Open for Extension, Closed for Modification

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// ❌ BAD: Not open for extension
public class PaymentProcessor {
    public PaymentResult process(PaymentRequest request) {
        // Directly handles credit card logic
        if (request.getType().equals("CREDIT_CARD")) {
            CreditCardDetails card = (CreditCardDetails) request.getDetails();
            // Validate card number
            if (!validateLuhn(card.getNumber())) {
                return PaymentResult.failure("Invalid card number");
            }
            // Call payment gateway
            GatewayResponse response = creditCardGateway.charge(
                card.getNumber(),
                card.getExpiry(),
                card.getCvv(),
                request.getAmount()
            );
            return mapGatewayResponse(response);
        }
        // What happens when we need PayPal? We must modify this class.
        // What happens when we need Apple Pay? More modifications.
        // Every new payment method = changes to this file.
        
        return PaymentResult.failure("Unsupported payment type");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// ✅ GOOD: Open for extension through abstraction
public interface PaymentHandler {
    boolean supports(PaymentRequest request);
    PaymentResult process(PaymentRequest request);
}
 
public class PaymentProcessor {
    private final List<PaymentHandler> handlers;  // Extension point!
    
    public PaymentProcessor(List<PaymentHandler> handlers) {
        this.handlers = handlers;
    }
    
    public PaymentResult process(PaymentRequest request) {
        // Find the appropriate handler - no knowledge of specific payment types
        for (PaymentHandler handler : handlers) {
            if (handler.supports(request)) {
                return handler.process(request);
            }
        }
        return PaymentResult.failure("No handler found for payment type");
    }
}
 
// New payment types = new classes, not modifications
public class CreditCardHandler implements PaymentHandler { /* ... */ }
public class PayPalHandler implements PaymentHandler { /* ... */ }
public class ApplePayHandler implements PaymentHandler { /* ... */ }  // Added later!

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// ❌ Dangerous: Mechanical extension without semantic support
public class LoggingStringBuilder extends StringBuilder {
    
    @Override
    public StringBuilder append(String str) {
        System.out.println("Appending: " + str);
        return super.append(str);
    }
    
    // BUT... StringBuilder has 13+ append overloads!
    // We've only overridden one. The others bypass our logging.
    // This extension is brittle and incomplete.
    // Future JDK versions might add more overloads, breaking us further.
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// ✅ Safe: Composition instead of fragile inheritance
public class LoggingStringBuilder {
    private final StringBuilder delegate = new StringBuilder();
    
    public LoggingStringBuilder append(String str) {
        System.out.println("Appending: " + str);
        delegate.append(str);
        return this;
    }
    
    public LoggingStringBuilder append(int i) {
        System.out.println("Appending int: " + i);
        delegate.append(i);
        return this;
    }
    
    // We explicitly choose which operations to expose
    // No hidden backdoors, no fragile base class problems
    
    @Override
    public String toString() {
        return delegate.toString();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Define the abstraction (what we need)
public interface ReportGenerator {
    String getFormat();
    byte[] generate(ReportData data);
}
 
// The system depends on the abstraction
public class ReportingService {
    private final Map<String, ReportGenerator> generators;
    
    public byte[] generateReport(String format, ReportData data) {
        ReportGenerator generator = generators.get(format);
        if (generator == null) {
            throw new UnsupportedFormatException(format);
        }
        return generator.generate(data);
    }
    
    // Extension point: register new generators without modifying this class
    public void registerGenerator(ReportGenerator generator) {
        generators.put(generator.getFormat(), generator);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Without DI: Extensions are impossible without source changes
public class OrderService {
    private final InventoryChecker checker = new DatabaseInventoryChecker(); // Hardcoded!
}
 
// With DI: Extensions are trivial
public class OrderService {
    private final InventoryChecker checker;  // Abstract dependency
    
    public OrderService(InventoryChecker checker) {
        this.checker = checker;  // Injected at construction
    }
}
 
// Now we can extend without modification:
OrderService standard = new OrderService(new DatabaseInventoryChecker());
OrderService realTime = new OrderService(new WarehouseApiInventoryChecker());
OrderService cached = new OrderService(new CachedInventoryChecker(underlyingChecker));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Stage 1: Closed but well-structured
public class NotificationService {
    private final EmailSender emailSender;  // Interface, not concrete class
    
    public NotificationService(EmailSender emailSender) {  // Injected
        this.emailSender = emailSender;
    }
    
    public void notifyUser(User user, String message) {
        emailSender.send(user.getEmail(), message);
    }
}
 
// Stage 2: When SMS is needed, openness emerges naturally
public interface NotificationChannel {
    void notify(User user, String message);
}
 
public class NotificationService {
    private final List<NotificationChannel> channels;  // Now fully open!
    
    public NotificationService(List<NotificationChannel> channels) {
        this.channels = channels;
    }
    
    public void notifyUser(User user, String message) {
        for (NotificationChannel channel : channels) {
            channel.notify(user, message);
        }
    }
}
 
// The refactoring was simple because we followed good practices from the start