Java Generics – Herbruikbare, type-veilige code bouwen

Deze gids legt Java generics uit, hoe je generieke klassen en methoden maakt, en de voordelen die ze brengen, geïllustreerd met heldere voorbeelden.

Inleiding

Java generics laten je één klasse, interface of methode schrijven die op veel verschillende datatypen kan opereren, terwijl compile-time veiligheid behouden blijft.

Let op: Generics werken niet met primitieve typen (int, float, char, etc).

Java Generics-klasse

Door een typeparameter te declareren, kun je een klasse maken die met elk objecttype werkt.

Voorbeeld: Een generieke klasse aanmaken

class Main {
    public static void main(String[] args) {
        GenericsKlasse<Integer> intObj = new GenericsKlasse<>(5);
        System.out.println("Generics-klasse retourneert: " + intObj.getData());
        GenericsKlasse<String> stringObj = new GenericsKlasse<>("Java Programmeren");
        System.out.println("Generics-klasse retourneert: " + stringObj.getData());
    }
}

class GenericsKlasse<T> {
    private T data;
    public GenericsKlasse(T data) {
        this.data = data;
    }
    public T getData() {
        return this.data;
    }
}

Output

Generics-klasse retourneert: 5
Generics-klasse retourneert: Java Programmeren

In het voorbeeld is GenericsKlasse een generieke klasse waar T de typeparameter is. Twee instanties worden aangemaakt:

• intObj – T wordt vervangen door Integer, dus de klasse werkt met integers
• stringObj – T wordt vervangen door String, dus de klasse werkt met strings

Java Generics-methode

Methoden kunnen ook generiek zijn, zodat ze elk type argument accepteren terwijl type-veiligheid behouden blijft.

Voorbeeld: Een generieke methode aanmaken

class Main {
    public static void main(String[] args) {
        DemoKlasse demo = new DemoKlasse();
        demo.<String>genericsMethode("Java Programmeren");
        demo.<Integer>genericsMethode(25);
    }
}

class DemoKlasse {
    public <T> void genericsMethode(T data) {
        System.out.println("Generics-methode:");
        System.out.println("Doorgegeven data: " + data);
    }
}

Output

Generics-methode:
Doorgegeven data: Java Programmeren
Generics-methode:
Doorgegeven data: 25

Wanneer de compiler het type kan afleiden, kun je het expliciete type-argument weglaten:

demo.genericsMethode("Java Programmeren");

Begrensde typen

Soms wil je dat een generiek type alleen een specifieke familie van klassen accepteert. Begrensde typen bereiken dit met het extends-keyword.

Syntax: <T extends A> – T kan A of elke subklasse van A zijn.

Voorbeeld: Begrensde typen

class GenericsKlasse <T extends Number> {
    public void toon() {
        System.out.println("Dit is een begrensde-type generics-klasse.");
    }
}

class Main {
    public static void main(String[] args) {
        // GenericsKlasse<String> obj = new GenericsKlasse<>(); // compileerfout
    }
}

Hier accepteert GenericsKlasse alleen numerieke typen (Integer, Double, etc.). Poging om het te instantiëren met String veroorzaakt een compileerfout:

GenericsKlasse<String> obj = new GenericsKlasse<>();
^ reason: inference variable T has incompatible bounds
equality constraints: String
lower bounds: Number
where T is a type-variable: T extends Number declared in class GenericsKlasse

Voordelen van Java Generics

1. Code-herbruikbaarheid

Generieke code kan op meerdere datatypen opereren, wat duplicatie vermindert. Een enkele methode kan integers, strings en custom-objecten verwerken.

2. Compile-time type-checking

Omdat de typeparameter op compile-tijd bekend is, kan de compiler type-mismatches detecteren voordat het programma draait.

3. Naadloze integratie met Collections

Java's collection-framework is generics-gebaseerd, wat collecties in staat stelt type-veiligheid af te dwingen. Voorbeelden:

ArrayList<String> lijst1 = new ArrayList<>();
ArrayList<Integer> lijst2 = new ArrayList<>();

Andere collectieklassen (LinkedList, Queue, Map, etc.) gebruiken ook generics voor dezelfde voordelen.