Curso Java. GUI Volumen XIX: Resolución al ejercicio propuesto

La entrega de hoy es diferente en cuanto al código, antes se hacían capturas de pantalla, ahora tenéis el propio código para copiar/pegar en vuestro netbeans. ¿Os gusta?

Antes de comenzar a ver el código de Java es necesario ver qué clases será necesario implementar. Un diagrama no podrá ser útil a la hora de organizarnos. Este es el diagrama que yo he contemplado:

El modelo está formado por las tres clases básicas, que no tienen nada que ver con la GUI, sería la base del programa, en nuestro caso son el Curso, el Alumno y  la Asignatura. A continuación el código de cada una de ellas:

Alumno

[java]

/** Datos de un alumno: nombre y notas

*
*
*/
public class Alumno {
private String nombre;
private String apellido1;
private String apellido2;
private NotasAsignatura notas = new NotasAsignatura();

public static class NotasAsignatura {
public double primerParcial=0;
public double segundoParcial=0;
}

/**
* Construye un alumno
* @param nombre nombre del alumno
* @param apellido1 primer apellido del alumno
* @param apellido2 segundo apellido del alumno
*/
public Alumno(String nombre, String apellido1, String apellido2) {
super();
this.nombre = nombre;
this.apellido1 = apellido1;
this.apellido2 = apellido2;
}

/**
* Retorna el nombre completo del alumno en el formato apellidos, nombre
* @return nombre completo del alumno
*/
public String getNombreCompleto() {
return apellido1 + » » + apellido2 + «, » + nombre;
}

/**
* Retorna las notas del alumno
* @return notas del alumno
*/
public NotasAsignatura notas() {
return notas;
}
}

[/java]

Asignatura

[java]

import java.util.ArrayList;

/**
* Asignatura con la lista de alumnos matriculados
*
*
*/
public class Asignatura {

// alumnos matriculados (se podría haber utilizado un DefaultListModel
// en lugar de un ArrayList)
private ArrayList matriculas = new ArrayList();

// nombre de la asignatura
private String nombre;

/**
* Construye la asignatura con una lista vacía de alumnos matriculados
* @param nombre nombre de la asignatura
*/
public Asignatura(String nombre) {
this.nombre = nombre;
}

/**
* Retorna el nombre de la asignatura
* @return nombre de la asignatura
*/
public String getNombre() {
return nombre;
}

/**
* Matricula un alumno en la asignatura
* @param alumno a matricular
*/
public void matriculaAlumno(Alumno alumno) {
matriculas.add(alumno);
}

/**
* Retorna el alumno correspondiente a la matrícula indicada por num
* @param num índice del alumno en la lista de matrículas
* @return el alumno o null en el caso de que el índice sea incorrecto
*/
public Alumno getAlumnoNum(int num) {
if (num = matriculas.size()) {
return null;
}
return matriculas.get(num);
}

/**
* Elimina un alumno de la lista de matriculados
* @param num índice en la lista de matrículas del alumno a eliminar
*/
public void eliminaAlumno(int num) {
matriculas.remove(num);
}

}

[/java]

Curso

[java]

import java.util.HashMap;

/**
* Curso con la lista de asignaturas que le componen
*
*
*/
public class Curso {
HashMap asignaturas = new HashMap();

/**
* Añade una asignatura al curso
* @param nombre nombre de la asignatura
*/
public void añadeAsignatura(String nombre) {
asignaturas.put(nombre, new Asignatura(nombre));
}

/**
* Busca la asignatura con el nombre indicado
* @param nomAsig nombre de la asignatura
* @return la asignatura con ese nombre o null en el caso de que
* no exista ninguna
*/
public Asignatura buscaAsignatura(String nomAsig) {
return asignaturas.get(nomAsig);
}
}

[/java]

Nota: Se podía haber hecho sin la necesidad de la clase Curso, pero queda mejor agrupar las asignaturas como si de un curso se tratase. Después a la hora de utilizarlo con la GUI resultará más fácil. También lo podíais haberlo hecho utilizando listas sueltas en cada asignatura, pero sin necesidad de hacer esto.

Después de esto vamos con la siguiente parte, las clases que formará la GUI. En este caso, tenemos dos grupos, los que formarán la Vista, que son la VentGestiónAlumnos, y los dos diálogos, el DialogoIntroduceAlumno y el DiálogoDatosAlumno.

En lo referido a las clases manejadoras, también necesitaremos hacer uso de ella, se encontrarán en la clase principal que forma la ventana y necesitaremos:

