Del diagrama de clases al código: una flota de alquiler

Ejercicio de JavaMedioUnos 70 minutos

Traduce a Java un diagrama de clases UML: una interfaz realizada, una clase abstracta con su método abstracto, dos subclases que redefinen métodos, una composición 1 a muchos y una asociación con multiplicidad; y úsalo para gestionar los alquileres y las revisiones de una flota de vehículos.

Leer un diagrama de clases
Realización de interfaces
Clases y métodos abstractos
Herencia y redefinición
Composición y asociación
Visibilidad (+ y -)

Enunciado

El diagrama de clases es el plano del programa: cada caja es una clase con sus atributos y sus métodos (- privado, + público, en cursiva o con {abstract} los abstractos) y cada flecha una relación. Pasar del diagrama al código es casi mecánico, y es lo que piden muchos exámenes de Entornos de Desarrollo y de Programación.

El diagrama de este ejercicio (en PlantUML, también en el código de partida; puedes pegarlo en el editor UML de la web para verlo dibujado) describe una empresa de alquiler: Revisable <|.. Vehiculo es una realización (implements), Vehiculo <|-- Coche una herencia (extends), Flota *-- Vehiculo una composición (la flota contiene sus vehículos, en una lista) y Alquiler --> Vehiculo una asociación navegable (el alquiler conoce su vehículo).

Qué tiene que hacer el programa

Escribe la interfaz y las cinco clases del diagrama con los atributos, la visibilidad y los métodos que indica, y estas reglas: precioDia de un coche es 30 € + 4 € por plaza y el de una furgoneta 50 € + 0,02 € por kg de carga; precio(dias) es precioDia() × dias, salvo en la furgoneta, que desde 7 días tiene un 10 % de descuento sobre todo; un vehículo necesitaRevision si ha hecho 15.000 km o más desde la última revisión, y revisar la pone en sus km actuales.
Alquiler.importe() es el precio de los días más 0,15 € por cada km por encima de los 200 incluidos por día. Flota.alta devuelve false si ya hay un vehículo con esa matrícula. toString de un coche: Coche de P plazas; de una furgoneta: Furgoneta de C kg.
Órdenes: coche M P y furgoneta M C dan de alta (Alta: <toString> M o Ya existe un vehículo con matrícula M); alquilar M D K escribe Alquiler de M (<toString>): D días, K km → X (1 día) y suma los km al vehículo; revisar M escribe M revisado a los K km; las dos con No existe el vehículo M si no está.
pendientes escribe Pendientes de revisión: y las matrículas separadas por , en el orden de alta, o ninguno. flota escribe Flota (N vehículos): (1 vehículo) y, por cada uno, M · <toString> · K km · X/día, más · revisión pendiente si la necesita.
Una orden desconocida, con un número de datos distinto o con números no válidos (no enteros, plazas, carga o días de 0 o menos, km negativos): Orden no válida: línea. Al final: Facturado: X en N alquileres (1 alquiler). Los importes, con dos decimales, coma y €.

Entrada

Una orden por línea: coche M P, furgoneta M C, alquilar M D K, revisar M, pendientes o flota.

Ejemplos de ejecución

Tu programa debe escribir exactamente esta salida para estas entradas. Las pruebas del editor incluyen estos ejemplos y otros casos ocultos.

Una flota con dos vehículos

Entrada

coche 1234ABC 5
furgoneta 5678DEF 1200
coche 1234ABC 7
alquilar 1234ABC 3 750
alquilar 5678DEF 7 16000
pendientes
flota
revisar 5678DEF
pendientes

Salida por consola

Alta: Coche de 5 plazas 1234ABC
Alta: Furgoneta de 1200 kg 5678DEF
Ya existe un vehículo con matrícula 1234ABC
Alquiler de 1234ABC (Coche de 5 plazas): 3 días, 750 km → 172,50 €
Alquiler de 5678DEF (Furgoneta de 1200 kg): 7 días, 16000 km → 2656,20 €
Pendientes de revisión: 5678DEF
Flota (2 vehículos):
  1234ABC · Coche de 5 plazas · 750 km · 50,00 €/día
  5678DEF · Furgoneta de 1200 kg · 16000 km · 74,00 €/día · revisión pendiente
