Pildorita de POO y Java: Gestor Universitario II

En la anterior pildorita del Gestor Universitario creamos las clases modelo, es decir, las entidades del problema, con sus atributos y métodos asociados.

A través de esas clases, asimilamos los conceptos básicos de creación de una clase, definición de atributos y métodos, visibilidad y ámbito, herencia, y relaciones entre clases.

Lo siguiente será crear los métodos con las funcionalidades del problema: búsqueda, adicción y borrado, lo que comúnmente se conoce como CRUD (Create, Read, Update and Delete).

Si seguisteis las pildoritas de bases de datos o simplemente habéis trabajado ya con ellas, os daréis cuenta que se corresponden con las operaciones de manipulación de datos (DML) de SQL. Aunque nosotros no vamos a guardar en una base de datos, sí que vamos a persistir datos en memoria, por lo que las operaciones siguen siendo las mismas.

Para ello crearemos una capa manager donde se localizarán todas las clases encargadas de los métodos de gestión de las clases modelo. Además, crearemos una clase manager por cada una de las entidades persistentes. Esta decisión es subjetiva: Podríamos utilizar una clase manager para todo, pero esta estaría excesivamente acoplada. Por el contrario, si hicieramos un manager por cada método, tendríamos menos acoplamiento, pero también caería la cohesión. Como vimos en la primera de las pildoritas, el arte está en encontrar el punto óptimo entre alta cohesión y bajo acomplamiento y como todo arte no deja de ser algo subjetivo. El enfoque que se va a dar aquí, no obstante, suele ser una medida acertada: Crear un manager por cada clase modelo.

ProfesorManager

package manager.persona;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import model.persona.Profesor;

/**
 * Clase Manager para las funcionalidades asociadas a los profesores
 * @author mar.millan
 * @version 1.0
 * @since 2017
 */
public class ProfesorManager {
	private List<Profesor> lsProfesores = new ArrayList<Profesor>();

	public void setLsProfesores(List<Profesor> lsProfesores) {
		this.lsProfesores = lsProfesores;
	}

	public List<Profesor> getLsProfesores() {
		return lsProfesores;
	}
	
	public void insertar(Profesor profesor) {
		String codProfesor = UUID.randomUUID().toString();
		profesor.setCodProfesor(codProfesor);
		lsProfesores.add(profesor);
	}
	
	public void editar(Profesor profesor) {
		int idx = lsProfesores.indexOf(profesor);
		lsProfesores.set(idx, profesor);
	}
	
	public void borrar(Profesor profesor) {
		int idx = lsProfesores.indexOf(profesor);
		lsProfesores.remove(idx);
	}
	
	public List<Profesor> getProfesores() {
		return lsProfesores;
	}
	
	public Profesor getProfesor(String dni) {
		return getProfesor(new Profesor(null, null, null, dni, null, null));
	}
	
	public Profesor getProfesor(Profesor profesor) {
		for (Profesor prof : lsProfesores) {
			if (prof.equals(profesor)) {
				return prof;
			}
		}
		return null;
	}

	public int numProfesores() {
		return lsProfesores.size();
	}
}

AlumnoManager

package manager.persona;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import exception.UniversidadException;
import model.persona.Alumno;

/**
 * Clase Manager para las funcionalidades asociadas a los alumnos
 * @author mar.millan
 * @version 1.0
 * @since 2017
 */
public class AlumnoManager {
	private List<Alumno> lsAlumnos = new ArrayList<Alumno>();
	
	public void insertar(Alumno alumno) {
		String codAlumno = UUID.randomUUID().toString();
		alumno.setCodAlumno(codAlumno);		
		lsAlumnos.add(alumno);
	}
	
	public void editar(Alumno alumno) {
		int idx = lsAlumnos.indexOf(alumno);
		lsAlumnos.set(idx, alumno);
	}
	
	public void borrar(Alumno alumno) {
		int idx = lsAlumnos.indexOf(alumno);
		lsAlumnos.remove(idx);
	}

	public List<Alumno> getAlumnos() {
		return lsAlumnos;
	}
	
	public Alumno getAlumno(Alumno alumno) {
		for (Alumno alum : lsAlumnos) {
			if (alum.equals(alumno)) {
				return alum;
			}
		}
		return null;
	}
	
	public Alumno getAlumno(String dni) { 
		return getAlumno(new Alumno(null, null, null, dni, null, null));
	}
	
	public int numAlumnos() {
		return lsAlumnos.size();
	}
	
	public double getNotaMediaAlumnos() throws UniversidadException {
		double resultado = 0;
		for (Alumno alum : lsAlumnos) {
			resultado += alum.getNotaMedia();
		}
		return (resultado != 0 ? resultado / lsAlumnos.size(): 0);
	}
}

AsignaturaManager

package manager.asignatura;

import java.util.ArrayList;
import java.util.List;

import model.asignatura.Asignatura;

/**
 * Clase Manager para las funcionalidades asociadas a las asignaturas
 * @author mar.millan
 * @version 1.0
 * @since 2017
 */
public class AsignaturaManager {
	
	private List<Asignatura> asignaturas = new ArrayList<Asignatura>();
	
	public void insertar(Asignatura asignatura) {
		asignaturas.add(asignatura);
	}
	
	public void editar(Asignatura asignatura) {
		int idx = asignaturas.indexOf(asignatura);
		asignaturas.set(idx, asignatura);
	}
	
	public void borrar(Asignatura asignatura) {
		int idx = asignaturas.indexOf(asignatura);
		asignaturas.remove(idx);
	}
	
	public List<Asignatura> getAsignaturas() {
		return asignaturas;
	}

	public Asignatura getAsignatura(Asignatura asignatura) {
		for (Asignatura asig : asignaturas) {
			if (asig.equals(asignatura)) {
				return asig;
			}
		}
		return null;
	}
	
	public Asignatura getAsignatura(String nombre) {
		return getAsignatura(new Asignatura(nombre, 0, null));
	}
}

Como se puede ver, en todos los manager tenemos las funcionalidades requeridas para cada entidad. Las altas, consultas, bajas y modificaciones de cada entidad, así como en el caso de los alumnos, la obtención de nota media de todos los alumnos.

Cada manager tiene una lista de la entidad que gestiona y hace las operaciones sobre estas listas. Estas listas se encuentran en memoria y si paramos la ejecución de nuestro gestor, perderemos toda la información. Si quisiéramos persistir esta información y recuperarla más tarde tendríamos que utilizar o bien ficheros en disco, o una base de datos. Veremos en futuras pildoritas como podemos hacer este tipo de cosas con Java.

Por otra parte, seguimos sin tener forma alguna de que un usuario sea capaz de invocar a estos métodos. Para ello, necesitamos crear una interfaz de usuario, con menús, opciones de selección, formularios de creación, edición y búsqueda, etc. Esto también es conocido en el desarrollo software como capa Vista.

Nuestra interfaz en esta ocasión será muy simple y utilizaremos la consola y métodos de la libería Standard I/O. Más adelante se verán librerías para la creación de interfaces gráficas con ventanas, como JavaFX, así como algo de desarrollo web, que son las formas comunes de interfaces de usuario.

El desarrollo de esta última capa cerrará nuestro Gestor Universitario y se publicará el próximo lunes, así que estad pendientes 😉

Índice de Pildoritas

Share