Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - Kabuto

Páginas: 1 ... 8 9 10 11 12 [13] 14 15 16 17 18 ... 50
241
De todo un poco... / Re: Me pdrian ayudar con este problema
« en: 09 de Marzo 2022, 12:14 »
Hola, primero necesitamos una clase Estudiante con algunos atributos, al menos los necesarios para cumplir con las gestiones que se solicitan:
Código: [Seleccionar]
public class Estudiante {

private String nombre;
private String apellidos;
private char sexo; //H hombre, M mujer
private int calificacion;

public Estudiante(String nombre, String apellidos, char sexo, int calificacion) {
this.nombre = nombre;
this.apellidos = apellidos;
this.sexo = sexo;
this.calificacion = calificacion;
}

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 char getSexo() {
return sexo;
}
public void setSexo(char sexo) {
this.sexo = sexo;
}
public int getCalificacion() {
return calificacion;
}
public void setCalificacion(int calificacion) {
this.calificacion = calificacion;
}

@Override
public String toString() {
return String.format("Nombre: %s %s , Calificacion: %d", nombre, apellidos, calificacion);
}

}

Una clase Maestro, la cuál entre sus atributos va a tener un objeto que será una lista inmutable, cuya clase escribiremos después.
Esa lista ha de tener un tamaño determinado, así que lo indicaremos en el constructor:
Código: [Seleccionar]
public class Maestro {

private String nombre;
private String apellidos;
private ListaDelMaestro listaEstudiantes;

public Maestro(String nombre, String apellidos, int nEstudiantes) {
this.nombre = nombre;
this.apellidos = apellidos;
listaEstudiantes = new ListaDelMaestro(nEstudiantes);
}

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 ListaDelMaestro getListaAlumnos() {
return listaEstudiantes;
}

public void setListaAlumnos(ListaDelMaestro listaEstudiantes) {
this.listaEstudiantes = listaEstudiantes;
}

}

Y ahora la clase ListaDelMaestro.
Esta clase será un arreglo de objetos Estudiante con el tamaño indicado.
Tendrá una serie de métodos para poder hacer todo lo que se pide: agregarEstudiante, hacer una lista de aprobados, etc..

Para poder saber hasta cuál posición del arreglo hay estudiantes registrados o no, usaremos un "indice", una variable int que comienza a 0 y va incrementando su valor cada vez que se agrega un estudiante.
Código: [Seleccionar]
public class ListaDelMaestro {

private Estudiante[] lista;
private int indice; //Este indice nos dice hasta que posicion hay estudiantes en el arreglo

public ListaDelMaestro(int nEstudiantes) {
lista = new Estudiante[nEstudiantes];
indice = 0;
}

public void agregarEstudianteFinal(Estudiante estu) {
if (indice == lista.length)
System.out.println("No se pudo agregar, la lista esta completa.");
else {
lista[indice] = estu;
indice++;
System.out.println("Estudiante agregado");
}
}

public void reemplazarEstudiante(Estudiante estu, int posicion) {
if (posicion >= lista.length)
System.out.println("Posicion fuera de rango");
else if (posicion < indice) {
lista[indice] = estu;
System.out.println("Estudiante reemplazado");
}
else
System.out.println("No hay Estudiante para reemplazar en la posicion indicada");
}

public Estudiante getPrimeroLista() {
if (indice == 0) {
System.out.println("La lista esta vacía");
return null;
}
else
return lista[0];
}

public Estudiante getUltimoLista() {
if (indice == 0) {
System.out.println("La lista esta vacía");
return null;
}
else
return lista[indice-1];
}

public Estudiante[] getListaHombres() {

}

public Estudiante[] getListaMujeres() {

}

public Estudiante[] getListaAprobados() {

}

public Estudiante[] getListaReprobados() {

}

public Estudiante[] getListaApellidosEmpiezan(char letra) {

}

public Estudiante[] getListaNombresEmpiezan(char letra) {

}
}

No he escrito el código de todos los métodos, tendrás que intentar escribirlos tú para completar esta clase.
Inténtalo y si no lo consigues, comparte por aquí lo que hayas conseguido y te ayudamos a completar.

Por último, hace falta una clase principal, donde crearemos un Maestro y ofreceremos un menú de opciones para que el usuario pueda gestionar la lista.
En el menú, pedimos una opcion, la evaluamos con switch, y llamaremos a distintos métodos para hacer lo que se pide.

Te pongo un ejemplo también sin terminar, de nuevo, intenta completarlo y pídenos ayuda cuando no puedas avanzar.
Un saludo.

Código: [Seleccionar]
import java.util.Scanner;

public class Main {

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

public static void main(String[] args) {
//Construimos un Maestro, indicando nombre y cuantos Estudiantes tendrá su lista
maestro = new Maestro("Francisco", "Sanchez", 24);

int opcion = 0;
//Menu opciones
do {
System.out.println("\n\t\tMENU DEL MAESTRO");
System.out.println("\t\t---- --- -------\n");
System.out.println("[1] - Agregar Estudiante a la Lista");
System.out.println("[2] - Reemplazar Estudiante en una posicion");
System.out.println("[3] - Regresar primero de la Lista");
System.out.println("[4] - Regresar ultimo de la Lista");
System.out.println("[5] - Obtener Lista de Hombres");
System.out.println("[6] - Obtener Lista de Mujeres");
System.out.println("[7] - Obtener Lista de Aprobados");
System.out.println("[8] - Obtener Lista de Reprobados");
System.out.println("[9] - Obtener Lista de Apellidos que empiezan por una letra");
System.out.println("[10] - Obtener Lista de Nombres que empiezan por una letra");
System.out.println("\t\t---------");
System.out.println("[0] - TERMINAR PROGRAMA");
System.out.print("\nOpcion:");
opcion = Integer.parseInt(teclado.nextLine());
switch(opcion) {
case 0:
System.out.println("\n\tFIN DE PROGRAMA");
break;
case 1:
agregarEstudiante();
break;
case 2:
reemplazarEstudiante();
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
case 10:
break;
}

}while(opcion != 0);
}

private static void agregarEstudiante() {
//Pedimos datos para construir un estudiante
System.out.println("\nNUEVO ESTUDIANTE\n");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Sexo(H/M): ");
char sexo = teclado.nextLine().toUpperCase().charAt(0);
System.out.print("Calificacion(0/10): ");
int califi = Integer.parseInt(teclado.nextLine());

//Agregamos a la lista
maestro.getListaAlumnos().agregarEstudianteFinal(new Estudiante(nombre, apellidos, sexo, califi));

}

private static void reemplazarEstudiante() {
System.out.println("\nREEMPLAZAR ESTUDIANTE\n");
System.out.println("Datos del nuevo estudiante:");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Sexo(H/M): ");
char sexo = teclado.nextLine().toUpperCase().charAt(0);
System.out.print("Calificacion(0/10): ");
int califi = Integer.parseInt(teclado.nextLine());

System.out.print("\nPosicion de la lista donde emplazarlo: ");
int posicion = Integer.parseInt(teclado.nextLine());

maestro.getListaAlumnos().reemplazarEstudiante(new Estudiante(nombre, apellidos, sexo, califi), posicion);
}

}

242
Buenas.

Es más intuitivo de lo que parece.
Veamos, un atributo sería la clase SistemaOperativo, que podría ser esta:
Código: [Seleccionar]
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
Código: [Seleccionar]
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:
Código: [Seleccionar]
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
Código: [Seleccionar]
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.
Código: [Seleccionar]
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.
Código: [Seleccionar]
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:
Código: [Seleccionar]
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:
Código: [Seleccionar]
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.

243
La idea es gestionar un mismo material (libros) de dos formas distintas, y con atributos distintos, según si se está funcionando como una biblioteca o como un tienda de libros.
El programa ha de ser ambivalente para ambas situaciones.

Bien, ya ha escrito la clase básica Material
Esta clase, va a tener dos hijas, una para los libros de tienda y otros para los libros de la biblioteca.
Esta podría ser la clase LibroTienda, que añade el atributo para el precio de venta, el cuál se puede proporcionar como parámetro del constructor
Código: [Seleccionar]
public class LibroTienda extends Material {

private double precioVenta;

public LibroTienda(String isbn, String nombre, String autor, double precioVenta) {
super(isbn, nombre, autor);
this.precioVenta = precioVenta;
}

public double getPrecioVenta() {
return precioVenta;
}

public void setPrecioVenta(double precioVenta) {
this.precioVenta = precioVenta;
}

}

Y esta la clase LibroBiblioteca, con dos atributos nuevos para los días que lleva prestado y el valor de multa para un posible retraso en su devolución.
Dichos atributos, parece lógico que se inicialicen a 0 al construir el libro.
Código: [Seleccionar]
public class LibroBiblioteca extends Material {

private int diasPrestamo;
private double valorMulta;

public LibroBiblioteca(String isbn, String nombre, String autor) {
super(isbn, nombre, autor);
diasPrestamo = 0;
valorMulta = 0d;
}

public int getDiasPrestamo() {
return diasPrestamo;
}

public void setDiasPrestamo(int diasPrestamo) {
this.diasPrestamo = diasPrestamo;
}

public double getValorMulta() {
return valorMulta;
}

public void setValorMulta(double valorMulta) {
this.valorMulta = valorMulta;
}

}

