Основы ООП в 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