OOP mit Java: Generische Klassen in Java ab Version 1.5

analog zu C++
mit Typüberprüfung zur Übersetzungszeit

public
abstract
class Stack<E> {
 
  //--------------------
  // der Konstruktor
 
  public
  Stack() { }
 
  //--------------------
  // die Attribut-Funktionen
 
  public
  abstract
  boolean isEmpty();
 
  public
  abstract
  E top();
 
  //--------------------
  // die modifizierenden Funktionen
 
  public
  abstract
  Stack<E> push(E e);
 
  public
  abstract
  Stack<E> pop();
 
  //--------------------
  // die Vorbedingungen
 
  public
  boolean preTop() {
    return
      ! isEmpty();
  }
 
  public
  boolean prePop() {
    return
      ! isEmpty();
  }
}
 
 

Eine konkrete Implementierung nach der gleichen Art wie oben

class SimpleStack<E>
    extends Stack<E> {
 
  // die Datenfelder: nicht nach aussen sichtbar
 
  private
  E [] a;                     // <-----
 
  private
  int i;
 
  //--------------------
  // der Konstruktor
 
  public
  SimpleStack() {
 
    // a = new E[20];            // so leider nicht
 
    @SuppressWarnings("unchecked")
    E [] t = (E []) new Object[20];   // aber so: mit downcast
 
    a = t;
    i = 0;
  }
 
  //--------------------
  // die Attribut-Funktionen
 
  public
  boolean isEmpty() {
    return
      i == 0;
  }
 
  public
  E top() {                   // <-----
    return
      a[i-1];
  }
 
  //--------------------
  // die modifizierenden Funktionen
 
  public
  Stack<E> push(E e) {        // <-----
    a[i++] = e;
    return
      this;
  }
 
  public
  Stack<E> pop() {
    a[--i] = null;
    return
      this;
  }
 
  // Vorbedingungen sind schon implementiert
}
 

Eine Anwendung

class SimpleTest {
 
    // zwei Stacks mit unterschiedlichen Elementtypen
 
    Stack<Integer> intStack;
 
    Stack<String> stringStack;
 
    void test() {
        intStack
            .push(new Integer(1))
            .push(new Integer(2))
            .push(new Integer(3));
 
        // autoboxing:
        // die int-Zahlen werden automatisch
        // in Integer-Objekte eingewickelt
 
        intStack.push(1).push(2).push(3);
 
        stringStack.push("abc").push("xyz");
    }
}

	Syntax sehr ähnlich wie bei C++
	Für Java 1.5 ist die JVM nicht geändert worden: Abwärtskompatibilität
	Typparameter werden in Java vollständig zur Übersetzungszeit ausgewertet und sind im JVM Code nicht mehr vorhanden
	In der JVM wird mit sogenannten raw types gearbeitet. Mit raw types bezeichnet man generische Größen, bei denen die Typparmater gelöscht worden sind. Diese raw types stehen für Familien von Typen.
	Typparameter können nicht zur Laufzeitbeschleunigung durch Vermeidung von downcasts genutzt werden.
	Primitiven Typen sind nicht als Typparameter zugelassen.
	Namenskonvention: Kurze Namen (häufig ein Großbuchstabe) als Bezeichner für Typparameter

Generische Klassen in Java ab Version 1.5

Generische ADTs mit Java 1.5