Какой из принципов SOLID невозможен для final классов?

Принцип SOLID, невозможный для final классов: Open/Closed Principle (OCP)

Open/Closed Principle (OCP) — принцип открытости для расширения и закрытости для модификации — становится невозможным применить к final классам. Когда класс объявлен как final, он не может быть расширен (наследован), что нарушает самую суть OCP.

Почему OCP несовместим с final

Open/Closed Principle гласит:

• Open for extension: классы должны быть открыты для расширения (через наследование, композицию, полиморфизм)
• Closed for modification: мы не должны менять исходный код при добавлении новой функциональности

// ❌ final класс — нарушение OCP
public final class PaymentProcessor {
    public void processPayment(String method, double amount) {
        if ("credit_card".equals(method)) {
            // логика для кредитки
        } else if ("paypal".equals(method)) {
            // логика для PayPal
        }
        // Чтобы добавить новый способ, нужно МЕНЯТЬ этот класс!
    }
}

// Не можем расширить:
// public class CryptoCurrencyPayment extends PaymentProcessor { }  // ОШИБКА!

Правильное применение OCP

// ✅ Open for extension, closed for modification
public interface PaymentMethod {
    void process(double amount);
}

public class CreditCardPayment implements PaymentMethod {
    @Override
    public void process(double amount) {
        // Реализация для кредитки
    }
}

public class PayPalPayment implements PaymentMethod {
    @Override
    public void process(double amount) {
        // Реализация для PayPal
    }
}

// Новый способ оплаты добавляется БЕЗ изменения существующего кода
public class CryptoCurrencyPayment implements PaymentMethod {
    @Override
    public void process(double amount) {
        // Реализация для крипто
    }
}

public class PaymentProcessor {
    private final PaymentMethod paymentMethod;
    
    public PaymentProcessor(PaymentMethod paymentMethod) {
        this.paymentMethod = paymentMethod;
    }
    
    public void processPayment(double amount) {
        paymentMethod.process(amount);  // Полиморфизм
    }
}

Когда используются final классы

Несмотря на конфликт с OCP, final имеет смысл в некоторых случаях:

// 1. String — final класс в Java (из соображений безопасности)
public final class String implements Comparable<String> {
    // нельзя переопределить, нельзя создать подкласс
}

// 2. Immutable классы (неизменяемые) — часто делают final
public final class ImmutableUser {
    private final String name;
    private final int age;
    
    public ImmutableUser(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 3. Утилиты без состояния (статические методы)
public final class MathUtils {
    private MathUtils() { }  // Не инстанцируем
    
    public static int add(int a, int b) {
        return a + b;
    }
}

Конфликт SOLID принципов

final класс нарушает не только OCP, но усложняет и другие принципы:

// Liskov Substitution Principle (LSP) — нельзя подставить final класс
public final class ConcreteLogger {  // final!
    public void log(String message) { }
}

// Dependency Inversion (DI) — сложно инъектировать зависимости
public class UserService {
    private final ConcreteLogger logger;  // Привязаны к конкретному классу
    
    // Лучше:
    private final Logger logger;  // Интерфейс — расширяемо
}

Пример: Почему OCP важна

// ❌ Плохо — final класс, нарушение OCP
public final class NotificationService {
    public void send(String type, String message) {
        if ("email".equals(type)) {
            sendEmail(message);
        } else if ("sms".equals(type)) {
            sendSMS(message);
        }
        // Новый канал? Менять класс!
    }
}

// ✅ Хорошо — применено OCP
public interface Notifier {
    void send(String message);
}

public class EmailNotifier implements Notifier {
    @Override
    public void send(String message) {
        // отправка Email
    }
}

public class SMSNotifier implements Notifier {
    @Override
    public void send(String message) {
        // отправка SMS
    }
}

public class SlackNotifier implements Notifier {
    @Override
    public void send(String message) {
        // отправка в Slack (новый функционал БЕЗ изменения существующего кода!)
    }
}

public class NotificationService {
    private final Notifier notifier;
    
    public NotificationService(Notifier notifier) {
        this.notifier = notifier;
    }
    
    public void send(String message) {
        notifier.send(message);
    }
}

Заключение

Open/Closed Principle (OCP) невозможен для final классов. final предотвращает наследование, что делает невозможным расширение функциональности без модификации исходного кода. Вместо final классов используй:

• Интерфейсы для контрактов
• Абстрактные классы для базовой функциональности
• Композицию вместо наследования
• final только для утилит, immutable объектов и классов, которые критичны для безопасности

Это позволяет создавать гибкие, расширяемые архитектуры, которые легко адаптируются к новым требованиям без изменения существующего кода.