В чем разница между бинарным и красно-черным деревьями?

# SOLID принципы в Java разработке

SOLID - это набор из 5 принципов объектно-ориентированного программирования, которые делают код более гибким, поддерживаемым и расширяемым. Это основа профессиональной разработки.

1. S - Single Responsibility Principle (SRP)

Класс должен иметь одну и только одну причину для изменения. Каждый класс отвечает за одно.

// ПЛОХО: класс делает слишком много
@Service
public class UserService {
    public void registerUser(UserRequest request) {
        // Валидация
        // Сохранение в БД
        // Отправка email
        // Логирование
        // Все в одном методе!
    }
}

// ХОРОШО: разделяем ответственность
@Service
public class UserRegistrationService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private EmailService emailService;
    
    public void registerUser(UserRequest request) {
        User user = new User(request);
        userRepository.save(user);
        emailService.sendWelcomeEmail(user);
    }
}

@Service
public class EmailService {
    public void sendWelcomeEmail(User user) {
        // Только отправка email
    }
}

@Service
public class UserValidationService {
    public void validate(UserRequest request) {
        // Только валидация
    }
}

Преимущества:

• Легче тестировать
• Легче изменять
• Переиспользуемость
• Лучше читаемость

2. O - Open/Closed Principle (OCP)

Класс должен быть открыт для расширения, но закрыт для модификации.

// ПЛОХО: нужно менять класс при добавлении типов
public class ReportGenerator {
    public void generate(String type) {
        if (type.equals("PDF")) {
            // PDF логика
        } else if (type.equals("EXCEL")) {
            // Excel логика
        } else if (type.equals("CSV")) {
            // CSV логика
        }
    }
}

// ХОРОШО: используем полиморфизм
public interface ReportFormatter {
    void format(List<String> data);
}

public class PdfFormatter implements ReportFormatter {
    @Override
    public void format(List<String> data) {
        // PDF логика
    }
}

public class ExcelFormatter implements ReportFormatter {
    @Override
    public void format(List<String> data) {
        // Excel логика
    }
}

public class ReportGenerator {
    private ReportFormatter formatter;
    
    public ReportGenerator(ReportFormatter formatter) {
        this.formatter = formatter;
    }
    
    public void generate(List<String> data) {
        formatter.format(data);
        // Можно добавлять новые форматы без изменения класса
    }
}

Преимущества:

• Легче добавлять новую функциональность
• Не нужно менять существующий код
• Меньше риск сломать старое

3. L - Liskov Substitution Principle (LSP)

Объекты подклассов должны корректно заменять объекты базовых классов.

// ПЛОХО: нарушение LSP
public class Bird {
    public void fly() {
        System.out.println("Летаю");
    }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Пингвины не летают!");
        // Нарушение контракта
    }
}

// Использование
Bird bird = new Penguin();
bird.fly(); // Ошибка! Ожидали что летает

// ХОРОШО: правильная иерархия
public interface Bird {
    void move();
}

public class FlyingBird implements Bird {
    @Override
    public void move() {
        System.out.println("Летаю");
    }
}

public class Penguin implements Bird {
    @Override
    public void move() {
        System.out.println("Плыву");
    }
}

Преимущества:

• Предсказуемость поведения
• Правильная иерархия классов
• Нет неожиданных ошибок

4. I - Interface Segregation Principle (ISP)

Не нужно заставлять класс реализовать методы, которые ему не нужны.

// ПЛОХО: большой интерфейс
public interface Worker {
    void work();
    void eat();
    void sleep();
    void code();
    void debug();
}

public class Robot implements Worker {
    @Override
    public void work() { }
    
    @Override
    public void eat() {
        throw new UnsupportedOperationException("Робот не ест!");
    }
    
    @Override
    public void sleep() {
        throw new UnsupportedOperationException("Робот не спит!");
    }
    // Много ненужных методов
}

// ХОРОШО: разделяем интерфейсы
public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface Sleepable {
    void sleep();
}

public class Robot implements Workable {
    @Override
    public void work() {
        System.out.println("Работаю");
    }
}

public class Human implements Workable, Eatable, Sleepable {
    @Override
    public void work() { }
    
    @Override
    public void eat() { }
    
    @Override
    public void sleep() { }
}

Преимущества:

• Класс реализует только нужные методы
• Меньше неиспользуемого кода
• Лучше гибкость

5. D - Dependency Inversion Principle (DIP)

Делай зависимость от абстракций, а не от конкретных реализаций.

// ПЛОХО: зависимость от конкретного класса
@Service
public class UserService {
    private MySQLDatabase database = new MySQLDatabase();
    
    public void saveUser(User user) {
        database.save(user);
    }
}

// ХОРОШО: зависимость от интерфейса
public interface UserRepository {
    void save(User user);
}

public class MySQLUserRepository implements UserRepository {
    @Override
    public void save(User user) {
        // MySQL сохранение
    }
}

public class PostgresUserRepository implements UserRepository {
    @Override
    public void save(User user) {
        // Postgres сохранение
    }
}

@Service
public class UserService {
    private UserRepository repository;
    
    @Autowired
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public void saveUser(User user) {
        repository.save(user);
    }
}

// Можешь менять реализацию без изменения UserService

Преимущества:

• Легко менять реализацию
• Легче тестировать (mock'ировать)
• Слабая связанность

Практический пример: Система платежей

// S: Каждый класс отвечает за одно
public class PaymentValidator {
    public void validate(Payment payment) { }
}

public class PaymentProcessor {
    public void process(Payment payment) { }
}

// O: Открыт для расширения
public interface PaymentGateway {
    void charge(Payment payment);
}

public class StripeGateway implements PaymentGateway { }
public class PayPalGateway implements PaymentGateway { }

// L: Правильная подстановка
public class PaymentService {
    private PaymentGateway gateway;
    
    public void processPayment(Payment payment) {
        gateway.charge(payment);
        // Любая реализация работает одинаково
    }
}

// I: Нужные интерфейсы
public interface Refundable {
    void refund(Payment payment);
}

// D: Зависимость от интерфейса
@Service
public class PaymentOrchestrator {
    private PaymentValidator validator;
    private PaymentProcessor processor;
    private PaymentGateway gateway;
    
    @Autowired
    public PaymentOrchestrator(
        PaymentValidator validator,
        PaymentProcessor processor,
        PaymentGateway gateway
    ) {
        this.validator = validator;
        this.processor = processor;
        this.gateway = gateway;
    }
}

Чеклист SOLID при code review

• Каждый класс имеет одну ответственность (SRP)
• Код открыт для расширения, закрыт для модификации (OCP)
• Иерархия классов правильная (LSP)
• Интерфейсы специализированные (ISP)
• Зависимости от интерфейсов, не от реализаций (DIP)

СОЛИД принципы - это не гайд для каждого кода, а скорее принципы хорошего дизайна. Применяй их когда имеет смысл, избегай над-инженирингма.