Guida a OOP: Classi, Astratti, Interfacce

Se stai iniziando a programmare, probabilmente hai sentito parlare di “classi” in diversi contesti. Ma sai qual è la differenza tra una classe concreta, astratta e un’interfaccia? In questo articolo, ti forniremo una guida facile e semplice per comprendere queste tre importanti costrutti della programmazione orientata agli oggetti.

Una classe concreta è una classe che può essere istanziata direttamente e che contiene metodi e proprietà implementate.

//Classe concreta
class Automobile {
  private $marca;
  private $modello;
  private $anno;

  public function __construct($marca, $modello, $anno) {
    $this->marca = $marca;
    $this->modello = $modello;
    $this->anno = $anno;
  }

  public function getInfo() {
    return "Marca: {$this->marca}, Modello: {$this->modello}, Anno: {$this->anno}";
  }
}

$auto = new Automobile("Fiat", "Panda", 2021);
echo $auto->getInfo(); // Output: "Marca: Fiat, Modello: Panda, Anno: 2021"

Una classe astratta è una classe che non può essere istanziata direttamente e che può contenere solo dichiarazioni di metodi e proprietà, lasciando l’implementazione a sottoclassi concrete.

// Classe astratta
abstract class Veicolo {
  protected $marca;
  protected $modello;
  protected $anno;

  public function __construct($marca, $modello, $anno) {
    $this->marca = $marca;
    $this->modello = $modello;
    $this->anno = $anno;
  }

  abstract public function getInfo();
}

// Classe che estende la classe astratta Veicolo
class Moto extends Veicolo {
  private $cilindrata;

  public function __construct($marca, $modello, $anno, $cilindrata) {
    parent::__construct($marca, $modello, $anno);
    $this->cilindrata = $cilindrata;
  }

  public function getInfo() {
    return "Marca: {$this->marca}, Modello: {$this->modello}, Anno: {$this->anno}, Cilindrata: {$this->cilindrata}";
  }
}

$moto = new Moto("Honda", "CBR600RR", 2022, 600);
echo $moto->getInfo(); // Output: "Marca: Honda, Modello: CBR600RR, Anno: 2022, Cilindrata: 600"

Un’interfaccia è una collezione di metodi e proprietà dichiarati senza implementazione, che deve essere implementata dalle classi che la utilizzano.

// Interfaccia
interface Veicolo {
  public function accelera();
  public function frenare();
}

// Classe che implementa l'interfaccia Veicolo
class Automobile implements Veicolo {
  private $marca;
  private $modello;
  private $velocita;

  public function __construct($marca, $modello) {
    $this->marca = $marca;
    $this->modello = $modello;
    $this->velocita = 0;
  }

  public function accelera() {
    $this->velocita += 10;
    echo "L'automobile {$this->marca} {$this->modello} accelera a {$this->velocita} km/h.\n";
  }

  public function frenare() {
    $this->velocita -= 5;
    echo "L'automobile {$this->marca} {$this->modello} frena a {$this->velocita} km/h.\n";
  }
}

$auto = new Automobile("Fiat", "Panda");
$auto->accelera(); // Output: "L'automobile Fiat Panda accelera a 10 km/h."
$auto->frenare();  // Output: "L'automobile Fiat Panda frena a 5 km/h."

Perché è importante conoscere la differenza tra queste tre costruzioni? Perché l’utilizzo di classi astratte e interfacce può portare a una maggiore modularità e flessibilità del codice, consentendo di scrivere codice più generico e riutilizzabile. Inoltre, l’uso di queste costruzioni può facilitare la scrittura di test e migliorare la manutenibilità del codice.