Dynamic-Mess.com


"The world is a dynamic mess of jiggling things..."

PHP : Quelques rappels pour la POO 1/2

Article posté le 26-11-2013 dans la catégorie PHP

Attention, le contenu cet article est peut-être obsolète!

PHP gère bien la POO : programmation orientée objet. Cette méthode de programmation permet de bien structurer et faciliter le développement de grosses applications. Voici donc la première partie de quelques rappels bien utiles.

Partons de la classe ci-dessous :

class toutou
{
    private $message;
    private $nombreAffichage;

 

    const AFFICHE_PAS_BEAUCOUP = 1;
    const AFFICHE_BEAUCOUP = 2;

 

    public function __construct($leMessage, $Affichage) // Constructeur demandant 2 paramètres
    {
        $this->setMessage($leMessage);
        $this->setQTY($Affichage);
    }

 

    private function setMessage($leMessage) //Setter ou "Mutateur"
    {
        $this->message = $leMessage;
    }

 

    private function setQTY($qty) //Setter ou "Mutateur"
    {
        if($qty == self::AFFICHE_BEAUCOUP || $qty== self::AFFICHE_PAS_BEAUCOUP)
        {
            $this->nombreAffichage = $qty;
            echo "La quantité est de ".$this->nombreAffichage."
";
        }
    }

 

    public function afficheMessage() // Getter ou "Accesseur"
    {
        echo $this->message;
    }

 

    public static function Perroquet()
    {
        echo "
toutou a parlé";
    }
}

Et voici maintenant de quoi appeler  cette classe :

function chargerMaClasse($classe)
{
  require $classe . '.php'; // On inclut la classe correspondante au paramètre passé.
}
//chargerClasse("toutou");
spl_autoload_register('chargerMaClasse');
$Eric = new toutou("Hello", toutou::AFFICHE_PAS_BEAUCOUP);
$Eric ->afficheMessage();
toutou::Perroquet();

Analysons maintenant ce joli code.

1-  Charger sa classe

En PHP, il est recommandé de faire un fichier par classe. Plutôt que de les appelers avec des "require", vous pouvez simplifier les choses en vous créant une fonction chargerMaClasse, et lui passant en paramètre le nom de la classe à charger, afin de pouvoir l'utiliser.

Utiliser la fonction autoload

Pour encore plus vous simplifier la tâche, mettez votre fonction précédemment crée dans la pile d'autoload de PHP. Ainsi, plus besoin de systématiquement inclure le fichier de la classe via votre fonction : PHP s'en chargera tout seul automatiquement quand vous essaierez d'instancier une classe dont le fichier n'a pas été chargé. Pour cela, rien de plus simple, soit la fonction "chargeClasse()":

function chargeClasse($strNomClasse) {
    
    $strFichier = "classes/" . $strNomClasse . ".class.php";
    
    if(file_exists($strFichier)) {
        require $strFichier;
    }
    
}
spl_autoload_register('chargeClasse'); // On déclare notre fonction dans la pile d'autoload

Vous pouvez enregister autant de fonctions de chargement que vous voulez: PHP les parcourera les unes après les autres jusqu'à ce qu'il trouve la classe souhaitée. Ainsi, on peut utiliser plusieurs répertoires différents pour stocker nos classes. Un dernier point: dans la dernière de vos fonctions autoload: jetez une exception pour dire que vous n'avez pas réussi  à charger la classe demandée.

2- Création de l'objet

L'instanciation de la classe se fait simplement, via une variable :

$Eric = new toutou("Hello", toutou::AFFICHE_PAS_BEAUCOUP);

On lui passe ici en paramètre deux variables : Un chaine de caractère, et une constante de classe. Nous reviendrons sur ce dernier point plus tard.

Ensuite, nous appelons une méthode de note objet :

$Eric ->afficheMessage();

puis nous appelons une méthode statique (remarquez, que comme pour les constantes, les variables et fonctions statiques sont appelées avec "::" au lieu de "->":

toutou::Perroquet();

3- Analysons maintenant  le contenu de la classe

Les variables privées sont déclarées "private", les protégées "protected", et les publiques "public".

Les constantes sont déclarées "const", et les statiques "static".

1- Publique, privée, protégée, constante et statique

Pour les variables et fonctions :

Publiques : d'être accessible depuis l'extérieur. A proscrire pour les variables

Privées : de n'être accessible que depuis l'intérieur de l'objet

Protégées : de n'être accessible que depuis l'intérieur de l'objet ou les objets qui en héritent

Statiques : La variable (ou fonction) et son contenu sont communs à tous les objets instanciées de la classe. Ils peuvent tous la modifier. Cela permet par exemple de compter le nombre d'instances.

Constantes : il s'agit de variables dont le contenu est défini de manière définitive: il est commun à tous les objets, et ne peut être modifié.

2- Constructeurs et encapsulation

Le constructeur se déclare comme ceci :

public function __construct($leMessage, $Affichage)

L'attribution des contenus aux variables respectives se fait en respectant l'encapsulation. C'est à dire que l'on ne modifie par directement la variable, mais on utilise un "setter" ou "Mutateur" pour en modifier le contenu.

$this->setMessage($leMessage); // Setter

De la même manière, que pour accéder à la variable depuis l'extérieur de l'objet, on utilisera un "getter" ou "Accesseur" :

public function afficheMessage() // Getter ou "Accesseur"
    {
        echo $this->message;
    }

qui sera appelée depuis l'extérieur :

$Eric ->afficheMessage();

3- This et self

Comme vous l'avez remarqué, on utilise le mot clef "$This" : pour des raisons de clarté, il permet de s'assurer que l'on accède bien aux infos (méthodes) de l'objet concerné, et donc depuis l'intérieur de cet objet.

Le mot clef "self", permet d'accéder, toujours depuis l'intérieur de l'objet, aux variables statiques et aux constantes, par exemple :

echo self::$message;

Pour accéder aux fonction statiques, on utilsera le nom de la classe, (et pas le nom de l'objet), que ce soit depuis l'intérieur de ce dernier et pourquoi pas depuis l'extérieur si la fonction est aussi en "public" :

toutou::Perroquet();

Voilà pour la première partie de ce rappel.

 


Cet article vous a plu? Découvrez d'autres articles


Tweet
comments powered by Disqus