L’ereditarietà è un concetto chiave della programmazione orientata agli oggetti. Con l’ereditarietà, una classe (chiamata classe figlia o sottoclasse) può ereditare attributi e metodi da un’altra classe (chiamata classe padre o superclasse). Questo permette di riutilizzare il codice, ridurre la complessità del programma e migliorare l’organizzazione del codice.
In Python, l’ereditarietà si implementa definendo una classe figlia che accetta come parametro la classe padre da cui ereditare le caratteristiche. Ad esempio:
```
class Animal: # Classe padre
def __init__(self, nome):
self.nome = nome
class Cane(Animal): # Classe figlia def parla(self): return ‘Bau’
class Gatto(Animal): # Classe figlia
def parla(self):
return ‘Miao‘
```
In questo esempio, sia `Cane` che `Gatto` sono classi figlie che ereditano da `Animal`. Questo significa che entrambe avranno un attributo `nome` e un metodo `parla`, anche se non li definiamo esplicitamente. Nota che i metodi possono essere sovrascritti nelle classi figlie, come abbiamo fatto con il metodo `parla`.
Quando crei un’istanza di `Cane` o `Gatto`, puoi accedere sia ai metodi e attributi definiti nella classe figlia sia a quelli ereditati dalla classe padre:
```
fido = Cane(“Fido”)
print(fido.nome) # Stampa “Fido“
print(fido.parla()) # Stampa “Bau“
```
Infine, Python supporta anche l’ereditarietà multipla, cioè una classe può ereditare da più di una classe padre. Basta elencare le classi padre come parametri separati da virgole:
```
class Padre1:
pass
class Padre2: pass
class Figlio(Padre1, Padre2):
pass
```
In questo caso, `Figlio` eredita sia da `Padre1` che da `Padre2`. Se ci sono attributi o metodi con lo stesso nome in entrambe le classi padre, avrà la precedenza quello della prima classe padre elencata (in questo caso, `Padre1`).