Bien, tenemos los dos tipos de material/libros.
Ahora hay que hacer que el programa pueda gestionar de dos formas distintas.
Para ello haremos otras dos clases, cada una enfocada a distinto tipo de negocio.
A pesar de ser negocios distintos, van a tener dos funciones básicas con el mismo nombre: transacción y cambios.

Es aquí donde podemos crear una interfaz, para indicar que esas dos clases han de tener esas dos funciones, aunque su comportamiento será distinto en cada una.
Esa interfaz es tan simple como esto:
Código: [Seleccionar]
public interface IOperarMaterial {

public void cambios();
public void transaccion();

}

Esta interfaz, la implementarán las clases que modelan los distintos tipos de negocio.
Una clase para el negocio de la tienda librería:
Código: [Seleccionar]
import java.util.ArrayList;

public class OperarLibreria implements IOperarMaterial {

private ArrayList<LibroTienda> libros = new ArrayList<LibroTienda>();

@Override
public void cambios() {
// TODO Codigo para que la tienda cambie un libro vendido por otro
//Se debe informar la fecha del cambio y el nombre del nuevo libro por el que fue cambiado.

}

@Override
public void transaccion() {
// TODO Codigo para vender un libro

}


}

Y otra para el negocio de la biblioteca:
Código: [Seleccionar]
import java.util.ArrayList;

public class OperarBiblioteca implements IOperarMaterial {

private ArrayList<LibroBiblioteca> libros = new ArrayList<LibroBiblioteca>();

@Override
public void cambios() {
// TODO Código para hacer la devolución de un libro prestado
//mostrar la fecha de la devolución del libro.

}

@Override
public void transaccion() {
// Codigo para realizar un préstamo a un usuario

}


}

Estas clases, no están terminadas. Intenta escribir el código de cada método, según cada caso.
Por ejemplo para que la tienda venda un libro (transacción) tendrá que preguntar que libro se va a vender, eliminarlo del ArrayList y mostrar en pantalla el precio de venta a modo de factura.

Cuanto tengas esas clases terminadas, ya lo último es crear la clase principal, con dos objetos como atributos para los dos tipos de negocio.
Y mostrar un menú, por ejemplo que empiece preguntando si se quiere operar como libreria o como biblioteca.
Y luego preguntar si se quiere hacer una transaccion o un cambio.
Y ya entonces pedirle al objeto correspondiente (libreria o bliblioteca) que invoquen a sus métodos según lo que haya elegido el usuario.
Código: [Seleccionar]
public class Main {

private static OperarLibreria libreria = new OperarLibreria();
private static OperarBiblioteca biblioteca = new OperarBiblioteca();

public static void main(String[] args) {
// TODO Menu para elebir entre modelo de negocio y preguntar
//que operacion se quiere realizar

}

}

Intenta terminar tú todas estas clases, si no lo consigues, muestra por aquí lo que tengas y te ayudamos a completarlo.

Un saludo.

244
Comencemos creando las interfaces, por ejemplo IOperacionEmpleado
Código: [Seleccionar]
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.
Código: [Seleccionar]
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.
Código: [Seleccionar]
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.

Código: [Seleccionar]
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.
Código: [Seleccionar]
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:

Código: [Seleccionar]
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.


245
OK, a ver, para meternos en contexto.
Esta podría ser la clase Empleado
Código: [Seleccionar]
public abstract class Empleado {

private String documento;
private String nombre;
private double sueldoHora;

public Empleado() {
documento = "";
nombre = "";
sueldoHora = 0d;
}

public Empleado(String documento, String nombre, double sueldoHora) {
this.documento = documento;
this.nombre = nombre;
this.sueldoHora = sueldoHora;
}

public String getDocumento() {
return documento;
}

public void setDocumento(String documento) {
this.documento = documento;
}

public String getNombre() {
return nombre;
}

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

public double getSueldoHora() {
return sueldoHora;
}

public void setSueldoHora(double sueldoHora) {
this.sueldoHora = sueldoHora;
}

@Override
public String toString() {
return String.format("documento=%s, nombre=%s, sueldoHora=%s", documento, nombre, sueldoHora);
}

}

Estas serían sus clases hijas. Nótese que sus métodos toString() se combinan con el toString() de la clase madre para mostrar la información adaptada a cada subclase.
Desarrollador
Código: [Seleccionar]
public class Desarrollador extends Empleado {

public Desarrollador() {
super();
}

public Desarrollador(String documento, String nombre, double sueldoHora) {
super(documento, nombre, sueldoHora);
}

@Override
public String toString() {
return String.format("Desarrollador [%s]", super.toString());
}

}

GestorProyectos
Código: [Seleccionar]
public class GestorProyectos extends Empleado {

private String area;

public GestorProyectos() {
super();
area = "";
}

public GestorProyectos(String documento, String nombre, double sueldoHora, String area) {
super(documento, nombre, sueldoHora);
this.area = area;
}

public String getArea() {
return area;
}

public void setArea(String area) {
this.area = area;
}

@Override
public String toString() {
return String.format("GestorProyectos [%s, area=%s]", super.toString(), area);
}

}

Admin
Código: [Seleccionar]
public class Admin extends Empleado {

public Admin() {
super();
}

public Admin(String documento, String nombre, double sueldoHora) {
super(documento, nombre, sueldoHora);
}

@Override
public String toString() {
return String.format("Admin [%s]", super.toString());
}

}

Esta sería la clase Empresa, a la cuál además de los atributos mencionados en el enunciado, le he añadido un ArrayList para guardar los Empleados que trabajarán para la Empresa.
Es necesario relacionar un empleado con una empresa y creo que la mejor forma es que cada empresa creada, tenga su propio ArrayList donde guardar los empleados que trabajan para ella.

Código: [Seleccionar]
import java.util.ArrayList;

public abstract class Empresa {

private String nit;
private String nombre;
private String direccion;
private String ciudad;
private ArrayList<Empleado> empleados;

public Empresa() {
nit = "";
nombre = "";
direccion = "";
ciudad = "";
empleados = new ArrayList<Empleado>();
}

public Empresa(String nit, String nombre, String direccion, String ciudad) {
this.nit = nit;
this.nombre = nombre;
this.direccion = direccion;
this.ciudad = ciudad;
empleados = new ArrayList<Empleado>();
}

public String getNit() {
return nit;
}

public void setNit(String nit) {
this.nit = nit;
}

public String getNombre() {
return nombre;
}

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

public String getDireccion() {
return direccion;
}

public void setDireccion(String direccion) {
this.direccion = direccion;
}

public String getCiudad() {
return ciudad;
}

public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}

public void asignarEmpleado(Empleado emp) {
empleados.add(emp);
}

public int contarEmpleados() {
return empleados.size();
}

@Override
public String toString() {
return String.format("nit=%s, nombre=%s, direccion=%s, ciudad=%s", nit, nombre, direccion, ciudad);
}

}

Y su clase hija EmpresaDesarrollo
Código: [Seleccionar]
public class EmpresaDesarrollo extends Empresa {

public EmpresaDesarrollo() {
super();
}

public EmpresaDesarrollo(String nit, String nombre, String direccion, String ciudad) {
super(nit, nombre, direccion, ciudad);
}

@Override
public String toString() {
return String.format("EmpresaDesarrollo [%s]", super.toString());
}

}


Hasta aquí tenemos digamos la "parte fácil".
Haremos un programa donde crear empresas, crear empleados que trabajarán en esas empresas y poder hacer algunas operaciones con estas entidades.

Bien, esas operaciones nos dicen que se han de hacer mediante otras dos clases, las cuáles han de implementar sendas interfaces en las que se declararán los métodos que realizarán esas operaciones.
Lo vemos en el próximo mensaje..

246
¿Cuál es tu confusión?
¿Has escrito al menos las clases básicas como Empleado o Empresa?

Especifica en que parte te atascas y/o muestra el código que tengas hecho y te ayudamos a corregirlo y a continuar a partir de él.

247
Perfecto.

Aunque quiero comentar algo, por si en el futuro te encontrases con un caso distinto.

Esta línea que has puesto, es totalmente correcta y perfecta:
Código: [Seleccionar]
System.out.println ("el doble del número introducido es: " + 2 * Integer.parseInt(entradaUsuario));
Pero, supongamos que en lugar de multiplicar * 2, te piden que le sumes + 2:

Código: [Seleccionar]
System.out.println ("Sumar 2 al numero introducido da el resultado: " + 2 + Integer.parseInt(entradaUsuario));
Si probamos con esa línea, veremos que no se hace ninguna suma aritmética, si no que el 2 se concatena con el otro número.
El operador +  sirve para sumar números, pero también para concatenar Strings. Y Java no puede adivinar cuál es nuestra intención, así que si se encuentra al menos un String en la expresión, los tratará a todos como Strings y hará concatenación

En el primer ejemplo esto no pasaba, porque el operador * es estrictamente aritmético así que no hay dudas de que es una multiplicación.

Pero cuando se trata de sumar, puede haber ambigüedad y la preferencia de Java será concatenar.

Esta ambigüedad podemos evitarla encerrando entre paréntesis la parte de la expresión que queremos que se sume:
Código: [Seleccionar]
System.out.println ("Sumar 2 al numero introducido da el resultado: " + [b](2 + Integer.parseInt(entradaUsuario))[/b]);Al hacer eso, le decimos a Java que lo hay entre paréntesis, es una expresión en si misma y ha de ser evaluada al margen de todo lo demás.
El resultado que de esa expresión, ya sí luego se evaluará con el resto de elementos de la "expresión principal"

