Как добраться из дочернего класса до реализации родительского класса

# Доступ к реализации родительского класса из дочернего

Основное средство: ключевое слово super

super — это специальное ключевое слово в Java, которое позволяет обращаться к членам родительского класса:

public class Parent {
    public void greet() {
        System.out.println("Hello from Parent");
    }
    
    public int getValue() {
        return 10;
    }
}

public class Child extends Parent {
    
    @Override
    public void greet() {
        // Получить доступ к родительской реализации
        super.greet(); // Output: "Hello from Parent"
        System.out.println("Hello from Child");
    }
    
    public void callParentMethod() {
        int value = super.getValue(); // 10
        System.out.println("Parent value: " + value);
    }
}

// Использование
Child child = new Child();
child.greet();
// Output:
// Hello from Parent
// Hello from Child

Вариант 1: Переопределение с вызовом super

Когда дочерний класс переопределяет метод, но хочет сначала выполнить родительскую логику:

public class EmailNotifier {
    
    public void send(String message) {
        System.out.println("Validating email...");
        System.out.println("Sending email: " + message);
    }
}

public class EnhancedEmailNotifier extends EmailNotifier {
    
    @Override
    public void send(String message) {
        // 1. Вызвать родительскую реализацию
        super.send(message);
        
        // 2. Добавить собственную логику
        System.out.println("Email sent successfully");
        logToDatabase(message);
    }
    
    private void logToDatabase(String message) {
        System.out.println("Logged to DB");
    }
}

// Использование
EmailNotifier notifier = new EnhancedEmailNotifier();
notifier.send("Hello World");
// Output:
// Validating email...
// Sending email: Hello World
// Email sent successfully
// Logged to DB

Вариант 2: super в конструкторах

Обычно используется для инициализации родительского класса:

public class Vehicle {
    protected String brand;
    protected int year;
    
    public Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }
}

public class Car extends Vehicle {
    private String color;
    
    public Car(String brand, int year, String color) {
        // Вызвать конструктор родителя
        super(brand, year);
        this.color = color;
    }
    
    public void displayInfo() {
        System.out.println(brand + " " + year + " (" + color + ")");
    }
}

// Использование
Car car = new Car("Toyota", 2023, "Red");
car.displayInfo(); // Output: Toyota 2023 (Red)

Вариант 3: super с полями

Доступ к переменным родительского класса:

public class Parent {
    protected String name = "Parent Name";
}

public class Child extends Parent {
    private String name = "Child Name"; // Переопределение
    
    public void printNames() {
        System.out.println("Child name: " + name);
        System.out.println("Parent name: " + super.name);
    }
}

// Использование
Child child = new Child();
child.printNames();
// Output:
// Child name: Child Name
// Parent name: Parent Name

Важные ограничения: static методы

Ключевое слово super не работает для static методов:

public class Parent {
    public static void staticMethod() {
        System.out.println("Parent static method");
    }
    
    public void instanceMethod() {
        System.out.println("Parent instance method");
    }
}

public class Child extends Parent {
    public static void staticMethod() {
        // ❌ ОШИБКА! super не работает с static
        // super.staticMethod(); // Компиляции не будет
        
        // Способ вызвать родительский static метод:
        Parent.staticMethod(); // ✅ Правильно
    }
    
    @Override
    public void instanceMethod() {
        super.instanceMethod(); // ✅ Правильно
    }
}

Вариант 4: Multiple inheritance через интерфейсы (Java 8+)

Java не поддерживает множественное наследование классов, но это можно сделать через интерфейсы:

public interface Logger {
    default void log(String message) {
        System.out.println("[LOG] " + message);
    }
}

public interface Validator {
    default void validate(String value) {
        System.out.println("[VALIDATE] " + value);
    }
}

public class Service implements Logger, Validator {
    
    public void process(String data) {
        // Вызвать реализацию из интерфейса Logger
        Logger.super.log("Processing: " + data);
        
        // Вызвать реализацию из интерфейса Validator
        Validator.super.validate(data);
    }
}

// Использование
Service service = new Service();
service.process("test");
// Output:
// [LOG] Processing: test
// [VALIDATE] test

Вариант 5: super в методах высшего порядка

Вызов родительского метода из анонимного класса:

public class Component {
    public void render() {
        System.out.println("Rendering component");
    }
}

public class Application {
    
    public static void main(String[] args) {
        Component component = new Component() {
            @Override
            public void render() {
                // Вызвать родительскую реализацию
                super.render();
                System.out.println("Custom rendering");
            }
        };
        
        component.render();
        // Output:
        // Rendering component
        // Custom rendering
    }
}

Практический пример: логирование

// Базовый класс
public abstract class BaseRepository<T> {
    
    public T save(T entity) {
        System.out.println("Saving entity: " + entity.getClass().getSimpleName());
        // Логика сохранения
        return entity;
    }
    
    public void delete(T entity) {
        System.out.println("Deleting entity");
    }
}

// Дочерний класс с аудитом
public class AuditedUserRepository extends BaseRepository<User> {
    
    @Override
    public User save(User user) {
        // Вызвать базовую реализацию
        User saved = super.save(user);
        
        // Добавить аудит
        auditLog("User saved: " + user.getId());
        
        return saved;
    }
    
    @Override
    public void delete(User user) {
        // Вызвать базовую реализацию
        super.delete(user);
        
        // Добавить аудит
        auditLog("User deleted: " + user.getId());
    }
    
    private void auditLog(String message) {
        System.out.println("[AUDIT] " + message);
    }
}

// Использование
AuditedUserRepository repo = new AuditedUserRepository();
User user = new User("john");
repo.save(user);
// Output:
// Saving entity: User
// [AUDIT] User saved: john

repo.delete(user);
// Output:
// Deleting entity
// [AUDIT] User deleted: john

Частые ошибки

❌ Забыли вызвать super в конструкторе

public class Parent {
    protected String value;
    
    public Parent(String value) {
        this.value = value;
    }
}

public class Child extends Parent {
    private String name;
    
    public Child(String value, String name) {
        // ❌ ОШИБКА: забыли super()
        // this.value не инициализирована!
        this.name = name;
    }
    
    // ✅ Правильно
    public Child(String value, String name) {
        super(value); // Вызвали конструктор родителя
        this.name = name;
    }
}

❌ Вызвали super слишком поздно

public class BadChild extends Parent {
    public BadChild(String value) {
        // ❌ ОШИБКА: используем this перед super
        // this.value = value; // Компиляция не будет
        
        super(value); // super должен быть ПЕРВЫМ
    }
}

Итого

super используется для:

1. ✅ Вызова методов родительского класса
2. ✅ Вызова конструктора родительского класса
3. ✅ Доступа к полям родительского класса
4. ✅ В интерфейсах (Java 8+) для вызова default реализаций

super НЕ работает:

• ❌ Со static методами
• ❌ За пределами класса

Правила:

• Всегда вызывайте super() первым в конструкторе
• Используйте super для переиспользования кода родителя
• Будьте осторожны с переопределением переменных

На интервью объясните, что super — это основной механизм полиморфизма в Java и неотъемлемая часть наследования.