Quels sont les quatre piliers de la POO ?

Question

Accepted Answer

La programmation orientée objet repose sur quatre principes fondamentaux — **Encapsulation, Héritage, Polymorphisme et Abstraction**. Java est construit autour de ces principes, et les comprendre est essentiel pour concevoir des programmes Java.

## 1. Encapsulation — regrouper les données + masquer les détails internes

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

L'encapsulation masque l'état interne (`private`) et expose un accès contrôlé (méthodes publiques/getters/setters). Cela protège les invariants — vous ne pouvez pas définir directement un solde négatif — et vous permet de modifier les détails internes sans casser les appelants.

## 2. Héritage — réutilisation via une relation « est-un »

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — inherits eat()
    void bark() { System.out.println("woof"); }
}
```

L'héritage permet à une sous-classe de réutiliser et d'étendre le comportement d'une superclasse, en modélisant des relations « est-un » et en évitant la duplication de code.

## 3. Polymorphisme — une interface, plusieurs formes

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

Le polymorphisme vous permet de traiter différentes sous-classes uniformément via un type commun, la méthode surchargée de l'objet **réel** étant appelée à l'exécution — ce qui permet un code flexible et extensible.

## 4. Abstraction — exposer quoi, masquer comment

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

L'abstraction (via interfaces/classes abstraites) expose un contrat simplifié tout en cachant l'implémentation complexe — ce qui vous permet d'échanger les implémentations et de réduire le couplage.

## Pourquoi c'est important

Les quatre piliers sont la fondation de la conception orientée objet et de Java lui-même.

L'encapsulation protège l'intégrité des données et permet des modifications en toute sécurité ; l'héritage favorise la réutilisation ; le polymorphisme offre flexibilité et extensibilité (traiter plusieurs types uniformément, comportement résolu à l'exécution) ; l'abstraction réduit le couplage et la complexité.

Comprendre ces concepts n'est pas une simple terminologie — ils guident la façon dont vous structurez les classes, concevez les API et construisez des systèmes maintenables et extensibles.

Ce sont aussi des sujets d'entretien très courants parce qu'ils révèlent si un développeur pense en termes appropriés de POO, ce qui est essentiel pour travailler efficacement dans l'écosystème centré sur les classes de Java.