Panoramica sull'ereditarietà in Java
A differenza di altri linguaggi di programmazione come C, Java offre un meccanismo mediante il quale membri di dati e metodi di una classe sono ereditati da un'altra classe. Questo processo è noto come Ereditarietà in Java Per ereditare da una classe, viene utilizzata la parola chiave "extends". L'ereditarietà in Java consente la riusabilità del codice in modo che una classe debba solo scrivere le caratteristiche uniche e il resto del codice possa essere esteso dall'altra classe. La classe che eredita dall'altra classe è nota come sottoclasse o classe figlio e la classe che viene ereditata è nota come classe genitore o superclasse. La sintassi, i tipi e l'implementazione dell'ereditarietà saranno discussi nelle sezioni seguenti.
Tipi di ereditarietà in Java
L'ereditarietà indica una relazione IS-A altrimenti nota come relazione genitore-figlio. Genitore e figlio sono già menzionati nella parte introduttiva.
Prima di passare ai tipi di ereditarietà in Java, per prima cosa, vediamo la sintassi dell'ereditarietà.
Sintassi:
class apple extends fruit
(
//methods and fields
)
Qui, apple è la sottoclasse e fruit è la classe genitore. Ciò significa che la mela ha alcune proprietà uniche e ha anche le proprietà del frutto.
Esistono 4 diversi tipi di ereditarietà in Java.
- Eredità singola
- Ereditarietà multilivello
- Eredità gerarchica
- Ereditarietà multipla (con l'aiuto di interfacce)
Ora, vediamo ciascuno di essi in dettaglio.
1. Eredità singola
Una classe che estende solo una classe. Nel seguente esempio, la classe apple estende il frutto della classe.
ovvero Fruit è la superclasse e Apple è la sottoclasse che estende le proprietà e il comportamento della classe Fruit.
Segue la dimostrazione della singola eredità in Java.
Codice:
//Java program to demonstrate Single Inheritance
//parent class
class fruit (
public void taste()
(
System.out.println("Fruits are sweet");
)
)
//child class of fruit
class apple extends fruit
(
public void shape()
(
System.out.println("Apple is round");
)
)
public class InheritanceExample
(
public static void main(String() args) (
apple fr = new apple(); //object of child class
fr.taste(); //call method of parent class
fr.shape(); //call method of child class
)
)
Produzione:
2. Ereditarietà multilivello
In questo tipo di ereditarietà, una classe verrà estesa da un'altra classe e la classe derivata fungerà da classe base per un'altra classe.
Ad esempio, nella figura, una classe a quattro ruote è la classe genitore e l'auto è la classe derivata della classe a quattro ruote. Allo stesso tempo, l'auto di classe può essere la classe base per la classe Maruti.
Codice:
//Java program to demonstrate Multiple Inheritance
//parent class
class fourwheeler (
public void wheels()
(
System.out.println("I have 4 wheels");
)
)
//child class of fourwheeler and parent of maruti
class car extends fourwheeler
(
public void type()
(
System.out.println("I'm a car");
)
)
//child class of car class
class maruti extends car
(
public void comp()
(
System.out.println("I'm maruti");
)
)
public class InheritanceExample
(
public static void main(String() args) (
maruti fr = new maruti(); //object of child class
fr.wheels();
fr.type();
fr.comp();
)
)
Produzione:
3. Eredità gerarchica
Nell'eredità gerarchica, una classe base ha più di una classe figlio, il che significa che le proprietà di una classe vengono acquisite da classi diverse.
Ad esempio, un veicolo di classe ha sottoclassi auto, biciclette, scooter.
Codice:
//Java program to demonstrate Hierarchical Inheritance
//parent class
class vehicle (
public void wheels()
(
System.out.println("I have wheels");
)
)
//first child class of vehicle class
class bike extends vehicle
(
public void countwl()
(
System.out.println("I am a bike and has 2 wheels");
)
)
//second child class of vehicle class
class car extends vehicle
(
public void countwlc()
(
System.out.println("I am a car and has 4 wheels");
)
)
//third child class of vehicle class
class scooter extends vehicle
(
public void countwls()
(
System.out.println("I am a scooter and has 2 wheels");
)
)
public class InheritanceExample
(
public static void main(String() args) (
scooter sc = new scooter(); //object of scooter class
sc.wheels();
sc.countwls();
car c = new car(); //object of car class
c.wheels();
c.countwlc();
bike b= new bike();//object of bike class
b.wheels();
b.countwl();
)
)
Produzione:
4. Ereditarietà multipla
Eredità multiple in java è un tipo di eredità in cui una classe ha più di una classe genitore.
Ad esempio, la classe C acquisisce le proprietà sia della classe A che della classe B.
Ma, in Java, l'ereditarietà multipla può essere ottenuta solo utilizzando le interfacce.
Supponiamo che siano implementate più eredità come altri tipi di ereditarietà, un errore in fase di compilazione può verificarsi come segue.
Codice:
//Java program to demonstrate multiple Inheritance
//parent class
class A
(
public void hh()
(
System.out.println("A is working");
)
)
class B
(
public void hh()
(
System.out.println("B is working");
)
)
class C extends A, B
(
//code for class c
)
public class InheritanceExample
(
public static void main(String() args) (
C sc = new C(); //object of C class
C.hh();
)
)
Qui, l'output non verrà visualizzato in quanto contiene un errore di compilazione.
Importanza dell'ereditarietà in Java
- Riusabilità del codice: l' ereditarietà aiuta a ridurre la riscrittura del codice. cioè il codice può essere riutilizzato da altre classi e la classe figlio deve solo scrivere le sue proprietà uniche. Ciò riduce il consumo di tempo e la complessità del codice.
- Per l'override del metodo: un metodo già presente nella classe genitore viene dichiarato dalla classe figlio, quindi è noto come metodo prioritario.
Sintassi:
final class A
(
. . .
)
Class B extends A
(
. . .
)
In questo caso, verrà generato un errore che dice "Impossibile ereditare dalla A finale".
Conclusione
L'ereditarietà in Java è una proprietà mediante la quale le proprietà e il comportamento di una classe vengono acquisiti da un'altra classe al fine di fornire riusabilità del codice. Esistono diversi tipi di ereditarietà in Java come l'ereditarietà singola, l'ereditarietà multi-livello, l'ereditarietà gerarchica e l'ereditarietà multipla in Java. In questo documento vengono trattati diversi aspetti importanti dell'eredità.
Articoli consigliati
Questa è una guida all'ereditarietà in Java. Qui discutiamo dell'importanza e dei diversi tipi di ereditarietà in Java insieme a sintassi, esempi e implementazione del codice. Puoi anche consultare i seguenti articoli per saperne di più-
- JScrollPane in Java
- Sessioni in PHP
- Ordinamento in Java
- Che cos'è Java Garbage Collector?
- Strumenti di distribuzione Java
- Sostituzione in Java
- Eredità in PHP