public interface Worker {
    void work();    // Для всех
    void eat();     // Только для людей
    void charge();  // Только для роботов
}

Класс Human реализует charge() бесполезно, Robot — eat().

public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface Chargeable {
    void charge();
}

public class Human implements Workable, Eatable {
    @Override
    public void work() { /*...*/ }

    @Override
    public void eat() { /*...*/ }
}

public class Robot implements Workable, Chargeable {
    @Override
    public void work() { /*...*/ }

    @Override
    public void charge() { /*...*/ }
}

Теперь классы реализуют только нужное.

public class ReportService {
    private MySQLDatabase db = new MySQLDatabase();  // Зависит от конкретной реализации

    public void generateReport() {
        db.connect();
        // ...
    }
}

Смена базы данных требует изменения сервиса.

public interface Database {
    void connect();
    // ...
}

public class MySQLDatabase implements Database {
    @Override
    public void connect() { /*...*/ }
}

public class ReportService {
    private Database db;  // Зависит от абстракции

    public ReportService(Database db) {  // Инъекция зависимости
        this.db = db;
    }

    public void generateReport() {
        db.connect();
        // ...
    }
}

Теперь можно передать любую реализацию: new ReportService(new MySQLDatabase()) или new ReportService(new PostgreSQLDatabase()).

public class Calculator {
    // Нарушение: Дублирование
    public double circleArea(double radius) {
        return 3.14159 * radius * radius;
    }

    public double circleVolume(double radius, double height) {
        return 3.14159 * radius * radius * height;  // Тот же расчет площади
    }
}

public class Calculator {
    // Правильно: Общий метод
    private double calculateCircleBase(double radius) {
        final double PI = 3.14159;
        return PI * radius * radius;
    }

    public double circleArea(double radius) {
        return calculateCircleBase(radius);
    }

    public double circleVolume(double radius, double height) {
        return calculateCircleBase(radius) * height;
    }
}

// Нарушение: Избыточная сложность
public class ComplexCalculator {
    public double calculate(double a, double b) {
        AdvancedMathUtils utils = new AdvancedMathUtils();
        return utils.performAdvancedOps(new OperationContext(a, b)).getResult();
    }
}

// Куча лишних классов...
Исправление: Простой метод:
javapublic class SimpleCalculator {
    public double calculate(double a, double b) {
        return Math.sqrt(a * a + b * b);  // Прямо и ясно
    }
}

// Нарушение: Лишние методы "на всякий случай"
public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public void sendEmail() { /* Пока пусто */ }
    public void sendSMS() { /* Пока пусто */ }
    public void integrateWithAPI() { /* Пока пусто */ }
}
Исправление: Только необходимое:
javapublic class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    // Только базовая функциональность
    public String getName() {
        return name;
    }
}

List<String> fruits = Arrays.asList("яблоко", "банан", "вишня");

Iterator<String> iterator = fruits.iterator();

while (iterator.hasNext()) {
    String fruit = iterator.next(); // "Вытягиваем" следующий элемент
    System.out.println(fruit.toUpperCase());
}

Flux<String> pushFlux = Flux.fromIterable(Arrays.asList("яблоко", "банан", "вишня"))
                    .map(String::toUpperCase); // Преобразование в потоке

pushFlux.subscribe(
               fruit -> System.out.println("Получено из push: " + fruit), // Реакция на толкание
               Throwable::printStackTrace, // Обработка ошибок
               () -> System.out.println("Push завершён")
);

WebClient.create()
     .get()
     .uri("https://api.example.com/fruits")
     .retrieve()
     .bodyToFlux(String.class) // Flux толкает строки из ответа
     .subscribe(fruit -> System.out.println("Push из API: " + fruit));

Flux.fromIterable(fruits)
     .map(String::toUpperCase)
     .flatMap(fruit -> sendToApi(fruit)) // flatMap толкает в асинхронный API
     .subscribe(result -> System.out.println("Ответ: " + result));

import reactor.core.publisher.Flux; // Flux реализует Publisher

Flux<Integer> publisher = Flux.range(1, 5); // Издатель: поток от 1 до 5

publisher.subscribe(new Subscriber<Integer>() {
    private Subscription subscription;

    @Override
    public void onSubscribe(Subscription s) {
        this.subscription = s;
        s.request(1); // Запрашиваем первый элемент
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Получено: " + item);
        subscription.request(1); // Запрашиваем следующий
    }

    @Override
    public void onError(Throwable t) {
        System.err.println("Ошибка: " + t);
    }

    @Override
    public void onComplete() {
        System.out.println("Завершено");
    }
});

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void makeSound() {
        System.out.println(name + " издает звук.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " лает: Гав!");
    }
}

public class Engine {
    private int horsepower;

    public Engine(int horsepower) {
        this.horsepower = horsepower;
    }

    public void start() {
        System.out.println("Двигатель с " + horsepower + " л.с. запущен.");
    }
}

public class Car {
    private String model;
    private Engine engine;  // Композиция: Car "имеет" Engine

    public Car(String model, Engine engine) {
        this.model = model;
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println(model + " едет.");
    }
}

public class Main {
    public static void main(String[] args) {
        Engine engine = new Engine(200);
        Car car = new Car("Toyota", engine);
        car.drive();  // Двигатель с 200 л.с. запущен. Toyota едет.
    }
}

public class Vehicle {
    public void move() {
        System.out.println("Движется с помощью двигателя.");
    }
}

public class Car extends Vehicle {
    // Проблема: А если электромобиль или велосипед?
}

Композиция (решение):
public interface Movable {
    void move();
}

public class EngineMovable implements Movable {
    @Override
    public void move() {
        System.out.println("Движется с помощью двигателя.");
    }
}

public class Car {
    private Movable movement;

    public Car(Movable movement) {
        this.movement = movement;
    }

    public void drive() {
        movement.move();
    }
}

Теперь Car может использовать любой Movable (двигатель, электромотор), без привязки к иерархии.

import reactor.core.publisher.Flux;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

Flux<Integer> fastPublisher = Flux.range(1, 1000); // Быстрый источник: 1000 элементов

fastPublisher.subscribe(new Subscriber<Integer>() {
    private Subscription sub;

    @Override
    public void onSubscribe(Subscription s) {
        sub = s;
        sub.request(5); // Сначала запрашиваем 5 элементов
    }

    @Override
    public void onNext(Integer item) {
        System.out.println("Обработано: " + item);
        // Симулируем медленную обработку: Thread.sleep(100); (но в реальности избегайте блокировок!)
        sub.request(1); // После каждого — запрашиваем следующий
    }

    @Override
    public void onError(Throwable t) { /* обработка */ }
    @Override
    public void onComplete() { System.out.println("Готово"); }
});

Здесь подписчик контролирует темп: запросил 5 — получил 5, обработал — запросил ещё. Если не request() — поток остановится. Это асинхронно: издатель не блокируется, а ждёт сигналов.