Accueil » Tutoriaux » PHP / SQL » Les bases de la POO
Les bases de la programmation orientée objet en php5 (POO)
  • Un peu d'histoire 

La POO a fait son arrivé dans PHP3 mais s'était une implémentation qui permettait de répondre à une demande immédiate. La gestion des objets de PHP4 était suffisante mais pas idéale, et représente l'un des grands défauts de cette version du langage. C'est pourquoi l'un des premiers buts du projet menant à PHP5 fut de revoir entièrement ce modèle objet - tout en restant compatible avec les habitudes des développeurs, et les innombrables scripts déjà créés. En passant, le coeur du langage (le Zend Engine) profite d'une mise à jour complète : les développeurs disposent désormais d'un PHP plus complet, plus rapide et mieux pensé que ses prédécesseurs.

  • La POO par l'exemple 

Avant de vous aventurer plus loin dans ce tuto, vous devez connaître les bases de PHP. Si ce n'est pas le cas, vous ne comprendrez certainement rien.

            1. Les classes :

Voici une classe :

class personne {
    var $prenom;
    var $nom;
    function mafonction($parametre1, $parametre2) {
        // code de la fonction
    }
}


Explications :

  • le mot class défini notre objet personne
  • le mot var permet de déclarer une variable dans la class
  • les fonctions sont déclarées comme d'habitude

En php5, les déclarations des variables se font soit en public (public) soit en privé (private) soit en protégé (protected). La différence réside dans le fait que si une variable est définie en type privé, elle ne pourra être modifié que par une fonction définie dans la classe contrairement à une variable définie en type public qui, elle, pourra être modifié n'importe où. En ce qui concerne le type protégé, la variable sera accessible uniquement depuis une méthode de cette classe, ou d'une classe héritant de celle-ci (Voir plus loin pour ce qui concerne l'héritage). Exemples :

Soit l'objet suivant :

class Maclass{
    public $mavariable;
} 

Après l'instanciation de mon objet, je pourrais modifier $mavariable dans le fichier où j'ai instancié ma class :

$test = new Maclass('variable') ;
$test->mavariable = 'autre_mot' ;

Ce que je ne peux pas faire si j'ai déclaré :

class Maclass{
    private $mavariable;
    function changenom($nom) {
       $this->mavariable = $nom;
    } 
}

Dans ce cas seul l'appel de la fonction changenom pourra modifier la valeur de la variable :

$test = new Maclass('variable') ;
$test->changenom('autre-mot') ;

Les fonctions peuvent elles aussi être déclarées soit en public, soit en privé, soit en protégé. 

 

        2. Utilisation de cette classe :

Tout d'abord, pour pouvoir utiliser un objet, il faut l'instancier c'est à dire la déclarer. Pour cela :

require_once 'maclasse.class.php';
$instance = new personne();

Donc, tout d'abord j'inclus le fichier qui contient ma class. Ensuite je l'instancie en faisant

$mavariable = new maclass();

Maintenant que ma class existe, j'assigne à ma variable une valeur :

$instance->prenom = 'nelly'; 

La variable prenom contient désormais la variable 'nelly';

Quel interet me direz-vous !

Et bien si, tout l'interêt est là. Maintenant je fais :

$instance = new personne();
$instance2 = new personne();
$instance->prenom = 'nelly';
$instance2->prenom = ' ashley'; 

echo $instance->myVar .' et '. $instance2->myVar; 

Affichera : nelly et ashley 

En effet, chaque instance est totalement indépendante des autres. Voilà le grand intérêt de la POO. Vous pouvez créer autant d'instances que vous voulez pour chaque classe. 


           3. Pseudo-variable $this :

Le script suivant est un script de panier d'achat

class Panier {
  var $nom;
  var $produits = array(
    'salade' => 0,
    'carotte' => 0,
    'champignon' => 0
  );
 
  function ajouterProduit($produit, $nombre) {
    $this->produits[$produit] += $nombre;
  }
}

$this est un pointeur vers l'instance de l'objet depuis laquelle la fonction qui contient this est appellée.

Un exemple plus gros :

require_once 'panier.class.php';

$panier = new Panier();
$panier2 = new Panier();

$panier->nom = 'Adrien';
$panier2->nom = 'Jarod';

$panier->ajouterProduit('salade', 6);
$panier2->ajouterProduit('salade', 2);

echo $panier->nom;
echo 'achète';
echo $panier->produits['salade'];
echo 'salade(s)';

echo '<br />';

echo $panier2->nom;
echo 'achète';
echo $panier2->produits['salade'];
echo 'salade(s)';

Grâce à la variable $this, cet exemple affichera :

Adrien achète 6 salade(s)
Jarod achète 2 salade(s)


        4. Place au constructeur :

Le constructeur correspond à une initialisation d'une variable dans une classe.

Un constructeur doit oblligatoirement porter le même nom que la classe.

En reprenant le premier exemple, voilà ce que ça donne :

class personne {
    var $prenom;
    var $nom;
    function mafonction($parametre1, $parametre2) {
        // code de la fonction
    }
 
    function personne ($nom,$prenom) {
        $this->prenom = $prenom; 
        $this->nom = $nom ;
    }
}

Lors de l'instanciation de la classe, on écrira :

$instance = new personne('nelly','furtado');

La construction se fait plus souvent à l'aide de la fonction :

function __construct ($mavar) { ... }

Et l'appel se fait de la même façon.

        5. L'héritage  :

L'héritage est un moyen de réutiliser le code. On définit une hiérarchie de classes, et les classes enfant héritent de ses propriétés et méthodes.

class personne {
    var $nom;
    var $age;

    function personne($nom,$age){
        $this->nom = $nom;
        $this->age = $age;
    }

    function afficheAge() {
        echo $this->age.' ans';
    }

    function afficheNom() {
        echo $this->nom;
    }

}

class fille extends personne {
    function chanter {
        echo 'You hou !!';
    }
}

class garcon extends personne {
    function parler {
        echo 'Bonjour';
    }
}

$lavoisine = new fille('Alice', 25);
$lavoisine->afficheNom();
$lavoisine->afficheAge();
$lavoisine->chanter;

$moi = new garcon('alfred', 21);
$moi->afficheNom();
$moi->afficheAge();
$moi->parler;

Ici, nous voyons que les classes Fille et Garcon héritent des méthodes afficheNom() et afficheAge(), ainsi que des propriétés $nom et $age. De plus, nous n'avons pas besoin de définir le constructeur de ces deux classes puisqu'il est déjà présent dans leur parent personne et puisqu'il ne change pas.

C'est aussi simple que ça ! J'espère vous avoir éclairci sur la POO. Pour ne pas décourager les novices, j'ai préféré ne pas trop rentrer dans les détails. Mais pour les autres, ne vous inquiétez pas, j'y reviendrais plus tard.