Composition de parties PHP OOP vs héritage et injection de dépendances

Dans cette série, je couvrirai les principes fondamentaux de la programmation orientée objet (POO) PHP. Le contenu sera organisé en parties séquentielles, chacune se concentrant sur un sujet spécifique. Si vous êtes débutant ou si vous n'êtes pas familier avec les concepts de POO, cette série est conçue pour vous guider étape par étape. Dans cette partie, je discuterai de la composition par rapport à l'héritage et à l'injection de dépendances en PHP. Commençons ensemble le voyage d’apprentissage de PHP OOP !

Composition vs héritage

Nous avons déjà découvert la relation entre les classes parent et enfant dans la programmation orientée objet, où nous avons vu qu'une classe enfant peut hériter d'une classe parent et accéder à tout à partir de celle-ci. C'est ce qu'on appelle l'héritage.

D'un autre côté, la composition fait référence à l'attribution d'une classe parent comme valeur de propriété dans la classe enfant, plutôt que d'en hériter. Grâce à cela, nous pouvons accéder à tout depuis la classe parent. C'est ce qu'on appelle la composition.

Vous trouverez ci-dessous des exemples illustrant la composition et l'héritage.

Exemple de code

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

Dans le premier exemple, nous pouvons voir que la classe ShoLink hérite de la classe Link. En revanche, dans le deuxième exemple, la classe User n'hérite pas de la classe Link. Au lieu de cela, il attribue une instance de la classe Link à l'une de ses propriétés. En conséquence, nous pouvons accéder à tout depuis la classe Link dans les deux classes enfants.

Maintenant, une question peut se poser : si nous pouvons déjà accéder à tout en utilisant l'héritage, pourquoi devrions-nous utiliser la composition ? Après tout, avec la composition, nous devons déclarer une propriété supplémentaire et fixer sa valeur via la construction. Cela semble être un travail supplémentaire : alors quel est l'avantage d'utiliser la composition ?

Eh bien, nous savons que l'héritage rend tout ce qui se trouve dans la classe parent accessible dans la classe enfant. Par conséquent, même si l'on ne souhaite pas utiliser certaines méthodes de la classe parent ou si certaines propriétés ou méthodes de la classe parent ne sont pas nécessaires dans la classe enfant, elles deviennent quand même accessibles dans la classe enfant si elles sont des membres publics ou protégés. .

Pour résoudre ce problème, une composition est utilisée. Avec la composition, nous pouvons rendre accessibles uniquement les parties requises de la classe parent dans la classe enfant. Clarifions cela davantage avec un autre exemple.

Si nous regardons attentivement la classe Link, nous pouvons voir qu'elle possède une méthode show. Grâce à cette méthode, nous pouvons afficher directement le lien créé dans la classe ShoLink.

Cependant, que se passe-t-il si nous voulons que la classe User empêche quiconque de visualiser directement le lien créé pour l'utilisateur ? Au lieu de cela, nous souhaiterions peut-être afficher le lien de l’utilisateur à côté de son profil.

C'est pourquoi, dans la classe User, au lieu d'hériter de la classe Link, nous y accédons via la composition. Par conséquent, personne ne peut visualiser directement le lien de l’utilisateur via la classe User, mais il peut visualiser directement le lien de la classe ShoLink.

Privilégier la composition à l'héritage

Maintenant, nous comprenons un peu la composition et quand l'utiliser à la place de l'héritage pour résoudre certains problèmes. En POO, il existe un principe appelé « Favoriser la composition plutôt que l'héritage », qui signifie donner la priorité à la composition plutôt qu'à l'héritage. En d’autres termes, pour les classes enfants où il n’est pas nécessaire d’accéder à tout depuis la classe parent, il faut toujours préférer la composition à l’héritage.

Maintenant, la question se pose : comment décider quand utiliser la composition et quand utiliser l'héritage ?

Dans ce cas, nous devons fonder notre décision sur deux types de relations :

