Introduction à la programmation orientée objet

Le terme “POO” signifie programmation orientée objet, c'est-à-dire une façon d'organiser et de structurer le code. La POO nous permet de considérer un programme comme une collection d'objets qui communiquent entre eux, plutôt que comme une séquence de commandes et de fonctions.

Dans la POO, un “objet” est une unité qui contient des données et des fonctions qui opèrent sur ces données. Les objets sont créés sur la base de “classes”, qui peuvent être considérées comme des plans ou des modèles d'objets. Une fois que nous disposons d'une classe, nous pouvons créer son “instance”, qui est un objet spécifique fabriqué à partir de cette classe.

Voyons comment créer une classe simple en PHP. Pour définir une classe, on utilise le mot-clé “class”, suivi du nom de la classe, puis des accolades qui entourent les fonctions de la classe (appelées “méthodes”) et les variables de la classe (appelées “propriétés” ou “attributs”) :

class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}

Dans cet exemple, nous avons créé une classe nommée Car avec une fonction (ou “méthode”) appelée honk.

Chaque classe ne doit résoudre qu'une seule tâche principale. Si une classe fait trop de choses, il peut être judicieux de la diviser en classes plus petites et spécialisées.

Les classes sont généralement stockées dans des fichiers distincts afin que le code reste organisé et facile à parcourir. Le nom du fichier doit correspondre au nom de la classe. Ainsi, pour la classe Car, le nom du fichier sera Car.php.

Pour nommer les classes, il est conseillé de suivre la convention “PascalCase”, ce qui signifie que chaque mot du nom commence par une majuscule et qu'il n'y a pas de soulignement ou d'autres séparateurs. Les méthodes et les propriétés suivent la convention “camelCase”, c'est-à-dire qu'elles commencent par une lettre minuscule.

Certaines méthodes en PHP ont des rôles spéciaux et sont préfixées par __ (deux underscores). L'une des méthodes spéciales les plus importantes est le “constructeur”, désigné par __construct. Le constructeur est une méthode qui est automatiquement appelée lors de la création d'une nouvelle instance d'une classe.

Nous utilisons souvent le constructeur pour définir l'état initial d'un objet. Par exemple, lors de la création d'un objet représentant une personne, vous pouvez utiliser le constructeur pour définir son âge, son nom ou d'autres attributs.

Voyons comment utiliser un constructeur en PHP :

class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

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

$person = new Person(25);
echo $person->howOldAreYou(); // Outputs: 25

Dans cet exemple, la classe Person possède une propriété $age et un constructeur qui définit cette propriété. La méthode howOldAreYou() permet ensuite d'accéder à l'âge de la personne.

Le mot-clé new est utilisé pour créer une nouvelle instance d'une classe. Dans l'exemple ci-dessus, nous avons créé une nouvelle personne âgée de 25 ans.

Vous pouvez également définir des valeurs par défaut pour les paramètres du constructeur s'ils ne sont pas spécifiés lors de la création d'un objet. Par exemple :

class Person
{
	private $age;

	function __construct($age = 20)
	{
		$this->age = $age;
	}

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

$person = new Person;  // if no argument is passed, parentheses can be omitted
echo $person->howOldAreYou(); // Outputs: 20

Dans cet exemple, si vous ne spécifiez pas d'âge lors de la création d'un objet Person, la valeur par défaut de 20 sera utilisée.

Enfin, la définition d'une propriété avec son initialisation via le constructeur peut être raccourcie et simplifiée comme suit :

class Person
{
	function __construct(
		private $age = 20,
	) {
	}
}

Espaces nominatifs

Les espaces de nommage nous permettent d'organiser et de regrouper des classes, des fonctions et des constantes apparentées tout en évitant les conflits de noms. Ils sont comparables aux dossiers d'un ordinateur, où chaque dossier contient des fichiers liés à un projet ou à un sujet spécifique.

Les espaces de noms sont particulièrement utiles dans les grands projets ou lors de l'utilisation de bibliothèques tierces où des conflits de noms de classes peuvent survenir.

Imaginez que vous ayez une classe nommée Car dans votre projet et que vous souhaitiez la placer dans un espace de noms appelé Transport. Voici comment procéder :

namespace Transport;

class Car
{
	function honk()
	{
		echo 'Beep beep!';
	}
}

Si vous souhaitez utiliser la classe Car dans un autre fichier, vous devez spécifier l'espace de noms d'où provient la classe :

$car = new Transport\Car;

Pour simplifier, vous pouvez indiquer au début du fichier quelle classe d'un espace de noms particulier vous souhaitez utiliser, ce qui vous permet de créer des instances sans mentionner le chemin d'accès complet :

use Transport\Car;

$car = new Car;

Héritage

L'héritage est un outil de la programmation orientée objet qui permet de créer de nouvelles classes basées sur des classes existantes, d'hériter de leurs propriétés et de leurs méthodes, et de les étendre ou de les redéfinir si nécessaire. L'héritage garantit la réutilisation du code et la hiérarchie des classes.

En d'autres termes, si nous disposons d'une classe et que nous souhaitons en créer une autre dérivée, mais avec quelques modifications, nous pouvons “hériter” la nouvelle classe de la classe d'origine.

En PHP, l'héritage est mis en œuvre à l'aide du mot-clé extends.

Notre classe Person stocke des informations sur l'âge. Nous pouvons avoir une autre classe, Student, qui étend Person et ajoute des informations sur le domaine d'études.

Prenons un exemple :

class Person
{
	private $age;

