Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Ayuda para crear este programa estoy perdido

Java - Ayuda para crear este programa estoy perdido

Volver
Nuevo Tema
<<>>
 
Vista:

Ayuda para crear este programa estoy perdido

Publicado por Jose (1 intervención) el 15/09/2018 21:48:00
Escriba un programa completo para un sistema de registro universitario. La tarea de su programa es pedirle al usuario el número de identificación del curso y el nombre del curso, el nombre de la facultad y su rango, y el tamaño máximo de clase permitido para generar una lista de clase de acuerdo con las siguientes reglas:


Su programa seleccionará el tamaño de clase real al azar y debe estar entre la mitad del máximo y el máximo inclusive. Entonces, si el tamaño máximo de clase ingresado por el usuario es 30, entonces su tamaño real de clase está entre 15-30 inclusive.
• Los nombres de los estudiantes se obtienen a partir de un enrollment.txt existente (se proporciona un archivo de texto) provisto para usted. Nota: Se incluye un programa de ejemplo para leer un cierto número de un archivo de texto. Cuando todo haya terminado, su programa imprimirá la lista de la clase de la siguiente manera:

Curso: MIS 525, programación orientada a objetos

Facultad: Profesor Kayed Akkawi

Seguido por una lista de los nombres y números de identificación de los estudiantes.

El conjunto mínimo de clases en su programa debe incluir lo siguiente, sin embargo, necesitará más clases para completar el proyecto.

• Una clase de Estudiante. Cada estudiante tendrá un nombre y una identificación única. La identificación se selecciona al azar y debe ser única

• Una clase de Facultad. Cada facultad tendrá un nombre, un rango (Profesor, Profesor Asociado Profesor Asistente). Debe haber un ítem manejado por menú para que el usuario seleccione la clasificación de la facultad. Como ejemplo
o Ingrese un nombre de la facultad:
o Seleccione el rango de la facultad
§ Ingrese 1 para el profesor
§ Ingresar 2 para Profesor Asociado
§ Ingrese 3 para Profesor Asistente

• Una clase de curso que tiene el número de identificación del curso, la sala asignada y el horario de inicio y finalización de la clase

• Una clase de registrador, que incluirá un método principal
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda para crear este programa estoy perdido

Publicado por Kabuto (1385 intervenciones) el 24/09/2018 02:45:35
Hola,

según creo entender, el enunciado indica que hay que pedir una serie de datos al usuario y con ellos generar los objetos Curso y Facultad.
Además hay que generar una lista de objetos Estudiante, cuyo numero dependerá del límite que indique el usuario.

En todo esto, solo hay dos cosas que se puedan considerar "dificultosas":
1) Los nombres de los estudiantes hemos de obtenerlos de un archivo txt.
El enunciado dice que ya se proporciona un programa de ayuda para hacer esto. Supongo que tu lo tendrás.
En cualquier caso, no lo necesitamos para resolverlo. Leer archivos de texto en realidad es muy sencillo como verás luego.

2) Se nos exige que los objetos de la clase Estudiante que vayamos a generar, tengan unos identificadores (ID) únicos.
Es decir, si generamos una lista de 30 estudiantes, cada uno ha de tener un ID único e irrepetible.
No se nos dice como quieren que controlemos este asunto, nos dejan via libre para hacerlo como queramos, ya que de hecho, hay varias formas de hacerlo.
Yo me he decidido hacerlo de una forma sencilla y práctica.
Tengamos en cuenta que los objetos Estudiante que vamos a generar, necesitamos agruparlos en alguna estructura de datos, ya sea un simple arreglo o mejor en estructuras menos primitivas como por ejemplo un ArrayList.
Hay muchas estructuras para elegir y hay algunas que nos pueden facilitar el tema este de controlar que los ID sean únicos.

Una de ellas es la estructura HashSet. Esta estructura no permite almacenar objetos "repetidos". Es decir, objetos que sean considerados iguales o equivalentes a algún objeto que ya está almacenado dentro de la estructura, serán rechazados.
Gracias a esto, podemos programar la clase Estudiante de modo que dos objetos de esta clase sean considerados equivalentes si sus ID son iguales (no importaría si el nombre del estudiante es distinto, solo se tendrá en cuenta el identificador ID)
Y entonces lo que haremos será crear objetos de la clase Estudiante de modo que si al guardarlos el HashSet lo rechaza, repetiremos el proceso de creacion una y otra vez hasta que por fin obtengamos un Estudiante con un ID no repetido y por lo tanto el HashSet sí lo admita.

Esto quizás se entienda mejor cuando veamos el código

Vamos por partes, veamos las clases que nos piden crear.

