1
2
3
4
5
6
7
8
9
10
11
12

　　　class MyHashTable<Key, Value> {　　// MyHashtable 稱為 generic type name，Key 及 Value 為 type parameter
　　　　　......
　　　　　Value put(Key k, Value v) {...} 
　　　　　Value get(Key k) {...} 
　　　}
　　　class Demo { 
　　　　　public static void main(String[] args) { 
　　　　　　　MyHashTable<Integer, String> h = new MyHashTable<Integer, String>( ); 
　　　　　　　h.put(new Integer(0), "value"); 
　　　　　　　......
　　　　　}
　　　}  

1
2
3
4
5
6

　　　　class MyGenericsSuper<T1, T2> {
　　　　　　......
　　　　}
　　　　class MyGenericsSub<T1, T2, T3> extends MyGenericsSuper<T1, T2> {
　　　　　　......
　　　　}

1
2

　　　　interface MyGenericsI<T1, T2> { /* ...... */  }
　　　　class MyGenericC<T1, T2> implements MyGenericsI<T1, T2> { /* ...... */ }

1
2
3
4
5

　　　　Vector<String>       // Vector<String> 稱為 parameterized types
　　　　Seq<Seq<A>>
　　　　Seq<String>.Zipper<Integer>
　　　　Collection<Integer>
　　　　Pair<String, String>

1

　　　　LinkedList<LinkedList<String>> texts 

1

　　　　　MyGenericsClass<? super Integer> obj;　　// 只接受 Integer 及其父類別型態的物件

1

　　　　　public class Matrix<V extends Number> { ...... }

1

　　　　　class C<T extends Comparable<? super T> & Serializable>

1
2
3
4
5
6
7
8

　　　　　interface ConvertibleTo<A> {
　　　　　　　A convert();
　　　　　}
　　　　　class ReprChange<A implements ConvertibleTo<B>, B implements ConvertibleTo<A>> { 　　// error, implements 須改為 extends
　　　　　　　A a;
　　　　　　　void set(B x) { a = x.convert(); }
　　　　　　　B get() { return a.convert(); }
　　　　　}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

　　　　class MyGenerics<T> {
　　　　　　T value;
　　　　　　void setter(T value) {
　　　　　　　　this.value = value;
　　　　　　}
　　　　　　T getter( ) {
　　　　　　　　return value;
　　　　　　}
　　　　}
 
　　　　class MyGenericsDemo {
　　　　　　public static void main(String[] args) {
　　　　　　　　MyGenerics<Integer> myObj1 = new MyGenerics<Integer>( );　　// 使用  parameterized type
　　　　　　　　myObj1.setter(new Integer(10));
　　　　　　　　System.out.println(myObj1.getter( )) ;    // 10
 
　　　　　　　　MyGenerics myObj2 = new MyGenerics( );　　// 使用 raw type
　　　　　　　　myObj2.setter((Object)new Integer(10));　　// warning: [unchecked] unchecked call to setter(T) as a member of the raw type MyGenerics
　　　　　　　　Integer i = (Integer) myObj2.getter( );
　　　　　　　　// System.out.println(i == myObj1);　　// Error: incomparable types: java.lang.Integer and MyGenerics
　　　　　　　　// System.out.println(i == myObj2);　　// Error: incomparable types: java.lang.Integer and MyGenerics<java.lang.Integer>
　　　　　　　　System.out.println(myObj2.getClass( ) == myObj1.getClass( ));　　// true
　　　　　　}
　　　　}

1

　　　MyGenericClass<? extends java.lang.Number> obj = new MyGenericClass<Integer>( );　　// Bounded wildcard

1
2
3
4

　　　LinkedList<String> myStrings;    // A variable of type LinkedList<String>
　　　myStrings = new LinkedList<String>( );
　　　或
　　　LinkedList<String> myStrings = new LinkedList<String>( );　　//define an object when you define the variable

1
2
3
4
5
6
7
8

　// T -- return type, <T>-- 指明 agrument 的傳入型態
　public <T>  T  ifThenElse(boolean b, T first, T second) {
　　　return b ? first : second;
　}
　......
　String s = ifThenElse(true, "a", "b"); 　　// a
　Integer i = ifThenElse(false, new Integer(1), new Integer(2));　　//2
　//String s = ifThenElse(b, "PI", new Float(3.14));　　// Error

1
2
3

　public static <T, S extends T> void copy (List <T> dest, List <S> src) { ...... } ;
　或
　public static <T> void copy (List <T> dest, List <? extends T> src) { ...... } ;

1
2
3
4
5
6
7
8
9
10
11
12

　public class M {
  　　public static <T extends Comparable> T minimum(T a, T b) {
　　　    if(a.compareTo(  b) <= 0) return a;
      　 　else return b;
　　  }
　　　public static void main(String[] args) {
　　　　　Integer b1  = new Integer(2);
　　　　　Integer b2  = new Integer(5);
　　　　　Integer min = minimum(b1, b2);
　　　　　System.out.println("Minimum of (2,5) : " + min);
　　　}
　}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

　public <T extends Animal> void printAnimals(Collection <T> animals) {　　// Version 1
　　　for (Animal nextAnimal: animals) {
　　　　　System.out.println(nextAnimal);
　　　}
　}
---------------------------------------------------------------------------------------------
　Version 1 的 method 內並未用到 T ，可改成 "wildcard" 型式
　public void printAnimals(Collection <? extends Animal> animals) {　　　// Version 2
　　　for (Animal nextAnimal: animals) {
　　　　　System.out.println(nextAnimal);
　　　}
　}
---------------------------------------------------------------------------------------------
　method 內使用 Type Parameter
　public <T extends Animal> void printAnimals(Collection<T> animals) {　　// Version 3
　　　for (T nextAnimal: animals) {
　　　　　System.out.println(nextAnimal);
　　　}
　}
---------------------------------------------------------------------------------------------
　以 ? 取代 T 會造成錯誤
　public void printAnimals(Collection<? extends Animal> animals) {　　// Version 4
　　　for (? nextAnimal: animals) {　　// illegal start of expression
　　　　　System.out.println(nextAnimal);
　　　}
　}

1
2
3
4
5
6
7
8

　　class C<T> {
  　　  static void m( ) {
    　　    T t;　　// Error: non-static class T cannot be referenced from a static context
　　    }
　　    static class D {
　  　      C<T> t;　　// Error: non-static class T cannot be referenced from a static context
　    　}
　　}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

　　import java.util.Hashtable;
 
　　interface Registry {
　　　　public void register(Object o);
　　}
 
　　class C<T> implements Registry {
　　　　int counter = 0;
　　　　Hashtable<Integer, T> values;
  
　　　　public C( ) {
　　　　　　values = new Hashtable<Integer, T>( );
　　　　}
  
　　　　public void register(Object obj) {
　　　　　　values.put(new Integer(counter), (T)obj);　　// warning: [unchecked] unchecked cast
　　　　　　counter++;
　　　　}
　　}

1
2
3

　　Collection<String> cs = new ArrayList<String>;
　　if ( cs instanceof Collection<String> )   {  ....  } 　　//illegal
　　<T> T badCast(T t, Object o) { return (T)o };　　// unchecked warning

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

　　import java.io.*;
　　interface MyExecutor<E extends Exception> {
　　　　void execute() throws E;
　　}
　　public class GenericExceptionTest {
　　　　public static void main(String args[]) {
　　　　　　try {
　　　　　　　　MyExecutor<IOException> e = new MyExecutor<IOException>() {
　　　　　　　　　　public void execute() throws IOException {
　　　　　　　　　　　　// code here that may throw an IOException or a subtype of  IOException
　　　　　　　　　　}
　　　　　　　　};
　　　　　　　　e.execute();
　　　　　　} catch(IOException ioe) {
　　　　　　　　System.out.println("IOException: " + ioe);
　　　　　　　　ioe.printStackTrace();
　　　　　　}
　　　　}
　　}

