Introduction.
Une classe est un format de variable non scalaire, comprenant trois types de composants : 
La programmation orientée objet s’effectue en deux étapes : la définition des classes, puis leur utilisation. Une fois la classe définie, il est en effet possible de créer des objets, appelés "instances", au format de la classe définie. Toutefois, les composants déclarés avec le mot codice_4 sont persistants, et accessibles sans instanciation préalable.
Opérateur objet.
Pour accéder aux propriétés et méthodes d'un objet, on utilise l' : codice_5.
Opérateur de résolution de portée.
Pour accéder aux constantes, propriétés et méthodes statiques d'une classe, on utilise l' : codice_6.
Cet opérateur peut également être précédé de noms de classes ou des mots réservés suivants :
Inclusion.
À l'instar d'une bibliothèque de fonctions, une classe est généralement stockée dans un fichier dédié, qui peut porter son nom.
Elle s'inclut donc dans un programme de la même manière qu'une bibliothèque :
include('ma_classe.php');
// ou
require('ma_classe.php');
// ou
require_once('ma_classe.php');
Mais la syntaxe à privilégier est celle par espace de nom :
use mon_namespace/ma_classe;
Instanciation.
Une fois la classe incluse, on peut l'appeler.
Par défaut, PHP fournit déjà la classe suivante pour créer des objets anonymes :
$c = new stdClass();
var_dump($c);
Définition des classes.
Définir une nouvelle classe adopte la syntaxe suivante :
class nomObjet
 var $variable1;
 var $variable2;
 function maFonction1()
 ...code
 function maFonction2()
Il est possible d’attribuer une valeur par défaut. Le code dans la classe est alors codice_11. Cette syntaxe est économe puisqu'elle évite d'initialiser la variable à chaque appel des méthodes qui l'utilisent.
La définition de méthodes de classe est identique à celle de n’importe quelle fonction à la différence que lorsqu’elle fait référence à une variable de sa classe, codice_12 doit être :
De même pour exécuter une autre méthode de sa classe. ex :
class client
 var $aDitBonjour = false;
 function direBonjour()
 $this->message("Bonjour");
 function message($message)
 echo $message;
 $this->aDitBonjour = true;
Pour utiliser une variable qui n'est pas dans la classe ou exécuter les méthodes d'une autre classe, il faut les redéclarer avec codice_17 :
class client
 function message($message)
 global $InstanceAutreClasse;
 $InstanceAutreClasse->aDitBonjour = true;
Utilisation d’un objet.
Attention : la classe est la définition d’un format de variable personnalisable. Le code n’est pas exécuté et il est impensable d’introduire le code suivant qui n’aurait aucun sens :
class client
 for ($i=0; $i<5; $i++)
 echo "$i\n";
Une fois la classe définie, il va falloir créer des variables objet du format de la classe définie. On crée un objet par le code suivant :
$objet = new client();
Il faut bien entendu avoir préalablement défini la classe client. La variable codice_18 contient donc un objet. Pour accéder à une variable pour lui faire subir des modifications, il suffit d’entrer le code suivant :
$objet->variable1 = "Hello world";
Il est possible de lui faire subir les mêmes opérations qu’à une variable normale. De même pour exécuter une fonction :
$objet->maFonction();
Autant les méthodes une fois définies ne peuvent pas être modifiées, autant il est possible d’ajouter ou de supprimer des variables dans l’objet :
$objet->variable = "valeur"; // définition de variable
unset($objet->variable); // suppressions
L’objet est unique, de sorte que s’il est enregistré dans une autre variable et qu’une modification lui est faite, elle sera visible pour les deux variables :
//Le code reprend l'ancien script
$objet = new client();
$objet2 = $objet;
$objet2->direBonjour();
echo $objet->aDitBonjour;
//affiche true
Pour dupliquer une variable de type objet, il faut donc entrer le code suivant :
$objet2 = clone $objet;
La nouvelle variable sera différente de l’ancienne mais aura les mêmes valeurs.
Il est également possible d'exécuter la méthode d'un objet sans avoir créé de variable auparavant :
class Message
 function direBonjour()
 echo "salut";
/* Exécute la méthode */
Message::direBonjour();
Héritage.
PHP était initialement un langage à héritage simple, c'est-à-dire qu'une classe ne peut hériter que d'au plus une seule autre classe.
L'héritage consiste à transmettre les propriétés et méthodes d’une classe mère à une classe fille, en déclarant cette dernière avec codice_19. Ex :
class parent1
 var $varParent;
 function méthodeParente()
 print 'Je connais méthodeParente' . PHP_EOL;
class enfant extends parent1
 var $varEnfant;
 function méthodeEnfant()
 print 'Je connais méthodeEnfant' . PHP_EOL;
