Оператор instanceof: Проверка типа

instanceof проверяет совместимость типов на runtime.

Синтаксис:

object instanceof Type

Возвращает true, если объект является экземпляром Type (класс, интерфейс) или его подтипа.

Нюанс: Для null — всегда false.

С Java 14+: Pattern matching (instanceof с переменной), но для простоты используем классический.

Пример безопасного downcasting:

Animal animal = new Dog("Шарик");

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();  // Безопасно
} else {
    System.out.println("Не собака!");
}

Проверка предотвращает ClassCastException.

С интерфейсами:

SoundMaker sound = new Dog("Шарик");
if (sound instanceof SoundMaker) {  // true
    // ...
}

Нюансы instanceof:
Работает с классами, интерфейсами, массивами.
Для примитивов — нет (они не объекты).
В иерархии: Dog instanceof Animal — true; Animal instanceof Dog — false (если объект Animal).
Performance: Не дорогой, но избегайте в горячих циклах.
Альтернативы: getClass().equals(Class.class) — строже, не учитывает подтипы.


Полный пример с полиморфизмом

Используем Animal, Dog, Cat:

public class Main {
    public static void main(String[] args) {
        Animal[] animals = {new Dog("Шарик"), new Cat("Мурка"), new Animal("Зверь")};

        for (Animal a : animals) {
            a.makeSound();  // Полиморфизм: каждый свой звук

            if (a instanceof Dog) {
                Dog d = (Dog) a;
                d.bark();  // Только для Dog
            } else if (a instanceof Cat) {
                Cat c = (Cat) a;
                // Специфический метод Cat, если есть
            }
        }
    }
}

Цикл работает с массивом Animal, но проверяет и приводит для специфического поведения.

Нюансы

ClassCastException: Всегда проверяйте instanceof перед downcasting.
Null: null instanceof Type — false; (Type) null — null (без исключения).
Generics: instanceof не работает с параметризованными типами на runtime (type erasure).
Массивы: Object[] instanceof String[] — false, даже если элементы String.
Интерфейсы: Класс может реализовывать несколько — instanceof true для любого.
Final классы: Не влияет на instanceof.
Performance и дизайн: Избегайте чрезмерного использования instanceof — это признак плохого дизайна (лучше полиморфизм через overriding). Используйте, когда нужно специфическое поведение.
Java 14+ Pattern Matching: if (animal instanceof Dog d) { d.bark(); } — упрощает, но для совместимости используйте классику.


Как создать это в IntelliJ IDEA

Проверка instanceof: IDE подскажет автодополнение.
Генерация: После if (a instanceof Dog) { } — IDE предложит создать переменную.
Debug: Поставьте breakpoint и смотрите типы объектов.


Полезные советы для новичков

Всегда проверяйте перед cast: Избегайте runtime ошибок.
Предпочитайте overriding: Вместо instanceof + cast, переопределяйте методы.
В коллекциях: Полезно для фильтрации типов.


#Java #для_новичков #beginner #poliphormizm #instanceof #Upcasting #Downcasting

Основы ООП в Java

Глава 5. Абстракция

Абстрактные классы и методы

Абстракция — это принцип ООП, который упрощает сложные системы, скрывая ненужные детали и показывая только essential интерфейс. Это позволяет моделировать реальные концепции на высоком уровне: например, "автомобиль" как абстракция, где вы знаете, что он едет, но не вникаете в механику двигателя.

В Java абстракция реализуется через абстрактные классы и интерфейсы (интерфейсы подробнее в следующем уроке). Абстрактные классы предоставляют частичную реализацию, заставляя подклассы заполнить пробелы.
Абстрактные классы: Определение и использование

Абстрактный класс — это класс, помеченный ключевым словом abstract, который нельзя инстанцировать (new AbstractClass() — ошибка). Он служит шаблоном для подклассов, предоставляя общий код и требуя реализации специфических частей.

Синтаксис:

public abstract class AbstractClass {
    // Абстрактные методы, concrete методы, поля
}

Особенности:
Может иметь абстрактные методы (без тела).
Может иметь обычные (concrete) методы с реализацией.
Может иметь поля, конструкторы.
Подклассы должны extends абстрактный класс и реализовать все абстрактные методы (или сами стать abstract).
Нюанс: Абстрактный класс может не иметь абстрактных методов — просто для предотвращения инстанциации.

