Java - Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

 
Vista:

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por alejandro (5 intervenciones) el 28/11/2018 10:25:59
Hola, tengo este programa que resolver en java, que me pide solución a sentencias:
(abajo del problema está el programa )

1. Registrar los datos de los alumnos; los datos que se requieren son los siguientes: Clave, Nombre, Apellidos, Edad, Sexo (‘F’ o ‘M’), Licenciatura a la cuál desean inscribirse, Calificación Promedio de la preparatoria, Tutor, Hora de tutoría.
La Facultad tiene como política que si el alumno pretende inscribirse a la Licenciatura de Gestión de la Información en Redes Sociales, solo se le permitirá registrarse si su promedio de preparatoria es mayor o igual a 8.0. Para ello, será necesario enviar un mensaje en pantalla indicando que no es posible su registro.

2. Asignar un tutor (profesor tutor) al alumno. Para lograr esta tarea, primero deberá crearse un profesor tutor con los siguientes datos: Clave, Nombre, Apellidos, Área de Especialidad, Categoría del Profesor (‘A’, ‘B’,’C’) por default la categoría de un profesor es ‘A’ y Número de clases impartidas. Una vez creado el tutor deberá ser asignado a un alumno.
Esta funcionalidad de asignar un tutor, es parte del registro de un alumno.

Una vez terminado el registro de un alumno individual enviar los datos registrados por cada alumno a pantalla, indicando el número de caracteres del Nombre Completo del Alumno.

Los datos registrados de cada alumno, deberán guardarse en un Archivo con extensión .txt, el nombre del archivo deberá ser: alumnos.txt y deberá ser almacenado en el sistema de ficheros de la computadora donde se esté ejecutando el programa.

Mostrar el reporte de todos alumnos inscritos (que incluya todos los datos que se les solicitó en su registro). Para ello, deberá hacer lectura del texto almacenado en alumnos.txt.

Calcular el promedio de un número de calificaciones por alumno. Lo que se pretende con esta tarea es, que el usuario ingrese una clave de alumno, posteriormente ingrese el número de calificaciones de las cuáles se obtendrá el promedio y finalmente ingrese cada una de las calificaciones. El programa le debe mostrar en pantalla el promedio de las calificaciones con el siguiente mensaje: “El promedio del alumno con clave __ es __”.

Administrar las asignaturas: Esta funcionalidad permitirá al usuario registrar asignaturas con los siguientes datos: Clave, Nombre de asignatura, semestre de impartición y Profesor. A su vez, del Profesor se requerirán los siguientes datos: Clave, Nombre, Apellidos, Edad, Estado Civil, Nivel de Escolaridad y Categoría. El valor de la Categoría dependerá del Nivel de Escolaridad del Profesor: Nivel de Escolaridad Categoría Licenciatura ‘A’ Maestría ‘B’ Doctorado ‘C’

Si tiene cualquier otro nivel de Escolaridad su categoría será ‘X’.

Se podrán registrar varias asignaturas de una sola vez, para ello, deberá indicarle al usuario que tecle -1 para finalizar la captura de las asignaturas.
Una vez terminado el registro de cada asignatura individual enviar los datos registrados por cada asignatura a pantalla.


[Nota: Tanto Alumno como el Tutor y Profesor deberá derivar a su vez de una clase denominada Persona, la cual tendrá los datos generales como son: Clave, Nombre, Apellidos, Edad, Sexo]

A través de la nota, se deduce que tienes que hacerlo con herencia, por medio de paquetes lo he desarrollado
Estas son las líneas de código que he escrito en NetBeans:


(CLASE PADRE)
package secundariasvariaciones;
import java.util.Scanner;

public class Persona {
protected String clave, nombre, apellidos, sexo;
protected int edad;
Scanner entrada = new Scanner(System.in);

//Este método pide datos de registro al usuario
public void ingresardatos(){
System.out.print("Ingresa clave: ");
clave = entrada.next();

System.out.print("Ingresa nombre: ");
nombre = entrada.next();

System.out.print("Ingresa apellidos: ");
apellidos = entrada.next();

System.out.print("Ingresa edad: ");
edad = entrada.nextInt();

System.out.print("Ingresa sexo (M o F): ");
sexo = entrada.next();
}
}

(SUBCLASE)
package secundariasvariaciones;

public class Alumno extends Persona{
protected String licenciatura;
protected double promedio;

public void ingresardatos1 (){
System.out.print("Ingresa licenciatura de inscripción: ");
licenciatura = entrada.next();

System.out.print("Escribe promedio de preparatoria: ");
promedio = entrada.nextDouble();
}
}

(SUBCLASE)
package secundariasvariaciones;

public class Tutor extends Persona{
protected String areaDeEspecialidad;
protected String categoria;
protected int clasesImpartidas;

public void ingresardatos2 (){
System.out.print("Escribe área de especialidad del tutor: ");
areaDeEspecialidad = entrada.next();

System.out.print("Ingresa categoria del tutor: ");
categoria = entrada.next();

System.out.print("Clases impartidas por el tutor: ");
clasesImpartidas = entrada.nextInt();
}
}

(EN ESTA LÍNEA ESTÁ EL MÉTODO MAIN, Y DE AQUÍ LLAMO; POR MEDIO DEL PAQUETE, A LAS CARACTERÍSTICAS DE LA CLASE PERSONA )

package principal;
import java.util.Scanner;
import secundariasvariaciones.Alumno;
import secundariasvariaciones.Tutor;

