Foros aprenderaprogramar.com
Aprender a programar => Aprender a programar desde cero => Mensaje iniciado por: agata6391 en 02 de Mayo 2022, 17:51
-
Hola comunidad yo de nuevo. El asunto es que estoy en un dilema. Tengo una idea de cómo se supone que debo hacerlo. Ya gracias a un compañero del foro (muchas gracias de nuevo)< Kabuto> logré avanzar un poco y después del avance el profesor agregó mas requisitos a la tarea.
El asunto es el siguiente
Al finalizar el ingreso de los datos se debe mostrar un mensaje con la clase JOptionPane para realizar una de las siguientes acciones: (este esta listo)
a. Buscar nombre: Devuelve la cantidad de veces que un nombre se repite
b. Buscar por puesto: Devuelve el nombre del estudiante que esté en un
puesto específico
c. Modificar estudiante: Cambia el nombre de un estudiante indicando el
puesto y el nombre nuevo
d. Salir: Termina el sistema de ejecutarse (este ya esta listo)
Todas las anteriores tareas deben validar la información para evitar que la aplicación
devuelva un error o se caiga.
Ya creé la clase Estudiante que sería esta:
public class Estudiante {
private String nombre;
private String apellido;
private int telefono;
public Estudiante() {
this.nombre = "";
this.apellido = "";
this.telefono = Integer.parseInt("");
}
public Estudiante(String nombr, String apellido, int telefono) {
this.nombre = nombre;
this.apellido = apellido;
this.telefono = telefono;
}
}
Tengo una idea de cómo hacerlo pero el detalle como mencioné anteriormente no sé implementarlo.
Sé que dada las opciones deben tener un ciclo para devolver al panel de opciones exceptuando la ultima ya que esa finaliza el programa, también he visto en muchos videos que importan clases como el scanner, pero no podemos usar ese tipo ya que no lo hemos visto, así que básicamente no me puedo apoyar en eso.
Así que espero una ayudita o algunas ideas de como implementarlo, no espero que den el asunto ya solucionado pero si por lo menos algunas ideas de cómo montarlo
Esto es lo que llevo del código de paso por si a alguien le sirve.
Saludos y gracias
public static void main(String[] args) {
String[] arreglo = 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 contendrá el arreglo
cantidad = Integer.parseInt(JOptionPane.showInputDialog(null, "Indique cantidad del Arreglo:"));
//Validamos la cantidad, si está fuera de límites lanzamos excepción
if (cantidad < 5 || cantidad > 20)
throw new Exception("ERROR: Cantidad del arreglo no puede ser inferior a 5 ni superior a 20");
else {
arreglo = new String[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());
}
}
JOptionPane.showMessageDialog(null,
"Lista estudiantes inicializada. Cantidad del Arreglo es: " + arreglo.length);
String[] options = {"Buscar Estudiante", "Buscar por puesto", "Modificar estudiante", "Salir"};
int option = JOptionPane.showOptionDialog(null, "Seleccione una opcion",
"Seleccione una opcion",
JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
System.out.println(option);
if (option == 0) {
JOptionPane.showInputDialog(null, " Ingrese el Nombre del estudiante");
//int dato =Integer.parseInt ();
Estudiante nombre = new Estudiante();
} else if (option == 1) {
JOptionPane.showInputDialog(null, "Ingrese el Numero de Puesto");
} else if (option == 2) {
JOptionPane.showInputDialog(null, "Ingrese el Dato a modificar");
} else if (option == 3) {
JOptionPane.showMessageDialog(null, "Cerrando su sesion");
}
}
}
-
Actualizacion intente agregar esto al codigo del arreglo en la primera parte pero no me esta funcionando las excepciones ya que vi que ocupo que me solicite los datos, ya que sino estaria con un arreglo vacio sin datos
PD: adivinen que no me sirvió..
JOptionPane.showMessageDialog(null, "Ingrese los datos del arreglo: ");
for (int i = 0; i > arreglo.length; i++) {
JOptionPane.showInputDialog(null, (i+1)+"digite los datos");
}
-
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
-
hola muchas gracias he logrado avanzar mas, pero igual estoy un poco pegado, conforme valla logrando el código, pondre mas consultas muy amable de nuevo :D :D ;D ;D