1. est un -> relation. Si la relation est « est un », nous devrions utiliser l'héritage.
2. a un -> relation. Si la relation est « a un », nous devrions utiliser la composition.

Exemple de code

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

Si vous regardez l'exemple de la classe ShoLink ci-dessus, vous verrez que la classe ShoLink hérite de la classe Link. Donc, si je devais définir une relation entre eux, la relation serait ShoLink est un lien car ShoLink est essentiellement un type de lien.

Exemple de code

// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}

Maintenant, si nous regardons l'exemple de la classe User ci-dessus, nous pouvons voir que la classe User utilise la composition avec la classe Link. Donc, si je devais définir une relation entre eux, la relation serait : L'utilisateur a un lien car un utilisateur n'est pas un lien, mais un utilisateur peut avoir un lien ou en posséder un.

J'espère que vous avez maintenant une compréhension plus claire de la composition et de l'héritage, y compris quand utiliser chacun d'eux et lequel donner la priorité dans différentes situations.

Injection de dépendance

Avant de comprendre l'injection de dépendances, nous devons d'abord comprendre ce qu'est une dépendance. Une dépendance se produit lorsqu'une classe enfant utilise les membres d'une autre classe, soit par héritage, soit par composition. Dans ce cas, la classe parent devient la dépendance de la classe enfant.

Dans l'exemple ci-dessus, nous avons vu que lorsque nous utilisons la composition au lieu de l'héritage, nous devons déclarer une propriété dans la classe enfant et attribuer l'instance de la classe parent à cette propriété via le constructeur. Par conséquent, si nous voulons utiliser la classe User, nous devons instancier la classe Link dans son constructeur car la classe User est dépendante de la classe Link. En d’autres termes, la classe Link est une dépendance de la classe User. Le problème ici est que le processus d'instanciation de la classe Link est étroitement couplé au sein de la classe User.

Le problème est que l'instanciation de la classe Link est limitée et spécifique à la classe User. Si nous voulons transmettre une autre classe au lieu de la classe Link de l'extérieur dans la classe User, nous ne pouvons pas le faire car nous créons explicitement l'instance de la classe Link dans le constructeur et l'attribuons à la propriété Link. C'est ce qu'on appelle une dépendance étroitement couplée, ce qui signifie que nous ne pouvons pas modifier cette dépendance de l'extérieur.

Cependant, si nous n'instancions pas nous-mêmes la classe Link dans le constructeur et la laissons à l'utilisateur, ce qui signifie que lorsqu'un utilisateur utilise notre classe User, il transmettra la dépendance de la classe Link à la classe User, notre problème sera résolu.

Regardons l'exemple de code ci-dessous.

Exemple de code

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

Dans cet exemple, nous pouvons voir qu'au lieu d'instancier la classe Link dans le constructeur de la classe User, nous transmettons la dépendance de la classe Link dans la classe User depuis l'extérieur. Ce processus de transmission de la dépendance dans la classe User via l'utilisateur est appelé injection de dépendance. En d’autres termes, nous injectons ou poussons la dépendance de la classe Link de l’extérieur. C'est ce qu'on appelle une dépendance lâchement couplée, ce qui signifie que nous pouvons facilement modifier cette dépendance de l'extérieur.

Maintenant, si la classe Link a également ses propres dépendances, nous pouvons également y injecter ces dépendances de l'extérieur via la classe User. Ensuite, on peut simplement injecter l’instance de la classe Link dans la classe User. Par conséquent, nous n’avons pas à nous soucier des dépendances de la classe Link au sein de la classe User, car l’utilisateur la gérera de l’extérieur.

Regardons l'exemple de code ci-dessous.

Exemple de code

// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}

De cette façon, on pourra injecter autant de dépendances que l'on veut depuis l'extérieur, et ce sera beaucoup plus flexible. C'est tout pour aujourd'hui ; nous en parlerons dans la prochaine leçon.

Vous pouvez me contacter sur GitHub et Linkedin.

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!