Пример абстрактного класса Shape (Фигура):

public abstract class Shape {
    protected String color;  // Общее поле

    public Shape(String color) {
        this.color = color;
    }

    // Абстрактный метод: Подклассы должны реализовать
    public abstract double getArea();

    // Concrete метод: Общий для всех
    public void displayColor() {
        System.out.println("Цвет: " + color);
    }
}

getArea(): Абстрактный — без тела, заканчивается ;.
displayColor(): С реализацией — наследуется как есть.

#Java #для_новичков #beginner #Abstract

Абстрактные методы: Требование реализации

Абстрактный метод — это метод без тела, помеченный abstract. Он определяет "что делать", но не "как".

Синтаксис:

public abstract returnType methodName(params);

Правила:
Может быть только в абстрактном классе или интерфейсе.
Нет тела — только сигнатура.
Подклассы должны override и реализовать (или стать abstract).
Модификаторы: Не может быть private (бесполезно, если не виден), final (нельзя override), static (static не override).

Подкласс Circle, реализующий Shape:

public class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);  // Вызов конструктора абстрактного класса
        this.radius = radius;
    }

    // Реализация абстрактного метода
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

Circle не abstract, так что обязан реализовать getArea().
Теперь можно new Circle(...), но не new Shape().

Полиморфизм с абстрактными классами

Абстрактные классы усиливают полиморфизм: ссылка на абстрактный класс может указывать на concrete подклассы.

Пример:

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle("Красный", 5.0);  // Полиморфизм: Shape на Circle
        shape.displayColor();  // Цвет: Красный (concrete метод)
        System.out.println("Площадь: " + shape.getArea());  // Площадь: ~78.54 (реализация Circle)
    }
}

Нюанс: Конструктор абстрактного класса вызывается через super(), даже если класс abstract.

Все нюансы абстрактных классов и методов

Инстанциация: new AbstractClass() — ошибка компиляции.
Конструкторы: Могут быть, вызываются super() из подклассов. Полезны для инициализации общих полей.
Поля: Могут быть final, static, private и т.д. Static поля/методы доступны через AbstractClass.field.
Наследование: Абстрактный класс может extends другой abstract или concrete класс.
Интерфейсы vs abstract классы: Abstract классы могут иметь реализацию и состояние; интерфейсы — нет (до Java 8). Abstract для "is-a" с частичной реализацией.
Ошибки:
Абстрактный метод в non-abstract классе — ошибка.
Не реализован abstract метод в concrete подклассе — ошибка.
Abstract метод с телом — ошибка.

Модификаторы: Abstract класс не может быть final (final не extends). Abstract метод не может быть final/static/private.
Дизайн: Используйте для шаблонов с общим кодом, где подклассы уточняют поведение. Избегайте глубоких иерархий.
Java-специфика: С Java 8 интерфейсы имеют default методы, размывая грань с abstract классами.


Как создать это в IntelliJ IDEA

Абстрактный класс: New → Java Class → Укажите abstract в коде, или IDE предложит.
Абстрактный метод: В abstract классе напишите abstract void method(); — IDE подскажет.
Реализация: В подклассе Ctrl+O (Override) — выберите abstract метод.
Проверка: Если не реализован — IDE выделит ошибку.


Полезные советы для новичков

Используйте abstract для контрактов: Заставьте подклассы реализовать ключевые методы.
Конструкторы в abstract: Полезны для общих init.
Комбинируйте с полиморфизмом: Ссылки на abstract класс для коллекций подклассов.
Избегайте: Не делайте все abstract — используйте concrete для общего.
Ресурсы: Oracle Tutorials on Abstract Classes.


#Java #для_новичков #beginner #Abstract

Основы ООП в Java

Глава 5. Абстракция

Интерфейсы. Default и static методы

Интерфейс в Java — это полностью абстрактный тип, который определяет контракт: набор методов, которые класс должен реализовать. Он описывает "что делать", но не "как". Интерфейсы идеальны для задания общего поведения для несвязанных классов, поддерживая полиморфизм без наследования состояния.

Синтаксис:

public interface InterfaceName {
    // Абстрактные методы
    // (с Java 8) default и static методы
}

Особенности:
Все методы в интерфейсе до Java 8 были неявно public abstract.
Классы реализуют интерфейс через implements.
Один класс может реализовать несколько интерфейсов (множественная реализация).
Нельзя создать объект интерфейса (new Interface() — ошибка).


