Какие элементы языка отвечают за наследование

Элементы языка Java, отвечающие за наследование

Наследование (Inheritance) — это один из столпов объектно-ориентированного программирования (ООП), который позволяет классу наследовать поля и методы от другого класса. В Java это ключевой механизм для переиспользования кода и создания иерархий типов.

Основной механизм наследования: ключевое слово extends

Концепция: Класс-наследник получает все публичные и защищённые члены класса-родителя.

// Базовый класс (Parent / Superclass)
public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println(name + " ест");
    }
    
    public String getName() {
        return name;
    }
}

// Класс-наследник (Child / Subclass)
public class Dog extends Animal {  // ← ключевое слово `extends`
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age);  // Вызов конструктора родителя
        this.breed = breed;
    }
    
    // Наследованные методы (from Animal):
    // - eat()
    // - getName()
    
    // Новые методы в Dog
    public void bark() {
        System.out.println("Вав! Я " + breed);
    }
}

// Использование
Animal animal = new Animal("Животное", 5);
Dog dog = new Dog("Шарик", 3, "Лабрадор");

animal.eat(); // "Животное ест"
dog.eat();    // "Шарик ест" (наследованный метод)
dog.bark();   // "Вав! Я Лабрадор"

1. Ключевое слово extends

Назначение: Указать, что класс наследует от другого класса.

// Синтаксис
public class ChildClass extends ParentClass {
    // ...
}

// Примеры
public class Car extends Vehicle { }
public class Manager extends Employee { }
public class ArrayList<E> extends AbstractList<E> { }

Правила:

• В Java можно наследовать только от одного класса (single inheritance)
• Каждый класс (кроме Object) наследует от какого-то класса
• Иерархия наследования может быть достаточно глубокой

// Цепочка наследования
public class Animal { }
public class Mammal extends Animal { }
public class Dog extends Mammal { }
public class Husky extends Dog { }

// Husky наследует от Dog, Dog от Mammal, Mammal от Animal
Husky husky = new Husky();
husky.getClass().getSuperclass(); // Dog
husky.getClass().getSuperclass().getSuperclass(); // Mammal

2. Ключевое слово super

Назначение: Ссылка на методы и конструктор родительского класса.

public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " ест");
    }
}

public class Dog extends Animal {
    private String breed;
    
    // 1. Вызов конструктора родителя
    public Dog(String name, String breed) {
        super(name);  // ← вызов конструктора Animal
        this.breed = breed;
    }
    
    // 2. Расширение метода родителя
    @Override
    public void eat() {
        super.eat();  // ← вызов eat() из Animal
        System.out.println("Мой любимый корм — мясо");
    }
    
    // 3. Доступ к полям родителя
    public void printInfo() {
        System.out.println("Имя: " + super.name);
    }
}

// Использование
Dog dog = new Dog("Шарик", "Овчарка");
dog.eat();
// Вывод:
// Шарик ест
// Мой любимый корм — мясо

3. Переопределение методов (@Override)

Назначение: Класс-наследник может переопределить метод родителя с другой реализацией.

public class Shape {
    public double getArea() {
        return 0;
    }
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override  // ← аннотация для явного указания переопределения
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double getArea() {
        return width * height;
    }
}

// Полиморфизм: один интерфейс, разная реализация
Shape shape1 = new Circle(5);
Shape shape2 = new Rectangle(4, 6);

System.out.println(shape1.getArea()); // ~78.54
System.out.println(shape2.getArea()); // 24

Правила переопределения:

• Сигнатура метода должна быть одинаковой (имя, параметры)
• Возвращаемый тип может быть более узким (covariant returns)
• Уровень доступа может быть только более открытым

public class Parent {
    protected String method(int x) {
        return "Parent";
    }
}

public class Child extends Parent {
    @Override
    public String method(int x) {  // ✅ Правильно: protected → public
        return "Child";
    }
    
    // ❌ Неправильно: нельзя сузить видимость
    // private String method(int x) { }
    
    // ❌ Неправильно: другая сигнатура
    // public String method(String x) { }
}

4. Полиморфизм через наследование

Концепция: Ссылка родительского типа может указывать на объект дочернего типа.

public abstract class Vehicle {
    protected String name;
    
