Um einen generischen Typen verwenden zu können, muss für jeden Typparameter des generischen Typen ein Typargument bereitgestellt werden. Dem Typnamen folgt ein spitzes Klammerpaar innerhalb dessen die Typargumente angegeben werden können. Das Ergebnis dieser Notation wird dann als parametrisierter Typ bezeichnet. Die einzelnen Begriffsbezeichnungen sollen anhand des generischen Typs Holder<E> in der folgenden Aufstellung noch einmal konkret genannt werden:

Generischer Typ:         Holder<E>
(Formaler) Typparamter:  E
Parametrisierter Typ:    Holder<Integer>
(Aktuelles) Typargument: Integer

Der parametrisierte Typ Holder<Integer> kann i.a. wie ein regulärer Referenztyp verwendet werden. Wie die folgenden Ableitungsregeln für Typargumente zeigen kann ein aktuelles Typargument entweder ein Referenztyp oder eine sogenannter Wildcard sein (für Einzelheiten zu Wildcards siehe Abschnitt 3.7):

TypeArguments:
        < ActualTypeArgumentList >
        
ActualTypeArgumentList:
        ActualTypeArgument
        ActualTypeArgumentList , ActualTypeArgument

ActualTypeArgument:
        ReferenceType
        Wildcard

Als Typargumente können Referenztypen (auch parametrisierte Typen) verwendet werden. Primitive Typen sind dagegen nicht erlaubt und würden bei der Compilierung zu einer Fehlermeldung führen. Die folgenden Beispiele nutzen den generischen Typ Holder<E>, wobei jeweils unterschiedliche Typargumente verwendet wurden:

Holder<String> hs = new Holder<String>();
Holder<Integer> hi = new Holder<Integer>(); 
Holder<Vector<Integer>> hvi = new Holder<Vector<Integer>>(); 
Holder<int> hint = new Holder<int>();  // Fehler

Das anschließende kurze Testprogramm benutzt die zuvor definierten generischen Typen Holder<E> und Holder2<K,V>. Dabei werden die Typparameter variiert (damit das Testprogramm richtig funktioniert müssen die beiden Dateien Holder.java und Holder2.java im gleichen Verzeichnis wie das Testprogramm sein):

/* 
 * TestHolder.java 
 * JDK 5
 *
 */

import java.util.*;

public class TestHolder {

  public static void main(String[] args) {
    
    Holder<String> h1 = new Holder<String>();
    h1.set("Hallo");
    String s1 = h1.get();
    System.out.println(s1);
    
    Holder<Integer> h2 = new Holder<Integer>(); 
    h2.set(new Integer(3));
    Integer i2 = h2.get();
    System.out.println(i2.toString());
    

    Holder2<String,Integer> h3 = new Holder2<String,Integer>();
    h3.set("vier", new Integer(4));
    String s3 = h3.getKey();
    Integer i3 = h3.getValue();
    System.out.println(s3 + ", " + i3.toString());
    
    Holder2<String,Vector<Integer>> h4 = new Holder2<String,Vector<Integer>>();
    Vector<Integer> v = new Vector<Integer>();
    v.add(new Integer(5));
    v.add(new Integer(6));
    h4.set("vector", v);
    String s4 = h4.getKey();
    Vector<Integer> v4 = h4.getValue();
    Integer i41 = v4.get(0);
    Integer i42 = v4.get(1);
    System.out.println(s4 + ", " + i41.toString() + ", " + i42.toString());
    
    Holder2<String,Holder<String>> h5 = new Holder2<String,Holder<String>>();
    h5.set("holder", h1);
    String s51 = h5.getKey();
    Holder<String> hs = h5.getValue();
    String s52 = hs.get();
    System.out.println(s51 + ", " + s52);
  }  
}

Die Ausgabe des Listings auf die Konsole lautet:

Hallo
3
vier, 4
vector, 5, 6
holder, Hallo