	function __construct($age)
	{
		$this->age = $age;
	}

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

class Student extends Person
{
	private $fieldOfStudy;

	function __construct($age, $fieldOfStudy)
	{
		parent::__construct($age);
		$this->fieldOfStudy = $fieldOfStudy;
	}

	function printInformation()
	{
		echo 'Age of student: ', $this->howOldAreYou();
		echo 'Field of study: ', $this->fieldOfStudy;
	}
}

$student = new Student(20, 'Computer Science');
$student->printInformation();

Comment fonctionne ce code ?

• Nous avons utilisé le mot-clé extends pour étendre la classe Person, ce qui signifie que la classe Student hérite de toutes les méthodes et propriétés de Person.
• Le mot-clé parent:: nous permet d'appeler des méthodes de la classe mère. Dans ce cas, nous avons appelé le constructeur de la classe Person avant d'ajouter notre propre fonctionnalité à la classe Student.

L'héritage est destiné aux situations où il existe une relation “est un” entre les classes. Par exemple, un Student est un Person. Un chat est un animal. Il nous permet, dans les cas où nous attendons un objet (par exemple, “Personne”) dans le code, d'utiliser un objet dérivé à la place (par exemple, “Étudiant”).

Il est essentiel de comprendre que l'objectif premier de l'héritage n'est pas d'empêcher la duplication du code. Au contraire, une mauvaise utilisation de l'héritage peut conduire à un code complexe et difficile à maintenir. S'il n'y a pas de relation “is a” entre les classes, nous devrions envisager la composition plutôt que l'héritage.

La composition

La composition est une technique par laquelle, au lieu d'hériter des propriétés et des méthodes d'une autre classe, nous utilisons simplement son instance dans notre classe. Cela nous permet de combiner les fonctionnalités et les propriétés de plusieurs classes sans créer de structures d'héritage complexes.

Par exemple, nous avons une classe Engine et une classe Car. Au lieu de dire “Une voiture est un moteur”, nous disons “Une voiture a un moteur”, ce qui est une relation de composition typique.

class Engine
{
	function start()
	{
		echo "Engine is running.";
	}
}

class Car
{
	private $engine;

	function __construct()
	{
		$this->engine = new Engine;
	}