5678DEF revisado a los 16000 km
Pendientes de revisión: ninguno
Facturado: 2828,70 € en 2 alquileres

Órdenes erróneas

Entrada

coche 1111AAA cinco
furgoneta 2222BBB
alquilar 9999ZZZ 2 100
coche 3333CCC 4
alquilar 3333CCC 0 10
alquilar 3333CCC 1 150
volar 3333CCC
revisar 0000XXX
flota

Salida por consola

Orden no válida: coche 1111AAA cinco
Orden no válida: furgoneta 2222BBB
No existe el vehículo 9999ZZZ
Alta: Coche de 4 plazas 3333CCC
Orden no válida: alquilar 3333CCC 0 10
Alquiler de 3333CCC (Coche de 4 plazas): 1 día, 150 km → 46,00 €
Orden no válida: volar 3333CCC
No existe el vehículo 0000XXX
Flota (1 vehículo):
  3333CCC · Coche de 4 plazas · 150 km · 46,00 €/día
Facturado: 46,00 € en 1 alquiler

Guía paso a paso

Intenta resolverlo por tu cuenta y abre un paso solo cuando te atasques: cada uno te acerca a la solución sin dártela entera.

1. De la caja a la clase

Cada atributo con - es un private; cada método con + un public. {abstract} en un método obliga a declarar la clase abstract y a que cada subclase lo implemente.

java
abstract class Vehiculo implements Revisable {
    private final String matricula;
    private int km;
    private int kmUltimaRevision;

    public abstract double precioDia();
}

2. Las flechas

Triángulo hueco con línea discontinua: implements; con línea continua: extends. Rombo relleno con 0..*: un atributo List<Vehiculo> creado y gestionado por la flota. Flecha simple hacia Vehiculo con multiplicidad 1: un atributo Vehiculo en Alquiler.

3. Redefinir con super

La furgoneta redefine precio reutilizando el de su madre: super.precio(dias) y aplica el descuento encima.

4. El main

Un switch con flechas sobre la orden y un try que capture IllegalArgumentException (que incluye NumberFormatException) para todas las órdenes mal escritas.

Resuélvelo aquí

El editor trae el esqueleto del programa. Pulsa «Ejecutar» para comprobarlo con los ejemplos y con 2 casos ocultos que buscan los errores típicos.

☕JavaDel diagrama de clases al código: una flota de alquilerMedio

Ejemplo

Entrada (lo que se escribe por teclado)

coche 1234ABC 5
furgoneta 5678DEF 1200
coche 1234ABC 7
alquilar 1234ABC 3 750
alquilar 5678DEF 7 16000
pendientes
flota
revisar 5678DEF
pendientes

Salida esperada

Alta: Coche de 5 plazas 1234ABC
Alta: Furgoneta de 1200 kg 5678DEF
Ya existe un vehículo con matrícula 1234ABC
Alquiler de 1234ABC (Coche de 5 plazas): 3 días, 750 km → 172,50 €
Alquiler de 5678DEF (Furgoneta de 1200 kg): 7 días, 16000 km → 2656,20 €
Pendientes de revisión: 5678DEF
Flota (2 vehículos):
  1234ABC · Coche de 5 plazas · 750 km · 50,00 €/día
  5678DEF · Furgoneta de 1200 kg · 16000 km · 74,00 €/día · revisión pendiente
5678DEF revisado a los 16000 km
Pendientes de revisión: ninguno
Facturado: 2828,70 € en 2 alquileres

⏳

Una flota con dos vehículos

⏳

Órdenes erróneas

⏳

Test oculto #3

⏳

Test oculto #4

0/4 tests pasados · pulsa un test para ver su entrada y su salida esperada

Solución explicada

Ver la solución completa

java
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Scanner;

