El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Principios SOLID

Siguiente ►
►

Los principios SOLID son un conjunto de cinco principios de diseño de software destinados a hacer que los sistemas sean más comprensibles, flexibles y mantenibles. Estos principios fueron introducidos por Robert C. Martin y son fundamentales para cualquier arquitecto de sistemas o desarrollador de software. A continuación, desglosaremos cada uno de estos principios, proporcionando explicaciones claras, ejemplos y ejercicios prácticos.

  1. Single Responsibility Principle (SRP)

Concepto

El principio de responsabilidad única establece que una clase debe tener una, y solo una, razón para cambiar. En otras palabras, cada clase debe tener una única responsabilidad o propósito.

Ejemplo

Consideremos una clase Report que tiene métodos para generar el contenido del informe y también para imprimirlo.

class Report:
    def generate_report(self):
        # Lógica para generar el contenido del informe
        pass

    def print_report(self):
        # Lógica para imprimir el informe
        pass

Según el SRP, esta clase tiene dos responsabilidades: generar y imprimir el informe. Deberíamos dividir estas responsabilidades en dos clases distintas.

class ReportGenerator:
    def generate_report(self):
        # Lógica para generar el contenido del informe
        pass

class ReportPrinter:
    def print_report(self, report):
        # Lógica para imprimir el informe
        pass

Ejercicio

Refactoriza la siguiente clase para que cumpla con el principio de responsabilidad única.

class User:
    def get_user_data(self):
        # Lógica para obtener datos del usuario
        pass

    def save_user_data(self):
        # Lógica para guardar datos del usuario
        pass

    def send_email(self):
        # Lógica para enviar un correo electrónico
        pass

Solución

class UserData:
    def get_user_data(self):
        # Lógica para obtener datos del usuario
        pass

    def save_user_data(self):
        # Lógica para guardar datos del usuario
        pass

class EmailService:
    def send_email(self):
        # Lógica para enviar un correo electrónico
        pass

  1. Open/Closed Principle (OCP)

Concepto

El principio de abierto/cerrado establece que las entidades de software (clases, módulos, funciones, etc.) deben estar abiertas para la extensión, pero cerradas para la modificación. Esto significa que deberíamos poder añadir nuevas funcionalidades sin cambiar el código existente.

Ejemplo

Consideremos una clase Shape con un método area que calcula el área de diferentes formas.

class Shape:
    def area(self, shape):
        if shape.type == 'circle':
            return 3.14 * shape.radius ** 2
        elif shape.type == 'rectangle':
            return shape.width * shape.height

Para cumplir con el OCP, podemos utilizar la herencia y el polimorfismo.

class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

Ejercicio

Refactoriza la siguiente clase para que cumpla con el principio de abierto/cerrado.

class Discount:
    def apply_discount(self, product, discount_type):
        if discount_type == 'percentage':
            return product.price * 0.9
        elif discount_type == 'fixed':
            return product.price - 10

Solución

class Discount:
    def apply_discount(self, product):
        pass

class PercentageDiscount(Discount):
    def apply_discount(self, product):
        return product.price * 0.9

class FixedDiscount(Discount):
    def apply_discount(self, product):
        return product.price - 10

  1. Liskov Substitution Principle (LSP)

Concepto

El principio de sustitución de Liskov establece que los objetos de una clase derivada deben poder reemplazar a los objetos de la clase base sin alterar el comportamiento del programa.

Ejemplo

Consideremos una clase Bird y una clase derivada Penguin.

class Bird:
    def fly(self):
        pass

class Penguin(Bird):
    def fly(self):
        raise Exception("Penguins can't fly")

Para cumplir con el LSP, debemos asegurarnos de que Penguin no tenga un método fly que no puede implementar correctamente.

class Bird:
    def move(self):
        pass

class FlyingBird(Bird):
    def fly(self):
        pass

class Penguin(Bird):
    def move(self):
        # Lógica para moverse sin volar
        pass

Ejercicio

Refactoriza la siguiente clase para que cumpla con el principio de sustitución de Liskov.