	function start()
	{
		$this->engine->start();
		echo "The car is ready to drive!";
	}
}

$car = new Car;
$car->start();

Ici, la classe Car ne possède pas toutes les propriétés et méthodes de la classe Engine, mais elle y a accès par l'intermédiaire de la propriété $engine.

L'avantage de la composition est une plus grande souplesse de conception et une meilleure adaptabilité aux changements futurs.

Visibilité

En PHP, vous pouvez définir la “visibilité” des propriétés, méthodes et constantes des classes. La visibilité détermine l'endroit où vous pouvez accéder à ces éléments.

1. Public: Si un élément est marqué comme public, cela signifie que vous pouvez y accéder de n'importe où, même en dehors de la classe.
2. Protégé: Un élément marqué comme protected n'est accessible qu'au sein de la classe et de toutes ses descendantes (classes qui en héritent).
3. Privé: Si un élément est marqué private, il n'est accessible qu'à l'intérieur de la classe dans laquelle il a été défini.

Si vous ne spécifiez pas la visibilité, PHP la définira automatiquement à public.

Voyons un exemple de code :

class VisibilityExample
{
	public $publicProperty = 'Public';
	protected $protectedProperty = 'Protected';
	private $privateProperty = 'Private';

	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		echo $this->privateProperty;    // Works
	}
}

$object = new VisibilityExample;
$object->printProperties();
echo $object->publicProperty;        // Works
// echo $object->protectedProperty;   // Throws an error
// echo $object->privateProperty;     // Throws an error

Poursuite de l'héritage des classes :

class ChildClass extends VisibilityExample
{
	public function printProperties()
	{
		echo $this->publicProperty;     // Works
		echo $this->protectedProperty;  // Works
		// echo $this->privateProperty;   // Throws an error
	}
}

Dans ce cas, la méthode printProperties() de la classe ChildClass peut accéder aux propriétés publiques et protégées, mais ne peut pas accéder aux propriétés privées de la classe mère.

Les données et les méthodes doivent être aussi cachées que possible et accessibles uniquement par l'intermédiaire d'une interface définie. Cela permet de modifier l'implémentation interne de la classe sans affecter le reste du code.

Mot-clé final

En PHP, nous pouvons utiliser le mot-clé final si nous voulons empêcher une classe, une méthode ou une constante d'être héritée ou surchargée. Lorsqu'une classe est marquée comme final, elle ne peut pas être étendue. Lorsqu'une méthode est marquée comme final, elle ne peut pas être remplacée dans une sous-classe.

Le fait de savoir qu'une certaine classe ou méthode ne sera plus modifiée nous permet d'apporter des changements plus facilement sans nous soucier des conflits potentiels. Par exemple, nous pouvons ajouter une nouvelle méthode sans craindre qu'un descendant ait déjà une méthode portant le même nom, ce qui entraînerait une collision. Nous pouvons également modifier les paramètres d'une méthode, toujours sans risquer de provoquer une incohérence avec une méthode surchargée dans un descendant.

final class FinalClass
{
}

// The following code will throw an error because we cannot inherit from a final class.
class ChildOfFinalClass extends FinalClass
{
}

Dans cet exemple, tenter d'hériter de la classe finale FinalClass entraînera une erreur.

Propriétés et méthodes statiques

Lorsque nous parlons d'éléments “statiques” d'une classe en PHP, nous parlons de méthodes et de propriétés qui appartiennent à la classe elle-même, et non à une instance spécifique de la classe. Cela signifie que vous n'avez pas besoin de créer une instance de la classe pour y accéder. Au lieu de cela, vous les appelez ou y accédez directement par l'intermédiaire du nom de la classe.

N'oubliez pas qu'étant donné que les éléments statiques appartiennent à la classe et non à ses instances, vous ne pouvez pas utiliser la pseudo-variable $this à l'intérieur des méthodes statiques.

L'utilisation de propriétés statiques conduit à un code obscurci et plein d'embûches, vous ne devriez donc jamais les utiliser, et nous ne montrerons pas d'exemple ici. En revanche, les méthodes statiques sont utiles. En voici un exemple :

class Calculator
{
	public static function add($a, $b)
	{
		return $a + $b;
	}

	public static function subtract($a, $b)
	{
		return $a - $b;
	}
}

// Using the static method without creating an instance of the class
echo Calculator::add(5, 3); // Output: 8
echo Calculator::subtract(5, 3); // Output: 2

Dans cet exemple, nous avons créé une classe Calculator avec deux méthodes statiques. Nous pouvons appeler ces méthodes directement sans créer une instance de la classe à l'aide de l'opérateur ::. Les méthodes statiques sont particulièrement utiles pour les opérations qui ne dépendent pas de l'état d'une instance de classe spécifique.

Constantes de classe

Au sein des classes, nous avons la possibilité de définir des constantes. Les constantes sont des valeurs qui ne changent jamais pendant l'exécution du programme. Contrairement aux variables, la valeur d'une constante reste inchangée.

class Car
{
	public const NumberOfWheels = 4;

	public function displayNumberOfWheels(): int
	{
		echo self::NumberOfWheels;
	}
}

echo Car::NumberOfWheels;  // Output: 4

Dans cet exemple, nous avons une classe Car avec la constante NumberOfWheels. Lorsque nous accédons à la constante à l'intérieur de la classe, nous pouvons utiliser le mot-clé self au lieu du nom de la classe.

Interfaces d'objets

Les interfaces d'objets agissent comme des “contrats” pour les classes. Si une classe doit implémenter une interface objet, elle doit contenir toutes les méthodes définies par l'interface. C'est un excellent moyen de s'assurer que certaines classes adhèrent au même “contrat” ou à la même structure.

En PHP, les interfaces sont définies à l'aide du mot-clé interface. Toutes les méthodes définies dans une interface sont publiques (public). Lorsqu'une classe implémente une interface, elle utilise le mot-clé implements.

interface Animal
{
	function makeSound();
}

class Cat implements Animal
{
	public function makeSound()
	{
		echo 'Meow';
	}
}

$cat = new Cat;
$cat->makeSound();

Si une classe implémente une interface, mais que toutes les méthodes attendues ne sont pas définies, PHP lèvera une erreur. Une classe peut implémenter plusieurs interfaces à la fois, ce qui est différent de l'héritage, où une classe ne peut hériter que d'une seule classe.

Classes abstraites

Les classes abstraites servent de modèles de base pour d'autres classes, mais vous ne pouvez pas créer leurs instances directement. Elles contiennent un mélange de méthodes complètes et de méthodes abstraites dont le contenu n'est pas défini. Les classes qui héritent de classes abstraites doivent fournir des définitions pour toutes les méthodes abstraites du parent.

Nous utilisons le mot-clé abstract pour définir une classe abstraite.

abstract class AbstractClass
{
	public function regularMethod()
	{
		echo 'This is a regular method';
	}

	abstract public function abstractMethod();
}

class Child extends AbstractClass
{
	public function abstractMethod()
	{
		echo 'This is the implementation of the abstract method';
	}
}

$instance = new Child;
$instance->regularMethod();
$instance->abstractMethod();

Dans cet exemple, nous avons une classe abstraite avec une méthode ordinaire et une méthode abstraite. Nous avons ensuite une classe Child qui hérite de AbstractClass et fournit une implémentation pour la méthode abstraite.

Vérification du type

En programmation, il est crucial de s'assurer que les données avec lesquelles nous travaillons sont du bon type. En PHP, nous avons des outils qui fournissent cette assurance. Vérifier que les données sont du bon type est appelé “vérification de type”.

Les types que nous pouvons rencontrer en PHP :

1. Types de base : Ils comprennent int (entiers), float (nombres à virgule flottante), bool (valeurs booléennes), string (chaînes de caractères), array (tableaux) et null.
2. Classes : Lorsque nous voulons qu'une valeur soit une instance d'une classe spécifique.
3. Interfaces : Définit un ensemble de méthodes qu'une classe doit implémenter. Une valeur qui répond à une interface doit posséder ces méthodes.
4. Types mixtes : Nous pouvons spécifier qu'une variable peut avoir plusieurs types autorisés.
5. Void : Ce type spécial indique qu'une fonction ou une méthode ne renvoie aucune valeur.

Voyons comment modifier le code pour inclure les types :

class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}

	public function printAge(): void
	{
		echo "This person is " . $this->age . " years old.";
	}
}

/**
 * A function that accepts a Person object and prints the person's age.
 */
function printPersonAge(Person $person): void
{
	$person->printAge();
}

De cette manière, nous nous assurons que notre code s'attend à ce que les données soient du bon type et qu'il fonctionne avec elles, ce qui nous permet d'éviter les erreurs potentielles.

Comparaison et identité

En PHP, vous pouvez comparer des objets de deux manières :

1. Comparaison de valeurs ==: Vérifie si les objets sont de la même classe et ont les mêmes valeurs dans leurs propriétés.
2. Comparaison d'identité ===: vérifie s'il s'agit de la même instance de l'objet.

class Car
{
	public string $brand;

	public function __construct(string $brand)
	{
		$this->brand = $brand;
	}
}

$car1 = new Car('Skoda');
$car2 = new Car('Skoda');
$car3 = $car1;