• Una clase de Estudiante. Cada estudiante tendrá un nombre y una identificación única. La identificación se selecciona al azar y debe ser única
ES fácil.
Solo dos atributos: nombre e identificador ID.
El nombre lo obtenemos como parametro desde el constructor.
El identificador lo generamos de forma interna con un numero aleatorio. Yo he decido hacerlo entre los rangos 0 y 999, aunque no se nos especifica nada.
Donde hay que prestar atención es a los dos últimos metodos: equals() y hashCode()
Estos metodos son heredados de la clase Object (en Java TODAS las clases, incluidas las creadas por nosotros, son siempre hijas de la clase Object, es algo así como la Diosa de todas las clases xD).
Podemos heredarlos y escribirlos según nuestras necesidades.

En equals(), le enseñamos a esta clase como debe compararse con otras clases para decidir si son equivalentes o no. Básicamente le decimos que si la otra clase con la que se compara es también una clase Estudiante y además el ID de esa claes es igual al suyo, entonces ha de devolver TRUE para indicar que SÍ son equivalentes.
Si el ID fuera distinto, o bien la otra clases no es una instancia (instanceof) de Estudiante, entonces ha de devolver FALSE para indicar que no son equivalentes.

En hashCode() le decimos a partir de que atributo de la clase queremos que genere un valor "hash" para que la estructuras como HashSet, HashMap o similares lo comprueben.

Estos dos metodos en conjunto, equals() y hashCode() serán los que nos ayudarán a que nuestro HashSet de Estudiantes, rechace los estudiantes con ID repetidos.

Clase Estudiante
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package registroUniversitario;
 
import java.util.Random;
 
public final class Estudiante {
 
	private Integer id;
	private String nombre;
 
	public Estudiante(String nombre) {
		id = generaID();
		this.nombre = nombre;
	}
 
	/**

	 * Genera un entero aleatorio entre 0 y 999.

	 * @return int generado aleatoriamente

	 */
	private int generaID() {
		return new Random().nextInt(1000);
	}
 
	public int getID() {
		return id;
	}
 
	@Override
	public String toString() {
		return "Nombre: " + nombre + "  ---  Id: " + id;
	}
 
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Estudiante) {
			return ((Estudiante) obj).getID() == this.id;
		}
		else
			return false;
	}
 
	@Override
	public int hashCode() {
		return id.hashCode();
	}
 
}


La siguiente clase que nos piden:
• Una clase de Facultad. Cada facultad tendrá un nombre, un rango (Profesor, Profesor Asociado Profesor Asistente). Debe haber un ítem manejado por menú para que el usuario seleccione la clasificación de la facultad. Como ejemplo
o Ingrese un nombre de la facultad:
o Seleccione el rango de la facultad
§ Ingrese 1 para el profesor
§ Ingresar 2 para Profesor Asociado
§ Ingrese 3 para Profesor Asistente


Es muy sencilla.
Tambien dos atributos: nombre y rango.
Los rangos hay que elegir entre tres prefijados.
Yo lo que he hecho es que el constructor pide un valor int que suponemos le llegará correctamente con los valores 1, 2 ó 3.
Luego según el valor de ese int, establezco el String adecuado para el atributo rango.

Clase Facultad
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package registroUniversitario;
 
public final class Facultad {
 
	private String nombre;
	private String rango;
 
	public Facultad(String nombre, int rango) {
		this.nombre = nombre;
		switch (rango) {
			case 1:
				this.rango = "Profesor";
				break;
			case 2:
				this.rango = "Profesor Asociado";
				break;
			case 3:
				this.rango = "Profesor Asistente";
				break;
		}
	}
 
	@Override
	public String toString() {
		return "Facultad: " + rango + " " + nombre;
	}
 
}

Siguiente clase:
Una clase de curso que tiene el número de identificación del curso, la sala asignada y el horario de inicio y finalización de la clase
Esta parte del enunciado es un poco extraña.
Se supone que los Cursos tienen un nombre si nos fijamos en el ejemplo que nos proponen:
Curso: MIS 525, programación orientada a objetos

Pero en este enunciado no se menciona ningún atributo para nombre. Aún así, yo lo he incluido en el código porque obviamente es necesario.
Luego, se mencionan dos atributos: "sala" y "horario" que si también nos fijamos en el ejemplo que nos proponen, son datos que ni se le piden al usuario, ni tampoco luego son mostrados en pantalla.
Así que son atributos totalmente innecesarios....aun así, por cumplir con el enunciado lo mejor posible, los he incluido en el código, les he dado unos valores preestablecidos y así ya podemos olvidarnos de ellos, porque no sirven para nada.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package registroUniversitario;
 
public final class Curso {
 
	private String idCurso;
	private String nombre;//El enunciado no menciona este atributo, pero obviamente es necesario