Esto lo comento solo por si en algún momento te encontrase con un caso como este y te encontrases con que logras hacer la suma porque Java se empeña en concatenar.
Ahora ya sabes el motivo y como solucionarlo.

Un saludo.

248
Pintan bien.

Solo comentar un detalle poco importante.
Al registrar nuevo libro, pides un boolean para indicar la disponibilidad del libro:
Citar
    public static void registrarLibro(){
        sc.nextLine();
        System.out.println("CREAR LIBRO.");
        System.out.print("Código: ");
        String codigo=sc.nextLine();
        System.out.print("Título: ");
        String titulo=sc.nextLine();
        System.out.print("Autoría: ");
        String autoria=sc.nextLine();
        System.out.print("Disponibilidad: ");
        boolean disponibilidad=sc.nextBoolean();

Quizás no debiera ser necesario pedir ese dato ya que al registrar un libro, es decir, añadir un nuevo título a la biblioteca, se entiende que SÍ está disponible porque aún no ha habido ocasión de prestarlo.

Al añadir el libro, lo lógico sería considerar como TRUE su disponibilidad, la cuál solo debiera pasar a FALSE en el momento que se haga un nuevo préstamo.

Pero bueno, como digo, es un detalle de escasa relevancia.

Un saludo.


249
Si no indicas qué errores son y cómo es tu código..., pues poco puedo ayudar.

Puedo comenzar un menú con interfaz gráfica, para que sirva de guía y ver en qué estás fallando, o bien que sirva de ejemplo para que lo continúes y lo completes.

No va a ser muy elaborado porque mi tiempo libre es limitado.
Podemos crear un JFrame principal con botones para acceder a los submenús de las entidades que tenga nuestro programa.
En mi caso tengo 4, porque estoy reutilizando las clases que puse anteriormente



Al pinchar en uno de los botones, podemos hacer que aparezca un JDialog para la gestión de cada elemento.
Aquí por ejemplo gestiono Socios con todas las opciones CRUD necesarias.

Con el JComboBox puedo seleccionar Socios escogiendo su Número de Socio que lo identifica.
Cada vez que elijo uno, se muestran el resto de datos en pantalla.
Con los botones de abajo, puedo crear, modificar, eliminar y guardar


Bien, el JFrame principal lo construyo con este código:
Código: [Seleccionar]
ublic class Biblioteca extends JFrame {

//Modelo
private ArrayList<Socio> socios = new ArrayList<Socio>();
static int idSocios = 0; //Contador para autogenerar id para los socios
private ArrayList<Autor> autores = new ArrayList<Autor>();
private ArrayList<Libro> libros = new ArrayList<Libro>();
private ArrayList<Prestamo> prestamos = new ArrayList<Prestamo>();

//Vista
private PanelBotonMenu menuSocios = new PanelBotonMenu("Gestion Socios");
private PanelBotonMenu menuAutores = new PanelBotonMenu("Gestion Autores");
private PanelBotonMenu menuLibros = new PanelBotonMenu("Gestion Libros");
private PanelBotonMenu menuPrestamos = new PanelBotonMenu("Gestion Prestamos");

public Biblioteca() {
comenzarConDatosCargados();

JPanel pnPrincipal = new JPanel();
pnPrincipal.setLayout(new GridLayout(2,2,10,10));
pnPrincipal.add(menuSocios);
pnPrincipal.add(menuAutores);
pnPrincipal.add(menuLibros);
pnPrincipal.add(menuPrestamos);
menuSocios.btOpcion.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
new DialogoSocio(null, true, socios);
}
});

setContentPane(pnPrincipal);

setTitle("Biblioteca");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {

@Override
public void run() {
new Biblioteca();
}
});
}


/*
* Este método carga algunos datos por defecto
* para poder hacer pruebas en el programa
*/
private void comenzarConDatosCargados() {
//Algunos socios
String id = String.format("SC%04d", idSocios);
socios.add(new Socio(id, "CED001", "Juan", "Marin Roca", "678901234", "994567890",
new Direccion("Sepulveda", "Roble", "34", TipoVivienda.CASA)));
idSocios++;
id = String.format("SC%04d", idSocios);
socios.add(new Socio(id, "CED002", "Sara", "Montes", "678901234", "994567890",
new Direccion("Azucena", "", "44", TipoVivienda.DEPARTAMENTO)));
idSocios++;
id = String.format("SC%04d", idSocios);
socios.add(new Socio(id, "CED003", "Jorge", "Morales", "678901234", "994567890",
new Direccion("Peru", "Ecuador", "11", TipoVivienda.EMPRESA)));
idSocios++;
id = String.format("SC%04d", idSocios);
socios.add(new Socio(id, "CED004", "Laura", "Sanchez", "678901234", "994567890",
new Direccion("Fresnedo", "", "67", TipoVivienda.DEPARTAMENTO)));
idSocios++;
//Algunos libros
libros.add(new Libro("978834556", "Cien años de soledad", "Gabriel Garcia Marquez", true,
new Localizacion("2", "4", "6", Area.ARTE_LITERATURA)));
libros.add(new Libro("978878912", "Lecturas y Pasiones", "Jose Luis Melero", true,
new Localizacion("1", "4", "5", Area.FILOLOGIA)));
libros.add(new Libro("978800781", "Sunies y Chiies", "Javier Martin", true,
new Localizacion("3", "3", "1", Area.RELIGION)));
libros.add(new Libro("978815690", "Salafismo", "Luz Gomez", true,
new Localizacion("3", "3", "2", Area.RELIGION)));
libros.add(new Libro("978813456", "Steven Universe Juego de Rol", "Rebecca Sugar", true,
new Localizacion("2", "3", "7", Area.GENERALIDADES)));
libros.add(new Libro("978890908", "Somos agua que piensa", "Joaquin Araujo", true,
new Localizacion("2", "8", "3", Area.CIENCIAS_NATURALES)));
//Correspondientes autores
Autor autor = new Autor("Gabriel Garcia Marquez", "Gabo", "Colombia", "6/3/1927");
autor.agregarLibro(libros.get(0));
autores.add(autor);
autor = new Autor("Jose Luis Melero", "", "España", "12/7/1956");
autor.agregarLibro(libros.get(1));
autores.add(autor);
autor = new Autor("Javier Martin", "", "Argentina", "11/9/1963");
autor.agregarLibro(libros.get(2));
autores.add(autor);
autor = new Autor("Luz Gomez", "", "España", "1/2/1969");
autor.agregarLibro(libros.get(3));
autores.add(autor);
autor = new Autor("Rebecca Sugar", "Sugar", "Estados Unidos", "9/7/1987");
autor.agregarLibro(libros.get(4));
autores.add(autor);
autor = new Autor("Joaquin Araujo", "", "España", "31/12/1947");
autor.agregarLibro(libros.get(5));
autores.add(autor);
}

Y la clase para crear el JDialog, es la siguiente. Fijaos que por el constructor le paso una referencia al ArrayList de Socios que se encuentra en la clase principal. Así el JDialog puede acceder directamente a la colección de socios.
Código: [Seleccionar]
public class DialogoSocio extends JDialog {

private ArrayList<Socio> socios;
private JComboBox<String> jcNumSocio;
private JTextField jtCedula;
private JTextField jtNombre;
private JTextField jtApellidos;
private JTextField jtTelefMovil;
private JTextField jtTelefConven;
private JTextField jtDireccion;
private JButton btNuevo;
private JButton btModificar;
private JButton btEliminar;
private JButton btGuardar;

public DialogoSocio(Frame padre, boolean modal, ArrayList<Socio> socios) {
super(padre, modal);
this.socios = socios;
inicializarComponentes();

JPanel pnDatos = new JPanel();
pnDatos.setLayout(new GridLayout(4,1,5,5));
JPanel pn1 = new JPanel();
pn1.setLayout(new GridLayout(1,2));
pn1.add(new PanelConLabel("Nº Socio: ", jcNumSocio));
pn1.add(new PanelConLabel("Nº Cedula: ", jtCedula));
JPanel pn2 = new JPanel();
pn2.setLayout(new GridLayout(1,2));
pn2.add(new PanelConLabel("Nombre: ", jtNombre));
pn2.add(new PanelConLabel("Apellidos: ", jtApellidos));
JPanel pn3 = new JPanel();
pn3.setLayout(new GridLayout(1,2));
pn3.add(new PanelConLabel("Tlf. Movil: ", jtTelefMovil));
pn3.add(new PanelConLabel("Tlf. Convenc: ", jtTelefConven));
JPanel pn4 = new JPanel();
pn4.add(new PanelConLabel("Direccion: ", jtDireccion));

pnDatos.add(pn1); pnDatos.add(pn2); pnDatos.add(pn3); pnDatos.add(pn4);

JPanel pnBotones = new JPanel();
pnBotones.add(btNuevo); pnBotones.add(btModificar);
pnBotones.add(btEliminar); pnBotones.add(btGuardar);

setLayout(new BorderLayout());
add(pnDatos, BorderLayout.CENTER);
add(pnBotones, BorderLayout.SOUTH);


setTitle("Gestion Socios");
setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
pack();
setLocationRelativeTo(null);
setVisible(true);
}

private void inicializarComponentes() {
jcNumSocio = new JComboBox<String>();
for (Socio s: socios)
jcNumSocio.addItem(s.getNumSocio());
jtCedula = new JTextField(8);
jtNombre = new JTextField(8);
jtApellidos = new JTextField(8);
jtTelefMovil = new JTextField(8);
jtTelefConven = new JTextField(8);
jtDireccion = new JTextField(20);
btNuevo = new JButton("Nuevo Socio");
btNuevo.addActionListener(new AccionNuevoSocio());
btModificar = new JButton("Modificar Socio");
btModificar.addActionListener(new AccionModificarSocio());
btEliminar = new JButton("Eliminar Socio");
btEliminar.addActionListener(new AccionEliminarSocio());
btGuardar = new JButton("Guardar Socio");
btGuardar.addActionListener(new AccionGuardarSocio());

actualizarInterfaz();
jcNumSocio.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
mostrarSocioSeleccionado();
}});
}

