Exemple

Considérons la fonction suivante qui calcule le minimum de deux entiers :

  static int min(int x, int y) {
    return x<=y ? x : y;
  }

On souhaite la généraliser, afin de pouvoir calculer aussi bien le minimum de deux objets. Ceci n'a de sens que si ces deux objets sont comparables, par exemple, on peut comparer deux points selon l'axe des X ou bien selon l'axe des Y. Pour généraliser cette fonction aux points, on remplace dans la définition précédente, int par Point, et on ajoute un troisième paramètre spécifiant la relation d'ordre utilisée, de sorte que l'on puisse écrire :

   Point 
     p = new Point(2, 3),
     q = new Point(3, 2);
   Point 
     m1 = min(p, q, ordreX),   // m1 == p
     m2 = min(p, q, ordreY);   // m2 == q

Ici, ordreX et ordreY sont des arguments fonctionnels, qui spécifient que :

• 231#231 est plus petit que 232#232 selon ordreX si 233#233 ou si 234#234 et 235#235 ;
• 231#231 est plus petit que 232#232 selon ordreY si 235#235 ou si 236#236 et 233#233.

La programmation dans un langage à objets prend le parti de tout représenter à l'aide de la notion d'objet : ordreX et ordreY sont donc des références à des objets « comparateurs de points ». Leur type est une interface, qui déclare une méthode de comparaison de points :

   interface ComparateurDePoints {
     boolean inférieurÀ(Point p1, Point p2);
   }

Il y a autant de comparateurs que de réalisations de cette interface. En voici deux :

   class OrdreX implements ComparateurDePoints {
     public boolean inférieurÀ(Point p1, Point p2) {
       return 
         p1.x < p2.x || 
         p1.x == p2.x && p1.y < p2.y;
   }

   class OrdreY implements ComparateurDePoints {
     public boolean inférieurÀ(Point p1, Point p2) {
       return 
         p1.y < p2.y || 
         p1.y == p2.y && p1.x < p2.x;
   }

Il est nécessaire d'instancier ces classes pour pouvoir invoquer les relations de comparaison :

   ComparateurDePoints
     ordreX = new OrdreX(),
     ordreY = new OrdreY();
   Point 
     p = new Point(2, 3),
     q = new Point(3, 2);
   Point 
     m1 = min(p, q, ordreX),   // m1 == p
     m2 = min(p, q, ordreY);   // m2 == q

Il reste à définir cette fonction générale min :

  static Point min(Point x, Point y, ComparateurDePoints ordre) {
    return ordre.inférieurÀ(x, y) ? x : y;
  }

Cette fonction permet de calculer le minimum de deux points selon une relation d'ordre passée en paramètre, mais elle ne s'applique qu'à des points.