    public abstract void startEngine();
    public abstract int getMaxSpeed();
}

public class Car extends Vehicle {
    @Override
    public void startEngine() {
        System.out.println("Машина: Vroooom!");
    }
    
    @Override
    public int getMaxSpeed() {
        return 200;
    }
}

public class Bicycle extends Vehicle {
    @Override
    public void startEngine() {
        System.out.println("Велосипед: Быстро крутим педали!");
    }
    
    @Override
    public int getMaxSpeed() {
        return 40;
    }
}

// Полиморфизм в действии
List<Vehicle> vehicles = new ArrayList<>();
vehicles.add(new Car());
vehicles.add(new Bicycle());
vehicles.add(new Car());

// Один цикл, разная реализация
for (Vehicle v : vehicles) {
    v.startEngine();  // Каждый вызовет свою версию
}

// Вывод:
// Машина: Vroooom!
// Велосипед: Быстро крутим педали!
// Машина: Vroooom!

5. Класс Object (корень иерархии)

Концепция: Все классы в Java наследуют от класса Object.

public class MyClass {
    // Автоматически наследует от Object
}

// Эквивалентно:
public class MyClass extends Object {
    // ...
}

// Методы из Object, доступные везде:
public class Example {
    public static void main(String[] args) {
        Object obj = new Object();
        
        // equals()
        obj.equals(new Object());  // сравнение по ссылке
        
        // hashCode()
        obj.hashCode();  // для HashSet, HashMap
        
        // toString()
        obj.toString();  // "java.lang.Object@2d98e3"
        
        // getClass()
        obj.getClass();  // java.lang.Object
        
        // wait(), notify(), notifyAll() - для синхронизации
        // obj.wait();
        
        // clone()
        Object cloned = obj.clone();  // создаёт копию
    }
}

Частое переопределение методов Object:

public class User {
    private Long id;
    private String email;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;  // Проверка идентичности
        if (o == null || getClass() != o.getClass()) return false;
        
        User user = (User) o;
        return Objects.equals(email, user.email);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(email);
    }
    
    @Override
    public String toString() {
        return "User{" +
               "id=" + id +
               ", email='" + email + '\'' +
               '}';
    }
}

// Использование
User user1 = new User(1L, "john@example.com");
User user2 = new User(2L, "john@example.com");

System.out.println(user1.equals(user2));  // true (по email)
System.out.println(user1.toString());      // User{id=1, email='john@example.com'}

6. Абстрактные классы (Abstract Classes)

Назначение: Определить общее поведение, которое должно быть реализовано подклассами.

public abstract class DatabaseConnection {
    protected String connectionString;
    
    // Абстрактный метод (должна быть реализация в подклассе)
    public abstract void connect();
    public abstract void disconnect();
    
    // Обычный метод (одинаков для всех)
    public void printConnectionString() {
        System.out.println("Подключение: " + connectionString);
    }
}

public class MySQLConnection extends DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Подключение к MySQL на " + connectionString);
    }
    
    @Override
    public void disconnect() {
        System.out.println("Отключение от MySQL");
    }
}

public class PostgresConnection extends DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Подключение к PostgreSQL на " + connectionString);
    }
    
    @Override
    public void disconnect() {
        System.out.println("Отключение от PostgreSQL");
    }
}

// Использование
DatabaseConnection conn = new MySQLConnection();  // Ссылка на abstract class
conn.connect();  // MySQL-специфичная реализация

Отличия abstract класса от interface:

Абстрактный класс                Interface
├─ Может иметь конструктор        ├─ Нет конструктора
├─ Может иметь поля               ├─ Только final static поля
├─ Может иметь обычные методы     ├─ Все методы абстрактные (или default)
├─ Может быть private/protected   ├─ Только public
├─ Поддерживает состояние         ├─ Не поддерживает состояние
└─ Одно наследование              └─ Множественная реализация

7. Интерфейсы (Interfaces)

Назначение: Определить контракт методов, которые должны быть реализованы.

public interface PaymentProcessor {
    void processPayment(double amount) throws PaymentException;
    void refund(String transactionId) throws PaymentException;
    boolean isAvailable();
}

public interface Serializable {
    // Маркер интерфейс — нет методов
}