private void actualizarInterfaz() {

jtCedula.setEditable(false);
jtNombre.setEditable(false);
jtApellidos.setEditable(false);
jtTelefMovil.setEditable(false);
jtTelefConven.setEditable(false);
jtDireccion.setEditable(false);

if (socios.isEmpty()) {
jtCedula.setText(null);
jtNombre.setText(null);
jtApellidos.setText(null);
jtTelefMovil.setText(null);
jtTelefConven.setText(null);
jtDireccion.setText(null);
btNuevo.setEnabled(true);
btModificar.setEnabled(false);
btEliminar.setEnabled(false);
btGuardar.setEnabled(false);
}
else {
jcNumSocio.setSelectedIndex(0);
mostrarSocioSeleccionado();
btNuevo.setEnabled(true);
btModificar.setEnabled(true);
btEliminar.setEnabled(true);
btGuardar.setEnabled(false);
}
}

/*
* Muestra en los campos los datos del socio
* seleccionado actualmente en el JComboBox
*/
private void mostrarSocioSeleccionado() {
Socio s = socios.get(jcNumSocio.getSelectedIndex());
jtCedula.setText(s.getCedula());
jtNombre.setText(s.getNombre());
jtApellidos.setText(s.getApellidos());
jtTelefMovil.setText(s.getTelefMovil());
jtTelefConven.setText(s.getTelefConvencional());
jtDireccion.setText(s.getDireccion().getDatos());
}

private class PanelConLabel extends JPanel {

public PanelConLabel(String txt, JComponent comp) {
add(new JLabel(txt));
add(comp);
}
}

/*
* Configura la interfaz para que el usuario pueda
* crear un socio nuevo
*/
private class AccionNuevoSocio implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
jcNumSocio.setEnabled(false);
jtCedula.setText(null); jtCedula.setEditable(true);
jtNombre.setText(null); jtNombre.setEditable(true);
jtApellidos.setText(null); jtApellidos.setEditable(true);
jtTelefMovil.setText(null); jtTelefMovil.setEditable(true);
jtTelefConven.setText(null); jtTelefConven.setEditable(true);
jtDireccion.setText(null); jtDireccion.setEditable(true);
btModificar.setEnabled(false);
btEliminar.setEnabled(false);
btGuardar.setEnabled(true);
}
}

/*
* Configura la interfaz para que el usuario pueda
* modificar un socio seleccionado
*/
private class AccionModificarSocio implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
jcNumSocio.setEnabled(true);
jtCedula.setEditable(true);
jtNombre.setEditable(true);
jtApellidos.setEditable(true);
jtTelefMovil.setEditable(true);
jtTelefConven.setEditable(true);
jtDireccion.setEditable(true);
btModificar.setEnabled(false);
btEliminar.setEnabled(true);
btGuardar.setEnabled(true);
}
}

/*
* Elimina un socio seleccionado y reconfigura la
* interfaz tras la eliminación
*/
private class AccionEliminarSocio implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {

int respuesta = JOptionPane.showConfirmDialog(null, "¿Seguro que quiere eliminar este Socio",
"Eliminar Socio", JOptionPane.YES_NO_OPTION);

if (respuesta == JOptionPane.YES_OPTION) {
socios.remove(jcNumSocio.getSelectedIndex());
jcNumSocio.removeItemAt(jcNumSocio.getSelectedIndex());
actualizarInterfaz();
}
}
}

/*
* Guarda un socio nuevo o modificado y reconfigura la
* interfaz tras la eliminación
*/
private class AccionGuardarSocio implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
//Recopilamos datos y comprobamos que no falta ningún dato importante
boolean faltanDatosImportantes = false;
String cedula = jtCedula.getText();
if (cedula.isBlank()) {
faltanDatosImportantes = true;
JOptionPane.showMessageDialog(null, "Campo Cédula no puede estar vacío",
"Guardar Socio", JOptionPane.WARNING_MESSAGE);
}
String nombre = jtNombre.getText();
if (nombre.isBlank()) {
faltanDatosImportantes = true;
JOptionPane.showMessageDialog(null, "Campo Nombre no puede estar vacío",
"Guardar Socio", JOptionPane.WARNING_MESSAGE);
}
String apellidos = jtApellidos.getText();
if (apellidos.isBlank()) {
faltanDatosImportantes = true;
JOptionPane.showMessageDialog(null, "Campo Apellidos no puede estar vacío",
"Guardar Socio", JOptionPane.WARNING_MESSAGE);
}
String telefM = jtTelefMovil.getText();
if (telefM.isBlank()) {
faltanDatosImportantes = true;
JOptionPane.showMessageDialog(null, "Campo Tlf Movil no puede estar vacío",
"Guardar Socio", JOptionPane.WARNING_MESSAGE);
}
String telefC = jtTelefConven.getText();
//Telefono convencional no es obligatorio
String direccion = jtDireccion.getText();
if (direccion.isBlank()) {
faltanDatosImportantes = true;
JOptionPane.showMessageDialog(null, "Campo Dirección no puede estar vacío",
"Guardar Socio", JOptionPane.WARNING_MESSAGE);
}

if (faltanDatosImportantes)
JOptionPane.showMessageDialog(null, "Faltan datos para poder guardar el Socio",
"Guardar Socio", JOptionPane.ERROR_MESSAGE);
else {
/*
* Antes de guardar, hay que saber si estamos creando un socio nuevo
* para añadirlo al ArrayList, o bien si estamos modificando un
* socio que ya existe en el ArrayList.
* Podemos distinguir entre un escenario y el otro según si el JComboBox
* está desactivado (nuevo socio) o si está activado(socio modificado)
*/
if (jcNumSocio.isEnabled()) { //Estamos modificando
int indice = jcNumSocio.getSelectedIndex();
socios.get(indice).setCedula(cedula);
socios.get(indice).setNombre(nombre);
socios.get(indice).setApellidos(apellidos);
socios.get(indice).setTelefMovil(telefM);
socios.get(indice).setTelefConvencional(telefC);
socios.get(indice).getDireccion().callePrincipal = direccion;
}
else { //Es un socio nuevo
String id = String.format("SC%04d", Biblioteca.idSocios);
Direccion nuevaDir = new Direccion();
nuevaDir.callePrincipal = direccion;
//Añadimos al ArrayList
socios.add(new Socio(id, cedula, nombre, apellidos, telefM, telefC, nuevaDir));
Biblioteca.idSocios++;
//Añadimos su id al combobox
jcNumSocio.addItem(id);
jcNumSocio.setSelectedIndex(jcNumSocio.getItemCount() - 1);
//Reactivamos el combobox
jcNumSocio.setEnabled(true);
}
btModificar.setEnabled(true);
btEliminar.setEnabled(true);
btGuardar.setEnabled(false);
jtCedula.setEditable(false);
jtNombre.setEditable(false);
jtApellidos.setEditable(false);
jtTelefMovil.setEditable(false);
jtTelefConven.setEditable(false);
jtDireccion.setEditable(false);
}
}
}
}

Los botones de acción no solo cogen y guardan datos. También activan/desactivan campos y botones según cada caso.
Por ejemplo, los campos de texto comienzan siendo "no editables", solo muestran datos.
Cuando se pulsa el botón Modificar, entonces se vuelven "editables" para que el usuario pueda cambiar los valores.
Al pulsar el botón Guardar, vuelven a ser de "solo lectura".

No tengo tiempo para hacer más por ahora, ni para explicar más a fondo el código.
Pruébalo, quizás tengas que adaptarlo a las clases de tu Modelo si no estás usando las que escribí yo en mensajes anteriores.
De hecho, yo mismo he tenido que hacer una "chapucilla" para el campo dirección, ya que en la interfaz trato este dato como una simple línea String, pero mi clase Socio el atributo Dirección es mucho más complejo, ya que es una clase con cuatro atributos distintos.
Pero no quería perder tiempo en crear más campos para la dirección.

Si te ves capaz, intentar hacer lo mismo pero para gestionar los libros.
Si tienes dudas concretas, pregúntalas.

Yo intentaré continuarlo cuando pueda.
Un saludo.

250
Párrafo 3.