var_dump($car1 == $car2);   // true, because they have the same value
var_dump($car1 === $car2);  // false, because they are not the same instance
var_dump($car1 === $car3);  // true, because $car3 is the same instance as $car1

L'opérateur instanceof

L'opérateur instanceof permet de déterminer si un objet donné est une instance d'une classe spécifique, un descendant de cette classe ou s'il implémente une certaine interface.

Imaginons que nous ayons une classe Person et une autre classe Student, qui est un descendant de Person:

class Person
{
	private int $age;

	public function __construct(int $age)
	{
		$this->age = $age;
	}
}

class Student extends Person
{
	private string $major;

	public function __construct(int $age, string $major)
	{
		parent::__construct($age);
		$this->major = $major;
	}
}

$student = new Student(20, 'Computer Science');

// Check if $student is an instance of the Student class
var_dump($student instanceof Student);  // Output: bool(true)

// Check if $student is an instance of the Person class (because Student is a descendant of Person)
var_dump($student instanceof Person);   // Output: bool(true)

D'après les résultats, il est évident que l'objet $student est considéré comme une instance des classes Student et Person.

Interfaces fluides

Une “interface fluide” est une technique de la POO qui permet d'enchaîner des méthodes en un seul appel. Cela permet souvent de simplifier et de clarifier le code.

L'élément clé d'une interface fluide est que chaque méthode de la chaîne renvoie une référence à l'objet actuel. Pour ce faire, on utilise return $this; à la fin de la méthode. Ce style de programmation est souvent associé à des méthodes appelées “setters”, qui fixent les valeurs des propriétés d'un objet.

Voyons à quoi pourrait ressembler une interface fluide pour l'envoi de courriers électroniques :

public function sendMessage()
{
	$email = new Email;
	$email->setFrom('sender@example.com')
		  ->setRecipient('admin@example.com')
		  ->setMessage('Hello, this is a message.')
		  ->send();
}

Dans cet exemple, les méthodes setFrom(), setRecipient(), et setMessage() sont utilisées pour définir les valeurs correspondantes (expéditeur, destinataire, contenu du message). Après avoir défini chacune de ces valeurs, les méthodes renvoient l'objet courant ($email), ce qui nous permet d'enchaîner une autre méthode après celle-ci. Enfin, nous appelons la méthode send(), qui envoie effectivement le courrier électronique.

Grâce aux interfaces fluides, nous pouvons écrire un code intuitif et facilement lisible.

Copier avec clone

En PHP, nous pouvons créer une copie d'un objet en utilisant l'opérateur clone. De cette manière, nous obtenons une nouvelle instance avec un contenu identique.

Si nous devons modifier certaines propriétés lors de la copie d'un objet, nous pouvons définir une méthode spéciale __clone() dans la classe. Cette méthode est automatiquement appelée lorsque l'objet est cloné.

class Sheep
{
	public string $name;

	public function __construct(string $name)
	{
		$this->name = $name;
	}

	public function __clone()
	{
		$this->name = 'Clone of ' . $this->name;
	}
}

$original = new Sheep('Dolly');
echo $original->name . "\n";  // Outputs: Dolly

$clone = clone $original;
echo $clone->name . "\n";     // Outputs: Clone of Dolly

Dans cet exemple, nous avons une classe Sheep avec une propriété $name. Lorsque nous clonons une instance de cette classe, la méthode __clone() veille à ce que le nom du mouton cloné reçoive le préfixe “Clone de”.

Traits

Les traits en PHP sont un outil qui permet de partager des méthodes, des propriétés et des constantes entre les classes et d'éviter la duplication du code. Vous pouvez les considérer comme un mécanisme de “copier-coller” (Ctrl-C et Ctrl-V), où le contenu d'un trait est “collé” dans les classes. Cela vous permet de réutiliser le code sans avoir à créer des hiérarchies de classes compliquées.

Voyons un exemple simple d'utilisation des traits en PHP :

trait Honking
{
	public function honk()
	{
		echo 'Beep beep!';
	}
}

class Car
{
	use Honking;
}

class Truck
{
	use Honking;
}

$car = new Car;
$car->honk(); // Outputs 'Beep beep!'

$truck = new Truck;
$truck->honk(); // Also outputs 'Beep beep!'

