Ereditarietà

Progettazione e Sviluppo del Software

C.D.L. Tecnologie dei Sistemi Informatici

Danilo Pianini — `danilo.pianini@unibo.it`

Gianluca Aguzzi — `gianluca.aguzzi@unibo.it`

Angelo Filaseta — `angelo.filaseta@unibo.it`

Compiled on: 2025-12-05 — versione stampabile

back

Outline

Goal della lezione

Illustrare il riuso via ereditarietà
Introdurre i vari meccanismi collegati all’ereditarietà

Argomenti

Estensione di classi: extends
Livello d’accesso protected
Overriding dei metodi
Gestione dei costruttori e chiamate super
Il modificatore final su classi e metodi

Riuso via ereditarietà

Ereditarietà

È un meccanismo che consente di definire una nuova classe specializzandone una esistente, ossia

“ereditando” i suoi campi e metodi, quindi riusando codice già scritto e testato
- è ortogonale al discorso di “visibilità”: membri privati, seppur non visibili, sono comunque ereditati
estendendo attraverso
- (A) modifica di metodi (sovrascrittura/overriding) e/o
- (B) aggiunta di campi/metodi

Scenari di riuso ed estensione

Data una classe, realizzarne un’altra con caratteristiche solo in parte diverse (o nuove)
- ad esempio, data una lampadina (Lamp), realizzare un televisore (Tv)
- SOTTOCASO: stessa cosa, ma senza disporre dei sorgenti della classe originaria (p.e., la classe di partenza è di libreria)
  - Non c’è alcuna differenza rispetto al primo caso: quello che conta in generale è il bytecode, non il sorgente
Data una classe, crearne una più specializzata
- ad esempio, a partire da una lampadina (SimpleLamp), realizzare una lampadina con controllo livello di intensità luminosa (AdvancedLamp)
- ad esempio, una classe più robusta e sicura, anche se più lenta
Creare gerarchie di classi (ossia di “comportamenti”)
- Ad esempio, una famiglia di Device diversi e specializzati

L’ereditarietà è un concetto chiave dell’OO

È connesso al meccanismo delle interfacce
È uno degli elementi chiave insieme a incapsulamento e interfacce
Non riguarda solo il riuso di codice, ma influenza anche il polimorfismo conseguente

Solito approccio

Illustreremo i meccanismi base attraverso semplici classi
Successivamente recupereremo l’importanza nei casi reali
Utilizzeremo l’idea di contatore

Esempio base: `Counter`

public class Counter {

	private int value;

	public Counter(final int initialValue) {
		this.value = initialValue;
	}

	public void increment() {
		this.value++;
	}

	public int getValue() {
		return this.value;
	}
}

Uso della classe `Counter`

public class UseCounter {
	public static void main(String[] s) {
		final Counter c = new Counter(0);

		System.out.println(c.getValue()); // 0
		c.increment();
		c.increment();
		System.out.println(c.getValue()); // 2
	}
}

Una nuova classe: `MultiCounter`

potrebbe essere implementata a partire dal codice sorgente di Counter
rispetto a Counter, offre un metodo multiIncrement(int)

public class MultiCounter {

    private int value;

    public MultiCounter(final int initialValue) {
        this.value = initialValue;
    }

    public void increment() {
        this.value++;
    }

    public int getValue() {
        return this.value;
    }

    /* Nuovo metodo */
    public void multiIncrement(final int n) {
        for (int i = 0; i < n; i++) {
            this.increment();
        }
    }
}

Uso della classe `MultiCounter`

public class UseMultiCounter {
    public static void main(String[] s) {
        final MultiCounter mc = new MultiCounter(10);
        System.out.println(mc.getValue()); // 10
        mc.increment();
        mc.increment();
        System.out.println(mc.getValue()); // 12
        mc.multiIncrement(10);
        System.out.println(mc.getValue()); // 22
    }
}

Versione con riuso via composizione: `MultiCounter2`

public class MultiCounter2 {

    private Counter counter;

    public MultiCounter2(final int initialValue) {
        this.counter = new Counter(initialValue);
    }

    public void increment() {
        this.counter.increment();
    }

    public int getValue() {
        return this.counter.getValue();
    }

    /* Nuovo metodo */
    public void multiIncrement(final int n) {
        for (int i = 0; i < n; i++) {
            this.counter.increment();
        }
    }
}

