Moştenire este cea mai puternică caracteristică a programării orientate pe obiecte. Ne permite să moștenim proprietățile unei clase într-o altă clasă. În această secțiune, vom discuta tipuri de moștenire în Java în profunzime cu exemple din viața reală. De asemenea, vom crea programe Java pentru a implementa conceptul diferitelor tipuri de moștenire.
Moştenire
Moştenire este un mecanism de conducere a unei noi clase dintr-o clasă existentă. Clasa existentă (veche) este cunoscută ca clasa de bază sau super clasa sau clasa de părinți . Noua clasă este cunoscută ca a clasa derivata sau subclasa sau clasa de copii . Ne permite să folosim proprietățile și comportamentul unei clase (părinte) într-o altă clasă (copil).
O clasă ale cărei proprietăți sunt moștenite este cunoscută ca clasa de părinți iar o clasă care moștenește proprietățile clasei părinte este cunoscută ca clasa de copii . Astfel, stabilește o relație între clasa părinte și copil care este cunoscută ca părinte-copil sau Este-a relaţie.
Să presupunem că există două clase numite Tată și Copil și vrem să moștenim proprietățile clasei Tată în clasa Copilului. Putem realiza acest lucru folosind se extinde cuvânt cheie.
//inherits the properties of the Father class class Child extends Father { //functionality } 
Când ar trebui să folosim moștenirea?
Moștenirea oferă reutilizabilitate de cod mai ales atunci când există o scară mare de cod de reutilizat. De asemenea, stabilește relația dintre diferitele clase care este cunoscută sub numele de a Este-a relaţie. Îl putem folosi și dacă dorim să realizăm depășirea metodei .
Puncte de reținut
- Constructorul nu poate fi moștenit în Java.
- Membrii privați nu sunt moșteniți în Java.
- Moștenirea ciclică nu este permisă în Java.
- Atribuiți referință părinte obiectelor copil.
- Constructorii sunt executați din cauza super() prezentă în constructor.
Tipuri de moștenire
Java acceptă următoarele patru tipuri de moștenire:
setați delimitator java
- Moștenire unică
- Moștenire pe mai multe niveluri
- Moștenirea ierarhică
- Moștenirea hibridă
Notă: Moștenirea multiplă nu este acceptată în Java.
Să discutăm fiecare cu un exemplu adecvat.
Moștenire unică
În moștenirea unică, o sub-clasă este derivată dintr-o singură super-clasă. Moștenește proprietățile și comportamentul unei clase monoparentale. Uneori este cunoscut și ca moștenire simplă .
În figura de mai sus, Angajatul este o clasă părinte și Executive este o clasă copil. Clasa Executive moștenește toate proprietățile clasei Employee.
Să implementăm mecanismul unic de moștenire într-un program 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); } } Ieșire:
șir la char
Total salary credited: 414408.0 Bonus of six months: 18000.0
Moștenire pe mai multe niveluri
În moștenire pe mai multe niveluri , o clasă este derivată dintr-o clasă care este derivată și dintr-o altă clasă se numește moștenire pe mai multe niveluri. Cu cuvinte simple, putem spune că o clasă care are mai multe clase părinte se numește moștenire pe mai multe niveluri. Rețineți că clasele trebuie să fie la niveluri diferite. Prin urmare, există o singură clasă de bază și o singură clasă derivată, dar mai multe clase de bază intermediare.
În figura de mai sus, clasa Marks moștenește membrii sau metodele clasei Studenți. Clasa Sport moștenește membrii clasei Marks. Prin urmare, clasa Student este clasa părinte a clasei Note, iar clasa Note este părintele clasei Sport. Prin urmare, clasa Sport moștenește implicit proprietățile Studentului împreună cu Notele clasei.
Să implementăm mecanismul de moștenire pe mai multe niveluri într-un program Java.
MultilevelInheritanceExample.java
sql selectați ca
//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(); } } Ieșire:
registration number= 0987 marks= 78.0 score= 68.7
Moștenirea ierarhică
Dacă un număr de clase sunt derivate dintr-o singură clasă de bază, aceasta este numită moștenire ierarhică .
În figura de mai sus, clasele Știință, Comerț și Arte moștenesc o clasă cu un singur părinte numită Student.
Să implementăm mecanismul de moștenire ierarhică într-un program Java.
HierarchicalHeritanceExample.java
convert string int 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(); } } Ieșire:
The method of the class Student invoked. The method of the class Student invoked. The method of the class Student invoked.
Moștenirea hibridă
Mijloacele hibride constau din mai multe. Moștenirea hibridă este combinația a două sau mai multe tipuri de moștenire.
În figura de mai sus, Bunicul este o super clasă. Clasa Father moștenește proprietățile clasei GrandFather. Întrucât Tatăl și Bunicul reprezintă moștenirea unică. În plus, clasa Tatălui este moștenită de clasa Fiului și Fiică. Astfel, Tatăl devine clasa părinte pentru Fiu și Fiică. Aceste clase reprezintă moștenirea ierarhică. În combinație, denotă moștenirea hibridă.
Să implementăm mecanismul de moștenire hibrid într-un program Java.
fiica.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(); } } Ieșire:
I am daughter.
Moștenire multiplă (nu este acceptată)
Java nu acceptă moșteniri multiple din cauza ambiguității. De exemplu, luați în considerare următorul program Java.
Demo.java
punct numpy
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(); } } Codul de mai sus dă eroare deoarece compilatorul nu poate decide ce metodă message() trebuie invocată. Din acest motiv, Java nu acceptă moșteniri multiple la nivel de clasă, dar poate fi obținut printr-un interfata .