PHP Programmation orientée objet
Introduction à la programmation orientée object ( ou POO )
La programmation orientée objet est la définition de briques logicielle - objets - qui interagissent entre eux.
Un object représente un concept, une idée ou toute entité du monde physique, comme une personne, un type de personne, une voiture,
un article, etc.
Il possède sa propre structure et son propre comportement et sait agir avec ses pairs.
Cette méthode de programmation se différencie de la programmation procédurale. Elle permet une meilleure compréhension du code,
un code plus indépendant, une meilleure possibilité d'évolution du code et de maintenance.
Les classes
La classe est la structure d'un objet. Il s'agit du plan de tout ce qui compose l'objet. La classe est composée de deux parties:
les attributs ( ou propriétés )
les méthodes
Les attributs sont les données associées à l'objet et les méthodes sont des fonctions qui sont associées à la classe.
Les objets
Les objects sont des instanciations de classe. On parle d'ailleurs d'instances de classe.
Il faut imaginer une classe comme une sorte d'usine qui peut sortir autant de produits que l'on désire. Ces produits sont les objets.
Une classe "voiture" peut ainsi créer des voitures, qui auront toutes des mêmes informations. Par exemple elles auront toutes un volant
et 4 roues. Mais lors de sa création, de son instanciation, on pourra par exemple changer la couleur d'un élément. On pourra également changer
le nombre de roues si besoin, mais la force de POO c'est que par défaut, on ne se soucie pas du nombre de roues puisqu'elles sont présentes
par défaut.
Exemple PHP
En
PHP on crée une classe comme ceci:
et si je veux instancier une voiture:
<?php |
$voiture = new voiture(); |
?> |
Les attributs
Je peux donner à la classe des attributs qu'hériteront chaque instance
<?php |
|
class voiture{ |
|
public $nb_roues = 4; |
public $volant = 1; |
public $prix = 5000; |
|
} |
|
$voiture = new voiture(); |
var_dump( $voiture ); |
|
|
?> |
Résultat:
object(voiture)[1]
public 'nb_roues' => int 4
public 'volant' => int 1
public 'prix' => int 5000
Je peux voir la valeur d'un attibut avec la syntaxe suivante:
<?php |
var_dump( $voiture->nb_roues ); |
?> |
Les méthodes
Les méthodes sont des fonctions propre à la classe.
Exemple:
<?php |
|
class voiture{ |
|
public $nb_roues = 4; |
public $volant = 1; |
public $prix = 5000; |
|
public function prix_voiture(){ |
return $this->prix; |
} |
|
} |
|
$voiture = new voiture(); |
print_r( $voiture->prix_voiture() ); |
|
|
?> |
Les méthodes permettent entre autre de manipuler les attributs. Il est d'ailleurs d'usage de ne pas appeler un attribut directement mais
de passer par une méthode.
Le constructeur
Le constructeur est une méthode qui est exécutée lors de l'instantiation de la classe.
<?php |
|
class voiture{ |
|
public $nb_roues = 4; |
public $volant = 1; |
public $prix = 5000; |
|
|
public function __construct(){ |
$this->prix+=150; |
} |
|
public function prix_voiture(){ |
return $this->prix; |
} |
|
} |
|
$voiture = new voiture(); |
print_r( $voiture->prix_voiture() ); |
|
?> |
Dans l'exemple ci-dessus on remarque que le prix à été augmenté de 150 euros. Cette action s'est déroulée dans le constructeur, qui a pour nom:
__construct()
Méthodes statiques
La méthode statique est une méthode qui n'a pas besoin d'être appellée depuis un objet. Sa syntaxe est celle ci:
CLASSE::METHODE()
<?php |
|
class voiture{ |
|
public $nb_roues = 4; |
public $volant = 1; |
public $prix = 5000; |
|
|
public function __construct(){ |
$this->prix+=150; |
} |
|
public function prix_voiture(){ |
return $this->prix; |
} |
|
public static function nom_de_la_voiture(){ |
return "BATMOBILE"; |
} |
|
} |
|
print_r( voiture::nom_de_la_voiture() ); |
|
?> |
On remarque dans l'exemple ci-dessus que pour appeler une méthode statique, on appelle directement la méthode sans instancier la classe.
getter et setter
Pour modifier une propriété on peut utiliser la syntaxe suivante:
<?php |
|
class voiture{ |
|
public $nb_roues = 4; |
public $volant = 1; |
public $prix = 5000; |
|
} |
|
$voiture = new voiture(); |
$voiture->prix = 5400; |
|
print_r( $voiture->prix ); |
|
?> |
Il n'est cependant pas conseillé d'utiliser cette syntaxe pour changer la valeur d'un attribut, il est préférable de passer par des methodes
qui feront la modification. On appelle ce genre de méthode un
setter ; et on récupère la valeur avec un
getter.
<?php |
|
class voiture{ |
|
public $nb_roues = 4; |
public $volant = 1; |
public $prix = 5000; |
|
public function setPrix( $prix ){ |
$this->$prix = $prix; |
} |
|
public function getPrix( $prix ){ |
return $this->$prix; |
} |
|
} |
|
$voiture = new voiture(); |
|
$voiture->setPrix( 5400 ); |
|
print_r( $voiture->getPrix() ); |
|
?> |
L'héritage
L'héritage en POO permet d'abstraire certaines fonctionnalités communes à plusieurs classes, tout en permettant aux classes filles d'avoir
leurs propres méthodes.
<?php |
|
class voiture{ |
|
public $roue = 4; |
|
} |
|
class Renault extends voiture{ |
|
} |
|
class Peugeot extends voiture{ |
|
public $roue = 5; |
} |
|
$peugeot = new Peugeot(); |
$renault = new Renault(); |
print_r( $peugeot->roue ); |
print_r( $renault->roue ); |
|
?> |
Visibilité
La visibilité d'un attribut ou d'une méthode peut être définie en prefixant sa déclaration avec un mots clé:
public,
protected ou
private.
Les éléments "
public" peuvent être appelés à n'importe quelle partie du programme. Les "
protected"
ne peuvent être appelés que par la classe elle même ou les classes parents/enfants. Les "
private" sont disponibles
que pour la classe en elle même.
Exemple:
<?php |
|
class voiture{ |
|
public $roue = 4; |
protected $prix = 5000; |
private $nom = "Batmobile"; |
|
} |
|
$voiture = new voiture(); |
|
print_r( $voiture->roue ); |
print_r( $voiture->prix ); |
print_r( $voiture->nom ); |
|
?> |
Mettre ce genre de protection permet d'indiquer au développeur qu'il doit récupérer les valeurs des attributs en passant par
des
getter pour des raisons de stratégies.
Exemple:
<?php |
|
class voiture{ |
|
public $roue = 4; |
protected $prix = 5000; |
private $nom = "Batmobile"; |
|
public function getPrix(){ |
return ( $this->prix + 100 ); |
} |
|
public function getNom(){ |
return $this->nom; |
} |
|
} |
|
$voiture = new voiture(); |
|
print_r( $voiture->roue ); |
print_r( $voiture->getPrix() ); |
print_r( $voiture->getNom() ); |
|
?> |
Pour les méthodes, c'est la même logique:
<?php |
|
class voiture{ |
|
public $roue = 4; |
protected $prix = 5000; |
private $nom = "Batmobile"; |
|
public function getPrix(){ |
return ( $this->calcPrix() + 100 ); |
} |
|
protected function calcPrix(){ |
return ( $this->prix + 10 ); |
} |
|
} |
|
$voiture = new voiture(); |
|
print_r( $voiture->getPrix() ); |
print_r( $voiture->calcPrix() ); |
|
?> |
UNE QUESTION SUR L'ARTICLE?