abbiamo riusato le funzionalità di Counter (via delega) ma non abbiamo veramente “ridotto” la quantità di codice scritto

La necessità di estendere e modificare

Una tipica situazione

È tipico nei progetti software, accorgersi di dover creare anche “versioni modificate/estese” delle classi esistenti
Appoggiarsi al “copia e incolla” per ottenere ripetizione di codice è sempre sconsigliabile (principio DRY)
- poiché tende a spargere errori in tutto il codice, e complica la manutenzione (se ciò che vogliamo modificare è sparso in N punti, dovremo prima localizzare questi N punti e poi ivi applicare la modifica)
Ottenere riuso via composizione (ossia delegazione) è in generale una ottima soluzione.. ma è possibile in alcuni casi fare meglio..

Si usa il meccanismo di ereditarietà

Definizione: class C extends D { ... }
La nuova classe C eredita campi/metodi di D
- Nota: eredita anche campi/metodi privati, ma non sono accessibili da C (la “visibilità” di un campo è ortogonale alla sua “presenza” in una classe)
- Nota: i costruttori non vengono ereditati, ma riusati implicitamente o esplicitamente
Terminologia: D superclasse, o classe base, o classe padre
Terminologia: C sottoclasse, o classe figlia, o specializzazione
Nota: non serve disporre dei sorgenti di D (basta il codice binario)

Una nuova versione di `MultiCounter`

/* Si noti la clausola extends */
public class MultiCounter extends Counter {

    /*
     * I costruttori vanno ridefiniti. Devono tuttavia richiamare 
     * quelli ereditati dalla sopraclasse
     */
    public MultiCounter(int initialValue) {
    	super(initialValue);
    }

    // increment e getValue automaticamente ereditati

    // si aggiunge multiIncrement
    public void multiIncrement(final int n) {
        for (int i = 0; i < n; i++) {
            this.increment();
        }
    }
}

Razionale

Ridefiniamo la classe `MultiCounter` come estensione di `Counter`

Definiamo il nuovo metodo multiIncrement()
Definiamo il costruttore necessario
- Il costruttore di una sottoclasse può cominciare con l’istruzione super, che chiama un costruttore (non privato) della classe padre
- Se non lo fa, si chiama il costruttore senza argomenti del padre (se c’è, altrimenti ERRORE)
- Senza costruttori, si ha al solito solo quello di default (che chiama il costruttore senza argomenti del padre)
UseMultiCounter continua a funzionare!

Il senso della definizione

Un oggetto di MultiCounter è simile ad un oggetto di Counter
- Ha i metodi increment() e getValue()
- Ha anche il campo value (che in effetti è incrementato), anche se essendo privato è inaccessibile dal codice della classe MultiCounter
Due modifiche necessarie rispetto a Counter: metodo multiIncrement() e ridefinizione del costruttore

Notazione UML per l’estensione

Arco a linea continua e punta a triangolo (vuoto/pieno) per la relazione “extends” (specializzazione)
- Stessa notazione di “realizzazione interfaccia”, a parte che quest’ultima ha linea tratteggiata
Nel caso di più classi figlie: archi raggruppati per migliorare la resa grafica

Notazione UML – versione semplificata per il design

Livello d’accesso `protected`

Motivazione: una classe figlia è un caso particolare di scope e quindi si potrebbe voler regolare la visibilità in tale scope
- Si ricordi che per il principio dell’information hiding si vuole ridurre il più possibile la “superficie visibile” per evitare una proliferazione di dipendenze
- Per motivi pratici (principalmente: riuso), può aver senso allargare la visibilità alle sottoclassi

Usabile per le proprietà d’una classe

È un livello intermedio fra public e private
Indica che la proprietà (campo, metodo, costruttore) è accessibile, oltre che dalla classe corrente, da :
- una sottoclasse (in qualsiasi package), e dalle sottoclassi delle sottoclassi (ricorsivamente)
- cavillo: anche da tutto il package (qualsiasi classe nello stess package)
In altre parole: il membro è “package-private” con visibilità estesa a tutte le classi discendenti

A cosa serve, `protected`?

Consente alle sottoclassi di accedere ad informazioni della sopraclasse che non si vogliono far vedere agli utilizzatori
Molto spesso usato a posteriori rimpiazzando un private
Molto meglio avere campi privati e getter/setter protetti

Esempio classe `BiCounter` – contatore bidirezionale

