Класс, охватывающий более одного класса Java?

Ответ 1

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

Сценарий1: Как вы узнали, в Java не возможно следующее:

public class Dog extends Animal, Canine{

}

Сценарий 2: Однако возможно следующее:

public class Canine extends Animal{

}

public class Dog extends Canine{

}

Разница в этих двух подходах заключается в том, что во втором подходе имеется четко определенный родительский или super класс, тогда как в первом подходе класс super неоднозначен.

Учтите, что у обоих Animal и Canine был метод drink(). В первом сценарии родительский метод вызывается, если мы вызываем Dog.drink()? По второму сценарию мы знаем, что вызов Dog.drink() будет вызывать метод Canine classes drink, если Dog не переопределил его.

Ответ 2

В java нет возможности (возможно, в java 8 будет avilable). За исключением случая, когда вы расширяетесь в дереве. Например:

class A
class B extends A
class C extends B

Ответ 3

В Java множественное наследование недопустимо для реализаций (классов) только для интерфейсов:

interface A extends B, C

например. MouseInputListener расширяет MouseListener и MouseMotionListener

И, конечно же, класс может реализовать несколько интерфейсов:

class X implements A, F

Ответ 4

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

Ответ 5

Множественное наследование невозможно с классом, вы можете достичь его с помощью интерфейса, но не с классом. Это дизайн java-языка. Посмотрите комментарий Джеймса Гослинга.

Джеймса Гослинга в феврале 1995 года дает представление о том, почему несколько Наследование не поддерживается в Java.

JAVA пропускает много редко используемых, плохо понятых, запутанных особенностей С++, которые в нашем опыте приносят больше горя, чем пользы. Эта прежде всего состоит из перегрузки оператора (хотя он имеет перегрузка метода), множественное наследование и расширенная автоматическая приведения типов.

Ответ 6

Предположим, что B и C переопределяют унаследованный метод и их собственную реализацию. Теперь D наследует оба B & С использованием множественного наследования. D должен наследовать переопределенный метод. Вопрос в том, какой переопределенный метод будет использоваться? Это будет от B или C? Здесь у нас есть двусмысленность. Чтобы исключить такую ситуацию, множественное наследование не использовалось в Java.

Ответ 7

Java не обеспечивала множественное наследование.
Когда вы говорите, что A расширяет B, это означает, что A расширяет B и B расширяет объект.
Это не означает, что A расширяет B, Object.

class A extends Object
class B extends A

Ответ 8

java не может поддерживать множественное наследование. Но вы можете сделать это таким образом.

class X
{
}
class Y extends X
{
}
class Z extends Y{
}

Ответ 9

Большинство приведенных ответов, похоже, предполагают, что все классы, которые мы наследуем, определяются нами.

Но что, если один из классов не определен нами, т.е. мы не можем изменить то, что наследует один из этих классов, и поэтому не может использовать принятый ответ, что происходит потом?

Ну, ответ зависит от того, есть ли у нас хотя бы один из классов, которые были нами определены. т.е. существует класс A среди списка классов, на которые мы хотели бы наследовать, где A создается нами.

В дополнение к уже принятому ответу я предлагаю еще 3 экземпляра этой проблемы множественного наследования и возможные решения для каждого из них.

Тип наследования 1

Хорошо сказать, что вы хотите, чтобы класс C расширял классы, A и B, где B - это класс, определенный где-то в другом месте, но A определяется нами. Мы можем сделать это с тем, чтобы превратить A в интерфейс, тогда класс C может реализовать A при расширении B.

class A {}
class B {} // Some external class
class C {}

Входит в

interface A {}
class AImpl implements A {}
class B {} // Some external class
class C extends B implements A

Тип наследования 2

Теперь скажите, что у вас есть более чем два класса, чтобы наследовать, но та же самая идея остается - все, кроме одного из классов, должны быть определены нами. Итак, скажем, мы хотим, чтобы класс A наследовал от следующих классов: B, C,... X, где X - это класс, который является внешним, то есть определенным в другом месте. Мы применяем ту же идею, что и все остальные классы, но последние в интерфейсе, мы можем:

interface B {}
class BImpl implements B {}
interface C {}
class CImpl implements C {}
...
class X {}
class A extends X implements B, C, ...

Тип наследования 3

Наконец, есть также случай, когда у вас есть только куча классов для наследования, но ни один из них не определяется вами. Это немного сложнее, но это можно сделать, используя delegation. Делегирование позволяет классу A претендовать на какой-то другой класс B, но любые вызовы на A для какого-либо общедоступного метода, определенного в B, на самом деле делегируют этот вызов объекту типа B, и результат вернулся. Это делает класс A тем, что я бы назвал Fat class

Как это помогает?

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

Изначально у нас есть следующие внешние классы B, C, D,..., X, и мы хотим, чтобы наш новый класс A наследовал от всех этих классов.

class B {
    public void foo() {}
}

class C {
    public void bar() {}
}

class D {
    public void fooFoo() {}
}

...

class X {
    public String fooBar() {}
}

Далее мы создаем интерфейс A, который предоставляет общедоступные методы, ранее существовавшие в классе A, а также общедоступные методы из вышеперечисленных классов

interface A {
    void doSomething(); // previously defined in A
    String fooBar(); // from class X
    void fooFoo(); // from class D
    void bar(); // from class C
    void foo(); // from class B
}

Наконец, мы создаем класс AImpl, который реализует интерфейс A.

class AImpl implements A {
    // It needs instances of the other classes, so those should be
    // part of the constructor
    public AImpl(B b, C c, D d, X x) {}
    ... // define the methods within the interface
}

И вот оно! Это своего рода псевдонаследование, потому что объект типа A не является строгим потомком любого из внешних классов, с которого мы начали, а скорее предоставляет интерфейс, который определяет те же методы, что и в этих классах.

Вы можете спросить, почему мы не просто создали класс, который определяет методы, которые мы хотели бы использовать, а не определяли интерфейс. то есть почему у нас просто нет класса A, который содержит общедоступные методы из классов, которые мы хотели бы наследовать? Это делается для того, чтобы уменьшить coupling. Мы не хотим, чтобы классы, которые используют A, слишком сильно зависят от класса A (потому что классы имеют тенденцию сильно меняться), а скорее полагаются на обещание, данное в интерфейсе A.

Ответ 10

Java не позволяет расширять несколько классов.

Предположим, что класс C расширяет классы A и B. Тогда, если предположить, что классы A и B имеют метод с тем же именем (Ex: method1()). Рассмотрим код:

C obj1 = new C(); obj1.method1(); - здесь JVM не поймет, к какому методу он должен получить доступ. Потому что оба класса A и B имеют этот метод. Таким образом, мы ставим JVM в дилемму, поэтому это причина, из-за которой множественное наследование удаляется с Java. И поскольку упомянутая реализация нескольких классов решит эту проблему.

Надеюсь, это помогло.

Ответ 11

Привет, пожалуйста, обратите внимание, как на настоящую работу.

Дети не могут иметь две матери

Итак, в java подкласс не может иметь двух родительских классов.