Dlaczego wielokrotne dziedziczenie nie jest dozwolone w Javie lub C#?

Wielokrotne dziedziczenie implementacji jest tym, co nie jest dozwolone.

Problem polega na tym, że kompilator / runtime nie może dowiedzieć się, co zrobić, jeśli masz klasę Cowboy i Artist, zarówno z implementacjami metody draw (), a następnie próbujesz utworzyć nowy typ CowboyArtist. Co się dzieje po wywołaniu metody draw ()? Ktoś leży martwy na ulicy, czy masz piękną akwarelę?

Myślę, że to się nazywa podwójne dziedzictwo diamentów problem.

Powód: Java jest bardzo popularna i łatwa w kodowaniu, ze względu na swoją prostotę.

Więc co kiedykolwiek Programiści Javy czują się trudni i skomplikowani do zrozumienia dla programistów, starali się tego uniknąć. Jednym z takich rodzajów własności jest wielokrotne dziedziczenie.

1. unikali wskazówek
Uniknęli wielokrotnego dziedziczenia.

Problem z dziedziczeniem wielokrotnym: Problem Diamentowy.

Przykład :

1. Załóżmy, że Klasa A jest zabawą metodą (). Klasa B I Klasa C wywodzi się z klasy A.
2. i obie klasy B I C nadpisują metodę fun().
3. teraz Załóżmy, że klasa D dziedziczy zarówno klasę B, jak i C. (tylko założenie)
4. Utwórz obiekt dla klasy D.
5. D D = new d ();
6. i spróbuj uzyskać dostęp do d.fun(); => czy nazywa się fun klasy B() czy fun klasy C()?

Jest to niejednoznaczność istniejąca w problemie diamentowym.

Nie jest niemożliwe, aby rozwiązać ten problem, ale to tworzy więcej zamieszania i złożoności dla programisty podczas jego czytania. Powoduje więcej problemów niż próbuje rozwiązać.

Notatka: ale w dowolny sposób zawsze możesz zaimplementować wiele dziedziczeń pośrednio za pomocą interfejsów.

