Как работает прототипное наследование?

# Как работает прототипное наследование

Этот вопрос обычно касается JavaScript, но в контексте Java Developer роли, могу объяснить оба подхода и их различия.

1. JavaScript Prototype Inheritance (если в контексте JS)

Базовая идея

В JavaScript каждый объект имеет невидимую ссылку [[Prototype]], которая указывает на прототип:

// Прототип — это просто объект
const personProto = {
    greet() {
        return `Hello, I'm ${this.name}`;
    },
    age: 25
};

// Создаём объект с прототипом
const john = Object.create(personProto);
john.name = "John";

console.log(john.name);     // "John" (свойство john)
console.log(john.age);      // 25 (из прототипа)
console.log(john.greet());  // "Hello, I'm John" (метод из прототипа)

Цепь прототипов

// Каждый объект может иметь прототип, у которого есть свой прототип...

const animal = {
    eat() { return "eating"; }
};

const dog = Object.create(animal);
dog.bark = function() { return "woof"; };

const myDog = Object.create(dog);
myDog.name = "Buddy";

// Цепь: myDog → dog → animal → Object.prototype → null

console.log(myDog.name);    // "Buddy" (в myDog)
console.log(myDog.bark());  // "woof" (в dog)
console.log(myDog.eat());   // "eating" (в animal)

Constructor Functions (старый способ)

function Person(name) {
    this.name = name;
}

// Методы добавляем на prototype
Person.prototype.greet = function() {
    return `Hello, I'm ${this.name}`;
};

const john = new Person("John");
console.log(john.greet());  // "Hello, I'm John"

// john.__proto__ === Person.prototype

Почему это интересно?

Это очень отличается от Java:

JavaScript: динамическое наследование через объекты
Java: статичное наследование через классы

JavaScript: может добавить метод в прототип в runtime
Java: структура класса фиксирована при компиляции

2. Java Class-Based Inheritance (основной вариант для Java Dev)

Классическое наследование

public class Animal {
    protected String name;
    
    public void eat() {
        System.out.println("Eating");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
    
    public void bark() {
        System.out.println("Woof!");
    }
}

Dog dog = new Dog();
dog.eat();   // "Dog is eating" (override)
dog.bark();  // "Woof!"

Полиморфизм

Animal animal = new Dog();  // Полиморфизм
animal.eat();  // Вызовет Dog.eat(), а не Animal.eat()
               // Потому что тип в runtime — Dog

// Это похоже на прототипную цепь JS,
// но определяется в compile-time

3. "Прототипное" в контексте Java Design Patterns

Prototype Pattern

Это паттерн для клонирования объектов:

public interface Prototype {
    Prototype clone();
}

public class User implements Prototype {
    private String name;
    private int age;
    
    @Override
    public User clone() {
        User copy = new User();
        copy.name = this.name;
        copy.age = this.age;
        return copy;
    }
}

User original = new User("John", 30);
User copy = original.clone();

// copy — это новый объект, независимый от original

Или через Cloneable:

public class Document implements Cloneable {
    private String title;
    private String content;
    
    @Override
    protected Document clone() throws CloneNotSupportedException {
        return (Document) super.clone();
    }
}

Document original = new Document("Title", "Content");
Document copy = original.clone();

4. Сравнение JavaScript и Java наследования

5. Если вопрос о Java Reflection (динамическое поведение)

// Java может работать более "прототипно" через Reflection

public class DynamicObject {
    private Map<String, Object> properties = new HashMap<>();
    private Map<String, Method> methods = new HashMap<>();
    
    public void setProperty(String name, Object value) {
        properties.put(name, value);
    }
    
    public Object getProperty(String name) {
        return properties.get(name);
    }
    
    public void addMethod(String name, Method method) {
        methods.put(name, method);
    }
    
    public Object invokeMethod(String name, Object... args) throws Exception {
        return methods.get(name).invoke(this, args);
    }
}

// Использование
DynamicObject obj = new DynamicObject();
obj.setProperty("name", "John");
obj.setProperty("age", 30);

// Это похоже на JavaScript: динамическое добавление свойств

6. Практический пример: Template Method Pattern (напоминает наследование)

public abstract class CoffeeRecipe {
    // Template method
    public final void makeCoffee() {
        boilWater();
        brewCoffee();
        pourInCup();
        addCondiments();
    }
    
    protected void boilWater() {
        System.out.println("Boiling water");
    }
    
    protected abstract void brewCoffee();
    protected abstract void addCondiments();
    
    protected void pourInCup() {
        System.out.println("Pouring into cup");
    }
}

public class Espresso extends CoffeeRecipe {
    @Override
    protected void brewCoffee() {
        System.out.println("Brewing espresso");
    }
    
    @Override
    protected void addCondiments() {
        System.out.println("Adding sugar");
    }
}

7. Modern Java: Records (похожи на прототипы)

В Java 16+ появились Records — неизменяемые классы-прототипы:

public record User(String name, int age) {}

// Это создаёт:
// - Constructor
// - Getters
// - equals(), hashCode(), toString()

User john = new User("John", 30);
User jane = john.copy(name = "Jane");  // можно скопировать с изменениями

8. Если вопрос о наследовании интерфейсов

public interface Drawable {
    void draw();
}

public interface Resizable extends Drawable {
    void resize(int size);
}

public class Circle implements Resizable {
    @Override
    public void draw() {
        System.out.println("Drawing circle");
    }
    
    @Override
    public void resize(int size) {
        System.out.println("Resizing to " + size);
    }
}

9. Composition vs Inheritance

// Неправильно: наследование (tight coupling)
public class Employee extends Person {  // Employee "IS-A" Person
    // Если Person меняется, Employee ломается
}

// Правильно: композиция (loose coupling)
public class Employee {
    private Person person;  // Employee "HAS-A" Person
    
    public String getName() {
        return person.getName();  // Делегируем
    }
}

// Композиция более гибкая и следует принципу DRY

10. Когда использовать наследование в Java

✅ Используйте когда:

• Есть явное "IS-A" отношение
• Нужно переопределить/расширить поведение
• Общая иерархия (Animal → Dog, Cat)

❌ Избегайте когда:

• Только для переиспользования кода (используйте композицию)
• Для изменения реализации (используйте интерфейсы)
• Есть множественное наследование (используйте интерфейсы)

Вывод

Для Java Developer:

Прототипное наследование (JavaScript):

• Динамическое, объекты наследуют от объектов
• Гибко, но сложно предсказать
• Используется в JavaScript

Наследование в Java:

• Статическое, классы наследуют от классов
• Тип проверяется при компиляции
• Более безопасно и быстро

Best Practice в Java:

• Используй интерфейсы (множественное наследование)
• Используй композицию вместо наследования
• Следуй принципу LSP (Liskov Substitution Principle)
• Избегай глубокой иерархии (max 3-4 уровня)