Introduzione alla programmazione orientata agli oggetti
*******************************************************

.[perex]
Il termine "OOP" sta per Object-Oriented Programming (programmazione orientata agli oggetti), un modo per organizzare e strutturare il codice. L'OOP ci permette di vedere un programma come un insieme di oggetti che comunicano tra loro, piuttosto che come una sequenza di comandi e funzioni.

Nell'OOP, un "oggetto" è un'unità che contiene dati e funzioni che operano su tali dati. Gli oggetti vengono creati sulla base di "classi", che possono essere intese come progetti o modelli di oggetti. Una volta che abbiamo una classe, possiamo creare la sua "istanza", che è un oggetto specifico creato a partire da quella classe.

Vediamo come creare una semplice classe in PHP. Quando si definisce una classe, si usa la parola chiave "class", seguita dal nome della classe e poi dalle parentesi graffe che racchiudono le funzioni della classe (chiamate "metodi") e le variabili della classe (chiamate "proprietà" o "attributi"):

```php
class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}
```

In questo esempio, abbiamo creato una classe chiamata `Car` con una funzione (o "metodo") chiamata `honk`.

Ogni classe dovrebbe risolvere un solo compito principale. Se una classe fa troppe cose, può essere opportuno dividerla in classi più piccole e specializzate.

Le classi sono in genere memorizzate in file separati per mantenere il codice organizzato e facile da navigare. Il nome del file deve corrispondere al nome della classe, quindi per la classe `Car` il nome del file sarà `Car.php`.

Quando si nominano le classi, è bene seguire la convenzione "PascalCase", cioè ogni parola del nome inizia con una lettera maiuscola e non ci sono sottolineature o altri separatori. I metodi e le proprietà seguono la convenzione "camelCase", cioè iniziano con una lettera minuscola.

Alcuni metodi in PHP hanno ruoli speciali e sono preceduti da `__` (due trattini bassi). Uno dei metodi speciali più importanti è il "costruttore", contrassegnato con `__construct`. Il costruttore è un metodo che viene chiamato automaticamente quando si crea una nuova istanza di una classe.

Spesso si usa il costruttore per impostare lo stato iniziale di un oggetto. Per esempio, quando si crea un oggetto che rappresenta una persona, si può usare il costruttore per impostarne l'età, il nome o altri attributi.

Vediamo come utilizzare un costruttore in PHP:

```php
class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

	function howOldAreYou()
	{
		return $this->age;
	}
}

$person = new Person(25);
echo $person->howOldAreYou(); // Outputs: 25
```

In questo esempio, la classe `Person` ha una proprietà (variabile) `$age` e un costruttore che imposta questa proprietà. Il metodo `howOldAreYou()` consente di accedere all'età della persona.

La pseudo-variabile `$this` viene utilizzata all'interno della classe per accedere alle proprietà e ai metodi dell'oggetto.

La parola chiave `new` viene utilizzata per creare una nuova istanza di una classe. Nell'esempio precedente, abbiamo creato una nuova persona di 25 anni.

È anche possibile impostare valori predefiniti per i parametri del costruttore, se non sono specificati durante la creazione di un oggetto. Per esempio:

```php
class Person
{
	private $age;

	function __construct($age = 20)
	{
		$this->age = $age;
	}

	function howOldAreYou()
	{
		return $this->age;
	}
}

$person = new Person;  // if no argument is passed, parentheses can be omitted
echo $person->howOldAreYou(); // Outputs: 20
```

In questo esempio, se non si specifica l'età quando si crea un oggetto `Person`, verrà usato il valore predefinito di 20.

La cosa bella è che la definizione della proprietà con la sua inizializzazione tramite il costruttore può essere accorciata e semplificata in questo modo:

```php
class Person
{
	function __construct(
		private $age = 20,
	) {
	}
}
```

Per completezza, oltre ai costruttori, gli oggetti possono avere dei distruttori (metodo `__destruct`) che vengono chiamati prima che l'oggetto venga rilasciato dalla memoria.


