Как реализуется наследование в Java?

Так, слушай, а вот эта ваша Java с её наследованием — это ж, блядь, как в семье: всё хорошее от родителей берёшь, а своё говно приносишь. Короче, если по-простому, то extends — это как крикнуть «папа, я твой!», и тебе автоматом скидывают все его методы и поля, кроме самых пошлых приватных, которые он в сейфе держит.

Вот как это выглядит, если не умничать:

class Roditel {
    // Тут всё, что папаша нажил
}

class Rebenok extends Roditel {
    // А тут ты уже со своим барахлом + всё папино (кроме его личных дневников)
}

Ну, а теперь на живом примере, чтобы понятно было:

// Это типа наш батя, транспортное средство
class Transport {
    protected String marka; // protected — чтоб дети могли трогать
    protected int godVypuska;

    public Transport(String marka, int god) {
        this.marka = marka;
        this.godVypuska = god;
    }

    public void startniDvigatel() {
        System.out.println("Двигатель завелся, ёпта!");
    }

    public void pokazhiChtoTam() {
        System.out.println("Марка: " + marka + ", Год выпуска: " + godVypuska);
    }
}

// А это его сынок, конкретная тачка
class Mashina extends Transport {
    private int kolvoDverej; // Своя фишка

    public Mashina(String marka, int god, int dveri) {
        // Кричим super, чтоб папин конструктор вызвать, иначе он обидится
        super(marka, god);
        this.kolvoDverej = dveri;
    }

    // Переписываем папин метод по-своему (оверрайд, блядь)
    @Override
    public void pokazhiChtoTam() {
        super.pokazhiChtoTam(); // Сначала папино выведем
        System.out.println("Дверей: " + kolvoDverej); // Потом своё
    }

    // А это уже своё, родное
    public void posignali() {
        System.out.println("Бип-бип, сука!");
    }
}

// Ну и где это всё работает
public class Main {
    public static void main(String[] args) {
        Mashina moyaMashina = new Mashina("Toyota", 2023, 4);
        moyaMashina.startniDvigatel(); // Метод от папы
        moyaMashina.pokazhiChtoTam();  // Метод переписанный
        moyaMashina.posignali();       // Свой метод

        // А вот тут магия полиморфизма, ёпта: машину можно в папу запихнуть
        Transport transport = moyaMashina;
        transport.pokazhiChtoTam(); // И всё равно вызовется метод сына! Хитро, блядь.
    }
}

А теперь главные подводные ебучие камни, чтоб не обосраться:

1. Кто что видит:

class Batya {
    private String secret;      // Это дети НЕ увидят, хоть тресни
    protected String family;    // А это можно, семейное же
    public String name;         // И это видно всем, как в окно голым стоять
    String packagePrivate;      // А это только если в одной квартире (пакете) живёте
}

2. Конструкторы и super(): Тут важно, блядь: если папаша без конструктора по умолчанию, то ты ОБЯЗАН его явно позвать в первой строчке своего конструктора. Иначе компилятор тебе ебальник набьёт.

class Synok extends Batya {
    public Synok(String param) {
        super(param); // Кричим папе, что мы тут, и параметр ему передаём
        // ... а потом уже своё дело делаем
    }
}

3. Переопределение (Override): Это когда ты берёшь папин метод и делаешь по-своему. Аннотацию @Override ставь всегда — она как предупредительный знак: «Чувак, я тут папино переписываю, не удивляйся».

class Synok extends Batya {
    @Override
    public void method() {
        // Своя дичь
        super.method(); // Если ещё и папин метод вызвать хочешь
    }
}

4. Одиночное наследование — пиздец какой важный момент: В Java ты можешь быть сыном только ОДНОГО класса. Как в жизни, блядь. Нельзя иметь двух пап.

class Papa1 {}
class Papa2 {}
// class Ya extends Papa1, Papa2 {} // Хуй тебе, а не два папы! Ошибка компиляции.

5. Final — это приговор: Если класс final — от него детей не будет, стерильный он. Если метод final — его переписать нельзя, хоть умри.

final class Besplodny {} // От этого наследника не сделаешь, хоть тресни
class Batya {
    public final void neTrogaй() {} // Этот метод дети трогать не смеют
}

6. Цепочка наследования: Можно строить династии, как Романовы: дед → папа → сын. Внук всё унаследует, и от папы, и от деда (кроме их приватных тараканов).

7. Object — главный предок всех: Все классы в Java, даже если ты не указал, — неявные дети класса Object. Это как все мы от Адама с Евой, блядь. От него все получают методы вроде toString() (чтобы строкой представиться) или equals() (чтобы сравнить, кто круче).

А теперь, блядь, альтернативы, потому что наследование — не панацея:

1. Композиция (предпочитай, если можно): Это когда ты не кричишь «я твой сын», а говоришь «у меня есть друг». Надёжнее, гибче, меньше головной боли.

class Dvigatel { /* ... */ }

class Mashina {
    private Dvigatel dvigatel; // Композиция: машина ИМЕЕТ двигатель

    public Mashina() {
        this.dvigatel = new Dvigatel(); // Создаём свой, не папин
    }
}

2. Интерфейсы (вот где можно от многих «наследоваться»): Java не даёт несколько пап, но даёт сколько угодно контрактов (интерфейсов), которые ты обязан выполнить. Это как навыки: можно уметь и водить, и летать.

interface Vozimoe {
    void poeхаli();
}

interface Letaemoe {
    void poleteli();
}

class LetayushayaMashina implements Vozimoe, Letaemoe {
    @Override
    public void poeхаli() { /* ... */ }

    @Override
    public void poleteli() { /* ... */ }
}

Итоговые советы, чтоб не вышло говно:

• Наследуйся только когда реально отношение «является» (Машина ЯВЛЯЕТСЯ Транспортом). Если «имеет» — делай композицию.
• Глубокие цепочки наследования (больше 3-4 колен) — это пиздец, потом сам не разберёшься, кто от кого.
• Поля в protected лепи только если дети реально должны в них лазить. Иначе — приватность, блядь, святое.
• @Override — не просто буквы, это страховка от тупых ошибок. Используй.
• И помни: наследование — это мощно, но как атомная бомба: если не уверен, лучше не трогай, а то наебнёшься.