Ereditarietà

1. Definizione di ereditarietà

Si dice che una classe A è una sottoclasse di B (e analogamente che B è una superclasse di A) quando:

• A eredita da B sia il suo stato che il suo behavior (comportamento)
• e quindi un’istanza della classe A è utilizzabile in ogni parte del codice in cui sia possibile utilizzare una istanza della classe B.

Per esempio:

classDiagram
    Persona --|> Studente : Inheritance
    note for Persona "classe base"
    note for Studente "classe derivata"

package ereditarieta;

// classe base
public class Persona {
    // attributi della classe
    private String nome;
    private String cognome;
    private String data_nascita;

    // costruttore
    // ...

    // metodi della classe
    // ...
}

// la classe Studente deriva da Persona
// => (ha accesso agli attributi e ai metodi protected e public).
public class Studente extends Persona {

    // attributi della classe
    private String matricola;

    // costruttore
    // ...

    // metodi della classe
    // ...
}

2. Visibilità

visibilità campi (dati/record) di una classe

	public	protected	(default)	private
nella classe in cui dichiarati	✅	✅	✅	✅
nello stesso package	✅	✅	✅	❌
nelle sottoclassi (anche se in package diversi)	✅	✅	❌	❌
all’esterno	✅	❌	❌	❌

3. Classe Object

Tutte le classi sono derivate dalla classe Object (def. in java.lang)

graph BT
  Rettangolo --> Object
  Quadrato --> Rettangolo

---

Object contiene l’mplementazione di default di alcuni metodi, per esempio:

• equals(Object) → boolean
  • confronta i reference dei due oggetti (come ==).
• toString() → String
  • restituisce la stringa corrente al reference dell’oggetto di invocazione.
• cone() → Object
  • effettua una copia (superficiale) dell’oggetto di invocazione.

Questi attributi sono ereditati da tutte le classi, ma possono essere ridefinite.

4. Instanceof

In java è possibile determinare se un oggetto $o$ appartiene o no ad una classe $c$ con l’operatore instanceof

$$o \ \ instanceof \ \ c$$

dovre:

• $o$ → oggetto;
• $c$ → classe;

restituisce:

• true → se l’oggetto $o$ è di tipo $c$.
• false → altrimenti.

5. Esempio Completo

classDiagram
    Rettangolo --|> Quadrato : Inheritance
    class Rettangolo {
        - base: int
        - altezza: int
        + Rettangolo()
        + Rettangolo(int, int)
        + perimetro() int
        + area() int
        + getAltezza() int
        + getBase() int
    }
    class Quadrato{
        + Quadrato()
        + Quadrato(int)
        + circonferenza() double
        + perimetro() int
    }

package Java.ereditarieta_esempio_completo;

// classe base
public class Rettangolo {
    // attributi
    private int base;
    private int altezza;

    // costruttore senza parametri
    public Rettangolo() {
        this.base = 0;
        this.altezza = 0;
    }

    // costruttore con 2 parametri
    public Rettangolo(int base, int altezza) {
        this.base = base;
        this.altezza = altezza;
    }

    // metodo
    public int perimetro() {
        return 2*base + 2*altezza;
    }

    // metodo
    public int area() {
        return base * altezza;
    }

    // metodi getter
    public int getBase() {
        return base;
    }
    public int getAltezza() {
        return altezza;
    }
}

package Java.ereditarieta_esempio_completo;

// classe derivata
public class Quadrato extends Rettangolo{
    // in questo caso questa classe non ha attributi
    // perchè già tutti contenuti nella classe base

    // costruttore senza parametri
    public Quadrato() {
        super();
    }

    // costruttore con un parametro
    public Quadrato(int lato){
        super(lato, lato);
    }

    // metodo
    public double circonferenza() {
        return getAltezza()*3.14;
    }

    // metodo
    public int perimetro() {
        // invoca il metodo perimetro della classe base
        return super.perimetro();
    }
}

package Java.ereditarieta_esempio_completo;

public class Main {
    public static void main(String[] args) {
        Rettangolo r1 = new Rettangolo(5, 7);
        Quadrato q1 = new Quadrato(4);

        System.out.println(r1.area());  // area del rettangolo
        System.out.println(q1.area());  // area del quadrato

        System.out.println(r1 instanceof Rettangolo); // -> true
        System.out.println(q1 instanceof Quadrato); // -> true
        System.out.println(q1 instanceof Rettangolo); // -> true
        System.out.println(r1 instanceof Quadrato); // -> false
        System.out.println(q1 instanceof Object); // -> true
    }
}

6. Quiz

Mettiti alla prova

0/10 risposte

1. Cos'è l'ereditarietà in Java?

   ALa copia del codice tra classiBIl meccanismo con cui una classe eredita attributi e metodi da un'altraCUn tipo di cicloDUna variabile globale

2. Quale keyword permette di creare una sottoclasse?

   AimplementsBinheritsCextendsDsuper

3. La classe da cui si eredita si chiama:

   ASottoclasseBClasse finaleCSuperclasseDClasse statica

4. Una sottoclasse può:

   ASolo usare i metodi della superclasseBAggiungere nuovi attributi e metodiCEliminare la superclasseDEreditare solo i costruttori

5. Quale keyword richiama il costruttore della superclasse?

   AthisBparentCbaseDsuper

6. Tutte le classi Java derivano implicitamente da:

   ASystemBMainCObjectDClassBase

7. L'operatore instanceof serve per:

   ACreare oggettiBVerificare il tipo di un oggettoCCopiare oggettiDDistruggere oggetti

8. Un oggetto Quadrato è anche un Rettangolo?

   ANoBSolo se castatoCSì, se Quadrato estende RettangoloDSolo con protected

9. Quale visibilità permette accesso alle sottoclassi?

   AprivateBprotectedCdefaultDstatic

10. Ridefinire un metodo della superclasse si chiama:

    AOverloadingBOverridingCCastingDBinding

Controlla le risposte

7. Esercizi

Ereditarietà di classi in linguaggio Java:esercizi risolti

7.1 Ereditarietà base

Creare:

• una classe Veicolo
• una classe Auto che estende Veicolo

Classe Veicolo:

• attributi: marca, velocità
• metodo: stampaInfo()

Classe Auto:

• attributo: numeroPorte

Creare un Main che istanzia un oggetto Auto.

7.2 Uso di super

Creare una classe:

• Animale con attributo nome.

Creare una sottoclasse:

• Cane.

Requisiti:

• costruttore con parametro nome
• inizializzazione tramite super(…).

7.3 Override

Creare:

• classe Forma con metodo area().
• classi Cerchio e Rettangolo.

Ogni sottoclasse deve ridefinire il metodo area().

Stampare l’area usando variabili di tipo Forma.

7.4 Uso di instanceof

Dato un riferimento:

• Animale a = new Cane();

Verificare:

• se è un Cane
• se è un Animale
• se è un Object

7.5 Ereditarietà multilivello

Realizzare la gerarchia:

• Persona → Studente → StudenteUniversitario

Ogni classe deve aggiungere:

• almeno un attributo
• almeno un metodo.