Différences entre les versions de « Programmation PHP/Programmation orientée objet »

m
<source> -> <syntaxhighlight> (phab:T237267)
m (<source> -> <syntaxhighlight> (phab:T237267))
 
Elle s'inclut donc dans un programme de la même manière qu'une bibliothèque :
<sourcesyntaxhighlight lang=php>
include('ma_classe.php');
// ou
// ou
require_once('ma_classe.php');
</syntaxhighlight>
</source>
 
Mais la syntaxe à privilégier est celle par espace de nom :
<sourcesyntaxhighlight lang=php>
use mon_namespace/ma_classe;
</syntaxhighlight>
</source>
 
{{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 :
<sourcesyntaxhighlight lang=php>
$c = new stdClass();
var_dump($c);
</syntaxhighlight>
</source>
 
== Définition des classes ==
Définir une nouvelle classe adopte la syntaxe suivante :
<sourcesyntaxhighlight lang="php">
class nomObjet
{
 
}
</syntaxhighlight>
</source>
 
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 :
<sourcesyntaxhighlight lang="php">
class client
{
 
}
</syntaxhighlight>
</source>
 
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> :
<sourcesyntaxhighlight lang="php">
class client
{
 
}
</syntaxhighlight>
</source>
 
== 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 :
 
<sourcesyntaxhighlight lang="php">
class client
{
 
}
</syntaxhighlight>
</source>
 
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 :
 
<sourcesyntaxhighlight lang="php">
$objet = new client();
</syntaxhighlight>
</source>
 
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 :
 
<sourcesyntaxhighlight lang="php">
$objet->variable1 = "Hello world";
</syntaxhighlight>
</source>
 
Il est possible de lui faire subir les mêmes opérations qu’à une variable normale. De même pour exécuter une fonction :
 
<sourcesyntaxhighlight lang="php">
$objet->maFonction();
</syntaxhighlight>
</source>
 
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 :
 
<sourcesyntaxhighlight lang="php">
$objet->variable = "valeur"; // définition de variable
 
unset($objet->variable); // suppressions
</syntaxhighlight>
</source>
 
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 :
 
<sourcesyntaxhighlight lang="php">
//Le code reprend l'ancien script
 
 
//affiche true
</syntaxhighlight>
</source>
 
Pour dupliquer une variable de type objet, il faut donc entrer le code suivant :
<sourcesyntaxhighlight lang="php">
$objet2 = clone $objet;
</syntaxhighlight>
</source>
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 :
 
<sourcesyntaxhighlight lang="php">
class Message
{
/* Exécute la méthode */
Message::direBonjour();
</syntaxhighlight>
</source>
 
== 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 :
 
<sourcesyntaxhighlight lang="php">
class parent1
{
$Enfant1 = new enfant();
$Enfant1->méthodeParente();
</syntaxhighlight>
</source>
 
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 :
<sourcesyntaxhighlight lang="php">
class enfant2 extends parent1
{
$Enfant2 = new enfant2();
$Enfant2->méthodeEnfant();
</syntaxhighlight>
</source>
 
=== Traits ===
Depuis PHP 5.4.0, une structure de données appelée "{{wt|trait}}" permet l'héritage multiple. Exemple d'utilisation :
<sourcesyntaxhighlight lang=php>
<?php
trait MonTrait1
$Test = new MaClasse1;
?>
</syntaxhighlight>
</source>
 
== Classes abstraites ==
 
Voici un exemple de {{w|classe abstraite}} :
<sourcesyntaxhighlight lang=php>
abstract class MaClasseAbstraite
{
abstract public function MaMethode($var1, $var2);
}
</syntaxhighlight>
</source>
 
{{attention|
== Interfaces ==
Voici un exemple d'{{w|Interface (programmation orientée objet)|interface}} :
<sourcesyntaxhighlight lang=php>
interface MonInterface
{
public function getName();
}
</syntaxhighlight>
</source>
 
Et son utilisation : la classe doit reprendre les méthodes de l'interface sous peine d'erreur.
<sourcesyntaxhighlight lang=php>
class MaClasse implements MonInterface
{
}
}
</syntaxhighlight>
</source>
 
{{attention|
== Namespaces ==
Exemple d'{{w|Espace_de_noms_(informatique)|espace de noms}} :
<sourcesyntaxhighlight lang="php">
namespace MonEspace\Nom;
 
$c = new \MonEspace\Nom\MaClasse;
$d = new \ClasseGlobale;
</syntaxhighlight>
</source>
 
Pour utiliser un namespace, "use" conserve son nom mais on peut le changer avec "as" :
<sourcesyntaxhighlight lang="php">
use MonEspace\Nom;
use SonEspace\Nom as NomExterne;
</syntaxhighlight>
</source>
 
== Portée des variables ==
 
Exemple :
<sourcesyntaxhighlight lang="php">
class CompteEnBanque
{
 
$compte->gagnerArgent(3000);
</syntaxhighlight>
</source>
 
En effet, il faut gagner de l’argent avant d’en ajouter à la banque (quoique...).
Voici un exemple utilisant les méthodes :
 
<sourcesyntaxhighlight lang="php">
//Définition de la classe
 
Amen
*/
</syntaxhighlight>
</source>
 
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 :
<sourcesyntaxhighlight lang="php">
function __call($method,$arguments)
{
var_dump($arguments);
}
</syntaxhighlight>
</source>
 
==== _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.
 
<sourcesyntaxhighlight lang="php">
class test
{
echo '<br/>';
echo $var->c; // affiche : "On a appelé __get($c)"
</syntaxhighlight>
</source>
 
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 :
<sourcesyntaxhighlight lang="php">
function __get($nom)
{
}
}
</syntaxhighlight>
</source>
 
==== __set() ====
Cette méthode s'exécute quand on modifie une variable inaccessible ou inexistante. Exemple :
 
<sourcesyntaxhighlight lang="php">
class test2
{
$var->b=11; // appelle __set('b',11)
echo $var->b; // appelle __get('b')
</syntaxhighlight>
</source>
 
=== __autoload() ===
* Après, ''ClasseDistante est introuvable !''
 
<sourcesyntaxhighlight lang=php>
<?php
function __autoload($ClasseDistante)
}
?>
</syntaxhighlight>
</source>
 
=== __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 :
<sourcesyntaxhighlight lang=php>
$maClasse = new MaClasse();
return $maClasse();
</syntaxhighlight>
</source>
 
== Quelques fonctions intégrées ==
Vérifie qu’une classe existe. Renvoie une valeur booléenne. ex :
 
<sourcesyntaxhighlight lang="php">
if (class_exists('maClasse'))
$var = new maClasse();
</syntaxhighlight>
</source>
 
=== get_class_methods() ===
Retourne toutes les méthodes d’une classe sous forme de tableau. Ex :
 
<sourcesyntaxhighlight lang="php">
$maClasse = new Classe();
$methodes = get_class_methods($maClasse);
print_r($methodes);
</syntaxhighlight>
</source>
 
=== 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 :
 
<sourcesyntaxhighlight lang="php">
$attributs = get_class_vars('Classe');
print_r($attributs);
$attributs = get_class_vars(get_class($maClasse));
print_r($attributs);
</syntaxhighlight>
</source>
 
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> :
 
<sourcesyntaxhighlight lang="php">
$reflecttion = new \ReflectionClass('Classe');
print_r($reflection->getProperties());
</syntaxhighlight>
</source>
 
=== 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 :
<sourcesyntaxhighlight lang=php>
$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";}
</syntaxhighlight>
</source>
 
Le préfixe "a:2" signifie "array of 2 lines", et il est obligatoire pour désérialiser.
1 535

modifications