types inheritance java single vs multiple inheritance
Obteniu més informació sobre els diversos tipus d’herència a Java amb ajuda d’exemples senzills. Esbrineu si Java admet herències múltiples:
Al nostre últim tutorial, vam introduir Herència a Java juntament amb els diversos conceptes bàsics relacionats amb l’herència als lectors.
En aquest tutorial, explorarem més a fons el tema de l'herència i aprendrem més sobre els tipus d'herència.
=> Consulteu TOTS els tutorials de Java aquí.
millors programes d’espionatge per a mòbils
Què aprendreu:
Tipus d’herència a Java
Segons la forma en què s’hereten les classes i quantes classes s’hereten, tenim els següents tipus d’herència, tal com es mostra a la figura següent.
Com es mostra a la figura anterior, hi ha cinc tipus d’herències a la programació orientada a objectes, tal com es descriu a continuació:
# 1) Herència única: Quan una classe o subclasse derivada només hereta d'una base o superclasse, és una herència única.
# 2) Herència multinivell: A l’herència multinivell, tenim més d’un nivell en què una classe hereta d’una classe base i la classe derivada al seu torn l’hereta una altra classe.
# 3) Herència jeràrquica: En aquest tipus d’herència es forma una jerarquia d’herències quan més d’una classe hereta una superclasse.
# 4) Herència múltiple: L'herència múltiple és aquella en què una classe pot heretar propietats i comportament de més d'un pare.
# 5) Herència híbrida: Quan es combinen un o més tipus d’herència, es converteix en una herència híbrida.
Tingueu en compte que Java només admet tipus d'herència simple, multinivell i jeràrquic mitjançant classes. Java no admet herències múltiples i híbrides amb classes.
Ara parlarem detalladament de cada tipus d’herència amb exemples de programació.
Herència única a Java
Es mostra una única herència com es mostra a continuació:
Aquí una subclasse hereta d’una sola superclasse. Es tracta d’una herència única. Qualsevol animal com el gos hereta de l’espècie animal. Aquesta és la forma d’herència més senzilla.
A continuació es mostra un programa Java que explica l’herència única.
//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 } } Sortida:
Aquí tenim un mètode de menjar (Action_eat) a la classe base Animal que és comú a les espècies animals. Tenim un gos de classe derivada que deriva de la classe Animal. A la classe del gos, tenim un mètode específic per a les espècies de gossos, l’escorça (Action_bark).
A continuació, creem un objecte Dog al mètode principal i, com que la classe Dog ha heretat la classe Animal, aquest objecte pot anomenar-se com també mètode d’escorça.
Herència multinivell a Java
A l’herència multinivell, tenim una cadena d’herències. Això significa que tenim una classe pare heretada per una classe derivada. Al seu torn, la classe derivada actua com a pare d'una altra classe, etc.
L'herència multinivell es pot representar de la manera següent:
Com es veu a la figura anterior, hi ha una classe pare A. La classe B hereta de la classe A. Després hi ha una altra classe C que al seu torn hereta de la classe B. Així podem veure que forma una cadena d'herència. Aquí la classe B es converteix en una classe intermediària que connecta les classes A i C.
Seguint amb el nostre exemple de classe Animal a continuació, podem tenir una classe de gos derivada de la classe Animal. Després podem tenir una altra classe Puppy que és un gos nadó derivat de la classe Dog. D’aquesta manera, podem tenir l’herència multinivell.
A continuació es mostra un exemple de programa per a l’herència multinivell.
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 } }Sortida:
Hem programat la cadena exacta que es mostra més amunt. A continuació, al mètode principal, creem un objecte de classe C. L'objecte de classe C pot accedir als mètodes del seu pare B, així com de l'avi A.
Herència jeràrquica a Java
Una classe pot tenir més d'una classe derivada d'ella. Per tant, tenim una base o superclasse i més d’una subclasse. Aquest tipus d’herència s’anomena “herència jeràrquica”.
L'herència jeràrquica es representa esquemàticament a continuació:
Com a exemple d’herència jeràrquica, podem representar la classe Animal com una superclasse i, a continuació, tenir-ne més d’un animal com el gat, el gos, la vaca, etc.
El programa Java següent mostra l’herència jerarquitzada a 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 } } Sortida:
Com veiem al programa, tenim una classe principal i tres classes secundàries derivades d’aquest pare. En el mètode principal, creem un objecte de cadascuna de les classes infantils i cridem als seus mètodes membres respectius.
Per trucar als mètodes de la classe pare, tingueu en compte que podem utilitzar qualsevol dels objectes de la classe fill, ja que tots tenen accés a la classe pare.
Herència múltiple a Java
L'herència múltiple és una situació en què una classe pot heretar de més d'una classe, és a dir, una classe pot tenir més d'un pare. Fent això, la classe pot tenir més d’una superclasse i així adquirir les propietats i el comportament de totes les seves superclasses.
La representació esquemàtica de l’herència múltiple es mostra a continuació:
Com es mostra més amunt, podem derivar una classe de més d'una classe simultàniament. D'aquesta manera, la classe derivada adquirirà les característiques de totes les seves classes pares. Això pot donar lloc a ambigüitats greus, especialment quan les funcions heretades són les mateixes.
Nota:Java no admet herències múltiples mitjançant classes. Però admet herències múltiples mitjançant interfícies que parlarem al nostre proper tutorial sobre herència.
Com que Java no admet herències múltiples amb classes, no entrarem en els detalls. Tanmateix, més endavant en el tutorial, intentarem entendre les raons per les quals Java no admet l'herència múltiple.
Herència híbrida a Java
L’herència híbrida és una combinació d’un o més tipus d’herències que hem comentat anteriorment. Tanmateix, qualsevol combinació resulta en un tipus d'herència múltiple que Java no admet.
Una herència híbrida es pot representar esquemàticament de la manera següent.
Per tant, Java no admet l'herència híbrida també amb les classes. Però, com l’herència múltiple, podem implementar l’herència híbrida a Java mitjançant interfícies. En parlarem amb detall al nostre proper tutorial.
Per què Java no admet herències múltiples?
Java té com a objectiu la simplicitat dels programes. Això s'aplica fins i tot a les funcions OOP. Per tant, quan es tracta d’herències múltiples, poden sorgir situacions ambigües quan derivem una classe de més d’una classe.
Ara entenem els problemes que poden sorgir quan tenim diverses herències al nostre programa.
Penseu en els següents sistemes d’herència múltiple.
Si veiem el sistema anterior, s’explica per si mateix. Aquí la classe A i la classe B són classes biparentals heretades per la classe C. Ara hem demostrat que tant les classes A com la B tenen un mètode amb el mateix nom, és a dir, print (). Per tant, quan la classe C hereta A i B, obtindrà les dues versions del mètode print ().
En aquest cas, la classe C no sabrà quin mètode ha d’heretar. Aquesta és la situació ambigua que hem esmentat anteriorment que es presenta en el cas de l’herència múltiple.
Per tant, Java emet un error del compilador quan la classe hereta de més d'una classe.
El següent programa Java ho demostrarà.
auriculars vr per a xbox one s
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(); } } Sortida:
Com es veu a la sortida, el compilador Java emet un error quan troba que la classe amplia dues classes.
Tot i que Java no permet heretar simultàniament dues classes, sí que ens ofereix una manera d’eludir aquesta limitació. Podem simular diverses herències mitjançant interfícies en lloc de classes. En parlarem en els nostres tutorials posteriors.
Problema del diamant
L'herència múltiple dóna lloc a una situació anomenada 'problema del diamant'.
Penseu que tenim el sistema d’herència següent.
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 } Podem representar aquest sistema de forma esquemàtica com es mostra a continuació:
Com podem veure al diagrama anterior, tot el sistema d’herències apareix en forma de diamant. A causa d’aquesta estructura de diamants, l’ambigüitat s’anomena “problema del diamant”.
Com s'ha explicat anteriorment per a l'herència múltiple, l'ambigüitat aquí és el nombre múltiple de còpies del mètode show () que la classe Sample obté com a resultat de l'herència. Com que hi ha diversos camins, aconsegueix el mètode show () i hi ha una ambigüitat sobre quina còpia heretar.
Com passa amb l’herència múltiple, el problema del diamant també es pot resoldre mitjançant interfícies.
Regles d'herència a Java
Fins ara hem vist els conceptes bàsics de l’herència i els tipus d’herència a Java, enumerem algunes regles que hem de seguir mentre desenvolupem aplicacions amb herència.
Regla # 1: Java no admet l’herència múltiple
Com ja hem vist, Java no admet herències múltiples en cap forma. Quan s'intenta una herència múltiple en un programa, el compilador Java emet un error del compilador.
Regla # 2: Java no permet l'herència cíclica
Una classe que s’hereta per formar un cicle s’anomena Herència Cíclica.
Penseu en les següents classes, classe1 i classe2.
classe class1 amplia la classe 2 {}
classe class2 amplia la classe 1 {}
La situació anterior forma un bucle. Això no està permès a Java.
Regla núm. 3: no podem heretar membres de dades privades
Al tema 'Modificadors d'accés' ja hem après que els membres amb accés privat no es poden heretar.
Regla # 4: els constructors no s’hereten
Com que els constructors s’utilitzen per crear objectes de classe, no s’hereten d’una classe a una altra.
Regla núm. 5: podem utilitzar la referència principal per accedir a objectes secundaris
Ja hem vist diversos exemples d’herència. Podem crear una referència de tipus pare tipus i després assignar-li un objecte de classe derivat creat amb la nova paraula clau.
Si super és una superclasse i sub és una classe derivada de super com es mostra a continuació.
class super{} class sub extends super{ public static void main(String() args){ super s_obj = new sub(); } }Regla # 6: Els constructors pares s’executen a causa de super () en constructors derivats
Una de les regles estableix que no es poden heretar els constructors. Però el constructor de la superclasse es pot executar dins del constructor de la classe derivada mitjançant la trucada super ().
Preguntes freqüents
P # 1) Quin tipus d'herència no és compatible amb Java?
Resposta: Java no admet herències múltiples, ja que pot donar lloc a problemes en aplicacions com el problema del diamant. Java tampoc no admet l’herència híbrida, ja que és una combinació d’un o més tipus d’herència i, en última instància, es pot convertir en una herència múltiple.
P # 2) Quin dels membres de la classe es pot heretar?
Resposta: Una classe pot heretar membres públics i protegits de la seva classe base, però no pot accedir als membres privats de la classe base.
P # 3) Per què no es permet l'herència múltiple?
Resposta: L'herència múltiple resulta en ambigüitat quan les classes biparentals tenen mètodes amb el mateix prototip. En aquest cas, la classe derivada s'enfronta a una ambigüitat respecte a quina classe base hauria d'heretar el mètode.
L'herència múltiple també pot provocar un problema de diamants a Java. Per tant, Java no admet herències múltiples.
Q # 4) Per què necessiteu l'herència múltiple?
Resposta: Llenguatges com Java i C # apliquen l'herència múltiple mitjançant diverses interfícies. Per tant, quan hem d’heretar funcions de més d’una interfície, necessitem múltiples herències.
P # 5) Quin és l'ús principal de l'herència multinivell?
Resposta: Es diu que una classe derivada d'una altra classe que al seu torn deriva d'una tercera classe presenta una herència multinivell. Els nivells d’aquest tipus d’herència es poden ampliar a qualsevol nombre sempre que mantingui la claredat i la simplicitat.
Podem representar diferents nivells d’espècies mitjançant l’herència multinivell. Des del punt de vista de la programació, quan volem representar diversos nivells de classes d’aplicacions, apostem per l’herència multinivell.
Conclusió
En aquest tutorial, hem parlat dels tipus d'herència a Java. Java només admet tipus d'herència de tipus únic, multinivell i jerarquitzat. Java no admet herències múltiples i híbrides. Hem discutit l'ambigüitat de l'herència múltiple i el problema Diamond a Java.
Després vam discutir les diverses regles que hem de seguir mentre implementem l’herència a Java. Amb això, hem completat la nostra discussió sobre la relació IS-A a Java.
=> Vigileu aquí les sèries de formació Java senzilles.
Lectura recomanada
- Què és l'herència a Java: tutorial amb exemples
- Herència a C ++
- Tipus d’herència en C ++
- Conceptes bàsics de Java: sintaxi de Java, Java Class i conceptes bàsics de Java
- Java Integer i Java BigInteger Class amb exemples
- Tipus de classes en Java: resum, concret, final, estàtic
- Variables de Java i els seus tipus amb exemples
- Tutorial de classe de Java Scanner amb exemples