Java, Moștenirea este un pilon important al OOP (Programare Orientată pe Obiect). Este mecanismul din Java prin care unei clase i se permite să moștenească caracteristicile (câmpurile și metodele) unei alte clase. În Java, Moștenirea înseamnă crearea de noi clase bazate pe cele existente. O clasă care moștenește de la o altă clasă poate reutiliza metodele și câmpurile acelei clase. În plus, puteți adăuga noi câmpuri și metode și la clasa dvs. curentă.

De ce avem nevoie de moștenirea Java?

• Reutilizarea codului: Codul scris în Superclasă este comun tuturor subclaselor. Clasele copii pot folosi direct codul clasei părinte.
• Suprascrierea metodei: Anularea metodei este realizabilă numai prin moştenire. Este una dintre modalitățile prin care Java realizează polimorfismul Run Time.
• Abstracție: Conceptul de abstract în care nu trebuie să furnizăm toate detaliile se realizează prin moștenire. Abstracția arată doar funcționalitatea utilizatorului.

Terminologii importante utilizate în moștenirea Java

• Clasă: Clasa este un set de obiecte care au în comun caracteristici/comportament și proprietăți/atribute comune. Clasa nu este o entitate din lumea reală. Este doar un șablon sau un model sau un prototip din care sunt create obiectele.
• Super clasă/clasa pentru părinți: Clasa ale cărei caracteristici sunt moștenite este cunoscută ca o superclasă (sau o clasă de bază sau o clasă părinte).
• Subclasa/Clasa pentru copii: Clasa care moștenește cealaltă clasă este cunoscută ca subclasă (sau clasă derivată, clasă extinsă sau clasă copil). Subclasa își poate adăuga propriile câmpuri și metode în plus față de câmpurile și metodele superclasei.
• Reutilizabilitate: Moștenirea acceptă conceptul de reutilizare, adică atunci când dorim să creăm o clasă nouă și există deja o clasă care include o parte din codul pe care îl dorim, putem deriva noua noastră clasă din clasa existentă. Făcând acest lucru, reutilizam câmpurile și metodele clasei existente.

Cum se utilizează moștenirea în Java?

The extinde cuvântul cheie este folosit pentru moștenire în Java. Utilizarea cuvântului cheie extins indică că sunteți derivat dintr-o clasă existentă. Cu alte cuvinte, extinde se referă la funcționalitate crescută.

redenumiți în directorul linux

Sintaxa:

class DerivedClass extends BaseClass  {   //methods and fields  }>

Exemplu de moștenire în Java

Exemplu: În exemplul de mai jos de moștenire, clasa Bicycle este o clasă de bază, clasa MountainBike este o clasă derivată care extinde clasa Bicycle și clasa Test este o clasă de șofer pentru a rula programul.

// Java program to illustrate the // concept of inheritance // base class class Bicycle {  // the Bicycle class has two fields  public int gear;  public int speed;  // the Bicycle class has one constructor  public Bicycle(int gear, int speed)  {  this.gear = gear;  this.speed = speed;  }  // the Bicycle class has three methods  public void applyBrake(int decrement)  {  speed -= decrement;  }  public void speedUp(int increment)  {  speed += increment;  }  // toString() method to print info of Bicycle  public String toString()  {  return ('No of gears are ' + gear + '
'  + 'speed of bicycle is ' + speed);  } } // derived class class MountainBike extends Bicycle {  // the MountainBike subclass adds one more field  public int seatHeight;  // the MountainBike subclass has one constructor  public MountainBike(int gear, int speed,  int startHeight)  {  // invoking base-class(Bicycle) constructor  super(gear, speed);  seatHeight = startHeight;  }  // the MountainBike subclass adds one more method  public void setHeight(int newValue)  {  seatHeight = newValue;  }  // overriding toString() method  // of Bicycle to print more info  @Override public String toString()  {  return (super.toString() + '
seat height is '  + seatHeight);  } } // driver class public class Test {  public static void main(String args[])  {  MountainBike mb = new MountainBike(3, 100, 25);  System.out.println(mb.toString());  } }>

No of gears are 3 speed of bicycle is 100 seat height is 25>

În programul de mai sus, când este creat un obiect din clasa MountainBike, o copie a tuturor metodelor și câmpurilor superclasei dobândește memorie în acest obiect. De aceea prin utilizarea obiectului subclasei putem accesa și membrii unei superclase.

Vă rugăm să rețineți că în timpul moștenirii este creat doar obiectul subclasei, nu superclasa. Pentru mai multe, consultați Crearea obiectelor Java a clasei moștenite .

Exemplul 2: În exemplul de mai jos de moștenire, clasa Employee este o clasă de bază, clasa Engineer este o clasă derivată care extinde clasa Employee și clasa Test este o clasă de driver pentru a rula programul.

// Java Program to illustrate Inheritance (concise) import java.io.*; // Base or Super Class class Employee {  int salary = 60000; } // Inherited or Sub Class class Engineer extends Employee {  int benefits = 10000; } // Driver Class class Gfg {  public static void main(String args[])  {  Engineer E1 = new Engineer();  System.out.println('Salary : ' + E1.salary  + '
Benefits : ' + E1.benefits);  } }>

Salary : 60000 Benefits : 10000>

Imagine ilustrativă a programului:

arp o comandă

În practică, moștenirea și polimorfism sunt utilizate împreună în Java pentru a obține performanță rapidă și lizibilitatea codului.

Tipuri de moștenire Java

Mai jos sunt diferitele tipuri de moștenire care sunt acceptate de Java.

1. Moștenire unică
2. Moștenirea pe mai multe niveluri
3. Moștenirea ierarhică
4. Moștenirea multiplă
5. Moștenirea hibridă

1. 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 jos, „A” este o clasă părinte și „B” este o clasă copil. Clasa „B” moștenește toate proprietățile clasei „A”.

Moștenire unică

// Java program to illustrate the // concept of single inheritance import java.io.*; import java.lang.*; import java.util.*; // Parent class class One {  public void print_geek()  {  System.out.println('Geeks');  } } class Two extends One {  public void print_for() { System.out.println('for'); } } // Driver class public class Main {  // Main function  public static void main(String[] args)  {  Two g = new Two();  g.print_geek();  g.print_for();  g.print_geek();  } }>

Geeks for Geeks>

2. Moștenirea pe mai multe niveluri

În Moștenirea pe mai multe niveluri, o clasă derivată va moșteni o clasă de bază și, la fel ca și clasa derivată, acționează și ca clasă de bază pentru alte clase. În imaginea de mai jos, clasa A servește ca o clasă de bază pentru clasa derivată B, care, la rândul său, servește ca o clasă de bază pentru clasa derivată C. În Java, o clasă nu poate accesa direct membrii bunicilor .

Moștenirea pe mai multe niveluri

// Importing required libraries import java.io.*; import java.lang.*; import java.util.*; // Parent class One class One {  // Method to print 'Geeks'  public void print_geek() {  System.out.println('Geeks');  } } // Child class Two inherits from class One class Two extends One {  // Method to print 'for'  public void print_for() {  System.out.println('for');  } } // Child class Three inherits from class Two class Three extends Two {  // Method to print 'Geeks'  public void print_lastgeek() {  System.out.println('Geeks');  } } // Driver class public class Main {  public static void main(String[] args) {  // Creating an object of class Three  Three g = new Three();    // Calling method from class One  g.print_geek();    // Calling method from class Two  g.print_for();    // Calling method from class Three  g.print_lastgeek();  } }>

Geeks for Geeks>

3. Moștenirea ierarhică

În Moștenirea ierarhică, o clasă servește ca superclasă (clasa de bază) pentru mai mult de o subclasă. În imaginea de mai jos, clasa A servește ca clasă de bază pentru clasele derivate B, C și D.

// Java program to illustrate the // concept of Hierarchical inheritance class A {  public void print_A() { System.out.println('Class A'); } } class B extends A {  public void print_B() { System.out.println('Class B'); } } class C extends A {  public void print_C() { System.out.println('Class C'); } } class D extends A {  public void print_D() { System.out.println('Class D'); } } // Driver Class public class Test {  public static void main(String[] args)  {  B obj_B = new B();  obj_B.print_A();  obj_B.print_B();  C obj_C = new C();  obj_C.print_A();  obj_C.print_C();  D obj_D = new D();  obj_D.print_A();  obj_D.print_D();  } }>

Class A Class B Class A Class C Class A Class D>

4. Moștenire multiplă ( Prin interfețe)

În Moșteniri multiple , o clasă poate avea mai multe superclase și poate moșteni caracteristici de la toate clasele părinte. Vă rugăm să rețineți că Java o face nu a sustine moșteniri multiple cu cursuri. În Java, putem obține mai multe moșteniri numai prin Interfețe . În imaginea de mai jos, clasa C este derivată din interfețele A și B.

Moștenirea multiplă

manipularea șirurilor de caractere în c++

// Java program to illustrate the // concept of Multiple inheritance import java.io.*; import java.lang.*; import java.util.*; interface One {  public void print_geek(); } interface Two {  public void print_for(); } interface Three extends One, Two {  public void print_geek(); } class Child implements Three {  @Override public void print_geek()  {  System.out.println('Geeks');  }  public void print_for() { System.out.println('for'); } } // Drived class public class Main {  public static void main(String[] args)  {  Child c = new Child();  c.print_geek();  c.print_for();  c.print_geek();  } }>

Geeks for Geeks>

5. Moștenirea hibridă

Este un amestec de două sau mai multe dintre tipurile de moștenire de mai sus. Deoarece Java nu acceptă moșteniri multiple cu clase, moștenirea hibridă care implică moșteniri multiple nu este, de asemenea, posibilă cu clase. În Java, putem obține moștenirea hibridă numai prin Interfețe dacă dorim să implicăm moștenirea multiplă pentru a implementa moștenirea hibridă.
Cu toate acestea, este important de reținut că moștenirea hibridă nu necesită neapărat utilizarea exclusivă a moștenirii multiple. Poate fi realizat printr-o combinație de moștenire pe mai multe niveluri și moștenire ierarhică cu clase, moștenire ierarhică și unică cu clase. Prin urmare, este într-adevăr posibil să se implementeze moștenirea hibridă folosind doar clase, fără a se baza pe tipul de moștenire multiplu.

Moștenirea hibridă

Java IS-un tip de relație

IS-A este un mod de a spune: Acest obiect este un tip al acelui obiect. Să vedem cum este folosit cuvântul cheie extins pentru a obține moștenirea.

public class SolarSystem { } public class Earth extends SolarSystem { } public class Mars extends SolarSystem { } public class Moon extends Earth { }>

Acum, pe baza exemplului de mai sus, în termeni orientați pe obiecte, următoarele sunt adevărate:

jframe

• SolarSystem este superclasa clasei Pământului.
• SolarSystem este superclasa clasei Marte.
• Pământul și Marte sunt subclase ale clasei SolarSystem.
• Luna este subclasa ambelor clase de Pământ și SolarSystem.

class SolarSystem { } class Earth extends SolarSystem { } class Mars extends SolarSystem { } public class Moon extends Earth {  public static void main(String args[])  {  SolarSystem s = new SolarSystem();  Earth e = new Earth();  Mars m = new Mars();  System.out.println(s instanceof SolarSystem);  System.out.println(e instanceof Earth);  System.out.println(m instanceof SolarSystem);  } }>

true true true>

Ce se poate face într-o subclasă?

În subclase putem moșteni membrii așa cum sunt, îi putem înlocui, îi putem ascunde sau îi putem completa cu membri noi:

• Câmpurile moștenite pot fi folosite direct, la fel ca orice alte câmpuri.
• Putem declara noi câmpuri în subclasă care nu sunt în superclasă.
• Metodele moștenite pot fi utilizate direct așa cum sunt.
• Putem scrie un nou instanță metoda din subclasa care are aceeasi semnatura cu cea din superclasa, deci depășind aceasta (ca în exemplul de mai sus, toString() metoda este anulată).
• Putem scrie un nou static metoda din subclasa care are aceeasi semnatura cu cea din superclasa, deci ascunzându-se aceasta.
• Putem declara noi metode în subclasă care nu sunt în superclasă.
• Putem scrie un constructor de subclase care invocă constructorul superclasei, fie implicit, fie folosind cuvântul cheie super .

Avantajele moștenirii în Java:

1. Reutilizarea codului: Moștenirea permite reutilizarea codului și reduce cantitatea de cod care trebuie scris. Subclasa poate reutiliza proprietățile și metodele superclasei, reducând duplicarea codului.
2. Abstracție: Moștenirea permite crearea de clase abstracte care definesc o interfață comună pentru un grup de clase înrudite. Acest lucru promovează abstracția și încapsularea, făcând codul mai ușor de întreținut și extins.
3. Ierarhia de clasă: Moștenirea permite crearea unei ierarhii de clasă, care poate fi folosită pentru a modela obiecte din lumea reală și relațiile lor.
4. Polimorfism: Moștenirea permite polimorfismul, care este capacitatea unui obiect de a lua mai multe forme. Subclasele pot suprascrie metodele superclasei, ceea ce le permite să-și schimbe comportamentul în moduri diferite.

Dezavantajele moștenirii în Java:

1. Complexitate: Moștenirea poate face codul mai complex și mai greu de înțeles. Acest lucru este valabil mai ales dacă ierarhia moștenirii este profundă sau dacă se utilizează moșteniri multiple.
2. Cuplare strânsă: Moștenirea creează o cuplare strânsă între superclasă și subclasă, ceea ce face dificilă efectuarea modificărilor superclasei fără a afecta subclasa.

Concluzie

Să verificăm câteva puncte importante din articol sunt menționate mai jos:

• Superclasă implicită : Cu exceptia Obiect clasă, care nu are superclasă, fiecare clasă are una și o singură superclasă directă (moștenire unică). În absența oricărei alte superclase explicite, fiecare clasă este implicit o subclasă a clasei Object.
• Superclasa poate fi doar una: O superclasă poate avea orice număr de subclase. Dar o subclasă poate avea doar unu superclasă. Acest lucru se datorează faptului că Java nu acceptă moșteniri multiple cu clase. Deși cu interfețe, moștenirile multiple sunt acceptate de Java.
• Constructori care moștenesc: O subclasă moștenește toți membrii (câmpuri, metode și clase imbricate) din superclasa sa. Constructorii nu sunt membri, deci nu sunt moșteniți de subclase, dar constructorul superclasei poate fi invocat din subclasă.
• Moștenirea unui membru privat: O subclasă nu moștenește membrii privați ai clasei părinte. Totuși, dacă superclasa are metode publice sau protejate (cum ar fi getters și setters) pentru accesarea câmpurilor sale private, acestea pot fi folosite și de subclasă.

Întrebări frecvente în Moștenire

1. Ce este Moștenirea Java?

Moștenirea este un concept de POO în care o clasă moștenește de la o altă clasă care poate reutiliza metodele și câmpurile clasei părinte.

2. Care sunt cele 4 tipuri de moștenire în Java?

Există unic, multiplu, mai multe niveluri, ierarhice și hibride

3. La ce folosește cuvântul cheie extinde?

Cuvântul cheie Extend este folosit pentru a moșteni o clasă în alta.

4. Care este un exemplu de moștenire în Java?

Un exemplu real de moștenire în Java este menționat mai jos:

Luați în considerare un grup de vehicule. Trebuie să creați clase pentru autobuz, mașină și camion. Metodele fuelAmount(), capacity(), applyBrakes() vor fi aceleași pentru toate cele trei clase.

Referințe folosite:

1. Head First Java de Kathy Sierra și Bert Bates
2. Java: un ghid pentru începători de Herbert Schildt
3. Java: Referința completă de Herbert Schildt
4. Java eficient de Joshua Bloch
5. Java: părțile bune de Jim Waldo.