Quels sont les motifs de conception courants en Java ?

Question

Accepted Answer

**Les motifs de conception** sont des solutions réutilisables à des problèmes récurrents de conception logicielle. La nature OOP de Java et son écosystème rendent plusieurs motifs particulièrement courants — les connaître vous aide à les reconnaître, à en discuter et à appliquer des structures éprouvées. Ils se divisent en catégories créationnelles, structurelles et comportementales.

## Singleton (créationnel) — une instance partagée

```java
public class Config {
    private static final Config INSTANCE = new Config();   // the single instance
    private Config() {}                                     // private constructor
    public static Config getInstance() { return INSTANCE; }
}
// (enum singletons are an even safer idiom). Used for shared config, connection pools.
```

## Factory (créationnel) — encapsuler la création d'objets

```java
public static Shape createShape(String type) {
    return switch (type) {                 // hides the concrete class from the caller
        case "circle" -> new Circle();
        case "square" -> new Square();
        default -> throw new IllegalArgumentException();
    };
}
// caller depends on Shape, not concrete classes — decoupling.
```

## Builder (créationnel) — construire des objets complexes étape par étape

```java
User user = new User.Builder()
    .name("Ann")
    .email("ann@x.com")
    .age(30)
    .build();    // readable construction; avoids huge telescoping constructors
```

## Strategy (comportemental) — algorithmes interchangeables

```java
interface PaymentStrategy { void pay(double amount); }
class CreditCard implements PaymentStrategy { public void pay(double a) {...} }
class PayPal implements PaymentStrategy { public void pay(double a) {...} }

// swap behavior at runtime — lambdas make this trivial in modern Java
processor.setStrategy(new PayPal());
```

## Observer (comportemental) — publication/souscription

```java
// subjects notify registered observers of changes (events, listeners)
button.addActionListener(e -> handleClick());   // GUI events use this everywhere
```

## Decorator (structurel) — envelopper pour ajouter un comportement

```java
// Java's I/O streams ARE the decorator pattern:
BufferedReader r = new BufferedReader(new FileReader("f.txt"));
// BufferedReader wraps FileReader, adding buffering
```

## Où les motifs apparaissent dans Java lui-même

```text
Singleton  → Runtime.getRuntime()
Factory    → Calendar.getInstance(), DriverManager
Builder    → StringBuilder, Stream.Builder
Observer   → event listeners, java.util.Observer
Decorator  → java.io streams (BufferedReader wrapping FileReader)
Iterator   → the Iterator interface / Collections
Strategy   → Comparator, functional interfaces
```

## Une mise en garde contre l'excès

```text
Patterns are tools, not goals. Applying them where they don't fit ADDS complexity.
Use them when they genuinely solve your problem — many can be simpler with lambdas now.
```

## Pourquoi c'est important

Les motifs de conception fournissent un vocabulaire partagé et des solutions éprouvées aux problèmes de conception courants, ce qui est précieux pour la communication (« utilise une Strategy ici »), la reconnaissance de structures dans le code existant et l'évitement de réinventer des solutions défectueuses.

Ils apparaissent dans les propres bibliothèques de Java (décorateurs I/O, factory methods, builders, événements basés sur observer), donc comprendre ces motifs vous aide à utiliser et étendre la bibliothèque standard efficacement.

Connaître les motifs majeurs — Singleton, Factory, Builder, Strategy, Observer, Decorator — et savoir où chacun s'applique est une caractéristique des développeurs expérimentés et un sujet fréquent d'entretien.

Tout aussi important est le jugement d'appliquer ces motifs de manière appropriée (résoudre de vrais problèmes) plutôt que de les forcer, surtout que les fonctionnalités modernes comme les lambdas simplifient de nombreux motifs classiques.