• Los botones
• Combo de selección de asiganturas
• Selección de alumnos en la lista con el ratón

Nota: tanto Añadir como Borrar se pueden controlar en el mismo manejador, ya que no se pueden realizar al mismo tiempo, por lo que es posible utilizar un manejador conjunto para las dos.

[java]

import java.awt.*;
import java.awt.event.*;
import java.util.Arrays;
import javax.swing.*;

/**
* Ventana principal de la aplicación de gestíon de los alumnos
* matriculados en las distintas asignaturas de un curso
*
*
*/
public class VentGestionAlumnos extends JFrame{

private static final long serialVersionUID = 1L;

// Curso
private Curso curso = new Curso();

// nombres asignaturas
private final String[] nomAsignaturas = {«Físicas», «Matemáticas», «Inglés»};

// asignatura actualmente seleccionada
private Asignatura asignaturaActual;

// componentes
private JComboBox cAsignaturas = new JComboBox(nomAsignaturas);
private JList lstAlumnos = new JList(new DefaultListModel());
private JButton bAñadir = new JButton(«Añadir»);
private JButton bBorrar = new JButton(«Borrar»);

// diálogos
private DialogoIntroduceAlumno diagIntroAlumno =
new DialogoIntroduceAlumno(this);
private DialogoDatosAlumno diagDatosAlumno =
new DialogoDatosAlumno(this);

/**
* constructor
*/
public VentGestionAlumnos() {
super(«Gestión Alumnos»);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// crea las asignaturas del curso
for(String n: nomAsignaturas)
curso.añadeAsignatura(n);

// configura la asignatura actual
asignaturaActual = curso.buscaAsignatura(nomAsignaturas[0]);

// tamaño de la lista
lstAlumnos.setPreferredSize(new Dimension(200,300));

// panel izq (label y combo)
JPanel pGrid = new JPanel(new GridLayout(0,1));
pGrid.add(new JLabel(«Asignaturas»));
pGrid.add(cAsignaturas);
JPanel pIzq = new JPanel(new FlowLayout());
pIzq.add(pGrid);

// panel botones
JPanel pBotones = new JPanel(new FlowLayout());
pBotones.add(bAñadir);
pBotones.add(bBorrar);

// panel etiqueta «lista de alumnos»
JPanel pLabel = new JPanel(new FlowLayout());
pLabel.add(new JLabel(«Lista de alumnos»));

// panel der (label, lista y botones)
JPanel pDer = new JPanel(new BorderLayout());
pDer.add(pLabel,BorderLayout.NORTH);
pDer.add(lstAlumnos, BorderLayout.CENTER);
pDer.add(pBotones, BorderLayout.SOUTH);

// coloca paneles en el «conten pane» de la ventana
add(pIzq, BorderLayout.WEST);
add(pDer, BorderLayout.CENTER);

// Manejador botones
bAñadir.addActionListener(new ManejadorBotones());
bBorrar.addActionListener(new ManejadorBotones());

// Manejador combo
cAsignaturas.addItemListener(new ManejadorCombo());

// Manejador de doble clic en lista
lstAlumnos.addMouseListener(new ManejadorSeleccionAlumno());

// fin de la configuración de la ventana
pack();
setVisible(true);
}

/**
* manejador botones
*/
private class ManejadorBotones implements ActionListener {

@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()==bAñadir) {
Alumno a = diagIntroAlumno.Muestra();
if (a!=null) {
// el usuario NO ha cancelado el diálogo:
// añadimos el alumno a la asignatura

asignaturaActual.matriculaAlumno(a);
}
}
if (e.getSource()==bBorrar) {
int[] índices = lstAlumnos.getSelectedIndices();
System.out.println(Arrays.toString(índices));
for(int i=índices.length-1; i>=0; i–)
asignaturaActual.eliminaAlumno(índices[i]);
}

// actualizamos la lista
actualizaLista();
}

}

/**
* manejador combo
*/
private class ManejadorCombo implements ItemListener {

@Override
public void itemStateChanged(ItemEvent e) {
// obtiene la asignatura actual
asignaturaActual =
curso.buscaAsignatura((String)cAsignaturas.getSelectedItem());

// actualiza la lista
actualizaLista();
}

}

