#24 - java, javascript, php y typescript

eulogioep · eulogioep · commit 5f6cb011f9ce · 2024-10-23T18:04:03.000+02:00
diff --git a/Roadmap/24 - DECORADORES/java/eulogioep.java b/Roadmap/24 - DECORADORES/java/eulogioep.java
@@ -0,0 +1,132 @@
+/*
+ * TEORÍA DE DECORADORES (ANOTACIONES) EN JAVA
+ * 
+ * En Java, los decoradores se llaman "anotaciones" y se definen usando @interface.
+ * Las anotaciones permiten añadir metadatos a:
+ * - Clases
+ * - Métodos
+ * - Campos
+ * - Parámetros
+ * 
+ * Características principales:
+ * - Se definen con @interface
+ * - Pueden tener elementos con valores por defecto
+ * - Se procesan en tiempo de compilación o ejecución
+ * - Se pueden consultar mediante Reflection
+ */
+
+import java.lang.annotation.*;
+import java.lang.reflect.*;
+
+// Definición del decorador para clases
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@interface LogClass {
+    String value() default ""; // Mensaje personalizado
+}
+
+// Definición del decorador para métodos
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@interface LogMethod {
+    String value() default ""; // Mensaje personalizado
+}
+
+// Definición del decorador contador para el ejercicio extra
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@interface ContadorLlamadas {
+}
+
+public class eulogioep {
+    // Clase principal que contiene el método main
+    public static void main(String[] args) {
+        try {
+            System.out.println("=== Pruebas de los decoradores ===");
+
+            // Prueba del decorador de clase
+            Ejemplo ejemplo = new Ejemplo();
+            procesarDecoradoresClase(ejemplo.getClass());
+
+            // Prueba del decorador de método
+            ejemplo.saludar("Java");
+
+            // Prueba del decorador contador
+            Calculadora calc = new Calculadora();
+            System.out.println("Resultado suma: " + calc.sumar(5, 3));        // Primera llamada
+            System.out.println("Resultado suma: " + calc.sumar(2, 4));        // Segunda llamada
+            System.out.println("Resultado multiplicación: " + calc.multiplicar(3, 4));  // Primera llamada
+            System.out.println("Resultado suma: " + calc.sumar(1, 1));        // Tercera llamada
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    // Clase de ejemplo con decoradores
+    @LogClass("Esta es una clase de ejemplo")
+    static class Ejemplo {
+        @LogMethod("Método de saludo")
+        public String saludar(String nombre) {
+            return "¡Hola " + nombre + "!";
+        }
+    }
+
+    // Clase Calculadora con el decorador contador
+    static class Calculadora {
+        private static java.util.Map<String, Integer> contadores = new java.util.HashMap<>();
+
+        @ContadorLlamadas
+        public int sumar(int a, int b) {
+            contarLlamada("sumar");
+            return a + b;
+        }
+
+        @ContadorLlamadas
+        public int multiplicar(int a, int b) {
+            contarLlamada("multiplicar");
+            return a * b;
+        }
+
+        private void contarLlamada(String metodo) {
+            int contador = contadores.getOrDefault(metodo, 0) + 1;
+            contadores.put(metodo, contador);
+            System.out.println("El método " + metodo + " ha sido llamado " + contador + " veces");
+        }
+    }
+
+    // Método para procesar decoradores de clase
+    private static void procesarDecoradoresClase(Class<?> clase) {
+        if (clase.isAnnotationPresent(LogClass.class)) {
+            LogClass anotacion = clase.getAnnotation(LogClass.class);
+            System.out.println("Clase creada: " + clase.getSimpleName() + 
+                             " - Mensaje: " + anotacion.value());
+        }
+    }
+
+    // Método para procesar decoradores de método
+    private static void procesarDecoradoresMetodo(Method metodo) {
+        if (metodo.isAnnotationPresent(LogMethod.class)) {
+            LogMethod anotacion = metodo.getAnnotation(LogMethod.class);
+            System.out.println("Método llamado: " + metodo.getName() + 
+                             " - Mensaje: " + anotacion.value());
+        }
+    }
+
+    // Procesador de aspectos (simulado con Reflection)
+    static {
+        // Interceptamos los métodos con decoradores usando Reflection
+        try {
+            Method[] metodos = Ejemplo.class.getDeclaredMethods();
+            for (Method metodo : metodos) {
+                if (metodo.isAnnotationPresent(LogMethod.class)) {
+                    // Aquí normalmente usaríamos un framework como AspectJ
+                    // Esta es una simulación simplificada
+                    procesarDecoradoresMetodo(metodo);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/Roadmap/24 - DECORADORES/javascript/eulogioep.js b/Roadmap/24 - DECORADORES/javascript/eulogioep.js
@@ -0,0 +1,121 @@
+/*
+ * TEORÍA DE DECORADORES EN JAVASCRIPT
+ * 
+ * Los decoradores son funciones especiales que pueden modificar el comportamiento
+ * de clases, métodos y propiedades. En JavaScript, son una característica que
+ * permite añadir funcionalidad adicional de manera declarativa.
+ * 
+ * Tipos principales de decoradores:
+ * 1. Decoradores de clase
+ * 2. Decoradores de método
+ * 3. Decoradores de propiedad
+ * 
+ * Para usar decoradores necesitas:
+ * 1. Un entorno que soporte la sintaxis de decoradores (Node.js moderno o Babel)
+ * 2. Configurar el compilador para soportar decoradores
+ */
+
+// Ejemplo 1: Decorador de clase
+function logClass(target) {
+    // Este decorador registra cuando se crea una instancia de la clase
+    console.log(`Clase creada: ${target.name}`);
+    return target;
+}
+
+// Ejemplo 2: Decorador de método
+function logMethod(target, key, descriptor) {
+    // Guardamos la función original
+    const originalMethod = descriptor.value;
+    
+    // Reemplazamos el método con una nueva función
+    descriptor.value = function(...args) {
+        console.log(`Llamando al método ${key}`);
+        return originalMethod.apply(this, args);
+    }
+    
+    return descriptor;
+}
+
+// Ejercicio Extra: Decorador contador de llamadas
+function contadorLlamadas(target, key, descriptor) {
+    // Creamos un mapa para almacenar los contadores de cada método
+    if (!target.constructor._contadores) {
+        target.constructor._contadores = new Map();
+    }
+    
+    // Guardamos la función original
+    const originalMethod = descriptor.value;
+    
+    // Reemplazamos el método con una nueva función que incluye el contador
+    descriptor.value = function(...args) {
+        // Obtenemos el contador actual o inicializamos en 0
+        const contador = (target.constructor._contadores.get(key) || 0) + 1;
+        target.constructor._contadores.set(key, contador);
+        
+        console.log(`La función ${key} ha sido llamada ${contador} veces`);
+        
+        // Llamamos a la función original
+        return originalMethod.apply(this, args);
+    }
+    
+    return descriptor;
+}
+
+// Aplicamos el decorador a una clase
+@logClass
+class Ejemplo {
+    constructor() {
+        console.log('Constructor de Ejemplo ejecutado');
+    }
+    
+    @logMethod
+    saludar(nombre) {
+        return `¡Hola ${nombre}!`;
+    }
+}
+
+// Clase con el decorador contador
+class Calculadora {
+    @contadorLlamadas
+    sumar(a, b) {
+        return a + b;
+    }
+    
+    @contadorLlamadas
+    multiplicar(a, b) {
+        return a * b;
+    }
+}
+
+// Código de prueba
+console.log("=== Pruebas de los decoradores ===");
+
+// Prueba del decorador de clase y método
+const ejemplo = new Ejemplo();
+console.log(ejemplo.saludar("JavaScript"));
+
+// Prueba del decorador contador
+const calc = new Calculadora();
+console.log("Resultado suma:", calc.sumar(5, 3));        // Primera llamada a sumar
+console.log("Resultado suma:", calc.sumar(2, 4));        // Segunda llamada a sumar
+console.log("Resultado multiplicación:", calc.multiplicar(3, 4));   // Primera llamada a multiplicar
+console.log("Resultado suma:", calc.sumar(1, 1));        // Tercera llamada a sumar
+
+// Ejemplo de uso de decoradores con clases ES6 modernas
+// Decorador que añade un método a la clase
+function añadirMetodo(target) {
+    target.prototype.nuevoMetodo = function() {
+        return "Este es un método añadido por el decorador";
+    }
+    return target;
+}
+
+@añadirMetodo
+class EjemploModerno {
+    constructor() {
+        console.log("Clase moderna creada");
+    }
+}
+
+const ejemploModerno = new EjemploModerno();
+console.log(ejemploModerno.nuevoMetodo());
diff --git a/Roadmap/24 - DECORADORES/php/eulogioep.php b/Roadmap/24 - DECORADORES/php/eulogioep.php
@@ -0,0 +1,126 @@
+<?php
+
+/**
+ * TEORÍA DE DECORADORES (ATRIBUTOS) EN PHP
+ * 
+ * En PHP 8.0+ los decoradores se implementan como "Atributos" y permiten añadir
+ * metadatos a las clases, métodos, propiedades y parámetros.
+ * 
+ * Los atributos en PHP:
+ * - Se definen como clases con el atributo #[Attribute]
+ * - Se aplican usando la sintaxis #[NombreAtributo]
+ * - Pueden recibir parámetros en su constructor
+ * - Se pueden consultar usando la API de Reflection
+ */
+
+// Ejemplo 1: Decorador simple para una clase
+#[Attribute]
+class LogClass {
+    public function __construct(public string $message = "") {}
+}
+
+// Ejemplo 2: Decorador para métodos que registra la ejecución
+#[Attribute]
+class LogMethod {
+    public function __construct(public string $message = "") {}
+}
+
+// Ejemplo 3: Decorador contador de llamadas (para el ejercicio extra)
+#[Attribute]
+class ContadorLlamadas {
+    private static array $contadores = [];
+    
+    public static function incrementar(string $metodo): int {
+        if (!isset(self::$contadores[$metodo])) {
+            self::$contadores[$metodo] = 0;
+        }
+        self::$contadores[$metodo]++;
+        return self::$contadores[$metodo];
+    }
+}
+
+// Clase de ejemplo con decoradores
+#[LogClass("Esta es una clase de ejemplo")]
+class Ejemplo {
+    #[LogMethod("Método de saludo")]
+    public function saludar(string $nombre): string {
+        return "¡Hola $nombre!";
+    }
+}
+
+// Clase Calculadora con el decorador contador
+class Calculadora {
+    #[ContadorLlamadas]
+    public function sumar(int $a, int $b): int {
+        return $a + $b;
+    }
+
+    #[ContadorLlamadas]
+    public function multiplicar(int $a, int $b): int {
+        return $a * $b;
+    }
+}
+
+// Clase Helper para procesar los decoradores
+class DecoratorHelper {
+    // Método para procesar decoradores de clase
+    public static function processClassDecorators(string $className): void {
+        $reflection = new ReflectionClass($className);
+        $attributes = $reflection->getAttributes();
+        
+        foreach ($attributes as $attribute) {
+            if ($attribute->getName() === LogClass::class) {
+                $instance = $attribute->newInstance();
+                echo "Clase {$className} creada: {$instance->message}\n";
+            }
+        }
+    }
+
+    // Método para procesar decoradores de método
+    public static function processMethodDecorators(string $className, string $methodName): void {
+        $reflection = new ReflectionMethod($className, $methodName);
+        $attributes = $reflection->getAttributes();
+        
+        foreach ($attributes as $attribute) {
+            if ($attribute->getName() === LogMethod::class) {
+                $instance = $attribute->newInstance();
+                echo "Método {$methodName} llamado: {$instance->message}\n";
+            } elseif ($attribute->getName() === ContadorLlamadas::class) {
+                $contador = ContadorLlamadas::incrementar($className . "::" . $methodName);
+                echo "El método {$methodName} ha sido llamado {$contador} veces\n";
+            }
+        }
+    }
+}
+
+// Clase Proxy para interceptar llamadas y procesar decoradores
+class CalculadoraProxy {
+    private Calculadora $calculadora;
+
+    public function __construct() {
+        $this->calculadora = new Calculadora();
+    }
+
+    public function __call(string $method, array $arguments) {
+        DecoratorHelper::processMethodDecorators(Calculadora::class, $method);
+        return $this->calculadora->$method(...$arguments);
+    }
+}
+
+// Código de prueba
+echo "=== Pruebas de los decoradores ===\n";
+
+// Prueba del decorador de clase
+DecoratorHelper::processClassDecorators(Ejemplo::class);
+
+// Prueba del decorador de método
+$ejemplo = new Ejemplo();
+DecoratorHelper::processMethodDecorators(Ejemplo::class, 'saludar');
+echo $ejemplo->saludar("PHP") . "\n";
+
+// Prueba del decorador contador
+$calc = new CalculadoraProxy();
+echo "Resultado suma: " . $calc->sumar(5, 3) . "\n";      // Primera llamada a sumar
+echo "Resultado suma: " . $calc->sumar(2, 4) . "\n";      // Segunda llamada a sumar
+echo "Resultado multiplicación: " . $calc->multiplicar(3, 4) . "\n";  // Primera llamada a multiplicar
+echo "Resultado suma: " . $calc->sumar(1, 1) . "\n";      // Tercera llamada a sumar
diff --git a/Roadmap/24 - DECORADORES/typescript/eulogioep.ts b/Roadmap/24 - DECORADORES/typescript/eulogioep.ts
