Introduzione all'ereditarietà

L'ereditarietà è un concetto fondamentale della programmazione orientata agli oggetti (OOP) che consente a una classe (sottoclasse) di ereditare attributi e metodi da un'altra classe (superclasse). Favorisce il riutilizzo del codice e rende il codice più organizzato.

In questa lezione imparerà a implementare l'ereditarietà in Python e a comprenderne i vantaggi.

Definizione di una superclasse

Una superclasse è la classe di base da cui ereditano altre classi. Viene definita come qualsiasi altra classe:

# Defining a superclass
class Animal:
    def speak(self):
        print("Animal speaks")

Creazione di una sottoclasse

Una sottoclasse eredita attributi e metodi da una superclasse. Per definire una sottoclasse, si passa il nome della superclasse come parametro:

# Defining a subclass
class Dog(Animal):
    def speak(self):
        print("Dog barks")

Sovrascrittura dei metodi

Una sottoclasse può sovrascrivere i metodi della superclasse per fornire un comportamento specifico:

# Overriding methods in a subclass
class Dog(Animal):
    def speak(self):
        print("Dog barks")

animal = Animal()
animal.speak()  # Outputs: Animal speaks

dog = Dog()
dog.speak()  # Outputs: Dog barks

Utilizzo della funzione super()

La funzione super() consente di chiamare i metodi della superclasse nella sottoclasse:

# Using super() to call superclass methods
class Dog(Animal):
    def speak(self):
        super().speak()
        print("Dog barks")

Ereditarietà multipla

Python supporta l'ereditarietà multipla, in cui una sottoclasse può ereditare da più di una superclasse:

# Example of multiple inheritance
class Flyer:
    def fly(self):
        print("Flying")

class Swimmer:
    def swim(self):
        print("Swimming")

class Duck(Flyer, Swimmer):
    pass

Verifica delle relazioni tra classi

È possibile verificare le relazioni tra classi usando le funzioni isinstance() e issubclass().

# Checking class relationships
# Checking if an object is an instance of a class
print(isinstance(Dog(), Dog))  # Outputs: True

# Checking if a class is a subclass of another
print(issubclass(Dog, Animal))  # Outputs: True

Errori comuni con l'ereditarietà

Ecco alcuni errori da evitare:

• Sovrascrivere i metodi senza chiamare super() quando necessario.
• Confondere l'ordine di risoluzione dei metodi (MRO) nell'ereditarietà multipla.
• Usare l'ereditarietà quando la composizione potrebbe essere una scelta migliore.

Che cosa abbiamo imparato?

In questa lezione ha imparato:

• Come definire superclassi e sottoclassi.
• Come sovrascrivere i metodi e usare super().
• Come funziona l'ereditarietà multipla in Python.

Ottimo lavoro! Passiamo al prossimo argomento.