Soluciones

.gitignore

@@ -12,4 +12,4 @@ pubspec.yaml
 pubspec.lock
 .venv
 *.class
-*.gradle 
+*.gradle 

Roadmap/29 - SOLID ISP/python/franxiscodev.py

@@ -0,0 +1,135 @@
+'''
+SOLID
+ISP: Interface Swgregation Principle
+principio de segregación de interfaces
+    # no se puede usar el método de la clase padre
+    # en la clase hija
+    # se debe crear una interfaz para cada clase hija
+    # y no una interfaz para todas las clases hijas
+
+'''
+from abc import ABC, abstractmethod
+
+# Sin ISP
+
+
+class WorkerInteface(ABC):
+    @abstractmethod
+    def work(self):
+        pass
+
+    @abstractmethod
+    def eat(self):
+        pass
+
+
+class HumanWorker(WorkerInteface):
+    def work(self):
+        print("Trabajando")
+
+    def eat(self):
+        print("Comiendo")
+
+
+class RobotWorker(WorkerInteface):
+    def work(self):
+        print("Trabajando")
+
+    def eat(self):
+        # no se puede usar el método de la clase padre en la clase hija rompe el ISP
+        raise NotImplementedError("Los robots no comen")
+
+# ISP
+
+
+class WorkInteface(ABC):
+    @abstractmethod
+    def work(self):
+        pass
+
+
+class EatInteface(ABC):
+    @abstractmethod
+    def eat(self):
+        pass
+
+
+class HumanWorker(WorkInteface, EatInteface):
+    def work(self):
+        print("Trabajando")
+
+    def eat(self):
+        print("Comiendo")
+
+
+class RobotWorker(WorkInteface):
+    def work(self):
+        print("Trabajando")
+
+# Extra
+
+
+class PrinterInteface(ABC):
+    @abstractmethod
+    def print(self, document: str):
+        pass
+
+
+class ColorPrinterInteface(ABC):
+    @abstractmethod
+    def print_color(self, document: str):
+        pass
+
+
+class ScannerInteface(ABC):
+    @abstractmethod
+    def scan(self, document: str) -> str:
+        pass
+
+
+class FaxInteface(ABC):
+    @abstractmethod
+    def send_fax(self, document: str):
+        pass
+
+
+class Printer(PrinterInteface):
+    def print(self, document: str):
+        print(f"Imprimiendo {document} en blanco y negro")
+
+
+class ColorPrinter(ColorPrinterInteface):
+    def print_color(self, document: str):
+        print(f"Imprimiendo {document} en color")
+
+
+class MultifunctionPrinter(PrinterInteface, ColorPrinterInteface, ScannerInteface, FaxInteface):
+    def print(self, document: str):
+        print(f"Imprimiendo {document} en blanco y negro")
+
+    def print_color(self, document: str):
+        print(f"Imprimiendo {document} en color")
+
+    def scan(self, document: str) -> str:
+        print(f"Escaneando {document}")
+        return document
+
+    def send_fax(self, document: str):
+        print(f"Enviando fax de {document}")
+
+
+def test_printer():
+    printer = Printer()
+    color_printer = ColorPrinter()
+    mfp = MultifunctionPrinter()
+
+    printer.print("documento1.txt")
+    color_printer.print_color("documento2.txt")
+    print("\tMultifunción")
+    mfp.print("documento_byn.pdf")
+    mfp.print_color("documento_color.pdf")
+    mfp.scan("documento_scan.pdf")
+    mfp.send_fax("documento_fax.pdf")
+
+
+test_printer()

Roadmap/30 - SOLID DIP/python/franxiscodev.py

@@ -0,0 +1,123 @@
+'''
+SOLID - DIP
+Principio SOLID de Inversión de Dependencias (Dependency Inversion Principle, DIP)
+#
+# El principio de inversión de dependencias establece que las clases de alto nivel no deben depender de las clases de bajo nivel. 
+# Ambas deben depender de abstracciones (interfaces o clases abstractas). 
+# Además, las abstracciones no deben depender de los detalles, sino que los detalles deben depender de las abstracciones.
+
+'''
+# Sin DIP
+# el switch es una clase de bajo nivel y la bombilla es una clase de alto nivel
+# la bombilla depende del switch, lo que significa que la bombilla no puede funcionar sin el switch
+
+
+from abc import ABC, abstractmethod
+
+
+class Switch:
+
+    def turn_on(self):
+        print("encender lámpara")
+
+    def turn_off(self):
+        print("apagar lámpara")
+
+
+class Bulb:
+    def __init__(self) -> None:
+        self.switch = Switch()
+
+    def operate(self, command):
+        if command == "on":
+            self.switch.turn_on()
+        elif command == "off":
+            self.switch.turn_off()
+        else:
+            print("comando no válido")
+
+
+bulb = Bulb()
+bulb.operate("on")
+bulb.operate("off")
+bulb.operate("office")
+
+# con DIP
+
+
+class AbstractSwitch:
+    def turn_on(self):
+        pass
+
+    def turn_off(self):
+        pass
+
+
+class BulbSwitch(AbstractSwitch):
+    def turn_on(self):
+        print("encender lámpara dip")
+
+    def turn_off(self):
+        print("apagar lámpara dip")
+
+
+class Bulb:
+    def __init__(self, switch: AbstractSwitch) -> None:
+        self.switch = switch
+
+    def operate(self, command):
+        if command == "on":
+            self.switch.turn_on()
+        elif command == "off":
+            self.switch.turn_off()
+        else:
+            print("comando no válido dip")
+
+
+# la bombilla no depende del switch, sino de la abstracción AbstractSwitch
+# y el switch puede ser cualquier clase que implemente la interfaz AbstractSwitch
+# por lo que se puede cambiar el switch sin afectar a la bombilla
+# y la bombilla puede funcionar sin el switch
+bulb = Bulb(BulbSwitch())
+bulb.operate("on")
+bulb.operate("off")
+bulb.operate("office")
+
+# Extra
+
+
+class Notifier(ABC):
+    @abstractmethod
+    def send(self, message: str):
+        pass
+
+
+class EmailNotifier(Notifier):
+    def send(self, message: str):
+        print(f"Enviando correo: {message}")
+
+
+class PUSHNotifier(Notifier):
+    def send(self, message: str):
+        print(f"Enviando PUSH: {message}")
+
+
+class SMSNotifier(Notifier):
+    def send(self, message: str):
+        print(f"Enviando SMS: {message}")
+
+
+class NotificationService:
+    def __init__(self, notifier: Notifier) -> None:
+        self.notifier = notifier
+
+    def notify(self, message: str):
+        self.notifier.send(message)
+
+
+service = NotificationService(EmailNotifier())
+service.notify("Hola mundo x email")
+service = NotificationService(PUSHNotifier())
+service.notify("Hola mundo x PUSH")
+service = NotificationService(SMSNotifier())
+service.notify("Hola mundo x SMS")