Java, l'ereditarietà è un pilastro importante della OOP (programmazione orientata agli oggetti). È il meccanismo in Java mediante il quale una classe può ereditare le funzionalità (campi e metodi) di un'altra classe. In Java, Ereditarietà significa creare nuove classi basate su quelle esistenti. Una classe che eredita da un'altra classe può riutilizzare i metodi e i campi di quella classe. Inoltre, puoi aggiungere nuovi campi e metodi anche alla tua classe attuale.

Perché abbiamo bisogno dell'ereditarietà Java?

• Riutilizzabilità del codice: Il codice scritto nella Superclasse è comune a tutte le sottoclassi. Le classi figlie possono utilizzare direttamente il codice della classe genitore.
• Metodo di sostituzione: Metodo prioritario è ottenibile solo tramite Eredità. È uno dei modi in cui Java raggiunge il polimorfismo del runtime.
• Astrazione: Il concetto di astratto in cui non dobbiamo fornire tutti i dettagli si ottiene attraverso l'ereditarietà. Astrazione mostra solo la funzionalità all'utente.

Terminologie importanti utilizzate nell'ereditarietà Java

• Classe: La classe è un insieme di oggetti che condividono caratteristiche/comportamenti comuni e proprietà/attributi comuni. La classe non è un'entità del mondo reale. È solo un modello, un progetto o un prototipo da cui vengono creati gli oggetti.
• Super Classe/Classe Genitore: La classe le cui caratteristiche vengono ereditate è conosciuta come superclasse (o classe base o classe genitore).
• Sottoclasse/Classe secondaria: La classe che eredita l'altra classe è conosciuta come sottoclasse (o classe derivata, classe estesa o classe figlia). La sottoclasse può aggiungere i propri campi e metodi oltre ai campi e ai metodi della superclasse.
• Riutilizzabilità: L'ereditarietà supporta il concetto di riusabilità, ovvero quando vogliamo creare una nuova classe ed esiste già una classe che include parte del codice che desideriamo, possiamo derivare la nostra nuova classe dalla classe esistente. In questo modo riutilizziamo i campi e i metodi della classe esistente.

Come utilizzare l'ereditarietà in Java?

IL estende la parola chiave viene utilizzato per l'ereditarietà in Java. L'uso della parola chiave extends indica che sei derivato da una classe esistente. In altre parole, l'estensione si riferisce ad una maggiore funzionalità.

array di oggetti in Java

Sintassi:

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

Ereditarietà in Java Esempio

Esempio: Nell'esempio di ereditarietà riportato di seguito, la classe Bicycle è una classe base, la classe MountainBike è una classe derivata che estende la classe Bicycle e la classe Test è una classe driver per eseguire il programma.

// 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>

Nel programma sopra, quando viene creato un oggetto della classe MountainBike, una copia di tutti i metodi e campi della superclasse acquisisce memoria in questo oggetto. Ecco perché utilizzando l'oggetto della sottoclasse possiamo accedere anche ai membri di una superclasse.

Tieni presente che durante l'ereditarietà viene creato solo l'oggetto della sottoclasse, non la superclasse. Per ulteriori informazioni, fare riferimento a Creazione di oggetti Java di classi ereditate .

Esempio 2: Nell'esempio di ereditarietà seguente, la classe Employee è una classe base, la classe Engineer è una classe derivata che estende la classe Employee e la classe Test è una classe driver per eseguire il programma.

// 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>

Immagine illustrativa del programma:

lupo contro volpe

In pratica, eredità, e polimorfismo vengono utilizzati insieme in Java per ottenere prestazioni rapide e leggibilità del codice.

Tipi di eredità Java

Di seguito sono riportati i diversi tipi di ereditarietà supportati da Java.

1. Eredità unica
2. Eredità multilivello
3. Eredità gerarchica
4. Eredità multipla
5. Eredità ibrida

1. 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 è detta anche ereditarietà semplice. Nella figura seguente, 'A' è una classe genitore e 'B' è una classe figlia. La classe 'B' eredita tutte le proprietà della classe 'A'.

Eredità unica

// 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. Eredità multilivello

Nell'ereditarietà multilivello, una classe derivata erediterà una classe base e, oltre alla classe derivata, fungerà anche da classe base per altre classi. Nell'immagine seguente, la classe A funge da classe base per la classe derivata B, che a sua volta funge da classe base per la classe derivata C. In Java, una classe non può accedere direttamente al membri dei nonni .

Eredità multilivello

// 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. Eredità gerarchica

Nell'ereditarietà gerarchica, una classe funge da superclasse (classe base) per più di una sottoclasse. Nell'immagine seguente, la classe A funge da classe base per le classi derivate B, C e 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. Eredità multipla ( Attraverso le interfacce)

In Eredità multiple , una classe può avere più di una superclasse ed ereditare funzionalità da tutte le classi genitori. Tieni presente che Java lo fa non supporto molteplici eredità con le classi. In Java, possiamo ottenere più eredità solo attraverso Interfacce . Nell'immagine seguente, la Classe C deriva dalle interfacce A e B.

Eredità multipla

// 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. Eredità ibrida

È un mix di due o più dei suddetti tipi di eredità. Poiché Java non supporta l'ereditarietà multipla con le classi, anche l'ereditarietà ibrida che coinvolge l'ereditarietà multipla non è possibile con le classi. In Java, possiamo ottenere l'ereditarietà ibrida solo attraverso Interfacce se vogliamo coinvolgere l'ereditarietà multipla per implementare l'ereditarietà ibrida.
Tuttavia, è importante notare che l'ereditarietà ibrida non richiede necessariamente l'uso esclusivo dell'ereditarietà multipla. Può essere ottenuto attraverso una combinazione di ereditarietà multilivello ed ereditarietà gerarchica con classi, ereditarietà gerarchica e singola con classi. Pertanto, è effettivamente possibile implementare l'ereditarietà ibrida utilizzando solo le classi, senza fare affidamento sul tipo di ereditarietà multipla.

