Welke mogelijkheden bieden Generics in Java?

Generics in Java verbeteren de typeveiligheid van de code door runtime-fouten gerelateerd aan typeconversies te voorkomen. Belangrijkste functies:

• Typecontrole tijdens compilatie: De compiler controleert het correcte gebruik van de in Generics gespecificeerde types, waardoor fouten vóór het uitvoeren van het programma worden opgespoord.

  // Zonder Generics - mogelijke ClassCastException
  List list = new ArrayList();
  list.add("string");
  list.add(123); // Integer toevoegen
  String s = (String) list.get(1); // Runtime-fout
  
  // Met Generics - compileerfout
  List<String> stringList = new ArrayList<>();
  stringList.add("string");
  // stringList.add(123); // Compileerfout
  String str = stringList.get(0); // Veilige toegang
  

• Verwijdering van typeconversies (type casting): Generics elimineren de noodzaak van expliciete typeconversies bij het ophalen van elementen uit collecties of het gebruik van getypeerde klassen.

  // Zonder Generics
  List list = new ArrayList();
  list.add("Hallo");
  String s = (String) list.get(0); // Expliciete conversie
  
  // Met Generics
  List<String> stringList = new ArrayList<>();
  stringList.add("Hallo");
  String str = stringList.get(0); // Geen conversie nodig
  

• Implementatie van generieke code (Generieke methoden, generieke klassen, generieke interfaces): Hiermee kunnen algemene algoritmen en datastructuren worden gemaakt die met verschillende types werken zonder code te dupliceren.

  // Generieke methode om een array af te drukken
  public static <T> void printArray(T[] array) {
      for (T element : array) {
          System.out.print(element + " ");
      }
      System.out.println();
  }
  
  // Generieke klasse - paar waarden
  class Pair<K, V> {
      private K key;
      private V value;
  
      public Pair(K key, V value) {
          this.key = key;
          this.value = value;
      }
  
      public K getKey() { return key; }
      public V getValue() { return value; }
  }
  

• Ondersteuning voor Wildcards: Hiermee kunnen flexibele beperkingen op types worden gedefinieerd.

  • ? (Onbeperkte Wildcard): Elk type.
  • ? extends T (Beperkte Wildcard - Upper Bound): Het type moet T of een subtype ervan zijn.
  • ? super T (Beperkte Wildcard - Lower Bound): Het type moet T of een supertype ervan zijn.

  // Methode die een lijst van elk type accepteert
  public static void processList(List<?> list) {
      // ...
  }
  
  // Methode die een lijst van getallen of subtypes accepteert
  public static void processNumbers(List<? extends Number> list) {
      // ...
  }
  
  // Methode die een lijst van strings of supertypes accepteert
  public static void addStrings(List<? super String> list) {
      list.add("nieuwe string");
  }
  

• Gebruik in het Collections Framework: Alle belangrijke collectieklassen (List, Set, Map, enz.) zijn parametrisch, wat het werken met collecties typeveilig en handig maakt.

Generics zijn een kernonderdeel van moderne Java, dat de betrouwbaarheid en leesbaarheid van de code verhoogt.