Vamos por partes.
La clase
Estudiante, contiene un error grave:
public Estudiante() {
this.nombre = "";
this.apellido = "";
this.telefono = Integer.parseInt("");
}
Ahí le estás pidiendo que convierta una cadena vacía, en un valor numérico.
Eso es imposible.
Cuando ponemos un constructor "por defecto" sin parámetros, los atributos de tipo String si podemos inicializarlos con cadenas vacías, pero los datos numéricos (int, float, double,...) hay que inicializarlos con un número, por costumbre, el 0.
Así que la clase
Estudiante, podría quedar así, añadiendo además getters y setteres para cada atributo:
public class Estudiante {
private String nombre;
private String apellido;
private int telefono;
public Estudiante() {
this.nombre = "";
this.apellido = "";
this.telefono = 0;
}
public Estudiante(String nombre, String apellido, int telefono) {
this.nombre = nombre;
this.apellido = apellido;
this.telefono = telefono;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public int getTelefono() {
return telefono;
}
public void setTelefono(int telefono) {
this.telefono = telefono;
}
}Volviendo al programa principal, ahora que se ha vuelto más complejo, hay que hacer algunos cambios a lo que hicimos antes.
Se supone que de esa clase
Estudiante, vamos almacenar objetos en el arreglo. Así que este ya no será de tipo
String, si no de tipo
Estudiante public static void main(String[] args) {
Estudiante[] estudiantes = null;
int cantidad = 0;
boolean validado = false;
//Este bucle se repite hasta que logremos inicializar el arreglo con una cantidad válida
while (!validado) {
try {
//Pedimos cantidad de alumnos contendrá el arreglo
cantidad = Integer.parseInt(JOptionPane.showInputDialog(null, "Indique cantidad de Estudiantes:"));
//Validamos la cantidad, si está fuera de límites lanzamos excepción
if (cantidad < 5 || cantidad > 20)
throw new Exception("ERROR: Cantidad alumnos no puede ser inferior a 5 ni superior a 20");
else {
estudiantes = new Estudiante[cantidad];
validado = true; //Todo ha ido bien, esto pondrá fin al bucle while
}
}
catch(NumberFormatException nfe) {//Aquí capturamos excepción en caso de fallar el parseInt()
JOptionPane.showMessageDialog(null, "ERROR: Introduzca un valor numérico");
}
catch(Exception ex) {//Aquí capturamos cualquier excepción, principalmente la que lanzamos si cantidad está fuera de rango
JOptionPane.showMessageDialog(null, ex.getMessage());
}
}
//Bucle while terminado, ya tenemos arreglo
JOptionPane.showMessageDialog(null,
"Lista estudiantes inicializada. Cantidad de alumnos: " + estudiantes.length);
}
Bien, se nos dice que ahora hay que mostrar un menú para buscar estudiantes, modificarlos,....
Pero, en nuestro programa no hemos creado ningún estudiante. Hemos creado un arreglo donde se pueden insertar estudiantes, pero no hemos escrito nada que permita insertarlos y por tanto va a ser imposible buscar o modificar estudiantes..., porque no los hay.
Así que, antes de mostrar ese menú, habrá que crear un proceso donde se soliciten datos para crear esos estudiantes.
En este proceso, mediante un bucle, pediremos nombre, apellidos y un teléfono por cada estudiante.
De nuevo, con try catch, podemos controlar que los datos tengan cierta validez, al menos que los campos de nombre y apellido no los dejen en blanco sin rellenar y que el teléfono esté compuesto de cifras numéricas.
Cuando tengamos esos datos validados, construimos un nuevo estudiante y lo insertaremos en el arreglo
Así que justo a continuación de lo que teníamos escrito, añadimos esto:
//Ahora, hay que registrar estudiantes
for (int i = 0; i < estudiantes.length; i++) {
Estudiante nuevo = null; //Referencia temporal para construir el nuevo estudiante antes de insertar en arreglo
while (nuevo == null) { //Mientras no se haya logrado construir un objeto Estudiante...
//Pedimos datos, controlando posibles excepciones
try {
String nombre = JOptionPane.showInputDialog(null, "Nombre:", "Estudiante para posicion #" + i, JOptionPane.QUESTION_MESSAGE);
if (nombre.isBlank())
throw new Exception("El campo Nombre no puede estar vacío");
String apellido = JOptionPane.showInputDialog(null, "Apellido:", "Estudiante para posicion #" + i, JOptionPane.QUESTION_MESSAGE);
if (apellido.isBlank())
throw new Exception("El campo Apellido no puede estar vacío");
int telefono = Integer.parseInt(JOptionPane.showInputDialog(null, "Teléfono:", "Estudiante para posicion #" + i, JOptionPane.QUESTION_MESSAGE));
//Si llegados a esta línea no se han lanzado excepciones, podemos construir un Estudiante
nuevo = new Estudiante(nombre, apellido, telefono);
//insertamos en arreglo, en la posición que indica el índice del bucle FOR
estudiantes[i] = nuevo;
}
catch(NumberFormatException nfe) {
JOptionPane.showMessageDialog(null, "El teléfono ha de estar compuesto solo de cifras numéricas");
}
catch(Exception ex) {
JOptionPane.showMessageDialog(null, ex.getMessage());
}
}
}Ya tenemos el código necesario para crear un arreglo de estudiantes y rellenarlo con datos.
Ahora sí, es cuando podemos mostrar el menú de opciones para buscar o modificar estudiantes.
Este menú se ha de repetir hasta que el usuario escoja la opción de salir (opción 3), así que podemos usar un bucle while cuya condición sea que se repita mientras que la variable "option" sea distinta de 3.
Y para evaluar la opción introducida, en lugar de usar varios if else, recomienda usar un switch, para que quede mejor estructurado:
//Ya tenemos estudiantes, podemos mostrar menú de opciones
String[] options = {"Buscar Estudiante", "Buscar por puesto", "Modificar nombre estudiante", "Salir"};
int option = 0;
while (option != 3) { //3 es la opcion de "Salir"
option = JOptionPane.showOptionDialog(null, "Seleccione una opcion",
"Seleccione una opcion",
JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
//Usamos un switch para evaluar la opcion escogida
switch(option) {
//Buscar por nombre
case 0:
String nombre = JOptionPane.showInputDialog(null, " Ingrese el Nombre del estudiante");
//Falta código para buscar por nombre...
break;
//Buscar por puesto/posición en el arreglo
case 1:
int puesto = Integer.parseInt(JOptionPane.showInputDialog(null, "Ingrese el Numero de Puesto"));
//Falta código para buscar por puesto...
break;
//Buscar por puesto y cambiar el nombre
case 2:
//Falta código para buscar por puesto y cambiar el nombre...
break;
//Salir del programa
case 3:
JOptionPane.showMessageDialog(null, "Cerrando su sesion");
}
}Como ves, el código no está terminado.
Para cada caso del switch, hay que escribir el código necesario para conseguir lo que pide el menú.
Inténtalo y ya nos cuentas como te va.
Por cierto, de ser posible, aquí lo que interesaría sería "modular" el programa escribiendo distintos métodos para cada opción del menú.
Un método para buscar por nombre, otro para buscar por puesto y otro para cambiar el nombre de un estudiante seleccionado.
Así no tendremos un único código enorme, si no varios códigos más pequeños, con lo cuál es más fácil de leer y mantener.
No se si te han enseñado ya a programar con una estructura modular, si no es así, pues nada..., tocará escribirlo todo junto.
Un saludo
Tema: Java POO ejercicio resuelto con JOptionPane Ciclo (bucle) y arrays CRUD buscar n (Leído 3733 veces)
RSS -
WAP2