Wikilivres

Programmation PHP/Programmation orientée objet

< Programmation PHP
Sécurité Sécurité
Bases de données Bases de données

[ Modifier le sommaire ]

Sécurité Sécurité
Bases de données Bases de données

Introduction

modifier

Une classe est un format de variable non scalaire, comprenant trois types de composants :

  1. des constantes, accessibles par réflexion avec $maClasse::getConstants().
  2. des variables appelées "propriétés", accessibles avec $maClasse::getProperties().
  3. des fonctions appelées "méthodes", accessibles avec $maClasse::getMethods().

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 static sont persistants, et accessibles sans instanciation préalable.

Opérateur objet

modifier

Pour accéder aux propriétés et méthodes d'un objet, on utilise l'opérateur object : ->.

Opérateur de résolution de portée

modifier

Pour accéder aux constantes, propriétés et méthodes statiques d'une classe, on utilise l'opérateur de résolution de portée : ::.

Cet opérateur peut également être précédé de noms de classes ou des mots réservés suivants[1] :

  • $this : l'objet courant.
  • parent : la classe parente.
  • static : la classe courante.
  • self : la classe parente puis la courante s'il n'y a rien[2].

 

Le mot-réservé static a donc deux sens : un pour les déclarations et un pour les appels.

Inclusion

modifier

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

 

En PHP, l'inclusion doit précéder les appels du code qui y figure.

 Les classes et fonctions globales peuvent être appelées directement dans le code, ou avec le préfixe "\" (signifiant "namespace global"). Mais il existe aussi use function ma_fonction pour déclarer l'utilisation d'une fonction.
 Avant PHP7.4, on pouvait mettre une URL dans ces fonctions, si la configuration allow_url_include=1[3]. Ex : require_once("http://example.com/");

Instanciation

modifier

Une fois la classe incluse, on peut l'appeler.

  • Directement pour une classe statique.
  • Après instanciation sinon. Elle est réalisée par le mot-clé "new".

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

modifier

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 var $variable1 = valeur;. 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, $variable doit être :

  • $this->variable pour cibler l'objet instancié (et $this::constante, $this->méthode()).
  • self::variable pour cibler la classe statique.


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

class client
{
  function message($message)
  {
    global $InstanceAutreClasse;
    $InstanceAutreClasse->aDitBonjour = true;
  }

}

Utilisation d’un objet

modifier

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

modifier

PHP était initialement un langage à héritage simple[4], 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 extends. 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 polymorphisme, 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[5]).

 

Les interfaces peuvent par contre bénéficier d'un héritage multiple.

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

modifier

Depuis PHP 5.4.0, une structure de données appelée "trait" 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;

 

Les traits sont limités par rapport aux classes :

  • Un trait ne peut pas contenir de constante.
  • Un trait ne peut pas hériter d'une classe, il doit utiliser un autre trait à la place.

De plus, ce type d'injection de dépendance est contraire au principe SOLID d'inversion des dépendances.

Final

modifier

Pour empêcher une classe ou une méthode d'être étendue (et en faire donc une classe finale ou une méthode finale), on peut la déclarer avec le mot-clé final. Ex : 

final class MaClasseFinale
{
    ...
}

Classes abstraites

modifier

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 classe abstraite : 

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[6]

 

Les méthodes abstraites sont obligatoirement à implémenter par les classes filles.

Closures

modifier

Apparues avec PHP 5.3[7], les closures sont des classes avec des méthodes gérant les fonctions anonymes.

Classes anonymes

modifier

Apparues avec PHP 7[8], les classes anonymes sont des classes sans nom, déclarées lors de l'exécution.

Interfaces

modifier

Voici un exemple d'interface : 

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

 

  • Les méthodes d'une interface ne peuvent pas contenir de code.
  • Une classe ou une interface ne peut implémenter qu'une ou plusieurs interfaces (donc pas d'implémentation de classe).
  • Une interface ne peut hériter que d'une autre interface[9].
  • Toutes les méthodes d'une interface doivent être publiques.
  • Si un objet hérite et implémente, toujours le déclarer en plaçant le extends avant le implements.

Namespaces

modifier

Exemple d'espace de noms : 

namespace MonEspace\Nom;

class MaClasse {}
function MaMethode() {}
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

modifier

Il est possible depuis PHP5 de préciser l'accès à certaines variables ou méthodes, en les déclarant à la place de var avec :

  • public : visible dans tout le programme.
  • protected : visible uniquement dans les instances de la classe et de ses sous-classes.
  • private : visible uniquement dans les instances de la classe.

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

 

Ce code retournera un message d’erreur s'il est exécuté sous PHP5 ou une version ultérieure.

Les méthodes prédéfinies