Añadir a la clase Mes un método para exportar a txt:
Código: [Seleccionar]
public void exportar() {
File salida = new File("visitasTuristicasDelMesDe" + nombreMes + ".txt");
try {
BufferedWriter escritor = new BufferedWriter(new FileWriter(salida));
//Recorremos los valores del HashMap
for (Visita v: visitas.values()) {
escritor.write(v.toString());
escritor.newLine();
}
escritor.close();
} catch (IOException e) {
System.out.println("Error exportando las Visitas a txt:\n" + e.getMessage());
}
}

Y ahora quedaría probar el código escrito.
Creamos una clase main donde construimos un mes y le añadimos un par de Tours y un par de Visitas.
En este ejemplo, pruebo lo de mostrar en pantalla ordenado y lo de exportar a txt.
Todo parece funcionar bien.
Código: [Seleccionar]
public class Test {

public static void main(String[] args) {
//Creamos un mes
Mes febrero = new Mes("Febrero");
//Añadimos un par de Excursiones
febrero.addVisita(new Excursion("Sur de Francia", new String[] {"Leucate", "Gruisan"},
"Francia", 45, "Visita Parque Natural Narbonaise", "Frances", 15, false, "15/02/2022",
"09:45", 12, true));
febrero.addVisita(new Excursion("Costa Cantabra", new String[] {"Santoña", "Santander"},
"España", 363, "Vista Palacio de la Magdalena", "Español", 25, true, "21/02/2022",
"09:30", 8, false));
//Y un par de Tours
febrero.addVisita(new Tour("Ruta Portuguesa",
new String[] {"Braga", "Oporto", "Ovar", "Agueda", "Coimbra", "Lisboa"}, "Portugal", 65,
"Paseo en barco por Rio Duero", "Portugues", 8, true, "19/02/2022", "09:00", "24/02/2022",
"20:00", new String[] {"La Braganza", "O portico", "Ovar Hilton", "Santa Agueda",
"El Coimbrano", "Lisbon HR"}));
febrero.addVisita(new Tour("Al-Andalus",
new String[] {"Sevilla", "Cadiz", "Marbella", "Motril", "Almeria",}, "España", 50,
"Excursion por el Parque Natural Los Alcornocales", "Español", 12, false, "01/02/2022", "09:00",
"05/02/2022", "18:00", new String[] {"Sevilla Hilton", "El Gaditano", "Marbella City",
"Hotel Alhambra", "Reino Almeria"}));

//Probamos a listarlos ordenados en pantalla
febrero.imprimirOrdenadas();

//Y exportamos a txt
febrero.exportar();

}

}

Quedaría probar los otros métodos de cambiar hotel o eliminar una visita por fecha.
Esto ya lo dejo en tus manos.

Pregunta lo que no entiendas.
Un saludo.

251
Bien, siguiente parrafo.
La clase Mes nos dice que tiene dos atributos, un String con el nombre del mes que representa y un HashMap para albergar objetos de la clase Visita (es decir, Tours y Excursiones) y la clave para mapearlos será el nombre de la Visita, es decir, un String.

Bien, vayamos haciendolo paso a paso. Aquí comenzamos con los dos atributos, un constructor (al que yo le veo sentido que reciba el nombre del mes) y métodos get/set para el atributo String.
El HashMap, al menos en este caso, no tiene sentido que tenga también un get y/o set.

Código: [Seleccionar]
import java.util.HashMap;

public class Mes {

private HashMap<String, Visita> visitas;
private String nombreMes;

public Mes(String nombreMes) {
this.nombreMes = nombreMes;
visitas = new HashMap<String, Visita>();
}

public String getNombreMes() {
return nombreMes;
}

public void setNombreMes(String nombreMes) {
this.nombreMes = nombreMes;
}




}
Que dice a continuación:
Citar
Debe disponer de un método para añadir una visita y otro para borrar una visita dada la fecha de salida.

Bien, añadir una visita es fácil. Se usa su nombre como clave para mapear y listo.

Borrarla, según fecha, ya supone un código algo más elaborado.
Habrá que recorrer los valores del HashMap para buscar alguno que coinicida con la fecha de salida que se nos indique.
Como están guardados bajo el tipo Visita, y esta clase madre no tiene atributos de fecha, a cada valor habrá que preguntarle si es un Tour o una Excursion, hacer casting a la clase que le corresponda, y ahora sí podremos consultar su valor para el atributo fecha de salida.

Si encontramos alguno que coincida, pues lo fusilamos del HashMap..

Código: [Seleccionar]
public class Mes {

private HashMap<String, Visita> visitas;
private String nombreMes;

public Mes(String nombreMes) {
this.nombreMes = nombreMes;
visitas = new HashMap<String, Visita>();
}

public String getNombreMes() {
return nombreMes;
}

public void setNombreMes(String nombreMes) {
this.nombreMes = nombreMes;
}

public void addVisita(Visita visita) {
visitas.put(visita.getNombre(), visita);
}

public void borrarVisita(String fechaSalida) {
Visita borrar = null;
//Recorremos los valores del hashmap
for (Visita v: visitas.values()) {
/*
* Los objetos están guardados como Visita.
* Para poder consultar sus fechas de salida, hay
* que castearlos a Tour o Excursion, según corresponda
*/
if(v instanceof Excursion) { //Es una Excursion
Excursion ex = (Excursion) v; //Casting
if (ex.getFechaSalida().equals(fechaSalida)) {//¿Coincide la fecha de salida?
borrar = v; //Pues entonces esta es la que vamos borrar
break; //Dejamos de buscar
}
}
else  {//Si no es Excursion, pues es un Tour
Tour to = (Tour) v;
if (to.getFechaSalida().equals(fechaSalida)) {
borrar = to;
break;
}
}
}

//Tras recorrer los valores, comprobamos si hemos encontrado alguna visita para borrar
if (borrar == null)
System.out.println("No se ha encontrado ninguna visita para la fecha: " + fechaSalida);
else { //borrar tiene algún valor, es la Visita que hay que eliminar
visitas.remove(borrar.getNombre());//Indicamos clave para borrar
System.out.println("Se ha eliminado la Visita con el nombre: " + borrar.getNombre());
}


}


}

Siguiente petición :
Citar
Otro método deberá imprimirlas por orden alfabético (usa un vector auxiliar)
Bien, para esto habrá que extraer los valores del hashmap en una colección auxiliar y ordenarlos alfabéticamente por nombre..
Y para ordenarlos de forma más cómoda y eficiente, lo ideal sería enseñarle a la clase Visita cómo ha de comparar sus objetos para ordenarse como queremos.
Así que podemos modificar la clase Visita implementándole la interfaz Comparable y sobreescribiendo el método compareTo(), donde le diremos que para ordenarse hay que comparar los nombres de las visitas.
Marco en azul los cambios
Citar
public abstract class Visita implements Comparable<Visita> {
   
   private String nombre;
   private String[] ciudades;
   private String pais;
   private double precioPersona;
   private String extras;
   private String idioma;
   private int personasApuntadas;
   private boolean accesible;
   
   public Visita(String nombre, String[] ciudades, String pais, double precioPersona, String extras, String idioma,
         int personasApuntadas, boolean accesible) {
      this.nombre = nombre;
      this.ciudades = ciudades;
      this.pais = pais;
      this.precioPersona = precioPersona;
      this.extras = extras;
      this.idioma = idioma;
      this.personasApuntadas = personasApuntadas;
      this.accesible = accesible;
   }

   public String getNombre() {
      return nombre;
   }

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

   public String[] getCiudades() {
      return ciudades;
   }

   public void setCiudades(String[] ciudades) {
      this.ciudades = ciudades;
   }

   public String getPais() {
      return pais;
   }

   public void setPais(String pais) {
      this.pais = pais;
   }

   public double getPrecioPersona() {
      return precioPersona;
   }

   public void setPrecioPersona(double precioPersona) {
      this.precioPersona = precioPersona;
   }

   public String getExtras() {
      return extras;
   }

   public void setExtras(String extras) {
      this.extras = extras;
   }

   public String getIdioma() {
      return idioma;
   }

   public void setIdioma(String idioma) {
      this.idioma = idioma;
   }

   public int getPersonasApuntadas() {
      return personasApuntadas;
   }

   public void setPersonasApuntadas(int personasApuntadas) {
      this.personasApuntadas = personasApuntadas;
   }

   public boolean esAccesible() {
      return accesible;
   }

   public void setAccesible(boolean accesible) {
      this.accesible = accesible;
   }

   @Override
   public String toString() {
      return String.format(
            "[nombre=%s, ciudades=%s, pais=%s, precioPersona=%.2f, extras=%s, idioma=%s, personasApuntadas=%d, accesible=%s",
            nombre, Arrays.toString(ciudades), pais, precioPersona, extras, idioma, personasApuntadas, accesible?"SI":"No");
   }
   
   @Override
   public int compareTo(Visita otraVisita) {
      return nombre.compareTo(otraVisita.nombre);
   }

}

Con estos cambios, ahora en la clase Mes podemos escribir un método para imprimir la visitas en orden alfabético y usando muy poco código.
Podemos crear un array con los valores del HashMap, ordenarlo e imprimirlo.
Código: [Seleccionar]
public void imprimirOrdenadas() {
//Creamos array
Visita[] aux = new Visita[visitas.size()];

//Traspasamos las visitas al array
int i = 0;
for (Visita v: visitas.values()) {
aux[i] = v;
i++;
}

//Ordenamos array
Arrays.sort(aux);


//Imprimimos en pantalla, cada Visita se mostrará según su método toString()
for (Visita v: aux)
System.out.println(v);
}

Que más...
Citar
Otro, almorzar, que recibirá un parámetro de tipo boolean, permitirá poner en todas las excursiones de un día el atributo almuerzo a true o false, según el boolean recibido.
Mmmhh. no está muy bien redactado esto. Supongo que además del boolean, se ha de indicar la fecha de las excursiones que se quiere cambiar, ¿no?
Código: [Seleccionar]
public void almorzar(String fechaSalida, boolean conAlmuerzo) {
//Recorremos valores del map buscando Excursiones
for (Visita v: visitas.values()) {
if (v instanceof Excursion) {
Excursion ex = (Excursion) v;
if (ex.getFechaSalida().equals(fechaSalida))
ex.setConAlmuerzo(conAlmuerzo);
}
}
}

Para terminar el párrafo 2:
Citar
Por último, un método cambiarHotel, cuyos parámetros serán: el nombre de un tour, una de sus ciudades y el nombre de un hotel. Deberá cambiar en ese tour y en esa ciudad el nombre del hotel antiguo por este nuevo que recibe.

Bien con el nombre de la Visita, ya tenemos la clave para buscarla en el HashMap.
Una vez obtenida, comprobamos si realmente es un Tour y en ese caso le hacemos casting.
Una vez tenemos el Tour, obtenemos de este objeto los arrays de Hoteles y Ciudades.
Buscamos la ciudad indicada en el array, su posición nos dirá donde tenemos que insertar el nuevo nombre del hotel
Código: [Seleccionar]
public void cambiarHotel(String nombre, String ciudad, String hotel) {
//Buscamos la Visita/Tour, su nombre nos da la clave
Visita v = visitas.get(nombre);
//Comprobamos si se ha encontrado
if (v == null)
System.out.println("No se ha encontrado ninguna Visita con el nombre: " + nombre);
else {
//Visita encontrada, ahora comprobamos si realmente es un Tour
if (v instanceof Tour) { //Sí lo es
Tour t = (Tour) v;
//Obtenemos array de ciudades, para buscar la posicion que ocupa la ciudad indicada
//En esa misma posicion, habrá que cambiar el nombre en el array de hoteles
String[] ciudades = t.getCiudades();
String[] hoteles = t.getHoteles();
for (int i = 0; i < ciudades.length; i++) {
if (ciudades[i].equals(ciudad)) //ciudad encontrada
hoteles[i] = hotel; //Cambiamos hotel
}
}
else //No es Tour
System.out.println("El nombre de Visita indicado no corresponde a un Tour");
}
}

Y me quedé sin tiempo, mañana vemos el párrafo 3

252
Hola.
Ya que no muestras como has hecho las clases del primer párrafo, te muestro como las haría yo. Todos modos tengo que escribirlas porque si no, no puedo avanzar con los siguientes párrafos.

Primero la clase Visita, con todos sus atributos y métodos.
La declaro como abstracta porque se entiende que no queremos construir objetos new Visita(), solo construiremos objetos de las clases hijas Excursiones y Tours.
No es obligatorio declararla abstracta, pero es una forma de impedir la creación de objetos Visita y además evidenciamos que es una clase destinada a ser "madre" de otras.
Código: [Seleccionar]
import java.util.Arrays;

public abstract class Visita {

private String nombre;
private String[] ciudades;
private String pais;
private double precioPersona;
private String extras;
private String idioma;
private int personasApuntadas;
private boolean accesible;

public Visita(String nombre, String[] ciudades, String pais, double precioPersona, String extras, String idioma,
int personasApuntadas, boolean accesible) {
this.nombre = nombre;
this.ciudades = ciudades;
this.pais = pais;
this.precioPersona = precioPersona;
this.extras = extras;
this.idioma = idioma;
this.personasApuntadas = personasApuntadas;
this.accesible = accesible;
}

public String getNombre() {
return nombre;
}

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

public String[] getCiudades() {
return ciudades;
}

public void setCiudades(String[] ciudades) {
this.ciudades = ciudades;
}

public String getPais() {
return pais;
}

public void setPais(String pais) {
this.pais = pais;
}

public double getPrecioPersona() {
return precioPersona;
}

public void setPrecioPersona(double precioPersona) {
this.precioPersona = precioPersona;
}

public String getExtras() {
return extras;
}

public void setExtras(String extras) {
this.extras = extras;
}

public String getIdioma() {
return idioma;
}

public void setIdioma(String idioma) {
this.idioma = idioma;
}

public int getPersonasApuntadas() {
return personasApuntadas;
}

public void setPersonasApuntadas(int personasApuntadas) {
this.personasApuntadas = personasApuntadas;
}

public boolean esAccesible() {
return accesible;
}

public void setAccesible(boolean accesible) {
this.accesible = accesible;
}

@Override
public String toString() {
return String.format(
"[nombre=%s, ciudades=%s, pais=%s, precioPersona=%.2f, extras=%s, idioma=%s, personasApuntadas=%d, accesible=%s",
nombre, Arrays.toString(ciudades), pais, precioPersona, extras, idioma, personasApuntadas, accesible?"SI":"No");
}

}

Aquí la clase hija Excursion. Su método toString() se complementa con lo que retorna el de su clase madre.
Código: [Seleccionar]
public class Excursion extends Visita {

private String fechaSalida;
private String horaSalida;
private int horasDura;
private boolean conAlmuerzo;

public Excursion(String nombre, String[] ciudades, String pais, double precioPersona, String extras,
String idioma, int personasApuntadas, boolean accesible, String fechaSalida, String horaSalida,
int horasDura, boolean conAlmuerzo) {
super(nombre, ciudades, pais, precioPersona, extras, idioma, personasApuntadas, accesible);
this.fechaSalida = fechaSalida;
this.horaSalida = horaSalida;
this.horasDura = horasDura;
this.conAlmuerzo = conAlmuerzo;
}

public String getFechaSalida() {
return fechaSalida;
}

public void setFechaSalida(String fechaSalida) {
this.fechaSalida = fechaSalida;
}

public String getHoraSalida() {
return horaSalida;
}

public void setHoraSalida(String horaSalida) {
this.horaSalida = horaSalida;
}

public int getHorasDura() {
return horasDura;
}

public void setHorasDura(int horasDura) {
this.horasDura = horasDura;
}

public boolean esConAlmuerzo() {
return conAlmuerzo;
}

public void setConAlmuerzo(boolean conAlmuerzo) {
this.conAlmuerzo = conAlmuerzo;
}

@Override
public String toString() {
return String.format("Excursion %s, fechaSalida=%s, horaSalida=%s, horasDura=%s, conAlmuerzo=%s]",
super.toString(), fechaSalida, horaSalida, horasDura, conAlmuerzo);
}

}

Y clase Tour
Código: [Seleccionar]
import java.util.Arrays;

public class Tour extends Visita {

private String fechaSalida;
private String horaSalida;
private String fechaLlegada;
private String horaLlegada;
private String[] hoteles;

public Tour(String nombre, String[] ciudades, String pais, double precioPersona, String extras, String idioma,
int personasApuntadas, boolean accesible, String fechaSalida, String horaSalida,
String fechaLlegada, String horaLlegada, String[] hoteles) {
super(nombre, ciudades, pais, precioPersona, extras, idioma, personasApuntadas, accesible);
this.fechaSalida = fechaSalida;
this.horaSalida = horaSalida;
this.fechaLlegada = fechaLlegada;
this.horaLlegada = horaLlegada;
this.hoteles = hoteles;
}

public String getFechaSalida() {
return fechaSalida;
}

public void setFechaSalida(String fechaSalida) {
this.fechaSalida = fechaSalida;
}

public String getHoraSalida() {
return horaSalida;
}

public void setHoraSalida(String horaSalida) {
this.horaSalida = horaSalida;
}

public String getFechaLlegada() {
return fechaLlegada;
}

public void setFechaLlegada(String fechaLlegada) {
this.fechaLlegada = fechaLlegada;
}

public String getHoraLlegada() {
return horaLlegada;
}

public void setHoraLlegada(String horaLlegada) {
this.horaLlegada = horaLlegada;
}

public String[] getHoteles() {
return hoteles;
}

public void setHoteles(String[] hoteles) {
this.hoteles = hoteles;
}

@Override
public String toString() {
return String.format("Tour %s, fechaSalida=%s, horaSalida=%s, fechaLlegada=%s, horaLlegada=%s, hoteles=%s]",
super.toString(), fechaSalida, horaSalida, fechaLlegada, horaLlegada, Arrays.toString(hoteles));
}

}

Luego sigo con el siguiente párrafo.

253
Claro.
Tu objeto llamado "entrada" es de la clase CantantesFamosos.
Aquí lo usas para crear un cantante y es correcto:
Código: [Seleccionar]
CantantesFamosos entrada = new CantantesFamosos();
        System.out.println("Ingrese un cantante famoso: ");
        entrada.setNombre(entradaEscaner.nextLine());
        System.out.println("Ahora el disco con más venta de ese cantante: ");
        entrada.setDiscoConMasVentas(entradaEscaner.nextLine());
        listaCantantesFamosos.addCantante(entrada);
Fíjate que en ese código, no estamos asignándole un String a "entrada". Le estamos asignando un objeto CantantesFamosos, cuyos atributos se componen de dos Strings, pero eso no significa que "cantante" sea un String.

