decorateur

Adaptateur (Adapter ou Wrapper)

Le Design Pattern Adaptateur peut avoir deux formes :

Adaptateur avec héritage :

Adaptateur avec composition :

LIEN VERS LE DICTIONNAIRE DES DEVELOPPEURS :


AUTRE RESSOURCE SUR DEVELOPPEZ.COM :


OBJECTIFS :

  • Convertir l'interface d'une classe dans une autre interface comprise par la partie cliente.
  • Permettre à des classes de fonctionner ensemble, ce qui n'aurait pas été possible sinon (à cause de leurs interfaces incompatibles).
RAISONS DE L'UTILISER :

Le système doit intégrer un sous-système existant. Ce sous-système a une interface non standard par rapport au système.

Cela peut être le cas d'un driver bas niveau pour de l'informatique embarquée. Le driver fournit par le fabricant ne correspond pas à l'interface utilisée par le système pour d'autres drivers.

La solution est de masquer cette interface non stantard au système et de lui présenter une interface standard. La partie cliente utilise les méthodes de l'Adaptateur qui utilise les méthodes du sous-système pour réaliser les opérations correspondantes.

RESULTAT :

Le Design Pattern permet d'isoler l'adaptation d'un sous-système.

RESPONSABILITES :

  • Standard : définit une interface qui est identifiée comme standard dans la partie cliente.
  • ImplStandard : implémente l'interface Standard. Cette classe n'a pas besoin d'être adaptée.
  • ImplAdapte : permet de réaliser les fonctionnalités définies dans l'interface Standard, mais ne la respecte pas. Cette classe a besoin d'être adaptée.
  • Adaptateur : adapte l'implémentation ImplAdapte à l'interface Standard. Pour réaliser l'adaptation, l'Adaptateur peut utiliser une ou plusieurs méthodes différentes de l'implémentationImplAdapte pour réaliser l'implémentation de chaque méthode de l'interface Standard.
  • La partie cliente manipule des objets Standard. Donc, l'adaptation est transparente pour la partie cliente.
IMPLEMENTATION JAVA :
Standard.java
/**
 * Définit une interface qui est identifiée 
 * comme standard dans la partie cliente. 
 */
public interface Standard {

    /**
     * L'opération doit multiplier les deux nombres,
     * puis afficher le résultat de l'opération
     */
    public void operation(int pNombre1, int pNombre2);
}
ImplStandard.java
/**
 * Implémente l'interface "Standard".
 */
public class ImplStandard implements Standard {

    public void operation(int pNombre1, int pNombre2) {
        System.out.println("Standard : Le nombre est : " + (pNombre1 * pNombre2));
    }
}
ImplAdapte.java
/**
 * Fournit les fonctionnalités définies dans l'interface "Standard",
 * mais ne respecte pas l'interface.
 */
public class ImplAdapte {

    public int operationAdapte1(int pNombre1, int pNombre2) {
        return pNombre1 * pNombre2;
    }
    
    /**
     * Apporte la fonctionalité définie dans l'interface,
     * mais la méthode n'a pas le bon nom 
     * et n'accepte pas le même paramètre.
     */
    public void operationAdapte2(int pNombre) {
        System.out.println("Adapte : Le nombre est : " + pNombre);
    }
}
Adaptateur.java (avec héritage)
/**
 * Adapte l'implémentation non standard avec l'héritage.
 */
public class Adaptateur extends ImplAdapte implements Standard {

    /**
     * Appelle les méthodes non standard 
     * depuis une méthode respectant l'interface. 
     * 1°) Appel de la méthode réalisant la multiplication
     * 2°) Appel de la méthode d'affichage du résultat
     * La classe adaptée est héritée, donc on appelle directement les méthodes
     */
    public void operation(int pNombre1, int pNombre2) {
        int lNombre = operationAdapte1(pNombre1, pNombre2);
        operationAdapte2(lNombre);
    }
}
Adaptateur.java (avec composition)
/**
 * Adapte l'implémentation non standard avec la composition.
 */
public class Adaptateur implements Standard {

    private ImplAdapte adapte = new ImplAdapte();
    
    /**
     * Appelle les méthodes non standard
     * depuis une méthode respectant l'interface. 
     * 1°) Appel de la méthode réalisant la multiplication
     * 2°) Appel de la méthode d'affichage du résultat
     * La classe adaptée compose l'adaptation, 
     * donc on appelle les méthodes de "ImplAdapte".
     */
    public void operation(int pNombre1, int pNombre2) {
        int lNombre = adapte.operationAdapte1(pNombre1, pNombre2);
        adapte.operationAdapte2(lNombre);
    }
}
AdaptatorPatternMain.java
public class AdaptatorPatternMain {

    public static void main(String[] args) {
        // Création d'un adaptateur
        final Standard lImplAdapte = new Adaptateur();
        // Création d'une implémentation standard
        final Standard lImplStandard = new ImplStandard();

        // Appel de la même méthode sur chaque instance
        lImplAdapte.operation(2, 4);
        lImplStandard.operation(2, 4);
        
        // Affichage : 
        // Adapte : Le nombre est : 8
        // Standard : Le nombre est : 8
    }
}

Comments