Dans cet exemple, nous avons un trait nommé Honking qui contient une méthode honk(). Nous avons ensuite deux classes : Car et Truck, qui utilisent toutes deux le trait Honking. Par conséquent, les deux classes “possèdent” la méthode honk() et nous pouvons l'appeler sur des objets des deux classes.

Les traits vous permettent de partager facilement et efficacement le code entre les classes. Ils n'entrent pas dans la hiérarchie de l'héritage, c'est-à-dire que $car instanceof Honking renverra false.

Exceptions

Les exceptions en POO nous permettent de traiter et de gérer les erreurs qui peuvent survenir au cours de l'exécution de notre code. Il s'agit essentiellement d'objets conçus pour enregistrer les erreurs ou les situations inattendues dans votre programme.

En PHP, nous disposons de la classe intégrée Exception pour ces objets. Elle possède plusieurs méthodes qui nous permettent d'obtenir plus d'informations sur l'exception, comme le message d'erreur, le fichier et la ligne où l'erreur s'est produite, etc.

Lorsqu'un problème survient, nous pouvons “lancer” une exception (en utilisant throw). Si nous voulons “attraper” et traiter cette exception, nous utilisons les blocs try et catch.

Voyons comment cela fonctionne :

try {
	throw new Exception('Message explaining the reason for the exception');

	// This code won't execute
	echo 'I am a message that nobody will read';

} catch (Exception $e) {
	echo 'Exception caught: '. $e->getMessage();
}

Il est important de noter qu'une exception peut être levée plus profondément, lors de l'appel à d'autres méthodes.

Pour un bloc try, plusieurs blocs catch peuvent être spécifiés si vous vous attendez à différents types d'exceptions.

Nous pouvons également créer une hiérarchie d'exceptions, où chaque classe d'exception hérite de la précédente. Prenons l'exemple d'une application bancaire simple qui autorise les dépôts et les retraits :

class BankingException extends Exception {}
class InsufficientFundsException extends BankingException {}
class ExceededLimitException extends BankingException {}

class BankAccount
{
	private int $balance = 0;
	private int $dailyLimit = 1000;

	public function deposit(int $amount): int
	{
		$this->balance += $amount;
		return $this->balance;
	}

	public function withdraw(int $amount): int
	{
		if ($amount > $this->balance) {
			throw new InsufficientFundsException('Not enough funds in the account.');
		}

		if ($amount > $this->dailyLimit) {
			throw new ExceededLimitException('Daily withdrawal limit exceeded.');
		}

		$this->balance -= $amount;
		return $this->balance;
	}
}

$account = new BankAccount;
$account->deposit(500);

try {
	$account->withdraw(1500);
} catch (ExceededLimitException $e) {
	echo $e->getMessage();
} catch (InsufficientFundsException $e) {
	echo $e->getMessage();
} catch (BankingException $e) {
	echo 'An error occurred during the operation.';
}

Dans cet exemple, il est important de noter l'ordre des blocs catch. Étant donné que toutes les exceptions héritent de BankingException, si nous avions ce bloc en premier, toutes les exceptions seraient capturées dans ce bloc sans que le code n'atteigne les blocs catch suivants. Par conséquent, il est important que les exceptions plus spécifiques (c'est-à-dire celles qui héritent d'autres exceptions) soient placées plus haut dans l'ordre du bloc catch que leurs exceptions parentales.

Meilleures pratiques

Une fois que vous avez assimilé les principes de base de la programmation orientée objet, il est essentiel de vous concentrer sur les meilleures pratiques de la POO. Celles-ci vous aideront à écrire un code non seulement fonctionnel, mais aussi lisible, compréhensible et facile à maintenir.

1. Séparation des préoccupations : Chaque classe doit avoir une responsabilité clairement définie et ne doit s'occuper que d'une seule tâche principale. Si une classe fait trop de choses, il peut être judicieux de la diviser en classes spécialisées plus petites.
2. Encapsulation : Les données et les méthodes doivent être aussi cachées que possible et accessibles uniquement par l'intermédiaire d'une interface définie. Cela permet de modifier l'implémentation interne d'une classe sans affecter le reste du code.
3. Injection de dépendances : Au lieu de créer des dépendances directement dans une classe, vous devriez les “injecter” depuis l'extérieur. Pour une compréhension plus approfondie de ce principe, nous recommandons les chapitres sur l'injection de dépendances.