Java/Ereditarietà
Ereditarietà
[modifica | modifica sorgente]La nozione di ereditarietà presente nei linguaggi object-oriented si ritrova anche in Java.
L'ereditarietà è un concetto fondamentale della programmazione OOP (Object Oriented Programming). Nasce per creare delle classi, con maggiori dettagli, da classi più generalizzate. Le classi "figlie", create da una classe più generale, erediteranno attributi e metodi della classe da cui derivano che potranno essere utilizzati dalla classe derivata.
Per la dichiarazione di una classe derivata si utilizza la parola chiave extends nel seguente modo:
class nomeClasseDerivata extends nomeClasseBase{
//...
}
Per il resto la classe derivata manterrà la struttura di una classe normale.
Overriding
[modifica | modifica sorgente]L'overriding (in italiano sovrascrittura) corrisponde a un'operazione completamente diversa rispetto all'overloading: consente di ridefinire un metodo in una sottoclasse, in modo che il metodo originale e quello che lo ridefinisce abbiano necessariamente la stessa firma, e solo a tempo di esecuzione si determina quale dei due deve essere eseguito. Ad esempio:
public class ClassePadre {
public void print(){
System.out.println("Classe padre");
}
}
class ClasseFiglio extends ClassePadre{
@Override
public void print() {
System.out.println("Classe figlio");
}
public static void main(String[] args) {
ClassePadre padre = new ClassePadre();
ClassePadre figlio = new ClasseFiglio();
padre.print();
figlio.print();
}
}
La classe Figlio ridefinisce il metodo print() della classe padre e ne cambia il comportamento.
Classi astratte e interfacce
[modifica | modifica sorgente]è possibile scrivere classi Java fatte apposta per essere estese. Per fare ciò, è sufficiente apporre il modificatore
abstract prima del nome della classe. Questo risulta molto utile per separare l'interfaccia di un oggetto
dalla sua implementazione.
Il modificatore abstract può essere utilizzato anche con i metodi; esso indica che il codice del metodo
deve essere obbligatoriamente fornito da una sottoclasse:
public abstract class Animale {
public abstract String getSpecie();
}
Si noti che il metodo non ha un corpo vuoto; piuttosto, il metodo non ha un corpo.
I metodi astratti possono essere definiti solo da classi astratte.
Il Java permette di definire le cosiddette interfacce. Un'interfaccia si definisce analogamente ad una classe astratta, ma ha i seguenti requisiti aggiuntivi:
- non può contenere campi di istanza;
- tutti i suoi metodi sono pubblici e astratti.
La parola-chiave da utilizzare non è class, ma interface.
Per questo, i modificatori public e static per i campi, e public ed abstract per i metodi, possono essere omessi. Analogamente, poiché un'interfaccia è sempre un tipo astratto, il modificatore abstract può essere omesso quando la si definisce.
Ereditarietà multipla
[modifica | modifica sorgente]Per motivi di sicurezza e di chiarezza del codice, il Java non permette l'ereditarietà multipla tra classi. Una classe può ereditare al massimo da un'altra classe, ma anche da un numero arbitrario di interfacce.
super
[modifica | modifica sorgente]Se non c’è nella sottoclasse una chiamata esplicita al costruttore della superclasse, il complilatore aggiunge automaticamente il codice: super() che invoca il default constructor o un costruttore senza parametri. Se non fosse presente, genererebbe un errore in compilazione. Ordine di esecuzione dei costruttori: prima i costruttori delle superclassi, poi eventuali inizializzatori, infine il costruttore.
Ereditarietà e sottotipi
[modifica | modifica sorgente]La nozione di sottotipo non coincide necessariamente con quella di sottoclasse. Per maggiori informazioni, si leggano le seguenti voci di Wikipedia:
Note
[modifica | modifica sorgente]
