Comprendre la différence entre « classe abstraite » et « interface » en PHP

Différence entre classe abstraite et interface en PHP

En PHP, les classes abstraites et les interfaces sont utilisées pour définir des structures que d'autres classes doivent suivre, mais elles servent des objectifs différents et ont des caractéristiques distinctes. Comprendre quand utiliser une classe abstraite par rapport à une interface est crucial pour concevoir un système orienté objet bien structuré et flexible. Explorons les différences entre ces deux concepts.

---

1. Définition

Cours abstrait :

Une classe abstraite est une classe qui ne peut pas être instanciée seule et qui est destinée à être étendue par d'autres classes. Il peut contenir à la fois des méthodes abstraites (méthodes sans implémentations) et des méthodes concrètes (méthodes avec implémentations). Les classes abstraites vous permettent de définir une classe de base commune pour un groupe de classes liées, avec des fonctionnalités partagées et des méthodes qui doivent être implémentées par les classes dérivées.

Interface :

Une interface est un contrat qui définit un ensemble de méthodes qu'une classe doit implémenter, mais contrairement à une classe abstraite, elle ne peut contenir aucune implémentation de méthode (en PHP, avant la version 8, les interfaces ne pouvaient pas Il n'y a aucune implémentation, bien que PHP 8 ait introduit des méthodes par défaut dans les interfaces). Les interfaces se concentrent uniquement sur la structure (les méthodes qui devraient exister) et laissent l'implémentation à la classe.

---

2. Objectif

• Classe abstraite : utilisée lorsque vous disposez d'une classe de base qui doit fournir un comportement par défaut ou partager certaines fonctionnalités communes entre les sous-classes, tout en permettant aux sous-classes de définir certains de leurs comportements.
• Interface : Utilisé pour définir un ensemble de méthodes que des classes non liées doivent implémenter. Les interfaces sont idéales pour définir des comportements communs entre les classes qui ne partagent pas un ancêtre commun.

---

3. Implémentation de la méthode

Cours abstrait :

• Peut avoir à la fois des méthodes abstraites (sans implémentation) et des méthodes concrètes (avec implémentation).
• Les méthodes abstraites doivent être implémentées par n'importe quelle sous-classe, mais les méthodes concrètes peuvent être héritées telles quelles ou remplacées.

Interface :

• Peut uniquement déclarer les signatures de méthode (méthodes sans corps), laissant l'implémentation aux classes.
• PHP 8 permet aux interfaces d'avoir des méthodes par défaut, ce qui signifie que vous pouvez fournir une implémentation, mais la classe peut toujours la remplacer.

Exemple :

// Abstract Class
abstract class Animal {
    abstract public function makeSound(); // Abstract method
    public function sleep() {
        echo "Sleeping..."; // Concrete method
    }
}

// Interface
interface AnimalInterface {
    public function makeSound(); // Only method signature
    public function eat(); // Only method signature
}

---

4. Héritage vs mise en œuvre

Cours abstrait :

• Une classe ne peut étendre qu'une seule classe abstraite car PHP ne prend pas en charge l'héritage multiple.
• Une sous-classe hérite à la fois des méthodes abstraites et concrètes de la classe abstraite.

Interface :

