Programmation PHP/Programmation orientée objet

Programmation PHP

• Introduction
• Installer PHP
• Composer
• IDE
  • PhpStorm
  • NetBeans
  • Eclipse
  • Visual Studio Code
• Bases du langage
  • Commentaires
  • Premier programme
  • Variables
  • Variables superglobales
  • Constantes
  • Opérateurs
  • Fonctions
  • Tableaux
  • Structures de contrôle
  • Boucles
• Programmation avancée
  • Dates
  • Sessions
  • Cookies
  • Cache
    • Memcached
    • Redis
  • Formulaire
  • Fichiers
    • Objets COM
    • Images
  • Mails
  • Sécurité
  • Programmation orientée objet
  • Bases de données
    • Microsoft SQL Server
    • MySQL
    • PDO
    • SQLite
  • Expressions rationnelles
  • Code de haute qualité
    • Analyse statique de programmes
  • Exceptions
  • Xdebug
  • Mots réservés
• Apprendre par l'exemple
  1. Utilisation de variables
  2. Un sommaire simple
  3. Interaction avec un formulaire
  4. Afficher le résultat d'une requête BDD
  5. Modifier une table
  6. Faire un livre d'or
  7. Faire un mini forum de discussion
  8. Parser avec DomXml
  9. Coder en MVC
  10. Faire un webservice
  11. Vérification RIO
  • AJAX
  1. Sommaire en Ajax
  2. Mise à jour périodique d'un cadre
  • Mini CMS
  1. Introduction
  2. Développement
     • Les couches choisies
     • Code de service
     • Modélisation
     • Implémentation
     • La vue
     • Ajaxification
     • Premier noyau
     • Fournir les données
     • IHM
  3. Rétrospective
  4. Conclusion
• Extensions PHP
  • cURL
  • DOMDocument
  • JSON
  • MING
  • SPL
• Bibliothèques externes
  • ADODB
  • DOMPDF
  • FPDF
  • PHPExcel
  • PHPMailer
  • PHPWord
  • RabbitMQ
• Cadriciels
  • CakePHP
  • PEAR
  • Symfony
  • Frameworks de tests
    • PHPUnit
    • SimpleTest
    • Behat
• Logiciels métier
• Problèmes connus

Introduction

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

Par ailleurs, le mot-clé static peut aussi être utilisé avant l'opérateur de résolution de portée ::, pour accéder aux propriétés statiques d'une méthode. Au passage, cet opérateur peut également être précédés de noms de classes ou des mots réservés this, parent, et self

Définition des classes

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

Toutefois, son code n'est pas pour autant utilisable car il faut d'abord l'instancier.

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

Par défaut, PHP fournit déjà la classe suivante pour créer des objets anonymes :

$c = new stdClass();
var_dump($c);

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

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

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

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

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

Classes abstraites

Voici un exemple de classe abstraite :

class abstract MaClasseAbstraite
{
    public $var="Bonjour";
    abstract public function MaMethode($var1, $var2);
}

• 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 fonctions anonymes.

Classes anonymes

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

Interfaces

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

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;

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

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 :

1. __call()
2. __callStatic()
3. __clone()
4. __construct()
5. __debugInfo()
6. __destruct()
7. __get()
8. __invoke()
9. __isset()
10. __set()
11. __set_state()
12. __sleep()
13. __toString()
14. __unset()
15. __wakeup()

Constructeur et destructeur

__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

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

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

__call()

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

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

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

Ces méthodes 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.

Quelques fonctions intégrées

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

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, ainsi que leurs valeurs par défaut sous forme de tableau. Ex :

$maClasse = new Classe();
$attributs = get_class_vars($maClasse);
print_r($attributs);

Peut donc servir pour un "foreach" propriétés de la classe.

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