Hébergeur LWS.

Gagner des Bitcoins.

Le HackerSpace Vision du web.
La réponse collaborative.
Le glider des Hackers.
Un symbole de rassemblement.
QWERTY.
Du clavier au terminal.
GNU / Linux Debian.
La distribution universelle.
GNU / Linux Ubuntu.
Linux pour les êtres humains.
GNU / Linux Arch.
Un Linux léger et flexible.
Nom de code Linux.
Documentaire FR.
HackerSpace !
Messagerie entre membres connectés.

Vous n´êtes pas identifié(e).

Nous avons 107 invités et aucun membre en ligne

 

PHP5

Classes et méthodes, concrètes, abstraites et finales

Initiation aux classes et méthodes, concrètes, abstraites et finales.

 

Rappel de la définition d'une classe en POO

Structure complexe (Classe) constituée de propriétés (Variables) et de méthodes (Fonctions).
Un objet en PHP5 peut posséder des méthodes réservées aux constructeurs et destructeurs.
Lire l'excellent tutoriel du site Vulgarisation informatique - PHP POO, créer une classe Voiture. : ICI
Exemple d'Objet : Objet Voiture.

Classe : Structure de base pour un objet on y déclare les propriétés et les méthodes.
Exemple : Class Voiture.

Propriété (ou encore attribut, membre, champ) : Variables globale de la classe déclarées à l'intérieur de la classe mais déclarées à l'extérieur d'une méthode.
Elles sont définies en utilisant un des mots-clés public, protected, ou private, suivi d'une déclaration classique de variable.
Exemple : Marque, Modèle, Nombre de roues, couleurs.

Méthode : Une méthode est une fonction dans un objet.
Elle permet d’effectuer des opérations précises sur les propriétés de votre objet ou autres instructions.
L’accès aux méthodes d’un objet se fait comme pour les propriétés : écrire le nom de la variable contenant l’objet instancié, suivi d’une flèche -> et du nom de la méthode().
La méthode doit impérativement être suivie des parenthèses, contenant les arguments s’il y en a.
Exemple : On change la couleur de la R5, On loue la R5, on observe le niveau d'essence et on met le plein si nécessaire.

Différents types de classes et méthodes : concrètes, abstraites, finales.

 

Dériver ou instancier, notion d'héritage

Une classe dérivée hérite de toutes les méthodes et variables de la classe de base.
Elle peut définir ses propres fonctions et variables en complément.
Une classe ne peut hériter que d'une seule autre classe.
L'héritage multiple n'est pas supporté.
Les héritages se font avec le mot clé 'extends'.
Complément pour dériver une classe en PHP : ICI

Une classe est instanciée avec le mot-clé new.
L'instance utilise la classe à l’intérieur d’une variable.
Les objets instanciés sont indépendants les uns des autres.
Exemple d'instanciation : on crée plusieurs Objets Voiture R5.

 

Classes  et méthodes concrètes

Classe qui peut être instanciée directement.
Elle ne peut pas avoir d'opérations abstraites.

 

Classes et méthodes abstraites

Les classes abstraites sont utilisées pour la sûreté de la programmation orientée objet.
Les classes abstraites se déclarent au moyen du mot-clé « abstract » et se comportent comme les classes dérivées.
On y déclare des propriétés et méthodes accessibles dans des classes dérivées en fonction de la visibilité choisie (public, private et protected).
Les classes abstraites ne peuvent pas être instanciées.
Exemple : abstract class EtreHumain

Une classe abstraire peut définir des méthodes abstraites.
Les méthodes abstraites devront obligatoirement être redéfinies dans les classes dérivées pour s'assurer que la classe dérivée adopte le comportement attendu.

Exemple d'une classe abstraite : La classe «EtreHumain» est dérivée par deux classes concrètes «Homme» et «Femme».

<?php
abstract class EtreHumain
{
/* Sexe de la personne
* @var string
*/
protected $sexe;

/*
* Nom de la personne
* @var string
*/
protected $nom;

/*
* Met à jour le nom
* @param string $nom
* @return null
*/
public function setNom($nom)
{
$this->nom = $nom;
}

/*
* Retourne le nom de la personne
* @param null
* @return string $nom
*/
public function getNom()
{
return $this->nom;
}

/*
* Retourne le sexe de la personne
* @param null
* @return string $sexe
*/
public function getSexe()
{
return $this->sexe;
}
}
?>