Интерфейсы: Основы и реализация

Класс, реализующий интерфейс, обязан предоставить реализацию всех его абстрактных методов (или стать abstract).

Пример интерфейса Drawable:

public interface Drawable {
    void draw();  // Неявно public abstract
}

Классы, реализующие Drawable:

public class Circle implements Drawable {
    private double radius;

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

    @Override
    public void draw() {
        System.out.println("Рисую круг радиусом " + radius);
    }
}

public class Square implements Drawable {
    private double side;

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

    @Override
    public void draw() {
        System.out.println("Рисую квадрат со стороной " + side);
    }
}

Полиморфизм с интерфейсом:

public class Main {
    public static void main(String[] args) {
        Drawable[] shapes = {new Circle(5.0), new Square(4.0)};
        for (Drawable shape : shapes) {
            shape.draw();  // Вызывает Circle.draw() или Square.draw()
        }
    }
}

Вывод:

Рисую круг радиусом 5.0
Рисую квадрат со стороной 4.0

Нюанс: Drawable объединяет несвязанные классы (Circle и Square) через общий контракт.


Default методы: Добавление реализации

С Java 8 интерфейсы могут содержать default методы — методы с реализацией, которые классы наследуют, если не переопределяют. Это позволяет расширять интерфейсы без ломки существующих реализаций.

Синтаксис:

default returnType methodName(params) {
    // Реализация
}

Пример с default методом:

public interface Drawable {
    void draw();

    default void describe() {
        System.out.println("Это фигура, которую можно нарисовать.");
    }
}

В Circle и Square не нужно реализовывать describe() — он наследуется.

Но можно переопределить:

public class Circle implements Drawable {
    private double radius;

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

    @Override
    public void draw() {
        System.out.println("Рисую круг радиусом " + radius);
    }

    @Override
    public void describe() {
        System.out.println("Это круг радиусом " + radius);
    }
}

Вызов circle.describe(): "Это круг радиусом 5.0".
Square использует default: "Это фигура, которую можно нарисовать.".

Зачем default:
Расширение интерфейса без изменения реализующих классов.
Общий код для большинства реализаций.
Нюанс: Если два интерфейса имеют default метод с одинаковой сигнатурой, класс должен явно переопределить его.


#Java #для_новичков #beginner #Abstract #Interfaces

Static методы: Утилиты интерфейса

С Java 8 интерфейсы могут содержать static методы — методы, принадлежащие интерфейсу, а не объекту. Они не наследуются и вызываются через имя интерфейса.

Пример:

public interface Drawable {
    void draw();

    default void describe() {
        System.out.println("Это фигура, которую можно нарисовать.");
    }

    static void printInfo() {
        System.out.println("Интерфейс Drawable для рисования фигур.");
    }
}

Вызов:

Drawable.printInfo();  // Вывод: Интерфейс Drawable для рисования фигур.

Нюанс: Circle.printInfo() — ошибка, только Drawable.printInfo().

Зачем static:
Утилитарные функции, связанные с интерфейсом.
Не требуют объекта, упрощают организацию кода.


Все нюансы интерфейсов

Множественная реализация:
Класс может implements Interface1, Interface2, ....

Нюанс: Конфликт default методов решается переопределением:

public class MyClass implements Interface1, Interface2 {
    @Override
    public void method() {
        Interface1.super.method();  // Выбор реализации
    }
}

Модификаторы:
Абстрактные методы: Неявно public abstract.
Поля: Всегда public static final (константы).
Default/static: Явно public.

Наследование интерфейсов:
Интерфейс может extends другой интерфейс: public interface AdvancedDrawable extends Drawable { ... }.

Ошибки:
Не реализован abstract метод в non-abstract классе — ошибка.
Конфликт default методов без переопределения — ошибка.
Нельзя инстанцировать интерфейс.


Default vs abstract классы:
Интерфейсы: Нет состояния, множественная реализация, default/static методы.
Abstract классы: Могут иметь состояние, конструкторы, одиночное наследование.
Java 9+: Private методы в интерфейсах для общего кода в default/static.


Как создать это в IntelliJ IDEA

Интерфейс: New → Interface → Drawable.
Implements: В классе напишите implements Drawable, IDE предложит override.
Default/static: Напишите default void describe() {} — IDE проверит синтаксис.
Тестирование: Создайте массив Drawable[] и цикл.


