public class Report {
    // Нарушение: Класс делает всё сразу
    public void readDataFromFile(String fileName) {
        // Код для чтения данных
    }

    public void processData() {
        // Код для обработки данных
    }

    public void printReport() {
        // Код для печати отчета
    }
}

Здесь класс имеет три ответственности. Если изменится способ чтения файлов, придется трогать весь класс.

public class DataReader {
    public String readDataFromFile(String fileName) {
        // Только чтение данных
        return "Данные из файла";
    }
}

public class DataProcessor {
    public String processData(String data) {
        // Только обработка
        return "Обработанные данные: " + data;
    }
}

public class ReportPrinter {
    public void printReport(String processedData) {
        // Только печать
        System.out.println(processedData);
    }
}

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

public class ShapeCalculator {
    public double calculateArea(Object shape) {
        if (shape instanceof Circle) {
            // Код для круга
            return Math.PI * ((Circle) shape).getRadius() * ((Circle) shape).getRadius();
        } else if (shape instanceof Square) {
            // Код для квадрата
            return ((Square) shape).getSide() * ((Square) shape).getSide();
        }
        // Если добавить треугольник, придется менять метод
        return 0;
    }
}

Добавление новой фигуры требует изменения метода, что нарушает принцип.

public abstract class Shape {
    public abstract double calculateArea();  // Метод для расширения
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Square extends Shape {
    private double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double calculateArea() {
        return side * side;
    }
}

// Для новой фигуры просто добавьте класс, без изменения старого кода

Теперь ShapeCalculator может быть:
public class ShapeCalculator {
    public double calculateArea(Shape shape) {
        return shape.calculateArea();  // Полиморфизм, закрыт для изменений
    }
}

Добавление треугольника — новый класс extends Shape, без изменений в калькуляторе.

public class Bird {
    public void fly() {
        System.out.println("Летаю!");
    }
}

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

Это нарушение: подстановка пингвина ломает код.

public class Animal {
    // Общие методы
}

public interface Flyable {
    void fly();
}

public class Eagle extends Animal implements Flyable {
    @Override
    public void fly() {
        System.out.println("Орел летает высоко!");
    }
}

public class Penguin extends Animal {
    // Нет fly(), так что не нарушает
}

Теперь код работает только с Flyable, без неожиданностей.

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()).

class Animal190925 {
    public String speak() {
        return "Some sound";
    }
}

class Dog190925 extends Animal190925 {
    public String speak() {
        return "Woof";
    }
    
    public String fetch() {
        return "Fetching stick";
    }
}

public class Task190925 {
    public static void main(String[] args) {
        Animal190925 myAnimal = new Dog190925();
        System.out.println(myAnimal.speak());
        System.out.println(myAnimal.fetch());
    }
}