Inutile d'ajouter un constructeur dans une classe abstraite puisqu'elles ne peuvent être instanciées.
Si on instancie cette classe pour créer un objet de type EtreHumain, le message d'erreur apparait : Fatal error: Cannot instantiate abstract class EtreHumain in .../abstract.php on line XX.

Exemple d'une méthode abstraite
C'est une méthode partiellement définie dans la classe et déclarée avec le mot-clé «abstract».
Les classes dérivées devront obligatoirement redéfinir entièrement toutes les méthodes abstraites de la classe parente.

Toute classe qui définit une ou plusieurs méthodes abstraites doit obligatoirement être déclarées abstraite.
Exemple avec l'ajout de méthodes abstraites à la classe abstraite «EtreHumain».

<?php
abstract class EtreHumain
{
/*
* Sexe de la personne
* @var string
*/
protected $sexe;

/*
* Nom de la personne
* @var string
*/
protected $nom;

/*
* Faire du sport.
* @abstract
*/
abstract function faireDuSport();

/*
* Se divertir.
* @abstract
*/
abstract function seDivertir();

/*
* Met à jour le nom
* @param string $nom
* @return null
*/
public function  setNom($nom)
{
$this->nom = $nom;
}

/*
* Retourne le nom de la personne
* @param null
* @return string $nom
*/
public function getNom()
{
return $this->nom;
}

/*
* Retourne le sexe de la personne
* @param null
* @return string $sexe
*/
public function getSexe()
{
return $this->sexe;
}
}
?>

La classe abstraite «EtreHumain» possède à présent les deux méthodes abstraites faireDuSport() et seDivertir().
Il faut définir ces méthodes dans les classes dérivées.

Créer deux classes «Homme» et «Femme» qui vont hériter des propriétés et méthodes de la classe abstraite.
Déclaration des classes dérivées Homme et Femme et instanciation.

<?php
class Homme extends EtreHumain
{
/*
* Construit l'objet Homme
* @param string $nom Nom de l'homme
* @return null
*/
public function __construct($nom)
{
$this->nom = $nom;
$this->sexe = 'M';
}
}

class Femme extends EtreHumain
{
/*
* Construit l'objet Femme
* @param string $nom Nom de la femme
* @return null
*/
public function __construct($nom)
{
$this->nom = $nom;
$this->sexe = 'F';
}
}
?>

Si on tente d'instancier une des deux classes.

<?php
$oBob = new Homme('Bobby');
echo $oBob->getNom();
?>

Erreur car les méthodes abstraites de la superclasse ne sont pas redéfinies.
Fatal error: Class Homme contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (EtreHumain::faireDuSport, EtreHumain::seDivertir) in .../abstract.php on line XX.

Deux possibilités pour pouvoir instancier la classe Homme.
- soit redéfinir explicitement les méthodes abstraites de la superclasse.
- soit rendre la classe Homme abstraite.

On veut pouvoir instancier la classe dérivée donc il faut redéfinir les méthodes abstraites de la superclasse.
Redéfinir les deux méthodes abstraites dans les classes dérivées.

<?php
class Homme extends EtreHumain
{
/*
* Construit l'objet Homme
* @param string $nom Nom de l'homme
* @return null
*/
public function __construct($nom)
{
$this->nom = $nom;
$this->sexe = 'M';
}

/*
* Affiche le sport de l'homme
* @param null
* @return null
*/
public function faireDuSport()
{
echo $this->nom .'de la Natation';
}

/*
* Affiche le loisir de l'homme
* @param null
* @return null
*/
public function seDivertir()
{
echo 'Informatique.';
}
}

class Femme extends EtreHumain
{
/*
* Construit l'objet Femme
* @param string $nom Nom de la femme
* @return null
*/
public function __construct($nom)
{
$this->nom = $nom;
$this->sexe = 'F';
}

/*
* Affiche le sport de la femme
* @param null
* @return null
*/
public function faireDuSport()
{
echo $this->nom .'du Fitness.';
}

/**
* Affiche la distraction de la femme
* @param null
* @return null
*/
public function seDivertir()
{
echo 'Shopping.';
}
}
?>

