Eredità è la caratteristica più potente della programmazione orientata agli oggetti. Ci consente di ereditare le proprietà di una classe in un'altra classe. In questa sezione discuteremo tipi di ereditarietà in Java approfondito con esempi di vita reale. Inoltre, creeremo programmi Java per implementare il concetto di diversi tipi di ereditarietà.
quanto è grande questo monitor?
Eredità
Eredità è un meccanismo per guidare una nuova classe da una classe esistente. La (vecchia) classe esistente è nota come classe base O classe eccellente O classe genitore . La nuova classe è conosciuta come a classe derivata O sottoclasse O classe infantile . Ci consente di utilizzare le proprietà e il comportamento di una classe (genitore) in un'altra classe (figlio).
Una classe le cui proprietà vengono ereditate è nota come classe genitore e una classe che eredita le proprietà della classe genitore è nota come classe infantile . Pertanto, stabilisce una relazione tra la classe genitore e quella figlia nota come genitore-figlio o È un relazione.
Supponiamo che ci siano due classi denominate Padre E Bambino e vogliamo ereditare le proprietà della classe Father nella classe Child. Possiamo raggiungere questo obiettivo utilizzando il file si estende parola chiave.
//inherits the properties of the Father class class Child extends Father { //functionality } 
Quando dovremmo usare l'ereditarietà?
L'ereditarietà fornisce il riusabilità di codice, soprattutto quando è presente una vasta scala di codice da riutilizzare. Stabilisce inoltre la relazione tra diverse classi nota come a È un relazione. Possiamo anche usarlo se vogliamo raggiungere metodo prevalente .
Punti da ricordare
- Il costruttore non può essere ereditato in Java.
- I membri privati non vengono ereditati in Java.
- L'ereditarietà ciclica non è consentita in Java.
- Assegna il riferimento genitore agli oggetti figlio.
- I costruttori vengono eseguiti a causa di super() presente nel costruttore.
Tipi di eredità
Java supporta i seguenti quattro tipi di ereditarietà:
- Eredità unica
- Eredità multilivello
- Eredità gerarchica
- Eredità ibrida
Nota: l'ereditarietà multipla non è supportata in Java.
Discutiamo ciascuno con l'esempio appropriato.
Eredità unica
Nell'ereditarietà singola, una sottoclasse deriva da una sola superclasse. Eredita le proprietà e il comportamento di una classe a genitore singolo. A volte è anche conosciuto come eredità semplice .
Nella figura sopra, Employee è una classe genitore e Executive è una classe figlia. La classe Executive eredita tutte le proprietà della classe Employee.
Implementiamo il meccanismo di ereditarietà singola in un programma Java.
Executive.java
class Employee { float salary=34534*12; } public class Executive extends Employee { float bonus=3000*6; public static void main(String args[]) { Executive obj=new Executive(); System.out.println('Total salary credited: '+obj.salary); System.out.println('Bonus of six months: '+obj.bonus); } } Produzione:
Total salary credited: 414408.0 Bonus of six months: 18000.0
Eredità multilivello
In ereditarietà multilivello , una classe deriva da una classe che è derivata anche da un'altra classe è detta ereditarietà multilivello. In parole semplici, possiamo dire che una classe che ha più di una classe genitore è chiamata ereditarietà multilivello. Tieni presente che le classi devono essere a livelli diversi. Pertanto, esiste un'unica classe base e un'unica classe derivata ma più classi base intermedie.
Nella figura sopra, la classe Marks eredita i membri o i metodi della classe Students. La classe Sport eredita i membri della classe Marchi. Pertanto, la classe Student è la classe genitore della classe Marks e la classe Marks è la classe genitore della classe Sports. Pertanto, la classe Sports eredita implicitamente le proprietà dello Student insieme alla classe Marks.
Implementiamo il meccanismo di ereditarietà multilivello in un programma Java.
Esempio di ereditarietà multilivello.java
//super class class Student { int reg_no; void getNo(int no) { reg_no=no; } void putNo() { System.out.println('registration number= '+reg_no); } } //intermediate sub class class Marks extends Student { float marks; void getMarks(float m) { marks=m; } void putMarks() { System.out.println('marks= '+marks); } } //derived class class Sports extends Marks { float score; void getScore(float scr) { score=scr; } void putScore() { System.out.println('score= '+score); } } public class MultilevelInheritanceExample { public static void main(String args[]) { Sports ob=new Sports(); ob.getNo(0987); ob.putNo(); ob.getMarks(78); ob.putMarks(); ob.getScore(68.7); ob.putScore(); } } Produzione:
registration number= 0987 marks= 78.0 score= 68.7
Eredità gerarchica
Se più classi derivano da una singola classe base, viene chiamata eredità gerarchica .
Nella figura sopra, le classi Scienza, Commercio e Arti ereditano un'unica classe genitore denominata Studente.
Implementiamo il meccanismo di ereditarietà gerarchica in un programma Java.
HierarchicalInheritanceExample.java
//parent class class Student { public void methodStudent() { System.out.println('The method of the class Student invoked.'); } } class Science extends Student { public void methodScience() { System.out.println('The method of the class Science invoked.'); } } class Commerce extends Student { public void methodCommerce() { System.out.println('The method of the class Commerce invoked.'); } } class Arts extends Student { public void methodArts() { System.out.println('The method of the class Arts invoked.'); } } public class HierarchicalInheritanceExample { public static void main(String args[]) { Science sci = new Science(); Commerce comm = new Commerce(); Arts art = new Arts(); //all the sub classes can access the method of super class sci.methodStudent(); comm.methodStudent(); art.methodStudent(); } } Produzione:
The method of the class Student invoked. The method of the class Student invoked. The method of the class Student invoked.
Eredità ibrida
I mezzi ibridi sono costituiti da più di uno. L'ereditarietà ibrida è la combinazione di due o più tipi di ereditarietà.
Nella figura sopra, il Nonno è una super classe. La classe Father eredita le proprietà della classe GrandFather. Poiché padre e nonno rappresentano un'unica eredità. Inoltre, la classe del Padre viene ereditata dalla classe del Figlio e della Figlia. Pertanto, il Padre diventa la classe genitrice del Figlio e della Figlia. Queste classi rappresentano l'eredità gerarchica. Insieme, denota l'eredità ibrida.
Implementiamo il meccanismo di ereditarietà ibrida in un programma Java.
Figlia.java
//parent class class GrandFather { public void show() { System.out.println('I am grandfather.'); } } //inherits GrandFather properties class Father extends GrandFather { public void show() { System.out.println('I am father.'); } } //inherits Father properties class Son extends Father { public void show() { System.out.println('I am son.'); } } //inherits Father properties public class Daughter extends Father { public void show() { System.out.println('I am a daughter.'); } public static void main(String args[]) { Daughter obj = new Daughter(); obj.show(); } } Produzione:
I am daughter.
Ereditarietà multipla (non supportata)
Java non supporta eredità multiple a causa dell'ambiguità. Consideriamo ad esempio il seguente programma Java.
Demo.java
class Wishes { void message() { System.out.println('Best of Luck!!'); } } class Birthday { void message() { System.out.println('Happy Birthday!!'); } } public class Demo extends Wishes, Birthday //considering a scenario { public static void main(String args[]) { Demo obj=new Demo(); //can't decide which classes' message() method will be invoked obj.message(); } } Il codice precedente restituisce un errore perché il compilatore non può decidere quale metodo message() deve essere invocato. Per questo motivo, Java non supporta eredità multiple a livello di classe ma può essere ottenuta tramite un file interfaccia .