Tipi di ereditarietà in Java con esempi

L'ereditarietà in Java consente agli sviluppatori di creare nuove classi con quelle esistenti. Consente la riutilizzabilità del codice. L'ereditarietà può essere sia un'ereditarietà singola che un'ereditarietà multilivello. L'ereditarietà riduce la ridondanza del codice, lo rende più leggibile e gestibile e funge quindi da strumento per aumentare la qualità del software.

Importanza dell'eredità

In Java, l'ereditarietà è il metodo con cui una classe acquisisce le proprietà e le funzionalità di un'altra classe. L'ereditarietà consente di risparmiare tempo, ridurre la ridondanza, rendere il codice più leggibile, comprensibile e gestibile e funge da strumento per aumentare la qualità del software. L'ereditarietà ha molte applicazioni vitali nel linguaggio di programmazione Java L'ereditarietà consente agli sviluppatori di creare nuove classi utilizzando quelle esistenti Le classi ereditate fungono da modelli o progetti L'ereditarietà fornisce la riutilizzabilità del software Le classi ereditate agiscono come una relazione genitore-figlio I metodi ereditati rendono indipendenti le classi ereditate Gli attributi ereditati rendono le classi ereditate indipendente.

La gerarchia di eredità denota una relazione padre-figlio tra i diversi livelli di eredità. Il livello più alto di eredità è noto come "Super Class" o "Parent Class".

Impara i corsi di sviluppo software online dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Sintassi dell'ereditarietà Java

class Nome-sottoclasse estende il nome-superclasse

{

//metodi e campi

}

La parola chiave estesa indica che stai creando una nuova classe che eredita tutte le funzionalità dal suo genitore. Significa “aumentare” o valorizzare ciò che c'è già.

Esempio: nell'esempio di ereditarietà seguente, la classe Bicycle è una classe base, la classe MountainBike è una classe derivata che estende la classe Bicycle e la classe Test è una classe pilota per eseguire un programma.

Ingresso:

// Programma Java per illustrare il

// concetto di eredità

// classe base

classe Bicicletta {

// la classe Bicycle ha due campi

attrezzi pubblici;

velocità interna pubblica;

// la classe Bicycle ha un costruttore

bicicletta pubblica(int gear, int speed)

{

questo.ingranaggio = ingranaggio;

questa.velocità = velocità;

}

// la classe Bicycle ha tre metodi

public void applyBrake(int decrement)

{

velocità -= decremento;

}

public void speedUp(int incremento)

{

velocità += incremento;

}

// metodo toString() per stampare le informazioni di Bicycle

public String toString()

{

ritorno ("Il numero di ingranaggi è " + ingranaggio + "\n"

+ “la velocità della bicicletta è ” + la velocità);

}

}

// classe derivata

classe MountainBike estende Bicicletta {

// la sottoclasse MountainBike aggiunge un altro campo

public int seatHeight;

// la sottoclasse MountainBike ha un costruttore

MountainBike pubblica(int gear, int speed,

int startHeight)

{

// invocando il costruttore della classe base (bicicletta).

super(marcia, velocità);

seatHeight = altezza iniziale;

}

// la sottoclasse MountainBike aggiunge un altro metodo

public void setHeight(int newValue)

{

seatHeight = nuovoValore;

}

// sovrascrivere il metodo toString()

// di Bicycle per stampare maggiori informazioni

@Esegui l'override della stringa pubblica suString()

{

return (super.toString() + "\nl'altezza del sedile è "

+ altezza del sedile);

}

}

// classe di guida

prova di classe pubblica {

public static void main(String args[])

{

MountainBike mb = nuova MountainBike(3, 100, 25);

System.out.println(mb.toString());

}

}

Uscita :

Il numero di marce è 3

la velocità della bicicletta è 100

l'altezza del sedile è 25

Termini usati nell'ereditarietà

• Classe : una classe è un gruppo di oggetti che hanno proprietà comuni. È come un manuale di istruzioni o un progetto da cui vengono create altre singole unità.
• Sottoclasse/classe figlio : una sottoclasse è una classe che eredita l'altra classe. Viene anche chiamata classe derivata, classe estesa o classe figlia.
• Superclasse /classe principale: la superclasse è la classe da cui una sottoclasse eredita le caratteristiche. Viene anche chiamata classe base o classe genitore.
• Riutilizzabilità : la riutilizzabilità è un principio di progettazione chiave nella programmazione orientata agli oggetti. Significa che puoi riutilizzare i campi e i metodi delle classi esistenti quando ne crei di nuovi invece di ripetere te stesso ogni volta con la codifica individuale.

Corsi e articoli popolari sull'ingegneria del software

Tipi di eredità Java

1. Ereditarietà singola

Ereditarietà singola significa che una classe ne estende un'altra o implementa più interfacce contemporaneamente con lo stesso modificatore di accesso o senza modificatore di accesso, cioè pubblico o privato. La sottoclasse creata eredita tutte le funzioni membro e i membri dati dalla sua base/superclasse ad eccezione di quelli dichiarati come privati, e a questi membri possono accedere i membri e gli amici della sottoclasse.

Fare riferimento all'esempio seguente:

Ingresso:

// Programma Java per illustrare il

// concetto di eredità singola

importa java.io.*;

importare java.lang.*;