class Vehicle:
    def start_engine(self):
        pass

class Bicycle(Vehicle):
    def start_engine(self):
        raise Exception("Bicycles don't have engines")

Solución

class Vehicle:
    def move(self):
        pass

class MotorVehicle(Vehicle):
    def start_engine(self):
        pass

class Bicycle(Vehicle):
    def move(self):
        # Lógica para moverse sin motor
        pass

  1. Interface Segregation Principle (ISP)

Concepto

El principio de segregación de interfaces establece que los clientes no deben estar obligados a depender de interfaces que no utilizan. Es mejor tener interfaces específicas y pequeñas en lugar de interfaces grandes y generales.

Ejemplo

Consideremos una interfaz Worker que tiene métodos para trabajar y comer.

class Worker:
    def work(self):
        pass

    def eat(self):
        pass

Para cumplir con el ISP, podemos dividir esta interfaz en dos interfaces más específicas.

class Workable:
    def work(self):
        pass

class Eatable:
    def eat(self):
        pass

Ejercicio

Refactoriza la siguiente interfaz para que cumpla con el principio de segregación de interfaces.

class Machine:
    def print(self):
        pass

    def scan(self):
        pass

    def fax(self):
        pass

Solución

class Printer:
    def print(self):
        pass

class Scanner:
    def scan(self):
        pass

class Fax:
    def fax(self):
        pass

  1. Dependency Inversion Principle (DIP)

Concepto

El principio de inversión de dependencias establece que los módulos de alto nivel no deben depender de módulos de bajo nivel. Ambos deben depender de abstracciones. Además, las abstracciones no deben depender de los detalles. Los detalles deben depender de las abstracciones.

Ejemplo

Consideremos una clase Light y una clase Switch que depende directamente de Light.

class Light:
    def turn_on(self):
        pass

    def turn_off(self):
        pass

class Switch:
    def __init__(self, light):
        self.light = light

    def operate(self, on):
        if on:
            self.light.turn_on()
        else:
            self.light.turn_off()

Para cumplir con el DIP, podemos introducir una interfaz Switchable que Light implementará.

class Switchable:
    def turn_on(self):
        pass

    def turn_off(self):
        pass

class Light(Switchable):
    def turn_on(self):
        pass

    def turn_off(self):
        pass

class Switch:
    def __init__(self, device: Switchable):
        self.device = device

    def operate(self, on):
        if on:
            self.device.turn_on()
        else:
            self.device.turn_off()

Ejercicio

Refactoriza la siguiente clase para que cumpla con el principio de inversión de dependencias.

class Database:
    def connect(self):
        pass

class Application:
    def __init__(self):
        self.db = Database()

    def start(self):
        self.db.connect()

Solución

class DatabaseConnection:
    def connect(self):
        pass

class Database(DatabaseConnection):
    def connect(self):
        pass

class Application:
    def __init__(self, db: DatabaseConnection):
        self.db = db

    def start(self):
        self.db.connect()

Conclusión

Los principios SOLID son fundamentales para el diseño de software robusto y mantenible. Aplicar estos principios puede ayudar a crear sistemas que sean más fáciles de entender, extender y mantener. Asegúrate de practicar estos principios en tus proyectos para internalizarlos y aplicarlos de manera efectiva. En el próximo tema, exploraremos otros principios de diseño de software que complementan los principios SOLID.

◄ Anterior
◄
Siguiente ►
►

Arquitecturas de Sistemas: Principios y Prácticas para Diseñar Arquitecturas Tecnológicas Robustas y Escalables

Módulo 1: Introducción a las Arquitecturas de Sistemas

Módulo 2: Principios de Diseño de Arquitecturas

Módulo 3: Componentes de una Arquitectura de Sistemas

Módulo 4: Escalabilidad y Rendimiento

Módulo 5: Seguridad en Arquitecturas de Sistemas

Módulo 6: Herramientas y Tecnologías

Módulo 7: Casos de Estudio y Ejemplos Prácticos

Módulo 8: Tendencias y Futuro de las Arquitecturas de Sistemas

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados