PHP/Classes

**Classes**
Leçon : PHP

Chapitre n^o 7
Chap. préc. :	Fonctions
Chap. suiv. :	Base de données

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Classes
PHP/Classes », n'a pu être restituée correctement ci-dessus.

Théorie générale sur la POO

La programmation orientée objet est un style de programmation qui associe à des éléments réels (un panier d'achat, par exemple), une série de variables et de fonctions.

Dans le domaine de la POO, la fonction d’un objet est appelée méthode et une variable attribut.

Pour que PHP puisse comprendre de quoi nous parlons, il est nécessaire de lui expliquer ce que représente l'objet, nous créons donc une classe d'objet.

Utilisation des classes

En PHP, la création d’une classe se fait en utilisant le mot-clé class suivit du nom de la classe puis d’un bloc d'instruction présentant les attributs et les méthodes de l'objet.

La déclaration d’une classe en PHP ressemble à ça :

Principe

class MaClasse {
    var $un_attribut;

    function une_methode() {
        return true;
    }
}

Les attributs sont assimilables à des variables local (un peu comme celles créées dans les fonctions, mais qui ne sont pas détruite tant que l’objet existe).

Il est possible d'attribuer des valeurs par défaut aux attributs en utilisant la syntaxe suivante :

Principe

class MaClasse {
    var $un_attribut = 'La valeur par default'; 
    /* À chaque création d’un objet de classe MaClasse, il sera automatiquement 
       doté d’un attribut $un_attribut contenant la chaine de caractères 
       'La valeur par default' */

    function une_methode() {
        return true;
    }
}

Une fois la classe définie, on peut l’utiliser. On va pour cela créer un objet de type MaClasse en utilisant le mot réservé new :

Principe

$mon_objet = new MaClasse;

La variable $mon_objet est désormais un objet de classe/type MaClasse (également appelé instance de MaClasse) et possède les attributs et méthodes définis plus haut. L'accès à ces informations s'effectue en utilisant ->.

Utilisation des attributs

Pour accéder à l'attribut $un_attribut, on écrit :

Principe

$mon_objet->un_attribut;

Attention! Pour accéder à un attribut, il ne faut pas utiliser le dollar $! Autrement, vous accédez à l'attribut portant le même nom que le contenu de la variable $un_attribut

Exemple

$mon_objet = new MaClasse;

$mon_objet->un_attribut; // Accède à l'attribut "un_attribut"

$un_attribut = 'attribut2';
$mon_objet->$un_attribut; // Accède à l'attribut "attribut2", puisque la variable $un_attribut vaut attribut2.

L'espace de nom d’un objet est totalement séparé du reste du script. Deux variables, une dans l'espace de nom global (le script normal) peut porter le même nom que l'attribut d’un objet sans pour autant pointé vers le même contenu.

Il n’est pas obligatoire d'écrire les attributs dans la classe. Il est possible d'accéder à tout moment, à n’importe quel attribut de l'objet, pour autant que son nom soit un nom de variable valide.

Chaque objet possède ses propres attributs.

Principe

$objet1 = new MaClasse;
$objet2 = new MaClasse; // Deux objet de type MaClasse

$objet1->nom = 'Dupont'; // L'attribut nom de l’objet 1 vaut Dupont
$objet2->nom = 'Smith'; // L'attribut nom de l’objet 2 vaut Smith

echo $objet1->nom; // Affichera bien 'Dupont' et pas 'Smith'

Utilisation des méthodes

L'utilisation des méthodes est plus ou moins similaire à l’utilisation des attributs.

Par exemple, pour accéder à la méthode une_methode() définie plus haut, on va utiliser :

Principe

$mon_objet = new MaClasse;

$mon_objet->une_methode();

Les méthodes fonctionnent exactement comme les fonctions classiques de PHP.

De la même façon que les attributs, les méthodes possèdent un espace de nom séparé ; il est donc possible d'appeler une méthode str_replace(), même si cette fonction est définie par PHP.

Auto-Référence

Lors de la création de méthode d'objet, il peut être nécessaire d'accéder aux attributs de ce même objet, pour les modifier par exemple.

Vous pouvez alors utiliser l’objet magique $this représentant l’objet lui-même.

Principe

class MonClient {
    var $nom = 'Dupont'; 

    function smithize() {
        $this->nom = 'Smith'; // Change l'attribut $nom de l'objet
    }
}

$client = new MonClient;
echo $client->nom; // Affiche 'Dupont'

$client->smithize();
echo $client->nom; // Affiche 'Smith'

Constructeur

La programmation orientée objets basique en PHP permet l’utilisation des constructeurs. Il s'agit d’une méthode particulière destinée à initialiser l'objet.

Dans une classe, il ne peut y avoir qu'un seul constructeur.

En PHP4, afin qu'elle soit reconnue comme telle, elle doit porter le même nom que la classe (attention aux majuscules). En PHP5, le constructeur fait appel à une méthode au nom prédéfini, "__construct".

Syntaxe PHP 4

Principe

class MonClient {
    var $nom; 

    function MonClient($nom) {
        $this->nom = $nom;
    }
}

Syntaxe PHP5

Principe

class MonClient {
    public $nom; 

    function __construct($nom) {
        $this->nom = $nom;
    }
}

Dans ce cas, lors de la création de l’objet (l'instanciation), on précise le nom du client comme si l’on appelait la fonction.

Principe

$client = new MonClient('Dupont');
echo $client->nom; // Affiche Dupont

Pour rendre optionnelles les parenthèses, tous les paramètres de la méthode doivent être optionnels :

Syntaxe PHP4

Principe

class MonClient {
    var $nom; 

    function MonClient($nom = '') {
        $this->nom = $nom;
    }
}

Syntaxe PHP5

Principe

class MonClient {
    public $nom; 

    function __construct($nom = '') {
        $this->nom = $nom;
    }
}

Principe

$client = new MonClient('Dupont');
echo $client->nom; // Affiche Dupont

$client = new MonClient; // Ne produit pas d'erreur
echo $client->nom; // N'affiche rien, l'attribut $nom vaut une chaine de caractères vide

Destructeur

La destruction d’une instance se fait automatiquement à la fin d'exécution d’un script mais peut être décorée :)

Syntaxe PHP5

Principe

class MonClient {
    public $nom; 

    function __destruct() {
        $this->save();
        echo 'Mon client est mort mais sauvegardé';
    }
}

AutoLoad

Pour utiliser une classe il faut l'avoir

Syntaxe PHP5

Fichier autoload.php

Principe

function __autoload($class_name) {
    require_once('./lib/'.$class_name.'.php');
}

Fichier index.php

Principe

require_once('./autoload.php');
new Client();//Lors de cette instanciation, autoload fera un require_once automatique :)

Surcharge

On appelle surcharge l'écrasement d’une méthode de la classe par une autre.

Ainsi dans l'exemple ci-dessus, la fonction "nom" est modifiée dans une deuxième classe :

class MonClient {
    public $nom; 
 
    function __construct($nom) {
        $this->nom = $nom;
    }
} 

$client = new MonClient('Dupont');
echo $client->nom."\n"; // Affiche Dupont

class LeClient {
    public $nom;

    function __construct($nom) {
        $this->nom = strtoupper($nom);
    }
}

$client = new LeClient('Dupont');
echo $client->nom; // Affiche DUPONT

Classes abstraites

Une classe abstraite est destinée à regrouper des éléments communs à ses classes filles. Elle ne doit donc jamais être déclarée comme "private" pour l'héritage (elle est "public" ou "protected"). Certaines de ses méthodes peuvent être abstraites aussi^[1].

abstract class personne
{
    public function nom($nom = "Dupont", $prenom = "Jean") {
        $this->nom() = $nom;
        $this->prénom() = $prenom;
   }
}

class MonClient extends personne 
{
    $Client = new personne;
... // Ce qui distingue un client d’une autre personne
}

class Salarier extends personne
{
    $Salarier = new personne;
... // Ce qui distingue un salarié d’une autre personne
}

Interface

Les interfaces rassemblent les méthodes publiques qui doivent être utilisées dans des classes. Donc s'il en manque une dans ces dernières, un message d'erreur apparait donc.

interface achat
{
    public function afficher($article);
    public function payer($article);
}

class ecommerce implements achat
{
    public function afficher ($article) // Obligatoire
    {
    ...
    }
    public function payer ($article) // Obligatoire
    {
    ...
    }
}

PHP

Fonctions

Base de données

Références

↑ php.net

[1] .net

[1]