	/*

	 * Los siguientes atributos los establece el enunciado pero luego no dice que tengamos

	 * que pedir al usuario estos datos, ni tampoco mostrarlos en pantalla.

	 * Así que les dejamos unos valores preestablecidos y nos olvidamos de ellos.

	 */
	private String salaAsignada = "A-101";
	private String horario = "18:00 - 19:30";
 
	public Curso(String idCurso, String nombre) {
		this.idCurso = idCurso;
		this.nombre = nombre;
	}
 
	@Override
	public String toString() {
		return "Curso: " + idCurso + ", " + nombre;
	}
}

Fíjate que en todas estas clases, les he incluido un método llamado toString().
Este método también es heredado de la clase Object y se emplea para que podamos crear un String con el que luego mostrar los datos de esta clase por pantalla de forma rápida y sencilla.

Bueno, y ahora viene la clase principal con el main() para la ejecución del programa.
• Una clase de registrador, que incluirá un método principal

Bien, verás que esta clase tiene dos métodos:
Uno es el metodo main() que básicamente sigue este guión:
- Pedir datos al usuario.
- Construir un objeto Curso y un objeto Facultad con estos datos.
- Generar una lista de estudiantes.
- Mostrar toda la informacion en pantalla

De estos cuatro pasos, el único que es un poco laborioso es el de Generar una lista de estudiantes, y de esto es de lo que se va encargar el segundo metodo.
Este segundo metodo recibe como parametro el "limite" de Estudiantes que el usuario ha indicado por teclado.
Este limite, no será el límite real, ya que el límite real hemos de generarlo al azar tal y como nos dicen:
Su programa seleccionará el tamaño de clase real al azar y debe estar entre la mitad del máximo y el máximo inclusive. Entonces, si el tamaño máximo de clase ingresado por el usuario es 30, entonces su tamaño real de clase está entre 15-30 inclusive.
ASí que el metodo genera el limte real siguiendo esta regla.
Luego accede al archivo de texto y va obteniendo nombres hasta llegar al limite real.
Cada vez que obtiene un nombre, genera un objeto Estudiante nuevo a partir de este nombre e intenta añadirlo a un HashSet.
Si consigue añadirlo, es que el ID del estudiante no está repetido y pasa al siguiente nombre.
Si NO consigue añadirlo, es que el ID autogenerado ya está repetido, y entonces vuelve a generar un nuevo Estudiante con el mismo nombre. Y así una y otra vez hasta que el HashSet por fin lo admita.

Una vez tenemos la lista de estudiantes generada, retornamos el HashSet para que el main() pueda trabajar con él, que lo único que hará será mostrar los datos de los Estudiantes generados recorriendo el HashSet con un bucle for.

En esta última parte del main(), la de mostrar datos, es donde se ve lo cómodo y útil que resulta valernos del método toString()

Clase Registrador
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*

 * https://www.lawebdelprogramador.com/foros/Java/1668026-Ayuda-para-crear-este-programa-estoy-perdido.html

 */
package registroUniversitario;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.Scanner;
 
public final class Registrador {
 
	/**

	 * Accede al fichero de nombres enrollment.txt y genera una lista de 

	 * Estudiantes almacenados en un HashSet

	 * @param limite Máximo numero de estudiantes que se va a generar.

	 * @return HashSet con los objetos Estudiante generados.

	 */
	private static HashSet<Estudiante> generaListaEstudiantes(int limite) {
		/*

		 * Puesto que exigen que los estudiantes tengan ID unicos,

		 * usar un HashSet para almacenarlos será util.

		 * Esta estructura rechazará "estudiantes" cuyo ID coincida

		 * con estudiantes ya almacenados.

		 * Así que con un bucle repetiremos el intento de almacenar un

		 * nuevo estudiante hasta que este haya sido admitido, lo cual 

		 * implica que su ID (que lo genera al azar su propia clase) es único.

		 */
		HashSet<Estudiante> estudiantes = new HashSet<Estudiante>();
		/*

		 * Segun el enunciado el limite real ha de ser generado al azar entre

		 * el limite indicado por el usuario y su mitad

		 */
		int min = limite / 2;
		int limiteReal = (int) (Math.random() * (limite - min + 1)  + min);
		/*

		 * Ya tenemos el limite real, ahora hay que extraer nombres del

		 * archivo enrollment.txt.Tantos nombres como nos indica el limite real.

		 */
		try {
			BufferedReader br = new BufferedReader(new FileReader(new File("enrollment.txt")));
			for (int i = 0; i < limiteReal; i++) {
				String nombre = br.readLine();//Leemos siguiente linea en el fichero de texto

				/*

				 * Tenemos nombre, intentamos crear e insertar un nuevo Estudiante.

				 * Si su ID generado al azar está repetido, será rechazado por el HashSet,

				 * así que insistiremos hasta que por fin tengamos un ID único y el estudiante

				 * sea aceptado. 

				 */
				Estudiante nuevo;
				do {
					nuevo =  new Estudiante(nombre);
				}while(estudiantes.add(nuevo) == false);//Si FALSE, es que se ha rechazado, asi que lo intentamos otra vez

			}
			br.close();
			//Bucle for finalizado, ya tenemos nuestro listado de estudiantes listo para retornarlo

			return estudiantes;
 
		} catch (FileNotFoundException e) {
			System.err.println("No se encuentra fichero de nombres 'enrollment.txt'");
			return null;
		} catch (IOException e) {
			System.err.println("Error de lectura en fichero de nombres 'enrollment.txt'");
			return null;
		}
	}
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
		//Pedimos datos