/*
@startuml
interface Revisable {
  +necesitaRevision(): boolean
  +revisar(): void
}
abstract class Vehiculo {
  -matricula: String
  -km: int
  -kmUltimaRevision: int
  +Vehiculo(matricula: String)
  +getMatricula(): String
  +getKm(): int
  +recorrer(km: int): void
  +{abstract} precioDia(): double
  +precio(dias: int): double
  +necesitaRevision(): boolean
  +revisar(): void
}
class Coche {
  -plazas: int
  +Coche(matricula: String, plazas: int)
  +precioDia(): double
  +toString(): String
}
class Furgoneta {
  -cargaKg: int
  +Furgoneta(matricula: String, cargaKg: int)
  +precioDia(): double
  +precio(dias: int): double
  +toString(): String
}
class Flota {
  -vehiculos: List<Vehiculo>
  +alta(v: Vehiculo): boolean
  +buscar(matricula: String): Vehiculo
  +getVehiculos(): List<Vehiculo>
  +pendientesDeRevision(): List<Vehiculo>
}
class Alquiler {
  -dias: int
  -km: int
  +Alquiler(vehiculo: Vehiculo, dias: int, km: int)
  +importe(): double
}
Revisable <|.. Vehiculo
Vehiculo <|-- Coche
Vehiculo <|-- Furgoneta
Flota "1" *-- "0..*" Vehiculo
Alquiler "0..*" --> "1" Vehiculo : vehiculo
@enduml
*/

interface Revisable {
    boolean necesitaRevision();
    void revisar();
}

abstract class Vehiculo implements Revisable {
    static final int KM_ENTRE_REVISIONES = 15000;
    private final String matricula;
    private int km;
    private int kmUltimaRevision;

    Vehiculo(String matricula) {
        this.matricula = matricula;
    }

    public String getMatricula() { return matricula; }
    public int getKm() { return km; }

    public void recorrer(int km) {
        this.km += km;
    }

    public abstract double precioDia();

    public double precio(int dias) {
        return precioDia() * dias;
    }

    @Override
    public boolean necesitaRevision() {
        return km - kmUltimaRevision >= KM_ENTRE_REVISIONES;
    }

    @Override
    public void revisar() {
        kmUltimaRevision = km;
    }
}

class Coche extends Vehiculo {
    private final int plazas;

    Coche(String matricula, int plazas) {
        super(matricula);
        this.plazas = plazas;
    }

    @Override
    public double precioDia() {
        return 30 + 4 * plazas;
    }

    @Override
    public String toString() {
        return "Coche de " + plazas + " plazas";
    }
}

class Furgoneta extends Vehiculo {
    private final int cargaKg;

    Furgoneta(String matricula, int cargaKg) {
        super(matricula);
        this.cargaKg = cargaKg;
    }

    @Override
    public double precioDia() {
        return 50 + 0.02 * cargaKg;
    }

    /** Desde 7 días, un 10 % de descuento sobre todo el alquiler. */
    @Override
    public double precio(int dias) {
        double p = super.precio(dias);
        return dias >= 7 ? p * 0.9 : p;
    }

    @Override
    public String toString() {
        return "Furgoneta de " + cargaKg + " kg";
    }
}

class Flota {
    private final List<Vehiculo> vehiculos = new ArrayList<>();

    public boolean alta(Vehiculo v) {
        if (buscar(v.getMatricula()) != null) return false;
        vehiculos.add(v);
        return true;
    }

    public Vehiculo buscar(String matricula) {
        for (Vehiculo v : vehiculos) if (v.getMatricula().equals(matricula)) return v;
        return null;
    }

    public List<Vehiculo> getVehiculos() { return vehiculos; }

    public List<Vehiculo> pendientesDeRevision() {
        List<Vehiculo> r = new ArrayList<>();
        for (Vehiculo v : vehiculos) if (v.necesitaRevision()) r.add(v);
        return r;
    }
}

class Alquiler {
    static final int KM_INCLUIDOS_DIA = 200;
    static final double PRECIO_KM_EXTRA = 0.15;
    private final Vehiculo vehiculo;
    private final int dias;
    private final int km;

    Alquiler(Vehiculo vehiculo, int dias, int km) {
        this.vehiculo = vehiculo;
        this.dias = dias;
        this.km = km;
    }

    public double importe() {
        int extra = Math.max(0, km - KM_INCLUIDOS_DIA * dias);
        return vehiculo.precio(dias) + extra * PRECIO_KM_EXTRA;
    }
}

