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

¿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.

Pintan bien.

Solo comentar un detalle poco importante.
Al registrar nuevo libro, pides un boolean para indicar la disponibilidad del libro:

    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.

Párrafo 3.

Añadir a la clase Mes un método para exportar a txt:
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.
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.

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.
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.
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
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.

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".

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

public class ListaCantantesFamosos11
{
    private ArrayList <String> listaCantantesFamosos;

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

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.

    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
    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:
    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.
    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.
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.

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

        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.

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
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
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.

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.

Hola.
A la clase Producto le faltarían atributos

Todos los productos llevan esta información común: Código, nombre del producto, precio, fecha de caducidad y número de lote.

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.... 

No se como implementar para hacer el registro de socios y que me aprezca a quien se presta el libro
es en Java Netbeans

A ver, en este programa intervienen muchas clases

Tenemos la clase Socio, que entre sus atributos, los datos de la dirección pueden agruparse a su vez en otra clase llamada Direccion.
No hace falta que sea una clase completa con getters y setters, podemos dejar sus atributos accesibles, sin encapsular, para acceder a ellos directamente.
Hay un atributo, el de "Tipo de Vivienda", que ya nos dan una serie de valores entre los que se debe elegir.
Por tanto, deberíamos establecer una forma para controlar que ese atributo solo reciba uno de esos valores indicados.

Una forma de hacerlo, es creando un ENUM..., que es muy parecido a una clase normal, pero con la diferencia de que "enumeramos" los únicos objetos que van a poder existir de esta clase/enum.
Este enum podemos llamarlo TipoVivienda
public enum TipoVivienda {

CASA("Casa"), DEPARTAMENTO("Departamento"),
OFICINA("Oficina"), EMPRESA("Empresa");

private String valor;

private TipoVivienda(String tipo) {
valor = tipo;
}

@Override
public String toString() {
return valor;
}

/*
* Recibe una cadena y comprueba a que enumerado
* corresponde. Una vez encontrado, lo retorna.
* Si no encuentra ninguno valido, retorna null.
*/
public static TipoVivienda convertirCadena(String cadena) {
for (TipoVivienda tv: TipoVivienda.values())
if (tv.valor.equalsIgnoreCase(cadena))
return tv;

return null;
}

}A este enum, le damos además un método estático que se encargue de recibir una cadena y retornar el objeto que se corresponda aunque no coincidan las mayúsculas.
Así, dará igual si el usuario teclea casa, CASA, cASA, CaSa, casA....
Para cualquiera de esas cadenas, obtendremos el objeto CASA, cuyo valor String es "Casa".

Así que este enum, será un atributo de la clase Direccion
public class Direccion {

String callePrincipal;
String calleSecundaria;
String numero;
TipoVivienda vivienda;

public Direccion() {
callePrincipal = "";
calleSecundaria = "";
numero = "";
vivienda = null;
}

public Direccion(String callePrincipal, String calleSecundaria, String numero, TipoVivienda vivienda) {
this.callePrincipal = callePrincipal;
this.calleSecundaria = calleSecundaria;
this.numero = numero;
this.vivienda = vivienda;
}

@Override
public String toString() {
return String.format("Calle Principal: %s\nCalle Secundaria: %s\n"
+ "Numero: %s\nTipo Vivienda: %s", callePrincipal, calleSecundaria,
numero, vivienda);
}
}Como dijimos, sus atributos están "desprotegidos" para que sea más cómodo acceder a ellos. Y no importa porque ya quedarán protegidos cuando esta clase se implemente como atributo de la clase Socio
public class Socio {

private String numSocio;
private String cedula;
private String nombre;
private String apellidos;
private String telefMovil;
private String telefConvencional;
private Direccion direccion;
private ArrayList<Libro> libros;

public Socio(String numSocio, String cedula, String nombre, String apellidos,
String telefMovil, String telefConvencional, Direccion direccion) {
this.numSocio = numSocio;
this.cedula = cedula;
this.nombre = nombre;
this.apellidos = apellidos;
this.telefMovil = telefMovil;
this.telefConvencional = telefConvencional;
this.direccion = direccion;
libros = new ArrayList<Libro>();
}

public String getNumSocio() {
return numSocio;
}

public void setNumSocio(String numSocio) {
this.numSocio = numSocio;
}

public String getCedula() {
return cedula;
}

public void setCedula(String cedula) {
this.cedula = cedula;
}

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 String getTelefMovil() {
return telefMovil;
}

public void setTelefMovil(String telefMovil) {
this.telefMovil = telefMovil;
}

public String getTelefConvencional() {
return telefConvencional;
}

public void setTelefConvencional(String telefConvencional) {
this.telefConvencional = telefConvencional;
}

public Direccion getDireccion() {
return direccion;
}

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

public boolean esConfiable() {
return libros.size() <= 10;
}

public void listarLibrosPrestados() {
for (Libro l: libros) {
System.out.print("--> Codigo: " + l.getCodigo());
System.out.println("\tTitulo: " + l.getTitulo());
}
}

public void prestarLibro(Libro l) {
libros.add(l);
}

public void devolverLibro(Libro l) {
libros.remove(l);
}

@Override
public String toString() {
return String.format("Num Socio: %s\tCedula: %s\nNombre: %s Apellidos: %s\n"
+ "Telef. Movil: %s\tTelef. Convencional: %s\nDatos Direccion:\n%s",
numSocio, cedula, nombre, apellidos, telefMovil, telefConvencional, direccion);
}

}Esta clase tiene los atributos que pide el enunciado y además un ArrayList donde se coleccionarán los libros que el socio tenga prestados.
Tiene métodos para poder prestarle un libro y retornar el libro prestado.
Otro método nos dice con un boolean si el usuario es confiable (tiene 10 o menos libros prestados) y otro lista en pantalla los libros que pueda tener prestados.

Luego tenemos la clase Libro y ocurre algo parecido como con Socio.
Uno de sus atributos es la Localización del libro, que es un dato compuesto por varios atributos así que podemos agruparlos en una única clase.
Y uno de esos atributos, el "area", también se nos dan una serie de valores determinados entre los que se puede escoger.
Así que también podemos modelar un enum para el dato de Area
public enum Area {

GENERALIDADES("Generalidades"), FILOSOFIA("Filosofia"), RELIGION("Religion"),
CIENCIAS_SOCIALES("Ciencias Sociales"),
FILOLOGIA("Filologia"), CIENCIAS_NATURALES("Ciencias Naturales"),
TECNICA_CIENCIA_PRACTICA("Tecnica y Ciencia Practica"),
ARTE_LITERATURA("Arte y Literatura"), HISTORIA("Historia");

private String valorArea;

private Area(String tipo) {
valorArea = tipo;
}

@Override
public String toString() {
return valorArea;
}

public static Area convertirCadena(String cadena) {
for (Area a: Area.values())
if (a.valorArea.equalsIgnoreCase(cadena))
return a;

return null;
}
}Este enum, será un atributo de la clase Localizacion
public class Localizacion {

String numPiso;
String numHabitacion;
String numEstante;
Area area;

public Localizacion() {
numPiso = "";
numHabitacion = "";
numEstante = "";
area = null;
}

public Localizacion(String numPiso, String numHabitacion, String numEstante, Area area) {
this.numPiso = numPiso;
this.numHabitacion = numHabitacion;
this.numEstante = numEstante;
this.area = area;
}

@Override
public String toString() {
return String.format("Piso: %s\tHabitacion: %s\nEstante: %s\tArea: %s", numPiso,
numHabitacion, numEstante, area);
}

}Y esta clase, será un atributo de la clase Libro
public class Libro {

private String codigo;
private String titulo;
private String autoria;
private boolean estaDisponible;
private Localizacion localizacion;

public Libro(String codigo, String titulo, String autoria, boolean estaDisponible,
Localizacion localizacion) {
this.codigo = codigo;
this.titulo = titulo;
this.autoria = autoria;
this.estaDisponible = estaDisponible;
this.localizacion = localizacion;
}

public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public String getTitulo() {
return titulo;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public String getAutoria() {
return autoria;
}
public void setAutoria(String autoria) {
this.autoria = autoria;
}
public boolean estaDisponible() {
return estaDisponible;
}
public void setDisponible(boolean disponibilidad) {
estaDisponible = disponibilidad;
}

public Localizacion getLocalizacion() {
return localizacion;
}

public void setLocalizacion(Localizacion localizacion) {
this.localizacion = localizacion;
}

@Override
public String toString() {
return String.format("Codigo: %s\tTitulo: %s\nAutoria: %s Disponible: %s\nLocalizacion:\n%s",
codigo, titulo, autoria, estaDisponible?"Si":"No", localizacion);
}

/*
* Dos libros son iguales si tienen el mismo codigo.
*/
@Override
public boolean equals(Object objeto) {
if (objeto instanceof Libro) {
Libro otroLibro = (Libro) objeto;
return codigo.equals(otroLibro.codigo);
}
else
return false;
}
}Para esta clase, nos conviene sobre escribirle el método equals() para indicar cuando dos libros deben considerarse como iguales.
Esto luego servirá para que se más fácil eliminar libros del ArrayList del socio, cuando este devuelva su préstamo.

Otra clase que interviene aquí, es la clase Autor, a quien podemos ponerle también un ArrayList para agrupar los libros que este autor ha escrito.
public class Autor {

private String nombre;
private String alias;
private String nacionalidad;
private String fechaNaci;
private ArrayList<Libro> libros;

public Autor(String nombre, String alias, String nacionalidad, String fechaNaci) {
this.nombre = nombre;
this.alias = alias;
this.nacionalidad = nacionalidad;
this.fechaNaci = fechaNaci;
libros = new ArrayList<Libro>();
}

public String getNombre() {
return nombre;
}

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

public String getAlias() {
return alias;
}

public void setAlias(String alias) {
this.alias = alias;
}

public String getNacionalidad() {
return nacionalidad;
}

public void setNacionalidad(String nacionalidad) {
this.nacionalidad = nacionalidad;
}

public String getFechaNaci() {
return fechaNaci;
}

public void setFechaNaci(String fechaNaci) {
this.fechaNaci = fechaNaci;
}

public void agregarLibro(Libro lib) {
libros.add(lib);
}

public void listarLibros() {
for (Libro l: libros)
System.out.println(l);
}

@Override
public String toString() {
return String.format("Nombre: %s\tAlias: %s\nNacionalidad: %s\tFecha Nacimiento: %s",
nombre, alias, nacionalidad, fechaNaci);
}

}
Y nos queda la clase Prestamo, a quién también le sobreescribiremos el método equals(), ya que en la clase principal tendremos un ArrayList con prestamos, y habrá que eliminarlos cuando los libros sean devueltos.

public class Prestamo {

private String codigoLibro;
private String numSocio;
private String fecha;

public Prestamo(String codigoLibro, String numSocio, String fecha) {
this.codigoLibro = codigoLibro;
this.numSocio = numSocio;
this.fecha = fecha;
}

public String getCodigoLibro() {
return codigoLibro;
}

public void setCodigoLibro(String codigoLibro) {
this.codigoLibro = codigoLibro;
}

public String getNumSocio() {
return numSocio;
}

public void setNumSocio(String numSocio) {
this.numSocio = numSocio;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

@Override
public String toString() {
return String.format("Codigo Libro: %s\tNumero Socio: %s\nFecha: %s", codigoLibro,
numSocio, fecha);
}

/*
* Dos prestamos se consideran iguales si coincide el codigo de libro
* y el codigo de socio
*/
@Override
public boolean equals(Object objeto) {
if (objeto instanceof Prestamo) {
Prestamo otroPrestamo = (Prestamo) objeto;
return codigoLibro.equals(otroPrestamo.codigoLibro) && numSocio.equals(otroPrestamo.numSocio);
}
else
return false;
}

}
En el siguiente mensaje vemos la clase principal

¿Y en que parte tienes problemas?
¿Qué es lo que no entiendes?

¿Qué clases has identificado tú? Es evidente que habrá que escribir las clases Socio y Libro.
Pero, ¿hay más clases?

¿Y en que lenguaje tienes que escribirlo? ¿En modo texto/consola o con interfaz gráfica?