/**
* Responde a los eventos de doble clic en la lista
*/
private class ManejadorSeleccionAlumno extends MouseAdapter {
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
int indexAlumno = lstAlumnos.locationToIndex(e.getPoint());

// comprueba que se ha pulsado sobre un alumno
if (indexAlumno != -1) {
// muestra el diálogo que muestra y actualiza las notas
// del alumno
Asignatura asig = curso.buscaAsignatura(
(String) cAsignaturas.getSelectedItem());
diagDatosAlumno.muestra(asig,
asig.getAlumnoNum(indexAlumno));
}
}
}
}

/**
* actualiza la lista con los alumnos de la asignatura actual
*/
private void actualizaLista() {
DefaultListModel lstAlumnosModel = (DefaultListModel)lstAlumnos.getModel();
lstAlumnosModel.clear();

// añade a la lista todos los alumnos de la asignatura actual
int i=0;
while(true) {
Alumno a = asignaturaActual.getAlumnoNum(i);
if (a==null) break;
lstAlumnosModel.addElement(a.getNombreCompleto());
i++;
}
}

/**
* Método principal de la aplicación
*/
public static void main(String[] args) {
new VentGestionAlumnos();
}
}

[/java]

Tendríamos la ventana principal creada con sus funcionalidades, pero nos faltan dos detalles, los diálogos. Para este ejercicio, necesitábamos dos, uno para introducir un nuevo alumno, y otro para modificar los datos de un alumno haciendo doble click sobre su nombre en la lista.

DialogoIntroduceAlumno

[java]

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

/**
* Díalogo que permite introducir los datos de un alumno
*
*
*/
public class DialogoIntroduceAlumno extends JDialog {

// almacena el alumno introducido
Alumno alumno=null;

// componentes
private JTextField tfNombre = new JTextField();
private JTextField tfApellido1 = new JTextField();
private JTextField tfApellido2 = new JTextField();
private JButton bAceptar = new JButton(«Aceptar»);
private JButton bCancelar = new JButton(«Cancelar»);

/**
* Constructor
*/
public DialogoIntroduceAlumno(JFrame owner) {
super(owner, «Introduce datos del alumno», true);

// panel campos de texto
JPanel pCT = new JPanel(new GridLayout(0,2));
pCT.add(new JLabel(«Nombre»));
pCT.add(tfNombre);
pCT.add(new JLabel(«Primer Apellido»));
pCT.add(tfApellido1);
pCT.add(new JLabel(«Segundo Apellido»));
pCT.add(tfApellido2);

// panel botones
JPanel pBotones = new JPanel(new FlowLayout());
pBotones.add(bAceptar);
pBotones.add(bCancelar);

// añade botones al diálogo
add(pCT, BorderLayout.CENTER);
add(pBotones, BorderLayout.SOUTH);

// añade manejadores
ManejadorCompDialogo m = new ManejadorCompDialogo();
bAceptar.addActionListener(m);
bCancelar.addActionListener(m);
tfNombre.addActionListener(m);
tfApellido1.addActionListener(m);
tfApellido2.addActionListener(m);

// fin de la configuración del diálogo
pack();
setResizable(false);
}

/**
* muestra el diálogo
* @return alumno introducido o null si el usuario cancela el diálogo
*/
public Alumno Muestra() {
// pone el alumno a null
alumno=null;

// hace visible el diálogo
setVisible(true);

// cuando el díalogo se cierra el alumno introducido está en «alumno»
return alumno;
}

/**
* Manejador de los botones
*/
public class ManejadorCompDialogo implements ActionListener {

@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()!=bCancelar) {
// diálogo NO cancelado

// crea el alumno
alumno = new Alumno(tfNombre.getText(),
tfApellido1.getText(),
tfApellido2.getText());
}

// hace invisible el diálogo
setVisible(false);

}

}

}

[/java]

¿Cómo se produce la llamada entre la ventana principal y el diálogo?

En este caso el diálogo de insertar un nuevo alumno sólo aparecerá cuando se pulse el botón Añadir. Es necesario definir en los atributos las interfaces.

[java]

……

// diálogos

private DialogoIntroduceAlumno diagIntroAlumno =

new DialogoIntroduceAlumno(this);

private DialogoDatosAlumno diagDatosAlumno =

new DialogoDatosAlumno(this);

…..

[/java]
Y posteriormente hacer la llamada en el manejador correspondiente
[java]
private class ManejadorBotones implements ActionListener {
@Override

public void actionPerformed(ActionEvent e) {

if (e.getSource()==bAñadir) {

Alumno a = diagIntroAlumno.Muestra();

if (a!=null) {

// el usuario NO ha cancelado el diálogo:

// añadimos el alumno a la asignatura
asignaturaActual.matriculaAlumno(a);

}

}

if (e.getSource()==bBorrar) {

int[] índices = lstAlumnos.getSelectedIndices();

System.out.println(Arrays.toString(índices));

for(int i=índices.length-1; i>=0; i–)

asignaturaActual.eliminaAlumno(índices[i]);

}
// actualizamos la lista

actualizaLista();

}
}


