Il serait bon que nous puissions écrire une méthode de tri unique qui pourrait trier les éléments dans un tableau entier, de chaînes ou un tableau de tout type compatible avec le trie.

Les méthodes génériques et les classes génériques permettent aux programmeurs de spécifier, avec une seule déclaration de méthode, un ensemble de méthodes connexes ou, avec une déclaration de classe unique, un ensemble de types liés, respectivement.

Les génériques fournissent également une sécurité de type temps de compilation qui permet aux programmeurs de capturer des types invalides au moment de la compilation.

En utilisant le concept Generique, nous pouvons écrire une méthode générique pour trier un ensemble d'objets, puis invoquer la méthode générique avec des tableaux en entier, des tableaux doubles, des tableaux de chaînes et ainsi de suite pour trier les éléments du tableau.

Les méthodes génériques

Vous pouvez écrire une seule déclaration de méthode générique qui peut être appelée avec des arguments de différents types. Sur la base des types d'arguments passés à la méthode générique, le compilateur gère chaque appel de méthode de manière appropriée. Voici les règles pour définir les méthodes génériques:

• Toutes les déclarations de méthode générique ont une section de paramètre de type délimitée par des crochets (<and>) qui précèdent le type de retour de la méthode (< E> dans l'exemple suivant).
• Chaque section de paramètre de type contient un ou plusieurs paramètres de type séparés par des virgules. Un paramètre de type, également connu comme une variable de type, est un identifiant qui spécifie un nom de type générique.
• Les paramètres de type peuvent être utilisés pour déclarer le type de retour et agir comme espaces réservés pour les types d'arguments passés à la méthode générique, connus sous le nom d'arguments de type réel.
• Le corps d'une méthode générique est déclaré comme celui de toute autre méthode. Notez que les paramètres de type ne peuvent représenter que des types de référence, pas des types primitifs (comme int, double et char).

Exemple:

L'exemple suivant illustre comment on peut afficher un tableau de types différents en utilisant une seule méthode Générique:

 public class GenericMethodTest
  {
   //generic method printArray                       
   public static <E> void printArray(E[] inputArray)
   {
      //Display array elements            
         for (E element : inputArray ){      
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }



    public static void main( String args[] )
    {
        //Create arrays of Integer, Double and Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
        System.out.println( "Array integerArray contains:" );
        printArray( intArray  ); // pass an Integer array
        System.out.println( "\nArray doubleArray contains:" );
        printArray( doubleArray ); // pass a Double array
        System.out.println( "\nArray characterArray contains:" );
        printArray( charArray ); // pass a Character array
    }
}

Cela produirait le résultat suivant:

Array integerArray contains:

1 2 3 4 5 6

 

Array doubleArray contains:

1.1 2.2 3.3 4.4

 

Array characterArray contains:

H E L L O

Paramètres de type délimité

Il peut y avoir des moments où vous voudrez restreindre les types de types autorisés à passer à un paramètre de type. Par exemple, une méthode qui fonctionne sur des nombres ne peut que vouloir accepter des instances de nombre ou de ses sous-classes. C'est pour cela que se situent les paramètres de type délimité.

Pour déclarer un paramètre de type délimité, énumérez le nom du paramètre de type, suivi du mot clé extends, suivi de sa limite supérieure.

Exemple:

L'exemple suivant illustre comment l'extension est utilisée dans un sens général pour signifier soit "étendre" (comme dans les classes) ou "impléments" (comme dans les interfaces). Cet exemple est une méthode générique pour renvoyer le plus grand des trois objets comparables:

public class MaximumTest
{
   //determines the largest of three Comparable objects
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                    
      T max = x; // assume x is initially the largest     
      if ( y.compareTo( max ) > 0 ){
         max = y; // y is the largest so far
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // z is the largest now                
      }
      return max; //returns the largest object 
   }

   public static void main( String args[] )

   {
      System.out.printf( "Max of %d, %d and %d is %d\n\n", 3, 4, 5, maximum( 3, 4, 5 ) );
      System.out.printf( "Maxm of %.1f,%.1f and %.1f is %.1f\n\n",6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
      System.out.printf( "Max of %s, %s and %s is %s\n","pear", "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

Cela produirait le résultat suivant:

Maximum of 3, 4 and 5 is 5

 

Maximum of 6.6, 8.8 and 7.7 is 8.8

 

Maximum of pear, apple and orange is pear

Les classes génériques

Une déclaration de classe générique ressemble à une déclaration de classe non générique, sauf que le nom de classe est suivi d'une section de paramètre de type.

Comme pour les méthodes génériques, la section des paramètres de type d'une classe générique peut avoir un ou plusieurs paramètres de type séparés par des virgules. Ces classes sont connues sous le nom de classes paramétrées ou de types paramétrés car elles acceptent un ou plusieurs paramètres.

Exemple:

L'exemple suivant illustre comment définir une classe générique:

public class Box<T>{
  private T t;
  public void add(T t) {
    this.t = t;
  }


  public T get() {
    return t;
  }

  public static void main(String[] args){
     Box<Integer> integerBox = new Box<Integer>();
     Box<String> stringBox = new Box<String>();
     integerBox.add(new Integer(10));
     stringBox.add(new String("Hello World"));
     System.out.printf("Integer Value :%d\n\n", integerBox.get());
     System.out.printf("String Value :%s\n", stringBox.get());
  }
}

Cela produirait le résultat suivant:

Integer Value : 10

 

String Value : Hello World

• ← Les collections
• Sommaire du cours
• La Sérialisation →