Patrón Inyección de dependencias

1import java.math.*;
2import java.util.*;
3
4interface Impuesto {
5    String nombre();
6    double aplicar(double base);
7}
8
9class IvaEspana implements Impuesto {
10    public String nombre() { return "IVA 21 %"; }
11    public double aplicar(double base) { return base * 1.21; }
12}
13
14class IvaPortugal implements Impuesto {
15    public String nombre() { return "IVA 23 %"; }
16    public double aplicar(double base) { return base * 1.23; }
17}
18
19class IgiCanarias implements Impuesto {
20    public String nombre() { return "IGIC 7 %"; }
21    public double aplicar(double base) { return base * 1.07; }
22}
23
24interface Descuento {
25    String nombre();
26    double aplicar(double precio);
27}
28
29class SinDescuento implements Descuento {
30    public String nombre() { return "sin descuento"; }
31    public double aplicar(double precio) { return precio; }
32}
33
34class DescuentoJoven implements Descuento {
35    public String nombre() { return "carné joven -15 %"; }
36    public double aplicar(double precio) { return precio * 0.85; }
37}
38
39class DescuentoFijo implements Descuento {
40    private final double euros;
41    DescuentoFijo(double euros) { this.euros = euros; }
42    public String nombre() { return "cupón -" + Main.euros(euros); }
43    public double aplicar(double precio) { return Math.max(0, precio - euros); }
44}
45
46/** Calcula precios con el impuesto y el descuento que le inyectan: no elige ninguno. */
47class CalculadoraPrecio {
48    private final Impuesto impuesto;
49    private final Descuento descuento;
50
51    CalculadoraPrecio(Impuesto impuesto, Descuento descuento) {
52        this.impuesto = impuesto;
53        this.descuento = descuento;
54    }
55
56    double precio(double base) {
57        return descuento.aplicar(impuesto.aplicar(base));       // primero el impuesto, después el descuento
58    }
59
60    String detalle() { return impuesto.nombre() + ", " + descuento.nombre(); }
61}
62
63public class Main {
64    static String euros(double x) {
65        return BigDecimal.valueOf(x).setScale(2, RoundingMode.HALF_UP).toPlainString().replace('.', ',') + " €";
66    }
67
68    public static void main(String[] args) {
69        Impuesto impuesto = new IvaEspana();
70        Descuento descuento = new SinDescuento();
71        Scanner sc = new Scanner(System.in);
72        while (sc.hasNextLine()) {
73            String[] p = sc.nextLine().trim().split("\\s+");
74            if (p[0].isEmpty()) continue;
75            try {
76                switch (p[0] + "/" + (p.length - 1)) {
77                    case "zona/1" -> impuesto = switch (p[1]) {
78                        case "es" -> new IvaEspana();
79                        case "pt" -> new IvaPortugal();
80                        case "canarias" -> new IgiCanarias();
81                        default -> throw new IllegalArgumentException("Zona desconocida: " + p[1]);
82                    };
83                    case "descuento/1" -> descuento = switch (p[1]) {
84                        case "ninguno" -> new SinDescuento();
85                        case "joven" -> new DescuentoJoven();
86                        default -> {
87                            if (!p[1].startsWith("cupon")) throw new IllegalArgumentException("Descuento desconocido: " + p[1]);
88                            yield new DescuentoFijo(Double.parseDouble(p[1].substring(5)));
89                        }
90                    };
91                    case "precio/1" -> {
92                        // El main es el «ensamblador»: crea la calculadora con las piezas elegidas
93                        CalculadoraPrecio c = new CalculadoraPrecio(impuesto, descuento);
94                        System.out.println(euros(Double.parseDouble(p[1])) + " → " + euros(c.precio(Double.parseDouble(p[1]))) + " (" + c.detalle() + ")");
95                    }
96                    default -> System.out.println("Orden no válida: " + String.join(" ", p));
97                }
98            } catch (NumberFormatException e) {
99                System.out.println("Orden no válida: " + String.join(" ", p));
100            } catch (IllegalArgumentException e) {
101                System.out.println(e.getMessage());
102            }
103        }
104    }
105}

