types inheritance java single vs multiple inheritance
Aflați totul despre diferitele tipuri de moștenire în Java cu ajutorul unor exemple simple. Aflați dacă Java acceptă moștenirea multiplă:
Am introdus moștenirea în Java împreună cu diferitele concepte de bază legate de moștenire pentru cititori în ultimul nostru tutorial.
În acest tutorial, vom explora mai departe subiectul moștenirii și vom afla mai multe despre tipurile de moștenire.
=> Verificați TOATE Tutorialele Java aici.
site-uri web pentru a viziona anime englezești dublate
Ce veți învăța:
Tipuri de moștenire în Java
În funcție de modul în care sunt moștenite clasele și de câte clase sunt moștenite, avem următoarele tipuri de moștenire așa cum se arată în figura de mai jos.
Așa cum se arată în figura de mai sus, există cinci tipuri de moșteniri în programarea orientată pe obiecte, așa cum este descris mai jos:
# 1) Moștenire unică: Când o clasă sau subclasă derivată moștenește dintr-o singură bază sau superclasă, atunci este o moștenire unică.
# 2) Moștenirea pe mai multe niveluri: În Moștenirea pe mai multe niveluri, avem mai mult de un nivel în care o clasă moștenește dintr-o clasă de bază, iar clasa derivată la rândul său este moștenită de o altă clasă.
# 3) Moștenirea ierarhică: O ierarhie a moștenirii se formează în acest tip de moștenire atunci când o superclasă este moștenită de mai multe clase.
# 4) Moștenirea multiplă: Moștenirea multiplă este cea în care o clasă poate moșteni proprietăți și comportament de la mai mulți părinți.
# 5) Moștenirea hibridă: Când unul sau mai multe tipuri de moștenire sunt combinate, atunci devine o moștenire hibridă.
Rețineți că Java acceptă numai tipuri de moștenire unice, multi-nivel și ierarhizate folosind clase. Java nu acceptă moștenirea multiplă și hibridă cu clase.
Acum vom discuta în detaliu fiecare tip de moștenire cu exemple de programare.
Moștenirea unică în Java
O singură moștenire este descrisă după cum se arată mai jos:
Aici o subclasă moștenește dintr-o singură superclasă. Aceasta este o moștenire unică. Orice animal ca câinele moștenește din specia animală. Aceasta este cea mai simplă formă de moștenire.
Mai jos este prezentat un program Java care explică moștenirea unică.
//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 } } Ieșire:
Aici, avem o metodă de mâncare (Action_eat) în clasa de bază Animal, care este comună speciilor de animale. Avem o clasă derivată Câine care derivă din clasa Animal. În clasa Câini, avem o metodă specifică speciilor de câini, scoarță (Action_bark).
Apoi creăm un obiect Dog în metoda principală și, deoarece clasa Dog a moștenit clasa Animal, acest obiect poate numi metoda eat, precum și metoda scoarței.
Moștenirea pe mai multe niveluri în Java
În moștenirea pe mai multe niveluri, avem un lanț de moștenire. Aceasta înseamnă că avem o clasă părinte care este moștenită de o clasă derivată. Clasa derivată acționează la rândul ei ca părinte pentru o altă clasă și așa mai departe.
Moștenirea pe mai multe niveluri poate fi reprezentată după cum urmează:
După cum se vede în figura de mai sus, există o clasă părinte A. Clasa B moștenește din clasa A. Apoi, există o altă clasă C care la rândul său moștenește din clasa B. Astfel putem vedea că formează un lanț de moștenire. Aici clasa B devine o clasă intermediară care conectează clasele A și C.
Continuând cu exemplul nostru de clasă Animal de mai jos, putem avea o clasă de câine derivată din clasa Animal. Apoi, putem avea o altă clasă Puppy, care este un câine care provine din clasa Dog. În acest fel, putem avea moștenirea pe mai multe niveluri.
Un exemplu de program pentru Moștenirea pe mai multe niveluri este prezentat mai jos.
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 } }Ieșire:
Am programat lanțul exact prezentat mai sus. Apoi, în metoda principală, creăm un obiect din clasa C. Obiectul din clasa C poate accesa metodele părintelui său B, precum și ale bunicului A.
Moștenirea ierarhică în Java
O clasă poate avea mai multe clase derivate din aceasta. Deci, avem o bază sau superclasă și mai multe subclase. Acest tip de moștenire se numește „Moștenire ierarhică”.
Moștenirea ierarhică este reprezentată schematic mai jos:
Ca exemplu de moștenire ierarhică, putem reprezenta clasa Animal ca o superclasă și apoi avem mai mult de un animal ca pisica, câinele, vaca etc.
Programul Java de mai jos demonstrează moștenirea ierarhică în 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 } } Ieșire:
După cum vedem din program, avem o clasă de părinte și trei clase de copii derivate din acest părinte. În metoda principală, creăm un obiect al fiecărei clase de copii și apelăm metodele lor membre respective.
Pentru apelarea metodelor clasei părinte, rețineți că putem folosi oricare dintre obiectele clasei copil deoarece toți au acces la clasa părinte.
Moștenirea multiplă în Java
Moștenirea multiplă este o situație în care o clasă poate moșteni din mai multe clase, adică o clasă poate avea mai mulți părinți. Făcând acest lucru, clasa poate avea mai multe superclase și astfel poate dobândi proprietățile și comportamentul tuturor superclasei sale.
Reprezentarea schematică a moștenirii multiple este prezentată mai jos:
După cum se arată mai sus, putem obține o clasă din mai multe clase simultan. În acest fel, clasa derivată va dobândi caracteristicile tuturor claselor sale părinte. Acest lucru poate da naștere la ambiguități serioase, mai ales atunci când caracteristicile moștenite sunt aceleași.
Notă:Java nu acceptă moștenirea multiplă folosind clase. Dar acceptă moștenirea multiplă folosind interfețe pe care le vom discuta în următorul nostru tutorial despre moștenire.
Deoarece Java nu acceptă moștenirea multiplă cu clase, nu vom intra în detalii. Cu toate acestea, mai târziu în tutorial, vom încerca să înțelegem motivele din spatele Java care nu acceptă moștenirea multiplă.
Moștenirea hibridă în Java
Moștenirea hibridă este o combinație a unuia sau mai multor tipuri de moșteniri despre care am discutat mai sus. Orice combinație are ca rezultat un tip de moștenire multiplă care nu este acceptat de Java.
O moștenire hibridă poate fi reprezentată schematic ca mai jos.
Prin urmare, Java nu acceptă moștenirea hibridă la fel de bine cu clasele. Dar, la fel ca moștenirea multiplă, putem implementa moștenirea hibridă în Java folosind interfețe. Vom discuta acest lucru în detaliu în următorul nostru tutorial.
De ce Java nu acceptă moștenirea multiplă?
Java vizează simplitatea în programe. Acest lucru se aplică chiar și funcțiilor OOP. Deci, când vine vorba de moștenirea multiplă, pot apărea unele situații ambigue atunci când derivăm o clasă din mai multe clase.
Acum să înțelegem problemele care pot apărea atunci când avem mai multe moșteniri în programul nostru.
Luați în considerare următoarele sisteme de moștenire multiplă.
Dacă vedem sistemul de mai sus, acesta se explică de la sine. Aici clasa A și clasa B sunt clase cu doi părinți moștenite de clasa C. Acum am arătat că atât clasele A cât și B au o metodă cu același nume, adică print (). Deci, atunci când clasa C moștenește A și B, atunci va primi ambele versiuni ale metodei print ().
În acest caz, clasa C nu va ști ce metodă ar trebui să moștenească. Aceasta este situația ambiguă pe care am menționat-o mai sus, care apare în cazul moștenirii multiple.
Prin urmare, Java emite o eroare de compilator atunci când clasa moștenește de la mai multe clase.
Următorul program Java va demonstra acest lucru.
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(); } } Ieșire:
După cum se vede din ieșire, compilatorul Java emite o eroare atunci când constată că clasa extinde două clase.
Deși Java nu permite ca două clase să fie moștenite simultan, ne oferă o cale de a evita această limitare. Putem simula moștenirea multiplă folosind interfețe în loc de clase. Vom discuta acest lucru în tutorialele noastre ulterioare.
Diamond Problem
Moștenirea multiplă are ca rezultat o situație numită „Problema diamantului”.
Luați în considerare faptul că avem următorul sistem de moștenire.
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 } Putem reprezenta acest sistem schematic așa cum se arată mai jos:
După cum putem vedea din diagrama de mai sus, întregul sistem de moștenire apare sub formă de diamant. Datorită acestei structuri diamantate, ambiguitatea este denumită „Problema diamantului”.
Așa cum s-a explicat mai devreme pentru moștenirea multiplă, ambiguitatea aici este numărul multiplu de copii ale metodei show () pe care clasa Sample o obține ca urmare a moștenirii. Deoarece există mai multe căi, realizează metoda show () și există o ambiguitate cu privire la ce copie să moștenească.
Ca și în cazul moștenirii multiple, problema diamantului poate fi rezolvată și cu ajutorul interfețelor.
Reguli de moștenire în Java
Până acum am văzut elementele de bază ale moștenirii, precum și tipurile de moștenire în Java, să enumerăm câteva reguli pe care trebuie să le urmăm în timp ce dezvoltăm aplicații cu moștenire.
Regula # 1: Java nu acceptă Moștenirea multiplă
După cum am văzut deja, Java nu acceptă moștenirea multiplă sub nicio formă. Când se încearcă moștenirea multiplă într-un program, compilatorul Java emite erori de compilare.
Regula # 2: Java nu permite moștenirea ciclică
O clasă care se moștenește pentru a forma un ciclu se numește Moștenirea ciclică.
Luați în considerare următoarele clase, clasa 1 și clasa 2.
class class1 extinde clasa 2 {}
class class2 extinde clasa 1 {}
cum deschid fișiere dat
Situația de mai sus formează o buclă. Acest lucru nu este permis în Java.
Regula # 3: Nu putem moșteni membrii de date private
Am aflat deja în subiectul „Modificatori de acces” că membrii cu acces privat nu pot fi moșteniți.
Regula # 4: Constructorii nu sunt moșteniți
Deoarece constructorii sunt utilizați pentru a crea obiecte de clasă, nu sunt moșteniți de la o clasă la alta.
Regula # 5: Putem folosi referința părintelui pentru a accesa obiectele copil
Am văzut deja diverse exemple de moștenire. Putem crea o referință a clasei părinte de tip și apoi îi putem atribui un obiect de clasă derivat creat folosind noul cuvânt cheie.
Dacă super este o superclasă și sub este o clasă derivată din super așa cum se arată mai jos.
class super{} class sub extends super{ public static void main(String() args){ super s_obj = new sub(); } }Regula # 6: Constructorii părinți sunt executați din cauza super () în constructorii derivați
Una dintre reguli prevede că constructorii nu pot fi moșteniți. Dar constructorul superclasei poate fi executat în interiorul constructorului clasei derivate folosind apelul super ().
întrebări frecvente
Q # 1) Ce tip de moștenire nu este acceptat de Java?
Răspuns: Java nu acceptă moștenirea multiplă, deoarece poate da naștere la probleme în aplicații precum problema diamantului. Java, de asemenea, nu acceptă moștenirea hibridă, deoarece este o combinație de unul sau mai multe tipuri de moștenire și se poate transforma în cele din urmă în moștenire multiplă.
Q # 2) Care dintre membrii clasei poate fi moștenit?
Răspuns: O clasă poate moșteni membrii publici și protejați ai clasei sale de bază, dar nu poate accesa membrii privați ai clasei de bază.
Î. 3) De ce nu este permisă moștenirea multiplă?
Răspuns: Moștenirea multiplă duce la ambiguitate atunci când clasele cu doi părinți au metode cu același prototip. În acest caz, clasa derivată se confruntă cu o ambiguitate cu privire la care clasă de bază ar trebui să moștenească metoda.
Moștenirea multiplă poate duce, de asemenea, la o problemă cu diamantul în Java. Prin urmare, Java nu acceptă moștenirea multiplă.
Î # 4) De ce aveți nevoie de moștenire multiplă?
Răspuns: Limbi precum Java și C # impun moștenirea multiplă folosind mai multe interfețe. Deci, atunci când trebuie să moștenim caracteristici de la mai multe interfețe, atunci avem nevoie de mai multe moșteniri.
Q # 5) Care este cea mai importantă utilizare a Moștenirii pe mai multe niveluri?
Răspuns: O clasă derivată dintr-o altă clasă care la rândul său este derivată dintr-o a treia clasă se spune că prezintă moștenire pe mai multe niveluri. Nivelurile din acest tip de moștenire pot fi extinse la orice număr atâta timp cât păstrează claritatea și simplitatea.
Putem descrie diferite niveluri de specii folosind moștenirea pe mai multe niveluri. Din punct de vedere al programării, atunci când vrem să reprezentăm diferite niveluri de clase de aplicații, atunci mergem pentru moștenirea pe mai multe niveluri.
Concluzie
În acest tutorial, am discutat despre tipurile de moștenire în Java. Java acceptă numai tipuri de moștenire unice, multinivele și ierarhice. Java nu acceptă moștenirea multiplă și hibridă. Am discutat despre ambiguitatea moștenirii multiple și problema Diamond în Java.
Apoi am discutat diferitele reguli pe care ar trebui să le urmăm în timp ce implementăm moștenirea în Java. Cu aceasta, am finalizat discuția noastră despre relația IS-A în Java.
=> Urmăriți aici seria de antrenament Java simplă.
Lectură recomandată
- Ce este moștenirea în Java - Tutorial cu exemple
- Moștenirea în C ++
- Tipuri de moștenire în C ++
- Noțiuni de bază Java: Sintaxă Java, Java Class și concepte de bază Java
- Java Integer și Java BigInteger Class cu exemple
- Tipuri de clase în Java: abstract, concret, final, static
- Variabile Java și tipurile lor cu exemple
- Tutorial de clasă Java Scanner cu exemple