diff --git a/language/oop5/final.xml b/language/oop5/final.xml
new file mode 100644
index 000000000..18b22893c
--- /dev/null
+++ b/language/oop5/final.xml
@@ -0,0 +1,130 @@
+
+
+
+ La parola chiave final
+
+ La parola chiave final impedisce alle classi figlie di sovrascrivere un metodo, una proprietà o una costante
+ anteponendo alla definizione il prefisso final. Se la classe
+ stessa viene definita come final, non potrà essere estesa.
+
+
+
+ Esempio di metodi final
+
+
+]]>
+
+
+
+
+
+ Esempio di classe final
+
+
+]]>
+
+
+
+
+ Esempio di proprietà final a partire da PHP 8.4.0
+
+
+]]>
+
+
+
+ Esempio di costanti final a partire da PHP 8.1.0
+
+
+]]>
+
+
+
+
+
+ A partire da PHP 8.0.0, i metodi privati non possono essere dichiarati final, a eccezione del costruttore.
+
+
+
+
+ Una proprietà dichiarata private(set) è implicitamente final.
+
+
+
+
diff --git a/language/oop5/iterations.xml b/language/oop5/iterations.xml
new file mode 100644
index 000000000..649eeadf9
--- /dev/null
+++ b/language/oop5/iterations.xml
@@ -0,0 +1,105 @@
+
+
+
+ Iterazione degli oggetti
+
+
+ PHP fornisce un modo per definire gli oggetti in modo tale che sia possibile iterare
+ attraverso un elenco di elementi, ad esempio con un'istruzione &foreach;. Per impostazione predefinita,
+ tutte le proprietà visibili verranno utilizzate
+ per l'iterazione.
+
+
+
+
+ Iterazione semplice degli oggetti
+
+ $value) {
+ print "$key => $value\n";
+ }
+ }
+}
+
+$class = new MyClass();
+
+foreach($class as $key => $value) {
+ print "$key => $value\n";
+}
+echo "\n";
+
+
+$class->iterateVisible();
+
+?>
+]]>
+
+ &example.outputs;
+
+ value 1
+var2 => value 2
+var3 => value 3
+
+MyClass::iterateVisible:
+var1 => value 1
+var2 => value 2
+var3 => value 3
+protected => protected var
+private => private var
+]]>
+
+
+
+
+
+ Come mostra l'output, il &foreach; ha iterato attraverso tutte le
+ proprietà visibili a cui era possibile
+ accedere.
+
+
+
+ &reftitle.seealso;
+
+
+ Generatori
+ Iterator
+ IteratorAggregate
+ Iteratori SPL
+
+
+
+
+
+
diff --git a/language/oop5/object-comparison.xml b/language/oop5/object-comparison.xml
new file mode 100644
index 000000000..ba676b16e
--- /dev/null
+++ b/language/oop5/object-comparison.xml
@@ -0,0 +1,124 @@
+
+
+
+ Confronto tra oggetti
+
+ Quando si utilizza l'operatore di confronto (==),
+ le variabili oggetto vengono confrontate in modo semplice, ovvero: due istanze
+ di oggetto sono uguali se hanno gli stessi attributi e valori (i valori vengono confrontati con ==) e sono
+ istanze della stessa classe.
+
+
+ Quando si utilizza l'operatore di identità (===),
+ le variabili oggetto sono identiche se e solo se si riferiscono alla stessa
+ istanza della stessa classe.
+
+
+ Un esempio chiarirà queste regole.
+
+ Esempio di confronto tra oggetti
+
+flag = $flag;
+ }
+}
+
+class OtherFlag
+{
+ public $flag;
+
+ function __construct($flag = true) {
+ $this->flag = $flag;
+ }
+}
+
+$o = new Flag();
+$p = new Flag();
+$q = $o;
+$r = new OtherFlag();
+
+echo "Two instances of the same class\n";
+compareObjects($o, $p);
+
+echo "\nTwo references to the same instance\n";
+compareObjects($o, $q);
+
+echo "\nInstances of two different classes\n";
+compareObjects($o, $r);
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+ Le estensioni possono definire le proprie regole per il confronto dei loro oggetti
+ (==).
+
+
+
+
diff --git a/language/oop5/references.xml b/language/oop5/references.xml
new file mode 100644
index 000000000..5b60c0df5
--- /dev/null
+++ b/language/oop5/references.xml
@@ -0,0 +1,87 @@
+
+
+
+ Oggetti e riferimenti
+
+ Uno dei punti chiave della OOP di PHP che viene spesso menzionato è che
+ "gli oggetti vengono passati per riferimento per impostazione predefinita". Questo non è completamente vero.
+ Questa sezione rettifica questo pensiero generale utilizzando alcuni esempi.
+
+
+
+ Un riferimento PHP è un alias, che permette a due variabili diverse di scrivere
+ sullo stesso valore. In PHP, una variabile oggetto non contiene l'oggetto
+ stesso come valore. Contiene solo un identificatore di oggetto che permette
+ agli accessori dell'oggetto di trovare l'oggetto reale. Quando un oggetto viene inviato come
+ argomento, restituito o assegnato a un'altra variabile, le diverse variabili
+ non sono alias: contengono una copia dell'identificatore, che punta allo stesso
+ oggetto.
+
+
+
+ Riferimenti e Oggetti
+
+
+$b->foo = 2;
+echo $a->foo."\n";
+
+
+$c = new A;
+$d = &$c; // $c and $d are references
+ // ($c,$d) =
+
+$d->foo = 2;
+echo $c->foo."\n";
+
+
+$e = new A;
+
+function foo($obj) {
+ // ($obj) = ($e) =
+ $obj->foo = 2;
+}
+
+foo($e);
+echo $e->foo."\n";
+
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
diff --git a/language/oop5/serialization.xml b/language/oop5/serialization.xml
new file mode 100644
index 000000000..7b4401861
--- /dev/null
+++ b/language/oop5/serialization.xml
@@ -0,0 +1,112 @@
+
+
+
+ Serializzazione degli oggetti - oggetti nelle sessioni
+ Serializzazione degli oggetti
+
+
+ serialize restituisce una stringa contenente una
+ rappresentazione in flusso di byte di qualsiasi valore che può essere memorizzato in
+ PHP. unserialize può utilizzare questa stringa per
+ ricreare i valori originali delle variabili. Utilizzando serialize per
+ salvare un oggetto si salveranno tutte le variabili nell'oggetto. I
+ metodi nell'oggetto non verranno salvati, solo il nome della
+ classe.
+
+
+
+ Per poter deserializzare un oggetto con unserialize,
+ la classe di quell'oggetto deve essere definita. Ovvero, se si ha un oggetto
+ della classe A e lo si serializza, si otterrà
+ una stringa che fa riferimento alla classe A e contiene tutti i valori delle variabili
+ contenute in essa. Per poter deserializzare
+ questo in un altro file, un oggetto della classe A, la
+ definizione della classe A deve essere presente in quel file.
+ Questo può essere fatto, ad esempio, memorizzando la definizione della classe A
+ in un file di inclusione e includendo questo file o utilizzando la
+ funzione spl_autoload_register.
+
+
+
+
+one;
+ }
+ }
+
+// page1.php:
+
+ include "A.php";
+
+ $a = new A;
+ $s = serialize($a);
+ // memorizza $s dove page2.php può trovarlo.
+ file_put_contents('store', $s);
+
+// page2.php:
+
+ // questo è necessario perché unserialize funzioni correttamente.
+ include "A.php";
+
+ $s = file_get_contents('store');
+ $a = unserialize($s);
+
+ // ora usa la funzione show_one() dell'oggetto $a.
+ $a->show_one();
+?>
+]]>
+
+
+
+
+ Se un'applicazione serializza oggetti per un uso successivo, si raccomanda
+ vivamente di includere la definizione della classe per quell'oggetto
+ in tutta l'applicazione. Non farlo potrebbe risultare in un oggetto
+ deserializzato senza una definizione di classe, il che porterà PHP ad
+ assegnare all'oggetto la classe __PHP_Incomplete_Class_Name,
+ che non ha metodi e renderebbe l'oggetto inutilizzabile.
+
+
+
+ Quindi, se nell'esempio precedente $a diventasse parte di una sessione
+ aggiungendo una nuova chiave all'array superglobale $_SESSION, è necessario includere il
+ file A.php in tutte le pagine, non solo in page1.php
+ e page2.php.
+
+
+
+ Oltre al consiglio precedente, si noti che è possibile anche agganciarsi agli eventi di serializzazione
+ e deserializzazione su un oggetto utilizzando i metodi
+ __sleep() e
+ __wakeup(). L'utilizzo di
+ __sleep() permette anche di serializzare solo
+ un sottoinsieme delle proprietà dell'oggetto.
+
+
+