Classes et objets PHP

Dans ce tutoriel, vous apprendrez à écrire du code de manière orientée objet en PHP.

What is object-oriented programming

La programmation orientée objet (OOP) est un modèle de programmation basé sur les concepts de classes et d'objets. Contrairement à la programmation procédurale, qui met l'accent sur l'écriture de processus ou de fonctions qui exécutent des opérations sur les données, l'object-orienté se concentre sur la création d'objets qui contiennent à la fois des données et des fonctions.

Compared to conventional or procedural programming, object-oriented programming has several advantages. The most important are listed below:

• Cela fournit une structure modulaire claire au programme.

• Cela peut vous aider à respecter le principe «Ne pas répéter soi-même» (DRY), rendant ainsi votre code plus facile à maintenir, à modifier et à déboguer.

• Cela permet de créer des comportements plus complexes avec moins de code, un temps de développement plus court et une haute réutilisabilité.

Les sections suivantes décriront comment les classes et les objets fonctionnent en PHP.

Comprendre les classes et les objets

Les classes et les objets sont les deux aspects principaux de la programmation orientée objet. Une classe est une collection indépendante de variables et de fonctions qui travaillent ensemble pour exécuter une ou plusieurs tâches spécifiques, tandis qu'un objet est une instance unique d'une classe.

Une classe agit comme un modèle ou un plan, à partir duquel on peut créer de nombreux objets individuels. Lors de la création d'un seul objet, bien que certains attributs de chaque objet puissent avoir des valeurs différentes, ils héritent des attributs et comportements communs.

Par exemple, considérez la classe comme le plan d'un bâtiment. Le plan en lui-même n'est pas le bâtiment, mais le plan détaillé du bâtiment. Et l'objet est comme le bâtiment réel construit selon ce plan. Nous pouvons construire plusieurs maisons identiques selon le même plan, mais chaque maison peut avoir des peintures, des aménagements intérieurs et des familles différentes, comme le montre la figure suivante.

On peut déclarer une classe en utilisant le mot-clé class, suivi du nom de la classe et d'un couple de crochets ({}), comme dans l'exemple suivant.

Créons un fichier PHP nommé Recangle.php et placez le code suivant à l'intérieur, afin de séparer notre code de classe du reste du programme. Ensuite, nous n'avons qu'à inclure le fichier Recangle.php pour l'utiliser partout où nécessaire.

