Patrón Command

1import java.math.*;
2import java.util.*;
3
4/** El receptor: la calculadora solo sabe su valor. */
5class Calculadora {
6    double valor = 0;
7}
8
9interface Comando {
10    void ejecutar();
11    void deshacer();
12    String descripcion();
13}
14
15/** Base de las operaciones: recuerda el valor de antes para poder deshacer. */
16abstract class Operacion implements Comando {
17    protected final Calculadora calc;
18    protected final double x;
19    private final String simbolo;
20    private double antes;
21
22    Operacion(Calculadora calc, double x, String simbolo) {
23        this.calc = calc;
24        this.x = x;
25        this.simbolo = simbolo;
26    }
27
28    protected abstract double aplicar(double v);
29
30    public void ejecutar() {
31        antes = calc.valor;                     // lo que hace falta para deshacer, antes de cambiar nada
32        calc.valor = aplicar(calc.valor);
33    }
34
35    public void deshacer() {
36        calc.valor = antes;
37    }
38
39    public String descripcion() { return simbolo + " " + Main.num(x); }
40}
41
42class Sumar extends Operacion {
43    Sumar(Calculadora c, double x) { super(c, x, "+"); }
44    protected double aplicar(double v) { return v + x; }
45}
46
47class Restar extends Operacion {
48    Restar(Calculadora c, double x) { super(c, x, "-"); }
49    protected double aplicar(double v) { return v - x; }
50}
51
52class Multiplicar extends Operacion {
53    Multiplicar(Calculadora c, double x) { super(c, x, "×"); }
54    protected double aplicar(double v) { return v * x; }
55}
56
57class Dividir extends Operacion {
58    Dividir(Calculadora c, double x) {
59        super(c, x, "÷");
60        if (x == 0) throw new ArithmeticException("No se puede dividir entre 0");
61    }
62    protected double aplicar(double v) { return v / x; }
63}
64
65/** El invocador: ejecuta las operaciones y las apila para deshacerlas en orden inverso. */
66class Historial {
67    private final Deque<Comando> hechos = new ArrayDeque<>();
68
69    void ejecutar(Comando c) {
70        c.ejecutar();
71        hechos.push(c);
72    }
73
74    /** Deshace la última operación y devuelve su descripción, o null si no hay nada. */
75    String deshacer() {
76        if (hechos.isEmpty()) return null;
77        Comando c = hechos.pop();
78        c.deshacer();
79        return c.descripcion();
80    }
81
82    List<String> descripciones() {
83        List<String> l = new ArrayList<>();
84        for (Comando c : hechos) l.add(c.descripcion());
85        Collections.reverse(l);                   // la pila tiene la última arriba
86        return l;
87    }
88}
89
90public class Main {
91    static String num(double x) {
92        return BigDecimal.valueOf(x).setScale(2, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString().replace('.', ',');
93    }
94
95    public static void main(String[] args) {
96        Calculadora calc = new Calculadora();
97        Historial historial = new Historial();
98        Scanner sc = new Scanner(System.in);
99        while (sc.hasNextLine()) {
100            String linea = sc.nextLine().trim();
101            if (linea.isEmpty()) continue;
102            String[] p = linea.split("\\s+");
103            try {
104                switch (p[0]) {
105                    case "sumar", "restar", "multiplicar", "dividir" -> {
106                        if (p.length != 2) throw new NumberFormatException();
107                        double x = Double.parseDouble(p[1]);
108                        Comando c = switch (p[0]) {
109                            case "sumar" -> new Sumar(calc, x);
110                            case "restar" -> new Restar(calc, x);
111                            case "multiplicar" -> new Multiplicar(calc, x);
112                            default -> new Dividir(calc, x);
113                        };
114                        historial.ejecutar(c);
115                        System.out.println(c.descripcion() + " = " + num(calc.valor));
116                    }
117                    case "deshacer" -> {
118                        String d = historial.deshacer();
119                        System.out.println(d == null ? "Nada que deshacer" : "Deshecho: " + d + " (vuelve a " + num(calc.valor) + ")");
120                    }
121                    case "historial" -> {
122                        List<String> l = historial.descripciones();
123                        System.out.println(l.isEmpty() ? "Historial vacío" : "Historial: " + String.join(", ", l));
124                    }
125                    default -> System.out.println("Orden no válida: " + linea);
126                }
127            } catch (NumberFormatException e) {
128                System.out.println("Orden no válida: " + linea);
129            } catch (ArithmeticException e) {
130                System.out.println(e.getMessage());
131            }
132        }
133        System.out.println("Resultado: " + num(calc.valor));
134    }
135}

1import java.util.*;
2
3// ───── Los receptores ─────
4class Luz {
5    final String nombre;
6    boolean encendida = false;
7    int brillo = 100;
8    Luz(String nombre) { this.nombre = nombre; }
9    public String toString() { return nombre + ": " + (encendida ? "encendida (" + brillo + " %)" : "apagada"); }
10}
11
12class Termostato {
13    int grados = 20;
14    public String toString() { return "termostato: " + grados + " °C"; }
15}
16
17interface Comando {
18    void ejecutar();
19    void deshacer();
20    String descripcion();
21}
22
23// ───── Los comandos: cada uno guarda lo que necesita para deshacerse ─────
24class Encender implements Comando {
25    private final Luz luz;
26    private final boolean encender;
27    private boolean antes;
28    Encender(Luz luz, boolean encender) { this.luz = luz; this.encender = encender; }
29    public void ejecutar() { antes = luz.encendida; luz.encendida = encender; }
30    public void deshacer() { luz.encendida = antes; }
31    public String descripcion() { return (encender ? "encender " : "apagar ") + luz.nombre; }
32}
33
34class Brillo implements Comando {
35    private final Luz luz;
36    private final int brillo;
37    private int brilloAntes;
38    private boolean encendidaAntes;
39    Brillo(Luz luz, int brillo) { this.luz = luz; this.brillo = brillo; }
40    public void ejecutar() {
41        brilloAntes = luz.brillo;
42        encendidaAntes = luz.encendida;
43        luz.brillo = brillo;
44        luz.encendida = true;
45    }
46    public void deshacer() { luz.brillo = brilloAntes; luz.encendida = encendidaAntes; }
47    public String descripcion() { return "brillo " + luz.nombre + " " + brillo + " %"; }
48}
49
50class Temperatura implements Comando {
51    private final Termostato t;
52    private final int grados;
53    private int antes;
54    Temperatura(Termostato t, int grados) { this.t = t; this.grados = grados; }
55    public void ejecutar() { antes = t.grados; t.grados = grados; }
56    public void deshacer() { t.grados = antes; }
57    public String descripcion() { return "termostato a " + grados + " °C"; }
58}
59
60/** Un comando hecho de comandos: se ejecuta y se deshace como una sola cosa. */
61class Macro implements Comando {
62    private final String nombre;
63    private final List<Comando> pasos;
64    Macro(String nombre, List<Comando> pasos) { this.nombre = nombre; this.pasos = pasos; }
65
66    public void ejecutar() {
67        for (Comando c : pasos) c.ejecutar();
68    }
69
70    public void deshacer() {
71        for (int i = pasos.size() - 1; i >= 0; i--) pasos.get(i).deshacer();   // al revés
72    }
73
74    public String descripcion() { return "macro " + nombre + " (" + pasos.size() + " órdenes)"; }
75}
76
77/** Deshacer y rehacer con dos pilas. */
78class Historial {
79    private final Deque<Comando> hechos = new ArrayDeque<>();
80    private final Deque<Comando> deshechos = new ArrayDeque<>();
81
82    void ejecutar(Comando c) {
83        c.ejecutar();
84        hechos.push(c);
85        deshechos.clear();                        // una orden nueva hace imposible rehacer lo anterior
86    }
87
88    String deshacer() {
89        if (hechos.isEmpty()) return null;
90        Comando c = hechos.pop();
91        c.deshacer();
92        deshechos.push(c);
93        return c.descripcion();
94    }
95
96    String rehacer() {
97        if (deshechos.isEmpty()) return null;
98        Comando c = deshechos.pop();
99        c.ejecutar();
100        hechos.push(c);
101        return c.descripcion();
102    }
103}
104
105public class Main {
106    public static void main(String[] args) {
107        Map<String, Luz> luces = new LinkedHashMap<>();
108        for (String n : List.of("salon", "cocina", "dormitorio")) luces.put(n, new Luz(n));
109        Termostato termo = new Termostato();
110        Historial historial = new Historial();
111        Scanner sc = new Scanner(System.in);
112        while (sc.hasNextLine()) {
113            String linea = sc.nextLine().trim();
114            if (linea.isEmpty()) continue;
115            String[] p = linea.split("\\s+");
116            try {
117                Comando c = null;
118                switch (p[0] + "/" + p.length) {
119                    case "luz/3" -> {
120                        Luz l = luces.get(p[1]);
121                        if (l == null) { System.out.println("No existe la luz: " + p[1]); continue; }
122                        if (!p[2].equals("on") && !p[2].equals("off")) throw new NumberFormatException();
123                        c = new Encender(l, p[2].equals("on"));
124                    }
125                    case "brillo/3" -> {
126                        Luz l = luces.get(p[1]);
127                        if (l == null) { System.out.println("No existe la luz: " + p[1]); continue; }
128                        int b = Integer.parseInt(p[2]);
129                        if (b < 1 || b > 100) { System.out.println("Brillo no válido: " + b); continue; }
130                        c = new Brillo(l, b);
131                    }
132                    case "termo/2" -> c = new Temperatura(termo, Integer.parseInt(p[1]));
133                    case "macro/2" -> {
134                        List<Comando> pasos = new ArrayList<>();
135                        switch (p[1]) {
136                            case "noche" -> {
137                                for (Luz l : luces.values()) pasos.add(new Encender(l, false));
138                                pasos.add(new Temperatura(termo, 18));
139                            }
140                            case "llegar" -> {
141                                pasos.add(new Brillo(luces.get("salon"), 80));
142                                pasos.add(new Temperatura(termo, 21));
143                            }
144                            default -> { System.out.println("No existe la macro: " + p[1]); continue; }
145                        }
146                        c = new Macro(p[1], pasos);
147                    }
148                    case "deshacer/1" -> {
149                        String d = historial.deshacer();
150                        System.out.println(d == null ? "Nada que deshacer" : "Deshecho: " + d);
151                    }
152                    case "rehacer/1" -> {
153                        String d = historial.rehacer();
154                        System.out.println(d == null ? "Nada que rehacer" : "Rehecho: " + d);
155                    }
156                    case "estado/1" -> {
157                        List<String> partes = new ArrayList<>();
158                        for (Luz l : luces.values()) partes.add(l.toString());
159                        partes.add(termo.toString());
160                        System.out.println(String.join(" · ", partes));
161                    }
162                    default -> throw new NumberFormatException();
163                }
164                if (c != null) {
165                    historial.ejecutar(c);
166                    System.out.println("Hecho: " + c.descripcion());
167                }
168            } catch (NumberFormatException e) {
169                System.out.println("Orden no válida: " + linea);
170            }
171        }
172    }
173}