java Généricité

Posted 2021-05-08

/*
 * Le principe de la généricité est de faire des classes qui n'acceptent qu'un certain type d'objets ou de données de façon dynamique
 * On peut utiliser plusieurs types génériques dans la classe(ex: <T, S, I>).
 * La généricité est un concept très utile pour développer des objets travaillant avec plusieurs types de données.
 * Vous passerez donc moins de temps à développer des classes traitant de façon identique des données différentes.
 * La généricité permet de réutiliser sans risque le polymorphisme avec les collections.
 * Cela confère plus de robustesse à votre code.
 * Vous pouvez coupler les collections avec la généricité !
 * Le wildcard (?) permet d'indiquer que n'importe quel type peut être traité et donc accepté !
 * Dès que le wildcard (?) est utilisé, cela revient à rendre ladite collection en lecture seule !
 * Vous pouvez élargir le champ d'acceptation d'une collection générique grâce au mot-clé extends.
 * L'instruction ? extends MaClasse autorise toutes les collections de classes ayant pour supertype MaClasse.
 * L'instruction ? super MaClasse autorise toutes les collections de classes ayant pour type MaClasse et tous ses supertypes !
 * Pour ce genre de cas, les méthodes génériques sont particulièrement adaptées et permettent d'utiliser le polymorphisme dans toute sa splendeur !
 */

// Création de la class générique.
public class Solo<T> {
 
  //Variable d'instance
  private T valeur;
        
  //Constructeur par défaut
  public Solo(){
    this.valeur = null;
  }

  //Constructeur avec paramètre inconnu pour l'instant
  public Solo(T val){
    this.valeur = val;
  }
        
  //Définit la valeur avec le paramètre
  public void setValeur(T val){
    this.valeur = val;
  }
        
  //Retourne la valeur déjà « castée » par la signature de la méthode !
  public T getValeur(){
    return this.valeur;
  }       
}

// Utilisation de la classe générique.
// On instancie la class avec comme valeur un Integer. Toutes les méthodes qui utilisent le T attendrons donc un Integer.
Solo<Integer> val = new Solo<Integer>(12);
int nbre = val.getValeur();

// Il faut utiliser les classes pour les types primitifs.
Solo<Integer> val = new Solo<Integer>();
Solo<String> valS = new Solo<String>("TOTOTOTO");
Solo<Float> valF = new Solo<Float>(12.2f);
Solo<Double> valD = new Solo<Double>(12.202568);

// On ne peut pas changer le type d'une instance.
// Ceci ne fonctionnera pas:
Genericite<Integer> val = new Genericite<Integer>(12);
Genericite val = new Genericite<String>("toto");

/*
 * Utilisation avec des collections
 */
// On s'assure que l'ArrayList contient que du String
List<String> listeString = new ArrayList<String>();
listeString.add("Une chaîne");
for(String str : listeString) {
  System.out.println(str);
}
// On s'assure que l'ArrayList contient que du Float
List<Float> listeFloat = new ArrayList<Float>();
listeFloat.add(128764.25f);
for(float f : listeFloat) {
  System.out.println(f);
}