Day[] days = Day.values();
for (Day d : days) {
    System.out.println(d + " ordinal: " + d.ordinal());
}

Вывод: MONDAY ordinal: 0, etc.

public void printDayType(Day day) {
    switch (day) {
        case MONDAY:
        case TUESDAY:
        case WEDNESDAY:
        case THURSDAY:
        case FRIDAY:
            System.out.println("Рабочий день");
            break;
        case SATURDAY:
        case SUNDAY:
            System.out.println("Выходной");
            break;
    }
}

enum Status {
    ACTIVE, INACTIVE;
    
    Status() {
        System.out.print(this.name() + " ");
    }
}

public class Task170925 {
    public static void main(String[] args) {
        System.out.print("Start ");
        Status status = Status.ACTIVE;
        System.out.print("End");
    }
}

Mono<string> mono = Mono.just("Привет из реки");  // Создаём простой Mono с одним элементом
mono.subscribe(
   value -> System.out.println("Получено: " + value),    // onNext: реакция на элемент
   error -> System.err.println("Ошибка: " + error),        // onError
    () -> System.out.println("Завершено")                        // onComplete
);

Здесь subscribe — это подписка. Mono "течёт" асинхронно: если элемент готов — срабатывает onNext, потом onComplete. Нет блокировок: код continue после subscribe.

Flux<integer> flux = Flux.range(1, 5);   // Поток чисел от 1 до 5
flux.subscribe(
         value -> System.out.println("Элемент: " + value),
         error -> System.err.println("Ошибка: " + error),
         () -> System.out.println("Поток завершён")
);

Flux.fromIterable(List.of("яблоко", "банан", "вишня"))
        .filter(fruit -> fruit.startsWith("б")) // Фильтруем
        .map(String::toUpperCase)              // Преобразуем
        .subscribe(System.out::println);       // Подписываемся

Результат: "БАНАН". Всё течёт как конвейер, без callback-ада: код читаем, как последовательный, но работает асинхронно.

Flux<integer> fastFlux = Flux.range(1, 1000); // Быстрый источник
fastFlux.subscribe(new BaseSubscriber<integer>() {

@Override
protected void hookOnSubscribe(Subscription subscription) {
        request(10); // Запрашиваем только 10 элементов сначала
}

@Override
protected void hookOnNext(Integer value) {
          System.out.println(value);
          if (value % 10 == 0) request(10); // Запрашиваем ещё по мере обработки
          }
});

import java.util.HashSet;
import java.util.Set;

public class Task180925 {
    public static void main(String[] args) {
        Point p1 = new Point(1, 2);
        Point p2 = new Point(1, 3);
        Set<Point> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        System.out.println(set.size());
    }

    public record Point(int x, int y) {
        public Point {
            if (x < 0) throw new IllegalArgumentException("x < 0");
            if (y < 0) throw new IllegalArgumentException("y < 0");
        }

        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x;
        }

        public int hashCode() {
            return x;
        }
    }
}

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());
    }
}