• Une classe peut implémenter plusieurs interfaces. C'est la manière dont PHP prend en charge l'héritage multiple pour le comportement (mais pas pour l'implémentation).

Exemple :

// Abstract Class Example
abstract class Bird {
    abstract public function fly();
}

class Sparrow extends Bird {
    public function fly() {
        echo "Sparrow is flying";
    }
}

// Interface Example
interface Flyable {
    public function fly();
}

interface Eatable {
    public function eat();
}

class Sparrow implements Flyable, Eatable {
    public function fly() {
        echo "Sparrow is flying";
    }

    public function eat() {
        echo "Sparrow is eating";
    }
}

---

5. Propriétés

Cours abstrait :

• Une classe abstraite peut avoir des propriétés (variables) avec des valeurs par défaut. Ces propriétés peuvent être héritées par les classes enfants.

Interface :

• Une interface ne peut pas avoir de propriétés. Il ne peut définir que des signatures de méthode, des constantes et des valeurs de constantes (le cas échéant).

Exemple :

// Abstract Class with Properties
abstract class Animal {
    public $name;
    abstract public function makeSound();
}

// Interface with Constants (No Properties)
interface AnimalInterface {
    const MAX_AGE = 100; // Constant
    public function makeSound();
}

---

6. Visibilité des Méthodes

Cours abstrait :

• Les méthodes peuvent avoir différents niveaux de visibilité : public, protégé ou privé.
• La visibilité des méthodes abstraites doit être maintenue lorsqu'elles sont implémentées dans des sous-classes.

Interface :

• Toutes les méthodes déclarées dans une interface doivent être publiques, car elles doivent être accessibles par les classes qui implémentent l'interface.

---

7. Cas d'utilisation

Cours abstrait :

• Fonctionnalité partagée : lorsque vous disposez d'un code commun qui doit être partagé entre plusieurs classes, comme le comportement par défaut de certaines méthodes.
• Ancêtre commun : lorsque vous souhaitez vous assurer que toutes les classes dérivées partagent une base commune et que vous pouvez fournir des fonctionnalités par défaut.

Interface :

• Comportements multiples : lorsque différentes classes doivent implémenter un ensemble de méthodes mais peuvent avoir des implémentations différentes et qu'elles ne partagent pas nécessairement un ancêtre commun.
• Code de découplage : Lorsqu'il faut découpler la définition d'un comportement de sa mise en œuvre.

---

8. Constructeur

Cours abstrait :

• Les classes abstraites peuvent avoir des constructeurs et définir un comportement partagé entre les sous-classes.

Interface :

• Les interfaces ne peuvent pas avoir de constructeurs car ils définissent uniquement les signatures de méthodes, pas les implémentations.

---

9. Exemple de classe abstraite vs interface

Exemple de classe abstraite :

// Abstract Class
abstract class Animal {
    abstract public function makeSound(); // Abstract method
    public function sleep() {
        echo "Sleeping..."; // Concrete method
    }
}

// Interface
interface AnimalInterface {
    public function makeSound(); // Only method signature
    public function eat(); // Only method signature
}

Exemple d'interface :

// Abstract Class Example
abstract class Bird {
    abstract public function fly();
}

class Sparrow extends Bird {
    public function fly() {
        echo "Sparrow is flying";
    }
}

// Interface Example
interface Flyable {
    public function fly();
}

interface Eatable {
    public function eat();
}

class Sparrow implements Flyable, Eatable {
    public function fly() {
        echo "Sparrow is flying";
    }

    public function eat() {
        echo "Sparrow is eating";
    }
}

---

Résumé des principales différences

Fonctionnalité Cours abstrait Interface ête>

Feature	Abstract Class	Interface
Method Implementation	Can have both abstract and concrete methods	Can only have method signatures (PHP 8 allows default methods)
Properties	Can have properties with default values	Cannot have properties
Constructor	Can have constructors	Cannot have constructors
Inheritance	Single inheritance (one parent class)	Multiple inheritance (can implement multiple interfaces)
Visibility	Can have public, protected, or private methods	All methods must be public
Use Case	Use when there’s common functionality	Use when defining a contract (set of methods)
Access to Methods	Can be inherited or overridden	Must be implemented by the class

Mise en œuvre de la méthode Peut avoir des méthodes abstraites et concrètes Ne peut avoir que des signatures de méthodes (PHP 8 autorise les méthodes par défaut) Propriétés Peut avoir des propriétés avec des valeurs par défaut Ne peut pas avoir de propriétés Constructeur Peut avoir des constructeurs Impossible d'avoir des constructeurs Héritage Héritage unique (une classe parent) Héritage multiple (peut implémenter plusieurs interfaces) Visibilité Peut avoir des méthodes publiques, protégées ou privées Toutes les méthodes doivent être publiques Cas d'utilisation À utiliser lorsqu'il existe des fonctionnalités communes À utiliser lors de la définition d'un contrat (ensemble de méthodes) Accès aux méthodes Peut être hérité ou remplacé Doit être implémenté par la classe

---

Conclusion

Les classes abstraites et les interfaces sont des outils puissants dans la conception orientée objet de PHP, mais elles servent des objectifs différents.

• Les Classes abstraites sont utilisées lorsque vous souhaitez partager des fonctionnalités et des états communs entre les classes.
• Les Interfaces sont utilisées pour définir un contrat auquel plusieurs classes, potentiellement sans rapport, doivent adhérer.

Le choix entre une classe abstraite et une interface dépend des besoins spécifiques de l’architecture de votre application. Si vous avez besoin de fonctionnalités partagées, optez pour une classe abstraite. Si vous devez vous assurer qu'un ensemble de méthodes est implémenté dans plusieurs classes, utilisez une interface.

---

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!