Полезные советы для новичков

Используйте интерфейсы для контрактов: Когда нужно поведение без состояния.
Default для совместимости: Добавляйте общую логику, но позволяйте override.
Static для утилит: Организуйте связанные функции.
Избегайте конфликтов: Переопределяйте default методы при множественной реализации.
Ресурсы: Oracle Tutorials on Interfaces.

#Java #для_новичков #beginner #Abstract #Interfaces

Основы ООП в Java

Глава 6. Ключевые модификаторы ООП

final: переменные, методы, классы

Модификатор final в Java означает "окончательный" и используется для предотвращения изменений. В зависимости от контекста — переменные, методы или классы — он ограничивает возможность переопределения, изменения или наследования.

Зачем нужен final:
Неизменяемость: Защищает данные от изменений, делая код предсказуемым.
Безопасность: Предотвращает нежелательное изменение поведения в подклассах.
Оптимизация: Компилятор может оптимизировать final-элементы, зная, что они не изменятся.
Дизайн: Помогает явно указать намерения разработчика (например, класс не для наследования).


final — один из ключевых инструментов для создания robust и maintainable кода в ООП.

1. Final переменные: Неизменяемые значения
Когда переменная помечена final, ее значение нельзя изменить после инициализации. Это делает переменную константой.

Типы переменных:
Локальные: Инициализируются один раз в методе.
Поля класса: Должны быть инициализированы при объявлении, в блоке инициализации или конструкторе.
Ссылочные типы: Ссылка неизменна, но объект, на который она указывает, может меняться (если он mutable).

Пример:

public class Circle {
    private final double PI = 3.14159;  // Константа
    private final double radius;        // Поле, инициализируется в конструкторе

    public Circle(double radius) {
        this.radius = radius;  // Инициализация final
    }

    public double getArea() {
        final double area = PI * radius * radius;  // Локальная final переменная
        // area = 10; // Ошибка: нельзя изменить
        return area;
    }
}

Нюанс: Для final ссылки (например, final StringBuilder sb = new StringBuilder();) нельзя переназначить sb = new StringBuilder();, но можно sb.append("text");.

Практика:
Константы: Обычно static final (например, public static final double PI = 3.14159;).
Именование: Константы в верхнем регистре с подчеркиваниями (MAX_VALUE).

2. Final методы: Запрет переопределения
Когда метод помечен final, его нельзя переопределить (override) в подклассах. Это полезно, когда поведение метода должно остаться неизменным.

Пример с наследованием:

public class Animal {
    public final void eat() {
        System.out.println("Животное ест.");
    }
}

public class Dog extends Animal {
    // Ошибка, если попытаться:
    // @Override
    // public void eat() { System.out.println("Собака ест кости."); }
}

Зачем:
Гарантия неизменного поведения.
Безопасность: Критичные методы (например, валидация) не изменятся.
Нюанс: final не влияет на вызов метода, только на override.

3. Final классы: Запрет наследования
Когда класс помечен final, его нельзя использовать как суперкласс (extends). Это предотвращает создание подклассов.

Пример:

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

// Ошибка:
// public class ExtendedPoint extends ImmutablePoint {}

Зачем:
Иммутабельность: Классы вроде String или Integer — final, чтобы гарантировать неизменность.
Безопасность: Например, в криптографии или конфигурации.
Дизайн: Сигнализирует, что класс завершен и не предназначен для расширения.

#Java #для_новичков #beginner #OOP #final

Все нюансы final

Переменные:
Инициализация: Должна быть до завершения конструктора (для полей) или до использования (локальные).
Blank final: final поле без начального значения, но с обязательной инициализацией в конструкторе.
Нюанс: final List<String> list = new ArrayList<>(); — можно менять содержимое list, но не саму ссылку.

Методы:
Не влияет на полиморфизм: Вызов метода работает как обычно.
Нельзя с abstract: Абстрактный метод требует override, final запрещает.
Нюанс: Используйте для методов, где логика критична (например, security checks).

Классы:
Все методы implicitly final, но это не нужно явно указывать.
Нюанс: String, Integer, Double — примеры final классов в Java.

Ошибки:
Изменение final переменной: Ошибка компиляции.
Override final метода: Ошибка компиляции.
Extends final класса: Ошибка компиляции.

