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

Prueba con este curso, a ver si te ayuda a asimilar mejor el aprendizaje de JS

Hay que tener claro que con HTML y CSS, lo que haces es maquetar, es decir "dar forma" a una página web. Por eso es algo que puedes visualizar inmediatamente.

Con JavaScript, en cambio, lo que se hace es "programar el comportamiento" de esa web.

Imagina que tienes que crear una web que consiste en una examen tipo test.

Con HTML y CSS puedes colocar el texto de las preguntas, las respuestas seleccionables con sus radio button (<input type="radio">), imágenes, campos de texto para que el alumno inserte su nombre, el botón para terminar la evaluación, etc...

Cuando el usuario pulse el botón de terminar evaluación, vamos a querer que la página compruebe las respuestas y de una nota, un resultado según los aciertos y los errores.
Pues ahí es donde entra JavaScript.

Con JS escribiremos un código que recorra el DOM de la página comprobando las respuestas y contando las correctas y las incorrectas.
Incluso si se detectan preguntas sin responder, JS puede resaltarlas cambiando su color o agruparlas juntas en un nuevo <div/> creado de forma dinámica para que el alumno las vea fácilmente y confirme si quiere dejarlas sin respuesta o no.

Y cuando el programa ya tenga las respuestas confirmadas, pues podrá computar los aciertos/errores y mostrar si el alumno ha aprobado el examen o no, puede además mostrar los temas en los que ha fallado y mostrar enlaces a los contenidos que debería repasar para poder aprobar la próxima vez que se evalúe.

Y en fin, se puede hacer casi cualquier cosa que pase por nuestra imaginación.

En resumen, HTML y CSS son para crear lo que vemos. Es el barro que nos permite modelar una estatua o figura.
Pero para dar "vida" a esa figura, hacer que responda, se mueva y cambie ella sola según los eventos que ocurran, necesitamos JS.

Hola.
Suponiendo que tu enum sea como este:
public enum TEvento {

CINE,TEATRO,CONCIERTO
}

Y cambiando en tu clase Abono el método para setear eventos de esta manera:
    public void setTipoEvento(TEvento TipoEvento)
    {
        this.TipoEvento = TipoEvento;
    }

Bien, la forma sencilla y rápida de cambiar el valor del enum en un objeto, es pedir al usuario que elija mediante un menú, y según lo que elija, seteamos el valor correspondiente desde el código.
Por ejemplo, si ejecutamos este código:
public class PruebaAbono {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);
Abono abono = new Abono();

int opcion = -1;
while (opcion != 0) {
System.out.println("\nTipo de Evento actual: " + abono.getTipoEvento());
System.out.println("Escoja cambiar el Evento o terminar aplicacion.");
System.out.println("[1] - Cine");
System.out.println("[2] - Teatro");
System.out.println("[3] - Concierto");
System.out.println("[0] - TERMINAR");
System.out.print("Opcion: ");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 0:
System.out.println("\n\tFIN DE PROGRAMA");
break;
case 1:
abono.setTipoEvento(TEvento.CINE);
break;
case 2:
abono.setTipoEvento(TEvento.TEATRO);
break;
case 3:
abono.setTipoEvento(TEvento.CONCIERTO);
break;
default:
System.out.println("Opcion equivocada");
}
}

teclado.close();
}

}
Veremos en pantalla que podemos cambiar el valor del enum a través de las opciones de un menú:

Tipo de Evento actual: CINE
Escoja cambiar el Evento o terminar aplicacion.
[1] - Cine
[2] - Teatro
[3] - Concierto
[0] - TERMINAR
Opcion: 2

Tipo de Evento actual: TEATRO
Escoja cambiar el Evento o terminar aplicacion.
[1] - Cine
[2] - Teatro
[3] - Concierto
[0] - TERMINAR
Opcion: 3

Tipo de Evento actual: CONCIERTO
Escoja cambiar el Evento o terminar aplicacion.
[1] - Cine
[2] - Teatro
[3] - Concierto
[0] - TERMINAR
Opcion: 1

Tipo de Evento actual: CINE
Escoja cambiar el Evento o terminar aplicacion.
[1] - Cine
[2] - Teatro
[3] - Concierto
[0] - TERMINAR
Opcion: 0

   FIN DE PROGRAMA

Como ves, pidiendo al usuario que introduzca simplemente un número entre 1 y 3, ya podemos cambiar el valor del enum y no hay por qué complicarse más la vida.

Espero haber resuelto tu duda.
Saludos.

Hola.
¿El código es tuyo o copiado? Tiene errores y algunas "malas costumbres", como poner los nombres de los atributos comenzando con mayúscula. En Java, la "buena costumbre" es escribirlos en minúsculas.

A ver, tenemos una clase Persona.
Con su constructor y métodos get/set. Además queremos un método que nos retorne de una sola vez todos los datos para mostrarlos en pantalla o donde sea.
Para esto, lo apropiados es sobreescribir el método toString(), donde construiremos un único String con toda la información de los atributos (o los que creamos importantes) y retornarlo.
En este ejemplo lo construyo usando String.format(), pero el String se puede construir como se quiera.
public class Persona {

protected String nombre;
protected int edad;
protected char sexo;
protected String curp;
protected String domicilio;

public Persona(String nombre, int edad, char sexo, String curp, String domicilio) {
this.nombre = nombre;
this.edad = edad;
this.sexo = sexo;
this.curp = curp;
this.domicilio = domicilio;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

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;
}

public String getCURP() {
return curp;
}

public void setCURP(String curp) {
this.curp = curp;
}

public String getDomicilio() {
return domicilio;
}

public void setDomicilio(String domicilio) {
this.domicilio = domicilio;
}

@Override
public String toString() {
return String.format("Nombre: %s, Edad: %d, Sexo: %s\nCURP: %s, Domicilio: %s", nombre, edad, sexo,
curp, domicilio);
}

}
De esta clase, tienen que heredar Alumno y Docente.

