public enum EnumName {
    CONSTANT1,
    CONSTANT2,
    // ...
}

public enum Day {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;  // Константа
        System.out.println(today);  // WEDNESDAY

        if (today == Day.WEDNESDAY) {  // Сравнение через ==
            System.out.println("Середина недели!");
        }
    }
}

System.out.println(today) вызывает toString(), который возвращает имя константы.

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;   // Масса в кг
    private final double radius; // Радиус в м

    // Конструктор (private по умолчанию)
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    // Метод
    public double surfaceGravity() {
        final double G = 6.67300E-11;  // Константа гравитации
        return G * mass / (radius * radius);
    }
}

Planet earth = Planet.EARTH;
System.out.println("Гравитация на Земле: " + earth.surfaceGravity());  // ~9.8

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, без неожиданностей.