Un contatore con anche il metodo decrement
Irrealizzabile senza rendere accessibile il campo counter

Un contatore estendibile: `ExtendibleCounter`

/* Il nome ExtendibleCounter è di comodo, più propriamente
 andrebbe chiamata semplicemente Counter */

public class ExtendibleCounter {

    /* campo value protetto */
    protected int value;

    public ExtendibleCounter(final int initialValue) {
        this.value = initialValue;
    }

    public void increment() {
        this.value++;
    }

    public int getValue() {
        return this.value;
    }
}

Classe `MultiCounter`

public class MultiCounter extends ExtendibleCounter {

    public MultiCounter(final int initialValue) {
        super(initialValue);
    }

    public void multiIncrement(final int n) {
        // Ora realizzabile più efficientemente
        if (n > 0) {
            this.value = this.value + n;
        }
    }
}

Classe `BiCounter`

NB: irrealizzabile (a meno di trick come overflow) mantenendo l’interfaccia di Counter (i.e. increment + getValue) senza un rendere accessibile in scrittura alle sottoclassi il campo value (direttamente o via setter)

public class BiCounter extends ExtendibleCounter {

	public BiCounter(final int initialValue) {
		super(initialValue);
	}

	public void decrement() {
		/* Ora this.counter è accessibile */
		this.value--;
	}
}

Overriding di metodi

Estensione e modifica

Quando si crea una nuova classe per estensione, spesso non è sufficiente aggiungere nuove funzionalità
A volte serve anche modificare alcune di quelle disponibili, eventualmente anche stravolgendone il funzionamento originario
Questo è realizzabile riscrivendo nella sottoclasse uno (o più) dei metodi della superclasse (ossia, facendone l’overriding)
- Se necessario, il metodo riscritto può invocare la versione del padre usando il receiver speciale super
NB: non si confondano i termini overloading e overriding (“to preveil”, “to extend over”, “to supersede”, “to overrule”)
- Terminologicamente: override vs. overwrite (“Override: the original is not being destroyed afterwards. Overwrite: the original is being destoryed afterwards”)

Esempio

Creare un contatore che, giunto ad un certo limite, non prosegue più
- non basta aggiungere qualcosa
È necessario fare overriding del metodo increment()
Un ulteriore metodo getter ispeziona il raggiungimento del limite

Classe `LimitCounter`

public class LimitCounter extends ExtendibleCounter {

    /* Aggiungo un campo, che tiene il limite */
    protected final int limit;

    public LimitCounter(final int limit) {
        super(0);
        this.limit = limit;
    }

    public boolean isOver() {
        return this.getValue() == this.limit;
    }

    /* Overriding del metodo increment() */
    public void increment() {
        if (!this.isOver()) {
            super.increment();
        }
    }
}

Uso della classe `LimitCounter`

public class UseLimitCounter {
	public static void main(String[] s) {
		final LimitCounter c = new LimitCounter(5);
		System.out.println(c.getValue()); // 0
		System.out.println(c.isOver()); // false
		c.increment();
		c.increment();
		System.out.println(c.getValue()); // 2
		System.out.println(c.isOver()); // false
		c.increment();
		c.increment();
		c.increment();
		c.increment();
		c.increment();
		c.increment();
		c.increment();
		System.out.println(c.getValue()); // 5
		System.out.println(c.isOver()); // true
	}
}

Notazione UML

I campi/metodi protetti si annotano con un “#”
I metodi overridden si riportano anche nella sottoclasse

Uno scenario completo

Una applicazione allo scenario domotica

Elementi

Usiamo LimitCounter
Definiamo una LimitedLamp (via estensione) che contiene un contatore, e che ha un tempo di vita basato sul numero di accensioni ammesse
Un EcoDomusController si compone di $n$ LimitedLamp, e ha la possibilità di verificare se tutte le lampadine sono esaurite, e di accendere la lampadina alla quale è rimasto più tempo di vita

Note sulla soluzione

Una alternativa era far sì che EcoDomusController componesse $n$ SimpleLamp e $n$ LimitCounter
LimitedLamp realizza alcuni metodi per delegazione al suo contatore
Per ora, non prevediamo l’aspetto di interazione con l’utente

Diagramma UML complessivo

`LimitCounter`

public class LimitCounter extends ExtendibleCounter {

    private final int limit;

    public LimitCounter(final int initialValue, final int limit) {
        super(initialValue);
        this.limit = limit;
    }

    public boolean isOver() {
        return this.getDistanceToLimit() == 0;
    }

    public int getDistanceToLimit() {
        return this.limit - this.value;
    }

    public void increment() {
        if (!this.isOver()) {
            super.increment();
        }
    }
}

`SimpleLamp`

public class SimpleLamp {

	private boolean switchedOn;

	public SimpleLamp() {
		this.switchedOn = false;
	}

	public void switchOn() {
		this.switchedOn = true;
	}

	public void switchOff() {
		this.switchedOn = false;
	}

	public boolean isSwitchedOn() {
		return this.switchedOn;
	}
}

`LimitedLamp`

public class LimitedLamp extends SimpleLamp {

	private LimitCounter counter;

	public LimitedLamp(final int limit) {
		super(); // Questa istruzione è opzionale
		this.counter = new LimitCounter(0, limit);
	}

	public void switchOn() {
		if (!this.isSwitchedOn()) {
			// incremento solo se è una vera accensione
			this.counter.increment();
		}
		if (!this.counter.isOver()) {
			super.switchOn();
		}
	}

	public int getRemainingLifeTime() { // delegazione a counter
		return this.counter.getDistanceToLimit();
	}

	public boolean isOver() { // delegazione a counter
		return this.counter.isOver();
	}
}

`EcoDomusController`

public class EcoDomusController {

	/* Compongo n LimitedLamp */
	final private LimitedLamp[] lamps;

	public EcoDomusController(final int size, final int lampsLimit) {
		this.lamps = new LimitedLamp[size];
		for (int i = 0; i < size; i++) {
			this.lamps[i] = new LimitedLamp(lampsLimit);
		}
	}

	public LimitedLamp getLamp(final int position) {
		return this.lamps[position];
	}

	private LimitedLamp toBeUsedNext() {
		LimitedLamp best = null;
		for (final LimitedLamp lamp : this.lamps) {
			if (!lamp.isSwitchedOn() && 
				( best == null ||
				  lamp.getRemainingLifeTime() > best.getRemainingLifeTime())) {
				best = lamp;
			}
		}
		return best;
	}

	/* Accendo una lampadina spenta, scegliendola in modo economico */
	public void switchOnOne() {
		final LimitedLamp lamp = this.toBeUsedNext();
		if (lamp != null) {
			lamp.switchOn();
		}
	}

	/* Verifico se sono tutti accesi */
	public boolean allOver() {
		for (final LimitedLamp lamp : this.lamps) {
			if (!lamp.isOver()) {
				return false;
			}
		}
		return true;
	}

	public String toString() {
		String s = "";
		for (final LimitedLamp lamp : this.lamps) {
			s += (lamp.isSwitchedOn() ? "on" : "off");
			s += "(" + lamp.getRemainingLifeTime() + ")" + " | ";
		}
		return s;
	}
}

`UseEcoDomusController`

public class UseEcoDomusController {
	public static void main(String[] s) {
		// Simulazione sessione di lavoro
		final EcoDomusController controller;
		controller = new EcoDomusController(5, 10);
		System.out.println(controller);
		// off(10) | off(10) | off(10) | off(10) | off(10) |
		final LimitedLamp l = controller.getLamp(0);
		l.switchOn();
		l.switchOff();
		l.switchOn();
		System.out.println(controller);
		// on(8) | off(10) | off(10) | off(10) | off(10) |
		controller.switchOnOne();
		controller.switchOnOne();
		controller.switchOnOne();
		controller.switchOnOne();
		System.out.println(controller);
		// on(8) | on(9) | on(9) | on(9) | on(9) |
	}
}

Ulteriori dettagli

Ereditarietà e costruttori

Costruttori di default e chiamate implicite

class A { }
class B extends A { } // OK

B ha un costruttore di default, che invoca il costruttore senza argomenti (quello di default in questo caso) di A

class A { A() { out.print("A"); } }
class B extends A { } // OK

B ha un costruttore di default, che invoca il costruttore senza argomenti di A

class A { A(int x) { out.print("A" + x); } }
class B extends A { } // ERROR

B ha un costruttore di default, che vorrebbe invocare il costruttore di A senza argomenti, ma non lo trova! Il compilatore restituisce un errore.

class A { }
class B extends A { B() { out.print("B"); } } // OK
// Stessa cosa di:
class B extends A { B() { super(); out.print("B"); } }

B ha un costruttore definito, che invoca implicitamente il costruttore senza argomenti (quello di default in questo caso) di A

class A { A() { out.print("A"); } }
class B extends A { B() { out.print("B"); } } // OK
// Stessa cosa di:
class B extends A { B() { super(); out.print("B"); } }

B ha un costruttore definito, che invoca implicitamente/esplicitamente il costruttore senza argomenti di A

class A {  A(int x) { out.print("A" + x); }  }
class B extends A { B() { out.print("B"); } } // ERROR
// Qua occorre fare:
class B extends A { B() { super(7); out.print("B"); } }

B ha un costruttore definito, che vorrebbe implicitamente invocare il costruttore di A senza argomenti, ma non lo trova! Il compilatore restituisce un errore.

Costruzione di oggetti in gerarchie di classi

Assumiamo si stia costruendo una catena di sottoclassi
Ogni classe introduce alcuni campi, che si aggiungono a quelli della superclasse a formare la struttura di un oggetto in memoria

Linee guida per la singola classe

Dovrà definire tutti i costruttori necessari, seguendo l’approccio visto
Ogni costruttore dovrà preoccuparsi di:
- Chiamare l’opportuno costruttore padre come prima istruzione (super), altrimenti il costruttore di default verrà chiamato, se c’è
- Inizializzare propriamente i campi localmente definiti

Ordine operazioni a seguito di una `new`

Prima si crea l’oggetto con tutti i campi non inizializzati
Il codice dei costruttori sarà eseguito, dalle superclassi in giù

Analisi: cosa succede?

class A {
	protected int i;

	public A(int i) {
		System.out.println("A().. prima " + this.i);
		this.i = i;
		System.out.println("A().. dopo " + this.i);
	}
}

class B extends A {
	protected String s;

	public B(String s, int i) {
		super(i);
		System.out.println("B().. prima " + this.s + " " + this.i);
		this.s = s;
		System.out.println("B().. dopo " + this.s + " " + this.i);
	}
	
	public static void main(String[] s) {
		B b = new B("prova", 5); // Cosa succede?
	}
}

Chiamate di metodo alla superclasse (`super`)

Chiamate `super`

Una sottoclasse C può includere una invocazione del tipo super.m(..args..)
Non solo in caso di overriding
Cosa ci aspettiamo succeda?

Semantica

Accade quello che accadrebbe se la classe corrente non avesse il metodo m, ossia viene eseguito il metodo m della superclasse
- O, se anche lì assente, quello nella sopraclasse più specifica che lo definisce
Se tale metodo al suo interno chiama un altro metodo n (su this), allora si ritorna a considerare la versione più specifica a partire dalla classe di partenza C

Analisi: cosa succede?

class C {
	protected int i;

	void m() {
		System.out.println("C.m.. prima " + i);
		this.i++;
		System.out.println("C.m.. dopo " + i);
	}
}

class D extends C {
	D(int i) {
		this.i = i;
	}
	void m() {
		super.m();
		System.out.println("D.m.. dopo " + this.i);
	}
	public static void main(String[] s) {
		new D(5).m(); // Cosa succede?
	}
}

Altra analisi: cosa succede?

class E {
	protected int i;

	void m() {
		this.i++;
		this.n();
	}
	void n() {
		this.i = this.i + 10;
	}
}

class F extends E {
	void n() {
		this.i = this.i + 100;
	}
	public static void main(String[] s) {
		F f = new F();
		f.i = 10;
		f.m();
		System.out.println("" + f.i);
	}
}

Un esempio: riprendiamo `LimitCounter`

public class LimitCounter extends ExtendibleCounter {

    private final int limit;

    public LimitCounter(final int initialValue, final int limit) {
        super(initialValue);
        this.limit = limit;
    }

    public boolean isOver() {
        return this.getDistanceToLimit() == 0;
    }

    public int getDistanceToLimit() {
        return this.limit - this.value;
    }

    public void increment() {
        if (!this.isOver()) {
            super.increment();
        }
    }
}

Un esempio: nuova specializzazione

Cosa succede chiamando `increment()` su un `UnlimitedCounter`?

Non avendo fatto overriding, si chiama la versione di LimitCounter
In LimitCounter si chiama this.isOver() che chiama this.getDistanceToLimit()
La versione di this.getDistanceToLimit() eseguita è quella di UnlimitedCounter

public class UnlimitedCounter extends LimitCounter {

	public UnlimitedCounter() {
		super(0, Integer.MAX_VALUE);
	}

	public int getDistanceToLimit() {
		// Quindi il contatore non scade mai
		return Integer.MAX_VALUE;
	}
}

Uso di `UnlimitedCounter`

public class UseUnlimitedCounter {
	public static void main(String[] s) {
		final UnlimitedCounter uc = new UnlimitedCounter();
		System.out.println("isOver: " + uc.isOver()); // false
		System.out.println("LifeTime: " + uc.getDistanceToLimit());
		uc.increment();
		uc.increment();
		uc.increment();
		System.out.println("isOver: " + uc.isOver()); // false
		System.out.println("LifeTime: " + uc.getDistanceToLimit());
	}
}

La tabella dei metodi virtuali

Anche detta: vtable, call table, dispatch table

ogni classe C ne ha una, ed è accessibile ai suoi oggetti
ad ogni metodo definito (o ereditato) in C, associa il codice corrispondente da eseguire, ossia la classe che riporta il body
le chiamate da risolvere con tale tabella sono quelle con late binding
è una struttura che rende efficiente il polimorfismo fra classi (che vedremo)
è utile conoscerla anche se non è detto che la JVM usi esattamente tale struttura
fa comprendere il funzionamento di this. e super.

Esempio

Come sono fatte le tabelle relative alle classi LimitedCounter e UnlimitedCounter nell’esempio precedente?

Esempio gestione memoria: stack/heap/vtables

Il modificatore `final`

Problema

Tramite l’overriding e le chiamate super è possibile prendere classi esistenti e modificarle con grande flessibilità
Questo introduce problemi di sicurezza, specialmente connessi al polimorfismo che vedremo nella prossima lezione

Soluzione: `final`

Oltre che per i campi (e argomenti di funzione o variabili, come già visto), è possibile dichiare final anche metodi e intere classi
Un metodo final è un metodo che NON può essere ri-definito per overriding
Una classe final non può essere estesa

Nelle librerie Java

Moltissime classi sono final, ad esempio String

Overriding e controllo d’accesso

Regole per fare l’overriding di un metodo $M$

La nuova versione deve avere esattamente la stessa signature
È possibile estendere la visibilità di un metodo (da protected a public)
Non è possile limitare la visibilità di un metodo (p.e. da public a protected, o da public a private)
È possibile indicare il metodo final

$\Rightarrow$ sono tutte conseguenze del principio di sostituibilità

La classe `Object`

Estensione di default

Una classe deve per forza estendere da qualcosa
Se non lo fa, si assume che estenda java.lang.Object
Quindi ogni classe eredita (indirettamente) da Object
Object è la radice della gerarchia di ereditarietà di Java

Classe `Object`

Fornisce alcuni metodi di utilità generale

toString(), che stampa informazioni sulla classe e la posizione in memoria dell’oggetto
clone(), per clonare un oggetto
equals() e hashCode(), usati nelle collection
notify() e wait(), usati nella gestione dei thread
…

Equals

Il metodo equals è definito nella classe Object e può essere sovrascritto
Il metodo equals è usato per confrontare due oggetti
La sua implementazione di default confronta i riferimenti degli oggetti
- La sua implementazione di default è equivalente a ==
La sua implementazione di default è spesso inadeguata
- Ad esempio, due oggetti con lo stesso contenuto dovrebbero essere considerati uguali
- == quindi non è un confronto semantico
In generale quindi si sovrascrive equals per definire un confronto semantico

class Person {
    private String name;
    private int age;
    // ...
    @Override
    public boolean equals(Object o) {
      return age == person.age && Objects.equals(name, person.name);
    }
}

Annotazione `@Override`

Metodi che fanno override di metodi di interfacce/classi base possono essere annotati con @Override
- Non è necessario, ma è buona prassi
Implicazioni
- Il compilatore genererà un errore se il metodo non fa effettivamente override
- Migliora la leggibilità di codice, rendendo immediatamente evidenti i casi di override di metodi

class Person {
    // ...
    @Override
    public String toString() {
      // ...
    }
}

Ereditarietà

Progettazione e Sviluppo del Software

C.D.L. Tecnologie dei Sistemi Informatici

Danilo Pianini — `danilo.pianini@unibo.it`

Gianluca Aguzzi — `gianluca.aguzzi@unibo.it`

Angelo Filaseta — `angelo.filaseta@unibo.it`

Compiled on: 2025-12-05 — versione stampabile

back

Ereditarietà

Progettazione e Sviluppo del Software

C.D.L. Tecnologie dei Sistemi Informatici

Danilo Pianini — danilo.pianini@unibo.it

Gianluca Aguzzi — gianluca.aguzzi@unibo.it

Angelo Filaseta — angelo.filaseta@unibo.it

Outline

Goal della lezione

Argomenti

Riuso via ereditarietà

Ereditarietà

Scenari di riuso ed estensione

L’ereditarietà è un concetto chiave dell’OO

Solito approccio

Esempio base: Counter

Uso della classe Counter

Una nuova classe: MultiCounter

Uso della classe MultiCounter

Versione con riuso via composizione: MultiCounter2

La necessità di estendere e modificare

Una tipica situazione

Si usa il meccanismo di ereditarietà

Una nuova versione di MultiCounter

Razionale

Ridefiniamo la classe MultiCounter come estensione di Counter

Il senso della definizione

Notazione UML per l’estensione

Notazione UML – versione semplificata per il design

Livello d’accesso protected

Usabile per le proprietà d’una classe

A cosa serve, protected?

Esempio classe BiCounter – contatore bidirezionale

Un contatore estendibile: ExtendibleCounter

Classe MultiCounter

Classe BiCounter

Overriding di metodi

Estensione e modifica

Esempio

Classe LimitCounter

Uso della classe LimitCounter

Notazione UML

Uno scenario completo

Una applicazione allo scenario domotica

Elementi

Note sulla soluzione

Diagramma UML complessivo

LimitCounter

SimpleLamp

LimitedLamp

EcoDomusController

UseEcoDomusController

Ulteriori dettagli

Ereditarietà e costruttori

Costruttori di default e chiamate implicite

Costruzione di oggetti in gerarchie di classi

Linee guida per la singola classe

Ordine operazioni a seguito di una new

Analisi: cosa succede?

Chiamate di metodo alla superclasse (super)

Chiamate super

Semantica

Analisi: cosa succede?

Altra analisi: cosa succede?

Un esempio: riprendiamo LimitCounter

Un esempio: nuova specializzazione

Cosa succede chiamando increment() su un UnlimitedCounter?

Uso di UnlimitedCounter

La tabella dei metodi virtuali

Anche detta: vtable, call table, dispatch table

Esempio

Esempio gestione memoria: stack/heap/vtables

Il modificatore final

Problema

Soluzione: final

Nelle librerie Java

Overriding e controllo d’accesso

Regole per fare l’overriding di un metodo $M$

La classe Object

Estensione di default

Classe Object

Danilo Pianini — `danilo.pianini@unibo.it`

Gianluca Aguzzi — `gianluca.aguzzi@unibo.it`

Angelo Filaseta — `angelo.filaseta@unibo.it`

Esempio base: `Counter`

Uso della classe `Counter`

Una nuova classe: `MultiCounter`

Uso della classe `MultiCounter`

Versione con riuso via composizione: `MultiCounter2`

Una nuova versione di `MultiCounter`

Ridefiniamo la classe `MultiCounter` come estensione di `Counter`

Livello d’accesso `protected`

A cosa serve, `protected`?

Esempio classe `BiCounter` – contatore bidirezionale

Un contatore estendibile: `ExtendibleCounter`

Classe `MultiCounter`

Classe `BiCounter`

Classe `LimitCounter`

Uso della classe `LimitCounter`

`LimitCounter`

`SimpleLamp`

`LimitedLamp`

`EcoDomusController`

`UseEcoDomusController`

Ordine operazioni a seguito di una `new`

Chiamate di metodo alla superclasse (`super`)

Chiamate `super`

Un esempio: riprendiamo `LimitCounter`

Cosa succede chiamando `increment()` su un `UnlimitedCounter`?

Uso di `UnlimitedCounter`

Il modificatore `final`

Soluzione: `final`

La classe `Object`

Classe `Object`

Annotazione `@Override`

Danilo Pianini — `danilo.pianini@unibo.it`

Gianluca Aguzzi — `gianluca.aguzzi@unibo.it`

Angelo Filaseta — `angelo.filaseta@unibo.it`