Objet RealMedia
Ce chapitre décrit comment utiliser l'objet Real Audio et Real Vidéo.
L'héritage fait partie des principes de la programmation orientée objet, et PHP l'implémente dans son modèle objet. L'héritage affecte les relations entre les classes et les objets.
L'héritage fait partie des principes de la programmation orientée objet, et PHP l'implémente dans son modèle objet. L'héritage affecte les relations entre les classes et les objets.
L'héritage en POO est une technique très puissante et extrêmement pratique.
L'héritage consiste à utiliser une classe parente et une ou plusieurs classes filles qui héritent des propriétés et méthodes publiques de la classe parente. Par exemple, nous avons la classe Vehicule des cours précédents, vous pouvez avoir une classe Voiture qui hérite des propriétés de la classe Vehicule , tout en ajoutant des propriétés qui lui sont propres.
Lorsqu'on dit que la classe Voiture hérite de la classe Vehicule, c'est que la classe Voiture hérite de tous les attributs et méthodes de la classe Vehicule.
Si l'on déclare des méthodes dans la classe Vehicule, et qu'on crée une instance de la classe Voiture, alors on pourra appeler n'importe quelle méthode public déclarée dans la classe Vehicule, et aussi n’importe quel attribut public.
Pour dire à PHP qu'une classe hérite d'une autre, le mot-clé extends est utilisé. Prenons l'exemple de la classe Vehicule que revoici :
Code de « Vehicule.php »:
Exemple : Copier le code
<?php
class Vehicule
{
// Attributs(les variables ) sont les suivates
private $roue = 4 ;
/* le nombre de roues du véhicule par défaut est 4 */
private $porte ;
private $carburant ;
private $compteur ;
private $tauxConsomation ;
// Constantes
// Méthodes (les fonctions)
// constructeur
public function __construct ($roue, $porte, $carburant, $compteur,$tauxConsomation )
{
// Message affiché quand un objet est créé.
echo 'Voici le constructeur <br />';
// initialisation des paramètres.
$this->roue = $roue;
$this->porte = $porte;
$this->carburant = $carburant;
$this->compteur = $compteur;
$this->tauxConsomation = $tauxConsomation;
}
/* Une méthode qui déplacera le véhicule (modifiera son attribut compteur).*/
public function deplacer()
{
$this->compteur = $this->compteur + 50;
}
/* Une méthode qui déplacera le véhicule (modifiera son attribut compteur).*/
public function consommer()
{
$this->carburant = $this->carburant -($this->tauxConsomation * 50);
}
/* cette fonction sert à donner un nombre de roues à un véhicule*/
public function setRoue($R)
{
$this->roue=$R;
}
/* ces fonctions servent à l’affichage des attributs (propriétés) ou accesseurs */
public function roue()
{
return $this->roue ;
}
public function carburant()
{
return $this->carburant ;
}
}
?>
Pour créer une classe fille Voiture de la classe Vehicule
1) la première manière : il suffit d’ajouter le code suivant dans le fichier de la classe Vehicule :
Le code à ajouter :
Exemple : Copier le code
class Voiture extends Vehicule
{
// Déclaration des attributs
// Constructeur de la classe Voiture
public function __construct(int $prix_vehicule, bool $clim)
{
//votre code ici
}
// Méthode de la classe Vehicule
}
2) La seconde manière
Vous vous souvenu de l’auto chargement que nous avons vu dans un chapitre précédent dont voici la fonction que nous avons retenu pour déclarer une classe :
Exemple : Copier le code
<?php
function chargerClasse ($classe)
{
include( $classe.‘.php’ ); /* On inclue la classe correspondante au paramètre passé*/
}
spl_autoload_register ('chargerClasse'); /* enregistrement de la fonction en autoload pour qu'elle soit appelée dès qu'on instancie une classe non déclarée*/
?>
Et bien on peut aussi créer notre classe fille dans un fichier indépendant à condition d’utiliser une fonction pour déclarer la classe mère ou tout simplement la fonction include.
Notre exemple de tout à l’heure devient comme suit :
Exemple : Copier le code
<?php
function chargerClasse ($classe)
{
include( $classe.’.php’ ); /* On inclue la classe correspondante au paramètre passé*/
}
spl_autoload_register ('chargerClasse'); /* enregistrement de la fonction en autoload pour qu'elle soit appelée dès qu'on instancie une classe non déclarée*/
$classe= "Vehicule" ;
class Voiture extends Vehicule
{
// Déclaration des attributs
// Constructeur de la classe Voiture
public function __construct(int $prix_vehicule, bool $clim)
{
//votre code ici
}
// Méthode de la classe Vehicule
}
?>
On vient de créer une classe fille qui hérite des propriétés de la classe parente.
Sachez que vous pouvez réécrire une méthode pour modifier son comportement, pour cela il suffit de redéclarer la méthode et d’écrire le code des instructions que vous voulez mettre dans cette méthode.
Exemple :
Exemple : Copier le code
<?php
class x {
public $array = array();
public function __construct($arg1, $arg2) {
$this->array['arg1'] = $arg1;
$this->array['arg2'] = $arg2;
}
}
class y extends x {
public function __construct($arg1, $arg2) {
/* Je surcharge la méthode du constructeur, donc de ce fait je vais faire : ->
Soit autre chose ; -> Soit je vais rajouter des fonctionnalités*/
parent::__construct($arg1, $arg2); /* Ici j'appèle le constructeur
de la classe parente. J'utilise donc les fonctionnalités de base.*/
/* Dans ce qui suit je modifie le comportement de la méthode constructeur*/
$this->array['arg1-arg2'] = $this->array['arg1'] + $this->array['arg2'];
echo $this->array['arg1-arg2']; // Affichera 12 quand on instancie la classe y
}
}
// on instancie la classe fille y
$y1 = new y(14,8);
?>
Dans l’exemple nous avons un nouveau opérateur parent::
Il arrive que vous ayez à écrire du code qui faire référence aux attributs et méthodes des classes parente.
Au lieu d'utiliser le nom littéral de votre classe parente dans votre code, vous pouvez utiliser le mot réservé parent suivie du double deux points (parent::), qui représente votre classe parente (celle indiqué par extends , dans la déclaration de votre classe fille).
Ainsi, vous éviter d'écrire le nom de votre classe parente directement dans votre code.
si la méthode parente retourne une valeur, vous pouvez la récupérer comme si vous appeliez une méthode normalement.
Exemple :
Exemple : Copier le code
<?php
class A
{
public function MaMethode()
{
return 'MaMethode de la classe A';
}
}
class B extends A
{
public function MaMethode()
{
$retour = parent::MaMethode();
echo $retour; // Affiche 'MaMethode'
}
}
$B1 = new B();
echo $B1->MaMethode();
?>
Nous allons maintenant voir le dernier type de visibilité existant en POO : il s'agit de protected.
Ce type de visibilité est à placer entre public et private
Nous savons que :
Le type de visibilité protected est en fait une petite modification du type private : il a exactement les mêmes effets que private, à l'exception que toute classe fille aura accès aux éléments protégés.
L'accès aux éléments protégés (protected) est limité aux classes et parents hérités (et à la classe qui a défini l'élément)
L'accès protégé ( protected ) est un intermédiaire entre l'accès publique et l'accès privé. Il permet d'utiliser des attributs et méthodes communs dans une classe parente et ses classes dérivées (héritantes).
Exemple :
Exemple : Copier le code
<?php
class ClasseParente
{
protected $attributProtege;
private $attributPrive;
public function __construct()
{
$this->attributProtege = 'Je suis un attribut protégé!';
$this->attributPrive = 'Je suis un attribut privé !';
}
}
class ClasseFille extends ClasseParente
{
public function EcrireAttributs()
{
echo $this->attributProtege; /* L'attribut est protégé, on y accède
donc à partir de la classse fille*/
echo $this->atributPrive; /* L'attribut est privé, on n'y a pas
accès, rien ne s'affichera (ou une notice si les notices sont activées).*/
}
}
$obj = new ClasseFille;
/* si vous décommentez la ligne suivte vous aurez une Erreur fatale.*/
// echo $obj->attributProtege;
echo $obj->attributPrive; /* Rien ne s'affiche (ou une notice si les notices
sont activées).*/
$obj->EcrireAttributs(); /* Affiche « Je suis un attribut protégé! » suivi de
rien (ou une notice si les notices sont activées).*/
?>
Quant utiliser private ou protected ?
Et bien on utilise private si on empêcher totalement l’accès à l’élément à l’extérieur de la classe qui l’a créé.
Et on utilise proected si on veut permettre aux classes filles l’accès à l’élément.
Jusqu’à présent nous avons vu qu’on peut instancier toute classe , mais on peut empêcher l’instanciation d’une classe. On parle alors de classe Abstraite.
Pour déclarer une classe abstraite, il suffit de faire précéder le mot-clé class du mot-clé abstract comme ceci :
Exemple : Copier le code
<?php
abstract class MaClasse // Notre classe est abstraite.
{
}
?>
Ainsi, si vous essayez de créer une instance de la classe Personnage, une
erreur fatale sera levée.
Toutes les classes contenant au moins une méthode abstraite doivent également être abstraites.
Pour définir une méthode abstraite, il faut simplement déclarer la signature de la méthode et ne fournir aucune implémentation (c'est-à-dire on ne doit spécifier aucune instruction dans la méthode).
Exemple 1:
Exemple : Copier le code
<?php
abstract class MaClasse
{
// On va forcer toute classe fille à réécrire cette méthode
abstract public function MaFonction1();
// Cette méthode n'aura pas besoin d'être réécrite.
public function MaFonction2()
{
// Instructions.
}
}
class MaClasseFille extends MaClasse
{
// On écrit la méthode « MaFonction1 » du même type de visibilité que la
méthode abstraite « MaFonction1 » de la classe mère.
public function MaFonction1()
{
// Instructions.
}
}
?>
Exemple 2:
Exemple : Copier le code
<?php
abstract class AbstractClass
{
// Force la classe étendue à définir ces méthode
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// méthode commune
public function printOut() {
print $this->getValue() . "<br />";
}
}
class ReelClass1 extends AbstractClass
{
protected function getValue() {
return "Je suis ReelClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ReelClass1";
}
}
class ReelClass2 extends AbstractClass
{
public function getValue() {
return "Je suis ReelClass2";
}
public function prefixValue($prefix) {
return "{$prefix}ReelClass2";
}
}
$class1 = new ReelClass1;
$class1->printOut();
echo $class1->prefixValue('PRE_') ."<br />";
$class2 = new ReelClass2;
$class2->printOut();
echo $class2->prefixValue('PRE_') ."<br />";
?>
Toute classe peut être héritée. Vous pouvez ainsi reproduire un réel arbre avec autant de classes héritant les unes des autres que vous le souhaitez.
Exemple :
Exemple : Copier le code
<?php
class A
{
// Attributs
//Méthodes
{
//Code de la méthode
}
}
class B extends A
{
// Attributs
//Méthodes
{
//Code de la méthode
}
}
class C extends B
{
// Attributs
//Méthodes
{
//Code de la méthode
}
}
?>
Et voilà ce long cours sur l’héritage . Mais je vous conseille de le relire plusieurs fois car c’est un concept très important dans la programmation orientée objet.
Par carabde 20 Aout 2014