« Bonjour, Amigo ! Aujourd'hui, je vais te dire exactement ce qu'un est adaptateur'. J'espère qu'après avoir découvert ce sujet, tu auras une meilleure compréhension des flux d'entrée/sortie. »

Adaptateurs - 1

Imagine que ton programme utilise deux frameworks écrits par d'autres programmeurs/entreprises. Les deux sont très bons et appliquent les principes de la POO : abstraction, polymorphisme, encapsulation. Ensemble, ils couvrent presque entièrement ce que ton programme a besoin de faire. Il ne te reste qu'une tâche simple. Tu dois passer les objets créés par un framework à l'autre. Mais les deux frameworks sont complètement différents et « ne se connaissent pas entre eux » : ils n'ont aucune classe en commun. Tu dois te débrouiller pour convertir les objets d'un framework en objets de l'autre.

Cette tâche peut être élégamment accomplie en appliquant la technique (modèle de conception) appelée « adaptateur » :

Code Java Description 
class MyClass implements Interface2
{
 private Interface1 object;
 MyClass(Interface1 object)
 {
  this.object = object;
 }
// C'est ici que nous plaçons les méthodes d'Interface2 
// qui appellent des méthodes d'Interface1
}
 Cela reflète le modèle de conception d'adaptateur.

Pour faire simple, l'idée est que MyClass convertit (adapte) une interface en l'autre.

« Tu pourrais me donner un exemple plus spécifique ? »

« Très bien. Disons que chaque framework a sa propre interface de 'liste' unique. Ça pourrait ressembler à ceci : »

Code Java Description 
interface AlphaList
{
 void add(int value);
 void insert(int index, int value);
 int get(int index);
 void set(int index, int value);
 int count();
 void remove(int index);
}
 Code du premier framework (Alpha)

AlphaList est une des interfaces qui permet au code du framework d'interagir avec le code qui utilise le framework.

 
class AlphaListManager
{
 public static AlphaList createList()
 {
  //du code pour créer un objet
 }
}
 AlphaListManager AlphaListManager est une classe dans le framework. Sa méthode createList crée un objet AlphaList 
interface BetaList
{
 int getValue(int index);
 void setValue(int index, int value);
 int getSize();
 void setSize(int newSize);
}
class BetaSaveManager
{
 public static void saveList(BetaList list)
 {
  //du code pour enregistrer un objet BetaList
  //dans un fichier sur le disque
 }
}
 Code du second framework (Beta).

BetaList est une des interfaces qui permet au code du framework d'interagir avec le code qui utilise le framework.

BetaSaveManager est une classe dans le framework. Sa méthode saveList enregistre un objet BetaList

 
class ListAdapter implements BetaList
{
 private AlphaList list;
 ListAdapter(AlphaList list)
 {
  this.list = list;
 }

 int getValue(int index)
 {
  return this.list.get(index);
 }

 void setValue(int index, int value)
 {
  this.list.set(index, value);
 }

 int getSize()
 {
  return this.list.count();
 }

 void setSize(int newSize)
 {
  if (newSize > this.list.count()
  {
   while (this.list.count() < newSize)
  {
   this.list.add(null);
  }
 }
 else if (newSize < this.list.count() {
   while (this.list.count() > newSize)
   {
    list.remove(list.count() - 1);
   }
  }
 }
}
 La classe 'adaptateur' qui convertit l'interface AlphaList en interface BetaList

La classe ListAdapter implémente l'interface BetaList du second framework.

Quand quelqu'un appelle ces méthodes, le code de la classe 'transmet' les appels à la variable list, qui est une AlphaList du premier framework.

Un objet AlphaList est passé au constructeur ListAdapter

La méthode setSize fonctionne selon les règles suivantes : si la taille de la liste doit être augmentée, ajouter des éléments vides (null). Si la taille de la liste doit être réduite, supprimer les éléments à la fin.

 
public static void main(String[] args)
{
 AlphaList listAlpha = AlphaListManager.createList();
 BetaList listBeta = new ListAdapter(listAlpha);
 BetaSaveManager.saveList(listBeta);
}
 Un exemple d'utilisation possible

« J'ai vraiment aimé ton dernier exemple en particulier. Très concis et clair. »