Ereditarietà Java

In questo tutorial, impareremo a utilizzare l'ereditarietà in Java con esempi.

L'ereditarietà è una delle funzionalità principali dell'OOP (orientamento a oggetti), che ci permette di definire una nuova classe partendo da una classe esistente. Ad esempio:

class Animal
}
　　　　// eat() metodo
　　　　// sleep() metodo
}
class Dog extends Animal
}
　　　　// metodo bark()
}

In Java, usiamo il关键字extends per ereditare da una classe. In questo caso, ereditiamo la classe Dog dalla classe Animal.

Animal è la superclasse (classe padre o base), mentre Dog è la sottoclasse (classe figlia o derivata). La sottoclasse herita i campi e i metodi della superclasse.

relazione is-a

L'ereditarietà èis-aRelazione, usiamo l'ereditarietà solo quando esiste una relazione is-a tra due classi.

Ecco alcuni esempi:

• L' auto è un veicolo.

• L' arancia è una frutta.

• L' chirurgo è un medico.

• Il cane è un animale.

Esempio 1: ereditarietà Java

class Animal {
　　　public void eat() {
　　　　　　System.out.println("Posso mangiare");
　　　}
　　　public void sleep() {
　　　　　　System.out.println("Posso dormire");
　　　}
}
class Dog extends Animal {
　　　public void bark() {
　　　　　　System.out.println("Io posso abbrivare");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1 = new Dog();
　　　　　　dog1.eat();
　　　　　　dog1.sleep();
　　　　　　dog1.bark();
　　　}
}

Risultato di output

Posso mangiare
Posso dormire
I　can　bark

In questo caso, abbiamo ereditato la sottoclasse Dog dal superclasse Animal. La classe Dog ha ereditato i metodi eat() e sleep() dalla classe Animal.

Quindi, gli oggetti della classe Dog possono accedere ai membri della classe Dog e della classe Animal.

Chiave di protezione

Abbiamo imparato i modificatori di accesso private e public nel tutorial precedente.

• I membri private possono essere acceduti solo all'interno della classe

• I membri public possono essere acceduti da qualsiasi parte

Puoi anche impostare metodi e campi come protected, i membri protetti possono accedervi

• All'interno della classe

• Nella sua sottoclasse

• Nello stesso pacchetto

Questo è un riassunto delle modificatori di accesso che possono essere utilizzati.

Esempio 2: chiave di protezione

class Animal {
　　　protected String type;
　　　private String color;
　　　public void eat() {
　　　　　　System.out.println("Posso mangiare");
　　　}
　　　public void sleep() {
　　　　　　System.out.println("Posso dormire");
　　　}
　　　public String getColor(){
　　　　　　return color;
　　　}
　　　public void setColor(String col){
　　　　　　color = col;
　　　}
}
class Dog extends Animal {
　　　public void displayInfo(String c){
　　　　　　System.out.println("Sono un " + type);
　　　　　　System.out.println("Il mio colore è " + c);
　　　}
　　　public void bark() {
　　　　　　System.out.println("Io posso abbrivare");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1 = new Dog();
　　　　　　dog1.eat();
　　　　　　dog1.sleep();
　　　　　　dog1.bark();
　
　　　　　　dog1.type = "mammal";
　　　　　　dog1.setColor("nero");
　　　　　　dog1.displayInfo(dog1.getColor());　
　　　}
}

Risultato di output

Posso mangiare
Posso dormire
I　can　bark
Sono un mammifero
Il mio colore è nero

dog1.type = "mammal";

È fattibile perché le classi Animal e Main si trovano nella stessa pacchetto (lo stesso file).

Sovrascrittura di metodo Java

Dal esempio sopra, sappiamo che anche gli oggetti della sottoclasse possono accedere ai metodi della superclasse.

　Cosa succede se si definisce lo stesso metodo sia nella superclasse che nella sottoclasse?

Bene, in questo caso, il metodo nella sottoclasse sovrascrive il metodo nella superclasse. Ad esempio,

Esempio 3: esempio di sovrascrizione/sovrascrittura di metodo

class Animal {
　　　protected String type = "animal";
　　　public void eat() {
　　　　　　System.out.println("Posso mangiare");
　　　}
　　　public void sleep() {
　　　　　　System.out.println("Posso dormire");
　　　}
}
class Dog extends Animal {
　　
　　　@Override
　　　public void eat() {
　　　　　　System.out.println("Io mangio cibo per cani");
　　　}
　　　public void bark() {
　　　　　　System.out.println("Io posso abbrivare");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1 = new Dog();
　　　　　　dog1.eat();
　　　　　　dog1.sleep();
　　　　　　dog1.bark();
　　　}
}

Risultato di output

Io mangio cibo per cani
Posso dormire
I　can　bark

In questo caso, eat() appare sia nella superclasse Animal che nella sottoclasse Dog. Abbiamo creato un oggetto della sottoclasse Dog chiamato dog1.

Quando si chiama il metodo eat() con l'oggetto dog1, viene chiamato il metodo interno di Dog senza chiamare il metodo dello stesso nome della superclasse. Questo si chiama sovrascrizione del metodo.

Nel programma sopra, abbiamo utilizzato l'annotazione @Override per informare il compilatore che stiamo sovrascrivendo un metodo. Tuttavia, non è obbligatorio. In un prossimo tutorial, esploreremoSovrascrittura di metodoParola chiave super Java

Se si desidera chiamare il metodo eat() dalla sottoclasse di Animal, utilizzare la chiave di super.

Esempio 4: chiave di super

class Animal {
　　　public Animal() {
　　　　　System.out.println("Sono un animale");
　　　}
　　　public void eat() {
　　　　　System.out.println("Posso mangiare");
　　　}
}
class Dog extends Animal {
　　　public Dog(){
　　　　　　super();
　　　　　　System.out.println("Sono un cane");
　　　}
　　@Override
　　public void eat() {
　　　　　super.eat();
　　　　　System.out.println("Io mangio cibo per cani");
　　}
　　　public void bark() {
　　　　　　System.out.println("Io posso abbrivare");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog dog1 = new Dog();
　　　　　　dog1.eat();
　　　　　　dog1.bark();
　　　}
}

Risultato di output

Sono un animale
Sono un cane
Posso mangiare
Io mangio cibo per cani
I　can　bark

I can bark

Qui abbiamo utilizzato la parola chiave super per chiamare il costruttore tramite super(). Inoltre, chiamiamo il metodo eat() della superclasse Animal tramite super.eat().Attenzione: la differenza tra il chiamare il costruttore e il metodo super. Per ulteriori informazioni, visitareParola chiave super Java

.

Tipi di ereditarietà

• Ci sono cinque tipi di ereditarietà. Ereditarietà singola

• -La classe B eredita solo dalla classe A. Ereditarietà multi-level

• -La classe B eredita dalla classe A, quindi la classe C eredita dalla classe B. Ereditarietà gerarchica

• -La classe A è il superclasse di B, C e D. Ereditarietà multipla

• -La classe C eredita dall'interface A e si estende B. Ereditarietà mista-Due o piùEreditata

Mista.

Java non supporta l'ereditarietà multipla e l'ereditarietà mista attraverso le classi. Tuttavia, possiamo implementare l'ereditarietà multipla in Java attraverso gli interface. Studieremo gli interface nei capitoli successivi.

• Perché utilizzare l'ereditarietà?

• L'uso più importante è la riutilizzabilità del codice. Il codice esistente nel superclasse non deve essere ri scritto nel sottoclasse. Inizieremo a studiare ulteriori informazioni sulla polimorfismo nei capitoli successivi.