Spazi dei nomi .[#toc-namespaces]
---------------------------------

Gli spazi dei nomi consentono di organizzare e raggruppare classi, funzioni e costanti correlate, evitando conflitti di denominazione. Si possono considerare come le cartelle di un computer, dove ogni cartella contiene file relativi a un progetto o a un argomento specifico.

Gli spazi dei nomi sono particolarmente utili in progetti di grandi dimensioni o quando si utilizzano librerie di terze parti in cui potrebbero sorgere conflitti di denominazione delle classi.

Immaginate di avere una classe chiamata `Car` nel vostro progetto e di volerla inserire in uno spazio dei nomi chiamato `Transport`. Si procederà in questo modo:

```php
namespace Transport;

class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}
```

Se si vuole utilizzare la classe `Car` in un altro file, occorre specificare da quale spazio dei nomi proviene la classe:

```php
$car = new Transport\Car;
```

Per semplificare, si può specificare all'inizio del file quale classe di un particolare spazio dei nomi si vuole utilizzare, consentendo di creare istanze senza citare il percorso completo:

```php
use Transport\Car;

$car = new Car;
```


Eredità .[#toc-inheritance]
---------------------------

L'ereditarietà è uno strumento della programmazione orientata agli oggetti che consente di creare nuove classi basate su quelle esistenti, ereditandone proprietà e metodi ed estendendole o ridefinendole a seconda delle necessità. L'ereditarietà garantisce la riusabilità del codice e la gerarchia delle classi.

In parole povere, se abbiamo una classe e vogliamo crearne un'altra derivata da essa ma con alcune modifiche, possiamo "ereditare" la nuova classe da quella originale.

In PHP, l'ereditarietà viene implementata utilizzando la parola chiave `extends`.

La nostra classe `Person` memorizza informazioni sull'età. Possiamo avere un'altra classe, `Student`, che estende `Person` e aggiunge informazioni sul campo di studi.

Vediamo un esempio:

```php
class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

	function printInformation()
	{
		echo "Age: {$this->age} years\n";
	}
}

class Student extends Person
{
	private $fieldOfStudy;

	function __construct($age, $fieldOfStudy)
	{
		parent::__construct($age);
		$this->fieldOfStudy = $fieldOfStudy;
	}

	function printInformation()
	{
		parent::printInformation();
		echo "Field of study: {$this->fieldOfStudy} \n";
	}
}

$student = new Student(20, 'Computer Science');
$student->printInformation();
```

Come funziona questo codice?

- Abbiamo usato la parola chiave `extends` per estendere la classe `Person`, il che significa che la classe `Student` eredita tutti i metodi e le proprietà da `Person`.

- La parola chiave `parent::` consente di richiamare i metodi della classe padre. In questo caso, abbiamo richiamato il costruttore della classe `Person` prima di aggiungere la nostra funzionalità alla classe `Student`. E allo stesso modo, il metodo dell'antenato `printInformation()` prima di elencare le informazioni sugli studenti.

L'ereditarietà è pensata per le situazioni in cui esiste una relazione "is a" tra le classi. Per esempio, un `Student` è un `Person`. Un gatto è un animale. Ci consente, nei casi in cui ci aspettiamo un oggetto (ad esempio, "Persona") nel codice, di utilizzare invece un oggetto derivato (ad esempio, "Studente").

È essenziale rendersi conto che lo scopo principale dell'ereditarietà **non** è quello di prevenire la duplicazione del codice. Al contrario, un uso improprio dell'ereditarietà può portare a codice complesso e difficile da mantenere. Se non c'è una relazione "è un" tra le classi, dovremmo considerare la composizione invece dell'ereditarietà.

Si noti che i metodi `printInformation()` delle classi `Person` e `Student` forniscono informazioni leggermente diverse. È possibile aggiungere altre classi (come `Employee`) che forniranno altre implementazioni di questo metodo. La capacità di oggetti di classi diverse di rispondere allo stesso metodo in modi diversi si chiama polimorfismo:

```php
$people = [
	new Person(30),
	new Student(20, 'Computer Science'),
	new Employee(45, 'Director'),
];

foreach ($people as $person) {
	$person->printInformation();
}
```


Composizione .[#toc-composition]
--------------------------------

La composizione è una tecnica in cui, invece di ereditare proprietà e metodi da un'altra classe, si usa semplicemente la sua istanza nella propria classe. Questo ci permette di combinare funzionalità e proprietà di più classi senza creare complesse strutture di ereditarietà.

Ad esempio, abbiamo una classe `Engine` e una classe `Car`. Invece di dire "Un'auto è un motore", diciamo "Un'auto ha un motore", che è una tipica relazione di composizione.

```php
class Engine
{
	function start()
	{
		echo 'Engine is running.';
	}
}

class Car
{
	private $engine;

	function __construct()
	{
		$this->engine = new Engine;
	}

	function start()
	{
		$this->engine->start();
		echo 'The car is ready to drive!';
	}
}

$car = new Car;
$car->start();
```

In questo caso, la classe `Car` non possiede tutte le proprietà e i metodi della classe `Engine`, ma vi ha accesso attraverso la proprietà `$engine`.

Il vantaggio della composizione è una maggiore flessibilità di progettazione e una migliore adattabilità ai cambiamenti futuri.


Visibilità .[#toc-visibility]
-----------------------------

In PHP, è possibile definire la "visibilità" per le proprietà, i metodi e le costanti delle classi. La visibilità determina dove è possibile accedere a questi elementi.

1. Se un elemento è contrassegnato come `public`, significa che è possibile accedervi da qualsiasi punto, anche al di fuori della classe.

2. Un elemento contrassegnato come `protected` è accessibile solo all'interno della classe e di tutti i suoi discendenti (classi che ereditano da essa).

3. Se un elemento è `private`, è possibile accedervi solo dalla classe in cui è stato definito.

Se non si specifica la visibilità, PHP la imposterà automaticamente a `public`.

Vediamo un esempio di codice:

```php
class VisibilityExample
{
	public $publicProperty = 'Public';
	protected $protectedProperty = 'Protected';
	private $privateProperty = 'Private';

	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		echo $this->privateProperty;    // Works
	}
}

$object = new VisibilityExample;
$object->printProperties();
echo $object->publicProperty;        // Works
// echo $object->protectedProperty;   // Throws an error
// echo $object->privateProperty;     // Throws an error
```

Continuare con l'ereditarietà delle classi:

```php
class ChildClass extends VisibilityExample
{
	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		// echo $this->privateProperty;   // Throws an error
	}
}
```

In questo caso, il metodo `printProperties()` della classe `ChildClass` può accedere alle proprietà pubbliche e protette, ma non alle proprietà private della classe padre.

I dati e i metodi devono essere il più possibile nascosti e accessibili solo attraverso un'interfaccia definita. Ciò consente di modificare l'implementazione interna della classe senza influenzare il resto del codice.


Parola chiave finale .[#toc-final-keyword]
------------------------------------------

In PHP, si può usare la parola chiave `final` se si vuole impedire che una classe, un metodo o una costante vengano ereditati o sovrascritti. Quando una classe è contrassegnata come `final`, non può essere estesa. Quando un metodo è contrassegnato come `final`, non può essere sovrascritto in una sottoclasse.

Essere consapevoli che una certa classe o un certo metodo non saranno più modificati ci permette di apportare modifiche più facilmente senza preoccuparci di potenziali conflitti. Ad esempio, possiamo aggiungere un nuovo metodo senza temere che un discendente abbia già un metodo con lo stesso nome, causando una collisione. Oppure possiamo cambiare i parametri di un metodo, sempre senza il rischio di causare incoerenze con un metodo sovrascritto in un discendente.

```php
final class FinalClass
{
}

// The following code will throw an error because we cannot inherit from a final class.
class ChildOfFinalClass extends FinalClass
{
}
```

In questo esempio, il tentativo di ereditare dalla classe finale `FinalClass` produrrà un errore.


Proprietà e metodi statici .[#toc-static-properties-and-methods]
----------------------------------------------------------------

Quando si parla di elementi "statici" di una classe in PHP, si intendono metodi e proprietà che appartengono alla classe stessa, non a un'istanza specifica della classe. Ciò significa che non è necessario creare un'istanza della classe per accedervi. Al contrario, è possibile chiamarli o accedervi direttamente attraverso il nome della classe.

Tenere presente che, poiché gli elementi statici appartengono alla classe e non alle sue istanze, non è possibile utilizzare la pseudo-variabile `$this` all'interno dei metodi statici.

L'uso di proprietà statiche porta a un [codice offuscato e pieno di insidie |dependency-injection:global-state], quindi non si dovrebbe mai usarle e non ne mostreremo un esempio qui. D'altra parte, i metodi statici sono utili. Ecco un esempio:

```php
class Calculator
{
	public static function add($a, $b)
	{
		return $a + $b;
	}

	public static function subtract($a, $b)
	{
		return $a - $b;
	}
}

// Using the static method without creating an instance of the class
echo Calculator::add(5, 3); // Output: 8
echo Calculator::subtract(5, 3); // Output: 2
```

In questo esempio, abbiamo creato una classe `Calculator` con due metodi statici. Possiamo chiamare questi metodi direttamente, senza creare un'istanza della classe, utilizzando l'operatore `::`. I metodi statici sono particolarmente utili per le operazioni che non dipendono dallo stato di una specifica istanza della classe.


Costanti di classe .[#toc-class-constants]
------------------------------------------

All'interno delle classi è possibile definire delle costanti. Le costanti sono valori che non cambiano mai durante l'esecuzione del programma. A differenza delle variabili, il valore di una costante rimane invariato.

```php
class Car
{
	public const NumberOfWheels = 4;

	public function displayNumberOfWheels(): int
	{
		echo self::NumberOfWheels;
	}
}

echo Car::NumberOfWheels;  // Output: 4
```

In questo esempio, abbiamo una classe `Car` con la costante `NumberOfWheels`. Quando si accede alla costante all'interno della classe, si può usare la parola chiave `self` invece del nome della classe.


Interfacce di oggetti .[#toc-object-interfaces]
-----------------------------------------------

Le interfacce di oggetti agiscono come "contratti" per le classi. Se una classe deve implementare un'interfaccia di oggetti, deve contenere tutti i metodi definiti dall'interfaccia. È un ottimo modo per garantire che alcune classi aderiscano allo stesso "contratto" o struttura.

In PHP, le interfacce sono definite utilizzando la parola chiave `interface`. Tutti i metodi definiti in un'interfaccia sono pubblici (`public`). Quando una classe implementa un'interfaccia, utilizza la parola chiave `implements`.

```php
interface Animal
{
	function makeSound();
}

class Cat implements Animal
{
	public function makeSound()
	{
		echo 'Meow';
	}
}

$cat = new Cat;
$cat->makeSound();
```

Se una classe implementa un'interfaccia, ma non tutti i metodi previsti sono definiti, PHP lancia un errore.

Una classe può implementare più interfacce contemporaneamente, a differenza dell'ereditarietà, dove una classe può ereditare solo da una classe:

```php
interface Guardian
{
	function guardHouse();
}

class Dog implements Animal, Guardian
{
	public function makeSound()
	{
		echo 'Bark';
	}

	public function guardHouse()
	{
		echo 'Dog diligently guards the house';
	}
}
```


Classi astratte .[#toc-abstract-classes]
----------------------------------------

Le classi astratte servono come modelli di base per altre classi, ma non è possibile creare direttamente le loro istanze. Contengono un mix di metodi completi e metodi astratti che non hanno un contenuto definito. Le classi che ereditano da classi astratte devono fornire le definizioni di tutti i metodi astratti del genitore.

Per definire una classe astratta si usa la parola chiave `abstract`.

```php
abstract class AbstractClass
{
	public function regularMethod()
	{
		echo 'This is a regular method';
	}

	abstract public function abstractMethod();
}

class Child extends AbstractClass
{
	public function abstractMethod()
	{
		echo 'This is the implementation of the abstract method';
	}
}

$instance = new Child;
$instance->regularMethod();
$instance->abstractMethod();
```

In questo esempio, abbiamo una classe astratta con un metodo regolare e uno astratto. Poi abbiamo una classe `Child` che eredita da `AbstractClass` e fornisce un'implementazione per il metodo astratto.

In cosa differiscono le interfacce e le classi astratte? Le classi astratte possono contenere sia metodi astratti che concreti, mentre le interfacce definiscono solo quali metodi la classe deve implementare, ma non forniscono alcuna implementazione. Una classe può ereditare da una sola classe astratta, ma può implementare un numero qualsiasi di interfacce.


Verifica del tipo .[#toc-type-checking]
---------------------------------------

Nella programmazione è fondamentale assicurarsi che i dati con cui si lavora siano del tipo corretto. In PHP, disponiamo di strumenti che forniscono questa garanzia. Verificare che i dati siano del tipo corretto si chiama "controllo del tipo".

Tipi che possiamo incontrare in PHP:

1. **Tipi di base**: Questi includono `int` (numeri interi), `float` (numeri in virgola mobile), `bool` (valori booleani), `string` (stringhe), `array` (array) e `null`.
2. **Classi**: Quando si vuole che un valore sia un'istanza di una classe specifica.
3. **Interfacce**: Definisce un insieme di metodi che una classe deve implementare. Un valore che soddisfa un'interfaccia deve avere questi metodi.
4. **Tipi misti**: Si può specificare che una variabile può avere più tipi consentiti.
5. **Voide**: Questo tipo speciale indica che una funzione o un metodo non restituisce alcun valore.

Vediamo come modificare il codice per includere i tipi:

```php
class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}

	public function printAge(): void
	{
		echo "This person is {$this->age} years old.";
	}
}

/**
 * A function that accepts a Person object and prints the person's age.
 */
function printPersonAge(Person $person): void
{
	$person->printAge();
}
```

In questo modo, ci assicuriamo che il nostro codice si aspetti e lavori con dati del tipo corretto, aiutandoci a prevenire potenziali errori.

Alcuni tipi non possono essere scritti direttamente in PHP. In questo caso, vengono elencati nel commento phpDoc, che è il formato standard per la documentazione del codice PHP, che inizia con `/**` e termina con `*/`. Esso consente di aggiungere descrizioni di classi, metodi e così via. E anche di elencare tipi complessi usando le cosiddette annotazioni `@var`, `@param` e `@return`. Questi tipi vengono poi utilizzati dagli strumenti di analisi statica del codice, ma non vengono controllati da PHP stesso.

```php
class Registry
{
	/** @var array<Person>  indicates that it's an array of Person objects */
	private array $persons = [];

	public function addPerson(Person $person): void
	{
		$this->persons[] = $person;
	}
}
```


Confronto e identità .[#toc-comparison-and-identity]
----------------------------------------------------

In PHP, è possibile confrontare gli oggetti in due modi:

1. Confronto tra valori `==`: verifica se gli oggetti appartengono alla stessa classe e hanno gli stessi valori nelle loro proprietà.
2. Identità `===`: verifica se si tratta della stessa istanza dell'oggetto.

```php
class Car
{
	public string $brand;

	public function __construct(string $brand)
	{
		$this->brand = $brand;
	}
}

$car1 = new Car('Skoda');
$car2 = new Car('Skoda');
$car3 = $car1;

var_dump($car1 == $car2);   // true, because they have the same value
var_dump($car1 === $car2);  // false, because they are not the same instance
var_dump($car1 === $car3);  // true, because $car3 is the same instance as $car1
```


L'operatore di `instanceof` .[#toc-the-instanceof-operator]
-----------------------------------------------------------

L'operatore `instanceof` consente di determinare se un dato oggetto è un'istanza di una classe specifica, un discendente di quella classe o se implementa una certa interfaccia.

Immaginiamo di avere una classe `Person` e un'altra classe `Student`, che è un discendente di `Person`:

```php
class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}
}

class Student extends Person
{
	private string $major;

	public function __construct(int $age, string $major)
	{
		parent::__construct($age);
		$this->major = $major;
	}
}

$student = new Student(20, 'Computer Science');

// Check if $student is an instance of the Student class
var_dump($student instanceof Student);  // Output: bool(true)

// Check if $student is an instance of the Person class (because Student is a descendant of Person)
var_dump($student instanceof Person);   // Output: bool(true)
```

Dai risultati, è evidente che l'oggetto `$student` è considerato un'istanza di entrambe le classi `Student` e `Person`.


Interfacce fluenti .[#toc-fluent-interfaces]
--------------------------------------------

Una "interfaccia fluida" è una tecnica dell'OOP che consente di concatenare i metodi in un'unica chiamata. Questo spesso semplifica e chiarisce il codice.

L'elemento chiave di un'interfaccia fluente è che ogni metodo della catena restituisce un riferimento all'oggetto corrente. Questo si ottiene utilizzando `return $this;` alla fine del metodo. Questo stile di programmazione è spesso associato ai metodi chiamati "setter", che impostano i valori delle proprietà di un oggetto.

Vediamo come potrebbe essere un'interfaccia fluente per l'invio di e-mail:

```php
public function sendMessage()
{
	$email = new Email;
	$email->setFrom('sender@example.com')
		  ->setRecipient('admin@example.com')
		  ->setMessage('Hello, this is a message.')
		  ->send();
}
```

In questo esempio, i metodi `setFrom()`, `setRecipient()` e `setMessage()` sono usati per impostare i valori corrispondenti (mittente, destinatario, contenuto del messaggio). Dopo aver impostato ciascuno di questi valori, i metodi restituiscono l'oggetto corrente (`$email`), consentendoci di concatenare un altro metodo dopo di esso. Infine, chiamiamo il metodo `send()`, che invia effettivamente l'e-mail.

Grazie alle interfacce fluide, possiamo scrivere codice intuitivo e facilmente leggibile.


Copiare con `clone` .[#toc-copying-with-clone]
----------------------------------------------

In PHP, possiamo creare una copia di un oggetto usando l'operatore `clone`. In questo modo, si ottiene una nuova istanza con contenuti identici.

Se durante la copia di un oggetto è necessario modificarne alcune proprietà, è possibile definire un metodo speciale `__clone()` nella classe. Questo metodo viene richiamato automaticamente quando l'oggetto viene clonato.

```php
class Sheep
{
	public string $name;

	public function __construct(string $name)
	{
		$this->name = $name;
	}

	public function __clone()
	{
		$this->name = 'Clone of ' . $this->name;
	}
}

$original = new Sheep('Dolly');
echo $original->name . "\n";  // Outputs: Dolly

$clone = clone $original;
echo $clone->name . "\n";     // Outputs: Clone of Dolly
```

In questo esempio, abbiamo una classe `Sheep` con una proprietà `$name`. Quando si clona un'istanza di questa classe, il metodo `__clone()` assicura che il nome della pecora clonata ottenga il prefisso "Clone di".


Tratti .[#toc-traits]
---------------------

I tratti in PHP sono uno strumento che consente di condividere metodi, proprietà e costanti tra le classi, evitando la duplicazione del codice. Si può pensare a loro come a un meccanismo di "copia e incolla" (Ctrl-C e Ctrl-V), in cui il contenuto di un tratto viene "incollato" nelle classi. Ciò consente di riutilizzare il codice senza dover creare complicate gerarchie di classi.

Vediamo un semplice esempio di utilizzo dei tratti in PHP:

```php
trait Honking
{
	public function honk()
	{
		echo 'Beep beep!';
	}
}

class Car
{
	use Honking;
}

class Truck
{
	use Honking;
}

$car = new Car;
$car->honk(); // Outputs 'Beep beep!'

$truck = new Truck;
$truck->honk(); // Also outputs 'Beep beep!'
```

In questo esempio, abbiamo un tratto chiamato `Honking` che contiene un metodo `honk()`. Abbiamo poi due classi: `Car` e `Truck`, che utilizzano entrambe il tratto `Honking`. Di conseguenza, entrambe le classi "possiedono" il metodo `honk()` e possiamo chiamarlo su oggetti di entrambe le classi.

I tratti consentono di condividere facilmente ed efficacemente il codice tra le classi. Non entrano nella gerarchia ereditaria, cioè `$car instanceof Honking` restituirà `false`.


Eccezioni
---------

Le eccezioni nell'OOP ci permettono di gestire con grazia gli errori e le situazioni inaspettate nel nostro codice. Sono oggetti che contengono informazioni su un errore o una situazione insolita.

In PHP, abbiamo una classe incorporata `Exception`, che serve come base per tutte le eccezioni. Questa classe ha diversi metodi che ci permettono di ottenere ulteriori informazioni sull'eccezione, come il messaggio di errore, il file e la riga in cui si è verificato l'errore, ecc.

Quando si verifica un errore nel codice, si può "lanciare" l'eccezione usando la parola chiave `throw`.

```php
function division(float $a, float $b): float
{
	if ($b === 0) {
		throw new Exception('Division by zero!');
	}
	return $a / $b;
}
```

Quando la funzione `division()` riceve null come secondo argomento, lancia un'eccezione con il messaggio di errore `'Division by zero!'`. Per evitare che il programma si blocchi quando viene lanciata l'eccezione, la intrappoliamo nel blocco `try/catch`:

```php
try {
	echo division(10, 0);
} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
}
```

Il codice che può lanciare un'eccezione viene avvolto in un blocco `try`. Se l'eccezione viene lanciata, l'esecuzione del codice passa a un blocco `catch`, dove è possibile gestire l'eccezione (ad esempio, scrivere un messaggio di errore).

Dopo i blocchi `try` e `catch`, si può aggiungere un blocco opzionale `finally`, che viene sempre eseguito, indipendentemente dal fatto che l'eccezione sia stata lanciata o meno (anche se si utilizzano `return`, `break`, o `continue` nel blocco `try` o `catch` ):

```php
try {
	echo division(10, 0);
} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
} finally {
	// Code that is always executed whether the exception has been thrown or not
}
```

Possiamo anche creare le nostre classi di eccezioni (gerarchia) che ereditano dalla classe Exception. A titolo di esempio, si consideri una semplice applicazione bancaria che consente depositi e prelievi:

```php
class BankingException extends Exception {}
class InsufficientFundsException extends BankingException {}
class ExceededLimitException extends BankingException {}

class BankAccount
{
	private int $balance = 0;
	private int $dailyLimit = 1000;

	public function deposit(int $amount): int
	{
		$this->balance += $amount;
		return $this->balance;
	}

	public function withdraw(int $amount): int
	{
		if ($amount > $this->balance) {
			throw new InsufficientFundsException('Not enough funds in the account.');
		}

		if ($amount > $this->dailyLimit) {
			throw new ExceededLimitException('Daily withdrawal limit exceeded.');
		}

		$this->balance -= $amount;
		return $this->balance;
	}
}
```

È possibile specificare più blocchi `catch` per un singolo blocco `try` se si prevedono diversi tipi di eccezioni.

```php
$account = new BankAccount;
$account->deposit(500);

try {
	$account->withdraw(1500);
} catch (ExceededLimitException $e) {
	echo $e->getMessage();
} catch (InsufficientFundsException $e) {
	echo $e->getMessage();
} catch (BankingException $e) {
	echo 'An error occurred during the operation.';
}
```

In questo esempio, è importante notare l'ordine dei blocchi `catch`. Poiché tutte le eccezioni ereditano da `BankingException`, se avessimo questo blocco per primo, tutte le eccezioni verrebbero catturate in esso, senza che il codice raggiunga i successivi blocchi `catch`. Pertanto, è importante che le eccezioni più specifiche (cioè quelle che ereditano da altre) si trovino più in alto nell'ordine dei blocchi `catch` rispetto alle loro eccezioni padre.


Iterazioni .[#toc-iterations]
-----------------------------

In PHP, è possibile eseguire un ciclo di oggetti utilizzando il ciclo `foreach`, proprio come si fa con un array. Perché funzioni, l'oggetto deve implementare un'interfaccia speciale.

La prima opzione è implementare l'interfaccia `Iterator`, che ha i metodi `current()` che restituisce il valore corrente, `key()` che restituisce la chiave, `next()` che passa al valore successivo, `rewind()` che passa all'inizio e `valid()` che controlla se siamo già alla fine.

L'altra opzione è implementare un'interfaccia `IteratorAggregate`, che ha un solo metodo `getIterator()`. Questo metodo può restituire un oggetto segnaposto che fornirà l'attraversamento, oppure può essere un generatore, cioè una funzione speciale che utilizza `yield` per restituire chiavi e valori in sequenza:

```php
class Person
{
	public function __construct(
		public int $age,
	) {
	}
}

class Registry implements IteratorAggregate
{
	private array $people = [];

	public function addPerson(Person $person): void
	{
		$this->people[] = $person;
	}

	public function getIterator(): Generator
	{
		foreach ($this->people as $person) {
			yield $person;
		}
	}
}

$list = new Registry;
$list->addPerson(new Person(30));
$list->addPerson(new Person(25));

foreach ($list as $person) {
	echo "Age: {$person->age} years\n";
}
```


Migliori pratiche .[#toc-best-practices]
----------------------------------------

Una volta acquisiti i principi di base della programmazione orientata agli oggetti, è fondamentale concentrarsi sulle best practice dell'OOP. Queste vi aiuteranno a scrivere codice non solo funzionale, ma anche leggibile, comprensibile e facilmente manutenibile.

1) **Separazione delle preoccupazioni**: Ogni classe dovrebbe avere una responsabilità chiaramente definita e dovrebbe occuparsi di un solo compito primario. Se una classe fa troppe cose, potrebbe essere opportuno dividerla in classi più piccole e specializzate.
2) **Incapsulamento**: I dati e i metodi devono essere il più possibile nascosti e accessibili solo attraverso un'interfaccia definita. Ciò consente di modificare l'implementazione interna di una classe senza influenzare il resto del codice.
3) **Iniezione di dipendenze**: Invece di creare dipendenze direttamente all'interno di una classe, è opportuno "iniettarle" dall'esterno. Per una comprensione più approfondita di questo principio, si consiglia di leggere i [capitoli sulla Dependency Injection |dependency-injection:introduction].