Tipuri de moștenire simplă în Java

Deja cunoaștem că limbajul Java, la nivel de clase, permite doar moștenire simplă. Adică, o clasă poate să extindă o singură clasă și numai una. Excepția este clasa Object, care este părintele tuturor claselor Java, dar ea însăși nu are părinte.

Dar ... chiar dacă Java nu permite moștenirea multiplă direct cu clase, conceptul de moștenire chiar și cea simplă este mai larg și poate fi împărțit în mai multe tipuri, fiecare cu avantajele și situațiile sale specifice. 

Să le examinăm pe rând pe rând:

1. Moștenire unică. Cel mai simplu tip de moștenire din Java, unde o clasă copil extinde doar o clasă părinte. 

O clasă derivată (B) moștenește o singură clasă de bază (A).

Exemplul 1

class Angajat1{
    float salariu=3500*12;
}
class Director extends Angajat1 {
    float bonus=1000*6;
}
class Test{
    public static void main(String args[]) {
        Director obj=new Director();
        System.out.println("Salariu total: "+obj.salariu);
        System.out.println("Bonus pentru 6 luni: "+obj.bonus);
    }}

2. Moștenire pe mai multe niveluri. Este un tip de moștenire în care o clasă copil extinde o altă clasă copil, care la rândul său extinde o clasă părinte.

O clasă derivată (B) devine la rândul ei clasă de bază pentru o altă clasă (C).

Exemplul 2

class FiguraGeometrica {
    public void suprafata() {
        System.out.println("Suprafata interioara");
    }}
class Dreptunghi extends FiguraGeometrica {
    public void arie() {
        System.out.println("Arie interioara");
    }}
class Patrat extends Dreptunghi{
    public void volum() {
        System.out.println("Volum interior");
    }}
class TestareIerarhica {
    public static void main(String[] arguments) {
        Patrat cube = new Patrat();
        cube.suprafata();
        cube.arie();
        cube.volum();
    }} 

3. Moștenirea ierarhică. Clasele copil extind aceeași clasă părinte. 

Mai multe clase derivate (B,C) moștenesc aceeași clasă de bază (A)

Exemplul 3 

class Vehicul {
    double pretBaza = 100000;
    public void afisarePret() {
        System.out.println("Pretul de baza: " + pretBaza);
    }}

class Bicicletaa extends Vehicul {
    double plusPret = 0.20;
    void pretFinal() {
        pretBaza  = pretBaza  + (pretBaza  * plusPret);
        System.out.println("Pretul pentru bicicleta:" + pretBaza);
    }}

class Masina extends Vehicul {
    double plusPret = 1;
    void pretFinal() {
        pretBaza  = pretBaza  + (pretBaza * plusPret);
        System.out.println("Pret pentru masina:" + pretBaza);
    }}
class TestareIerarhic {
    public static void main(String[] args) {
        System.out.println("----------------------");
        Bicicletaa bicicleta = new Bicicletaa();
        bicicleta.afisarePret();
        bicicleta.pretFinal();
        System.out.println("----------------------");
        Masina auto = new Masina();
        auto.afisarePret();
        auto.pretFinal();
    }}

4. Moștenirea hibridă. Este combinația mai multor tipuri de moștenire, de exemplu, un amestec între moștenire în lanț, sau pe mai multe niveluri, și moștenire ierarhică. 

Exemplul 4

class A {
    public void afiseaza() {
        System.out.println("clasa A");
    }}
class B extends A {
    public void afiseazaB() {
        System.out.println("clasa B");
    }}
class C extends A {
    public void afiseazaC() {
        System.out.println("clasa C");
    }}
class D extends C {
    public void afiseazaD() {
        System.out.println("clasa D");
    }}

class Mainn {
    public static void main(String[] args) {
        D obj = new D();
        obj.afiseaza();
    }}

La fel cum în viața de zi cu zi învățăm și ne construim experiențele pe baza a ceea ce știm deja, în programare clasele „împrumută” caracteristici și metode de la clasele părinte. Astfel codul devine mai clar, mai ordonat și mai elegant. 

Succes! 

❤️