importa java.util.*;

classe uno {

public void print_A()

{

System.out.println(“A”);

}

}

la classe due estende uno {

public void print_for() { System.out.println("per"); }

}

// Classe pilota

classe pubblica Principale {

public static void main(String[] args)

{

due g = nuovi due();

g.stampa_A();

g.stampa_per();

g.print_Apple();

}

}

Uscita :

UN

Per

Mela

2. Ereditarietà multilivello

L'ereditarietà multilivello è quella in cui c'è una catena di eredità. n In Java, una classe derivata non può accedere direttamente ai membri del nonno. Quando hai una gerarchia di ereditarietà come questa in cui ogni nuovo livello eredita da un'altra persona o cosa prima di loro (o viceversa), diventa difficile per un dato oggetto in entrambi i gruppi perché sono in grado di usare solo ciò che è disponibile nei rispettivi rispettivi livelli; rendendo quindi il debug più noioso del necessario!

Ingresso:

// Programma Java per illustrare il

// concetto di ereditarietà multilivello

importa java.io.*;

importare java.lang.*;

importa java.util.*;

classe uno {

public void print_Inheritance()

{

System.out.println(“Ereditarietà”);

}

}

la classe due estende uno {

public void print_in() { System.out.println("in"); }

}

la classe tre estende due {

public void print_Inheritance()

{

System.out.println(“Java”);

}

}

// Classe derivata

classe pubblica Principale {

public static void main(String[] args)

{

tre g = nuovo tre();

g.print_Ereditarietà();

g.stampa_in();

g.print_Java();

}

}

Uscita :

Eredità

In

Giava

3. Ereditarietà gerarchica

Due classi in una gerarchia possono ereditare l'una dall'altra. Ad esempio, se il Cane e il Gatto rientrano entrambi sotto Animale, allora ci sarà un'eredità gerarchica con loro discendenti di quella classe.

Ingresso:

classe Animale{

void eat(){System.out.println("mangiare...");}

}

classe Cane estende Animale{

void bark(){System.out.println("abbaiare...");}

}

classe Gatto estende Animale{

void meow(){System.out.println("miagolando...");}

}

classe TestEreditarietà3{

public static void main(String args[]){

Gatto c=nuovo Gatto();

c.miao();

c.mangiare();

//c.bark();//CTError

}}

Uscita :

miagolando…

mangiare...

4. Ereditarietà multipla (tramite interfacce)

Java non supporta l'ereditarietà multipla con le classi, ma è possibile ottenerle tramite le interfacce. Nell'immagine sottostante la Classe C è derivata sia da A che da B, il che significa che condividono alcune funzionalità pur avendo implementazioni diverse per altre a seconda delle loro esigenze specifiche nell'esecuzione del codice o nell'adempimento dei metodi richiesti dagli utenti (i).

Ingresso:

// Programma Java per illustrare il

// concetto di ereditarietà multipla

importa java.io.*;

importare java.lang.*;

importa java.util.*;

interfaccia uno {

public void print_eye();

}

interfaccia due {

public void print_for();

}

interfaccia tre estende uno, due {

public void print_eye();

}

class child implementa tre {

@Override public void print_eye()

{

System.out.println(“Occhio”);

}

public void print_for() { System.out.println("per"); }

}

// Classe derivata

classe pubblica Principale {

public static void main(String[] args)

{

figlio c = nuovo figlio();

c.print_eye();

c.stampa_per();

c.print_eye();

}

}

Uscita :

Occhio

per

Occhio

5. Ereditarietà ibrida (attraverso interfacce)

L'ereditarietà ibrida è un tipo di programmazione che ci consente di mescolare due o più tipi. Le classi non possono farlo da sole perché hanno solo un insieme di metodi, il che significa che abbiamo bisogno di un altro oggetto affinché tutto funzioni correttamente, ma le interfacce offrono tranquillità consentendoti di sapere come sarà il tuo programma prima che qualsiasi codice sia stato scritto !

Ingresso

(Riferimento)

Le classi A e B estendono la classe C → Ereditarietà gerarchica

La classe D estende la classe A → Ereditarietà singola

classe C

{

display vuoto pubblico()

{

System.out.println(“C”);

}

}

la classe A estende C

{

display vuoto pubblico()

{

System.out.println(“A”);

}

}

la classe B estende C

{

display vuoto pubblico()

{

System.out.println(“B”);

}

}

la classe D estende A

{

display vuoto pubblico()

{

System.out.println(“D”);

}

public static void main(String args[]){

D obj = nuovo D();

obj.disp();

}

}

Produzione:

D

Se desideri approfondire l'ereditarietà in Java e altri concetti OOP, ti consigliamo il programma Executive PG di upGrad nello sviluppo software di IIIT-Bangalore . Il corso di 13 mesi è progettato da professionisti del settore e docenti di livello mondiale per sviluppare competenze in oltre 30 strumenti e software. Comprendeva oltre 400 ore di contenuti, oltre 30 casi di studio e progetti rilevanti per il settore e oltre 10 sessioni dal vivo per aiutarti a raggiungere i risultati desiderati; Il corso offre tre specializzazioni, ovvero sviluppo full-stack, sviluppo back-end cloud e sicurezza informatica.

Prenota oggi il tuo posto nel programma!