====== PHP Programmation Objet ======
#
#
===== Création d'une classe et création d'objets =====
=== Pour résumer ===
* L'attribut : fait référence à des données
* La méthode : fait référence à un traitement
* Une classe est un "moule" qui permet de fabriquer un objet
===== L'accès aux attributs et méthodes =====
Création et utilisation d'une classe :
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
=== Pour résumer ===
* **$this** : fait référence à **moi l'objet** je veux (**->**) utiliser cette **methode** : **$this->methode()**
* La bonne pratique est de n'avoir jamais recours aux attributs "public".
* Les valeurs des attributs privés peuvent être affichés via des méthodes.
===== Le constructeur =====
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
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
=== Pour résumer ===
* Le constructeur est la fonction qui permet de définir les caractéristiques de notre objet.
* Il ne peut y avoir qu'un seul constructeur dans une classe
===== Interaction entre les objets =====
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
===== Constantes =====
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.
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
===== Methode et attributs statiques =====
=== Méthode statique ===
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
=== Attributs statiques ===
Résultat attendu :
3
=== Pour résumer ===
* L'opérateur **->** : cet opérateur permet d'accéder à un élément de tel objet
* L'opérateur **::** : cet opérateur permet d'accéder à un élément de telle classe
===== Héritage =====
==== Déclaration de classes filles et portée des éléments ====
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";
?>
==== Réécrire une méthode héritée ====
test();
echo "\n";
echo $trucB->test();
?>
Resultat attendu :
test
test avec des chose en plus
==== Imposer des contraintes ====
Restreindre l'utilisation d'une classe qu'aux classes filles.
Obliger les classes filles à réécrire certaines méthodes de la classe parente.
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.
==== Résolution statique à la volée ====
Résultat attendu :
Je suis la classe Mere !
==== Pour résumer ====
* Avec l'attribut **protected** il est possible de permettre au classe fille d'utiliser l'attribut contrairement à l'attribut **private**
* **abstract** dans une classe empèche d'utiliser cette classe en dehors d'une classe fille
* **abstract** dans une méthode oblige les classes filles à réécrire la méthode.
* **final** permet de déclarer une méthode ou classe comme non "héritable"
* **parent::methode()** permet de reprendre les éléments d'une methode parente y ajouter modifier des éléments