Por eso luego al querer usar ese mismo objeto para pedir una cadena String al usuario, da error:
Código: [Seleccionar]
while (!entrada.equals("no")){
            System.out.println("\nAgregar otro cantante a la lista?(si/no): ");
            entrada = entradaEscaner.nextLine();
Es imposible. Son cosas distintas. Si quieres pedir una cadena String al usuario, pues tienes que declarar un objeto que sea de la clase String y que además tenga otro nombre.
Yo por ejemplo, usé el nombre "respuesta" para el objeto String
Código: [Seleccionar]
String respuesta = "";
       
        while (!respuesta.equals("no")) {
        System.out.print("\nAgregar otro cantante a la lista?(si/no): ");
        respuesta = entradaEscaner.nextLine();
Porque ahí lo queremos es que el usuario nos diga sí o no a la pregunta de continuar añadiendo cantantes, y para recibir esa respuesta, necesitamos guardarla en un String.

254
Vamos por partes.

Tu clase CantantesFamosos es correcta como está, aunque yo le añadiría un constructor donde se reciban los valores para los atributos.
Y ya puestos, un segundo constructor donde se pueda inicializar el objeto con unos valores "por defecto".

Código: [Seleccionar]
public class CantantesFamosos
{
    private String nombre;
    private String discoConMasVentas;
   
    //Constructor que recibe valores
    public CantantesFamosos(String valorNombre, String valorDiscoConMasVentas) {
nombre = valorNombre;
discoConMasVentas = valorDiscoConMasVentas;
}
    //Constructor con valores "por defecto"
    public CantantesFamosos() {
nombre = "";
discoConMasVentas = "";
}

public void setNombre (String valorNombre){
        nombre = valorNombre;
    }
   
    public void setDiscoConMasVentas (String valorDiscoConMasVentas){
        discoConMasVentas = valorDiscoConMasVentas;
    }
   
    public String getNombre () {return nombre;}
   
    public String getDiscoConMasVentas () {return discoConMasVentas;}
   
}

En cambio la clase ListaCantantesFamosos11, sí que hay que corregir cosas.

Su atributo ArrayList, no es para tipo String
Citar
public class ListaCantantesFamosos11
{
    private ArrayList <String> listaCantantesFamosos;

Será para el tipo CantantesFamosos, ya que eso es lo que queremos almacenar

Citar
public class ListaCantantesFamosos11
{
    private ArrayList <CantantesFamosos> listaCantantesFamosos;

Su constructor, tan solo debe inicializar el ArrayList. Nada más.
Tú además has inicializado un objeto CantantesFamosos y un objeto ListaCantantesFamosos11 (mal escrito por cierto porque has puesto que termina en 1 y no en 11)
Esos objetos son innecesarios y no aportan nada al programa.

También has hecho que en el constructor se añadan dos cantantes a la lista. El enunciado dice que estos dos cantantes se añadan en la clase Test, pero bueno, si quieres también podemos hacerlo aquí en el constructor.

Código: [Seleccionar]
    public ListaCantantesFamosos11 () {
        listaCantantesFamosos = new ArrayList <CantantesFamosos>();
        //Añadimos dos objetos CantantesFamosos al ArrayList
        listaCantantesFamosos.add(new CantantesFamosos("Ariana Grande", "7 Rings"));
        listaCantantesFamosos.add(new CantantesFamosos("Ed Sheeran", "="));
    }

Fíjate que para añadir esos dos objetos, utilizo el constructor de CantantesFamosos que recibe valores para los atributos, ya que es lo más cómodo.

Bien, ¿qué métodos vamos a necesitar para esta clase?
Para empezar, uno que permita añadir más objetos al ArrayList
Código: [Seleccionar]
    public void addCantante(CantantesFamosos cantante) {
    listaCantantesFamosos.add(cantante);
    }

Luego, la lista de cantantes ha de ser recorrida con un Iterator. Entonces, aquí tenemos dos opciones.
Una, es usar un método que retorne el iterador para que desde otra clase distinta, pueda recogerse y recorrer la lista desde ahí. Es recomendable (no obligatorio) especificar de que clase son los objetos que contiene el Iterator que se está retornando:
Código: [Seleccionar]
    public Iterator<CantantesFamosos>  getIterador() {
    return listaCantantesFamosos.iterator();
    }

La otra opción, es usar el Iterator de forma interna, sin retornar nada. O sea, hacemos un método que se encargue el mismo de recorrer y mostrar la lista.
Podemos también añadir una comprobación extra, si se diera el caso de que la lista esta vacía que muestre un mensaje informando.
En caso contrario, pues entonces sí creamos un Iterator y recorremos los objetos de la lista.
Código: [Seleccionar]
    public void mostrarListaCantantes() {
    System.out.println("\n\t\tLISTA CANTANTES FAMOSOS\n");
   
    if (listaCantantesFamosos.isEmpty())
    System.out.println("La lista de cantantes esta vacía...");
    else {
    //Creamos iterador
    Iterator<CantantesFamosos> it = listaCantantesFamosos.iterator();
    while (it.hasNext()) {
    //Obtenemos el siguiente objeto del iterador
    CantantesFamosos cantante = it.next();
    //Mostramos sus valores
    System.out.println("Nombre: " + cantante.getNombre() + " -- Disco Top Ventas: " + cantante.getDiscoConMasVentas());
    }
    }
    }

Y ya está, no se necesita nada más para esta clase. Podemos dejar escrita en ella las dos posibilidades para el Iterator, para que sirva de ejemplo.
Código: [Seleccionar]
import java.util.ArrayList;
import java.util.Iterator;

public class ListaCantantesFamosos11
{
    private ArrayList <CantantesFamosos> listaCantantesFamosos;
   
    public ListaCantantesFamosos11 () {
        listaCantantesFamosos = new ArrayList <CantantesFamosos>();
        //Añadimos dos objetos CantantesFamosos al ArrayList
        listaCantantesFamosos.add(new CantantesFamosos("Ariana Grande", "7 Rings"));
        listaCantantesFamosos.add(new CantantesFamosos("Ed Sheeran", "="));
    }   
   
    public void addCantante(CantantesFamosos cantante) {
    listaCantantesFamosos.add(cantante);
    }
   
    //Retorna un Iterator para que la lista puede recorrerse de forma EXTERNA desde otra clase
    public Iterator<CantantesFamosos> getIterador() {
    return listaCantantesFamosos.iterator();
    }
   
    //Usa un Iterator para recorrer la lista de forma INTERNA
    public void mostrarListaCantantes() {
    System.out.println("\n\t\tLISTA CANTANTES FAMOSOS\n");
   
    if (listaCantantesFamosos.isEmpty())
    System.out.println("La lista de cantantes esta vacía...");
    else {
    //Creamos iterador
    Iterator<CantantesFamosos> it = listaCantantesFamosos.iterator();
    while (it.hasNext()) {
    //Obtenemos el siguiente objeto del iterador
    CantantesFamosos cantante = it.next();
    //Mostramos sus valores
    System.out.println("Nombre: " + cantante.getNombre() + " -- Disco Top Ventas: " + cantante.getDiscoConMasVentas());
    }
    }
    }

}


Y vamos ahora con la clase Test principal.

Lo primero será crear un objeto Scanner para pedir datos y un objeto para la lista de cantantes famosos.
Como hemos hecho que su constructor añada directamente dos cantantes, una vez construido ya podemos mostrar en pantalla la lista de cantantes actual.

Y tras eso pasaríamos a preguntar al usuario si quiere añadir más cantantes o no.
Para añadir nuevos cantantes, podemos usar cualquiera de los dos constructores que le hemos puesto a la clase CantantesFamosos.
Antes, al inicializar el ArrayList, hemos usado el constructor que recibe los valores.

Ahora, para variar, podemos usar el que NO recibe valores, y por tanto, se han de usar los setters para establecer los valores del nuevo objeto creado.

Código: [Seleccionar]
public class TestListaCantantesFamosos11
{
   
    public static void main (String [] args){
        Scanner entradaEscaner = new Scanner (System.in);
       
        //El constructor de este objeto, ya añade dos cantantes automáticamente
        ListaCantantesFamosos11 listaCantantesFamosos = new ListaCantantesFamosos11();
       
        listaCantantesFamosos.mostrarListaCantantes();
       
        //A partir de aquí, el usuario decide si quiere ampliar la lista
        String respuesta = "";
       
        while (!respuesta.equals("no")) {
        System.out.print("\nAgregar otro cantante a la lista?(si/no): ");
        respuesta = entradaEscaner.nextLine();
        if (!respuesta.equals("no")) {
        //Creamos nuevo cantante
        CantantesFamosos nuevo = new CantantesFamosos();
        //Pedimos datos
        System.out.print("Nombre del Cantante: ");
        nuevo.setNombre(entradaEscaner.nextLine());
        System.out.print("Disco mas vendido: ");
        nuevo.setDiscoConMasVentas(entradaEscaner.nextLine());
        //Añadimos a la lista
        listaCantantesFamosos.addCantante(nuevo);
        //Mostramos lista actualizada
        listaCantantesFamosos.mostrarListaCantantes();
        }
        }
       
        System.out.println("\n\n\t\tFIN DE PROGRAMA");
        entradaEscaner.close();
       
    }
}

Y con esto ya estaría completo el ejercicio.

En tu clase principal, hay algunos errores conceptuales.

Por ejemplo, pedias nombre y disco más vendido para guardarlos en un String. Esto podría estar bien.
Pero luego a esos String, le intentas aplicar los getters que corresponde a la clase CantantesFamosos

Citar
        System.out.println("Ingrese un cantante famoso: ");
        String entrada1 = entradaEscaner.nextLine();
        System.out.println("Ahora el disco con más venta de ese cantante: ");
        String entrada2 = entradaEscaner.nextLine();
        listaCantantesFamosos.addNombre(entrada1.getNombre());
        listaCantantesFamosos.addNombre(entrada2.getDiscoConMasVentas());

Espero que viendo el código que he escrito, se disipen estos errores de concepto.
No dudes en preguntar cualquier cosa que no entiendas, aunque pienses que es una tontería.

Un saludo.

255
La clase principal no tiene porque ser demasiado complicada, básicamente es poder probar las distintas clases Producto.

Así que puedes simplemente pedir datos por teclado, los necesarios para crear cada tipo de producto.

Puedes dejar los atributos como los tienes ahora y pedir datos de esta manera:
Código: [Seleccionar]
import java.util.Scanner;

public class TestHerencia2
{
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        //Peticion de datos
        System.out.println("Vamos a crear un Producto Refrigerado");
        System.out.print("Introduzca fecha caducidad: ");
        String fechaRefri = teclado.nextLine();
        System.out.print("Introduzca numero de lote: ");
        String loteRefri = teclado.nextLine();
        System.out.print("Introduzca codigo de supervision: ");
        String codigoRefri = teclado.nextLine();
        //construimos objeto con los datos obtenidos
        ProductoRefrigerado refrigerado = new ProductoRefrigerado(fechaRefri, loteRefri, codigoRefri);
        //Mostramos datos del objeto creado
        System.out.print("Nuevo Refrigerado creado:");
        refrigerado.imprimoDatos();
    }
}

Siguiendo ese ejemplo, haz lo mismo para los dos tipos de productos.

256
A ver, para modular el código y tenerlo un poco más ordenado, puedes crear dos clases adicionales, una para trabajar con el archivo de texto y otra para el archivo de ranking.

La del archivo de texto puedes hacer que lea el texto una sola vez en su constructor y guardar las líneas obtenidas en un atributo.
Así, con un método puedes pedirle una palabra al azar tantas veces como quieras sin tener que repetir lecturas en disco.

El constructor de esta clase recibiría la ruta del archivo que ha de leer, haría la lectura y obtendría el texto.
Este proceso, en Java es obligatorio controlar posibles excepciones (archivo no existe, archivo no es legible por estar corrupto o protegido...), así que el constructor de esta clase debería "lanzar" estas excepciones para poder recibirlas en la clase principal del programa.

Porque en la clase principal, el programa solo debería ejecutarse si ha sido posible obtener un texto (no han habido excepciones). Si no es así, debería informar del problema en pantalla y terminar, ya que no tiene sentido ofrecer al usuario poder jugar si no tenemos palabras.

Esta podría ser la clase ArchivoTexto
Código: [Seleccionar]
mport java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Random;

public class ArchivoTexto{

private StringBuilder texto; //Texto que se leera desde fichero

public ArchivoTexto(String ruta) throws Exception {
texto = new StringBuilder();
try {
BufferedReader lector = new BufferedReader(new FileReader(ruta));
//Los archivos de texto se leen línea a línea
String linea = lector.readLine();
while (linea != null) {
texto.append(linea + "\n");
linea = lector.readLine();
}
lector.close();
//Comprobamos que realmente hemos obtenido algún texto
if (texto.toString().isBlank())
throw new Exception("No se obtuvo texto.\nEl archivo: " + ruta + " parece estar en blanco.");
else {
System.out.println("Archivo texto: OK");
System.out.println("Texto obtenido:\n" + toString());
}
} catch (FileNotFoundException e) {
throw new Exception("No se encuentra fichero en " + ruta);
} catch (IOException e) {
throw new Exception("Error accediendo a fichero.\n" + e.getLocalizedMessage());
}
}

public String getPalabraAzar() {
//Construimos un array con todas las palabras del texto
String[] palabras = texto.toString().split(" ");
//Generamos un indice al azar, según la cantidad de palabras obtenidas
Random azar = new Random();
int indice = azar.nextInt(palabras.length);
//Retornamos palabra al azar
return palabras[indice];
}

@Override
public String toString() {
return texto.toString();
}

}

La clase ArchivoRanking es un poco parecida, pero más simple.
Su constructor también recibe la ruta del archivo donde se han de escribir las puntuaciones, pero simplemente lo guarda en un atributo.

Escribiremos un método que reciba como argumentos el nombre del jugador y los puntos para intentar escribirlos en el archivo.
Para este proceso también es obligado controlar posibles excepciones.
Pero en esta ocasión no es necesaria "lanzarlas" al programa principal, porque podemos permitir que el programa siga ejecutándose aunque esté fallando el proceso de guardar las puntuaciones.
El jugador al menos podrá seguir jugando ya que en teoría si dispondremos de palabras.

Así que la posibles excepciones las gestionará el método de forma interna, sin lanzarlas.
En todo caso, podemos hacer que el método sea boolean. Así si todo ha ido bien, retornará true.
Si ha fallado por ocurrir una excepción, mostramos en pantalla el mensaje de error y retornamos false.

Esta sería la clase ArchivoRanking
Código: [Seleccionar]
import java.io.BufferedWriter;
import java.io.FileWriter;

public class ArchivoRanking {

private String ruta;

public ArchivoRanking(String ruta) {
this.ruta = ruta;
}

public boolean guardarPuntuacion(String nombre, int puntos) {
try {
BufferedWriter escritor = new BufferedWriter(new FileWriter(ruta, true));
escritor.write("Nombre: " + nombre + " --- Puntos: " + puntos);
escritor.newLine();
escritor.close();
return true;
} catch (Exception e) {
System.out.println("Error al crear o acceder al archivo: " + ruta + "\n" + e.getLocalizedMessage());
return false;
}
}

}

Y ya luego, en el programa principal, colocaremos dos objetos de estas clases como atributos de ámbito global para que estén totalmente accesibles dentro de esta clase.

Lo primero que haremos será inicializar el objeto ArchivoTexto, que obligatoriamente tenemos que poner try catch para capturar las posibles excepciones que puede lanzar.
Si todo va bien, automáticamente se mostrará en pantalla el texto que se ha obtenido.

Ya luego solo hay que inicializar el objeto ArchivoRanking y ya puede comenzar el resto del programa, con el menú y el código para jugar al Ahorcado.

Código: [Seleccionar]
public class Ahorcado {

private static ArchivoTexto texto;
private static ArchivoRanking ranking;

public static void main(String[] args) {

try {
texto = new ArchivoTexto("info.txt");
ranking = new ArchivoRanking("ranking.txt");

String oculta = texto.getPalabraAzar();

//A partir de aquí, código para el menú y juego del ahorcado



} catch (Exception e) {
System.out.println(e.getMessage());
}

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

}

}

El objeto ArchivoTexto nos dará una palabra "oculta" al azar, siempre que se la pidamos.
Y el objeto ArchivoRanking guardará las puntuaciones que le vayamos indicando.

Como puedes ver, separando estos procesos en distintas clases, el código queda más ordenado.

Si algo no se entiende, solo tienes que preguntar.
Un saludo.

257
No sé si se debe a que has puesto dos guiones, en lugar de solo uno:

Citar
Para k<--0 Hasta k<(c-1) Con Paso 1 Hacer

258
Hola.
A la clase Producto le faltarían atributos
Citar
Todos los productos llevan esta información común: Código, nombre del producto, precio, fecha de caducidad y número de lote.

259
¿En qué necesitas ayuda?
¿En leer archivos de texto? ¿En escoger una palabra de ese texto?

Comienza tú un código, llega hasta donde puedas y dinos donde te atascas.

260
Podrías ayudarme esto es lo que me pide a mi en la aplicación:
Es el mismo problema por favor

La aplicación debe contener:
 
•   Ventana que permita ingresar un socio nuevo con los objetos gráficos necesarios para el ingreso de lo descrito anteriormente.
.........

Con las clases que he publicado antes, prácticamente ya se tiene la parte del "Modelo".
Intenta comenzar una Vista y te ayudamos donde te atasques.

Si encuentro tiempo, intentaría comenzar yo una interfaz que sirviera de ejemplo... pero el tiempo escasea....  :(

Páginas: 1 ... 8 9 10 11 12 [13] 14 15 16 17 18 ... 50

Sobre la educación, sólo puedo decir que es el tema más importante en el que nosotros, como pueblo, debemos involucrarnos.

Abraham Lincoln (1808-1865) Presidente estadounidense.

aprenderaprogramar.com: Desde 2006 comprometidos con la didáctica y divulgación de la programación

Preguntas y respuestas

¿Cómo establecer o cambiar la imagen asociada (avatar) de usuario?
  1. Inicia sesión con tu nombre de usuario y contraseña.
  2. Pulsa en perfil --> perfil del foro
  3. Elige la imagen personalizada que quieras usar. Puedes escogerla de una galería de imágenes o subirla desde tu ordenador.
  4. En la parte final de la página pulsa el botón "cambiar perfil".