[/java]
DialogoDatosAlumno
[java]
import java.awt.*;

import java.awt.event.*;
import javax.swing.*;
/**

* Diálogo que muestra los datos de un alumno y permite

* cambiar sus notas

*

*

*/

public class DialogoDatosAlumno extends JDialog {
// componentes

private JLabel lNombre = new JLabel(«Nombre alumno»);

private JTextField tfPrimerPar = new JTextField(«0»);

private JTextField tfSegundoPar = new JTextField(«0»);

private JButton bAceptar = new JButton(«Aceptar»);

private JButton bCancelar = new JButton(«Cancelar»);
// indica si se ha cancelado el diálogo

private boolean cancelado = false;
/**

* Constructor

*/

public DialogoDatosAlumno(JFrame owner) {

super(owner, » «, true);
// panel nombre

JPanel pNombre = new JPanel(new FlowLayout());

pNombre.add(lNombre);
// panel campos de texto

JPanel pCT = new JPanel(new GridLayout(2,0));

pCT.add(new JLabel(«Nota primer parcial»));

pCT.add(tfPrimerPar);

pCT.add(new JLabel(«Nota segundo parcial»));

pCT.add(tfSegundoPar);
// panel botones

JPanel pBotones = new JPanel(new FlowLayout());

pBotones.add(bAceptar);

pBotones.add(bCancelar);
// añade botones al diálogo

add(pNombre, BorderLayout.NORTH);

add(pCT, BorderLayout.CENTER);

add(pBotones, BorderLayout.SOUTH);
// añade manejadores

ManejadorCompDatos m = new ManejadorCompDatos();

bAceptar.addActionListener(m);

bCancelar.addActionListener(m);

tfPrimerPar.addActionListener(m);

tfSegundoPar.addActionListener(m);
// fin de la configuración del diálogo

pack();

setResizable(true);

}
/**

* muestra el diálogo

* @return alumno introducido o null si el usuario cancela el diálogo

*/

public void muestra(Asignatura asig, Alumno alu) {

// obtiene las notas del alumno para la asignatura

Alumno.NotasAsignatura notas = alu.notas();
// pone el título

setTitle(«Notas de » + alu.getNombreCompleto());
// pone los datos del alumno

lNombre.setText(asig.getNombre());

tfPrimerPar.setText(«» + notas.primerParcial);

tfSegundoPar.setText(«» + notas.segundoParcial);
// hace visible el diálogo

setVisible(true);
// si no se ha cancelado actualiza las notas

if (!cancelado) {

notas.primerParcial =

Double.parseDouble(tfPrimerPar.getText());

notas.segundoParcial =

Double.parseDouble(tfSegundoPar.getText());

}

}
/**

* Manejador de los botones

*/

public class ManejadorCompDatos implements ActionListener {
@Override

public void actionPerformed(ActionEvent e) {

// mira si se ha cancelado el diálogo

cancelado = e.getSource()==bCancelar;
// hace invisible el diálogo

setVisible(false);
}
}
}
[/java]
NOTA: Muy importante el método ActualizaLista(). Siempre que se haga un cambio es necesaria sin invocación
[java]
private void actualizaLista() {

DefaultListModel lstAlumnosModel = (DefaultListModel)lstAlumnos.getModel();

lstAlumnosModel.clear();
// añade a la lista todos los alumnos de la asignatura actual

int i=0;

while(true) {

Alumno a = asignaturaActual.getAlumnoNum(i);

if (a==null) break;

lstAlumnosModel.addElement(a.getNombreCompleto());

i++;

}

}

[/java]
Para establecer un símil, podría ser como el método repaint() de los ejemplos anteriores, necesario para mantener el panel de dibujos actualizado. Aprender C y C++ es también una buena idea.
Ya tendríamos listo nuestro, programa, partiendo de esta base, podéis probar a hacer modificaciones en el programa para probar las distintas funcionalidades que hemos explicado.
En la siguiente entrega, como ya os adelantábamos al comienzo, empezaremos con la entrada y salida de ficheros. Si tenéis alguna duda con respecto a la solución, no dudéis en exponerla.