Instancier les classes Homme et Femme.

<?php
$oAlice = new Femme('Alice');
$oAlice->faireDuSport();
echo '<br/>';
$oAlice->seDivertir();
echo '<br/>';
echo 'Sexe : ', $oAlice->getSexe();

echo '<br/><br/>';

$oBob = new Homme('Bobby');
$oBob->faireDuSport();
echo '<br/>';
$oBob->seDivertir();
echo '<br/>';
echo 'Sexe : ', $oBob->getSexe();
?>

Le résultat est fonctionnel.

Alice fait du Fitness.
Shopping.
Sexe : F

Bobby fait de la Natation.
Informatique.
Sexe : M

 

Classes et méthodes finales

Une classe « final » ne pourra plus être dérivée par une sous-classe.
Cela implique également que ses propriétés et ses méthodes ne pourront plus être redéfinies.

Une méthode « final » ne pourra plus être redéfinie dans les classes dérivées.

Exemple de classe final
Nous décidons que les classes « Homme » et « Femme » ne pourront pas être dérivées.
Nous les déclarons donc comme étant finales.

<?php
final class Homme extends EtreHumain
{
/* Le code de la classe */
}
final class Femme extends EtreHumain
{
/* Le code de la classe */
}
?>

Tentons de dériver l'une des deux classes et de l'instancier.
Écrire une classe « JeuneGarcon » qui hérite des propriétés et méthodes de la classe « Homme ».

<?php
class JeuneGarcon extends Homme
{
/*
* Construit l'objet JeuneGarcon
* @param string $nom pour le nom du jeune garçon.
* @return null
*/
public function __construct($nom)
{
parent::__construct($nom);
}  
}
?>

Une erreur est générée puisque la classe Homme n'est pas dérivable du fait de sa déclaration "final".
Fatal error: Class JeuneGarcon may not inherit from final class (Homme) in .../abstract.php on line XX.

Une classe abstraite ne peut-être déclarée "final".
Déclarer une classe abstraite comme "final" n'a pas de sens puisque le but d'une classe abstraite est d'être dérivée par des classes enfants.

Exemple de méthode final
Utilisons la classe abstraite « EtreHumain » et déclarons les méthodes « getNom() » et « getSexe() » comme finales.
Les classes dérivées «Homme» et «Femme» ne peuvent maintenant plus redéfinir ces deux méthodes.

<?php
abstract class EtreHumain
{
// Propriétés et autres méthodes de la classe.
/**
* Retourne le nom de la personne
* @param null
* @return string $nom
* @final
*/
public final function getNom()
{
return $this->nom;
}

/**
* Retourne le sexe de la personne
* @param null
* @return string $sexe
* @final
*/
public final function getSexe()
{
return $this->sexe;
}
}
?>

Essayons de surcharger une de ces méthodes dans la classe «Homme» :

<?php
final class Homme extends EtreHumain
{
// Autres méthodes de la classe...
/**
* Retourne le sexe
* @param null
* @return string sexe de l'homme
*/
public function getSexe()
{
return 'Masculin';
}
}
?>

La redéfinition de la méthode génère une erreur fatale par l'interpréteur PHP.
Fatal error: Cannot override final method EtreHumain::getSexe() in ../abstract.php on line XX.

La méthode « getSexe() » ne retourne plus la valeur de la propriété protégée $sexe mais tente de renvoyer la chaine de caractères « Masculin ».

Les classes finales permettent de mettre fin à la réutilisation de la classe, empêche l'héritage.
On ne peut pas redéfinir les propriétés et méthodes de cette classe dans une classe dérivée.

Les classes abstraites forcent à créer des classes qui héritent de la classe abstraite.
Les classes et méthodes abstraites doivent obligatoirement être dérivées et ne peuvent être instanciées.

REMARQUE ! Ce site utilise des cookies et autres technologies similaires.

Si vous ne changez pas les paramètres de votre navigateur, vous êtes d'accord. En savoir plus

J'ai compris

En poursuivant votre navigation sur ce site, vous acceptez l’utilisation de Cookies pour vous proposer un accès membre personnalisé et réaliser des statistiques de visites.

Vision du web sur votre réseau social

La seule amitié qui vaille est celle qui naît sans raison.
[Arthur Van Schendel]