Generische Programmierung in Java wird durch sog. Generics seit Java 1.5 ermöglicht. Der Begriff steht synonym für „parametrisierte Typen“. Die Idee dahinter ist, zusätzliche Variablen für Typen einzuführen. Diese Typ-Variablen repräsentieren zum Zeitpunkt der Implementierung unbekannte Typen. Erst bei der Verwendung der Klassen, Schnittstellen und Methoden werden diese Typ-Variablen durch konkrete Typen ersetzt. Damit kann typsichere Programmierung meistens gewährleistet werden. Jedoch nicht immer.

Das Konzept

Ab Version 5.0 („Tiger“, 2004 veröffentlicht) steht auch in der Programmiersprache Java mit den Generics ein syntaktisches Mittel für die generische Programmierung zur Verfügung. Damit lassen sich Klassen und Methoden (Methoden auch unabhängig von ihren Klassen) mit Typen parametrisieren. Damit werden der Sprache einige ähnliche Möglichkeiten eröffnet, die sich vergleichbar bei den Templates in C++ bieten.

Prinzipiell gibt es aber durchaus wesentliche Unterschiede. Während in Java über die Schnittstelle der Typparameter parametrisiert wird, wird in C++ direkt über den Typ des Typparameters selbst parametrisiert. Der Quelltext eines C++-Templates muss für den Anwender (d. h. beim Einsetzen des Typparameters) verfügbar sein, während ein generischer Java-Typ auch als übersetzter Bytecode veröffentlicht werden kann. Für verschiedene konkret verwendete Typparameter produziert der Compiler duplizierten Zielcode.

Beispielsweise bietet die Funktion std::sort in C++ die Möglichkeit, alle Container zu sortieren, die bestimmte Methoden anbieten (hier speziell begin() und end(), die jeweils einen Iterator liefern) und deren Typparameter den 'operator<' implementiert (oder explizit eine andere Vergleichsfunktion angegeben wurde). Ein Nachteil, der sich durch dieses System ergibt, ist die (für den Programmierer!) schwierigere Übersetzung. Der Compiler hat keine andere Möglichkeit, als den Typparameter in jedem Fall durch den geforderten konkreten Typ zu ersetzen und den ganzen Code erneut zu kompilieren.

Sehr leicht können bei unpassenden Typparametern und anderen Problemen komplizierte und unverständliche Compiler-Meldungen entstehen, was einfach mit der Tatsache zusammenhängt, dass die konkreten Anforderungen an die Typparameter unbekannt sind. Die Arbeit mit C++-Templates erfordert deshalb eine lückenlose Dokumentation der Anforderungen an einen Typparameter. Durch Template-Metaprogrammierung können die meisten Anforderungen (Basisklasse, Vorhandensein von Methoden, Kopierbarkeit, Zuweisbarkeit etc.) auch in speziellen Konstrukten abgefragt werden, wodurch sich lesbarere Fehlermeldungen ergeben. Obgleich sie standardkonform sind, werden diese Konstrukte jedoch nicht von allen Compilern unterstützt.

Dagegen sind den generischen Klassen und Methoden in Java die Anforderungen (engl. constraints) an ihre eigenen Typparameter bekannt. Um eine Collection (ohne Comparator) zu sortieren, müssen die enthaltenen Elemente vom Typ Comparable sein, also dieses Interface implementiert haben. Der Compiler muss lediglich prüfen, ob der Typparameter ein Untertyp von Comparable ist, und kann damit schon sicherstellen, dass der Code korrekt ist (d. h. die erforderliche Methode compareTo verfügbar ist). Weiterhin wird ein und derselbe Code für alle konkreten Typen verwendet und nicht jedes Mal dupliziert.

Praktische Beispiele

Ein Programm verwendet eine ArrayList, um eine Liste von JButtons zu speichern.

Bisher war die ArrayList auf den Typ Object fixiert:

List list = new ArrayList();
list.add(new JButton("Button 1"));
list.add(new JButton("Button 2"));
list.add(new JButton("Button 3"));
list.add(new JButton("Button 4"));
list.add(new JButton("Button 5"));

for (int i = 0; i < list.size(); i++) {
    JButton button = (JButton) list.get(i);
    button.setBackground(Color.white);
}

Man beachte die notwendige explizite Typumwandlung (auch „Cast“ genannt) sowie die Typunsicherheit, die damit verbunden ist. Man könnte versehentlich ein Objekt in der ArrayList speichern, das keine Instanz der Klasse JButton ist. Die Information über den genauen Typ geht beim Einfügen in die Liste verloren, der Compiler kann also nicht verhindern, dass zur Laufzeit bei der expliziten Typumwandlung von JButton eine ClassCastException auftritt.

Mit generischen Typen ist in Java Folgendes möglich:

List<JButton> list = new ArrayList<JButton>();
list.add(new JButton("Button 1"));
list.add(new JButton("Button 2"));
list.add(new JButton("Button 3"));
list.add(new JButton("Button 4"));
list.add(new JButton("Button 5"));

for (int i = 0; i < list.size(); i++)
    list.get(i).setBackground(Color.white);

Beim Auslesen ist nun keine explizite Typumwandlung mehr notwendig, beim Speichern ist es nur noch möglich, JButtons in der ArrayList list abzulegen.

Ab Java7 ist die Instanzierung generischer Typen vereinfacht worden. Die erste Zeile in obigem Beispiel kann seit Java 7 folgendermaßen geschrieben werden:

List<JButton> list = new ArrayList<>();

Durch Kombination von generischen Typen mit den erweiterten For-Schleifen lässt sich obiges Beispiel kürzer fassen:

List<JButton> list = new ArrayList<>();
list.add(new JButton("Button 1"));
list.add(new JButton("Button 2"));
list.add(new JButton("Button 3"));
list.add(new JButton("Button 4"));
list.add(new JButton("Button 5"));

for (JButton b: list)
    b.setBackground(Color.white);

Ein Beispiel für eine generische Klasse, die zwei Objekte von beliebigem, aber einander gleichem Typ beinhaltet, liefert der folgende Beispielcode:

public class DoubleObject<T> {
    private T object1;
    private T object2;

    public DoubleObject(T object1, T object2) {
        this.object1 = object1;
        this.object2 = object2;
    }

    public String toString() {
        return this.object1 + ", " + this.object2;
    }

    public static void main(String[] args) {
        DoubleObject<String> s = new DoubleObject<>("abc", "def");
        DoubleObject<Integer> i = new DoubleObject<>(123, 456);
        System.out.println("DoubleObject<String> s=" + s.toString());
        System.out.println("DoubleObject<Integer> i=" + i.toString());
    }
}

Varianzfälle

In Java können die nachfolgenden Varianzfälle unterschieden werden. Sie bieten jeweils eine völlig eigenständige Flexibilität beim Umgang mit generischen Typen und sind jeweils absolut statisch typsicher.

List<Integer> list = new ArrayList<Integer>();
// ...
Integer x = list.get(index);
list.get(index).methodeVonInteger();
list.set(index, 98347); // Autoboxing, entspricht Integer.valueOf(98347)
int y = list.get(index); // Auto-Unboxing

List<Number> list = new ArrayList<Integer>();

// OK, Integer[] ist abgeleitet von Number[]
Number[] array = new Integer[10];

// ArrayStoreException zur Laufzeit: Double -> Integer sind nicht
// zuweisungskompatibel
array[0] = new Double(5.0);

List<? extends Number> list;
list = new ArrayList<Double>();
list = new ArrayList<Long>();
list = new ArrayList<Integer>();

// Typfehler vom Compiler
list.set(index, myInteger);

// OK aber Warnung vom Compiler: unchecked cast
((List<Integer>) list).set(index, myInteger);

Number n = list.get(index); // OK
Integer i = list.get(index); // Typfehler: Es muss sich bei '? extends Number'
                             // nicht um ein Integer handeln.
Integer j = (Integer) list.get(index); // OK

List<? super Double> list;
list = new ArrayList<Number>();
list = new ArrayList<Double>();
list = new ArrayList<Object>();

// Fehler: 'list' könnte vom Typ List<Object> sein
Number x = list.get(index);

// Fehler: 'list' könnte List<Object> oder List<Number> sein
Double x = list.get(index);

// Die einzige Ausnahme: Objects sind auf jeden Fall in der Liste
Object x = list.get(index);

List<? super Number> list;
list.add(new Double(3.0)); // OK: 'list' hat immer den Typ List<Number>
                           // oder List<Basisklasse von Number>. Damit
                           // ist die Zuweisung Double -> T immer erlaubt.

List<?> list;
list = new ArrayList<Integer>();
list = new ArrayList<Object>();
list = new ArrayList<String>();
// ...

// Keine Informationen über den Typparameter nötig, kann ''beliebige'' Listen
// aufnehmen.
int readSize(List<?> list) {
    return list.size();
}

<T> int readSize(List<T> list) {
    return list.size();
}

Weblinks

• Ina Brenner: Tutorial zu Generics in Java von der Autorin eines Buchs zur Java-Zertifizierung SCJP (deutsch)
• Klaus Kreft, Angelika Langer: Artikelserie zu Generics in Java im JavaSpektrum (deutsch)
• Kapitel zu Generischen Datentypen aus dem Galileo-Openbook Java ist auch eine Insel (deutsch)

Einzelnachweise

1. ↑ Java and Scala’s Type Systems are Unsound. Abgerufen im 1. Januar 1