6.Le langage PHP

6.8.Programmation orientée objet

6.8.4.Implémentation d'une classe ou interface

6.8.4.1.Introduction

En bref:
La déclaration de la classe se fait selon le schéma suivant (les "crochets" indiquent des mots clés optionnels)
<?php
<abstract> class MaClasseAMoi extends MaClasseMere implements MonInterface1, MonInterface2
{
    abstract public <static> function maMethodeAbstraite($param);
    <final> public <static> function maMethodePublique($param) {}
    <final> private <static> function maMethodePrivee($param) {}
    <final> protected <static> function maMethodeProtegee($param) {}
}
Et les interfaces
<?php
interface MonInterface1 extends InterfaceMere
{
    public function maMethode($param);
    public function static maMethodeStatique($param);
}
Le mot clé "public" pour indiquer la visibilité est optionnel car la visibilité est par défaut "public" mais conseillé par les règles de codage PSR-2.
Bien entendu, si la classe contient au moins une méthode abstraite, elle devra être elle-même déclarée abstraite.

6.8.4.2.La classe

6.8.4.2.1.Présentation

Une classe se déclare via le mot clé class suivi (au moins) du nom de la classe et du bloc décrivant la classe.
<?php
class MaClasseAMoi
{
    // corps de la classe
}
La coutume et les règles de codage PSR-2 nous invitent à:
  • A déclarer une classe dans un fichier PHP dédié (qui ne contiendra donc que la déclaration de la classe)
  • A utiliser la notation Camel pour le nom de la classe. A savoir, un nom de classe commençant par une majuscule (comme tous les mots composant le nom) et sans délimiteur du type tiret ou souligné (underscore)
  • A nommer le fichier comme la classe (avec l'extension .php en plus)
  • A ne pas fermer la balise <?php (i.e. à ne pas mettre de ?> en fin de fichier)
  • A ne pas omettre un retour chariot à la dernière ligne (celle qui comporte l'accolade fermante de la déclaration de la classe)

6.8.4.2.2.Classe abstraite

Une classe peut être déclarée abstraite (elle devra être héritée avant de pouvoir être utilisée généralement après avoir implémenté des méthodes déclarées abstraites), via le mot clé abstract placé avant "class".
<?php
abstract class MaClasseAMoi
{
    // corps de la classe
}

6.8.4.2.3.Classe héritée

Une classe peut hériter d'une autre classe en précisant après le nom de la classe fille le mot clé extends suivi du nom de la classe mère.
<?php
class MaClasseAMoi extends MaClasseMere
{
    // corps de la classe
}

6.8.4.3.Les méthodes

6.8.4.3.1.méthode publique

Le corps de la classe est essentiellement composé de méthodes. Les méthodes, se déclarent exactement de la même façon que les fonctions, la seule différence (ou presque) c'est qu'elles sont associées à une classe.
<?php
class MaClasseAMoi
{
    function maMethode($param)
    {
        // corps de la méthode
    }
}
Il est de coutume d'écrire le nom de la méthode avec la notation Camel mais avec la première lettre en minuscule.
Si l'on souhaite suivre les règles de codage PSR-2 nous devons explicitement préciser la visibilité de la méthode (par défaut "public").
<?php
class MaClasseAMoi
{
    public function maMethode($param)
    {
        // corps de la méthode
    }
}

6.8.4.3.2.Méthode protégée ou privée

Une méthode peut être déclarée protégée (resp. privée) via le mot clé protected (resp. private).
<?php
class MaClasseAMoi
{
    protected function maMethodeProtegee($param)
    {
        // corps de la méthode
    }

    private function maMethodePrivee($param)
    {
        // corps de la méthode
    }
}

6.8.4.3.3.Méthode statique

Une méthode (qu'elle soit publique ou privée) peut être déclarée statique (lorsqu'elle ne fait pas référence à $this) via le mot clé static.
<?php
class MaClasseAMoi
{
    public static function maMethode($param)
    {
        // corps de la méthode
    }
}
D'après les règles de codage PSR-2 le mot clé static doit être placé après la visibilité (public, protected, private).

6.8.4.3.4.Méthode abstraite et méthode finale

Une méthode (qu'elle soit publique ou privée, statique ou pas) peut être déclarée abstraite (resp. finale) via le mot clé abstract (resp. final).
<?php
class MaClasseAMoi
{
    // Une méthode abstraite doit être implémentée par une classe
    // héritant ce celle-ci
    abstract public function maMethodeAbstraite($param);

    final public function maMethodeFinale($param)
    {
        // A l'inverse une méthode finale ne peut pas être modifiée
        // par une classe héritant de celle-ci
    }
}
D'après les règles de codage PSR-2 les mots clés abstract et final doivent être placé avant la visibilité (public, protected, private).

6.8.4.4.Les interfaces

6.8.4.4.1.Déclaration

Une interface se déclare avec le mot clé interface suivi (au moins) du nom de l'interface. Le corps de l'interface contiendra alors le prototype des méthodes (sans implémentation)
<?php
interface MonInterfaceAMoi
{
    public function methodeAImplementer($param1, $param2);
}

6.8.4.4.2.Classe implémentant une ou plusieurs interfaces

Une classe peut déclarer implémenter une ou plusieurs interfaces (Cf. plus loin définition d'une interface). Pour cela, il faut utiliser le mot clé implements suivi du nom des interfaces séparés par une virgule.
<?php
class MaClasseAMoi implements MonInterface1, MonInterface2
{
    // corps de la classe
}
Ici vous pouvez apprendre :
Forum PHP
Version imprimable: imprimer