La clase Alumno tiene un atributo llamado status cuyo valor no debe ser proporcionado por el usuario, si no que se calcula según el valor de su nota promedio.
Para hacer este cálculo usamos un método privado llamado calcularEstatus(), al cuál debemos invocar siempre que se modifique la nota promedio.
Por tanto, lo vamos a invocar en el constructor y también dentro del método setPromedio()

Esta clase también tiene un método toString(), lo que hace es coger el método toString que retorna su super clase (Persona) y añadirle los valores del alumno, para construir un único String con todos los datos.
public class Alumno extends Persona {

private int numControl;
private String carrera;
private int semestre;
private char grupo;
private float promedio;
private String status;

public Alumno(String nombre, int edad, char sexo, String curp, String domicilio, int numControl, String carrera,
int semestre, char grupo, float promedio) {
super(nombre, edad, sexo, curp, domicilio);
this.numControl = numControl;
this.carrera = carrera;
this.semestre = semestre;
this.grupo = grupo;
this.promedio = promedio;
calcularEstatus();
}

private void calcularEstatus(){
if (promedio>60){
if (promedio>85)
status="Excelente";
else
status="Regular";
}
else
status="Irregular";
}

public int getNumControl() {
return numControl;
}

public void setNumControl(int numControl) {
this.numControl = numControl;
}

public String getCarrera() {
return carrera;
}

public void setCarrera(String carrera) {
this.carrera = carrera;
}

public int getSemestre() {
return semestre;
}

public void setSemestre(int semestre) {
this.semestre = semestre;
}

public char getGrupo() {
return grupo;
}

public void setGrupo(char grupo) {
this.grupo = grupo;
}

public float getPromedio() {
return promedio;
}

public void setPromedio(float promedio) {
this.promedio = promedio;
calcularEstatus();
}

public String getStatus() {
return status;
}

@Override
public String toString() {
return String.format("%s\nNº Control: %d, Carrera: %s, Semestre: %d\nGrupo: %s, Promedio: %.2f, Status: %s",
super.toString(), numControl, carrera, semestre, grupo, promedio, status);
}

}
Con la clase Docente, ocurre algo similar. Tiene un atributo llamado sueldoBase cuyo valor no lo decide el usuario, si no que se autocalcula según las horas que trabaja.
Así que de nuevo usaremos un método privado para este cálculo, al que llamaremos al construir el objeto y cada vez que se cambie el valor de las horas en el método setHoras()
public class Docente extends Persona {

private String idEmpleado;
    private String academia;
    private int horas;
    private float sueldoBase;
    private char nivel;
   
public Docente(String nombre, int edad, char sexo, String curp, String domicilio, String idEmpleado,
String academia, int horas, char nivel) {
super(nombre, edad, sexo, curp, domicilio);
this.idEmpleado = idEmpleado;
this.academia = academia;
this.horas = horas;
this.nivel = nivel;
calcularSueldo();
}

private void calcularSueldo() {
sueldoBase=(float) (horas*33*.85*8*15);
    }

public String getIdEmpleado() {
return idEmpleado;
}

public void setIdEmpleado(String idEmpleado) {
this.idEmpleado = idEmpleado;
}

public String getAcademia() {
return academia;
}

public void setAcademia(String academia) {
this.academia = academia;
}

public int getHoras() {
return horas;
}

public void setHoras(int horas) {
this.horas = horas;
calcularSueldo();
}

public float getSueldoBase() {
return sueldoBase;
}

public char getNivel() {
return nivel;
}

public void setNivel(char nivel) {
this.nivel = nivel;
}
   
    @Override
    public String toString() {
    return String.format("%s\nID Emp.: %s, Academia: %s, Horas: %d\nSueldo: %.2f, Nivel: %s",
    super.toString(), idEmpleado, academia, horas, sueldoBase, nivel);
    }
}

Vale, tendríamos modeladas las entidades principales que actúan en este programa.
Ahora necesitamos una forma de gestionarlas, es decir, registrarlas en algún tipo de colección y que luego se pueda consultar.
En el código que has puesto, parece que se intenta usar un arreglo primitivo, pero con error en su sintaxis.
De todos modos, no es el tipo de colección ideal porque hay que establecerle un tamaño fijo que luego no puede aumentarse.

Es mejor usar un ArrayList, que tiene un tamaño dinámico y puede crecer según se van añadiendo objetos.

De hecho, usaremos dos, uno para Alumnos y otro para Docentes.
Habrá que escribir código para todo lo relativo a la gestión de estos datos y también código para escribir un menú en pantalla, capturar opción escogida, etc...
Se puede hacer todo junto en una sola clase.

O bien, separarlo en dos. Una clase exclusivamente para gestionar los dos ArrayList y la otra exclusivamente para encargarse del menú principal.

Yo prefiero esta última opción y esta podría ser la clase "gestora" de datos:
import java.util.ArrayList;

import javax.swing.JOptionPane;

public class GestionDatos {

private ArrayList<Alumno> alumnos = new ArrayList<Alumno>();
private ArrayList<Docente> docentes = new ArrayList<Docente>();

public void registrarAlumno() {
String nombre = JOptionPane.showInputDialog("Nombre:");
int edad = Integer.parseInt(JOptionPane.showInputDialog("Edad:"));
char sexo = JOptionPane.showInputDialog("Sexo: ").charAt(0);
String curp = JOptionPane.showInputDialog("CURP:");
String domicilio = JOptionPane.showInputDialog("Domicilio:");
int nControl = Integer.parseInt(JOptionPane.showInputDialog("Nº Control:"));
String carrera = JOptionPane.showInputDialog("Carrera:");
int semestre = Integer.parseInt(JOptionPane.showInputDialog("Semestre:"));
char grupo = JOptionPane.showInputDialog("Grupo:").charAt(0);
float promedio = Float.parseFloat(JOptionPane.showInputDialog("Promedio:"));

alumnos.add(new Alumno(nombre, edad, sexo, curp, domicilio, nControl, carrera, semestre, grupo, promedio));

JOptionPane.showMessageDialog(null, "Nuevo Alumno registrado");
}

public void listarAlumnos() {
if (alumnos.isEmpty())
JOptionPane.showMessageDialog(null, "No hay Alumnos registrados");
else {
for (int i = 0; i < alumnos.size(); i++)
JOptionPane.showMessageDialog(null, alumnos.get(i),
String.format("Alumno %d/%d", (i+1), alumnos.size()), 1);
}
}

}¡¡NO ESTÁ TERMINADA!!
Solo he puesto lo necesario para registrar Alumnos y también poder listar los que ya están registrados.
Luego intenta por tu parte, añadir dos métodos más registrar y listar Docentes. Casi es copiar lo que yo he puesto.