Ponieważ Java ma znacznie inną filozofię projektowania niż C++. (Nie będę tu dyskutował o C#.)

W projektowaniu C++, Stroustrup chciał włączyć przydatne funkcje, niezależnie od tego, w jaki sposób można je niewłaściwie wykorzystać. Możliwe jest spieprzenie wielu dziedziczeń, przeciążenia operatorów, szablonów i różnych innych funkcji, ale można również zrobić z nimi bardzo dobre rzeczy.

Filozofia projektowania Javy ma na celu podkreślenie bezpieczeństwa w konstrukcjach językowych. W rezultacie są rzeczy, które są o wiele bardziej niezręczne, ale możesz być o wiele bardziej pewny, że kod, na który patrzysz, oznacza to, co myślisz, że robi.

Ponadto Java była w dużej mierze reakcją C++ i Smalltalk, najbardziej znanych języków OO. Istnieje wiele innych języków oo (Common Lisp był właściwie pierwszym, który został ustandaryzowany), z różnymi systemami oo, które lepiej obsługują MI.

Nie wspominając o tym, że jest to całkowicie możliwe, aby zrobić MI w Java, za pomocą interfejsów, kompozycji i delegacji. Jest bardziej wyrazisty niż w C++ i dlatego jest niezgrabniejszy w użyciu, ale da ci coś, co łatwiej zrozumiesz na pierwszy rzut oka.

Tu nie ma prawidłowej odpowiedzi. Odpowiedzi są różne, a to, które z nich jest lepsze dla danej sytuacji, zależy od aplikacji i indywidualnych preferencji.

Głównym (choć bynajmniej nie jedynym) powodem, dla którego ludzie odchodzą od MI, jest tak zwany "problem diamentów" prowadzący do dwuznaczności w Twojej implementacji. Ten artykuł Wikipedii omawia go i wyjaśnia lepiej niż mogłem. MI może również prowadzić do bardziej skomplikowanego kodu, a wielu projektantów OO twierdzi, że nie potrzebujesz MI, a jeśli go używasz, twój model prawdopodobnie się myli. Nie jestem pewien, czy Zgadzam się z tym ostatnim punktem, ale utrzymanie rzeczy prostych jest zawsze dobrym planem.

W C++ dziedziczenie wielokrotne było głównym bólem głowy, gdy było używane nieprawidłowo. Aby uniknąć tych popularnych problemów projektowych, w nowoczesnych językach (java, C#) wymuszono dziedziczenie wielu interfejsów.

Dziedziczenie wielokrotne jest

• trudno zrozumieć
• trudne do debugowania (na przykład, jeśli mieszasz klasy z wielu frameworków, które mają identyczne metody w głębi duszy, mogą wystąpić nieoczekiwane synergie)
• łatwy w użyciu
• nie do końca to przydatne
• trudne do zaimplementowania, zwłaszcza jeśli chcesz to zrobić poprawnie i efektywnie

Dlatego można uznać za mądry wybór Nie zawierać Wielokrotne dziedziczenie w języku Java.

Innym powodem jest to, że dziedziczenie jednostkowe sprawia, że rzucanie jest trywialne, nie emitując żadnych instrukcji asemblera (poza sprawdzaniem zgodności typów tam, gdzie jest to wymagane). Jeśli masz dziedziczenie wielokrotne, musisz dowiedzieć się, gdzie w klasie dzieci zaczyna dany rodzic. Tak więc wydajność jest z pewnością atutem(choć nie jedynym).

Przyjmuję stwierdzenie, że "wielokrotne dziedziczenie nie jest dozwolone w Javie" z przymrużeniem oka.

Dziedziczenie wielokrotne jest definiowane, gdy " Typ "dziedziczy z więcej niż jednego "typu". Interfejsy są również klasyfikowane jako typy, ponieważ mają zachowanie. Więc Java ma wiele dziedziczeń. Tylko, że jest bezpieczniej.

Dynamiczne ładowanie klas utrudnia implementację dziedziczenia wielokrotnego.

W Javie unikali złożoności dziedziczenia wielokrotnego, zamiast tego używali pojedynczego dziedziczenia i interfejsu. Złożoność dziedziczenia wielokrotnego jest bardzo wysoka w sytuacji opisanej poniżej

diamentowy problem dziedziczenia wielokrotnego. Mamy dwie klasy B I C dziedziczące z A. Załóżmy, że B I C są nadrzędne wobec metody dziedziczonej i zapewnij własną realizację. Teraz d dziedziczy zarówno z B jak i C wykonując wiele dziedziczeń. D powinien dziedziczyć tę nadpisaną metodę, jvm nie może zdecydować, która nadpisana metoda zostanie użyta?

W c++ do obsługi służą funkcje wirtualne i musimy to zrobić jawnie.

Można tego uniknąć za pomocą interfejsów, nie ma ciał metod. Interfejsy nie mogą być tworzone instancyjnie-mogą być implementowane tylko przez klasy lub rozszerzane przez inne Interfejsy.

W dawnych czasach (lata 70.), kiedy Informatyka była bardziej nauką i mniej masową produkcją, programiści mieli czas, aby pomyśleć o dobrym projekcie i dobrej implementacji, a w rezultacie produkty ( programy) charakteryzowały się wysoką jakością (np. Projektowanie i implementacja TCP/IP). W dzisiejszych czasach, gdy wszyscy programują, a menedżerowie zmieniają specyfikacje przed terminami, subtelne problemy, takie jak te opisane w linku do wikipedii z postu Steve 'a Haigh' a, są trudne do wyśledzenia; dlatego "dziedziczenie wielokrotne" jest ograniczone przez konstrukcję kompilatora. Jeśli ci się spodoba, nadal możesz używać C++ .... i miej tyle wolności, ile chcesz:)

W rzeczywistości dziedziczenie wielokrotne powstanie złożoności, jeśli odziedziczone klasy mają tę samą funkcję. ie kompilator będzie miał zamieszanie, które trzeba wybrać(problem diamond). Więc w Javie, że złożoność usunięte i dał interfejs, aby uzyskać funkcjonalność jak wiele dziedziczenia dał. Możemy użyć interfejsu

Java ma pojęcie, czyli polimorfizm. Istnieją 2 rodzaje polimorfizmu w Javie. Istnieją metody przeciążające i nadpisujące metody. Wśród nich nadpisywanie metod odbywa się z relacją super - i podklasową. Jeśli tworzymy obiekt podklasy i wywołujemy metodę superclass, a jeśli podklasa rozszerza więcej niż jedną klasę, którą metodę super klasy należy wywołać?

Lub, wywołując konstruktor superclass przez super(), który konstruktor super klasy otrzyma dzwonił?

Ta decyzja jest niemożliwa dzięki obecnym funkcjom java API. więc wielokrotne dziedziczenie nie jest dozwolone w Javie.

Dziedziczenie wielokrotne nie jest dozwolone bezpośrednio w Javie, ale poprzez interfejsy jest dozwolone.

Powód:

Dziedziczenie wielokrotne: wprowadza większą złożoność i wieloznaczność.

Interfejsy: interfejsy są całkowicie abstrakcyjnymi klasami w Javie, które zapewniają jednolity sposób na właściwe określenie struktury lub wewnętrznego działania programu z jego publicznie dostępnego interfejsu, a konsekwencją jest większa elastyczność i Kod wielokrotnego użytku, a także większą kontrolę nad tym, jak tworzysz i współdziałasz z innymi klasami.

Dokładniej, są to specjalne konstrukcje w Javie z dodatkowymi cechami, które pozwalają na wykonywanie pewnego rodzaju dziedziczenia wielokrotnego, tzn. klas, które mogą być przypisane do więcej niż jednej klasy.

Weźmy prosty przykład.

1. Załóżmy, że istnieją 2 klasy klasy A i B o tych samych nazwach metod, ale różnych funkcjach. Poprzez następujący kod ze słowem kluczowym (extends) dziedziczenie wielokrotne nie jest możliwe.

      public class A                               
        {
          void display()
            {
              System.out.println("Hello 'A' ");
            }
        }
   
      public class B                               
         {
           void display()
             {
               System.out.println("Hello 'B' ");
             }
         }
   
     public class C extends A, B    // which is not possible in java
       {
         public static void main(String args[])
           {
             C object = new C();
             object.display();  // Here there is confusion,which display() to call, method from A class or B class
           }
       }
   

2. Ale poprzez interfejsy, ze słowem kluczowym (implementuje) możliwe jest wielokrotne dziedziczenie.

   interface A
       {
          // display()
       }
   
   
    interface B
       {
         //display()
       }
   
    class C implements A,B
       {
          //main()
          C object = new C();
          (A)object.display();     // call A's display
   
          (B)object.display(); //call B's display
       }
   }
   