<?php
class Rectangle
{
　　　　//Déclarer les attributs
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
?>

Le mot-clé public avant les attributs et méthodes dans l'exemple précédent est unModificateur d'accèsindique que cet attribut ou cette méthode peut être accédé depuis n'importe où. Nous en apprendrons davantage sur ce sujet plus tard dans ce chapitre.

Créer un autre fichier PHP nommé test.php et placez le code suivant à l'intérieur.

<?php
//包含类定义
class Rectangle
{
　　　　//Déclarer les attributs
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//Créer un nouvel objet à partir de la classe Rectangle
$obj = new Rectangle;
　
//Obtenir les valeurs des attributs de l'objet
echo $obj->length;　//　Sortie : 0
echo $obj->width;　//　Sortie : 0
　
//Définir la valeur de l'attribut de l'objet
$obj->length =　30;
$obj->width =　20;
　
//Lire à nouveau les valeurs des attributs de l'objet pour afficher les modifications
echo $obj->length;　//　Sortie :　30
echo "<br>";
echo $obj->width;　//　Sortie :　20
　
　
//Appel de la méthode de l'objet
echo $obj->getPerimeter();　//　Sortie :　100
echo "<br>";
echo $obj->getArea();　//　Sortie :　600
?>

Le symbole de flèche (->() est une construction OOP utilisée pour accéder aux attributs et méthodes contenus dans un objet donné. Le pseudo-variables $this fournit une référence à l'objet appelant (c'est-à-dire l'objet auquel appartient la méthode).

Quand on utilise plusieurs instances de la même classe, la véritable puissance de la programmation orientée objet (OOP) est évidente, comme le montre l'exemple suivant :

<?php
//包含类定义
class Rectangle
{
　　　　//Déclarer les attributs
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//Créer plusieurs objets à partir de la classe Rectangle
$obj1　= new Rectangle;
$obj2　= new Rectangle;
　
//Appel des méthodes des deux objets
echo $obj1->getArea();　//Sortie : 0
echo $obj2->getArea();　//Sortie : 0
　
//Définir $obj1Valeur de l'attribut
$obj1->length =　30;
$obj1->width =　20;
　
//Définir $obj2Valeur de l'attribut
$obj2->length =　35;
$obj2->width =　50;
　
//Appel à nouveau des méthodes des deux objets
echo $obj1->getArea();　//Sortie :600
echo "<br>";
echo $obj2->getArea();　//Sortie :1750
?>

Comme illustré dans l'exemple ci-dessus, l'appel de la méthode getArea() sur des objets différents permet à cette méthode de s'opérer sur des ensembles de données différents. Chaque instance d'objet est complètement indépendante, possédant ses propres attributs et méthodes, donc même si elles appartiennent à la même classe, elles peuvent être manipulées indépendamment.

使用构造函数和析构函数

为了简化面向对象的编程，PHP提供了一些魔术方法，当对象中发生某些操作时，这些方法会自动执行。

例如，每当创建新对象时，魔术方法__construct()（称为构造函数）都会自动执行。 同样，魔术方法__destruct()（称为析构函数）在对象被销毁时会自动执行。 销毁对象后，析构函数将清除分配给该对象的所有资源。

<?php
class MyClass
{
　　　　//　Constructeur
　　　　public function __construct(){
　　　　　　　　echo '  Classe "' . __CLASS__ . '" a démarré<br>';
　　　　}
　　　　
　　　　//　析构函数
　　　　public function __destruct(){
　　　　　　　　echo '类 "' . __CLASS__ . '" 已销毁<br>';
　　　　}
}
　
//创建一个新对象
$obj = new MyClass;
　
//在文件末尾输出消息
echo "到达文件末尾。";
?>

Le code PHP de l'exemple suivant produira la sortie suivante :

类 "MyClass" 已启动
到达文件末尾。
类 "MyClass" 已销毁

脚本结束时将自动调用析构函数。但是，要显式触发析构函数，可以使用PHP unset()函数销毁对象，如下所示：

<?php
class MyClass
{
　　　　//　Constructeur
　　　　public function __construct(){
　　　　　　　　echo '  Classe "' . __CLASS__ . '" a démarré<br>';
　　　　}
　　　　
　　　　//　析构函数
　　　　public function __destruct(){
　　　　　　　　echo '类 "' . __CLASS__ . '" 已销毁<br>';
　　　　}
}
　
//创建一个新对象
$obj = new MyClass;
　
//　销毁对象
unset($obj);
　
//在文件末尾输出消息
echo "到达文件末尾。";
?>

现在，以上示例中的PHP代码将产生以下输出：

类 "MyClass" 已启动
类 "MyClass" 已销毁
到达文件末尾。

通过继承扩展类

类可以使用extends关键字继承另一个类的属性和方法。可扩展性的过程称为继承。这可能是使用面向对象的编程模型背后最强大的原因。

<?php
//包含类定义
class Rectangle
{
　　　　//Déclarer les attributs
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//根据现有的类定义一个新的类
class Square extends Rectangle
{　　　
　　　　//方法来测试矩形是否也是正方形
　　　　public function isSquare(){
　　　　　　　　if($this->length == $this->width){
　　　　　　　　　　　　return true;　//　C'est un carré
　　　　　　　　} else {
　　　　　　　　　　　　return false;　//Ce n'est pas un carré
　　　　　　　　}
　　　　}
}
　
//Créer un nouveau objet à partir de la classe Square
$obj = new Square;
　
//　Définir la valeur de l'attribut de l'objet
$obj->length =　20;
$obj->width =　20;
　
//　Appel de la méthode de l'objet
if($obj->isSquare()){
　　　　echo "L'aire du carré est";
} else {
　　　　echo "L'aire du rectangle est";
};
echo $obj->getArea();
?>

Le code PHP de l'exemple suivant produira la sortie suivante :

L'aire du carré est　400

Comme vous pouvez le voir dans l'exemple ci-dessus, bien que la définition de la classe Square ne contienne pas explicitement la méthode getArea() ni les attributs $length et $width, l'instance de la classe Square peut les utiliser, car elles sont héritées de la classe parente Rectangle.

Contrôle de la visibilité des attributs et des méthodes

Lors de l'utilisation d'une classe, vous pouvez même utiliser les mots-clés de visibilité pour limiter l'accès à ses attributs et méthodes, ce qui permet un meilleur contrôle. Il y a trois mots-clés de visibilité (de la plus visible à la moins visible) : public, protected, private, qui déterminent comment et d'où accéder et modifier les attributs et les méthodes.

• public - Il est possible d'utiliser les mots-clés de visibilité pour limiter l'accès aux attributs et aux méthodes d'une classe lors de son utilisation, ce qui permet un meilleur contrôle. Il y a trois mots-clés de visibilité (de la plus visible à la moins visible) : public, protected, private, qui déterminent comment et d'où accéder et modifier les attributs et les méthodes.
  

• protected - Les attributs ou les méthodes protégés ne peuvent être accédés que depuis la classe elle-même ou les sous-classes ou les classes héritées (c'est-à-dire les classes qui étendent cette classe).
  

• private - Les attributs ou les méthodes privés ne peuvent être accédés que depuis la classe qui les définit. Même les sous-classes ou les classes héritées ne peuvent pas accéder aux attributs ou méthodes privés.

Le suivant est un exemple qui vous montre comment cela fonctionne réellement :

<?php
//Définition de la classe
class Automobile
{
　　　　//Déclarer les attributs
　　　　public $fuel;
　　　　protected $engine;
　　　　private $transmission;
}
class Car extends Automobile
{
　　　　//　Constructeur
　　　　public function __construct(){
　　　　　　　　echo '  Classe "' . __CLASS__ . '" a démarré<br>';
　　　　}
}
　
//Créer un objet à partir de la classe Automobile
$automobile = new Automobile;
　
//Essayer de définir les attributs de l'objet $automobile
$automobile->fuel = 'Essence';　//　ok
$automobile->engine = '1500 cc';　//　erreur fatale
$automobile->transmission = 'Manual';　//　erreur fatale
　
//Créez un objet à partir de la classe Car
$car = new Car;
　
//Tentez de définir la propriété de l'objet $car
$car->fuel = 'Diesel';　//　ok
$car->engine = '2200 cc';　//　erreur fatale
$car->transmission = 'Automatic';　//　undefined
?>

Propriétés et méthodes statiques

En plus de la visibilité, les propriétés et les méthodes peuvent être déclarées comme statiques (statiques), ce qui permet d'y accéder sans instance de la classe. Vous pouvez utiliser l'opérateur de portée (::) pour accéder aux propriétés et méthodes statiques, comme suit : ClassName::$property et ClassName::method().

Bien que les méthodes statiques puissent être utilisées, les propriétés déclarées comme statiques ne peuvent pas être accédées via l'objet de la classe, comme dans l'exemple suivant :

<?php
//Définition de la classe
class HelloClass
{
　　　　//Déclaration de propriété statique
　　　　public static $greeting = "Hello World!";
　　　　
　　　　//Déclaration de méthode statique
　　　　public static function sayHello(){
　　　　　　　　echo self::$greeting;
　　　　}
}
//Tentez d'accéder directement aux propriétés et méthodes statiques
echo HelloClass::$greeting;　//Sortie : Hello World!
HelloClass::sayHello();　//Sortie : Hello World!
　
//Tentez d'accéder aux propriétés et méthodes statiques via l'objet
$hello = new HelloClass;
echo $hello->greeting;　//　Avertissement strict
$hello->sayHello();　//Sortie : Hello World!
?>

Dans l'exemple précédent, le mot-clé self représente «la catégorie actuelle». Il ne peut pas commencer par un symbole dollar ($) et commence toujours par l'opérateur de portée (::) (par exemple self :: $ name).

La clé self est différente de la clé this, elle représente «l'objet courant» ou «l'instance actuelle de la classe». Ce mot-clé commence toujours par un symbole dollar ($) suivi de-> opérateurs (par exemple $ this-> name()).

Nous espérons que vous avez maintenant compris les concepts de base de la programmation orientée objet. Vous trouverez plus d'exemples d'OOP dans la partie PHP et base de données MySQL.