types inheritance java single vs multiple inheritance
Scopri tutto sui vari tipi di ereditarietà in Java con l'aiuto di semplici esempi. Scopri se Java supporta l'ereditarietà multipla:
Abbiamo introdotto l'ereditarietà in Java insieme ai vari concetti di base relativi all'ereditarietà ai lettori nel nostro ultimo tutorial.
In questo tutorial, esploreremo ulteriormente l'argomento dell'ereditarietà e impareremo di più sui tipi di ereditarietà.
=> Controlla TUTTI i tutorial Java qui.
intervista php domande e risposte pdf
Cosa imparerai:
Tipi di ereditarietà in Java
A seconda del modo in cui le classi vengono ereditate e di quante classi vengono ereditate, abbiamo i seguenti tipi di ereditarietà, come mostrato nella figura seguente.
Come mostrato nella figura sopra, esistono cinque tipi di eredità nella programmazione orientata agli oggetti come descritto di seguito:
# 1) Ereditarietà singola: Quando una classe o una sottoclasse derivata eredita da una sola base o superclasse, si tratta di un'ereditarietà singola.
# 2) Ereditarietà multilivello: In Multilevel Inheritance, abbiamo più di un livello in cui una classe eredita da una classe base e la classe derivata a sua volta viene ereditata da un'altra classe.
# 3) Ereditarietà gerarchica: Una gerarchia di ereditarietà si forma in questo tipo di ereditarietà quando una superclasse viene ereditata da più di una classe.
# 4) Ereditarietà multipla: L'ereditarietà multipla è quella in cui una classe può ereditare proprietà e comportamento da più di un genitore.
# 5) Ereditarietà ibrida: Quando uno o più tipi di ereditarietà vengono combinati, diventa un'eredità ibrida.
Si noti che Java supporta solo il tipo di ereditarietà singolo, multilivello e gerarchico utilizzando le classi. Java non supporta l'ereditarietà multipla e ibrida con le classi.
Ora discuteremo ogni tipo di ereditarietà in dettaglio con esempi di programmazione.
Ereditarietà singola in Java
Una singola eredità è rappresentata come mostrato di seguito:
Qui una sottoclasse eredita da una singola superclasse. Questa è un'eredità singola. Qualsiasi animale come il cane eredita dalla specie animale. Questa è la forma più semplice di eredità.
Di seguito è riportato un programma Java che spiega Single Inheritance.
//base class:Animal class Animal { void Action_eat() { System.out.print('eating...'); } } //derived class:Dog class Dog extends Animal { void Action_bark() { System.out.print('barking...'); } } class Main{ public static void main(String args()){ Dog d=new Dog(); //create an object of derived class System.out.print('The dog is '); d.Action_bark(); //call derived class method System.out.print('
The dog is '); d.Action_eat(); //call base class method } } Produzione:
Qui, abbiamo un metodo mangiare (Action_eat) nella classe base Animal che è comune alle specie Animal. Abbiamo una classe derivata Dog che deriva dalla classe Animal. Nella classe Dog, abbiamo un metodo specifico per le specie di cani, bark (Action_bark).
Quindi creiamo un oggetto Dog nel metodo principale e poiché la classe Dog ha ereditato la classe Animal, questo oggetto può chiamare il metodo eat oltre che bark.
Ereditarietà multilivello in Java
Nell'ereditarietà multilivello, abbiamo una catena di eredità. Ciò significa che abbiamo una classe genitore ereditata da una classe derivata. La classe derivata a sua volta funge da genitore di un'altra classe e così via.
L'eredità multilivello può essere rappresentata come di seguito:
Come si vede nella figura sopra, c'è una classe genitore A. La classe B eredita dalla classe A. Poi c'è un'altra classe C che a sua volta eredita dalla classe B. Quindi possiamo vedere che forma una catena di ereditarietà. Qui la classe B diventa una classe intermedia che collega le classi A e C.
Continuando con il nostro esempio di classe Animal di seguito, possiamo avere una classe Dog derivata dalla classe Animal. Quindi possiamo avere un'altra classe Puppy che è un cucciolo di cane derivato dalla classe Dog. In questo modo, possiamo avere l'eredità multilivello.
Di seguito è mostrato un programma di esempio per l'ereditarietà multilivello.
import java.util.*; import java.lang.*; import java.io.*; //parent class A class A { public void print_A() { System.out.print('SoftwareTestingHelp '); } } //Derived class B - intermediary class B extends A { public void print_B() { System.out.print('Java Series '); } } //Derived Class C class C extends B { public void print_C() { System.out.print('Tutorials'); } } public class Main { public static void main(String() args) { C c_obj = new C(); //create Class C obj c_obj.print_A(); //call grandparent class method c_obj.print_B(); //call parent class method c_obj.print_C(); //call member method } }Produzione:
Abbiamo programmato la catena esatta mostrata sopra. Quindi nel metodo principale, creiamo un oggetto di classe C. L'oggetto di classe C può quindi accedere ai metodi del suo genitore B così come del nonno A.
Ereditarietà gerarchica in Java
Una classe può avere più di una classe derivata da essa. Quindi abbiamo una base o una superclasse e più di una sottoclasse. Questo tipo di eredità è chiamato 'eredità gerarchica'.
L'eredità gerarchica è rappresentata schematicamente di seguito:
Come esempio di eredità gerarchica, possiamo rappresentare la classe Animal come una superclasse e quindi derivarne più di un animale come Gatto, Cane, Mucca, ecc.
Il programma Java riportato di seguito mostra l'ereditarietà gerarchica in Java.
//class Parent class Parent { public void print_parent() { System.out.println('In ::Parent class'); } } //child1 class class Child1 extends Parent { public void print_child1() { System.out.println('In ::Child1 class'); } } //child2 class class Child2 extends Parent { public void print_child2() { System.out.println('In ::Child2 class'); } } //child3 class class Child3 extends Parent { public void print_child3() { System.out.println('In ::Child3 class'); } } public class Main { public static void main(String() args) { Child1 ch1 = new Child1(); //create a Child1 class object ch1.print_child1(); //call its member method Child2 ch2 = new Child2(); //create a Child2 class object ch2.print_child2(); //call its member method Child3 ch3 = new Child3(); //create a Child3 class object ch3.print_child3(); //call its member method ch3.print_parent(); //call parent class method with any object } } Produzione:
Come vediamo dal programma abbiamo una classe genitore e tre classi figlie derivate da questo genitore. Nel metodo principale, creiamo un oggetto di ciascuna delle classi figlie e chiamiamo i rispettivi metodi membri.
Per chiamare i metodi della classe genitore, si noti che possiamo usare qualsiasi oggetto della classe figlia poiché tutti hanno accesso alla classe genitore.
Ereditarietà multipla in Java
L'ereditarietà multipla è una situazione in cui una classe può ereditare da più di una classe, ovvero una classe può avere più di un genitore. In questo modo, la classe può avere più di una superclasse e quindi acquisire le proprietà e il comportamento di tutte le sue superclassi.
La rappresentazione schematica dell'ereditarietà multipla è mostrata di seguito:
Come mostrato sopra, possiamo derivare una classe da più di una classe contemporaneamente. In questo modo la classe derivata acquisirà le caratteristiche di tutte le sue classi padre. Ciò può dar luogo a serie ambiguità soprattutto quando le caratteristiche ereditate sono le stesse.
Nota:Java non supporta l'ereditarietà multipla utilizzando le classi. Ma supporta l'ereditarietà multipla usando le interfacce che discuteremo nel nostro prossimo tutorial sull'ereditarietà.
Poiché Java non supporta l'ereditarietà multipla con le classi, non entreremo nei dettagli. Tuttavia, più avanti nel tutorial, proveremo a capire i motivi alla base del fatto che Java non supporta l'ereditarietà multipla.
Ereditarietà ibrida in Java
L'ereditarietà ibrida è una combinazione di uno o più tipi di eredità di cui abbiamo discusso in precedenza. Qualsiasi combinazione tuttavia risulta in un tipo di ereditarietà multipla che non è supportata da Java.
Un'eredità ibrida può essere rappresentata schematicamente come di seguito.
Quindi Java non supporta anche l'ereditarietà ibrida con le classi. Ma come l'ereditarietà multipla, possiamo implementare l'ereditarietà ibrida in Java utilizzando le interfacce. Ne discuteremo in dettaglio nel nostro prossimo tutorial.
networking risoluzione dei problemi intervista domande e risposte pdf
Perché Java non supporta l'ereditarietà multipla?
Java mira alla semplicità nei programmi. Questo vale anche per le funzionalità OOP. Quindi, quando si tratta di ereditarietà multipla, possono sorgere alcune situazioni ambigue quando deriviamo una classe da più di una classe.
Ora capiamo i problemi che possono sorgere quando abbiamo ereditarietà multipla nel nostro programma.
Considera i seguenti sistemi di ereditarietà multipla.
Se vediamo il sistema sopra, è autoesplicativo. Qui la classe A e la classe B sono classi a due genitori ereditate dalla classe C.Ora abbiamo mostrato che entrambe le classi A e B hanno un metodo con lo stesso nome, cioè print (). Quindi, quando la classe C eredita A e B, otterrà entrambe le versioni del metodo print ().
In questo caso, la classe C non saprà quale metodo dovrebbe ereditare. Questa è la situazione ambigua che abbiamo menzionato sopra che si presenta nel caso di eredità multipla.
Quindi, Java emette un errore del compilatore quando la classe eredita da più di una classe.
Il seguente programma Java lo dimostrerà.
class A{ void print(){ System.out.println('Class A :: print()'); } } class B{ void print(){ System.out.println('Class B :: print()'); } } class C extends A , B{ //let C inherit from A and B } public class Main { public static void main(String() args) { C cObj = new C(); c.print(); } } Produzione:
Come visto dall'output, il compilatore Java emette un errore quando rileva che la classe estende due classi.
Sebbene Java non consenta di ereditare due classi contemporaneamente, ci offre un modo per aggirare questa limitazione. Possiamo simulare ereditarietà multipla usando interfacce invece di classi. Ne discuteremo nei nostri successivi tutorial.
Problema del diamante
L'ereditarietà multipla si traduce in una situazione chiamata 'problema del diamante'.
Considera che abbiamo il seguente sistema di ereditarietà.
class Super{ void show(){} } class Sub1 extends super{ void show1(){} } class Sub2 extends super{ void show2(){} } class sample extends Sub1,Sub2{ //Sample class code here } Possiamo rappresentare questo sistema schematicamente come mostrato di seguito:
Come possiamo vedere dal diagramma sopra, l'intero sistema ereditario appare a forma di diamante. A causa di questa struttura del diamante, l'ambiguità è chiamata 'Diamond Problem'.
Come spiegato in precedenza per l'ereditarietà multipla, l'ambiguità qui è il numero multiplo di copie del metodo show () che la classe Sample ottiene come risultato dell'ereditarietà. Poiché ci sono più percorsi, raggiunge il metodo show () e c'è un'ambiguità riguardo a quale copia ereditare.
Come con l'ereditarietà multipla, il problema del diamante può anche essere risolto utilizzando le interfacce.
Regole di ereditarietà in Java
Finora abbiamo visto le basi dell'ereditarietà così come i tipi di ereditarietà in Java, elenchiamo alcune regole che dobbiamo seguire durante lo sviluppo di applicazioni con ereditarietà.
Regola n. 1: Java non supporta l'ereditarietà multipla
Come abbiamo già visto, Java non supporta l'ereditarietà multipla in nessuna forma. Quando si tenta l'ereditarietà multipla in un programma, il compilatore Java genera un errore del compilatore.
Regola n. 2: Java non consente l'ereditarietà ciclica
Una classe che eredita se stessa per formare un ciclo è chiamata ereditarietà ciclica.
Considera le seguenti classi, class1 e class2.
class class1 estende la classe 2 {}
class class2 estende la classe 1 {}
La situazione di cui sopra forma un loop. Ciò non è consentito in Java.
Regola n. 3: non possiamo ereditare membri di dati privati
Abbiamo già appreso nell'argomento 'Modificatori di accesso' che i membri con accesso privato non possono essere ereditati.
Regola n. 4: i costruttori non vengono ereditati
Poiché i costruttori vengono utilizzati per creare oggetti di classe, non vengono ereditati da una classe all'altra.
Regola # 5: possiamo usare il riferimento genitore per accedere agli oggetti figli
Abbiamo già visto vari esempi di eredità. Possiamo creare un riferimento di tipo parent class e quindi assegnargli un oggetto di classe derivata creato utilizzando la nuova parola chiave.
Se super è una superclasse e sub è una classe derivata da super come mostrato di seguito.
class super{} class sub extends super{ public static void main(String() args){ super s_obj = new sub(); } }Regola # 6: i costruttori principali vengono eseguiti a causa di super () nei costruttori derivati
Una delle regole afferma che i costruttori non possono essere ereditati. Ma il costruttore della superclasse può essere eseguito all'interno del costruttore della classe derivata usando la chiamata super ().
Domande frequenti
D # 1) Quale tipo di ereditarietà non è supportato da Java?
Risposta: Java non supporta l'ereditarietà multipla in quanto può dare origine a problemi in applicazioni come il problema del diamante. Java inoltre non supporta l'ereditarietà ibrida poiché è una combinazione di uno o più tipi di ereditarietà e può infine trasformarsi in eredità multipla.
D # 2) Quale dei membri della classe può essere ereditato?
Risposta: Una classe può ereditare membri pubblici e protetti della sua classe base ma non può accedere ai membri privati della classe base.
D # 3) Perché l'ereditarietà multipla non è consentita?
Risposta: L'ereditarietà multipla crea ambiguità quando le classi a due genitori hanno metodi con lo stesso prototipo. In questo caso, la classe derivata deve affrontare un'ambiguità riguardo a quale classe base dovrebbe ereditare il metodo.
L'ereditarietà multipla può anche causare un problema di diamante in Java. Quindi Java non supporta l'ereditarietà multipla.
D # 4) Perché è necessaria l'ereditarietà multipla?
Risposta: Linguaggi come Java e C # impongono l'ereditarietà multipla utilizzando più interfacce. Quindi, quando abbiamo bisogno di ereditare funzionalità da più di un'interfaccia, allora abbiamo bisogno di ereditarietà multipla.
D # 5) Qual è l'uso principale di Multilevel Inheritance?
Risposta: Si dice che una classe derivata da un'altra classe che a sua volta è derivata da una terza classe mostri un'eredità multilivello. I livelli in questo tipo di eredità possono essere estesi a qualsiasi numero purché mantenga chiarezza e semplicità.
Possiamo rappresentare diversi livelli di specie utilizzando l'eredità multilivello. Dal punto di vista della programmazione, quando vogliamo rappresentare vari livelli di classi applicative, allora andiamo per l'ereditarietà multilivello.
Conclusione
In questo tutorial, abbiamo discusso i tipi di ereditarietà in Java. Java supporta solo tipi di ereditarietà singola, multilivello e gerarchica. Java non supporta l'ereditarietà multipla e ibrida. Abbiamo discusso l'ambiguità dell'ereditarietà multipla e il problema del diamante in Java.
Quindi abbiamo discusso le varie regole che dovremmo seguire durante l'implementazione dell'ereditarietà in Java. Con questo, abbiamo completato la nostra discussione sulla relazione IS-A in Java.
=> Guarda qui la serie di formazione su Java semplice.
Lettura consigliata
- Cos'è l'ereditarietà in Java - Tutorial con esempi
- Ereditarietà in C ++
- Tipi di ereditarietà in C ++
- Nozioni di base su Java: sintassi Java, classe Java e concetti principali di Java
- Java Integer e Java BigInteger Class con esempi
- Tipi di classi in Java: astratta, concreta, finale, statica
- Variabili Java e loro tipi con esempi
- Tutorial di classe per scanner Java con esempi