modifier

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[10], et leurs noms commencent toujours par deux underscores :

  1. __call() : à chaque appel d'une méthode de la classe.
  2. __callStatic() : à chaque appel statique d'une méthode de la classe.
  3. __clone() : lors du clonage de l'objet (via la fonction "clone").
  4. __construct() : à l'instanciation de la classe.
  5. __debugInfo() : modifie les résultats des var_dump().
  6. __destruct() : à la suppression de l'objet instancié.
  7. __get() : à la lecture de propriétés inexistantes ou interdites.
  8. __invoke() : à l'appel de l'objet comme une fonction (ex : echo $object(1)).
  9. __isset() : à l'appel de isset() (ou empty()) sur des propriétés inexistantes ou interdites.
  10. __serialize() : à l'appel de serialize().
  11. __set() : à l'écriture de propriétés inexistantes ou interdites.
  12. __set_state() : modifie les résultats des var_export().
  13. __sleep() : à l'appel de serialize(), pour en modifier le résultat.
  14. __toString() : à l'appel de l'objet comme une chaine de caractères (ex : echo $object).
  15. __unserialize() : à l'appel de serialize().
  16. __unset() : à l'appel de unset() sur des propriétés inexistantes ou interdites.
  17. __wakeup() : à l'appel de unserialize(), pour en modifier le résultat.

Constructeur et destructeur

modifier
__construct()
Cette méthode s’exécute lors de la création de l’objet. On entre alors les attributs potentiels de la fonction lors de sa création. Cette méthode est appelée "le constructeur"
__destruct()
Cette méthode s’exécute au contraire au moment de la destruction de la variable. Elle est appelée "le 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 __construct() n’est pas trouvée, l’interpréteur cherchera une méthode du même nom que la classe.

Copie en profondeur

modifier

Il existe une méthode qui s’exécute lors d’une duplication de l’objet. Son nom est __clone().

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

modifier

Ces méthodes permettent de rendre dynamique l'utilisation de la classe, et permettent la surcharge magique[11].

__call()

modifier

La méthode __call() 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()

modifier

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 $nom. Important : le contenu de la variable $nom 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 __get.

 

Ne jamais accéder à une variable de classe privée dans son __get() sous peine de boucle infinie.

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

function __get($nom)
{
    if ($nom == 'b') {
        echo $this->b;
    }
}

__set()

modifier

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

modifier

Cette méthode se déclenche lors de l'autochargement, 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 :

  • Avant PHP 5.3.0, Fatal error: Class 'ClasseDistante' not found in C:\Program Files (x86)\EasyPHP\data\localweb\WL.php on line 7.
  • Après, ClasseDistante est introuvable !
<?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()

modifier

Ces méthodes ne fonctionnent plus avec l'interface Serializable depuis PHP 8.1, au profit de serialize et unserialize[12].

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

modifier

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

modifier

Voici quelques fonctions en relation avec la programmation orientée objet qui peuvent vous être utiles.

self()

modifier

Une classe peut s'instancier elle-même avec new self();.

class_exists()

modifier

Vérifie qu’une classe existe. Renvoie une valeur booléenne. ex : 

if (class_exists('maClasse'))
    $var = new maClasse();

get_class_methods()

modifier

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

modifier

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 \ReflectionClass::getProperties[13] : 

$reflecttion = new \ReflectionClass('Classe');
print_r($reflection->getProperties());

get_object_vars()

modifier

Idem avec les valeurs courantes de l'objet instance de classe.

method_exists($classe, $méthode)

modifier

Teste sur une méthode existe dans une classe.

serialize() et unserialize()

modifier

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');
    var_dump($Hello);      // array(2) { [0]=> string(5) "Hello" [1]=> string(5) "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.

Références

modifier
  1. ↑ http://php.net/manual/fr/language.oop5.paamayim-nekudotayim.php
  2. ↑ https://www.php.net/manual/fr/language.oop5.static.php#104823
  3. ↑ https://www.php.net/manual/fr/filesystem.configuration.php
  4. ↑ Sébastien Rohaut, Algorithmique : Techniques fondamentales de programmation (avec des exemples en PHP), Editions ENI, (lire en ligne)
  5. ↑ http://php.net/manual/fr/language.oop5.basic.php
  6. ↑ http://php.net/manual/fr/language.oop5.abstract.php
  7. ↑ http://php.net/manual/fr/class.closure.php
  8. ↑ https://secure.php.net/manual/fr/language.oop5.anonymous.php
  9. ↑ https://www.safaribooksonline.com/library/view/php-5-power/013147149X/013147149X_ch03lev1sec14.html
  10. ↑ http://php.net/manual/fr/language.oop5.magic.php
  11. ↑ http://php.net/manual/fr/language.oop5.overloading.php
  12. ↑ https://www.php.net/manual/en/class.serializable.php
  13. ↑ https://www.php.net/manual/fr/reflectionclass.getproperties.php
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmation_PHP/Programmation_orientée_objet&oldid=691740 »