$Enfant1 = new enfant();
$Enfant1->méthodeParente();
L'héritage permet le , qui consiste à utiliser des variables ou méthodes dans des classes de plusieurs types, grâce à l'héritage.
Les classes filles bénéficieront automatiquement de toutes les propriétés et des méthodes de leur classe mère (qui n'a pas de limite dans le nombre de ses filles).
On peut aussi invoquer les méthodes parentes depuis la classe enfant :
class enfant2 extends parent1
 var $varEnfant;
 function méthodeEnfant()
 parent::méthodeParente();
 print 'Je connais méthodeEnfant2' . PHP_EOL;
$Enfant2 = new enfant2();
$Enfant2->méthodeEnfant();
Traits.
Depuis PHP 5.4.0, une structure de données appelée "" permet l'héritage multiple. Exemple d'utilisation :
<?php
trait MonTrait1
 function Hello()
 print 'Hello';
trait MonTrait2
 function World()
 print 'World';
class MaClasse1
 use MonTrait1;
 use MonTrait2;
 function __construct()
 $this->Hello();
 $this->World();
$Test = new MaClasse1;
De plus, ce type d'injection de dépendance est contraire au principe d'.
Final.
Pour empêcher une classe ou une méthode d'être étendue (et en faire donc une ou une ), on peut la déclarer avec le mot-clé codice_20. Ex :
final class MaClasseFinale
 ...
Classes abstraites.
La classe abstraite ne peut pas être instanciée, mais elle peut être appelée en statique. Comme pour l'héritage classiques, ses classes filles accèdent à ses attributs et méthodes publics et protégés.
Voici un exemple de :
abstract class MaClasseAbstraite
 public $var="Bonjour";
 abstract protected function MaMethode($var1, $var2);
 protected function MaMethode2($var1, $var2)
 return 'TODO';
Dans cet exemple, on voit que les méthodes d'une classe abstraite peuvent contenir du code, mais les méthodes abstraites non (elles ne définissent que les arguments
Closures.
Apparues avec PHP 5.3, les closures sont des classes avec des méthodes gérant les .
Classes anonymes.
Apparues avec PHP 7, les sont des classes sans nom, déclarées lors de l'exécution.
Interfaces.
Voici un exemple d' :
interface MonInterface
 public function setName($name);
 public function getName();
Et son utilisation : la classe doit reprendre les méthodes de l'interface sous peine d'erreur.
class MaClasse implements MonInterface
 private $myName;
 public function setName($name)
 print 'Définition de '.$name;
 $myName = $name;
 public function getName()
 print 'Récupération de '.$myName;
Namespaces.
Exemple d' :
namespace MonEspace\Nom;
const MYCONST = 1;
$a = new MaClasse;
$c = new \MonEspace\Nom\MaClasse;
$d = new \ClasseGlobale;
Pour utiliser un namespace, "use" conserve son nom mais on peut le changer avec "as" :
use MonEspace\Nom;
use SonEspace\Nom as NomExterne;
Depuis PHP7 on peut même importer plusieurs classes, fonctions ou constantes sur la même ligne :
 use MonEspace\{MaClasseA, MaClasseB as B};
Portée des variables.
Il est possible depuis PHP5 de préciser l'accès à certaines variables ou méthodes, en les déclarant à la place de codice_21 avec :
Exemple :
class CompteEnBanque
 private $argent = 0;
 private function ajouterArgent($valeur)
 $this->argent += $valeur;
 function gagnerArgent($valeur)
 $this->ajouterArgent($valeur);
$compte = new CompteEnBanque()
//les actions suivantes sont impossibles :
$compte->argent = 3000;
$compte->ajouterArgent(3000);
//l'action suivante est possible
$compte->gagnerArgent(3000);
En effet, il faut gagner de l’argent avant d’en ajouter à la banque (quoique...).
Les méthodes prédéfinies.
Il existe quelques méthodes prédéfinies qui s’exécutent automatiquement à des périodes de la vie de l’objet. Elles sont appelées "méthodes magiques", et leurs noms commencent toujours par deux underscores : 
Constructeur et destructeur.
Voici un exemple utilisant les méthodes :
//Définition de la classe
class Humain
 public $homme = false;
 public $femme = false;
 function __construct($type)
 if ($type=="homme")
 $this->homme=true;
 if ($type=="femme")
 $this->femme=true;
 function extremeOnction()
 echo 'Amen';
 function __destruct()
 $this->extremeOnction();
//C'est un garçon !
$homme = new Humain("homme");
if ($homme->homme) {
 echo "C'est un homme";
} elseif ($homme->femme) {
 echo "C'est une femme";
//mort de l'homme
unset($homme);
/*
La sortie sera
C'est un homme
Amen
Sous php4, le constructeur avait pour nom celui de la classe. Sous php5, si la fonction codice_36 n’est pas trouvée, l’interpréteur cherchera une méthode du même nom que la classe.
Copie en profondeur.
Il existe une méthode qui s’exécute lors d’une duplication de l’objet. Son nom est codice_39.
En effet, elle est utile car par défaut si $x = $y, $x n'est qu'une référence à $y et changer $x changera $y.
__get, __set, __call.
Ces méthodes permettent de rendre dynamique l'utilisation de la classe, et permettent la surcharge magique</code>.
__call().
La méthode codice_40 s'exécute quand une méthode appelée est inaccessible ou inexistante. Exemple :
 function __call($method,$arguments)
 echo "On a appelé $method sans succès avec les paramètres :<br/>";
 var_dump($arguments);
_get().
Cette méthode s'exécute quand une variable appelée est inaccessible ou inexistante. L'exemple ci-dessous lui permet de retourner une donnée dépendant du contenu de la variable codice_41. Important : le contenu de la variable codice_41 ne sera pas prioritaire sur le nom d'une variable interne à la classe.
class test
 public $a;
 private $b;
 function __construct($a,$b)
 $this->a=$a;
 $this->b=$b;
 function __get($nom)
 echo "On a appelé __get(\$$nom)";
// Utilisation
$var=new test(5,10);
echo $var->a; // affiche : "5"
echo '<br/>';
echo $var->b; // affiche : "On a appelé __get($b)". En effet, b est privée et ne peut donc pas être accédée.
echo '<br/>';
echo $var->__get('a'); // affiche : "On a appelé __get($a)"
echo '<br/>';
echo $var->c; // affiche : "On a appelé __get($c)"
On voit ici que PHP va chercher en priorité à retourner une variable interne, mais si elle est privée ou inexistante, il prendra le résultat du codice_43. 
Exemple de réécriture de la méthode codice_43 ci-dessus pour accéder à la variable privée :
function __get($nom)
 if ($nom == 'b') {
 echo $this->b;
__set().
Cette méthode s'exécute quand on modifie une variable inaccessible ou inexistante. Exemple :
class test2
 public $a;
 private $b;
 function __construct($a,$b)
 $this->a=$a;
 $this->b=$b;
 function __get($nom)
 echo 'get '.$nom;echo '<br/>';
 function __set($nom,$value)
 echo 'set '.$nom.' '.$value;echo '<br/>';
$var=new test2(5,10);
$var->a=6;
echo $var->a; // affiche 6
echo '<br/>';
$var->b=11; // appelle __set('b',11)
echo $var->b; // appelle __get('b')
__autoload().
Cette méthode se déclenche lors de l', c'est-à-dire quand le programme charge une autre classe (lors de son instanciation ou invocation statique). Elle permet donc de lever les exceptions si par exemple la classe demandée n'existe pas.
Le code ci-dessous affiche :
<?php
function __autoload($ClasseDistante)
 throw new Exception($ClasseDistante . ' est introuvable !');
try {
 $ClasseDistante1 = new ClasseDistante();
} catch (Exception $ex) {
 echo $ex->getMessage(), "<br/>";
try {
 $ClasseDistante2 = ClasseDistante::MethodeStatique();
} catch (Exception $ex) {
 echo $ex->getMessage(), "<br/>";
?>
__sleep() et __wakeup().
Ces méthodes ne fonctionnent plus avec l'interface "Serializable" depuis PHP 8.1, au profit de serialize et unserialize.
Elles permettent respectivement de sauvegarder et restaurer l'état d'un objet, pour qu'il soit fonctionnel après une sérialisation / désérialisation. C'est utile par exemple pour se reconnecter à une base de données.
__invoke().
Cette méthode rend la classe invocable, c'est-à-dire qu'après instanciation, elle s'exécute si on l'appelle comme une méthode. Ex :
$maClasse = new MaClasse();
return $maClasse();
Quelques fonctions intégrées.
Voici quelques fonctions en relation avec la programmation orientée objet qui peuvent vous être utiles.
self().
Une classe peut s'instancier elle-même avec codice_45.
class_exists().
Vérifie qu’une classe existe. Renvoie une valeur booléenne. ex :
if (class_exists('maClasse'))
 $var = new maClasse();
get_class_methods().
Retourne toutes les méthodes d’une classe sous forme de tableau. Ex :
$maClasse = new Classe();
$methodes = get_class_methods($maClasse);
print_r($methodes);
get_class_vars().
Retourne tous les attributs d'une classe (dont la portée est accessible, donc généralement les publiques), ainsi que leurs valeurs par défaut sous forme de tableau. Ex :
$attributs = get_class_vars('Classe');
print_r($attributs);
// Fonctionne aussi avec les instances :
$maClasse = new Classe();
$attributs = get_class_vars(get_class($maClasse));
print_r($attributs);
Peut donc servir pour un "foreach" propriétés de la classe.
Pour récupérer ou filtrer les attributs privés, utiliser codice_46 :
$reflecttion = new \ReflectionClass('Classe');
print_r($reflection->getProperties());
get_object_vars().
Idem avec les valeurs courantes de l'objet instance de classe.
method_exists($classe, $méthode).
Teste sur une méthode existe dans une classe.
serialize() et unserialize().
Assurent la transformation du flux de données, en précisant les types des variables et index des tableaux. Exemple :
 $Hello = 'Hello World';
 var_dump($Hello); // string(11) "Hello World" 
 $Hello = serialize($Hello);
 print $Hello; // s:11:"Hello World";
 $Hello = array('Hello', 'World');
 $Hello = serialize($Hello);
Le préfixe "a:2" signifie "array of 2 lines", et il est obligatoire pour désérialiser.