От скольки классов может быть наследован класс

Множественное наследование классов в Java

Вопрос о наследовании классов — один из фундаментальных в Java архитектуре. Ответ ясен: класс может наследоваться только от одного класса, но может реализовывать неограниченное количество интерфейсов.

Почему только одно наследование

Java сознательно отказалась от множественного наследования классов из-за проблемы Diamond Problem (проблема ромба):

Представьте себе такую иерархию:

       Animal
      /      \
    Dog    Cat
      \      /
      HybridPet

Если HybridPet наследуется от Dog и Cat, которые оба наследуются от Animal, то у HybridPet есть две копии методов из Animal. Какую использовать? Неоднозначность!

// ❌ КОМПИЛИРУЕТСЯ НЕ БУДЕТ
class Dog extends Animal {}
class Cat extends Animal {}
class HybridPet extends Dog, Cat {}  // Ошибка компиляции!

Единственное наследование класса

Синтаксис

public class Child extends Parent {
    // Child наследует все методы и поля из Parent
}

Практический пример

// Базовый класс
class Vehicle {
    protected String name;
    protected int speed;
    
    public void start() {
        System.out.println("Engine started");
    }
    
    public void stop() {
        System.out.println("Engine stopped");
    }
}

// Car наследуется ТОЛЬКО от Vehicle
public class Car extends Vehicle {
    private int numberOfDoors;
    
    @Override
    public void start() {
        System.out.println("Car engine started");
        // Вызов родительского метода
        super.start();
    }
    
    public void openTrunk() {
        System.out.println("Trunk is open");
    }
}

// Usage
Car car = new Car();
car.start();  // Вызывает переопределённый метод Car
car.stop();   // Наследованный метод из Vehicle
car.openTrunk();

Иерархия наследования

Хотя класс может наследоваться только от одного класса, можно создавать цепочки наследования:

// Иерархия
class Animal {}
class Mammal extends Animal {}
class Dog extends Mammal {}
class GoldenRetriever extends Dog {}

// GoldenRetriever наследует от Dog, Dog от Mammal, Mammal от Animal
GoldenRetriever dog = new GoldenRetriever();
// dog имеет все методы из Dog, Mammal, Animal

Интерфейсы — решение проблемы

Для достижения эффекта множественного наследования Java использует интерфейсы. Класс может реализовывать множество интерфейсов:

// Различные интерфейсы (контракты)
interface Swimmable {
    void swim();
}

interface Flyable {
    void fly();
}

interface Walkable {
    void walk();
}

// Duck реализует ВСЕ три интерфейса
public class Duck implements Swimmable, Flyable, Walkable {
    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }
    
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }
    
    @Override
    public void walk() {
        System.out.println("Duck is walking");
    }
}

// Комбинирование
public class Penguin implements Swimmable, Walkable {
    // Пингвин не может летать, поэтому не реализует Flyable
}

Наследование + Интерфейсы

Сочетание наследования класса и интерфейсов

// Базовый класс
class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// Dog наследует Animal и реализует интерфейсы
public class Dog extends Animal implements Swimmable, Walkable {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void swim() {
        System.out.println("Dog is swimming");
    }
    
    @Override
    public void walk() {
        System.out.println("Dog is walking");
    }
}

// Usage
Dog dog = new Dog("Buddy");
dog.eat();    // Из базового класса Animal
dog.swim();   // Из интерфейса Swimmable
dog.walk();   // Из интерфейса Walkable

Абстрактные классы vs Интерфейсы

Когда использовать абстрактный класс

// Когда нужна общая логика и состояние
abstract class DatabaseRepository<T> {
    protected DataSource dataSource;
    
    protected DatabaseRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    // Общая реализация
    public List<T> findAll() {
        // Логика получения из БД
    }
    
    // Абстрактный метод для переопределения
    abstract T mapResultSet(ResultSet rs);
}

class UserRepository extends DatabaseRepository<User> {
    @Override
    User mapResultSet(ResultSet rs) {
        // Специфическая логика для User
    }
}

Когда использовать интерфейс

// Когда определяю контракт поведения
interface Repository<T> {
    List<T> findAll();
    Optional<T> findById(Long id);
    void save(T entity);
}

// Разные реализации
class UserRepository implements Repository<User> {}
class RedisUserRepository implements Repository<User> {}
class GraphQLUserRepository implements Repository<User> {}

Полиморфизм и Liskov Substitution Principle

// Благодаря единственному наследованию避免了 complexity
class Manager {
    public void doWork(Employee emp) {
        emp.work();  // Polymorphism
    }
}

class Developer extends Employee {}
class Designer extends Employee {}
class Tester extends Employee {}

// Все подтипы Employee могут использоваться взаимозаменяемо
Manager mgr = new Manager();
mgr.doWork(new Developer());
mgr.doWork(new Designer());
mgr.doWork(new Tester());

Best Practices

1. Наследуйте для переиспользования кода (is-a отношение)
2. Реализовывайте интерфейсы для определения контрактов (can-do отношение)
3. Используйте composition вместо наследования когда это возможно
4. Следуйте Liskov Substitution Principle
5. Избегайте глубокой иерархии наследования (более 3-4 уровней)

// ✅ Composition (предпочтительнее часто)
public class Car {
    private Engine engine;  // Вместо extends
    private Transmission transmission;
    
    public void start() {
        engine.start();
    }
}

// ❌ Глубокое наследование (избегать)
class A {}
class B extends A {}
class C extends B {}
class D extends C {}
class E extends D {}  // Слишком глубоко!

Заключение

Java позволяет классу наследоваться только от одного класса, что избегает сложности множественного наследования. Вместо этого используются интерфейсы для достижения гибкости, абстрактные классы для общей логики, и композиция для переиспользования. Это дизайн-решение делает код более предсказуемым и maintainable.