public class Registro {
public static void main (String[] args){

System.out.println("Ingresa tus datos aspirante a alumno ");
Alumno pasoalumno = new Alumno();
pasoalumno.ingresardatos();
pasoalumno.ingresardatos1();

System.out.println("Ingresa datos del tutor ");
Tutor pasotutor = new Tutor();
pasotutor.ingresardatos();
pasotutor.ingresardatos2();

ESTO ES PARTE DE LA CLASE PRINCIPAL CON EL MÉTODO MAIN, PARA EL APARTADO PROMEDIO

class Calcularpromedio {
String clave1;
double calificaciones=1;
double calificacionesac=0;
double valors;
double promedio;
int suma, ncalificaciones;
Scanner entrada1 = new Scanner(System.in);

public void ingresarclave(){
System.out.print("Ingrese clave del alumno: ");
clave1 = entrada1.next();

System.out.print("Ingrese número de calificaciones que se resgistrarán: ");
ncalificaciones= entrada1.nextInt();

while(calificaciones <= ncalificaciones ){
System.out.print("Ingrese la nota número "+ calificaciones);
valors=entrada1.nextDouble();
calificacionesac +=valors;
calificaciones++;
}
promedio= calificacionesac / ncalificaciones;
System.out.print("El promedio del alumno con clave: "+clave1+promedio);
}
}


Podrían orientarme, por favor, a hacer: por favor

Al ejecutar el programa, este se detiene cuando finalizo de registrar los datos del tutor. ¿por qué no ejecuta lo del promedio?
-- cómo relaciono al tutor con el alumno
-- cómo creo la categoría del profesor
--cómo se hace una variable para la hora (hora de tutoría)

-- cómo registro la licenciatura; Licenciatura de Gestión de la Información en Redes Sociales, y que esta al poner el promedio que solicita, ejecute el mensaje. porque solo he hecho que al registrar cualquier dato y con el promedio menor a 8.0, aparezca el mensaje, pero al parecer tiene que hacerse con esas palabras específicas. lo intenté hacer por IF o WHILE (no tengo el código), pues siempre me aparecía un error: "String, int no puede ser convertido a boolean".

--cómo muestro en pantalla todos los datos del registro: como estoy usando scanner, pensé hacer una variable y luego un método, así:

String registro
public void Mostrarregistro (){
System.out.println(registro);
}
Pero no se dónde ponerlo, o siquiera si es correcto hacer uso de scanner para resolver el problema

espero puedan orientarme, gracias. :)
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

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por Kabuto (1382 intervenciones) el 29/11/2018 00:49:33
Hola.
Las clases Persona, Alumno, Profesor y Tutor no deberían pedir datos. Deberían representar simplemente los atributos de estas entidades.
Se puede hacer que pidan datos, pero no es lo acostumbrado. Lo ideal es que estas clases sean una representacion de la identidad y el proceso de pedir datos se desarrolle en el main() que vaya a usar estas clases.

Mira, la clase Persona, puede quedar tal que así, con todos sus getters y setters (aunque luego probablemente no los usemos):
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
public class Persona {
 
	private int clave;
	private String nombre;
	private String apellidos;
	private int edad;
	private char sexo;
 
	public Persona(int clave, String nombre, String apellidos, int edad, char sexo) {
		this.clave = clave;
		this.nombre = nombre;
		this.apellidos = apellidos;
		this.edad = edad;
		this.sexo = sexo;
	}
 
	public int getClave() {
		return clave;
	}
 
	public void setClave(int clave) {
		this.clave = clave;
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public String getApellidos() {
		return apellidos;
	}
 
	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}
 
	public int getEdad() {
		return edad;
	}
 
	public void setEdad(int edad) {
		this.edad = edad;
	}
 
	public char getSexo() {
		return sexo;
	}
 
	public void setSexo(char sexo) {
		this.sexo = sexo;
	}
 
}

Fíjate que está pensada para recibir de golpe todos los datos necesarios mediante su constructor, datos que ya se encargará de conseguirlos otro proceso distinto.

Ahora vamos a ver la clase Profesor.
Esta clase hereda de Persona, por tanto para contruir un Profesor hay que proporcionarle todos los datos necesarios para construir una Persona(clave, nombre, apellidos,..) y también los datos para los atributos especificos de Profesor.

Fíjate que los datos correspondientes a los atributos Persona, se los pasamos a esta clase mediante la instruccion super()

Y fíjate que el único dato que no se pide, es el de la categoria, ya que este se decide automaticamente en función del nivel de escolaridad del Profesor
Esto lo hace el propio constructor, mediante un switch.

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
public final class Profesor extends Persona{
 
	private char estadoCivil;
	private String nivelEscolaridad;
	private char categoria;
 
	public Profesor(int clave, String nombre, String apellidos, int edad, char sexo,
			char estadoCivil, String nivelEscolaridad) {
		super(clave, nombre, apellidos, edad, sexo);
		this.estadoCivil = estadoCivil;
		this.nivelEscolaridad = nivelEscolaridad;
		switch(nivelEscolaridad) {
		case "licenciatura":
			categoria = 'A';
			break;
		case "maestria":
			categoria = 'B';
			break;
		case "doctorado":
			categoria = 'C';
			break;
		default:
			categoria = 'X';
		}
	}
 
	public char getEstadoCivil() {
		return estadoCivil;
	}
 
	public void setEstadoCivil(char estadoCivil) {
		this.estadoCivil = estadoCivil;
	}
 
	public String getNivelEscolaridad() {
		return nivelEscolaridad;
	}
 
	public void setNivelEscolaridad(String nivelEscolaridad) {
		this.nivelEscolaridad = nivelEscolaridad;
	}
 
	public char getCategoria() {
		return categoria;
	}
 
	public void setCategoria(char categoria) {
		this.categoria = categoria;
	}
 
}

Vale, ahora vamos a ver la clase Tutor
No tiene nada de especial la verdad, como antes, se piden los datos necesarios para construir una Persona, los cuáles transferimos mediante la instrucción super() y también se requieren los datos propios de Tutor
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
public final class Tutor extends Persona{
 
	private String areaEspecialidad;
	private char categoria;
	private int numClasesImpartidas;
 
	public Tutor(int clave, String nombre, String apellidos, int edad, char sexo,
			String especialidad, char categoria, int clasesImpartidas) {
		super(clave, nombre, apellidos, edad, sexo);
		areaEspecialidad = especialidad;
		this.categoria = categoria;
	}
 
	public String getAreaEspecialidad() {
		return areaEspecialidad;
	}
 
	public void setAreaEspecialidad(String areaEspecialidad) {
		this.areaEspecialidad = areaEspecialidad;
	}
 
	public char getCategoria() {
		return categoria;
	}
 
	public void setCategoria(char categoria) {
		this.categoria = categoria;
	}
 
	public int getNumClasesImpartidas() {
		return numClasesImpartidas;
	}
 
	public void setNumClasesImpartidas(int numClasesImpartidas) {
		this.numClasesImpartidas = numClasesImpartidas;
	}
 
}

Ahora viene la clase Alumno.
Aquí podemos dar respuesta a varias preguntas que te hacías.
¿Cómo controlar lo de la licenciatura esa tan concreta que pide un promedio de 8.0 o más?
Sí, podría hacerse desde la clase. Pero insisto en que las clases que representan entidades han de ser lo más genéricas posibles.
Me refiero a que esta clase Alumno, en un hipotético programa real, ha de servir para cualquier otro programa y/o facultad.
A lo mejor otras facultades no tienen esta restricción para inscribirse en esa licenciatura, entonces si hacemos que nuestra clase Alumno incorpore de serie esta restricción, ya no serviría para ninguna otra facultad....
Por eso, en principio, la clase no debería llevar implícita esta restricción, la cuál es mejor controlarla desde el programa main() donde se pedirán los datos para registrar alumnos.

¿Cómo relacionamos un Alumno con un Tutor?
Fácil, la clase Alumno va a tener un atributo que será un objeto de la clase Tutor.
Esto significa que para poder crear un objeto Alumno, al mismo tiempo tendrémos que crear también un objeto Tutor.
Luego ya verás en el main() como he realizado esto

¿Cómo hacer una varaible para la hora de tutoría?
En Java existen clases para datos de tiempo como Date (en desuso) o Calendar. Pero no te compliques la vida, usa simplemente un String para recoger el dato y ya está.
Total, luego no hay que hacer ninguna operacion matemática con este dato ni nada, tan solo que quede registrado.

Bien, ahora pondré el código de la clase Alumno.
A parte de lo ya mencionado, fíjate que al final de todo he creado un método llamado toString(). Este método en realidad es heredado de la clase Object (en Java, TODAS las clases heredan automáticamente de Object) y lo que hacemos es sobreescribirlo (override) para que nos devuelva un String que muestre todos los datos del alumno en cuestión.
Este método nos servirá para mostrar en pantalla dichos datos, tal y como pide el enunciado.
TAmbién será este String el que guardaremos en el archivo "alumnos.txt", que nos pide crear el enunciado.

Este String que será creado, le he aplicado algo de formato mediante String.format() para que salga por pantalla más o menos elegante a pesar de las limitaciones de mostrar datos en consola.
No importa si no entiendes muy bien que son esos % con numeros y letras, no pierdas tiempo ahora con eso, ya tendrás tiempo de aprenderlo.
Tu luego si quieres, puedes contruir otro String como te plazca. Yo he incluido todos los atributos del Alumno, incluyendo la clave del Tutor asignado (no vamos a poner el Tutor completo)

Aquí el código:
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
public final class Alumno extends Persona{
 
	private String licenciaturaInscribe;
	private double calificacionPromedio;
	private Tutor tutor;
	private String horaTutoria;
 
	public Alumno(int clave, String nombre, String apellidos, int edad, char sexo,
			String licenciatura, double calificacion, Tutor tutor, String horaTutoria) {
		super(clave, nombre, apellidos, edad, sexo);
		licenciaturaInscribe = licenciatura;
		calificacionPromedio = calificacion;
		this.tutor = tutor;
		this.horaTutoria = horaTutoria;
	}
 
	public String getLicenciaturaInscribe() {
		return licenciaturaInscribe;
	}
 
	public void setLicenciaturaInscribe(String licenciaturaInscribe) {
		this.licenciaturaInscribe = licenciaturaInscribe;
	}
 
	public double getCalificacionPromedio() {
		return calificacionPromedio;
	}
 
	public void setCalificacionPromedio(double calificacionPromedio) {
		this.calificacionPromedio = calificacionPromedio;
	}
 
	public String getHoraTutoria() {
		return horaTutoria;
	}
 
	public void setHoraTutoria(String horaTutoria) {
		this.horaTutoria = horaTutoria;
	}
 
	public int getLongitudNombreCompleto() {
		return super.getNombre().length() + super.getApellidos().length();
	}
 
	@Override
	public String toString() {
		return String.format("%-12s | %-20s | %-30s | %-4d | %-4c | %-30s | %-15.2f | %-11s | %-12s",
				super.getClave(), super.getNombre(), super.getApellidos(), super.getEdad(),
				super.getSexo(), licenciaturaInscribe, calificacionPromedio, tutor.getClave(),
				horaTutoria);
	}
}


Vale, aún faltaría la clase Asignatura. Esta la dejo para que lo hagas tú.
No tiene mayor misterio, tan solo tener en cuenta que uno de sus atributos, ha de ser un objeto de la clase Profesor

Lo de Calcular el Promedio, no es necesario crear una clase específica para ello. Basta con crear un método específico para realizar dicha función en el main().
Ahora sigo en otro post, comentando como podría llevarse a cabo el main()
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por alejandro (5 intervenciones) el 29/11/2018 13:55:23
hola, gracias por orientarme, se puede ver que iba por un mal camino.
podrías ayudarme:
por qué aquí; en los métodos (¿son métodos?)pones las variables entre paréntesis. bueno no solo ahí.

public Alumno(int clave, String nombre, String apellidos, int edad, char sexo,
String licenciatura, double calificacion, Tutor tutor, String horaTutoria)



también aquí:

public Tutor(int clave, String nombre, String apellidos, int edad, char sexo,
String especialidad, char categoria, int clasesImpartidas)



y aquí: public Persona(int clave, String nombre, String apellidos, int edad, char sexo)

nuevamente, gracias, en verdad, por ayudarme
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
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

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por Kabuto (1382 intervenciones) el 29/11/2018 23:57:30
Hola.
Respondo a esto:
1
2
3
4
5
6
7
8
9
10
11
12
13
por qué aquí; en los métodos (¿son métodos?)pones las variables entre paréntesis. bueno no solo ahí.
 
public Alumno(int clave, String nombre, String apellidos, int edad, char sexo,
String licenciatura, double calificacion, Tutor tutor, String horaTutoria)
 
 
también aquí:
 
public Tutor(int clave, String nombre, String apellidos, int edad, char sexo,
String especialidad, char categoria, int clasesImpartidas)
 
 
y aquí: public Persona(int clave, String nombre, String apellidos, int edad, char sexo)

Esto, no son métodos. Son constructores. Las variables que pongo entre paréntesis es para indicar que para construir un objeto usando ese contructor, OBLIGATORIAMENTE habrá que proporcionar todas esas variables y respetando el orden.

EL constructor es quien, valga la redundancia, "construye" los objetos que instanciamos de las clases.

Para crear/construir un objeto Persona, tenemos que hacer:
1
Persona persona1 = new Persona();

Ese new Persona(), es una llamada al constructor de la clase Persona, que en este ejemplo, es un constructor simple que no exige recibir ningún parámetro.

Para construir un objeto, podemos hacerlo de distintas formas.
Podemos usar un constructor simple como el del ejemplo, y luego mediante los setters, pasarle valores a sus atributos:

1
2
3
4
Persona persona1 = new Persona();
persona1.setClave(001);
persona1.setNombre("Perico");
persona1.setApellidos("De los Palotes");

O bien, podemos implementar un constructor en la clase Persona que reciba todos esos datos de golpe y se encargue el de pasarlo a los atributos. De este modo, podemos crear una Persona completa en una sola línea:
1
Persona persona1 = new Persona(001, "Perico", "De los Palotes");

Este es el tipo de constructor que le puse a las clases, uno que obliga a recibir todos los parametros y luego los pasa a los atributos en el momento de construir el objeto.

Una clase puede tener muchos constructores, todos los que queramos implementar. Por ejemplo a Persona se le podría haber puesto otro contructor que solo recibiese la clave, que es digamos, el dato más importante para poder incluir un objeto Persona en una base de datos, si nuestro programa fuese real..
1
2
3
public Persona(int clave) {
    this.clave = clave;
}
Esto nos daría una Persona sin nombre, apellidos, sexo....datos que pueden ser definidos en otro momento más adelante. Pero al menos tiene la clave, el atributo identificador y que en teoría sería único y usariamos para indexar los alumnos en bases de datos.

Sobre elegir entre constructores sin parámetros, con todos los parámetros, con solo ciertos parámetros....... no hay una opción mejor que otra.
Depende de cada caso y muchas veces, va un poco a gustos. Yo por lo general, me gusta construir los objetos pasando todos los datos necesarios de golpe en una sola linea.
Rara vez uso los setters para construir objetos, si los usos para modificar atributos una vez creados, pero rara vez para crearlos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
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

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por Kabuto (1382 intervenciones) el 29/11/2018 01:33:47
Vale, el main(). Primero vamos a ir viéndolo por partes.
Al final del mensaje, lo publicaré entero, para que puedas copiarlo todo directamente y probarlo.

El main() es quien ha de encargarse de mostrar un menú con las 4 opciones posibles.
Y según la opción que elija, se invocarán los métodos correspondientes para pedir datos de alumnos, o leer el archivo "alumos.txt", o lo que sea...

Puesto que habrá más de un método que necesite pedir datos por consola, lo ideal es declarar un objeto Scanner como atributo de esta nuestra clase principal.
De este modo, todos los métodos tendrán acceso al objeto Scanner, cosa que no sería posible si lo declarasemos dentro del main().

En mi caso, además he declarado también un String que mostrará una "cabecera" para cuando se muestre un listado de los alumnos registrados en el archivo de texto.
Esto no es necesario, es simplemente para que quede algo más bonito.
Estos son pues los atributos que he declarado para la clase pincipal:
1
2
3
4
5
6
7
8
public final class GestionFacultad {
 
	static Scanner teclado = new Scanner(System.in);
	static final String CABECERA = String.format("%-12s | %-20s | %-30s | %-4s | %-4s | %-30s | %-15s | %-11s | %-12s",
			 "Clave Alumno", "Nombre", "Apellidos", "Edad", "Sexo", "Licenciatura Inscrita", "Calif. Promedio", "Clave Tutor",
			"Hora Tutoria");
 
	public static void main(String[] args) {

Ahora voy a mostrarte el metodo main().
Es muy simple, básicamente es un bucle do while() donde se muestra un menu a través de un método que a su vez devuelve la opcion elegida por el usuario.
Esta opción pasa por un switch y según lo que haya pedido el usuario, se llama al método correspondiente.
Verás que falta la opción de "Registrar Asignaturas". Esta no la he hecho, ya la intentarás hacer tú.
Mira, este es el main()
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
public static void main(String[] args) {
 
    int opcion = 0;
    do {
        opcion = menu();
        switch(opcion)
        {
        case 0:
            System.out.println("\n\n\t\tFIN DEL PROGRAMA");
            break;
        case 1:
            registrarAlumno();
            break;
        case 2:
            mostrarReporte();
            break;
        case 3:
            calcularPromedio();
            break;
        default:
            System.out.println("\nOpcion invalida");
        }
    }while(opcion != 0);
 
}

Ya está, solo eso. Como dije es muy simple, todo el "trabajo duro" lo han de hacer métodos separados dedicándose cada uno a cosas concretas.
Vamos a ver el metodo menu().
Lo que hace es mostrar en pantalla las opciones numerada del 0 al 4. El usuario introduce un número dentro de este rango para escoger la opcion deseada y el metodo devuelve la opcion escogida para ser recogida en el main() quien la analizará en el switch que ya hemos visto.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static int menu() {
    System.out.println("\n\n\t\tGESTION FACULTAD");
    System.out.println("\t\t------- --------\n");
    System.out.println("[1] -- Registrar ALUMNO");
    System.out.println("[2] -- Mostrar listado ALUMNOS");
    System.out.println("[3] -- Calcular promedio calificaciones ALUMNO");
    System.out.println("[4] -- Registrar ASIGNATURA");
    System.out.println("[0] -- Terminar programa\n");
    int opcion;
    do {
        System.out.print("Elija opcion: ");
        opcion = Integer.parseInt(teclado.nextLine());
    }while(opcion < 0 && opcion > 4);
    return opcion;
}

Fíjate que para pedir el numero, lo pido usando el metodo nextLine() de la clase Scanner, la cuál devuelve un String, y automáticamente lo parseo a un valor int.
Podría haber pedido el dato int directamente con el método nextInt() en lugar de nextLine()...... pero probablemente tú mismo ya hayas experimentado cierto problema cuando en un mismo programa pedimos datos numéricos y datos String con el mismo objeto Scanner, y este hace cosas raras....
El caso es que pidiendo siempre datos con nextLine(), y luego parseando a lo que necesitemos (int, float, double...) evitamos este tipo de problemas.

Bien, este método no hay nada más que comentar.
Vamos a ver el método de la primera opción, que es el más extenso porque ha de pedir muchos datos ya que ha de registrar un Alumno, y al mismo tiempo, un Tutor

Fíjate que la mayoría de lineas no tienen misterio, pedimos datos y vamos guardando en variables. Cuando tengamos todos los datos necesarios para el contructor del Alumno, crearemos un objeto de esta clase e intentaremos guardarlo en el archivo alumnos.txt.
Tan solo tiene tres "momentos clave" que marcaré en negrita.

El primero es el tema de la licenciatura "gestion de la informacion en redes sociales" que exige un 8.0 o más.
Esto lo resuelvo con un simple if donde controlo si han introducido dicha licenciatura y si la nota cumple el requisito.
Si no se cumple, informo por pantalla que no se puede llevar a cabo el registro e interrumpo el método haciendo un "return vacío" que nos devolverá al main().
Si se cumple, no pasa nada, seguimos adelante pidiendo datos.

El segundo es el momento en el que hay que crear un Tutor para asociarlo a este alumno. Para hacer esto llamo a otro método distinto, que se encargará de pedir datos para crear un tutor y devolverá un objeto Tutor ya creado.

El tercero es cuando intentamos guardar los datos en un archivo de texto. Esto lo hago con otro método a parte (las tareas siempre hay que repartirlas en distintos métodos) al cuál le pasamos el String que nos genera el método toString() de la clase Alumno.

Aquí el método registrarAlumno()
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
static void registrarAlumno() {
    System.out.println("\n\tNUEVO ALUMNO:\n");
    System.out.print("Clave: ");
    int clave = Integer.parseInt(teclado.nextLine());
    System.out.print("Nombre: ");
    String nombre = teclado.nextLine();
    System.out.print("Apellidos: ");
    String apellidos = teclado.nextLine();
    System.out.print("Edad: ");
    int edad = Integer.parseInt(teclado.nextLine());
    System.out.print("Sexo(F/M): ");
    char sexo = teclado.nextLine().toUpperCase().charAt(0);
    System.out.print("Licenciatura en la que inscribe: ");
    String licenciatura = teclado.nextLine();
    System.out.print("Calificacion Promedio: ");
    double promedio = Double.parseDouble(teclado.nextLine());
    if (licenciatura.toLowerCase().equals("gestion de la informacion en redes sociales") &&
            promedio < 8.0)
    {
        System.out.println("La calificacion promedio es insuficiente para registrarse en "
                + "la licenciatura indicada.");
        System.out.println("No es posible continuar con el registro.");
        return; //Interrumpimos metodo
    }
    System.out.print("Hora de tutoria: ");
    String tutoria = teclado.nextLine();
    Tutor tutor = asignarTutor(); //Llamamos al metodo que pide datos para crear un tutor
    //Tenemos los datos necesarios para crear Alumno
    Alumno alumno = new Alumno(clave, nombre, apellidos, edad, sexo, licenciatura, promedio, tutor, tutoria);
    System.out.println("\n\tDatos Alumno registrado: ");
    System.out.println(CABECERA + "\n");
    System.out.println(alumno.toString());
    System.out.println("\nLongitud del nombre completo: " + alumno.getLongitudNombreCompleto());
    //Intentamos guardar en archivo texto
    if (guardarEnArchivo(alumno.toString()))
        System.out.println("\nEl alumno ha sido guardado en archivo alumnos.txt");
    else
        System.out.println("\nNo fue posible guardar los datos en alumnos.txt");
}

Aquí el método para crear un Tutor. No tiene misterio, pedimos datos y construimos un Tutor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static Tutor asignarTutor() {
    System.out.println("\nA continuacion indique datos del tutor...");
    System.out.print("Clave: ");
    int clave = Integer.parseInt(teclado.nextLine());
    System.out.print("Nombre: ");
    String nombre = teclado.nextLine();
    System.out.print("Apellidos: ");
    String apellidos = teclado.nextLine();
    System.out.print("Edad: ");
    int edad = Integer.parseInt(teclado.nextLine());
    System.out.print("Sexo(F/M): ");
    char sexo = teclado.nextLine().toUpperCase().charAt(0);
    System.out.print("Area Especialidad: ");
    String area = teclado.nextLine();
    System.out.print("Categoria Profesor(A/B/C): ");
    char categoria = teclado.nextLine().toUpperCase().charAt(0);
    System.out.print("Numero clases impartidas: ");
    int numClases = Integer.parseInt(teclado.nextLine());
    return new Tutor(clave, nombre, apellidos, edad, sexo, area, categoria, numClases);
}

Y este es el método para guardar los datos de alumnos en un archivo txt.
Es muy sencillo, recibe una linea String y la añade al archivo "alumnos.txt". Si este archivo no existiese, se creará automáticamente:
1
2
3
4
5
6
7
8
9
10
11
12
static boolean guardarEnArchivo(String linea) {
    try {
        BufferedWriter bw = new BufferedWriter(new FileWriter("alumnos.txt", true));
        bw.newLine();
        bw.write(linea);
        bw.close();
        return true;
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
}

A continuación el método para la segunda opcion, mostrar el reporte de alumnos registrados.
Simplemente es leer el archivo txt y mostrar las lineas que contenga. Usamos la "cabecera" que declaré al principio, para que quede más mono...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static void mostrarReporte() {
    try {
        BufferedReader br = new BufferedReader(new FileReader("alumnos.txt"));
        String linea = br.readLine();
        System.out.println(CABECERA);
        while (linea != null)
        {
            System.out.println(linea);
            linea = br.readLine();
        }
        br.close();
    } catch (FileNotFoundException e) {
        System.out.println("\nNo se encuentra archivo: alumnos.txt");
    } catch (IOException e) {
        System.out.println("Error de acceso al archivo: alumnos.txt");
    }
}

Y método para la tercera opción, calcular Promedio.
Este método es muy sencillo, e incluso algo absurdo porque pide clave de alumno pero no se hace nada especial con este dato, más allá de presentarlo en pantalla.
ESte método no tiene mucha más utilidad, que practicar un poco ejercicios con bucles..
1
2
3
4
5
6
7
8
9
10
11
12
13
static void calcularPromedio() {
    System.out.print("Indique clave alumno: ");
    String clave = teclado.nextLine();
    System.out.print("¿Cuantas calificaciones introducira?: ");
    double numCalif = Integer.parseInt(teclado.nextLine());
    double sumaNotas = 0d;
    for (int i = 0; i < numCalif; i++)
    {
        System.out.printf("\nIndique calificacion %d#: ", (i+1));
        sumaNotas += Double.parseDouble(teclado.nextLine());
    }
    System.out.printf("\nEl promedio del alumno con clave %s es %.2f", clave, (sumaNotas/numCalif));
}

En fín, solo falta crear el método para registrar Asignaturas. (y Profesores para asociarlos)
Te dejo que lo rumies tú.
Fíjate que el enunciado dice que hay que registar asignaturas hasta que el usuario diga basta introduciendo un -1
Y que luego hay que mostrar todos los datos de todas las asiganturas que haya estado registrando.

Esto plantea una dificultad:
Para mostrar los datos de todas las asignaturas registradas, hay que ir guardándolas en un algún tipo de coleccion, por ejemplo un array simple.
Pero no sabemos cuantas asignaturas va a introducir, así que no sabemos que tamaño hay que darle al array. Ya que para crear un array simple hay que especificarle un tamaño concreto.

Entonces, tenemos dos opciones:
- Usamos algún tipo de colección más avanzada, como un ArrayList, ya que tienen la ventaja de que no hay que especificar tamaño y van creciendo según añadimos elementos.
- O bien declaramos un array exageradamente grande, por ejemplo, de 50 elementos, o de 100.... y luego para mostrar datos de las asignaturas registradas, no lo recorremos entero, si no hasta que encontremos un null, lo cuál significa que ya no contiene más asignaturas.

Lo ideal sería la primera opción. Tu decides.

Por último, te pongo aquí la clase principal completa, para no tener que ir copiandola a retazos.
Sigue pregutnando dudas que tengas.
Un saludo.

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
 
public final class GestionFacultad {
 
	static Scanner teclado = new Scanner(System.in);
	static final String CABECERA = String.format("%-12s | %-20s | %-30s | %-4s | %-4s | %-30s | %-15s | %-11s | %-12s",
			 "Clave Alumno", "Nombre", "Apellidos", "Edad", "Sexo", "Licenciatura Inscrita", "Calif. Promedio", "Clave Tutor",
			"Hora Tutoria");
 
	public static void main(String[] args) {
 
		int opcion = 0;
		do {
			opcion = menu();
			switch(opcion)
			{
			case 0:
				System.out.println("\n\n\t\tFIN DEL PROGRAMA");
				break;
			case 1:
				registrarAlumno();
				break;
			case 2:
				mostrarReporte();
				break;
			case 3:
				calcularPromedio();
				break;
			default:
				System.out.println("\nOpcion invalida");
			}
		}while(opcion != 0);
 
	}
 
	static int menu() {
		System.out.println("\n\n\t\tGESTION FACULTAD");
		System.out.println("\t\t------- --------\n");
		System.out.println("[1] -- Registrar ALUMNO");
		System.out.println("[2] -- Mostrar listado ALUMNOS");
		System.out.println("[3] -- Calcular promedio calificaciones ALUMNO");
		System.out.println("[4] -- Registrar ASIGNATURA");
		System.out.println("[0] -- Terminar programa\n");
		int opcion;
		do {
			System.out.print("Elija opcion: ");
			opcion = Integer.parseInt(teclado.nextLine());
		}while(opcion < 0 && opcion > 4);
		return opcion;
	}
 
	static void registrarAlumno() {
		System.out.println("\n\tNUEVO ALUMNO:\n");
		System.out.print("Clave: ");
		int clave = Integer.parseInt(teclado.nextLine());
		System.out.print("Nombre: ");
		String nombre = teclado.nextLine();
		System.out.print("Apellidos: ");
		String apellidos = teclado.nextLine();
		System.out.print("Edad: ");
		int edad = Integer.parseInt(teclado.nextLine());
		System.out.print("Sexo(F/M): ");
		char sexo = teclado.nextLine().toUpperCase().charAt(0);
		System.out.print("Licenciatura en la que inscribe: ");
		String licenciatura = teclado.nextLine();
		System.out.print("Calificacion Promedio: ");
		double promedio = Double.parseDouble(teclado.nextLine());
		if (licenciatura.toLowerCase().equals("gestion de la informacion en redes sociales") &&
				promedio < 8.0)
		{
			System.out.println("La calificacion promedio es insuficiente para registrarse en "
					+ "la licenciatura indicada.");
			System.out.println("No es posible continuar con el registro.");
			return; //Interrumpimos metodo
		}
		System.out.print("Hora de tutoria: ");
		String tutoria = teclado.nextLine();
		Tutor tutor = asignarTutor(); //Llamamos al metodo que pide datos para crear un tutor
		//Tenemos los datos necesarios para crear Alumno
		Alumno alumno = new Alumno(clave, nombre, apellidos, edad, sexo, licenciatura, promedio, tutor, tutoria);
		System.out.println("\n\tDatos Alumno registrado: ");
		System.out.println(CABECERA + "\n");
		System.out.println(alumno.toString());
		System.out.println("\nLongitud del nombre completo: " + alumno.getLongitudNombreCompleto());
		//Intentamos guardar en archivo texto
		if (guardarEnArchivo(alumno.toString()))
			System.out.println("\nEl alumno ha sido guardado en archivo alumnos.txt");
		else
			System.out.println("\nNo fue posible guardar los datos en alumnos.txt");
	}
 
	static Tutor asignarTutor() {
		System.out.println("\nA continuacion indique datos del tutor...");
		System.out.print("Clave: ");
		int clave = Integer.parseInt(teclado.nextLine());
		System.out.print("Nombre: ");
		String nombre = teclado.nextLine();
		System.out.print("Apellidos: ");
		String apellidos = teclado.nextLine();
		System.out.print("Edad: ");
		int edad = Integer.parseInt(teclado.nextLine());
		System.out.print("Sexo(F/M): ");
		char sexo = teclado.nextLine().toUpperCase().charAt(0);
		System.out.print("Area Especialidad: ");
		String area = teclado.nextLine();
		System.out.print("Categoria Profesor(A/B/C): ");
		char categoria = teclado.nextLine().toUpperCase().charAt(0);
		System.out.print("Numero clases impartidas: ");
		int numClases = Integer.parseInt(teclado.nextLine());
		return new Tutor(clave, nombre, apellidos, edad, sexo, area, categoria, numClases);
	}
 
	static boolean guardarEnArchivo(String linea) {
		try {
			BufferedWriter bw = new BufferedWriter(new FileWriter("alumnos.txt", true));
			bw.newLine();
			bw.write(linea);
			bw.close();
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}
 
	static void mostrarReporte() {
		try {
			BufferedReader br = new BufferedReader(new FileReader("alumnos.txt"));
			String linea = br.readLine();
			System.out.println(CABECERA);
			while (linea != null)
			{
				System.out.println(linea);
				linea = br.readLine();
			}
			br.close();
		} catch (FileNotFoundException e) {
			System.out.println("\nNo se encuentra archivo: alumnos.txt");
		} catch (IOException e) {
			System.out.println("Error de acceso al archivo: alumnos.txt");
		}
	}
 
	static void calcularPromedio() {
		System.out.print("Indique clave alumno: ");
		String clave = teclado.nextLine();
		System.out.print("¿Cuantas calificaciones introducira?: ");
		double numCalif = Integer.parseInt(teclado.nextLine());
		double sumaNotas = 0d;
		for (int i = 0; i < numCalif; i++)
		{
			System.out.printf("\nIndique calificacion %d#: ", (i+1));
			sumaNotas += Double.parseDouble(teclado.nextLine());
		}
		System.out.printf("\nEl promedio del alumno con clave %s es %.2f", clave, (sumaNotas/numCalif));
	}
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por alejandro (5 intervenciones) el 29/11/2018 13:50:32
hola, gracias por responder a mis dudas, ha sido de gran ayuda.

he creado la clase asignatura así:

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
package Secundario;
 
public class Asignatura {
 
    private String claveAsignatura;
    private String nombreAsignatura;
    private int semestrecurso;
    private final Profesor profesor;
 
    public Asignatura(String claveAsignatura, String nombreAsignatura, int semestrecurso, Profesor profesor) {
        this.claveAsignatura = claveAsignatura;
        this.nombreAsignatura = nombreAsignatura;
        this.semestrecurso = semestrecurso;
        this.profesor = profesor;
    }
 
    public String getClaveAsignatura() {
        return claveAsignatura;
    }
 
    public void setClaveAsignatura (String claveAsignatura){
        this.claveAsignatura= claveAsignatura;
    }
 
    public String getNombreAsignatura() {
        return nombreAsignatura;
    }
    public void setNombreAsignatura(String nombreAsignatura){
        this.nombreAsignatura= nombreAsignatura;
    }
 
    public int getSemestrecurso() {
        return semestrecurso;
    }
    public void setSemestrecurso(int semestrecurso){
        this.semestrecurso=semestrecurso;
    }
 
    @Override
    public String toString() {
        return claveAsignatura + nombreAsignatura + semestrecurso + profesor.getNombre();
    }
}

y he asignado a la subclase profesor en un método, así
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static Profesor asignarProfesor(){
    System.out.println("\nA continuación registre datos del profesor...");
    System.out.print("Clave (número de cuenta): ");
    int clave = Integer.parseInt(entrada.nextLine());
    System.out.print("Nombre: ");
    String nombre = entrada.nextLine();
    System.out.print("Apellidos: ");
    String apellidos = entrada.nextLine();
    System.out.print("Edad: ");
    int edad = Integer.parseInt(entrada.nextLine());
    System.out.print("Sexo(F/M): ");
    char sexo = entrada.nextLine().toUpperCase().charAt(0);
    System.out.print("Estado civil:");
    char estadoCivil= entrada.nextLine().toUpperCase().charAt(0);
    System.out.print("Nivel de escolaridad:");
    String nivelEscolaridad=entrada.nextLine();
    System.out.print("Categoría del profesor:");
    char categoria = entrada.nextLine().toUpperCase().charAt(0);
    return new Profesor (clave, nombre, apellidos, edad, sexo,estadoCivil,nivelEscolaridad,categoria);
}
para después llamarlo, en un método que use la clase asignatura, ahí tengo dudas:

cómo hacer que se repita el registro de las asignaturas y los demás datos, pues solo se puede escribir uno, este se finaliza. creí que poniendo lo siguiente, se repetiría, pero no, ahora no registra nada

1
2
3
4
5
6
7
8
9
ArrayList<String> registro1 = new ArrayList<String>();
String Asignatura;
System.out.println("Datos de entrada (-1 para acabar)");
do {
asignatura = entrada.nextLine();
if (!asignatura.equalsIgnoreCase("adios"))
registro.add(asignatura);
else break;
} while (true);

[u]otra vez, de verdad agradezco que me dieras tu ayuda, gracias
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
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

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por Kabuto (1382 intervenciones) el 30/11/2018 00:40:01
Vamos allá.

La clase Asignatura está bastante bien. Quizás habría que hacer que el String creado por el método toString() fuera un poco más bonito, al menos con espacios en blanco entre cada dato, pero bueno, esto son detalles estéticos sin importancia.

El método para pedir datos y crear un objeto Profesor para luego asociarlo a las asignaturas también está bien.
Solo tiene un pequeño fallo. No hay que pedir el dato "categoria". Este dato se decide automáticamente según el nivel de escolaridad.
Esto es lo que decía el enunciado:
1
2
3
4
5
6
del Profesor se requerirán los siguientes datos:
Clave, Nombre, Apellidos, Edad, Estado Civil, Nivel de Escolaridad y Categoría.
El valor de la Categoría dependerá del Nivel de Escolaridad del Profesor:
Nivel de Escolaridad Categoría Licenciatura ‘A’ Maestría ‘B’ Doctorado ‘C’
 
Si tiene cualquier otro nivel de Escolaridad su categoría será ‘X’.

Así que esta decisión, la hace el constructor de la clase Profesor mediante un switch, recuerda:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public Profesor(int clave, String nombre, String apellidos, int edad, char sexo,
    char estadoCivil, String nivelEscolaridad) {
    super(clave, nombre, apellidos, edad, sexo);
    this.estadoCivil = estadoCivil;
    this.nivelEscolaridad = nivelEscolaridad;
    switch(nivelEscolaridad) {
    case "licenciatura":
        categoria = 'A';
        break;
    case "maestria":
        categoria = 'B';
        break;
    case "doctorado":
        categoria = 'C';
        break;
    default:
        categoria = 'X';
    }
}

Así que en el método para asignar profesor no pedimos este dato, y no lo pasamos por el contructor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static Profesor asignarProfesor(){
    System.out.println("\nA continuación registre datos del profesor...");
    System.out.print("Clave (número de cuenta): ");
    int clave = Integer.parseInt(teclado.nextLine());
    System.out.print("Nombre: ");
    String nombre = teclado.nextLine();
    System.out.print("Apellidos: ");
    String apellidos = teclado.nextLine();
    System.out.print("Edad: ");
    int edad = Integer.parseInt(teclado.nextLine());
    System.out.print("Sexo(F/M): ");
    char sexo = teclado.nextLine().toUpperCase().charAt(0);
    System.out.print("Estado civil:");
    char estadoCivil= teclado.nextLine().toUpperCase().charAt(0);
    System.out.print("Nivel de escolaridad:");
    String nivelEscolaridad=teclado.nextLine();
    // No pedimos dato categoria, este dato lo autocalcula el constructor
    // de la clase Profesor segun el nivel de escolaridad
    /*
    System.out.print("Categoría del profesor:");
    char categoria = teclado.nextLine().toUpperCase().charAt(0);
    */
    return new Profesor (clave, nombre, apellidos, edad, sexo,estadoCivil,nivelEscolaridad);
}

Vale, ahora viene el método para registrar Asignaturas. Aquí si que te has hecho un poco de lío je je..pero no ibas demasiado mal encaminado.
Lo primero es que parece que has olvidado que las asignaturas, tienen su propia clase llamada Asignatura No son simples String, por lo tanto, el ArrayList no ha de almacenar objetos String, sino objetos Asignatura.
Y los datos que debemos pedir al usuario son: clave, nombre asignatura, semestre y un objeto Profesor (mediante el método antes descrito)

Puesto que el usuario puede introducir varias asignaturas, efectivamente hay que usar un bucle el cuál ha de finalizar cuando el usuario introduzca "-1".
Yo, para controlar si el bucle termina o no, he preferido usar una variable boolean.
Mientras esta variable tenga valor TRUE, el bucle continuará pidiendo datos para crear asignaturas.
Si al pedir la clave de asignatura, el usuario introduce "-1", entonces ya no pido más datos, sino que cambio el valor de la variable boolean a FALSE y de este modo el bucle finalizará.

Al finalizar, hay que mostrar las asignaturas registradas. Para esto primero compruebo si realmente el usuario ha registrado algo (quizás lo primero que puso fue "-1" y no hay nada que mostrar) comprobando si el ArrayList esta vacío o no.
Si no lo está, lo recorro con un bucle y por cada objeto Asignatura, muestro datos en pantalla llamando a su metodo toString()

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
static void registrarAsignatura() {
    ArrayList<Asignatura> asignaturas = new ArrayList<Asignatura>();
    boolean continuar = true;
    do {
        System.out.println("\n\tNUEVA ASIGNATURA:\n");
        System.out.print("Indique clave(-1 para terminar): ");
        String clave = teclado.nextLine();
        if (clave.equals("-1")) //Ya no pedimos datos y finalizamos bucle
            continuar = false;
        else
        {
            System.out.print("Nombre Asignatura: ");
            String nombre = teclado.nextLine();
            System.out.print("Semestre: ");
            int semestre = Integer.parseInt(teclado.nextLine());
            Profesor profe = asignarProfesor();
            //Tenemos todos los datos, construimos objeto Asignatura y guardamos en el ArrayList
            asignaturas.add(new Asignatura(clave, nombre, semestre, profe));
        }
    } while(continuar);
    //El usuario ha terminado de registrar asignaturas, ahora las mostramos todas, si es que ha registrado alguna...
    if (asignaturas.isEmpty())
        System.out.println("\nNo se ha registrado ninguna Asignatura");
    else
    {
        System.out.println("\n\nA continuacion se muestran las Asignaturas registradas");
        //Recorremos ArrayList y mostramos asignatura en pantalla
        for (Asignatura asig: asignaturas)
            System.out.println("--> " + asig.toString() + "\n");
    }
}

Y ya está. Con esto creo que queda completo el ejercicio propuesto.
Si tienes más dudas, pregunta lo que sea.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por Yair (1 intervención) el 04/10/2021 16:31:21
Me podrían ayudar por favor
Realiza los siguientes ejercicios.
Crea una clase de tipo computadora con sus respectivos atributos y meotodos get, set y tostrig.
Mediante consola o utilizando JOptionPane solicita 10 datos para tu arreglo y al final recorrelo todo.
En otra clase, crea una matriz bidimencional de tipo String, y crea una tabla con 5 datos ingresados por el usuario, los datos deben coincidir con tu clase computadora, pero no debes utilizar la clase para llenar la matriz.
Crea un ArrayList de tipo computadora, y realiza un alta, baja y modificacion (CRUD) utilizando consola o JOptionPane.
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

Programa en java, intellij

Publicado por Mercedes Castro (1 intervención) el 17/02/2023 01:38:32
Desarrollar un sistema de calificaciones en java, en este se debe considerar lo siguiente:
1. El programa debe permitir el ingreso de las notas por parte del usuario.
2. Debe permitir realizar consultas sobre algún estudiante.
3. Debe permitir realizar modificación sobre algún estudiante.
4. Debe permitir realizar eliminación sobre algún dato.
5. Se debe considerar que las notas ingresadas puede ser desde 1-10(realizar validación).
6. Los componentes para realizar el cálculo del promedio son: Gestión formativa 33%, gestión practica 33% y examen 34%)
7. Deben ingresar la información básica del usuario (nombres, apellidos, dirección, materia paralelo, entre otros.)
8. Se debe realizar las respectivas validaciones con respecto a los campos.
por favor me podrian ayudar
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
Imágen de perfil de Fernando Arturo

Programa en java, ¿Cómo puedo hacer esto? (Netbeans)

Publicado por Fernando Arturo (1 intervención) el 27/04/2022 15:11:19
Me podrían ayudar con este ejercicio:

Desarrollar un programa que me permita ingresar por el teclado (Clase BufferReader ) , el código , nombre , apellido ,edad de una serie de alumnos de un colegio, los datos se tienen que insertar en una tabla (tb_alumno ) de la base de datos bd_colegio..
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