Codigo limpio y refactorización

El bajo acoplamiento y la alta cohesión son principios fundamentales del diseño de software que ayudan a crear sistemas más modulares, flexibles y mantenibles:

  • Bajo acoplamiento: Las clases o módulos deben depender lo menos posible entre sí. Esto facilita cambios en una parte del sistema sin afectar otras.
  • Alta cohesión: Una clase o módulo debe tener un propósito bien definido y agrupar funcionalidades relacionadas. Esto mejora la claridad y la reutilización.

Ejemplo Malo: Alto Acoplamiento y Baja Cohesión

1public class OrderService {
2    public void processOrder(String productName, int quantity, String paymentMethod) {
3        System.out.println("Processing order for " + productName);
4        System.out.println("Quantity: " + quantity);
5        
6        // Pago
7        if (paymentMethod.equals("credit")) {
8            System.out.println("Processing credit card payment...");
9        } else if (paymentMethod.equals("paypal")) {
10            System.out.println("Processing PayPal payment...");
11        }
12    }
13}

Problemas en los Ejemplos Malos

  1. Alto acoplamiento:
    • OrderService está directamente acoplado a los detalles del método de pago.
    • Si se agrega un nuevo método de pago, hay que modificar la lógica interna de OrderService.
  2. Baja cohesión: OrderService maneja múltiples responsabilidades: gestionar pedidos y procesar pagos, violando el principio de responsabilidad única (SRP).

Beneficios del Código Corregido

  1. Bajo Acoplamiento:

    • OrderService no está directamente vinculado a un método de pago específico.
    • Nuevos métodos de pago se pueden agregar fácilmente implementando la interfaz o clase base PaymentProcessor.

  2. Alta Cohesión: Cada clase tiene una única responsabilidad:

    • OrderService: Procesa pedidos.
    • PaymentProcessor y sus subclases: Gestionan métodos de pago.

  3. Extensibilidad: Agregar nuevos métodos de pago no requiere modificar OrderService, siguiendo el principio Open/Closed.

  4. Mantenibilidad: El diseño modular facilita el mantenimiento y las pruebas unitarias.

Ejemplo Corregido: Bajo Acoplamiento y Alta Cohesión

1public interface PaymentProcessor {
2    void processPayment();
3}
4
5public class CreditCardProcessor implements PaymentProcessor {
6    public void processPayment() {
7        System.out.println("Processing credit card payment...");
8    }
9}
10
11public class PayPalProcessor implements PaymentProcessor {
12    public void processPayment() {
13        System.out.println("Processing PayPal payment...");
14    }
15}
16
17public class OrderService {
18    public void processOrder(String productName, int quantity, PaymentProcessor paymentProcessor) {
19        System.out.println("Processing order for " + productName);
20        System.out.println("Quantity: " + quantity);
21        paymentProcessor.processPayment();
22    }
23}
24// Uso
25OrderService orderService = new OrderService();
26PaymentProcessor paymentProcessor = new CreditCardProcessor();
27orderService.processOrder("Laptop", 1, paymentProcessor);

  • Loading...
← Inyección de dependenciasVolver al cursoNo usar organización →