Introduzione ai Principi SOLID: Open/Closed Principle

OCP: Come rendere il codice estendibile senza modificarlo

Dopo aver approfondito il Single Responsibility Principle (SRP), che puoi leggere qui continuiamo il nostro viaggio nei principi SOLID con l’Open/Closed Principle (OCP). Questo principio, introdotto da Bertrand Meyer, afferma che:

Le entità software (classi, moduli, funzioni, ecc.) devono essere aperte all’estensione, ma chiuse alla modifica.

Ma cosa significa in pratica? E come possiamo implementarlo nei nostri progetti per migliorare la manutenibilità e l’estensibilità del codice? Scopriamolo con esempi pratici.

---

Cosa Significa l’Open/Closed Principle?

“Aperto all’estensione”

Il codice deve permettere di aggiungere nuove funzionalità senza modificare le classi o i moduli esistenti.

“Chiuso alla modifica”

Una volta scritta e testata, una classe non dovrebbe essere alterata per evitare di introdurre bug in parti già funzionanti del sistema.

---

Perché è importante?

---

Esempio Pratico Senza OCP

Immaginiamo di voler calcolare l’area di diverse forme geometriche. Senza seguire l’OCP, il codice potrebbe apparire così:

class ShapeCalculator {
    public function calculateArea($shape) {
        if ($shape instanceof Circle) {
            return pi() * pow($shape->radius, 2);
        } elseif ($shape instanceof Rectangle) {
            return $shape->width * $shape->height;
        }
 // Aggiungere nuovi tipi di forme richiede modifiche a questa classe
    }
}

class Circle {
    public $radius;
    public function __construct($radius) {
        $this->radius = $radius;
    }
}

class Rectangle {
    public $width;
    public $height;
    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }
}

Ogni volta che aggiungiamo una nuova forma (es. un triangolo), dobbiamo modificare la classe ShapeCalculator. Questo viola il principio OCP.

---

Applicazione dell’OCP

Con il principio OCP, possiamo estendere il comportamento del nostro calcolatore senza modificarne il codice esistente. Lo facciamo utilizzando il polimorfismo.

interface Shape {
    public function calculateArea();
}

class Circle implements Shape {
    private $radius;
    public function __construct($radius) {
        $this->radius = $radius;
    }
    public function calculateArea() {
        return pi() * pow($this->radius, 2);
    }
}

class Rectangle implements Shape {
    private $width;
    private $height;
    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }
    public function calculateArea() {
        return $this->width * $this->height;
    }
}

class ShapeCalculator {
    public function calculateArea(Shape $shape) {
        return $shape->calculateArea();
    }
}

// Uso concreto
$circle = new Circle(5);
$rectangle = new Rectangle(4, 6);

$calculator = new ShapeCalculator();
echo $calculator->calculateArea($circle); // Output: 78.54
echo $calculator->calculateArea($rectangle); // Output: 24

Vantaggi:

1. Nuove forme possono essere aggiunte semplicemente implementando l’interfaccia Shape, senza toccare la classe ShapeCalculator.

2. Ogni forma è responsabile del proprio calcolo dell’area, seguendo anche il principio SRP.

---

Implementazione in Altri Contesti

L’OCP non si applica solo alla geometria. Ecco alcuni altri esempi:

• Gestione dei pagamenti: Aggiungere nuovi metodi di pagamento senza modificare il sistema di checkout.

• Logger personalizzati: Aggiungere nuovi formati di log senza modificare il logger principale.

• Sistemi di notifica: Aggiungere notifiche via SMS o push senza modificare l’invio via email.

Esempio: Logger Estendibile

interface Logger {
    public function log($message);
}

class FileLogger implements Logger {
    public function log($message) {
        file_put_contents('log.txt', $message . PHP_EOL, FILE_APPEND);
    }
}

class DatabaseLogger implements Logger {
    public function log($message) {
        // Log nel database
    }
}

class LoggerManager {
    public function logMessage(Logger $logger, $message) {
        $logger->log($message);
    }
}

// Uso concreto
$fileLogger = new FileLogger();
$loggerManager = new LoggerManager();
$loggerManager->logMessage($fileLogger, "Messaggio di log");

---

Come Riconoscere la Violazione del Principio?

1. Modifiche frequenti a classi già scritte per supportare nuove funzionalità.

2. Utilizzo eccessivo di if o switch per distinguere tra vari tipi.

---

L’Open/Closed Principle non è solo una regola astratta, ma un approccio concreto per scrivere codice estendibile e manutenibile. Adottare questo principio non solo migliora la qualità del codice, ma rende i progetti più scalabili e sostenibili.

E tu? Hai incontrato codice che viola l’OCP nei tuoi progetti? Condividi la tua esperienza nei commenti e discutiamone insieme! 😊