Eredità ibrida

Java IS-Un tipo di relazione

IS-A è un modo per dire: questo oggetto è un tipo di quell'oggetto. Vediamo come viene utilizzata la parola chiave extends per ottenere l'ereditarietà.

gestione delle stringhe in c++

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

Ora, sulla base dell'esempio precedente, in termini orientati agli oggetti, è vero quanto segue: -

• Il Sistema Solare è la superclasse della classe Terra.
• SolarSystem è la superclasse della classe Marte.
• Terra e Marte sono sottoclassi della classe SolarSystem.
• Moon è la sottoclasse delle classi Terra e Sistema Solare.

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>

Cosa si può fare in una sottoclasse?

Nelle sottoclassi possiamo ereditare i membri così come sono, sostituirli, nasconderli o integrarli con nuovi membri:

• I campi ereditati possono essere utilizzati direttamente, proprio come qualsiasi altro campo.
• Possiamo dichiarare nuovi campi nella sottoclasse che non sono nella superclasse.
• I metodi ereditati possono essere utilizzati direttamente così come sono.
• Possiamo scriverne uno nuovo esempio metodo nella sottoclasse che ha la stessa firma di quello nella superclasse, quindi prevalente it (come nell'esempio sopra, accordare() il metodo viene sovrascritto).
• Possiamo scriverne uno nuovo statico metodo nella sottoclasse che ha la stessa firma di quello nella superclasse, quindi nascondersi Esso.
• Possiamo dichiarare nuovi metodi nella sottoclasse che non si trovano nella superclasse.
• Possiamo scrivere un costruttore di sottoclasse che invoca il costruttore della superclasse, implicitamente o utilizzando la parola chiave super .

Vantaggi dell'ereditarietà in Java:

1. Riutilizzabilità del codice: l'ereditarietà consente il riutilizzo del codice e riduce la quantità di codice da scrivere. La sottoclasse può riutilizzare le proprietà e i metodi della superclasse, riducendo la duplicazione del codice.
2. Astrazione: l'ereditarietà consente la creazione di classi astratte che definiscono un'interfaccia comune per un gruppo di classi correlate. Ciò promuove l'astrazione e l'incapsulamento, rendendo il codice più semplice da mantenere ed estendere.
3. Gerarchia di classi: l'ereditarietà consente la creazione di una gerarchia di classi, che può essere utilizzata per modellare oggetti del mondo reale e le loro relazioni.
4. Polimorfismo: l'ereditarietà consente il polimorfismo, ovvero la capacità di un oggetto di assumere più forme. Le sottoclassi possono sovrascrivere i metodi della superclasse, il che consente loro di modificare il proprio comportamento in modi diversi.

Svantaggi dell'ereditarietà in Java:

1. Complessità: l'ereditarietà può rendere il codice più complesso e più difficile da comprendere. Ciò è particolarmente vero se la gerarchia di ereditarietà è profonda o se vengono utilizzate più eredità.
2. Stretto accoppiamento: l'ereditarietà crea uno stretto accoppiamento tra la superclasse e la sottoclasse, rendendo difficile apportare modifiche alla superclasse senza influenzare la sottoclasse.

Conclusione

Controlliamo alcuni punti importanti dell'articolo menzionati di seguito:

finestra.apri javascript

• Superclasse predefinita : Tranne Oggetto classe, che non ha superclasse, ogni classe ha una ed una sola superclasse diretta (ereditarietà singola). In assenza di qualsiasi altra superclasse esplicita, ogni classe è implicitamente una sottoclasse della classe Object.
• La superclasse può essere solo una: Una superclasse può avere un numero qualsiasi di sottoclassi. Ma una sottoclasse può avere solo uno superclasse. Questo perché Java non supporta eredità multiple con classi. Sebbene con le interfacce, Java supporta più eredità.
• Costruttori ereditari: Una sottoclasse eredita tutti i membri (campi, metodi e classi nidificate) dalla sua superclasse. I costruttori non sono membri, quindi non vengono ereditati dalle sottoclassi, ma il costruttore della superclasse può essere invocato dalla sottoclasse.
• Eredità dei membri privati: Una sottoclasse non eredita i membri privati ​​della sua classe genitore. Tuttavia, se la superclasse dispone di metodi pubblici o protetti (come getter e setter) per accedere ai suoi campi privati, questi possono essere utilizzati anche dalla sottoclasse.

Domande frequenti in Ereditarietà

1. Cos'è l'ereditarietà Java?

L'ereditarietà è un concetto di OOP in cui una classe eredita da un'altra classe che può riutilizzare i metodi e i campi della classe genitore.

2. Quali sono i 4 tipi di ereditarietà in Java?

Esistono Singoli, Multipli, Multilivello, Gerarchici e Ibridi

3. A cosa serve la parola chiave extend?

La parola chiave Extend viene utilizzata per ereditare una classe in un'altra.

4. Qual è un esempio di ereditarietà in Java?

Di seguito è riportato un esempio reale di ereditarietà in Java:

Consideriamo un gruppo di veicoli. È necessario creare classi per autobus, auto e camion. I metodi FuelAmount(), Capability() e ApplyBrakes() saranno gli stessi per tutte e tre le classi.

Riferimenti utilizzati:

1. Head First Java di Kathy Sierra e Bert Bates
2. Java: una guida per principianti di Herbert Schildt
3. Java: il riferimento completo di Herbert Schildt
4. Java efficace di Joshua Bloch
5. Java: le parti buone di Jim Waldo.