1import java.util.*;
2import java.util.function.Supplier;
3
4/** Un contenedor de dependencias mínimo: sabe cómo crear cada tipo y si se comparte. */
5class Contenedor {
6    private final Map<Class<?>, Supplier<?>> fabricas = new HashMap<>();
7    private final Map<Class<?>, Object> compartidos = new HashMap<>();
8    private final Set<Class<?>> unicos = new HashSet<>();
9
10    /** Cada obtener crea un objeto nuevo. */
11    <T> void registrar(Class<T> tipo, Supplier<? extends T> fabrica) {
12        fabricas.put(tipo, fabrica);
13        unicos.remove(tipo);
14        compartidos.remove(tipo);
15    }
16
17    /** Se crea la primera vez que se pide y después siempre se devuelve el mismo. */
18    <T> void singleton(Class<T> tipo, Supplier<? extends T> fabrica) {
19        fabricas.put(tipo, fabrica);
20        unicos.add(tipo);
21        compartidos.remove(tipo);
22    }
23
24    <T> T obtener(Class<T> tipo) {
25        Supplier<?> f = fabricas.get(tipo);
26        if (f == null) throw new IllegalStateException("No hay nada registrado para " + tipo.getSimpleName());
27        if (!unicos.contains(tipo)) return tipo.cast(f.get());
28        return tipo.cast(compartidos.computeIfAbsent(tipo, t -> f.get()));
29    }
30}
31
32// ───── Las piezas de una aplicación pequeña ─────
33interface Registro { void escribir(String s); List<String> lineas(); }
34class RegistroMemoria implements Registro {
35    static int creados = 0;
36    private final List<String> lineas = new ArrayList<>();
37    RegistroMemoria() { creados++; }
38    public void escribir(String s) { lineas.add(s); }
39    public List<String> lineas() { return lineas; }
40}
41
42interface Reloj { String ahora(); }
43class RelojFijo implements Reloj {
44    private int tic = 0;
45    public String ahora() { return String.format("10:%02d", tic++); }
46}
47
48/** Recibe sus dependencias en el constructor: el contenedor se las da. */
49class ServicioAvisos {
50    static int creados = 0;
51    private final Registro registro;
52    private final Reloj reloj;
53    ServicioAvisos(Registro registro, Reloj reloj) { this.registro = registro; this.reloj = reloj; creados++; }
54    void avisar(String texto) { registro.escribir(reloj.ahora() + " " + texto); }
55}
56
57public class Main {
58    public static void main(String[] args) {
59        Contenedor c = new Contenedor();
60        Scanner sc = new Scanner(System.in);
61        while (sc.hasNextLine()) {
62            String linea = sc.nextLine().trim();
63            if (linea.isEmpty()) continue;
64            try {
65                switch (linea) {
66                    case "registrar registro" -> c.registrar(Registro.class, RegistroMemoria::new);
67                    case "singleton registro" -> c.singleton(Registro.class, RegistroMemoria::new);
68                    case "singleton reloj" -> c.singleton(Reloj.class, RelojFijo::new);
69                    case "registrar servicio" -> c.registrar(ServicioAvisos.class, () -> new ServicioAvisos(c.obtener(Registro.class), c.obtener(Reloj.class)));
70                    case "mismo registro" -> System.out.println("¿Mismo registro? " + (c.obtener(Registro.class) == c.obtener(Registro.class) ? "sí" : "no"));
71                    case "mismo servicio" -> System.out.println("¿Mismo servicio? " + (c.obtener(ServicioAvisos.class) == c.obtener(ServicioAvisos.class) ? "sí" : "no"));
72                    case "registro" -> {
73                        List<String> l = c.obtener(Registro.class).lineas();
74                        System.out.println("Registro: " + (l.isEmpty() ? "(vacío)" : String.join(" | ", l)));
75                    }
76                    default -> {
77                        if (!linea.startsWith("avisar ")) throw new IllegalArgumentException();
78                        c.obtener(ServicioAvisos.class).avisar(linea.substring(7));
79                        System.out.println("Avisado: " + linea.substring(7));
80                    }
81                }
82            } catch (IllegalStateException e) {
83                System.out.println(e.getMessage());
84            } catch (IllegalArgumentException e) {
85                System.out.println("Orden no válida: " + linea);
86            }
87        }
88        System.out.println("Registros creados: " + RegistroMemoria.creados + " · servicios creados: " + ServicioAvisos.creados);
89    }
90}