PHP, classes et objets

Classes et objets en PHP

PHP, comme Java, prend en charge la programmation orientée objet et utilise des classes et des objets comme éléments de base. Comprendre ces concepts est essentiel pour maîtriser PHP. Ce guide couvrira tout ce que vous devez savoir sur les classes et les objets en PHP.

Définir une classe

Une classe en PHP est un modèle pour créer des objets. Il définit la structure et le comportement qu'auront les objets de la classe.

Syntaxe

class ClassName {
    // Properties (Fields)
    // Methods
}

Exemple

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Création d'objets

Les objets sont des instances de classes. Vous créez un objet à partir d'une classe en utilisant le nouveau mot-clé.

Syntaxe

$objectName = new ClassName();

Exemple

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Propriétés et méthodes

Les propriétés (également appelées champs) représentent l'état d'un objet, tandis que les méthodes définissent le comportement de l'objet.

Propriétés

Les propriétés sont des variables qui contiennent les données d'un objet.

Exemple

class Car {
    public $color;
    public $model;
    public $year;
}

Méthodes

Les méthodes sont des fonctions définies au sein d'une classe qui décrivent les comportements des objets.

Exemple

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Constructeurs

Les constructeurs sont des méthodes spéciales qui sont automatiquement appelées lorsqu'un objet est instancié. Ils initialisent l'objet nouvellement créé.

Constructeur par défaut

Si aucun constructeur n'est défini, PHP fournit un constructeur par défaut sans argument.

Exemple

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Constructeur paramétré

Un constructeur paramétré permet d'initialiser un objet avec des valeurs spécifiques.

Exemple

class Car {
    public $color;
    public $model;
    public $year;

