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

Escrito por Adrián Crespo
Java
2

Seguimos adelante en RedesZone.net con nuestro curso de Java. En la entrega anterior, hablamos de los eventos de bajo nivel generados por el ratón y el teclado y como se pueden controlar con las clases manejadoras que posee Java.

En la entrega de hoy, daremos solución al ejercicio que os dejamos pendiente en la entrega XVII, por lo que si queréis, lo podéis echar un vistazo antes de mirar las soluciones.

También os queremos adelantar que la parte de GUIs ha llegado a su fin, y que a partir de ahora el curso de Java se va a centrar en la entrada y salida de ficheros.

Por lo tanto, vamos a explicar la solución del problema planteado.

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


/** 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;
 }
}

Asignatura


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<Alumno> matriculas = new ArrayList<Alumno>();

 // 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 < 0 || 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);
 }

}

Curso


import java.util.HashMap;

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

 /**
 * 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);
 }
}

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.


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();
 }
}

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


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);

}

}

}

¿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.


......
<pre>// diálogos
 private DialogoIntroduceAlumno diagIntroAlumno =
 new DialogoIntroduceAlumno(this);
 private DialogoDatosAlumno diagDatosAlumno =
 new DialogoDatosAlumno(this);
.....

Y posteriormente hacer la llamada en el manejador correspondiente


<pre>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();
 }

 }</pre>

DialogoDatosAlumno


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);

}

}

}

NOTA: Muy importante el método ActualizaLista(). Siempre que se haga un cambio es necesaria sin invocación

<pre>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++;
 }
 }

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.

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.


Noticias relacionadas

Comentarios


2 comentarios
  1. Fredy Pascual 16 Jul, 15 22:09

    Faltaron las notas del alumno pero aun asi es Excelente, gracias por compartir;

    Responder
    0
    1. Fredy Pascual 08 Ago, 15 1:19

      Corrijo, funciona perfectamente, hay que darle doble click a los nombre para insertar sus notas.

      Gracias 😀

      Responder
      0