		System.out.print("Numero ID del curso: ");
		String idCurso = teclado.nextLine();
		System.out.print("Nombre del curso: ");
		String nombreCurso = teclado.nextLine();
		System.out.print("Nombre Facultad: ");
		String nomFacultad = teclado.nextLine();
		System.out.println("\tRangos admitidos");
		System.out.println("(1) - Profesor");
		System.out.println("(2) - Profesor Asociado");
		System.out.println("(3) - Profesor Asistente");
		System.out.println("Elija[1|2|3]: ");
		int rango = teclado.nextInt();
		System.out.print("Tamaño máximo de la clase (limite es 42): ");
		int limite = teclado.nextInt();
		teclado.close();
		//Tenemos datos, creamos los objetos

		Curso curso = new Curso(idCurso, nombreCurso);
		Facultad facultad = new Facultad(nomFacultad, rango);
		//Intentamos generar listado de estudiantes

		HashSet<Estudiante> estudiantes = generaListaEstudiantes(limite);
 
		//Ya solo queda presentar la informacion en pantalla.

		System.out.println("\n\n\t\tDATOS DEL CURSO REGISTRADO\n\n");
		System.out.println(curso.toString() + "\n");
		System.out.println(facultad.toString()+ "\n");
		System.out.println("\tLISTADO DE ESTUDIANTES\n");
		for (Estudiante e: estudiantes)
			System.out.println("- " + e.toString());
 
	}
 
}

Y con esto creo que ya cumplimos con todo lo que nos piden.
Como dije antes, lo único dificil es controlar lo de los ID únicos y lo hemos resuelto fácilmente usando una estructura HashSet y codificando correctamente la clase Estudiante para indicar que el atributo id es quien decide si dos Estudiantes son iguales (o sea, están repetidos) o no.

Lo de acceder al fichero de texto, puedes ver como se hace en el método generarListaEstudiantes(). Es muy sencillo, pero si tienes duda sobre eso o cualquier otra cosa, pregunta lo que sea.

Mi archivo txt de nombre solo tiene 42 nombres, por eso en el main le digo al usuario que como "limite" solo puede llegar hasta 42

Por ultimo, agrego aquí un listado de nombres, con los que poder probar el programa, por si alguien no tiene ninguno a mano:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
Acevedo Manríquez María Mireya
Acevedo Mejía Enrique
Acevedo Ruiz Carolina
Acosta Canto Tomás José
Acosta Gámez Celina
Aguilar Dorantes Irma
Bacab Pech Guillermo
Báez Chávez Ángel Salvador
Balderas Flores Luis Alberto
Ballesteros González Francisco
Ballesteros Gutiérrez Rubio Raúl
Baltazar Cedeño Laura Elizabeth
Caballero Valle Prudenciano
Cadena Palacios Juana Patricia
Calvillo Carrasco Juan Gabriel
Camacho Cárdenas Sandra Verónica
Camacho Pérez Jorge Alberto
Cámara Contreras César Armando
De León Martínez Guadalupe Victoriana
De León Sánchez Juan de Dios
De León Sánchez Rodolfo
De Lira Ávalos Adán
Del Razo Ruiz Armando
Del Toro Arreola David
Escobar Beltrán Francisco Enrique
Escobedo Návar Óscar Horacio
Escudero Contreras Francisco Octavio
Espinosa Hernández Delia
Esquer Limón Cuauhtémoc
Esquinca Gutiérrez José Rodulfo
Figueroa Salmorán Norma Nelia
Figueroa Salmorán Rómulo Amadeo
Figueroa Valle Jorge Alberto
Flores Cruz Jaime
Flores Díaz Octavio Joel
Flores Martínez Alma Estela
Galaviz Ramírez Alba Lorenia
Galdámez Blanco Arturo
Galindo Andrade Carlos
Galindo Sánchez Teodoro Quintín
Gallardo Vara Ricardo
Gallegos León Mario Fernando
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar