Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Se ocupa el procesador eclipce para realizar el codigo, se que es mejor aprender con generador de texto

Primero comentar que no estoy de acuerdo con esa afirmación.

Los entornos de desarrollo como Eclipse, NetBeans, IntelliJ,.... son una ayuda excelente.
Tienen cientos de funciones que los aprendices no vamos a usar, pero también tienen otras que sí son útiles.
Informan al usuario de si se ha escrito mal una instrucción, de si está llamando a una clase que requiere hacer un import, de si estamos intentando usar una variable que no se ha inicializado, o que está fuera de ámbito (scope), etc...
Son pequeñas ayudas que evitan que el usuario pierda demasiado tiempo corrigiendo la sintaxis de lo que ha escrito, y se pueda centrar más en desarrollar la lógica que el programa ha de seguir, que es lo importante y en lo que ninguna máquina podrá ayudarle.

Por supuesto, es importante ser capaz de evitar uno mismo todos esos errores y poder escribir un programa sin ayudas en cualquier editor, incluso en el Bloc de Notas de Windows...
Pero esa habilidad se va adquiriendo con el tiempo, a fuerza de escribir código cada día. Así que al principio mejor que los aprendices puedan centrarse en desarrollar lógica, y no en perder tiempo en buscar un fallo que puede ser tan tonto como haber escrito la palabra System todo en minúsuculas...


Dicho esto, sobre el programa que te piden.
Lo ideal es modularlo, usar un método/función para cada uno de los ejercicios que pide.
Así el programa principal, solo ha de mostrar un menú e invocar a la función que desarrolle el ejercicio escogido por el usuario.

Te dejo una posible solución, a ver si te sirve para entender mejor y familiarizarte con Java, y así en el futuro te sea más fácil desarrollar código por tu cuenta.
Cualquier cosa que no entiendas, por favor, pregúntala aquí en este mismo tema.

Un saludo.

import java.util.Random;
import java.util.Scanner;

public class MenuEjercicios {

private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {
String opcion = "";

do {
System.out.println("\n\t\tOPCIONES");
System.out.println("(1) -- Leer tres números por consola");
System.out.println("(2) -- Leer cinco palabras");
System.out.println("(3) -- Generar cien aleatorios y contar pares/impares");
System.out.println("(4) -- Leer palabras y mostrar las que superan 5 letras");
System.out.println("(5) -- SALIR");
System.out.print("Opcion: ");
opcion = teclado.nextLine();

switch(opcion) {
case "1":
ejercicio1();
break;
case "2":
ejercicio2();
break;
case "3":
ejercicio3();
break;
case "4":
ejercicio4();
break;
case "5":
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpción errónea");
}

}while(!opcion.equals("5"));

}

/**
* Leer tres números por consola hasta que la resta del primero con el segundo sea igual al
* tercer número que se leyó. Mostrar la cantidad de intentos que se hicieron hasta obtener el
* resultado deseado.
*/
private static void ejercicio1() {

int intentos = 0;
int num1 = 0, num2 = 0, num3 = 0;

do {
intentos++;
System.out.print("\nPrimer número: ");
num1 = Integer.parseInt(teclado.nextLine());
System.out.print("\nSegundo número: ");
num2 = Integer.parseInt(teclado.nextLine());
System.out.print("\nTercer número: ");
num3 = Integer.parseInt(teclado.nextLine());
}while(num1 - num2 != num3);

System.out.println("\nIntentos necesarios: " + intentos);

System.out.println("\n\t\tPulsa INTRO para continuar...");
teclado.nextLine();
}

/**
* Leer 5 palabras y muestre con un mensaje si la palabra comienza con vocal o consonante.
*/
private static void ejercicio2() {

for (int i = 1; i <= 5; i++) {
System.out.print("\nPalabra: ");
String palabra = teclado.nextLine().toLowerCase();

char comienzo = palabra.charAt(0);

switch(comienzo) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("Comienza por vocal");
break;
default:
System.out.println("Comienza por consonante");
}
}

System.out.println("\n\t\tPulsa INTRO para continuar...");
teclado.nextLine();
}

/**
* Generar 100 números aleatorios y mostrar la cantidad de números pares
* y la cantidad de números impares.
*/
private static void ejercicio3() {
//Con la clase Random obtendremos números aleatorios
Random azar = new Random();
int pares = 0, impares = 0;

//Un número es par si al dividir entre 2, su resto es 0.
//Para eso usamos el operador MODULO, en Java es --> %
for (int i = 1; i <= 100; i++) {
if (azar.nextInt() % 2 == 0)
pares++;
else
impares++;
}

System.out.println("\n100 números aleatorios generados...");
System.out.println("Cantidad pares: " + pares);
System.out.println("Cantidad impares: " + impares);

System.out.println("\n\t\tPulsa INTRO para continuar...");
teclado.nextLine();
}

/**
* Leer palabras hasta que se ingrese la palabra stop y mostrar
* las palabras que tengan mas de 5 letras.
*/
private static void ejercicio4() {
/*
* Con la clase StringBuilder podemos concatenar
* juntas las palabras que superen 5 letras.
*/
StringBuilder palabras5 = new StringBuilder();
String palabra = "";

System.out.println("\nIntroduzca palabras.\nPara terminar ingrese stop");
while (!palabra.equals("stop")) {
System.out.print("Palabra: ");
palabra = teclado.nextLine();
if (palabra.length() > 5)
palabras5.append(palabra +"\n");
}

System.out.println("\nPalabras introducidas que superan las 5 letras:");
System.out.println(palabras5.toString());

System.out.println("\n\t\tPulsa INTRO para continuar...");
teclado.nextLine();
}

}

Hola.
En principio para este programa no se necesitaría un menú de opciones.
Se podría poner, pero el enunciado más bien parece que desea que se siga una serie de pasos concretos, como un guión ya escrito, y no tanto que el usuario pueda moverse por un menú.

En cualquier caso, antes de todo esto, hay que escribir las clases Persona y Cliente (que va a heredar de Persona).

A continuación pongo cómo podrían ser estas dos clases.
Míratelas bien, asegúrate de que entiendes bien cada línea, decide si te parecen acordes a los que pide el enunciado..., y luego pasamos a ver como podría ser el main

Clase Persona
public class Persona {

private String rut;
private String nombre;
private String apellido;
private String email;

public Persona() {
rut = "";
nombre = "";
apellido = "";
email = "";
}

public Persona(String rut, String nombre, String apellido, String email) {
this.rut = rut;
this.nombre = nombre;
this.apellido = apellido;
this.email = email;
}

public String getRut() {
return rut;
}

public void setRut(String rut) {
this.rut = rut;
}

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 String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

@Override
public String toString() {
return "RUT: " + rut +
"\nNombre: " + nombre +
"\nApellido: " + apellido +
"\nE-Mail: " + email;
}

}
Clase Cliente
public class Cliente extends Persona{

private String numCuenta;
private float saldo;
private String tipoCuenta;

public Cliente() {
super();
numCuenta = "";
saldo = 0f;
tipoCuenta = "";
}

public Cliente(String rut, String nombre, String apellido, String email, String numCuenta,
float saldo, String tipoCuenta) {
super(rut, nombre, apellido, email);
this.numCuenta = numCuenta;
this.saldo = saldo;
this.tipoCuenta = tipoCuenta;
}

public String getNumCuenta() {
return numCuenta;
}

public void setNumCuenta(String numCuenta) {
this.numCuenta = numCuenta;
}

public float getSaldo() {
return saldo;
}

public void setSaldo(float saldo) {
this.saldo = saldo;
}

public String getTipoCuenta() {
return tipoCuenta;
}

public void setTipoCuenta(String tipoCuenta) {
this.tipoCuenta = tipoCuenta;
}

public void depositar(float monto) {
saldo += monto;
}

public void girar(float monto) {
if (monto >= saldo)
System.out.println("No hay suficiente saldo para hacer el giro");
else
saldo -= monto;
}

@Override
public String toString() {
return super.toString() +
"\nNúmero Cuenta: " + numCuenta +
"\nSaldo: " + String.format("%.2f", saldo) +
"\nTipo Cuenta: " + tipoCuenta;
}

}

Hola.
No se porque usas dos objetos Triangulo.
Entiendo que con uno ya te sirve para calcular área y perímetro.
Y así además, te habrías evitado este error, que es el motivo de que no obtengas perímetro:

<%
            String n1=request.getParameter("base");
            String n2=request.getParameter("altura");
                     
            Triangulo t=new Triangulo(n1,n2);
            t.sacarArea();
            int area=t.getArea();
           
            Triangulo p=new Triangulo(n1,n2);
            t.sacarPerimetro(); //Calculas el perímetro en el triángulo t
            int perimetro=p.getPerimetro(); //Pero luego pides resultado a p, que no ha hecho ningún cálculo
        %>

Si vas a usar dos triángulos, ha de pedirle a p que calcule el perímetro.
Pero vamos, que con un único triángulo podrías hacer ambos cálculos.

Un saludo.

Hola
Ejercicio 1 lo resuelves usando dos bucles for anidados, cada uno se va a repetir las veces que indique el valor ingresado por teclado.

El bucle interno escribiría en la misma línea un asterisco cada vez que se repita.
El bucle externo, lo que hace es repetir este bucle interno y cuando termina cada repetición, hace un salto de línea para que el bucle interno siga escribiendo asteriscos en la línea siguiente.

ES más fácil de lo que parece, intenta hacerlo.
Si no te sale, pregunta por aquí o si quieres fíjate en el código que pongo a continuación.
Pero importante que primero lo intentes tú, aunque te salga un horror de código que no sirva para nada.
Se aprende más intentando y fallando, que copiando directamente una solución.

public class Ej1 {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);
System.out.print("Ingrese valor: ");
int valor = teclado.nextInt();
teclado.close();

/*
* Usamos dos bucles anidados para crear el cuadrado.
* Si pensamos en el cuadrado como una tabla de asteriscos,
* el primer bucle crearía las FILAS
* y el segundo las COLUMNAS
*/
for (int fila = 1; fila <= valor; fila++) {
for (int columna = 1; columna <= valor; columna++)
System.out.print("*");

System.out.println();//Salto de línea para pasar a la siguiente FILA
}

}

}

El segundo ejercicio.
Hay cuatro opciones y recomiendo "modular" el código. Es decir, que cada opción sea un procedimiento escrito por separado del código principal.

El main, el código principal, solo debería presentar menú y pedir opción. Que se repita hasta que el usuario elija terminar el programa.
Con un switch, analiza la opción ingresada y llamaría al procedimiento correspondiente según dicha opción.
Este podría ser el código del main. Como digo, lo que hace es invocar los procedimientos que resuelven cada opción del menú

   public static void main(String[] args) {
      
      int opcion = 0;
      
      do {
         System.out.println("\n\t\tMENU\n");
         System.out.println("(1) - Leer 20 numeros");
         System.out.println("(2) - Leer palabras");
         System.out.println("(3) - Veces se repite una palabra");
         System.out.println("(4) - Leer 2 numeros");
         System.out.println("(5) - CERRAR PROGRAMA");
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 1:
            leer20numeros();
            System.out.println("\nPulse INTRO para volver al menu");
            teclado.nextLine();
            break;
         case 2:
            leerPalabras();
            System.out.println("\nPulse INTRO para volver al menu");
            teclado.nextLine();
            break;
         case 3:
            vecesRepitePalabra();
            System.out.println("\nPulse INTRO para volver al menu");
            teclado.nextLine();
            break;
         case 4:
            leer2numeros();
            System.out.println("\nPulse INTRO para volver al menu");
            teclado.nextLine();
            break;
         case 5:
            System.out.println("\n\t\tFIN DE PROGRAMA");
            break;
         default:
            System.out.println("Opcion equivocada");
            System.out.println("\nPulse INTRO para volver al menu");
            teclado.nextLine();
         }
         
      }while(opcion != 5);

   }

El código de cada opción, no es difícil.

Opcion 1, leer 20 números  y sumar por separado los pares y los impares.
Declaramos dos variables acumuladora, una para suma pares y la otra para los impares
Usas un bucle for que lea acepte 20 números por teclado.
Cada vez que se ingresa un número, se comprueba si es par o impar y se acumula en la variable correspondiente.
Podemos saber si un número es par dividiéndolo por 2 y comprobar si el resto es 0, es decir, usamos el operador "módulo", que en Java está representado con el operador %

Cuando termina el bucle, se muestran ambas sumas en pantalla.

Te dejo una solución, pero de nuevo insisto en la importancia de que primero lo intentes tú por tu cuenta.

private static void leer20numeros() {
int sumaPares = 0, sumaImpares = 0;
for (int i = 1; i <= 20; i++) {
System.out.println("\nEntrada " + i + "/20");
System.out.print("Ingrese numero: ");
int numero = Integer.parseInt(teclado.nextLine());
if (numero % 2 == 0)
sumaPares += numero;
else
sumaImpares += numero;
}
System.out.println("\nSuma de pares: " + sumaPares);
System.out.println("Suma de impares: " + sumaImpares);
}
Opción 2: Leer varias palabras y que se detenga al leer FIN, y muestre todas las palabras que se leyeron.
Hay que usar un bucle while y que pida palabras para ir coleccionándolas.
El bucle while se repite mientras la palabra ingresada sea distinto de "FIN".
Al terminar el bucle, se muestran las palabras ingresadas.

Para coleccionar las palabras, hay varias fórmulas.
Una podría ser usar una estructura de datos dinámica como List,ArrayList, etc..

Otra podría ser usar un String e ir concatenando las palabras una tras otra, intercalando una coma o un espacio en blanco entre cada palabra.
Sin embarco, los objetos String son "inmutables", no se pueden modificar. Entonces, cuando concatenamos Strings, nos parece que los estamos modificando, pero en realidad se está creando un objeto nuevo, y los otros objetos String que hemos usado para concatenar, no desaparecen. Se quedan en memoria ocupando recursos hasta que termine el programa.

A efectos prácticos, esto no es problema para un ejercicio tan sencillo, pero no esta de más que intentemos que nuestro código sea lo más eficiente posible.
Así que para evitar esto, podemos usar la clase StringBuilder.
Esta clase nos da un objeto similar a un String que sí es "mutable" y podremos concatenarle todos los String que queramos sin que eso suponga desperdiciar recursos.

Pero bueno, en cualquier caso, estas tres formas de solucionarlo son válidas.
Yo he optado por usar StringBuilder:

private static void leerPalabras() {
/*
* Las palabras a leer se podrían concatenar en un
* String normal. Pero internamente un String es estático,
* no se puede modificar, así que cuando concatenamos dos
* String, no estamos modificando ninguno, estamos creando un
* tercer String nuevo. Esto supone consumir más recursos del sistema.
*
* StringBuilder es un objeto dinámico, si es modificable y las concatenaciones
* que hagamos no implican crear nuevos objetos, solo modificar el ya existente.
*/
StringBuilder palabras = new StringBuilder();
String palabra = "";
while (!palabra.equals("FIN")) {
System.out.print("Ingrese palabra (FIN para terminar): ");
palabra = teclado.nextLine();
if (!palabra.equals("FIN")) {
palabras.append(palabra);
palabras.append(" ");
}
}
System.out.println("\nPalabras ingresadas:");
System.out.println(palabras.toString());
}
Opción 3: Leer 30 palabras y mostrar cuantas veces esta una determinada palabra. La palabra a buscar debe leerse antes de ingresar las 30 palabras.
Primero pedimos la palabra a buscar.
Luego las 30 palabras donde debemos buscar.

Como ya sabemos de antemano que han de ser 30 palabra, esta vez para coleccionar estas palabras podemos usar un simple array de String.

Cuando tengamos las 30 palabras, recorremos el array con un bucle y cada palabra la comparamos con la que estamos buscando.
Si son iguales, aumentamos una variable contador.
Luego mostramos resultado

private static void vecesRepitePalabra() {
System.out.print("\nIngrese palabra a buscar: ");
String palabra = teclado.nextLine();
System.out.println("A continuación ingrese 30 palabras...");
String[] palabras = new String[30];

for (int i = 0; i < 30; i++) {
System.out.println("\nEntrada " + (i+1) + "/30");
System.out.print("Palabra: ");
palabras[i] = teclado.nextLine();
}
//Contamos repeticiones
int repite = 0;
for (String p: palabras)
if (p.contentEquals(palabra))
repite++;
//Resultado
System.out.println("\nLa palabra " + palabra + " se repite " + repite + " veces.");
}
Opción 4: Leer 2 números. El primero debe estar entre 5 y 50 y el segundo no debe ser par.
Entregar como resultado la suma de los dos números, en caso de que sean correctos los
valores, en caso contrario mostrar un mensaje de error.

Muy sencillo, pedimos dos números.
Comprobamos si el primero está entre 5 y 50.
Si no lo está, mensaje de error y se acabó.

Si es correcto, comprobamos el segundo número.
Si no lo es, mensaje error y fin.

Si es correcto, pues mostramos la suma de ambos números.

private static void leer2numeros() {
int num1 = 0, num2 = 0;

System.out.print("\nPrimer numero (entre 5 y 50): ");
num1 = Integer.parseInt(teclado.nextLine());
System.out.print("Segundo numero (ha de ser impar): ");
num2 = Integer.parseInt(teclado.nextLine());

if (num1 < 5 || num1 > 50)
System.out.println("ERROR (numero 1 no está entre 5 y 50)");
else if (num2 % 2 == 0)
System.out.println("ERROR (el segundo número es par)");
else
System.out.println("Suma de numeros: " + (num1 + num2));
}

Y eso es todo, a continuación de dejo el código de esta clase al completo, main y procedimientos.
E insisto una vez más, intenta comenzar tú un código, no importa si sale mal o si apenas llegas a escribir 5 líneas antes de atascarte.
Es así como se aprende, cometiendo errores.

Cualquier duda que tengas, pregúntala por aquí.
Un saludo.

public class Ej2 {

/*
* Objeto Scanner lo declaramos en ámbito global para que
* sea accesible a todos los métodos/procedimientos y
* puedan utilizarlo
*/
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

do {
System.out.println("\n\t\tMENU\n");
System.out.println("(1) - Leer 20 numeros");
System.out.println("(2) - Leer palabras");
System.out.println("(3) - Veces se repite una palabra");
System.out.println("(4) - Leer 2 numeros");
System.out.println("(5) - CERRAR PROGRAMA");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
leer20numeros();
System.out.println("\nPulse INTRO para volver al menu");
teclado.nextLine();
break;
case 2:
leerPalabras();
System.out.println("\nPulse INTRO para volver al menu");
teclado.nextLine();
break;
case 3:
vecesRepitePalabra();
System.out.println("\nPulse INTRO para volver al menu");
teclado.nextLine();
break;
case 4:
leer2numeros();
System.out.println("\nPulse INTRO para volver al menu");
teclado.nextLine();
break;
case 5:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("Opcion equivocada");
System.out.println("\nPulse INTRO para volver al menu");
teclado.nextLine();
}

}while(opcion != 5);

}

private static void leer20numeros() {
int sumaPares = 0, sumaImpares = 0;
for (int i = 1; i <= 20; i++) {
System.out.println("\nEntrada " + i + "/20");
System.out.print("Ingrese numero: ");
int numero = Integer.parseInt(teclado.nextLine());
if (numero % 2 == 0)
sumaPares += numero;
else
sumaImpares += numero;
}
System.out.println("\nSuma de pares: " + sumaPares);
System.out.println("Suma de impares: " + sumaImpares);
}


private static void leerPalabras() {
/*
* Las palabras a leer se podrían concatenar en un
* String normal. Pero internamente un String es estático,
* no se puede modificar, así que cuando concatenamos dos
* String, no estamos modificando ninguno, estamos creando un
* tercer String nuevo. Esto supone consumir más recursos del sistema.
*
* StringBuilder es un objeto dinámico, si es modificable y las concatenaciones
* que hagamos no implican crear nuevos objetos, solo modificar el ya existente.
*/
StringBuilder palabras = new StringBuilder();
String palabra = "";
while (!palabra.equals("FIN")) {
System.out.print("Ingrese palabra (FIN para terminar): ");
palabra = teclado.nextLine();
if (!palabra.equals("FIN")) {
palabras.append(palabra);
palabras.append(" ");
}
}
System.out.println("\nPalabras ingresadas:");
System.out.println(palabras.toString());
}

private static void vecesRepitePalabra() {
System.out.print("\nIngrese palabra a buscar: ");
String palabra = teclado.nextLine();
System.out.println("A continuación ingrese 30 palabras...");
String[] palabras = new String[30];

for (int i = 0; i < 30; i++) {
System.out.println("\nEntrada " + (i+1) + "/30");
System.out.print("Palabra: ");
palabras[i] = teclado.nextLine();
}
//Contamos repeticiones
int repite = 0;
for (String p: palabras)
if (p.contentEquals(palabra))
repite++;
//Resultado
System.out.println("\nLa palabra " + palabra + " se repite " + repite + " veces.");
}

private static void leer2numeros() {
int num1 = 0, num2 = 0;

System.out.print("\nPrimer numero (entre 5 y 50): ");
num1 = Integer.parseInt(teclado.nextLine());
System.out.print("Segundo numero (ha de ser impar): ");
num2 = Integer.parseInt(teclado.nextLine());

if (num1 < 5 || num1 > 50)
System.out.println("ERROR (numero 1 no está entre 5 y 50)");
else if (num2 % 2 == 0)
System.out.println("ERROR (el segundo número es par)");
else
System.out.println("Suma de numeros: " + (num1 + num2));
}
}

Interesante propuesta.
La verdad es que poco más se puede hacer, ya que en modo consola las posibilidades de lo que mostramos en pantalla son muy limitadas en Java.

Lo único que le faltaría añadir sería una opción para poder salir del programa, ya que el bucle de "juego" se repite infinitas veces.

Sobre lo del objeto Scanner, a ver si lo explico mejor.

Cuando tú escribes algo, ya sea en Java, en Bloc de Notas, en un foro...en cualquier soporte informático, con el teclado estamos enviando caracteres que se muestran en pantalla y forman palabras, instrucciones, números y operaciones, etc...

Pero hay algunas teclas que envían caracteres especiales, caracteres que no se ven en pantalla, pero que cumplen una función.

Uno de ellos es el carácter que se produce cuando pulsamos la tecla enter, o intro, o como queramos llamarla...
Este carácter, su función es poner fin a la línea que estamos escribiendo y se llama "retorno de carro". No de "coche", de carro.
Este nombre viene heredado de las antiguas máquinas de escribir, donde para poner fin a una línea y comenzar la siguiente se accionaba una palanca:



Al accionar esta palanca, el "carro" volvía a la posición original ,el rodillo saltaba a la línea siguiente, y se podía seguir escribiendo de izquierda a derecha.

Bueno, lo que nos interesa a nosotros... este carácter como digo, es invisible en pantalla y el usuario no lo ve, pero el ordenador sí, para él es otro carácter más y suele representarlo con el carácter \r

Así que cuando escribimos esto:

Línea 1.
Línea 2.
Línea 3.

El ordenador recibe esto:

Línea 1.\r
Línea 2.\r
Línea 3.\r

En Java, la clase Scanner se encarga de recibir datos de los sistemas de entrada. Generalmente el teclado, pero podrían ser otros como un fichero de texto.
Scanner funciona como una cola, va recibiendo bytes (para crear una carácter se usa un byte de información) y de estos captura, en orden de llegada, lo que le solicitemos.

Si a Scanner le pedimos que capture una entrada de datos usando el método nextLine(), es decir, que capture una línea, pues va a recoger todos los bytes/caracteres necesarios para crear una línea y eso incluye el carácter \r

Entonces, si al hacer nextLine() le tecleamos esto:

Hola que tal, buenas tardes\r

Capturará TODOS los caracteres, porque todos conforman una línea y la "cola de datos" (stream) del Scanner quedará vacía.

Pero, y ahora viene el problema, si le pedimos que capture datos con el método nextInt(), es decir, que capture los caracteres necesarios para crear un valor numérico entero, esto va a excluir el caracter \r, porque con eso no se hace un valor numérico.
El carácter retorno de carro, a nextInt() le va a servir para saber que tiene que dejar de buscar caracteres válidos para crear un número, pero no lo capturará.

Entonces, si a nextInt() le damos esto:

129\r

Cogerá el 1, el 2 y el 9.., pero no el \r. Y este \r se va a quedar en la "cola de datos".

Y aquí es donde viene el problema.

Si después de esto seguimos pidiendo leer números con nextInt(), nextDouble(), etc... no habrá problema.
Estos métodos se encontrarán el \r en la cola, pero no le harán caso porque todavía no han entrado caracteres para crear valores numéricos. Cuando empiecen a entrar, los irán capturando hasta que el usuario ponga fin enviando un nuevo \r, que los métodos no recogerán y también quedará olvidado en la cola de datos.

Pero, si tras leer números y dejar caracteres \r en la cola de datos, queremos leer una línea con nextLine(), será entonces cuando el usuario no podrá introducir nada.
Porque cuando nextLine() se vaya a la cola de datos a esperar que el usuario teclee cosas, se encontrará los \r olvidados de las lecturas anteriores.
Y este es un carácter que nextLine() NO DEBE ignorar, puede usarlos para conformar lo que se le ha pedido, una línea.

Y de hecho, es el carácter que pone fin a la línea, así que nextLine() da por finalizada la captura de datos, sin que el usuario haya podido teclear absolutamente nada.
nextLine() ha creado una línea vacía (que técnicamente es válida), pero el usuario se queda asombrado porque parece que el programa se ha saltado la entrada de datos.

Por esto, cuando en un programa queramos leer números y líneas, es mejor usar para todo nextLine() y si hace falta, parsear a Integer, Float o lo que sea...
Así se evita dejar retornos de carros abandonados en la cola del Scanner.

Si solo se van a leer valores numéricos y/o valores char (que en realidad también es un numérico) pues entonces no hay problema.

Espero que con esta explicación más extensa se entienda mejor.
He de decir que esto del Scanner nos vuelve locos a TODOS cuando empezamos a programar en Java, no eres el único je je..

Y además decir que no es un error de Java, ni nada parecido. En realidad es una consecuencia lógica al hacer lecturas de datos, no se si podríamos decir, a "bajo nivel".

Esto mismo ocurre también por ejemplo en lenguaje C.

2. Volver a ingresar las notas de un alumno. Permite volver a ingresar las notas de un alumno identificado por el índice de la posición el vector o ArrayList y reemplaza el promedio.
    3. Eliminar las notas de un alumno. Elimina el promedio de notas del vector o ArrayList desde una posición específica.

Para modificar y eliminar, hay que preguntar al usuario sobre cuál posición del ArrayList quiere actuar.
En pantalla puedes pedirle que introduzca la posición, entre 0 y la última posición disponible actualmente.

Esta última posición puedes saberla preguntando al ArrayList su tamaño size() y restarle menos 1

Es decir, si el ArrayList tiene 10 elementos, las posiciones disponibles para elegir serían entre 0 y 9.
Cuando el usuario te ha dado la posición, ya puedes actuar en ella.

Para eliminar, tienes el método remove(int posicion).
Para modificar, tienes el método set(int posicion, Float nuevoPromedio)

Para conocer los métodos de cada clase, SIEMPRE conviene consultar la documentación de Oracle.
ArrayList Oracle

Por ejemplo, eliminar se podría escribir así:
case 3:
System.out.println("Indique posición del promedio a eliminar, entre 0 y " + (promedios.size() - 1));
int posEliminar = teclado.nextInt();
promedios.remove(posEliminar);
break;
Modificar sería parecido, solo que tras pedir la posición a modificar, luego habría que volver a pedir otra vez notas, calcular promedio y usar el método set() para modificar el promedio anterior.

Hola.
Cuando analizas qué animal es, y su estado, no haría falta preguntar dos veces el tipo de animal:

Por ejemplo, aquí preguntas dos veces si es vaca

      Si especie = "vaca" & estado = "sana" Entonces
         vacas = vacas +1
         v_sanas <- v_sanas + 1
      Sino
         si especie = "vaca" & estado = "enferma" Entonces
            vacas = vacas +1
            v_enfermas = v_enfermas + 1
         FinSi
      FinSi

Se puede hacer preguntándolo una sola vez.
Y para evaluar el estado, tampoco hace falta preguntar si es "sana" y si no lo es, preguntar si es "enferma"
Solo hay dos posibilidades, así que si no es "sana", pues obligatoriamente será "enferma"

      Si especie = "vaca" Entonces
         vacas = vacas +1
         Si estado = "sana" Entonces
             v_sanas <- v_sanas + 1
         Sino
             v_enfermas = v_enfermas + 1   
         FinSi
      FinSi

Funcionar, funciona igual de bien que como lo has hecho tú. Prácticamente es lo mismo, pero evitas preguntas redundantes y el código queda un poco más simplificado.


Sobre los grupos, si divides entre 19 el total contado de cada animal, sabrás cuantos grupos hay.

Supón que has contado 43 vacas, si hacemos una división entera, es decir, ignoramos la parte decimal:
43 / 19 = 2
Pues hay 2 grupos de 19 vacas.

El sobrante, lo obtienes sacando el resto o módulo de esa misma división:
43 MOD 19  = 5
Hay un sobrante de 5 vacas.

Así que con vacas / 19 tendrás los grupos de vacas, y con vacas MOD 19 el sobrante.

Hola.

¿En que necesitas ayuda exactamente?
¿En usar NetBeans? ¿En hacer un diagrama UML? ¿En emplear POO? ¿En escribir el código?
¿En todo?....

En cualquier caso, lo primero es analizar el enunciado e identificar las "entidades" que toman parte. De estas entidades, tendremos que crear clases para modelarlas.

Por ejemplo. Es evidente que una entidad será Asignatura.
Una Asignatura tiene un nombre y según el enunciado, va a tener tres notas parciales.
Si creamos una clase de esta entidad, pues sus atributos serán el nombre de Asignatura, de tipo String y las tres notas, que podrían ser de tipo float si queremos recibir notas con decimales.
Estas tres notas parciales se pueden gestionar como tres atributos separados, o bien agruparlas en un único array de tres elementos float. Esto va a gusto del programador (a mi me gusta más usar el array).

Tenemos los atributos, ahora hay que pensar en su constructor.
Con un constructor que reciba por parámetros el nombre que tendrá la Asignatura, sería suficiente.
Si hemos elegido usar un array para las notas, el constructor además se encargaría de inicializarlo.

Ahora pensemos en los métodos.

Uno será el típico getNombre() para obtener un String con el nombre de la asignatura.
Parece que no será necesario un setNombre() para poder cambiar el nombre, pero se le puede poner si se desea.

Lo que si será necesario será un método para recibir las notas parciales que tiene la asignatura.
Puede llamarse setNotaParcial()
Si se ha elegido usar tres atributos separados para las notas, se necesitarán tres métodos distintos, uno para cada atributo.
Si se ha elegido usar un array, pues será suficiente un único método, pero este método además de recibir la nota que hay que establecer, ha de recibir en que posición del array se ha insertar (un valor int entre 0 y 2)

El enunciado pide que se pueda calcular la nota definitiva de una Asignatura, es decir, la nota que podemos calcular según las tres notas parciales.
Así que podemos incluir ya un método para que la Asignatura sea capaz de hacer este cómputo por ella misma.
Un método que puede llamarse getNotaDefinitiva() y retorne un valor float si se ha elegido usar notas con decimales, o un int si se ha elegido usar valores enteros para las notas.

El diagrama UML para esta clase podría ser:




Bien, otra entidad evidente sería Estudiante.
Un Estudiante tendría también un nombre y 5 Asignaturas.
Las Asignaturas, pueden tratarse individualmente en 5 atributos distintos, o como antes, usar un array de 5 elementos.

Diseña tú el UML para la clase Estudiante, con esos atributos. Piensa que constructor y métodos puede necesitar.

Compártelo aquí cuando lo tengas y vemos si hay que corregir o añadir algo.

Un saludo.

Cada vez que se ejecuta el método crearCSV(), se genera un archivo nuevo.
Si en lugar de eso queremos que se vaya agregando información al archivo, entonces hay que añadirle el parámetro TRUE al constructor del objeto FileWriter que usamos para escribir los datos en el archivo.

FileWriter escritor = new FileWriter(archivo, true);

Ahora las líneas se irán añadiendo al archivo, pero esto plantea un problema.
El código que escribí, SIEMPRE inserta una línea con una cabecera, y SIEMPRE escribe TODOS los objetos contenidos en el ArrayList.

Es decir, si registro al Doctor Pepe y creo el CSV. Insertará una cabecera y los datos del Doctor Pepe.
Eso está bien.

Pero si acto seguido registros a la Dra Susana y creo de nuevo el CSV, lo que añadirá a continuación es otra vez la cabecera, otra vez los datos del Dr. Pepe y por último a la Dra.Susana.
Y si registro un tercer doctor, de nuevo redundará otra cabecera, otra vez el Dr. Pepe, la Dra Susana y el tercer doctor..


Habría que cambiar la estrategia, que solo inserte la línea de cabecera (la que da nombres a las columnas de datos) la primera vez que se crea el archivo.
Esto lo podemos controlar con un boolean

Y que solo escriba la última entrada recibida en el ArrayList, para que no repita los datos de los registros anteriores.
Esto lo conseguimos consultando cuánto mide el ArrayList y restándole -1 para obtener el indice del último registro recibido.
Marco en negrita los cambios que haríamos al método de crearCSV().

   
   public void crearCSV() {
      
      File archivo = new File("D:/csv/doctores.csv");
      
      try {
         //Si no existe archivo, intentamos crearlo
         boolean primeraVez = false;
         if (!archivo.exists()) {
            File carpeta = archivo.getParentFile();
            carpeta.mkdirs();
            archivo.createNewFile();
            primeraVez = true; //Primera vez que trabajamos en este archivo
         }
         
         FileWriter escritor = new FileWriter(archivo, true);
         //Cabecera para datos del CSV, solo si es la primera vez
         if (primeraVez)
            escritor.append("#ID;Nombre;Apellidos;Especialidad\n");
         
         //Datos del último Doctor registrado
         int ultimo = doctores.size() - 1;
         escritor.append(doctores.get(ultimo).generaLineaCSV());//Insertamos linea CSV
         
         escritor.close();
      } catch (IOException e) {
         System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
      }
   }

De este modo, solo escribe el último Doctor registrado. Por lo tanto, nos será más comodo si en lugar de invocar este método desde el main() después de cada Doctor registrado, lo podemos invocar desde dentro del método que usemos para crear Doctores.
Así cada vez que se da de alta un nuevo Doctor, automáticamente se genera la línea CSV correspondiente.
Ya no es necesario solicitarlo en el main de la clase principal

   
   public void nuevoDoctor() {
      System.out.println("\nALTA NUEVO DOCTOR");
      System.out.println("---- ----- ------\n");
      System.out.print("ID: ");
      String id = teclado.nextLine();
      System.out.print("Nombre: ");
      String nombre = teclado.nextLine();
      System.out.print("Apellidos: ");
      String apell = teclado.nextLine();
      System.out.print("Especialidad: ");
      String espe = teclado.nextLine();
      
      doctores.add(new Doctor(id, nombre, apell, espe));
      crearCSV(); //Añadimos nueva línea CSV al archivo en disco
   }

Lo mismo habrá que hacer con las Citas y los Pacientes.


Sobre las Citas, y relacionar Doctores y Pacientes.

No se como habrás escrito tu clase Cita, pero entiendo que lo de relacionar consiste en que una Cita tendrá entre sus atributos, un Doctor y un Paciente, además de los otros atributos indicados por el enunciado.

Puedes incluso porporcionarle dos constructores.
Uno que reciba todos los parámetros para todos los atributos.
Otro que solo reciba ID, hora, fecha y motivo. Con la idea de luego usar los setters para agregar un Doctor y un Paciente a esta Cita.

public class Cita {

private String id;
private String fecha;
private String hora;
private String motivo;
private Doctor doctor;
private Paciente paciente;

public Cita(String id, String fecha, String hora, String motivo,
Doctor doctor, Paciente paciente) {
this.id = id;
this.fecha = fecha;
this.hora = hora;
this.motivo = motivo;
this.doctor = doctor;
this.paciente = paciente;
}

public Cita(String id, String fecha, String hora, String motivo) {
this.id = id;
this.fecha = fecha;
this.hora = hora;
this.motivo = motivo;
}

public String getMotivo() {
return motivo;
}

public void setMotivo(String motivo) {
this.motivo = motivo;
}

public Paciente getPaciente() {
return paciente;
}

public void setPaciente(Paciente paciente) {
this.paciente = paciente;
}

}

El resto de tu programa, lo colocas dentro del if que acepta la validación.

   public static void main(String[] args) {
      crearAdmins();

      if (validarAcceso()) {
         System.out.println("\nUsuario autorizado\n");
         doctores.nuevoDoctor();
         doctores.modificarDoctor();
         doctores.mostrarDoctores();
         pacientes.nuevoPaciente();
         pacientes.mostrarPacientes();
         pacientes.modificarPaciente();
         pacientes.borrarPaciente();
         citas.nuevoCita();
         citas.mostrarCitas();
      }
      else
         System.out.println("\nUsuario no autorizado.");

      System.out.println("\n\t\tFIN DE PROGRAMA");

   }

Para crear un CSV. Hay librerías externas que se pueden usar.
Pero en realidad un CSV es un tipo de archivo muy sencillo y si tan solo queremos crearlos, podemos hacerlo fácilmente nosotros.

Un CSV básicamente son líneas de datos separados por un delimitador, habitualmente un punto y coma ;

Para facilitar aún más el proceso, podemos enseñarle a nuestras clases a crear una línea CSV con sus datos.
Por ejemplo la clase Doctor, podemos incluirle este método:
     
      public String generaLineaCSV() {
      return String.format("%s;%s;%s;%s\n", id, nombre, apellidos, especialidad);
      }
Con ese método, podmos pedirle a cada objeto Doctor que nos retorne un String con sus datos formateados en CSV.

Luego, desde la clase GestorDoctor, ahí podemos escribir otro método que se encargue de escribir en disco un archivo CSV, con las líneas que le proporcione cada uno de los doctores que está gestionando.
Un método como este:

public void crearCSV() {

File archivo = new File("D:/csv/doctores.csv");

try {
//Si no existe archivo, intentamos crearlo
if (!archivo.exists()) {
File carpeta = archivo.getParentFile();
carpeta.mkdirs();
archivo.createNewFile();
}

FileWriter escritor = new FileWriter(archivo);
//Cabecera para datos del CSV
escritor.append("#ID;Nombre;Apellidos;Especialidad\n");

//Datos de los doctores
for (Doctor doc: doctores)
escritor.append(doc.generaLineaCSV());//Insertamos linea CSV

escritor.close();
} catch (IOException e) {
System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
}
}

De este modo, si en mi programa clínica (que no está completo y solo gestiona doctores) doy de alta a tres doctores y genero un CSV:

public static void main(String[] args) {
crearAdmins();

if (validarAcceso()) {
System.out.println("\nUsuario autorizado\n");
doctores.nuevoDoctor();
doctores.nuevoDoctor();
doctores.nuevoDoctor();
doctores.crearCSV();
}
else
System.out.println("\nUsuario no autorizado.");

System.out.println("\n\t\tFIN DE PROGRAMA");

}

ACCESO AL SISTEMA
------ -- -------

Nombre: Kabuto
Password: 1234

Usuario autorizado


ALTA NUEVO DOCTOR
---- ----- ------

ID: ID001
Nombre: Ramon
Apellidos: Luna
Especialidad: Cardiologia

ALTA NUEVO DOCTOR
---- ----- ------

ID: ID002
Nombre: Susana
Apellidos: Lopez
Especialidad: Hematologia

ALTA NUEVO DOCTOR
---- ----- ------

ID: ID003
Nombre: Raul
Apellidos: Molino
Especialidad: Endoscopia

      FIN DE PROGRAMA

Puedo comprobar que se ha generado un archivo CSV:


Y si lo abro, tengo los datos disponibles en una hoja de cálculo: