Introduzione all'incapsulamento e all'astrazione

Incapsulamento e astrazione sono principi fondamentali della programmazione orientata agli oggetti (OOP) che aiutano a gestire la complessità e a migliorare l'organizzazione del codice.

L'incapsulamento limita l'accesso diretto ai dati di un oggetto, mentre l'astrazione nasconde i dettagli dell'implementazione ed espone solo le funzionalità essenziali.

Che cos'è l'incapsulamento?

L'incapsulamento consiste nel raggruppare dati (attributi) e metodi all'interno di una classe e nel limitarne l'accesso diretto.

# Example of encapsulation
class Person:
    # Private attribute (indicated by double underscores)
    def __init__(self, name):
        self.__name = name

    # Public method to access the private attribute
    def get_name(self):
        return self.__name

person = Person("Alice")
# Accessing private data via a public method
print(person.get_name())

Attributi privati

In Python, gli attributi privati sono indicati da due caratteri di sottolineatura __. Non è possibile accedervi direttamente dall'esterno della classe.

# Private attributes
class Car:
    def __init__(self, brand):
        self.__brand = brand  # Private attribute

    def get_brand(self):
        # Public method to access the private attribute
        return self.__brand

car = Car("Toyota")
print(car.get_brand())  # Outputs: Toyota

Che cos'è l'astrazione?

L'astrazione nasconde i dettagli dell'implementazione interna di una classe ed espone all'utente solo le funzionalità necessarie.

# Example of abstraction
from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Subclass implementing the abstract method
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

circle = Circle(5)
print(circle.area())  # Outputs: 78.5

Classi astratte

Le classi astratte sono classi che non possono essere istanziate direttamente. Vengono utilizzate per definire un'interfaccia comune per le relative sottoclassi.

# Abstract Base Class with multiple subclasses
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

dog = Dog()
cat = Cat()
dog.speak()  # Outputs: Dog barks
cat.speak()  # Outputs: Cat meows

Incapsulamento e astrazione

Incapsulamento e astrazione sono concetti strettamente correlati, ma distinti:

• Incapsulamento: limita l'accesso ai dati all'interno di una classe.
• Astrazione: nasconde i dettagli dell'implementazione e fornisce un'interfaccia chiara.

Vantaggi dell'incapsulamento e dell'astrazione

Ecco alcuni vantaggi principali:

• Migliorano la sicurezza e la manutenibilità del codice.
• Promuovono un codice modulare e riutilizzabile.
• Rendono il codice più facile da leggere e comprendere.

Errori comuni con l'incapsulamento e l'astrazione

Ecco alcuni errori da evitare:

• Accedere direttamente agli attributi privati invece di utilizzare i metodi getter e setter.
• Istanziare direttamente classi astratte.
• Non implementare tutti i metodi astratti nelle sottoclassi.

Che cosa abbiamo imparato?

In questa lezione ha imparato:

• Che cos'è l'incapsulamento e come limitare l'accesso ai dati utilizzando attributi privati.
• Che cos'è l'astrazione e come utilizzare le classi astratte per definire interfacce comuni.
• Quali sono le differenze e i vantaggi dell'incapsulamento e dell'astrazione.

Ottimo lavoro! Passiamo al prossimo argomento.