Auteur Auteur

Les classes et les objets

Les classes et les objets sont des concepts essentiels en programmation orientée objet (POO). En PHP, la POO est une approche puissante qui vous permet de créer des structures de données complexes et de les manipuler de manière encapsulée.

Dans ce cours, nous allons couvrir les bases de la création de classes et d'objets en PHP, ainsi que leur utilisation avec des exemples concrets.

I. Introduction aux classes et aux objets

  • Une classe est une structure qui définit les propriétés et les comportements d'un objet.
  • Un objet est une instance d'une classe, qui a ses propres attributs et méthodes.

II. Déclaration d'une classe

  • Une classe est déclarée en utilisant le mot-clé "class", suivi du nom de la classe.
  • Les propriétés de la classe sont déclarées à l'intérieur des accolades, avec des modificateurs d'accès comme "public", "private" ou "protected".
  • Les méthodes de la classe sont également déclarées à l'intérieur des accolades.

Exemple : 

class MyClass {
    // Propriétés
    public $myProperty;

    // Méthodes
    public function myMethod() {
        // Code de la méthode
    }
}

III. Création d'un objet

  • Un objet est créé à partir d'une classe à l'aide du mot-clé "new".
  • Une fois créé, vous pouvez accéder aux propriétés et aux méthodes de l'objet en utilisant l'opérateur "->".
Exemple : 


$obj = new MyClass();
$obj->myProperty = "Valeur";
$obj->myMethod();

IV. Constructeur et destructeur

  • Le constructeur est une méthode spéciale qui s'exécute automatiquement lorsqu'un nouvel objet est créé.
  • Il est généralement utilisé pour initialiser les propriétés de l'objet.
  • Le destructeur est une méthode spéciale qui est appelée lorsque l'objet n'est plus utilisé.
  • Il est généralement utilisé pour nettoyer les ressources utilisées par l'objet.
Exemple : 


class MyClass {
    public function __construct() {
        // Code du constructeur
    }

    public function __destruct() {
        // Code du destructeur
    }
}

V. Encapsulation

  • L'encapsulation est le fait de regrouper les propriétés et les méthodes liées dans une classe.
  • Vous pouvez définir l'accès aux propriétés et aux méthodes en utilisant les modificateurs d'accès : "public", "private" et "protected".
  • Les propriétés publiques peuvent être accédées directement, tandis que les propriétés privées et protégées nécessitent l'utilisation de méthodes spéciales appelées "getters" et "setters".
Exemple : 


class MyClass {
    private $myPrivateProperty;

    public function getMyProperty() {
        return $this->myPrivateProperty;
    }

    public function setMyProperty($value) {
        $this->myPrivateProperty = $value;
    }
}

$obj = new MyClass();
$obj->setMyProperty("Valeur");
echo $obj->getMyProperty(); // Affiche "Valeur"

VI. Héritage

  • L'héritage permet de créer de nouvelles classes en se basant sur une classe existante.
  • Une classe héritante (ou dérivée) peut accéder aux propriétés et aux méthodes de la classe parente (ou de base).
  • Cela permet de réutiliser le code existant et de créer des relations hiérarchiques entre les classes.
Exemple : 


class ParentClass {
    protected $myProperty;

    protected function myMethod() {
        // Code de la méthode parente
    }
}

class ChildClass extends ParentClass {
    public function myChildMethod() {
        $this->myProperty = "Valeur";
        $this->myMethod();
    }
}

VII. Polymorphisme

  • Le polymorphisme permet de traiter des objets de différentes classes de manière uniforme.
  • Cela signifie que vous pouvez utiliser une classe parente comme référence pour des objets de classes dérivées.
  • L'appel d'une méthode sur un objet utilisant une référence de classe parente exécutera la méthode appropriée de la classe dérivée.
Exemple : 

class ParentClass {
    public function myMethod() {
        echo "Méthode parente";
    }
}

class ChildClass extends ParentClass {
    public function myMethod() {
        echo "Méthode enfant";
    }
}

$obj1 = new ParentClass();
$obj2 = new ChildClass();

$obj1->myMethod(); // Affiche "Méthode parente"
$obj2->myMethod(); // Affiche "Méthode enfant"

Voici un exemple d'une classe Person : 

class Person {
    // Propriétés
    private $name;
    private $age;

    // Constructeur
    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }

    // Méthodes
    public function getName() {
        return $this->name;
    }

    public function getAge() {
        return $this->age;
    }

    public function sayHello() {
        echo "Bonjour, je m'appelle " . $this->name . " et j'ai " . $this->age . " ans.";
    }
}

// Utilisation de la classe
$person = new Person("Russell", 19);
echo $person->getName(); // Affiche "Russell"
echo $person->getAge(); // Affiche 19
$person->sayHello(); // Affiche "Bonjour, je m'appelle Russell et j'ai 19 ans."

Explication du code

Dans cet exemple, nous avons une classe Person avec deux propriétés privées ($name et $age) ainsi qu'un constructeur pour initialiser ces propriétés lorsqu'un nouvel objet Person est créé.

Nous avons également trois méthodes :

  • getName() qui renvoie le nom de la personne.
  • getAge() qui renvoie l'âge de la personne.
  • sayHello() qui affiche un message de salutation incluant le nom et l'âge de la personne.

Finalement, nous pouvons créer un objet Person avec le nom "Russell" et l'âge 19, afficher le nom et l'âge en utilisant les méthodes getName() et getAge(), et utiliser la méthode sayHello() pour afficher le message de salutation.

C'était un cours complet sur les classes et les objets en PHP avec des exemples. J'espère que cela vous a aidé à mieux comprendre ces concepts fondamentaux de la programmation orientée objet en PHP. N'hésitez pas à pratiquer davantage et à expérimenter avec des exemples supplémentaires pour approfondir votre compréhension.

Précédent