Veamos ahora la clase principal, usaremos un menú hecho con JOptionPane, tal y como se hace en el código que tú has puesto antes.
Su principal atributo, será un objeto de la clase "gestora" de datos

De momento, solo ofrecemos 5 opciones: registrar alumno, listarlos, registrar docentes, listarlos y TERMINAR.

Con un switch analizamos que ha pedido el usuario, y según su opción, llamamos al método adecuado de la clase "gestora".
Creo que es sencillo de entender el código.

public class Principal {

private static GestionDatos gestor = new GestionDatos();
private static final String MENU = "[1] -- Registrar Alumno\n[2] -- Registrar Docente"
+ "\n[3] -- Listar Alumnos\n[4] -- Listar Docentes\n[0] -- TERMINAR PROGRAMA";

public static void main(String[] args) {

String opcion = "";

do {
opcion = JOptionPane.showInputDialog(MENU);
switch(opcion) {
case "0":
JOptionPane.showMessageDialog(null, "FIN DE PROGRAMA");
break;
case "1":
gestor.registrarAlumno();
break;
case "2":
//gestor.registrarDocente();
break;
case "3":
gestor.listarAlumnos();
break;
case "4":
//gestor.listarDocentes();
break;
default:
JOptionPane.showMessageDialog(null, "Opcion equivocada");
}
}while(!opcion.equals("0"));

}

}
Pues como dije, intenta completar lo necesario para poder gestionar los Docentes.

Y cuando lo tengas, tú mismo intenta añadir más opciones, como modificar la nota promedio de un Alumno, o las horas que trabaja un Docente..., lo que se te ocurra.

Cuando te atasques, o si hay cosas que no te han quedado claras, vuelve a preguntar por aquí.
Un saludo.

Todo parece correcto, solo cambiaría dos detalles.

El modificador de acceso de los atributos, por norma general, siempre los vamos a declarar como private, no como public

public class Circulo {
    public static final double numeroPi = 3.1415;
    public double radio;

Habrá situaciones en que resulte más óptimo declararlos como public o como protected(algo a medio camino entre publico y privado).
Pero por lo general los declararemos como privados siempre, y luego si el desarrollo del programa lo exigiese, pues ya cambiaremos el nivel de acceso.


Otra cosa, si un método retorna un valor, pues seguramente no vamos a necesitar que sea el propio método quien lo muestren en pantalla.

    public double areaCirculo(){
        double area = 0.0;
        area = numeroPi * (radio * radio);
        System.out.println("El area es: " + area + " cm");
        return area;
    }

Y si vamos a hacer que el método lo imprima en pantalla, entonces cuando lo invoquemos en el programa principal, no conviene llamarlo dentro de un System.out.println()
System.out.println(circulo.areaCirculo());Porque eso va a hacer que el valor del area salga en pantalla dos veces: una por el println() que ya tiene el propio método y otra porque el area retornada va a ser impresa por el println() del programa principal.

Si nuestro método ya incorpora un println(), basta con invocarlo directamente en el programa principal, no hace falta ponerlo dentro de otro println()
circulo.areaCirculo();
Pero vamos, lo normal es que si el método retorna el valor, no tenga su propio println().

    public double areaCirculo(){
        double area = 0.0;
        area = numeroPi * (radio * radio);
        System.out.println("El area es: " + area + " cm");
        return area;
    }

