/** Interface de description d'un point */
public interface Point {
 /** Retourne l'abscisse du point */ 
 public int getX();
 /** Retourne l'ordonnée du point */ 
 public int getY();
}

/** Interface de description d'une ligne */
public interface Line {
  /** Retourne les coordonnées du mier point */
  public int getX1();
  public int getY1();
  /** Retourne les coordonnées du deuxième point */
  public int getX2();
  public int getY2();
}

/**  Fabrique  retournant des objets de types point ou ligne */
public class CanvasFactory {
  /** Retourne un Point aux coordonnées x,y */ 
  public Point getPoint( int x, int y ) {
   return new PointImpl( x, y );
  }
  /** Retourne une Ligne aux coordonnées x1,y1,x2,y2 */ 
  public Line getLine( int x1, int y1, int x2, int y2 ) {
   return new LineImpl( x1, y1, x2, y2 );
 } 
}

public CanvasFactory {
  /** Donnée de classe contenant l'instance courante */
  private static CanvasFactory instance = new CanvasFactory();

  /** Constructeur privé interdisant l'instanciation en dehors de cette classe */
  private CanvasFactory () {}
  /** Singleton de la classe courante */ 
  public static CanvasFactory getInstance() { return instance; }
  ...
}

CanvasFactory cf = CanvasFactory.getInstance();

/** Builder pour les objets Canvas */
public CanvasBuilder {
   /** Initialise le canvas */ 
   public void initCanvas( Canvas c ) { ... }
   /** Ajouter un point aux coordonnées x,y */
   public void addPoint( int x, y ) { ... }
   /** Ajouter une ligne aux coordonnées x1,y1,x2,y2 */
   public void addLine( int x1, int y1, int x2, int y2 ) { ... }
}

//Instanciation du Builder
CanvasBuilder cb = new CanvasBuilder();
Canvas c = new CanvasImpl();
//Montage du Canvas
cb.initCanvas( c );
cv.addPoint( 5, 5 );
cv.addLine(  0, 0 );
cv.addLine( 10,0 );
cv.addLine( 10, 10);
...

/** Interface de représentation d'un cercle */
public interface Circle {
  /** Retourne l'abscisse du centre du cercle */
  public int getX();
  /** Retourne l'ordonnée du centre du cercle */
  public int getY();
  /** Retourne le rayon du cercle */
  public int getR();
}

/** Classe implémentant l'interface Circle */
public class CircleImpl implements Circle {
  ...
}

/** Adapteur pour transformer le circle en un point */
public class CircleImplPointAdapter implements Point {
  private Circle c;
  public CircleImplPointAdapter( Circle c ) {
   this.c = c;
  } 
  public int getX() { return c.getX(); }
  public int getY() { return c.getY(); }
}

/** Interface représentant un espace de dessin */
public interface Canvas {
  /** Ajout d'un objet graphique */
  public void addGraphicElement( GraphicElement ge );
}

/**  Proxy pour l'espace de dessin */
public class CanvasProxy implements Canvas {
  private Canvas c;
  public CanvasProxy( Canvas c ) {
   this.c = c;
  }
  public void addGraphicElement( GraphicElement ge ) {
   c.addGraphicElement( ge );
  }
}

/** Implémentation de l'interface Canvas composite */
public class CanvasImpl implements GraphicElement, Canvas {
/** Ajout d'un élément graphique ou d'un Canvas ! */
public void addGraphicElement( GraphicElement ge ) { ... }

/** Classe de gestion d'un espace de dessin */
public class CanvasImpl implements GraphicsElement, Canvas {
  // Tableau pour stoker les éléments de la collection 
  private GraphicsElement[] ge;
  ...
  /** Retourne un itérateur pour accéder aux objets de la collection */
  public Iterator getIterator() { return ArrayIterator( ge ); }
}

/** Interface pour toutes les collections d'objets de GraphicElement */
public interface Iterator {
   public GraphicElement getNextElement();
}

/** Iterateur parcourant un tableau pour retourner des objets de type GraphicElement */
public class ArrayIterator implements Iterator {
  private GraphicElement[] ge;
  private int nge;
  /** Constructeur avec un tableau de données à parcourir */
  public ArrayIterator( GraphicElement[] ge ) {
   this.ge = ge;
   nge = 0;
  }
  /** Retourne chaque élément de la collection ou null */
  public GraphicElement getNextElement() {
   if ( nge >= ge.length ) return null;
   return ge[ nge++ ];
  }
}

/** Template d'extraction d'éléments d'une collection selon différents critères */
public abstract class GraphicElementSorter {
   /** Iterateur d'une collection d'objet GraphicElement */
   public GraphicElementSorter( Iterator t ) {
    ...
   }

  /** Retourne l'objet le plus grand de la collection passé dans le constructeur */
  public GraphicElement getMaxGraphicElement() { 
    GraphicElement refGe = t.getNextElement();
    for ( GraphicElement ge = t.getNextElement(); ge != null; ) {
      if ( isGreaterThan( ge, refGe ) ) then refGe = ge;
    }
   return refGe;
  }
  /** Méthode à surcharger retournant l'objet graphique le plus grand entre ge1 et ge2 */
  protected abstract GraphicElement isGreaterThan( GraphicElement ge1, GraphicElement ge2 );
}

/** Cette classe désigne la méthode pour comparer la taille de deux objets */
public class SimpleGraphicElementSorter {
   /** Cette méthode compare deux objets ayant chacun une méthode size retournant la surface */
   public GraphicElement isGreaterThan( GraphicElement ge1, GraphicElement ge2 ) {
    if ( ge1.size() > ge2.size() return ge1; else return ge2;
   }
}