Дизайн и производительность:
Final улучшает оптимизацию JIT (компилятор знает, что не будет изменений).
Избегайте чрезмерного использования: Final классы ограничивают гибкость (например, тестирование с mocking).
Константы: static final для глобальных неизменяемых значений.

Сценарии использования:
Immutable классы: Все поля final, класс final.
Utility классы: Часто final (например, java.lang.Math).
Конфигурации: Final поля для неизменяемых настроек.


Как создать это в IntelliJ IDEA

Final переменные: Объявите поле с final, IDE проверит инициализацию.
Final методы: Добавьте final перед методом, IDE предупредит о попытке override.
Final классы: Добавьте final к классу, IDE покажет ошибку при extends.
Тестирование: Создайте Main и проверьте поведение.


Полезные советы для новичков

Константы: Используйте static final для PI, MAX_VALUE и т.д.
Иммутабельность: Делайте поля final для защиты данных.
Дизайн: Final классы для завершенных реализаций, но не злоупотребляйте.
Проверяйте: Попробуйте override final метода — IDE покажет ошибку.
Ресурсы: Oracle Tutorials on Final Classes and Methods.


#Java #для_новичков #beginner #OOP #final

Основы ООП в Java

Глава 6. Ключевые модификаторы ООП

static: поля, методы, блоки инициализации

Модификатор static означает "статический" и привязывает элемент к классу, а не к экземпляру (объекту). Static-элементы существуют в одном экземпляре на класс, независимо от количества объектов.

Зачем нужен static:
Общие данные: Для переменных, общих для всех объектов (например, счетчик экземпляров).
Утилиты: Для методов, не зависящих от состояния объекта (например, Math.sqrt()).
Эффективность: Избежать создания объектов для вызова методов.
Инициализация: Блоки для выполнения кода при загрузке класса.

Static — инструмент для класс-уровня логики в ООП, но не злоупотребляйте: он может нарушать инкапсуляцию.
Static поля: Общие переменные класса
Static поля (class variables) принадлежат классу и делятся всеми объектами. Они инициализируются при загрузке класса.

Синтаксис:

static type fieldName = value;

Доступ: Через ClassName.fieldName или объект.fieldName (но рекомендуется через класс).

Пример:

public class Counter {
    public static int count = 0;  // Static поле

    public Counter() {
        count++;  // Увеличивает общее значение
    }
}

Использование:

public class Main {
    public static void main(String[] args) {
        new Counter();
        new Counter();
        System.out.println(Counter.count);  // 2
    }
}

Нюанс: Static поля инициализируются по умолчанию (0 для чисел, null для объектов). Можно изменить в static блоке.


Static методы: Утилиты класса

Static методы принадлежат классу и вызываются без объекта. Они не имеют доступа к non-static полям/методам (нет this).

Синтаксис:

static returnType methodName(params) { ... }
Доступ: ClassName.methodName().

Пример:

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

Вызов:

int sum = MathUtils.add(5, 3);  // 8

Нюанс: Static методы не override — это method hiding. Вызов зависит от типа ссылки, не объекта.


Static блоки инициализации: Код при загрузке класса

Static блоки — код, выполняющийся один раз при загрузке класса (перед конструкторами).

Синтаксис:

static {
    // Код
}

Пример:

public class Config {
    public static String appName;

    static {
        appName = "MyApp";  // Инициализация при загрузке
        System.out.println("Класс загружен!");
    }
}

Нюанс: Несколько блоков выполняются в порядке объявления. Полезно для сложной инициализации static полей (например, загрузка конфигурации).


Все нюансы static

Доступ и видимость:
Static элементы доступны без объекта, но non-static — нет из static контекста.
Нюанс: Из static метода нельзя this.field или non-static method() — ошибка.

Наследование:
Static поля/методы наследуются, но не override — hiding. ChildClass.staticMethod() скрывает ParentClass.staticMethod().
Нюанс: Вызов через ссылку: Animal a = new Dog(); a.staticMethod() — вызовет Animal.version (зависит от типа ссылки).

Инициализация:
Static поля/блоки инициализируются при первой загрузке класса (class loading).
Нюанс: Lazy loading — не инициализируется, пока не используется.

Ошибки:
Доступ к non-static из static — ошибка компиляции.
Static в интерфейсах: Да, с Java 8 (static методы).
Static классы: Nested классы могут быть static (не зависят от внешнего объекта).