 Si no que será el programa principal quien se ocupe de imprimir en pantalla el valor retornado:
System.out.println("El area es: " + circulo.areaCirculo() + " cm");

Espero haberme explicado bien y no haber liado más las cosas.
Como digo, son detalles, por lo demás el ejercicio parece correcto.
Un saludo.

Hola.
Tal y como he entendido el ejercicio (que quizás lo he entendido mal), usar recursividad aquí no parece lo más óptimo. Pero supongo que lo importante es entender la recursividad, sin importar si este es el mejor escenario para usarla.

A ver, para usar recursividad tenemos que usar una función. Y una función ha de retornar un valor.

Así que hay que pensar en que valor necesitamos retornar.
Tenemos una matriz y hay que indicar que compuerta es la segura. De hecho, puede haber más de una.
Las compuertas son posiciones de la matriz, así que se identifican con dos valores, es decir, dos índices: [0,3], [4,2], etc...

Bien, suponiendo que solo hubiera una compuerta sin coyote, ya tendríamos un problema porque la función solo puede retornar UN valor pero para identificar una compuerta hemos dicho que necesitamos DOS índices.
Lo podríamos solucionar retornando un arreglo de dos elementos, uno para cada índice.

Pero es que en realidad, puede haber más de una compuerta sin coyote, así que no sabemos si vamos a retornar DOS índices, o CUATRO, u OCHO, ...o CIEN MIL......
Así que no nos sirve la idea de retornar un arreglo.

Pero, siendo un poco listos, lo que podemos hacer es retornar un String. En ese String, se pueden ir concatenando las parejas de índices que identifiquen compuertas seguras.
De este modo en UN único valor (un String), podemos tener todos los índices que queramos.

Bien, ya hemos decidido que tipo de dato va a retornar la función recursiva. Ahora hay que decidir cuáles son los argumentos que (lo que va entre paréntesis) hay que aportar en cada llamada a la función.
Es decir, la función se va a ir llamando a sí misma un número indeterminado de veces y en cada llamada hay que aportarle unos argumentos para evaluar.

Un argumento está claro que será la matriz de "compuertas".

Para recorrer la matriz, va a necesitar dos índices, así que también le pasaremos dos valores int. Estos valores int, incrementarán su valor en cada llamada recursiva para que en cada iteración se compruebe una posición de la matriz distinta. Será parecido a cuando usamos dos bucles anidados para recorrer una matriz.

Otro argumento que hay que proporcionar, será el String donde se anoten las posiciones válidas. Este String ha de ir "viajando" en cada llamada recursiva para que se actualice su información en caso de encontrar una compuerta segura.

Ok, pues esta sería la "firma" de nuestra función, que yo la he llamado examinar():
private static String examinar(char[][] matriz, int i, int j, String seguras)Como hemos dicho, sus argumentos son la matriz, dos indices para recorrer la matriz y un String para apuntar las compuertas seguras.
Precisamente este String, será el que esta función retornará cuando finalice su proceso recursivo.

Vamos a pensar ahora en su código.
El código de una función recursiva, siempre tiene como mínimo dos sentencias RETURN.
Un return será una llamada recursiva a sí misma, prolongando su proceso.
El otro return, será el del valor final ya procesado, lo cuál pone fin a todo el proceso recursivo.

Hacer un return u otro, obviamente dependerá de si se cumplen unas condiciones u otras.

Yo por lo general, el código lo comienzo escribiendo las condiciones que van a poner fin al proceso recursivo.
¿Y cuáles son esas condiciones? ¿Cuándo queremos que el proceso termine?
Pues si el objetivo es recorrer la matriz de principio a fin, el proceso ha de terminar cuando ambos índices hayan alcanzado los límites de la matriz (longitud de la matriz - 1).
Para entonces ya no quedarán "compuertas" para comprobar y podremos retornar el String con la lista de compuertas seguras:
private static String examinar(char[][] matriz, int i, int j, String seguras) {
if (i == matriz.length - 1 && j == matriz.length - 1)//Ambos índices están en el límite
return seguras; //Ya se ha recorrido toda la matriz
else  {........
Sigamos, ¿y si aún quedan compuertas por comprobar?
Vale, pues entonces comprobamos si la compuerta actual, la que nos van a indicar los indices i y j, hay un coyote o no.

Si no hay coyote, entonces esta "compuerta" es segura y concatenamos su dirección en el String donde anotamos los índices de compuertas sin coyotes.
Si hay coyote, entonces no haremos nada, así que ni siquiera lo vamos a preguntar.

Con o sin coyote, una vez comprobada la compuerta hay que pasar a la siguiente, es decir, hay que incrementar los índices.
Lo haremos de forma análoga a como se haría si estuvieramos usando dos bucles anidados.
Comprobamos si el indice j se puede incrementar. Si está por debajo del límite de la matriz, se incrementa y listo.
Si está en el límite, entonces retoma valor 0 y es el índice i el que se incrementa

Tras esto, ya tenemos los índices actualizados y listos para pasar a la siguiente compuerta, es decir, hacemos una nueva llamada recursiva a la función, aportando todos los argumentos que han de acompañar esa llamada.
private static String examinar(char[][] matriz, int i, int j, String seguras) {
if (i == matriz.length - 1 && j == matriz.length - 1)//Ambos índices están en el límite
return seguras; //Ya se ha recorrido toda la matriz
else  {
//Comprobamos la compuerta actual
if (matriz[i][j] != 'C')  //Aquí NO hay coyote
seguras += String.format("[%s,%s]\n", i,j);//Añadimos esta posición a la lista de "seguras"

//Ahora incrementamos los índices, vigilando los límites de la matriz
if (j < matriz.length - 1)//Segundo índice está por debajo del límite
j++; //Se puede incrementar
else { //Segundo índice está en el límite
j = 0; //Vuelve a 0...
i++; //...y se incrementa el primer índice
}
//Índices actualizados, hacemos llamada recursiva
return examinar(matriz, i, j, seguras);
}
}

Pues ya tenemos la función recursiva. Ahora hay que ponerla a prueba.
Hacemos un método main, construimos una matriz y llamamos a nuestra función para que construya y retorne un String con las posiciones seguras.

Fíjate que al llamar la función en el programa, tenemos pasarle dos valores 0 para los índices (para que empiece desde el principio de la matriz) y una cadena String vacía que será donde se concatenen las posiciones de compuertas seguras:
public static void main(String[] args) {

char[][] compuertas = {
{'C', 'L', 'L', 'C', 'C'},
{'L', 'L', 'C', 'C', 'C'},
{'C', 'C', 'C', 'C', 'C'},
{'C', 'C', 'L', 'C', 'C'},
{'C', 'C', 'C', 'C', 'C'},
};

System.out.println("Lista de compuertas seguras:");
System.out.println(examinar(compuertas, 0, 0, ""));

}
Si lo ejecutamos, en pantalla veremos la lista de posiciones sin coyotes:

Lista de compuertas seguras:
[0,1]
[0,2]
[1,0]
[1,1]
[3,2]

Y eso es todo.
Repito que no se si he entendido bien el ejercicio, pero de todos modos, hemos creado un ejemplo de recursividad.
Espero que se haya entendido, pregunta lo que sea necesario.

Un saludo.

La variable entrada, ya es un int. Así que hacerle un parseInt() es innecesario, porque ya es un int.

int entrada = entradaScanner.nextInt();
       
        if (numero == Integer.parseInt(entrada)){

De todos modos, intentas comparar entrada, que es int, con numero que es de la clase adivinarNumero

No puedes compararlos, son cosas distintas. Aunque ambos sean valores numéricos, no se pueden comparar directamente porque están modelados de formas distintas.
entrada es un int primitivo, básicamente es un trocito de memoria RAM que ocupa 32 bit.
numero es un objeto adivinarNumero, al ser una clase POO, es algo mucho más complejo que una simple dirección de memoria reservada.
Por eso no se pueden comparar, al menos no directamente.

Parte del problema radica en que quizás estás buscando una solución más compleja de lo necesario.

El número secreto, o sea, el número que hay que adivinar, no tiene porque ser una clase POO.
Basta con que sea un simple int, igual que el número que ingresará el usuario. La diferencia es que uno va a proceder del teclado del usuario y el otro nos lo dará un objeto Random.

Esta podría ser la forma sencilla de solucionarlo. Añado algo importante que tú no habías puesto, un bucle que se repita hasta que el usuario haya acertado el número secreto:
public class AdivinarNumero {

public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
Random azar = new Random();
int numSecreto = azar.nextInt(100) + 1;
boolean acertado = false;

while(!acertado) {
System.out.print("Acierta un numero entre 1 y 100: ");
int numero = teclado.nextInt();

if (numero == numSecreto) {
System.out.println("Enhorabuena! Has acertado");
acertado = true; //Esto pondrá fin al bucle
}
else if (numero < numSecreto)
System.out.println("Fallaste! El numero es mayor");
else
System.out.println("Fallaste! El numero es menor");
}

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

}
Como ves, aquí no hay ningún problema en comparar los números, porque ambos son int.
Y con esto es suficiente.

Sin embargo, vamos a darle una vuelta de tuerca. Vamos a seguir tu planteamiento de hacer que el número "secreto", sea una clase POO.
Por ejemplo, esta:
public class NumeroSecreto {

private int secreto;

public NumeroSecreto() {
Random azar = new Random();
secreto = azar.nextInt(100) + 1;
}

public int getSecreto() {
return secreto;
}

}Al construir un objeto de esta clase, obtendremos un int con un valor generado por un Random.

Si lo aplicamos en el programa principal, ahora las comparaciones (marco en rojo) nos van a dar error:

public class AdivinarNumero {

   public static void main(String[] args) {
      Scanner teclado = new Scanner(System.in);

      NumeroSecreto numSecreto = new NumeroSecreto();
      boolean acertado = false;
      
      while(!acertado) {
         System.out.print("Acierta un numero entre 1 y 100: ");
         int numero = teclado.nextInt();
         
         if (numero == numSecreto) {
            System.out.println("Enhorabuena! Has acertado");
            acertado = true; //Esto pondrá fin al bucle
         }
         else if (numero < numSecreto)
            System.out.println("Fallaste! El numero es mayor");
         else
            System.out.println("Fallaste! El numero es menor");
      }

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

}

¿Por qué da error si el número secreto, en esencia, es un int?
Sí, el numero secreto es un atributo int, pero está "encapsulado" en una clase POO y eso hace que no se pueda comparar directamente con otros int.

Directamente no..., pero, hay otra forma.

Tú intentaste usar el método Integer.parseInt(). Bien, pues no sirve en este caso.
Este método solo puede convertir objetos String a Integer(int).
Pero no podemos pedirle que haga lo mismo con un objeto NumeroSecreto.

En realidad, no necesitamos ayuda externa. Nuestra clase NumeroSecreto ya tiene un método get() que nos puede retornar el atributo int que tenemos encapsulado.
Así que basta con invocar este método para poder comparar con "simples int".

public class AdivinarNumero {

   public static void main(String[] args) {
      Scanner teclado = new Scanner(System.in);

      NumeroSecreto numSecreto = new NumeroSecreto();
      boolean acertado = false;
      
      while(!acertado) {
         System.out.print("Acierta un numero entre 1 y 100: ");
         int numero = teclado.nextInt();
         
         if (numero == numSecreto.getSecreto()) {
            System.out.println("Enhorabuena! Has acertado");
            acertado = true; //Esto pondrá fin al bucle
         }
         else if (numero < numSecreto.getSecreto())
            System.out.println("Fallaste! El numero es mayor");
         else
            System.out.println("Fallaste! El numero es menor");
      }

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

}

Listo.
Espero haber aclarado tus dudas. Si no fuera así, no dejes de preguntar.
Un saludo.

Hola.
Necesitas dos ArrayList, uno para clase String donde guardar los nombres de clientes. Otro para clase Integer (o Double) donde guardan las compras.

Los clientes y sus compras quedan relacionados según la posición que ocupan en los ArrayList.

Es decir, si un cliente ocupa la posición número 4 en su ArrayList de String, pues sus compras estarán en la posición 4 del ArrayList de Integer.
Teniendo en cuenta esta relación, podemos cumplir las funcionalidades que se nos piden.


Mira, este podría ser el "esqueleto" del programa.
- Los dos ArrayList y un Scanner para recibir datos por consola.
- Un menú de opciones donde, con un switch, analizamos qué ha elegido el usuario y llamaremos al método que se ocupará de cumplir esa función
- Y los cuatro métodos para dichas funcionalidades.

import java.util.ArrayList;
import java.util.Scanner;

public class RegistroCompras {

private static ArrayList<String> clientes = new ArrayList<String>();
private static ArrayList<Integer> compras = new ArrayList<Integer>();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

do {
System.out.println("\n\n\t\tREGISTRO DE COMPRAS");
System.out.println("\t\t-------- -- -------\n");
System.out.println("[1] - Registrar cliente y su compra");
System.out.println("[2] - Listar clientes y sus compras");
System.out.println("[3] - Consultar la compra de un cliente");
System.out.println("[4] - Eliminar un cliente");
System.out.println("[9] - FIN DE PROGRAMA");
System.out.print("Opcion: ");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
registrarCliente();
break;
case 2:
mostrarListado();
break;
case 3:
buscarCliente();
break;
case 4:
eliminarCliente();
break;
case 9:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("Opcion equivocada");
}
}while(opcion != 9);


}

private static void registrarCliente( ) {

}

private static void mostrarListado() {

}

private static void buscarCliente() {

}

private static void eliminarCliente() {

}

}
Falta el código de los métodos, que es lo que realmente importa.

Bien, vamos a escribir el primer método, que es muy sencillo, es pedir un nombre y un valor de compra, y guardarlos en los correspondientes ArrayList:
private static void registrarCliente( ) {
System.out.print("\nNombre Cliente: ");
clientes.add(teclado.nextLine());
System.out.print("Valor de compra: ");
compras.add(Integer.parseInt(teclado.nextLine()));
}Listo, solo se necesitan esas 4 líneas. No tiene ningún misterio.

Vamos a ver otro método más interesante, el de buscar un cliente y mostrar su compra.
Aquí si que tenemos que poner en práctica la forma de relacionar un dato con el otro.
Pediremos el nombre de un cliente, lo buscaremos en el ArrayList para conocer que posición ocupa.
Sabiendo esa posición, podremos encontrar el valor de su compra en el otro ArrayList:
private static void buscarCliente() {
if (clientes.isEmpty())
System.out.println("\nNo hay clientes registrados");
else {
System.out.print("\nNombre Cliente: ");
int posicion = clientes.indexOf(teclado.nextLine());
if (posicion == -1)
System.out.println("No hay cliente con ese nombre");
else
System.out.println("Valor de compra: " + compras.get(posicion));
}
}Como ves, tampoco se requiere un código complicado.
La clave es obtener la posición del cliente, esto nos los da el propio ArrayList invocando a su método indexOf().
Si el nombre que damos para buscar no existe, nos retorna el valor -1.
Si existe, entonces si obtendremos la posición que nos sirve para encontrar la compra que le corresponde a dicho cliente.

Intenta tú completar los otros dos métodos que faltan.
Si te atascas o algo no entiendes, pregunta por aquí.

Un saludo.

Claro, ese objeto vehículo1 lo estás creando en el case 1.

Pero ese case, puede que ocurra o que no ocurra..., por tanto si ocurre un case 2, sin que previamente haya ocurrido un case 1, estarías haciendo referencia a un objeto que no ha sido creado.

Para evitar esto, puedes declarar ese objeto antes de comience el switch, aunque sea con valor null.
Ya luego, si ocurre un case 1, no lo declaras de nuevo. Solamente has de construir un nuevo objeto usando la misma referencia.

Y en el case 2, ya no habrá problemas para comprobar si esa referencia tiene valor null o no, porque la existencia de esa referencia ahora está garantizada. No va a depender de que ocurra un case 1 previamente.

        do {
            System.out.println("1. Generar vehículo");
            System.out.println("2. Mostrar datos");
            System.out.println("3. Calcular beneficio");
            System.out.println("4. Salir");

            try {
                System.out.println("Escoge la opcion:");
                opcionMenu = teclado.nextInt();
                Vehiculo Vehiculo1 = null;

                switch (opcionMenu) {
                    case 1:
                        Vehiculo1 = new Vehiculo("1234ABC", "Seat", 1000);
                        System.out.println(Vehiculo1.toString());
                        break;
                    case 2:
                        if (Vehiculo1 == null) {  \\\ AQUÍ TENGO EL PROBLEMA
                            System.out.println("No has creado el vehiculo");
                        }

                        break;
                    case 3:

                        break;
                    case 4:
                        salir = true;
                        break;
                    default:
                        System.out.println("Tienes que introducir un valor entre 1 y 4");
                }
            } catch (InputMismatchException e) {
                System.out.println("Tienes que introducir un valor entre 1 y 4");
                teclado.next(); // volvemos a activar la entrada de teclado aqui. si no entramos en bucle
            }

        } while (!salir);

Buenas.

Es más intuitivo de lo que parece.
Veamos, un atributo sería la clase SistemaOperativo, que podría ser esta:
public class SistemaOperativo {

private String tipo;
private int version;

public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
this.tipo = tipo;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}

}

Y luego dos atributos para la camara delantera y para la trasera, que como sus atributos son los mismos, no hace falta escribir dos clases, nos bastaría con una sola clase Camara
public class Camara {

private int resolucion;
private int numCamaras;
private boolean estabilidador;

public int getResolucion() {
return resolucion;
}

public void setResolucion(int resolucion) {
this.resolucion = resolucion;
}

public int getNumCamaras() {
return numCamaras;
}

public void setNumCamaras(int numCamaras) {
this.numCamaras = numCamaras;
}

public boolean tieneEstabilidador() {
return estabilidador;
}

public void setEstabilidador(boolean estabilidador) {
this.estabilidador = estabilidador;
}

}
Fíjate que a estas clases no les he puesto constructor. Podríamos ponérselos, pero para este ejemplo no será necesario (aunque esto va un poco a gusto del programador)

El caso es que ahora hay que crear la clase Movil con estos objetos como atributos:
public class Movil {

private SistemaOperativo so;
private Camara camDelantera;
private Camara camTrasera;


}
No está completa, falta constructor y métodos get/set. Y es que aquí es cuando hay que parase a pensar que es lo que podemos necesitar.
Podemos hacer un constructor que reciba TODOS los parámetros necesarios para dar valores a todos los objetos que componen este teléfono móvil. Así que iremos construyendo cada atributo y les seteamos sus valores
public class Movil {

private SistemaOperativo so;
private Camara camDelantera;
private Camara camTrasera;

public Movil(String tipoSo, int version, int resolCamDelan, int numCamDelan, boolean estabilDelan,
int resolCamTras, int numCamTras, boolean estabilTras) {
//Construimos SO
so = new SistemaOperativo();
so.setTipo(tipoSo);
so.setVersion(version);
//Construimos camara delantera
camDelantera = new Camara();
camDelantera.setResolucion(resolCamDelan);
camDelantera.setNumCamaras(numCamDelan);
camDelantera.setEstabilidador(estabilDelan);
//Construimos la trasera
camTrasera = new Camara();
camTrasera.setResolucion(resolCamTras);
camTrasera.setNumCamaras(numCamTras);
camTrasera.setEstabilidador(estabilTras);
}

}
Pero puede que no siempre vayamos a querer usar un constructor al que haya que pasarle taaaantos parámetros.
Así que podemos darle un segundo constructor a nuestra clase, un constructor "por defecto" el cuál no recibe ningún parámetro.
Simplemente construimos los atributos sin darles valores, con la idea de que ya luego en el programa donde se utilice nuestra clase, ya le darán esos valores con unos setters.
public class Movil {

private SistemaOperativo so;
private Camara camDelantera;
private Camara camTrasera;

//Constructor que recibe valores
public Movil(String tipoSo, int version, int resolCamDelan, int numCamDelan, boolean estabilDelan,
int resolCamTras, int numCamTras, boolean estabilTras) {
//Construimos SO
so = new SistemaOperativo();
so.setTipo(tipoSo);
so.setVersion(version);
//Construimos camara delantera
camDelantera = new Camara();
camDelantera.setResolucion(resolCamDelan);
camDelantera.setNumCamaras(numCamDelan);
camDelantera.setEstabilidador(estabilDelan);
//Construimos la trasera
camTrasera = new Camara();
camTrasera.setResolucion(resolCamTras);
camTrasera.setNumCamaras(numCamTras);
camTrasera.setEstabilidador(estabilTras);
}

//Constructor que no recibe valores.
public Movil() {
so = new SistemaOperativo();
camDelantera = new Camara();
camTrasera = new Camara();
}

}

Y ahora, unos getters/setters.
public class Movil {

private SistemaOperativo so;
private Camara camDelantera;
private Camara camTrasera;

//Constructor que recibe valores
public Movil(String tipoSo, int version, int resolCamDelan, int numCamDelan, boolean estabilDelan,
int resolCamTras, int numCamTras, boolean estabilTras) {
//Construimos SO
so = new SistemaOperativo();
so.setTipo(tipoSo);
so.setVersion(version);
//Construimos camara delantera
camDelantera = new Camara();
camDelantera.setResolucion(resolCamDelan);
camDelantera.setNumCamaras(numCamDelan);
camDelantera.setEstabilidador(estabilDelan);
//Construimos la trasera
camTrasera = new Camara();
camTrasera.setResolucion(resolCamTras);
camTrasera.setNumCamaras(numCamTras);
camTrasera.setEstabilidador(estabilTras);
}

//Constructor que no recibe valores.
public Movil() {
so = new SistemaOperativo();
camDelantera = new Camara();
camTrasera = new Camara();
}

public SistemaOperativo getSo() {
return so;
}

public void setSo(SistemaOperativo so) {
this.so = so;
}

public Camara getCamDelantera() {
return camDelantera;
}

public void setCamDelantera(Camara camDelantera) {
this.camDelantera = camDelantera;
}

public Camara getCamTrasera() {
return camTrasera;
}

public void setCamTrasera(Camara camTrasera) {
this.camTrasera = camTrasera;
}

}
Hay que tener en cuenta que estos getters/setters trabajan también con objetos. Es decir, si quiero obtener la versión de sistema operativo de un móvil, tendré que pedirle al móvili que me retorne su so, y a este so pedirle que me retorne su versión.

Por ejemplo, si ejecutamos este programa de prueba:
public class Prueba {

public static void main(String[] args) {

Movil miMovil = new Movil("Android", 13, 600, 3, true, 400, 2, false);

System.out.println("Tipo de SO: " + miMovil.getSo().getTipo());
System.out.println("Versión: " + miMovil.getSo().getVersion());

}

}
En pantalla obtendremos los datos que hemos buscado:
Tipo de SO: Android
Versión: 13

Y bueno, creo que con esto queda explicado.
Si tuvieras más dudas, solo tienes que preguntar.

Un saludo.

Comencemos creando las interfaces, por ejemplo IOperacionEmpleado
public interface IOperacionEmpleado {

public Empleado crearEmpleado();

public void listarEmpleados();

public void consultarEmpleado();

public void calcularSueldoEmpleado();

}
Fíjate que al ser una interfaz, no incluye código. Solo se pone "la firma" de los métodos, es decir, nombre de los métodos, tipo que retorna y, si fuera necesario, los parámetros a recibir entre paréntesis.

Lo mismo con la interface IOperacionEmpresa.
En esta ocasión, el método asignarEmpleado() probablemente necesitaremos recibir como parámetro el Empleado que hay que asignar.
public interface IOperacionEmpresa {

public void crearEmpresa();

public void asignarEmpleado(Empleado emp);

public void listarEmpresas();

public void contarEmpleadosdeEmpresa();
}
Vamos a ver ahora las clases que van a implementar estas interfaces.
Empecemos por la clase OperacionEmpleado, la cuál tendrá un ArrayList donde guardar los empleados que el usuario vaya creando.
Al indicarle a esta clase que ha de implementar la interface que hemos escrito antes, automáticamente se nos "obliga" a sobreescribir los métodos de dicha interfaz.
import java.util.ArrayList;

public class OperacionEmpleado implements IOperacionEmpleado {

private ArrayList<Empleado> empleados = new ArrayList<Empleado>();

@Override
public Empleado crearEmpleado() {

}

@Override
public void listarEmpleados() {

}

@Override
public void consultarEmpleado(String documento) {

}

@Override
public void calcularSueldoEmpleado(String documento, int horasTrabajadas) {

}

}
Es aquí, ahora, donde hay que escribir el código para que cada uno de estos métodos funcionen.

import java.util.ArrayList;

import javax.swing.JOptionPane;

public class OperacionEmpleado implements IOperacionEmpleado {

private ArrayList<Empleado> empleados = new ArrayList<Empleado>();

@Override
public Empleado crearEmpleado() {
//Preguntamos que tipo empleado se va a crear
int tipo = JOptionPane.showOptionDialog(null, "Elija tipo de Empleado quiere crear",
"Crear Empleado", 0, 3, null,
new String[] {"Admin", "Desarrollador", "Gestor Proyectos"}, null);
//Pedimos datos del empleado
String documento = JOptionPane.showInputDialog(null, "Documento:", "Crear Empleado", 3);
String nombre = JOptionPane.showInputDialog(null, "Nombre:", "Crear Empleado", 3);
double sueldoHora = Double.parseDouble(JOptionPane.showInputDialog(null,
"Sueldo x Hora:", "Crear Empleado", 3));
//Comprobamos elección para determinar que empleado hay que crear
switch(tipo) {
case 0: //Admin
Admin admin = new Admin(documento, nombre, sueldoHora);
empleados.add(admin);
return admin;
case 1: //Desarrollador
Desarrollador desarr = new Desarrollador(documento, nombre, sueldoHora);
empleados.add(desarr);
return desarr;
case 2: //Gestor de proyectos, requiere pedir otro dato
String area = JOptionPane.showInputDialog(null, "Area:", "Crear Empleado", 3);
GestorProyectos gesPro = new GestorProyectos(documento, nombre, sueldoHora, area);
empleados.add(gesPro);
return gesPro;
default:
return null;
}
}

@Override
public void listarEmpleados() {
JOptionPane.showMessageDialog(null, "Se mostrará un listado en la consola",
"Listar Empleados", 1);
System.out.println("\n\t\tLISTA EMPLEADOS");
System.out.println("\t\t----- ---------\n");
for (Empleado emp: empleados)
System.out.println(emp);
}

@Override
public void consultarEmpleado() {
String documento = JOptionPane.showInputDialog(null, "Documento del empleado:", "Consultar Empleado", 3);
//Buscamos el empleado
Empleado buscar = null;
for (Empleado emp: empleados)
if (emp.getDocumento().equals(documento))
buscar = emp;
//Comprobamos si lo hemos encontrado
if (buscar == null)
JOptionPane.showMessageDialog(null, "No hay ningún empleado con ese documento",
"Consultar Empleado", 0);
else
JOptionPane.showMessageDialog(null, buscar,
"Listar Empleados", 1);
}

@Override
public void calcularSueldoEmpleado() {
String documento = JOptionPane.showInputDialog(null, "Documento del empleado:", "Calcular Sueldo", 3);
int horas = Integer.parseInt(JOptionPane.showInputDialog(null, "Horas trabajadas:", "Calcular Sueldo", 3));
//Buscamos empleado
Empleado buscar = null;
for (Empleado emp: empleados)
if (emp.getDocumento().equals(documento))
buscar = emp;
//Comprobamos si lo hemos encontrado
if (buscar == null)
JOptionPane.showMessageDialog(null, "No hay ningún empleado con ese documento",
"Calcular Sueldo", 0);
else {
double calculo = buscar.getSueldoHora() * horas;
JOptionPane.showMessageDialog(null,String.format("Sueldo: %.2f", calculo),
"Calcular Sueldo", 1);
}
}

}
Lo mismo con la clase OperacionEmpresa, implementamos la interfaz y escribimos el código para los métodos.
La clase cuenta con su ArrayList para guardar empresas.
import java.util.ArrayList;

import javax.swing.JOptionPane;

public class OperacionEmpresa implements IOperacionEmpresa {

private ArrayList<Empresa> empresas = new ArrayList<Empresa>();

@Override
public void crearEmpresa() {
String nit = JOptionPane.showInputDialog(null, "NIT:", "Crear Empresa", 3);
String nombre = JOptionPane.showInputDialog(null, "Nombre:", "Crear Empresa", 3);
String direc = JOptionPane.showInputDialog(null, "Direccion:", "Crear Empresa", 3);
String ciudad = JOptionPane.showInputDialog(null, "Ciudad:", "Crear Empresa", 3);

empresas.add(new EmpresaDesarrollo(nit, nombre, direc, ciudad));

}

@Override
public void asignarEmpleado(Empleado emp) {
String nit = JOptionPane.showInputDialog(null, "Indique NIT de la empresa:", "Asignar Empleado", 3);
//Buscamos empresa
Empresa buscar = null;
for (Empresa empre: empresas)
if (empre.getNit().equals(nit))
buscar = empre;
//Comprobamos
if (buscar == null)
JOptionPane.showMessageDialog(null, "No hay empresas con ese NIT", "Asignar Empleado", 0, null);
else {
buscar.asignarEmpleado(emp);
JOptionPane.showMessageDialog(null, "Empleado asignado", "Asignar Empleado", 1, null);
}
}

@Override
public void listarEmpresas() {
JOptionPane.showMessageDialog(null, "Se mostrará un listado en la consola", "Listar Empresas", 1, null);
System.out.println("\n\t\tLISTA EMPRESAS");
System.out.println("\t\t----- --------\n");
for (Empresa empre: empresas)
System.out.println(empre);
}

@Override
public void contarEmpleadosdeEmpresa() {
String nit = JOptionPane.showInputDialog(null, "Indique NIT de la empresa:", "Contar Empleados", 3);
//Buscamos empresa
Empresa buscar = null;
for (Empresa empre: empresas)
if (empre.getNit().equals(nit))
buscar = empre;
//Comprobamos
if (buscar == null)
JOptionPane.showMessageDialog(null, "No hay empresas con ese NIT", "Contar Empleados", 0, null);
else
JOptionPane.showMessageDialog(null,
String.format("Empleados contados: %d", buscar.contarEmpleados()), "Contar Empleados", 1, null);
}

}
Y con esto ya podemos crear la clase Main.

Usamos tu menú, habrá que añadir objetos de las clases OperacionEmpleado y OperacionEmpresa y ya prácticamente solo será necesario invocar a los métodos necesarios para cada opción:

public class Main {

private static OperacionEmpleado empleados = new OperacionEmpleado();
private static OperacionEmpresa empresas = new OperacionEmpresa();

public static void main(String[] args) {
int op = 0;
        String menu = "Bienvenido, por favor ingrese la información solicitada: \n";
        menu += "1. Ingresar Empresa: \n";
        menu += "2. Ingresar datos del Empleado\n";
        menu += "3. Consular información del Empleado: \n";
        menu += "4. Consultar todas las empresas: \n";
        menu += "5. Consultar todos los empleados: \n";
        menu += "6. Calcular sueldo de empleado: \n";
        menu += "7. Cantidad de empleados en la empresa: \n";
        menu += "8. Salir \n";
        menu += "Selecciona una de las opciones del menú \n";
        do {
            op = Integer.parseInt(JOptionPane.showInputDialog(menu));
            switch (op) {
                case 1:
                empresas.crearEmpresa();
                    break;
                case 2:
                //Creamos empleado y lo recogemos
                Empleado emp = empleados.crearEmpleado();
                //Y ahora lo asignaremos a una empresa
                empresas.asignarEmpleado(emp);
                    break;
                case 3:
                empleados.consultarEmpleado();
                    break;
                case 4:
                empresas.listarEmpresas();
                    break;
                case 5:
                empleados.listarEmpleados();
                    break;
                case 6:
                empleados.calcularSueldoEmpleado();
                    break;
                case 7:
                empresas.contarEmpleadosdeEmpresa();
            }
        } while (op != 8);
    }

}
Pruébalo, y pregunta lo que no entiendas.
Un saludo.