Короткий ответ

Можно сказать, что в основном существует два типа множественного наследования: множественное наследование реализации класса и множественное наследование реализации типа .

Создатели Java явно запретили первое. Таким образом, любая попытка расширить класс из более чем одного класса приведет к ошибке. Основными причинами для этого были:

• Избегайте двусмысленности кода
• Сделайте Java более простой по сравнению с C++ и другими языками.
• Они считали, что множественное наследование создает больше проблем, чем решает.

Все это будет объяснено более подробно в длинном ответе.

длинный ответ

Все мы знаем, что значит наследовать . Короче говоря, это получение чего-то от кого-то вроде нас и возможность наслаждаться этим.

В ООП наследование означает, что объект получает (наследует) что-то от другого объекта, чтобы использовать его.

Слово, чтобы выразить это в Java, extends. Когда класс расширяет более одного класса, это называется множественным наследованием.

Например, класс VehiculoMotorрасширяет классы VehiculoDieselи VehiculoGasolina.

Теперь мы можем говорить о двух типах множественного наследования, согласно документации Java : реализация множественного наследования (классов) и реализация множественного наследования типов (с интерфейсами).

1. Множественное наследование реализации (классов)

Реализация множественного наследования — это возможность наследовать определения методов от нескольких классов.

Этот тип наследования невозможен в Java .

Почему Java не поддерживает множественное наследование?

В той же документации (ссылка выше) объясняются некоторые причины:

• Конфликты имен и двусмысленность. Когда компиляторы языков программирования, поддерживающие этот тип суперкласса с множественной последовательностью, содержат методы с одинаковыми именами, они иногда не могут определить, к какому члену или методу обращаться или вызывать.

• Кроме того, программист может непреднамеренно вызвать конфликт имен, добавив новый метод в суперкласс.

Типичной проблемой, возникающей при реализации множественного наследования, является так называемая проблема алмаза .

Давайте посмотрим изображение:

Эта проблема возникла бы, если бы классы VehiculoDieselи VehiculoGasolinaимели методы с одинаковыми именами. Давайте представим, что у обоих есть метод llenar(). Пока все идеально. Но, поскольку класс VehiculoMotorрасширяется из этих двух классов. Если мы сделаем это:

VehiculoMotor camion = new VehiculoMotor();
camion.llenar();

Что будем заправлять camion, дизель или бензин? Сложный вопрос, не так ли? Мы могли бы разбить грузовик.

Это основная причина, по которой реализация множественного наследования невозможна в Java.

2. Реализация множественного наследования с типами

Начиная с Java 8, благодаря введению методов по умолчанию , можно использовать форму реализации множественного наследования с использованием интерфейсов. То есть класс может реализовать ( implements) более одного интерфейса, который может содержать методы по умолчанию с одинаковыми именами. Компилятор Java предоставляет некоторые правила для определения того, какой метод по умолчанию использует конкретный класс.

Язык программирования Java поддерживает множественное наследование типов, то есть способность класса реализовывать более одного интерфейса. Объект может иметь несколько типов: тип собственного класса и типы всех интерфейсов, реализуемых классом. Это означает, что если переменная объявлена ​​как тип интерфейса, то ее значение может ссылаться на любой объект, созданный из любого класса, реализующего интерфейс. Это обсуждается в разделе « Использование интерфейса как типа » документации Java.

Как и в случае множественного наследования реализации, класс может наследовать различные реализации метода, определенного (по умолчанию или статического) в расширяемых им интерфейсах. В этом случае компилятор или пользователь должны решить, какой из них использовать.

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

Взяв тот же пример с изображения, мы можем VehiculoMotor реализовать в классе два интерфейса LlenableGasolinaи LlenableDieselкаждый из них с методом по умолчанию llenar().

ИнтерфейсLlenableDiesel

interface LlenableDiesel {

    public default void llenar() {
        System.out.println("Llenar con Diesel");
    }
}

ИнтерфейсLlenableGasolina

interface LlenableGasolina {

    public default void llenar() {
        System.out.println("Llenar de Gasolina");
    }
}

Имея два таких интерфейса, мы можем создать класс, VehiculoMotorв котором программист может переопределить метод, llenar()указывающий внутри него, какой из двух методов будет вызываться, используя метод по умолчанию любого из интерфейсов, реализуемых классом. Таким образом, если необходимо вызвать метод, соответствующий дизельным автомобилям:

    @Override
    public void llenar() {
        LlenableDiesel.super.llenar();
    }   

Вместо этого, чтобы вызвать метод llenar()для автомобилей с бензиновым двигателем:

    @Override
    public void llenar() {
        LlenableGasolina.super.llenar();
    }   

Вывод этого кода:

Учебный классVehiculoMotor

public class VehiculoMotor implements LlenableDiesel, LlenableGasolina {

    public static void main(String args[]) {

        VehiculoMotor camion = new VehiculoMotor();
        camion.llenar();

    }

    @Override
    public void llenar() {
        LlenableDiesel.super.llenar();
    }   

}

Тогда было бы так:

Llenar con Diesel

• Источник: поддерживает ли Java множественное наследование?

Подробнее

Тема обсуждалась много лет назад (в 2002 году) в JavaWorld .

Среди причин, по которым Java не допускает множественного наследования, можно назвать:

Причины отказа от множественного наследования в языке Java связаны главным образом с «простой, объектно-ориентированной и привычной» мета . Как простой язык, создатели Java хотели, чтобы большинство разработчиков могли понять его без серьезной подготовки. Для этого они работали над тем, чтобы сделать язык как можно более похожим на C++ (привычным), не преодолевая ненужную сложность C++ (простой).

По мнению разработчиков, множественное наследование создает больше проблем и путаницы, чем решает... Большой опыт разработчиков в C++ научил их тому, что множественное наследование не стоит головной боли.

И говорят, что в качестве решения было выбрано использование нескольких интерфейсов:

Вместо этого разработчики Java решили разрешить наследование нескольких интерфейсов за счет использования интерфейсов, идея, заимствованная из протоколов Objective C. Множественное наследование интерфейсов позволяет объекту наследовать множество различных сигнатур методов с оговоркой, что наследующий объект должен реализовывать унаследованные методы.

Множественное наследование интерфейсов позволяет объекту наследовать методы и полиморфно вести себя в этих методах.

В этой статье есть ссылки на другие интересные статьи и обсуждения на эту тему, если вы хотите углубиться.

Чтобы добавить к ответу А. Чедано , есть два дополнительных соображения:

1. Java поддерживает множественное наследование на уровне интерфейса. Пример:

   public interface Calentable {
       void aumentarTemperatura(double incremento);
       void disminuirTemperatura(double decremento);
   }
   public interface Redimensionable {
       void crecer(Dimension incremento);
       void decrecer(Dimension decremento);
   }
   //al heredar de 2 o más interfaces
   //esta interfaz permite tener todos los métodos de
   //todas las interfaces que hereda
   public interface Termodinamico extends Calentable, Redimensionable {
   }
   
   //una clase puede implementar la interfaz Termodinamico
   //en consecuencia, está implementando las demás interfaces
   public class Metal implements Termodinamico {
       @Override
       public void aumentarTemperatura(double incremento) {
           /* implementación */
       }
       @Override
       public void crecer(Dimension incremento) {
           /* implementación */
       }
       //implementar los métodos restantes
   }
   
   //una clase puede ser diseñada para implementar solo una interfaz
   public class Agua implements Calentable {
       @Override
       public void aumentarTemperatura(double incremento) {
           /* implementación */
       }
   }
   

2. Начиная с Java 8 возможности интерфейсов были расширены за счет наличия методов по умолчанию, то есть интерфейс может обеспечивать реализацию своих методов. Это означает, что интерфейс/класс, расширяя/реализуя более одного интерфейса, теперь может попасть в проблему алмаза. Компилятор решает эти случаи, требуя от конкретного класса реализации конфликтующего метода. Пример:

   public interface Afectuoso {
       default String saludar(String nombre) {
           return "¡Saludos " + nombre + "! Venga ese abrazo";
       }
   }
   
   public interface Cordial {
       default String saludar(String nombre) {
           return "Buenas " + nombre;
       }
   }
   
   //ambas interfaces tienen un método String saludar(String nombre)
   //y ambas proveen una implementación por defecto
   //la clase se ve forzada a implementar dicho método
   public class Persona implements Afectuoso, Cordial {
       @Override
       public String saludar(String nombre) {
           //se puede elegir la implementación de una interfaz
           //por ejemplo, escogemos que sea Afectuoso
           return Afectuoso.super.saludar(nombre);
       }
   
       public static void main(String[] args) {
           Persona persona = new Persona();
           System.out.println(persona.saludar("Luiggi"));
       }
   }
   

Вылет из:

¡Saludos Luiggi! Venga ese abrazo

Джеймс Гослинг исключил это при создании java. Он отметил, что множественное наследование не дает больших преимуществ C++ и что его можно лучше реализовать при правильном использовании интерфейсов.

Я действительно не понимаю, в чем проблема? Мне кажется, что решение так же просто, как необходимость указать, из какого родительского класса исходит метод, который мы хотим вызвать, только если он повторяется в других родительских классах. среда разработки Java, .Net, ruby... и любого другого объектно-ориентированного языка должна предупреждать программиста каждый раз, когда этот "конфликт происходит" с прожектором, красным светом или чем угодно, и все! они десятилетиями тонули в чем-то таком глупом, и не похоже, что они захотят снова дышать. множественное наследование очень необходимо и полезно.