    // Parameterized constructor
    public function __construct($color, $model, $year) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Utilisation du constructeur paramétré

class Main {
    public function run() {
        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Surcharge du constructeur

PHP ne prend pas nativement en charge la surcharge de méthodes comme Java, mais vous pouvez la simuler en utilisant des paramètres facultatifs ou en gérant les arguments manuellement au sein d'un seul constructeur.

Exemple

class Car {
    public $color;
    public $model;
    public $year;

    // Simulating constructor overloading
    public function __construct($color = "Unknown", $model = "Unknown", $year = 0) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Utilisation du constructeur surchargé simulé

class Main {
    public function run() {
        $defaultCar = new Car();
        $defaultCar->displayInfo();

        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Encapsulation, modificateurs d'accès et membres statiques en PHP

Encapsulation

L'encapsulation en PHP est la pratique consistant à regrouper des données (propriétés) et des méthodes (fonctions) au sein d'une classe. Il garantit que l’état interne d’un objet est à l’abri des interférences extérieures et des utilisations abusives.

Modificateurs d'accès

Les modificateurs d'accès en PHP contrôlent la visibilité et l'accessibilité des propriétés, des méthodes et des constructeurs. PHP prend en charge trois modificateurs d'accès principaux :

• public : Accessible de partout.
• protected : Accessible au sein de la classe, des sous-classes et du même package.
• privé : Accessible uniquement au sein de la classe de définition.

Exemple d'utilisation :

class ClassName {
    // Properties (Fields)
    // Methods
}

Membres statiques

Les membres statiques en PHP sont associés à la classe elle-même plutôt qu'à une instance spécifique. Ils sont accessibles sans créer d'objet de la classe.

Propriétés statiques :

Les propriétés statiques sont partagées entre toutes les instances d'une classe. Ils sont déclarés à l'aide du mot-clé static.

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Méthodes statiques :

Les méthodes statiques sont déclarées à l'aide du mot-clé static. Ils appartiennent à la classe plutôt qu'à une instance.

$objectName = new ClassName();

Accès aux membres statiques :

Les membres statiques sont accessibles en utilisant le nom de la classe, et non via un objet.

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Modificateurs d'accès en PHP

Les modificateurs d'accès en PHP contrôlent la visibilité des membres de la classe, garantissant l'encapsulation et appliquant les restrictions d'accès.

Types de modificateurs d'accès

1. public
2. protégé
3. privé

1. publique

• Accessible depuis :N’importe où.
• Utilisation : Utilisez public pour les membres qui doivent être largement accessibles.

class Car {
    public $color;
    public $model;
    public $year;
}

2. protégé

• Accessible depuis : Au sein de la classe et de ses sous-classes.
• Utilisation : Utiliser protected pour les membres qui ne doivent être accessibles qu'au sein de la hiérarchie des classes.

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

3. privé

• Accessible depuis : Uniquement au sein de la classe.
• Utilisation : Utilisez private pour les membres qui ne doivent pas être accessibles en dehors de la classe de définition.

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Modificateurs de non-accès en PHP

Les modificateurs de non-accès en PHP modifient le comportement des membres de la classe sans affecter leur visibilité.

Types de modificateurs de non-accès

1. statique
2. finale
3. résumé

1. statique

• Utilisation : Déclare les propriétés et les méthodes qui appartiennent à la classe plutôt qu'à une instance.
• Exemple :

class ClassName {
    // Properties (Fields)
    // Methods
}

2. finale

• Utilisation : Empêche toute modification ultérieure des méthodes ou l'héritage des classes.
• Variables : PHP ne prend pas en charge les variables finales.
• Méthodes : Les méthodes finales ne peuvent pas être remplacées.
• Cours : Les cours finaux ne peuvent pas être prolongés.
• Exemple :

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

3. résumé

• Utilisation : Déclare les classes et méthodes incomplètes et qui doivent être implémentées dans des sous-classes.
• Classes abstraites : Ne peut pas être instanciée.
• Méthodes abstraites : Déclarées sans corps et doivent être implémentées par des sous-classes.
• Exemple :

$objectName = new ClassName();

Héritage en PHP et modificateurs d'accès

Héritage

L'héritage en PHP est un mécanisme par lequel une classe (sous-classe) peut hériter des propriétés et méthodes d'une autre classe (superclasse). Il facilite la réutilisation du code et permet la création d'une relation hiérarchique entre les classes.

Syntaxe pour l'héritage

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Exemple

class Car {
    public $color;
    public $model;
    public $year;
}

Dans cet exemple :

• Animal est la superclasse avec une propriété $name et une méthode eat().
• Dog est la sous-classe qui hérite de $name et eat() d'Animal et ajoute sa propre méthode bark().

Modificateurs d'accès dans l'héritage

Les modificateurs d'accès en PHP déterminent la visibilité des membres de la classe dans les sous-classes et d'autres parties du programme. Ils jouent un rôle clé dans l'héritage.

Modificateurs d'accès pour les attributs et méthodes normaux

• public : Accessible de partout.
• protected : Accessible au sein de la classe, des sous-classes et au sein du même package.
• private : Accessible uniquement au sein de la classe où il est déclaré.

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Modificateurs d'accès pour les attributs et méthodes statiques

Les membres statiques en PHP sont associés à la classe plutôt qu'à une instance spécifique. Ils suivent les mêmes règles d'accès que les membres non statiques en héritage.

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Les méthodes statiques sont-elles héritées ?

Les méthodes statiques sont héritées en PHP mais ne peuvent pas être remplacées dans le même sens que les méthodes d'instance. Lorsqu'une sous-classe définit une méthode statique du même nom, elle masque la méthode statique de la classe parent.

class ClassName {
    // Properties (Fields)
    // Methods
}

Modificateurs d'accès pour les méthodes abstraites

Les méthodes abstraites en PHP doivent être définies dans des classes abstraites. La visibilité d'une méthode abstraite dans la superclasse détermine sa visibilité dans les sous-classes. Les sous-classes doivent implémenter des méthodes abstraites avec des modificateurs d'accès identiques ou moins restrictifs.

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Modificateurs d'accès pour les attributs et méthodes finaux

Les méthodes finales en PHP ne peuvent pas être remplacées par des sous-classes et les classes finales ne peuvent pas être étendues.

• Méthodes finales : Empêcher le remplacement de méthode.
• Cours finaux : Empêcher l'héritage.

$objectName = new ClassName();

Syntaxe pour déclarer les classes de niveau supérieur en PHP

En PHP, la déclaration des classes de premier niveau (classes non imbriquées dans d'autres classes) suit un ordre précis de mots-clés. La déclaration peut inclure des modificateurs d'accès, des mots-clés abstraits ou finaux et le mot-clé class.

Mots-clés pouvant être utilisés :

1. Modificateur d'accès : public
2. Type de cours : résumé ou final

Commande:

class ClassName {
    // Properties (Fields)
    // Methods
}

Syntaxe:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Remarques importantes :

1. PHP considère public comme modificateur d'accès par défaut si aucun n'est spécifié.
2. Un cours ne peut pas être à la fois abstrait et final.
3. les modificateurs d'accès protégés et privés ne sont pas autorisés pour les classes de niveau supérieur.

Exemple:

$objectName = new ClassName();

---

Syntaxe de déclaration d'attributs dans les classes en PHP

Mots-clés pouvant être utilisés :

1. Modificateurs d'accès : public, protégé, privé
2. Modificateur statique : statique
3. Modificateur immuable : lecture seule (introduit dans PHP 8.1)

Commande:

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

Syntaxe:

class Car {
    public $color;
    public $model;
    public $year;
}

Remarques importantes :

1. Attributs par défaut à public si aucun modificateur d'accès n'est spécifié.
2. les attributs statiques appartiennent à la classe plutôt qu'aux instances.
3. les attributs en lecture seule ne peuvent être initialisés qu'une seule fois, soit lors de la déclaration, soit dans le constructeur (PHP 8.1).

Exemple:

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

Syntaxe pour déclarer des méthodes dans les classes en PHP

Mots-clés pouvant être utilisés :

1. Modificateurs d'accès : public, protégé, privé
2. Modificateur statique : statique
3. Modificateur final : final
4. Modificateur abstrait : abstrait

Commande:

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Syntaxe:

class Car {
    public $color;
    public $model;
    public $year;

    // Parameterized constructor
    public function __construct($color, $model, $year) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

Remarques importantes :

1. Si aucun modificateur d'accès n'est spécifié, la méthode est publique par défaut.
2. les méthodes statiques appartiennent à la classe, pas aux instances.
3. les méthodes finales ne peuvent pas être remplacées dans les sous-classes.
4. les méthodes abstraites doivent être déclarées dans une classe abstraite et ne peuvent pas avoir de corps.

Exemple:

class Main {
    public function run() {
        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

Classes abstraites en PHP

Les classes abstraites en PHP sont similaires à leurs homologues en Java, utilisées pour définir un plan pour d'autres classes. Ils contiennent à la fois des méthodes abstraites (méthodes sans implémentation) et des méthodes concrètes (méthodes avec implémentation). Les classes abstraites sont déclarées à l'aide du mot-clé abstract et ne peuvent pas être instanciées directement.

---

1. Introduction aux classes abstraites

Une classe abstraite sert de classe de base pour les classes dérivées. Il définit des comportements communs pour ses sous-classes tout en permettant l'implémentation de méthodes spécifiques dans ces sous-classes.

---

2. Déclarer une classe abstraite

Pour déclarer une classe abstraite en PHP, utilisez le mot-clé abstract avant le mot-clé class.

Exemple:

class ClassName {
    // Properties (Fields)
    // Methods
}

---

3. Méthodes abstraites

Les méthodes abstraites sont définies dans la classe abstraite mais n'ont pas de corps. Les sous-classes doivent implémenter toutes les méthodes abstraites.

Exemple:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

4. Méthodes concrètes

Les méthodes concrètes d'une classe abstraite ont un corps et peuvent être héritées par les sous-classes telles quelles ou remplacées.

Exemple:

$objectName = new ClassName();

---

5. Création de sous-classes

Les sous-classes d'une classe abstraite doivent implémenter toutes ses méthodes abstraites à moins que la sous-classe ne soit également déclarée comme abstraite.

Exemple:

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

6. Instanciation de classes abstraites

Les classes abstraites ne peuvent pas être instanciées directement. Vous devez utiliser une sous-classe concrète pour créer une instance.

Exemple:

class Car {
    public $color;
    public $model;
    public $year;
}

---

7. Constructeurs dans les classes abstraites

Les classes abstraites peuvent avoir des constructeurs, et leurs constructeurs sont appelés lorsqu'une sous-classe est instanciée.

Exemple:

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

8. Classes abstraites avec champs et méthodes

Les classes abstraites peuvent inclure des variables d'instance et des méthodes concrètes, fournissant des fonctionnalités réutilisables pour les sous-classes.

Exemple:

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

9. Méthodes statiques dans les classes abstraites

Les classes abstraites peuvent contenir des méthodes statiques. Les méthodes statiques appartiennent à la classe et peuvent être appelées sans l'instancier.

Exemple:

class ClassName {
    // Properties (Fields)
    // Methods
}

---

Syntaxe pour déclarer des classes abstraites en PHP

Mots-clés pouvant être utilisés :

1. résumé
2. public, protégé, privé (modificateurs d'accès)

Commande:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

Exemples :

Cours abstrait avec méthodes abstraites et concrètes

$objectName = new ClassName();

Classe abstraite avec champs et méthodes finales

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

Remarques importantes :

1. Les classes abstraites ne peuvent pas être instanciées directement.
2. Les méthodes abstraites doivent être implémentées par des sous-classes non abstraites.
3. Les sous-classes qui n'implémentent pas toutes les méthodes abstraites doivent également être déclarées abstraites.
4. Les méthodes concrètes dans les classes abstraites sont facultatives pour que les sous-classes puissent les remplacer.
5. Les classes abstraites peuvent avoir des constructeurs, des propriétés et des constantes.
6. Les classes abstraites peuvent utiliser n'importe quel modificateur de visibilité pour leurs méthodes et propriétés.

Interfaces en PHP

Une interface en PHP définit un contrat pour les classes qui l'implémentent. Il spécifie les méthodes qu'une classe doit implémenter, mais ne fournit aucune implémentation de méthode elle-même. Les interfaces permettent un code plus flexible et modulaire, permettant aux classes d'adhérer à un ensemble commun de signatures de méthodes, quelle que soit leur hiérarchie d'héritage.

---

1. Introduction aux interfaces

Une interface en PHP est similaire à une classe abstraite, mais elle ne peut définir que des signatures de méthodes sans aucune implémentation. Une classe qui implémente une interface doit fournir les implémentations de toutes les méthodes déclarées dans l'interface. Une classe peut implémenter plusieurs interfaces, ce qui fait des interfaces un élément clé de la prise en charge par PHP de l'héritage multiple de comportement.

---

2. Déclarer une interface

Pour déclarer une interface, utilisez le mot-clé interface. Les interfaces ne peuvent contenir que des déclarations de méthodes (pas de corps de méthode), des constantes et des méthodes abstraites.

Exemple:

class Car {
    public $color;
    public $model;
    public $year;
}

---

3. Implémentation d'une interface

Une classe qui implémente une interface doit fournir des implémentations pour toutes les méthodes déclarées dans l'interface. Une classe peut implémenter plusieurs interfaces, en les séparant par des virgules.

Exemple:

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

4. Signatures de méthodes d'interface

Les méthodes dans les interfaces ne peuvent pas avoir de corps et elles doivent être publiques. Lorsqu'une classe implémente une interface, elle doit implémenter ces méthodes exactement comme déclarées dans l'interface, y compris la signature de la méthode.

Exemple:

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

5. Implémentation d'interfaces multiples

Une classe en PHP peut implémenter plusieurs interfaces. Cela permet plus de flexibilité dans la conception de systèmes dans lesquels les classes peuvent adhérer à différents contrats.

Exemple:

class ClassName {
    // Properties (Fields)
    // Methods
}

---

6. Constantes d'interface

Les interfaces peuvent contenir des constantes. Ces constantes sont automatiquement publiques et accessibles par toute classe qui implémente l'interface.

Exemple:

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

7. Héritage des interfaces

Une interface peut étendre une autre interface. Cela signifie que l'interface enfant hérite de toutes les méthodes (signatures) de l'interface parent et peut également ajouter de nouvelles méthodes. Une classe implémentant l'interface enfant doit implémenter toutes les méthodes des interfaces parent et enfant.

Exemple:

$objectName = new ClassName();

---

8. Méthodes statiques dans les interfaces

Les interfaces ne peuvent pas contenir de méthodes statiques. Toutes les méthodes déclarées dans une interface doivent être des méthodes d'instance. Les méthodes statiques ne sont pas autorisées dans les interfaces, car les interfaces définissent des contrats au niveau de l'instance pour les classes d'implémentation.

---

Syntaxe pour déclarer et implémenter des interfaces en PHP

Mots-clés pouvant être utilisés :

1. interface
2. publique

Commande:

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

---

Exemples :

Interface avec les signatures de méthode

class Car {
    public $color;
    public $model;
    public $year;
}

Interface avec plusieurs implémentations

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

---

Remarques importantes :

1. Méthodes d'interface : les méthodes d'une interface doivent être publiques et ne peuvent pas avoir de corps.
2. Implémentation de plusieurs interfaces : Une classe peut implémenter plusieurs interfaces, en les séparant par des virgules.
3. Modificateurs d'accès : Toutes les méthodes d'une interface sont implicitement publiques. Les modificateurs d'accès comme privé ou protégé ne sont pas autorisés.
4. Constantes d'interface : les interfaces peuvent déclarer des constantes qui sont automatiquement publiques et accessibles en implémentant des classes.
5. Héritage d'interface : Une interface peut étendre une ou plusieurs interfaces, en combinant leurs signatures de méthode.
6. Méthodes statiques : les interfaces ne peuvent pas contenir de méthodes statiques.
7. Implémentation de toutes les méthodes : Une classe doit implémenter toutes les méthodes définies par les interfaces qu'elle implémente.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!