// Реализация интерфейса
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) throws PaymentException {
        // реализация
    }
    
    @Override
    public void refund(String transactionId) throws PaymentException {
        // реализация
    }
    
    @Override
    public boolean isAvailable() {
        return true;
    }
}

// Множественная реализация
public class PayPalProcessor implements PaymentProcessor, Serializable {
    // должна реализовать все методы PaymentProcessor
}

// Множественное наследование интерфейсов
public interface Auditable {
    void log(String message);
}

public class Transaction implements PaymentProcessor, Auditable, Serializable {
    // Реализует методы из всех трёх интерфейсов
}

8. Ключевое слово final

Назначение: Запретить наследование или переопределение.

// 1. Запрет на наследование класса
public final class ImmutableClass {
    // Никто не может наследовать
}

// Примеры в Java: String, Integer, Boolean
public final class String { }  // Нельзя расширить

// 2. Запрет на переопределение метода
public class Parent {
    public final void criticalMethod() {
        // Подклассы не могут переопределить
    }
}

public class Child extends Parent {
    // ❌ Это вызовет ошибку компиляции:
    // @Override
    // public void criticalMethod() { }
}

// 3. Запрет на изменение переменной
public class Config {
    public static final double PI = 3.14159;
    // После инициализации значение не может быть изменено
}

9. Instanceof (проверка типа)

Назначение: Проверить, является ли объект экземпляром определённого класса.

public class PaymentService {
    public void processPayment(PaymentProcessor processor) {
        if (processor instanceof CreditCardProcessor) {
            CreditCardProcessor cardProc = (CreditCardProcessor) processor;
            cardProc.processPayment(100);
        } else if (processor instanceof PayPalProcessor) {
            PayPalProcessor paypal = (PayPalProcessor) processor;
            paypal.processPayment(100);
        }
    }
}

// Java 16+: Pattern matching
public void processPaymentModern(PaymentProcessor processor) {
    if (processor instanceof CreditCardProcessor cardProc) {
        // cardProc уже приведена к нужному типу
        cardProc.processPayment(100);
    } else if (processor instanceof PayPalProcessor paypal) {
        paypal.processPayment(100);
    }
}

10. Множественное наследование через интерфейсы

public interface Eatable {
    void eat();
}

public interface Walkable {
    void walk();
}

public interface Talkable {
    void talk();
}

// Класс может реализовать несколько интерфейсов
public class Human implements Eatable, Walkable, Talkable {
    @Override
    public void eat() {
        System.out.println("Человек ест");
    }
    
    @Override
    public void walk() {
        System.out.println("Человек идёт");
    }
    
    @Override
    public void talk() {
        System.out.println("Человек говорит");
    }
}

public class Dog implements Eatable, Walkable {
    @Override
    public void eat() {
        System.out.println("Собака ест");
    }
    
    @Override
    public void walk() {
        System.out.println("Собака бежит");
    }
}

Диаграмма наследования

Object (корень иерархии)
  |
  ├─ String (final — не наследуется)
  ├─ Number (abstract)
  │  ├─ Integer (final)
  │  ├─ Double (final)
  │  └─ BigDecimal
  ├─ Collection
  │  ├─ List
  │  │  ├─ ArrayList
  │  │  ├─ LinkedList
  │  │  └─ Vector
  │  ├─ Set
  │  │  ├─ HashSet
  │  │  ├─ TreeSet
  │  │  └─ LinkedHashSet
  │  └─ Queue
  │     └─ ...
  └─ ...

Выводы

Ключевые элементы наследования в Java:

1. extends — наследование от класса (single inheritance)
2. super — доступ к методам и конструктору родителя
3. @Override — переопределение методов
4. Полиморфизм — разные реализации одного интерфейса
5. Object — корень иерархии всех классов
6. abstract — определение контракта для подклассов
7. interface — множественное наследование через implements
8. final — запрет на наследование или переопределение
9. instanceof — проверка типа объекта
10. Множественное наследование интерфейсов — один класс может реализовать несколько интерфейсов

Золотые правила:

• Предпочитай composition наследованию где возможно
• Используй abstract классы для состояния и поведения
• Используй интерфейсы для контрактов и множественного наследования
• Переопределяй equals() и hashCode() при необходимости
• Не углубляй иерархию больше чем на 3-4 уровня