1
2
3
4
5

　　Integer[] intArray = new Integer[10];  
　　Number[] numberArray = intArray;　　// OK
　　List<Integer> intList = new ArrayList<Integer>();
　　List<Number> numberList = intList;　　// error
　　numberList.add(new Float(3.1415));　　// error

1
2
3
4
5
6

　　List<Integer> li = new ArrayList<Integer>( );
　　li.add(new Integer(42));
　　List<?> lu = li;　　// OK
　　System.out.println(lu.get(0));
　　//lu.add(new Integer(43));　　// error
　　lu.clear( );　　// OK, don't depend on the compiler having to know anything about the type parameter of lu

1
2
3
4
5
6
7

　　class ShoppingCart<T extends DVD>{
　　　　……
　　}
 
　　class ShoppingCart<T extends VideoTape>{
　　　　……
　　}

1
2
3
4
5
6
7
8

　　class TwoForOneSpecial<T extends Rentable, W extends Rentable> {
　　　　public void add(T newRentable) {
　　　　　　……
　　　　}
　　　　public void add(W newRentable) {
　　　　　　……
　　　　}
　　}

1
2
3
4
5
6
7

　　public class GenericClass<E> {
　　　   ……
　　　   public Class<E> getElementType() {
　　　　      return E.class;　　// error
　　　   }
　　　   ……
　　}

1
2
3

　　Vector<String> x = new Vector<String>();
　　Vector<Integer> y = new Vector<Integer>();
　　return x.getClass() == y.getClass();　　// true

1
2
3

　　LinkedList<Float> floatList = new LinkedList<Float>( );
　　List<Float> moreFloats = floatList;　　// legal
　　LinkedList<Number> numberList = floatList;　　// error

1
2
3
4

　　List<Integer> ints = new LinkedList<Integer>( );
　　List oldList = ints;　　// We can widen (due to backwards compatibility)
　　oldList.add("Hello");　　// This line should be illegal, but it happily compiles and runs
　　Integer i = ints.get(0);　　// compile warning, runtime error -- ClassCastException at runtime

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

　　import java.util.ArrayList;
　　import java.util.List;
 
　　public class BadIdea {
　　　　private static List<Integer> ints = new ArrayList<Integer>( );
　　　　public static void fillList(List<Integer> list) {
　　　　　　for (Integer i : list) {
　　　　　　　　ints.add( i );
　　　　　　} // for
　　　　} // fillList(List<Integer> list)
 
　　　　public static void printList( ) {
　　　　　　for (Integer i : ints) {
　　　　　　　　System.out.println( i );
　　　　　　} // for
　　　　} // printList( )
 
　　　　public static void main(String[] args) {
　　　　　　List<Integer> myInts = new ArrayList<Integer>( );
　　　　　　myInts.add(1);
　　　　　　myInts.add(2);
　　　　　　myInts.add(3);
　　　　　　System.out.println("Filling list and printing in normal way...");
　　　　　　fillList(myInts);
　　　　　　printList( );
 
　　　　　　try {
　　　　　　　　List list = (List)BadIdea.class.getDeclaredField("ints").get(null);
　　　　　　　　list.add("Illegal Value!");
　　　　　　} catch (Exception e) {
　　　　　　　　e.printStackTrace( );
　　　　　　} // try-catch
    
　　　　　　System.out.println("Printing with illegal values in list...");
　　　　　　printList( );
　　　　} //main()
　　} 

1
2
3
4
5
6

　　List<String> [] lsa = new List<String>[10]; 　// 錯誤
　　　　　　　　　　= new List<?>[10]; 　　// OK
　　Object o = isa;
　　Object[] oa = (Object[])o;
　　oa[1] = new ArrayList<Integer>( );
　　String s = lsa[1].get( );　　// error