Quels modèles de conception, en plus de Singleton…

Méthode de Fabrique. Utilisée pour créer des objets sans spécifier explicitement le type de classe. Utile lorsque la logique de création dépend des sous-classes.
Fournisseur Abstrait. Employé pour créer des familles d'objets liés ou dépendants, en fournissant une interface pour cela, mais sans spécifier de classes concrètes.
Builder. Utilisé pour créer étape par étape des objets complexes, où l'ordre et la combinaison des étapes peuvent varier. Permet d'éviter le "constructeur télescopique".
Observer. Implémenté pour créer des dépendances "un à plusieurs" entre objets, où une modification de l'état d'un objet notifie automatiquement tous les objets dépendants.
Strategy. Appliqué pour définir une famille d'algorithmes, en encapsulant chacun d'eux et en assurant leur interchangeabilité. Permet de choisir l'algorithme au moment de l'exécution.
Decorator. Utilisé pour ajouter dynamiquement de nouvelles responsabilités aux objets sans modifier leur structure.
Proxy. Employé lorsque le contrôle d'accès à un objet est nécessaire, par exemple pour le chargement paresseux ou l'accès distant.
Template Method. Utilisé pour définir la structure d'un algorithme dans la superclasse, permettant aux sous-classes de redéfinir certains pas de l'algorithme sans changer la structure principale.
Adapter. Appliqué pour transformer l'interface d'une classe en l'interface attendue par les clients. Permet à des classes avec des interfaces incompatibles de fonctionner ensemble.
Command. Utilisé pour encapsuler une requête sous forme d'objet, permettant de paramétrer des clients avec différentes requêtes, de mettre des requêtes en file d'attente ou de tenir un journal des opérations, ainsi que de supporter l'annulation d'opérations.

Exemple d'implémentation de la Factory Method :

// Interface du produit
interface Product {
    void doSomething();
}

// Produits concrets
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Fait quelque chose dans Product A");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Fait quelque chose dans Product B");
    }
}

// Interface de la fabrique
abstract class Creator {
    public abstract Product factoryMethod();

    public void someOperation() {
        Product product = factoryMethod();
        product.doSomething();
    }
}

// Fábricas concretas
class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

Quels modèles de conception, en plus de Singleton, avez-vous utilisés?