public class Main {
    static String euros(double x) {
        return String.format(Locale.ROOT, "%.2f", x).replace('.', ',') + " €";
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Flota flota = new Flota();
        double facturado = 0;
        int alquileres = 0;
        while (sc.hasNextLine()) {
            String linea = sc.nextLine().trim();
            if (linea.isEmpty()) continue;
            String[] p = linea.split("\\s+");
            try {
                switch (p[0]) {
                    case "coche", "furgoneta" -> {
                        if (p.length != 3) throw new IllegalArgumentException();
                        int n = Integer.parseInt(p[2]);
                        if (n <= 0) throw new IllegalArgumentException();
                        Vehiculo v = p[0].equals("coche") ? new Coche(p[1], n) : new Furgoneta(p[1], n);
                        System.out.println(flota.alta(v) ? "Alta: " + v + " " + p[1] : "Ya existe un vehículo con matrícula " + p[1]);
                    }
                    case "alquilar" -> {
                        if (p.length != 4) throw new IllegalArgumentException();
                        int dias = Integer.parseInt(p[2]), km = Integer.parseInt(p[3]);
                        if (dias <= 0 || km < 0) throw new IllegalArgumentException();
                        Vehiculo v = flota.buscar(p[1]);
                        if (v == null) {
                            System.out.println("No existe el vehículo " + p[1]);
                            break;
                        }
                        double importe = new Alquiler(v, dias, km).importe();
                        v.recorrer(km);
                        facturado += importe;
                        alquileres++;
                        System.out.println("Alquiler de " + p[1] + " (" + v + "): " + dias + (dias == 1 ? " día, " : " días, ") + km + " km → " + euros(importe));
                    }
                    case "revisar" -> {
                        if (p.length != 2) throw new IllegalArgumentException();
                        Vehiculo v = flota.buscar(p[1]);
                        if (v == null) {
                            System.out.println("No existe el vehículo " + p[1]);
                            break;
                        }
                        v.revisar();
                        System.out.println(p[1] + " revisado a los " + v.getKm() + " km");
                    }
                    case "pendientes" -> {
                        List<String> m = new ArrayList<>();
                        for (Vehiculo v : flota.pendientesDeRevision()) m.add(v.getMatricula());
                        System.out.println("Pendientes de revisión: " + (m.isEmpty() ? "ninguno" : String.join(", ", m)));
                    }
                    case "flota" -> {
                        int n = flota.getVehiculos().size();
                        System.out.println("Flota (" + n + (n == 1 ? " vehículo):" : " vehículos):"));
                        for (Vehiculo v : flota.getVehiculos()) {
                            System.out.println("  " + v.getMatricula() + " · " + v + " · " + v.getKm() + " km · " + euros(v.precioDia()) + "/día"
                                    + (v.necesitaRevision() ? " · revisión pendiente" : ""));
                        }
                    }
                    default -> throw new IllegalArgumentException();
                }
            } catch (IllegalArgumentException e) {      // NumberFormatException también lo es
                System.out.println("Orden no válida: " + linea);
            }
        }
        System.out.println("Facturado: " + euros(facturado) + " en " + alquileres + (alquileres == 1 ? " alquiler" : " alquileres"));
    }
}

La interfaz Revisable la realiza Vehiculo, y por herencia también la cumplen Coche y Furgoneta: la flota pregunta a cada vehículo si necesita revisión sin saber de qué tipo es (polimorfismo).

La composición (rombo relleno) significa que los vehículos pertenecen a la flota: los crea, los guarda y los busca ella. La asociación de Alquiler es más débil: el alquiler solo apunta a un vehículo que existe por su cuenta.

El precio de la furgoneta muestra la redefinición: Alquiler.importe() llama a vehiculo.precio(dias) y Java ejecuta la versión de la clase real del objeto, con descuento o sin él.

Los atributos privados con métodos públicos que los usan (recorrer, revisar) son la encapsulación del diagrama: nadie puede bajar los km de un vehículo desde fuera.

Para ir más allá

Añade una clase Moto al diagrama y al código, sin tocar Flota ni Alquiler.
Dibuja el diagrama de secuencia de la orden alquilar.
Guarda el historial de alquileres de cada vehículo (una nueva asociación 1 -- 0..*) y muestra el más caro.

Del diagrama de clases al código: una flota de alquiler

Enunciado

Qué tiene que hacer el programa

Entrada

Ejemplos de ejecución

Una flota con dos vehículos

Órdenes erróneas

Guía paso a paso

Resuélvelo aquí

Solución explicada

Para ir más allá

Dónde se explica