Дизайн:
Избегайте mutable static полей — проблемы в многопоточности.
Используйте для констант (static final), утилит (Math), singleton.
Нюанс: Static блоки для JDBC драйверов или логирования.

Многопоточность: Static поля общие — используйте synchronization для изменений.


Как создать это в IntelliJ IDEA

Static поле/метод: Добавьте static — IDE подскажет доступ.
Static блок: Напишите static {} — IDE форматирует.
Тестирование: Вызовите static через класс — IDE автодополнит.


Полезные советы для новичков

Константы: public static final для глобальных.
Утилиты: Static методы для helper-классов.
Избегайте состояния: Static поля — только immutable.
Тестируйте: Проверьте доступ из static/non-static.
Ресурсы: Oracle Tutorials on Static Members.


#Java #для_новичков #beginner #OOP #static

Основы ООП в Java

Глава 6. Ключевые модификаторы ООП

Перечисления (enum)

Перечисление (enum) — это специальный класс, который представляет фиксированный набор констант (например, дни недели, цвета или статусы). Enum введен в Java 5 и является полноценным классом, наследующим от java.lang.Enum, но с особым синтаксисом.

Зачем нужен enum:
Типобезопасность: Вместо int или String для констант (где возможны ошибки, как 8 для дня недели), enum гарантирует только допустимые значения.
Читаемость: Код становится самодокументируемым (Day.MONDAY clearer, чем 1).
ООП-функции: Enum может иметь поля, методы, конструкторы.
Переключатели: Идеально для switch, без ошибок.
Неизменяемость: Enum константы immutable и final.

Enum — это абстракция для групп констант, делая код robust и maintainable.


Синтаксис и базовое использование enum

Enum объявляется как класс, но с enum вместо class. Константы перечисляются через запятую.

Синтаксис:

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("Середина недели!");
        }
    }
}

Нюанс: Enum константы — это объекты, но сравниваются через == (не equals, так как уникальные).

Вывод:

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

Enum с полями, конструкторами и методами

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

Пример с полями:

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

Нюанс: Конструктор private (нельзя new Planet()). Константы — единственные экземпляры.
Методы: Могут быть абстрактными (каждая константа реализует) или обычными.


#Java #для_новичков #beginner #OOP #Enum

Методы Enum-класса и полезные функции

Enum наследует от Enum<E>, предоставляя методы:
name(): Возвращает имя константы как String.
ordinal(): Порядковый номер (начиная с 0).
valueOf(String name): Возвращает enum по имени.
values(): Массив всех констант.

Пример:

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

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

Нюанс: ordinal() не рекомендуется для логики — лучше поля, так как порядок может измениться.


Switch с enum

Enum идеален для switch — безопасно и читаемо.

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

Нюанс: Нет default, если все случаи покрыты — компилятор не требует.


Все нюансы enum

Наследование и реализация:
Enum не может extends класс (уже extends Enum), но может implements интерфейсы.
Нюанс: public enum MyEnum implements Interface { ... }


Конструкторы и поля:
Конструкторы private.
Константы должны быть первыми в enum, за ними — поля/методы.
Нюанс: Константы с параметрами: CONSTANT(params),

Иммутабельность: Enum константы final и immutable — идеально для singleton.
Сериализация: Enum сериализуется по имени, безопасно.

Ошибки:
Enum с public конструктором — ошибка.
valueOf("INVALID") — IllegalArgumentException.
Enum не может быть abstract, но может иметь abstract методы (константы реализуют).


Дизайн:
Используйте для фиксированных наборов (статусы, типы).
Добавляйте методы для логики.
Нюанс: Nested enum — static по умолчанию.


Как создать это в IntelliJ IDEA

Enum: New → Enum → Planet.
Константы: Напишите MERCURY(3.303e+23, 2.4397e6), — IDE подскажет конструктор.
Методы: Добавьте surfaceGravity() — IDE поможет с override для abstract.
Switch: Напишите switch (day) — IDE сгенерирует cases.


Полезные советы для новичков

Замените int/String константы: Enum safer.
Добавляйте toString(): Переопределите для custom вывода.
Используйте в коллекциях: Set для уникальных.
ordinal() осторожно: Лучше поля для значений.
Ресурсы: Oracle Tutorials on Enum Types.


#Java #для_новичков #beginner #OOP #Enum