Please enable JavaScript.

Coggle requires JavaScript to display documents.

SOLID Principles con Ejemplos de Código - Coggle Diagram

SOLID Principles con Ejemplos de Código

S - Single Responsibility Principle (SRP)

ANTES

public class UserService(String email) {
    public void registerUser(String email) {
        System.out.println("Guardando usuario en base de datos");
            System.out.println("Enviando email de bienvenida a " + email);
            System.out.println("Escribiendo log de registro");
        }
}

DESPUÉS

public class UserRepository {
    public void save(String email) {
        System.out.println("Guardando usuario en DB");
    }
}

public class EmailService {
    public void sendWelcome(String email) {
        System.out.println("Enviando email a " + email);
    }
}

public class LoggerService {
    public void log(String message) {
        System.out.println("LOG: " + message);
    }
}

public class LoggerService {
    public void log(String message) {
        System.out.println("LOG: " + message);
    }
}

public class UserService {

    private UserRepository repository;
    private EmailService emailService;
    private LoggerService logger;

    public UserService(UserRepository repository,
                    EmailService emailService,
                    LoggerService logger) {
        this.repository = repository;
        this.emailService = emailService;
        this.logger = logger;
    }

    public void registerUser(String email) {
        repository.save(email);
        emailService.sendWelcome(email);
        logger.log("Usuario registrado");
    }
}

L - Liskov Substitution Principle (LSP)

ANTES

public class Bird {
    public void fly() {
        System.out.println("Volando");
    }
}
public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Los pingüinos no vuelan");
    }
}

DESPUÉS

public interface Bird {
    void eat();
}

public interface FlyingBird extends Bird {
    void fly();
}

public class Sparrow implements FlyingBird {
    public void eat() {}
    public void fly() {
        System.out.println("Volando");
    }
}

public class Penguin implements Bird {
    public void eat() {
        System.out.println("Comiendo pescado");
    }
}

D - Dependency Inversion Principle (DIP)

ANTES

// Low-level class
class FileLogger {
    log(message) {
        print("Logging to file: " + message)
    }
}

// High-level class
class UserService {
    constructor(logger: FileLogger) {
        this.logger = logger
    }

        register(username) {
        // registration logic
        this.logger.log("User '" + username + "' registered.")
    }
}

DESPUÉS

Then FileLogger, DatabaseLogger, or any other logger can implement this interface.

class FileLogger implements Logger {
    log(message) {
        print("Logging to file: " + message)
    }
}
class DatabaseLogger implements Logger {
    log(message) {
        print("Logging to database: " + message)
    }
}

Now UserService depends on the abstraction created by the interface.

class UserService {
    constructor(logger: Logger) {
        this.logger = logger
    }

        register(username) {
        // registration logic
        this.logger.log("User '" + username + "' registered.")
    }
}

Forma de usarlo

Now UserService works with any logger without needing changes. Both the high-level service and the low-level logger depend only on the abstraction.

fileLogger = new FileLogger()
dbLogger = new DatabaseLogger()

userService1 = new UserService(fileLogger)
userService1.register("Alice")

userService2 = new UserService(dbLogger)
userService2.register("Bob")

O - Open/Closed Principle (OCP)

DESPUÉS

public interface Discount {
    double apply(double price);
}

public class NormalDiscount implements Discount {
    public double apply(double price) {
        return price * 0.9;
    }
}

public class VipDiscount implements Discount {
    public double apply(double price) {
        return price * 0.8;
    }
}

public class DiscountService {
    public double calculate(Discount discount, double price) {
        return discount.apply(price);
    }
}

ANTES

public class DiscountService {

    public double calculate(String type, double price) {
        if (type.equals("NORMAL")) {
            return price * 0.9;
        } else if (type.equals("VIP")) {
            return price * 0.8;
        }
        return price;
    }
}