W C++ Klasa może dziedziczyć (bezpośrednio lub pośrednio) z więcej niż jednej klasy, która jest określana jako dziedziczenie wielokrotne .

C# i Java, jednak ograniczają klasy do pojedynczego dziedziczenia każda klasa dziedziczy z klasy samotnego rodzica.

Dziedziczenie wielokrotne jest użytecznym sposobem tworzenia klas, które łączą aspekty dwóch różnych klas hierarchii, co często zdarza się podczas używania różnych frameworków klas w ramach jednego podanie.

Jeśli dwie frameworki definiują własne klasy bazowe dla WYJĄTKÓW, na przykład, możesz użyj dziedziczenia wielokrotnego, aby utworzyć klasy wyjątków, które mogą być używane w obu frameworkach.

Problem z dziedziczeniem wielokrotnym polega na tym, że może to prowadzić do niejednoznaczności. Klasycznym przykładem jest, gdy klasa dziedziczy z dwóch innych klas, z których każda dziedziczy z tej samej klasy:

class A {
    protected:
    bool flag;
};
class B : public A {};
class C : public A {};
class D : public B, public C {
    public:
    void setFlag( bool nflag ){
        flag = nflag; // ambiguous
    }
};

W tym przykładzie element danych flag jest zdefiniowany przez class A. Ale class D zstępuje od class B i class C, które oba wywodzą się z A, więc w istocie dostępne są dwie kopie z flag, ponieważ dwa instancje {[7] } znajdują się w hierarchii klas D. Który chcesz ustawić? Kompilator będzie narzekał że odniesienie do flag w D jest niejednoznaczne . Jedną z poprawek jest jawne disambiguate reference:

B::flag = nflag;

Kolejną poprawką jest zadeklarowanie B I C jako virtual base classes, co oznacza, że tylko jedna kopia a może istnieć w hierarchii, eliminując wszelkie dwuznaczność.

Istnieją inne złożoności z dziedziczeniem wielokrotnym, takie jak kolejność, w jakiej klasy bazowe są inicjowane, gdy obiekt Pochodny jest konstruowany, lub sposób, w jaki członkowie mogą być przypadkowo Ukryte z klas pochodnych. Aby uniknąć tych zawiłości, niektóre języki ograniczają się do prostszego modelu pojedynczego dziedziczenia.

Chociaż znacznie upraszcza to dziedziczenie, ogranicza również jego przydatność ponieważ tylko klasy ze wspólnym przodkiem mogą współdzielić zachowania. Interfejsy ograniczenie nieco poprzez umożliwienie klasom w różnych hierarchiach ujawniania wspólnych interfejsów nawet jeśli nie są zaimplementowane przez współdzielenie kodu.

Czy ktoś może mi dokładnie powiedzieć, dlaczego nie jest to dozwolone?

Możesz znaleźć odpowiedź z tej dokumentacji link

Jednym z powodów, dla których język programowania Java nie pozwala na rozszerzenie więcej niż jednej klasy, jest unikanie problemów z wielokrotnym dziedziczeniem stanu, czyli możliwością dziedziczenia pól z wielu klas

Jeśli dozwolone jest dziedziczenie wielokrotne i kiedy tworzysz obiekt przez utworzenie instancji tej klasy, to obiekt dziedziczy pola ze wszystkich superklas klasy. Spowoduje to dwa problemy.

1. Co jeśli metody lub konstruktory z różnych super klas tworzą instancję tego samego pola?

2. Która metoda lub konstruktor będzie miała pierwszeństwo?

Nawet jeśli wielokrotne dziedziczenie stanu jest teraz dozwolone, nadal możesz zaimplementować

Dziedziczenie wielokrotne typu: zdolność klasy do implementacji więcej niż jednego interfejs.

Dziedziczenie wielu implementacji (poprzez domyślne metody w interfejsach): możliwość dziedziczenia definicji metod z wielu klas

Zobacz to powiązane pytanie SE, aby uzyskać dodatkowe informacje:

Wieloznaczność dziedziczenia z interfejsem

Wyobraź sobie ten przykład: Mam klasę Shape1

Ma CalcualteArea metodę:

Class Shape1
{

 public void CalculateArea()

     {
       //
     }
}

Istnieje inna klasa Shape2, która również ma tę samą metodę

Class Shape2
{

 public void CalculateArea()

     {

     }
}

Teraz mam dziecięcy krąg klasowy, wywodzi się zarówno z Shape1, jak i Shape2;

public class Circle: Shape1, Shape2
{
}

Teraz, kiedy tworzę obiekt dla Circle i wywołuję metodę, system nie wie, którą metodę Oblicz obszar należy wywołać. Oba mają te same podpisy. Więc kompilator się pomyli. Dlatego wiele spadków nie jest dozwolone.

Ale może być wiele interfejsów, ponieważ interfejsy nie mają definicji metody. Nawet oba interfejsy mają tę samą metodę, oba nie mają żadnej implementacji i zawsze zostanie wykonana metoda w klasie potomnej.