« Programmation PHP/Programmation orientée objet » : différence entre les versions

 

Elle s'inclut donc dans un programme de la même manière qu'une bibliothèque :

include('ma_classe.php');

// ou

// ou

require_once('ma_classe.php');

 

Mais la syntaxe à privilégier est celle par espace de nom :

use mon_namespace/ma_classe;

 

{{attention|En PHP, l'inclusion doit précéder les appels du code qui y figure.|clear=left}}

 

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

{

 

}

 

Il est possible d’attribuer une valeur par défaut. Le code dans la classe est alors <code>var $variable1 = valeur;</code>. Cette syntaxe est économe puisqu'elle évite d'initialiser la variable à chaque appel des méthodes qui l'utilisent.

 

De même pour exécuter une autre méthode de sa classe. ex :

class client

{

 

}

 

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 <code>global</code> :

class client

{

 

}

 

== 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

{

 

}

 

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 <code>$objet</code> 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

 

 

//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

{

/* Exécute la méthode */

Message::direBonjour();

 

== Héritage ==

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 <code>extends</code>. Ex :

 

class parent1

{

$Enfant1 = new enfant();

$Enfant1->méthodeParente();

 

L'héritage permet le {{w|Polymorphisme (informatique)|polymorphisme}}, qui consiste à utiliser des variables ou méthodes dans des classes de plusieurs types, grâce à l'héritage.

 

On peut aussi invoquer les méthodes parentes depuis la classe enfant :

class enfant2 extends parent1

{

$Enfant2 = new enfant2();

$Enfant2->méthodeEnfant();

 

=== Traits ===

Depuis PHP 5.4.0, une structure de données appelée "{{wt|trait}}" permet l'héritage multiple. Exemple d'utilisation :

<?php

trait MonTrait1

$Test = new MaClasse1;

?>

 

== Classes abstraites ==

 

Voici un exemple de {{w|classe abstraite}} :

abstract class MaClasseAbstraite

{

abstract public function MaMethode($var1, $var2);

}

 

{{attention|

== Interfaces ==

Voici un exemple d'{{w|Interface (programmation orientée objet)|interface}} :

interface MonInterface

{

public function getName();

}

 

Et son utilisation : la classe doit reprendre les méthodes de l'interface sous peine d'erreur.

class MaClasse implements MonInterface

{

}

}

 

{{attention|

== Namespaces ==

Exemple d'{{w|Espace_de_noms_(informatique)|espace de noms}} :

namespace MonEspace\Nom;

 

$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;

 

== Portée des variables ==

 

Exemple :

class CompteEnBanque

{

 

$compte->gagnerArgent(3000);

 

En effet, il faut gagner de l’argent avant d’en ajouter à la banque (quoique...).

Voici un exemple utilisant les méthodes :

 

//Définition de la classe

 

Amen

*/

 

Sous php4, le constructeur avait pour nom celui de la classe. Sous php5, si la fonction <code>__construct()</code> n’est pas trouvée, l’interpréteur cherchera une méthode du même nom que la classe.

==== __call() ====

La méthode <code>__call()</code> s'exécute quand une méthode appelée est inaccessible ou inexistante. Exemple :

function __call($method,$arguments)

{

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 <code>$nom</code>. Important : le contenu de la variable <code>$nom</code> ne sera pas prioritaire sur le nom d'une variable interne à la classe.

 

class test

{

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 <code>__get</code>.

 

Exemple de réécriture de la méthode <code>__get</code> ci-dessus pour accéder à la variable privée :

function __get($nom)

{

}

}

 

==== __set() ====

Cette méthode s'exécute quand on modifie une variable inaccessible ou inexistante. Exemple :

 

class test2

{

$var->b=11; // appelle __set('b',11)

echo $var->b; // appelle __get('b')

 

=== __autoload() ===

* Après, ''ClasseDistante est introuvable !''

 

<?php

function __autoload($ClasseDistante)

}

?>

 

=== __sleep() et __wakeup() ===

=== __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 ==

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);

$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 <code>\ReflectionClass::getProperties</code><ref>https://www.php.net/manual/fr/reflectionclass.getproperties.php</ref> :

 

$reflecttion = new \ReflectionClass('Classe');

print_r($reflection->getProperties());

 

=== get_object_vars() ===

=== 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; // a:2:{i:0;s:5:"Hello";i:1;s:5:"World";}

 

Le préfixe "a:2" signifie "array of 2 lines", et il est obligatoire pour désérialiser.