# #
<?php class MaClasse { //Une classe est contituée //D'attribut contenant des valeurs private attribut1; //Valeur privée non accessible de l'extérieur public attribut2; //Valeur public accessible de l'extérieur (utilisation non recommandée //De methode contenant des instructions imbriquées dans des fonctions public function methode1; { } public function methode2; { } } //Pour créer les objet $truc1 et $truc2 avec la classe MaClasse $truc1 = new MaClasse; $truc2 = new MaClasse; ?>
Création et utilisation d'une classe :
<?php class MaClasse { private $var1; public $var2 = 'publique'; //Attribut avec valeur prédéfinie private $var3 = 'coucou'; //Attribut avec valeur prédéfinie private $var4 = 'hello'; //Attribut avec valeur prédéfinie public function methode1 () { //$this fait référence à : "moi l'objet" je veux ma valeur de $var3 //Cette instruction affichera "coucou". echo $this->var3; } public function methode2 () { //"moi l'objet" retourne moi ma valeur de $var4 //Cette instruction retournera "hello" return $this->var4; } } // Création de l'objet "$truc" $truc = new MaClasse(); // Exemple d'affichage attribut public dans la classe (non recommandé), les attributs privé ne peuvent pas être affichés. // "Moi l'objet $truc" je veux la valeur de mon attribut public $var2: "publique" sera affiché echo $truc->var2; echo "\n"; //Retour chariot en ligne de commande // "Moi l'objet $truc" j'exécute ma méthode "methode1": Cette instruction affiche "coucou". $truc->methode1(); echo "\n"; // "Moi l'objet $truc" j'exécute ma méthode "methode2". Rien ne sera affiché puisque return n'affiche rien (return utilisé au lieu de echo) $truc->methode2(); // "Moi l'objet $truc" je veux qu'on m'affiche le résultat de la "methode2" que j'exécute : Cette instruction affichera "hello". echo $truc->methode2(); echo "\n"; ?>
Résultat attendu :
publique coucou hello
Le contructeur est une fonction qui permet de définir les valeurs des attributs que l'on souhaite donner à l'objet que l'on crée
<?php class MaClasse { private $var1; private $var2; //Constructeur permettant de définir les valeurs des attribut de l'objet que l'on cré public function __construct ($valeur1, $valeur2) { $this->var1 = $valeur1; $this->var2 = $valeur2; } //Cette fonction affichera les valeurs que l'on a défini en créant notre objet public function affiche_valeurs() { echo $this->var1; echo "\n"; echo $this->var2; echo "\n"; } } $truc = new MaClasse('coucou', 33); $truc->affiche_valeurs(); $machin = new MaClasse('hello', 22); $machin->affiche_valeurs(); ?>
Résultat attendu :
coucou 33 hello 22
<?php class MaClasse { private $var1; public function __construct ($valeur1) { $this->var1 = $valeur1; } public function affiche_ma_valeur1 () { echo $this->var1; echo "\n"; } public function affiche_la_valeur1 (MaClasse $objet) { echo $objet->var1; echo "\n"; } } // On crée les 2 objets en leur donner les valeurs pour les contruires $truc1 = new MaClasse (11); $truc2 = new MaClasse (22); // On affiche la valeur1 de chaque objet $truc1->affiche_ma_valeur1(); $truc2->affiche_ma_valeur1(); // On demande à l'objet $truc1 de sortir la valeur1 de l'objet $truc2 $truc1->affiche_la_valeur1($truc2); ?>
Résultat attendu :
11 22 22
Les constantes sont des variables qui appartiennent à la classe et non à l'objet. Ce sont ds variable prédéfinie dans l'objet et qui ne changent pas.
<?php class MaClasse { private $var1; const VAR_PREDEFINIE1 = 11; const VAR_PREDEFINIE2 = 22; public function __construct ($valeur1) { $this->var1 = $valeur1; } public function affiche_ma_valeur1 () { echo $this->var1; echo "\n"; } public function affiche_la_valeur1 (MaClasse $objet) { echo $objet->var1; echo "\n"; } } // On crée les 2 objets en leur donner les valeurs prédéfinies par la classe $truc1 = new MaClasse (MaClasse::VAR_PREDEFINIE1); $truc2 = new MaClasse (MaClasse::VAR_PREDEFINIE2); // On affiche la valeur1 de chaque objet $truc1->affiche_ma_valeur1(); $truc2->affiche_ma_valeur1(); // On demande à l'objet $truc1 de sortir la valeur1 de l'objet $truc2 $truc1->affiche_la_valeur1($truc2); ?>
Résultat attendu :
11 22 22
<?php class MaClasse { private $var = 'toto'; public static function good_static() { echo "Hello\n"; } public static function bad_static() { //Ceci est un mauvais exemple //Dans un context de methode static, $this qui fait référence à un objet qui n'a rien à faire là $this->var; } } // Ci-dessous la methode good_static de la classe est exécutée. Elle ne necessite pas la création d'un objet MaClasse::good_static(); // Ci-dessous on aura une erreur, puisque le $this défini dans la fonction faite référence à un objet qui n'existe pas MaClasse::bad_static(); ?>
Résultat attendu :
Hello PHP Fatal error: Using $this when not in object context in /var/www/test-php/test/static.php on line 15
<?php class MaClasse { // Déclaration de la variable $compteur // Cette variable n'est utilisable par aucun objet private static $compteur = 0; public function __construct() { // On instancie la variable $compteur qui appartient à la classe (donc utilisation du mot-clé self) // Ici le constructeur incrémente $compteur chaque fois qu'il construit un objet self::$compteur++; } public static function getCompteur() // Méthode statique qui renverra la valeur du compteur { //Attention de bien définir le $ devant l'attribut return self::$compteur; } } $test1 = new MaClasse; $test2 = new MaClasse; $test3 = new MaClasse; // Ceci permet de savoir combien d'objets ont été construit avec MaClasse echo MaClasse::getCompteur(); echo "\n"; ?>
Résultat attendu :
3
<?php class ClasseMere { // Un attribut protected est un attributs pouvant être transmise // L'utilisation de protected au lieu de private et conseillé pour faciliter l'accès aux classes filles protected $attributProtege = 'protégé'; private $attributPrive = 'privé'; public $attributPublic = 'publique'; } // Ceci est une classe qui hérite des attributs et méthode de ClasseMere // Elle hérite des éléments public ou protected mais pas private class ClasseFille extends ClasseMere { public function get() { // Ci dessous aucun problème d'accès à l'attribut echo $this->attributPublic."\n"; // Ci dessous aucun problème d'accès tant que l'on est dans une classe fille echo $this->attributProtege."\n"; // La directive ci-dessous génèrera une erreur car la classe fille ne peut pas hériter d'attributs privés echo $this->attributPrive."\n"; } } // On peut créer autant de classes fille que l'on veut class ClasseGarcon extends ClasseMere { } // On peut créer une arborescence de classe (tous les éléments parents public ou protected seront hérétées) class ClassePetiteFille extends ClasseFille { } $truc1 = new ClasseMere; $truc2 = new ClasseFille; // Ici on lance notre méthode get qui affichera une erreur à cause de l'attribut privé qui ne peut pas être affiché ici $truc2->get(); //Ci-dessous il n'y a aucun problème pour accéder à un attribut public en dehors d'une classe echo $truc2->attributPublic."\n"; //La directive ci-dessous génèrera une erreur car la classe fille ne peut pas hériter d'attributs privés echo $truc2->attributProtege."\n"; ?>
<?php class A { public function test() { return "test"; } } class B extends A { public function test() { // Ici on dit que $retour est égale au resultat de la methode "test" de la classe parente $retour = parent::test(); return $retour." avec des chose en plus\n"; } } $trucA = new A; $trucB = new B; echo $trucA->test(); echo "\n"; echo $trucB->test(); ?>
Resultat attendu :
test test avec des chose en plus
Restreindre l'utilisation d'une classe qu'aux classes filles.
<?php abstract class ClasseMere { } class ClasseFille extends ClasseMere { } $truc1 = new ClasseFille; //Aucun problème pour utiliser la classe ClasseFille $truc2 = new ClasseMere; //En revanche il y a une restriction pour utiliser la classe ClasseMere. Une erreur aura lieu. ?>
Obliger les classes filles à réécrire certaines méthodes de la classe parente.
<?php abstract class ClasseMere { //Pour définir une méthode comme étant abstraite, il faut que la classe elle-même soit abstraite ! abstract public function Afficher(); // Il n'y a pas d'instruction dans cette methode, Elle ne peut pas en contenir // Les classes Filles seront toutes obligées de réécrire le methode Afficher() } class ClasseFille extends ClasseMere { public function Afficher() { echo "Methode obligatoirement ecrite dans la classe fille\n"; } } $truc = new ClasseFille; $truc->Afficher(); ?>
Restreindre l'héritage d'une classe (classe finale ne pouvant être héritée) et la empêcher réécriture d'une methode.
<?php abstract class ClasseMere { // Ceci est une methode finale ne pouvent être héritée final public function Methode() { echo "Hello\n"; } } // Cette classe est déclarée comme finale, aucun classe ne peut en hériter final class ClasseFille extends ClasseMere { // Erreur fatale, car le methode "Methode" était déclarée comme final dans la classe parente. public function Methode() { } } // Erreur fatale, car notre classe hérite d'une classe finale. class ClassePetiteFille extends ClasseFille { } ?>
<?php class Mere { public static function lancerLeTest() { self::quiEstCe(); } public function quiEstCe() { echo "Je suis la classe Mere !\n"; } } class Enfant extends Mere { public function quiEstCe() { echo 'Je suis la classe Enfant !'; } } Enfant::lancerLeTest(); ?>
Résultat attendu :
Je suis la classe Mere !