案例1-泛型类:

 1 /**
 2  * 1.分析如下泛型定义是否正确?
 3  * 1)class A<Parameter>{} 正确
 4  * 2)interface B<Param,Result>{} 正确
 5  * 3)class C{
 6  *     public <T>void doMethod(T t){} 正确 
 7  *   }
 8  * 4)class D<T>{ //不正确(类上泛型不作用于静态方法)
 9  *     static void doMethod(T t){} 
10  *   }
11  * 2.分析如下代码,检查代码是否有问题?
12  * class A<T>{}
13  * class B extends A<T>{} 不正确
14  * class C<T> extends A<T>{}正确
15  * class E extends A<String>{}正确
16  * 3.分析如下代码,检查代码是否有问题?
17  * 
18  * interface A<K,V>{}
19  * class B implements A<K,V>{} 不正确
20  * class C<K,V> implements A<K,V>{} 正确
21  * class D  implements A<String,Object>{}正确
22  * class E<K> implments A<K,Object>{}正确
23  * 
24  * 4.分析如下代码,检查代码是否有问题?
25  * List<Object> list=new ArrayList<String>();不正确
26  * List<String> list=new ArrayList<Object>();不正确
27  * List<? extends Object> list=new ArrayList<String>();正确
28  * List<? super String> list=new ArrayList<Object>();正确
29  */
30 //泛型接口(接口定义时使用泛型用于约束方法参数类型,返回值类型)
31 interface Container<T>{
32     void add(T t);
33     T get(int i);
34     int size();
35 }
36 //泛型类,当使用一个类实现泛型接口对象时
37 //说明:类定义时要么声明为泛型类,要么为接口传入具体类型
38 abstract class AbsContainer<T> implements Container<T>{
39     @Override
40     public int size() {
41         return 0;
42     }
43 }
44 class ArrayContainer extends AbsContainer<Integer>{
45     private Object[] array;
46     public ArrayContainer() {
47         array=new Object[16];
48     }
49     @Override
50     public void add(Integer t) {
51         //....
52     }
53     @Override
54     public Integer get(int i) {
55         //...
56         return null;
57     }
58 }
59 public class TestGeneric01 {
60 
61     public static void main(String[] args) {
62        ArrayContainer c=new ArrayContainer();
63        c.add(100);
64     }
65 }

 

案例2-泛型接口:

 1 package com.company.java.generic;
 2 
 3 interface Task<Param,Result>{
 4     Result execute(Param param);
 5 }
 6 class IntegerConvertTask  implements Task<String,Integer>{
 7     @Override
 8     public Integer execute(String param) {
 9         return Integer.valueOf(param);
10     }
11 }
12 public class TestGeneric02 {
13     public static void main(String[] args) {
14         Task<String,Integer> task=
15                 new IntegerConvertTask ();
16         Integer a=task.execute("1000");
17         System.out.println(a);
18         
19     }   
20 }

案例3-泛型方法:

 1 package com.company.java.generic;
 2 
 3 import java.util.Collection;
 4 import java.util.Date;
 5 import java.util.List;
 6 
 7 /**
 8  * 泛型方法应用
 9  * 特点:修饰符   <泛型>返回值类型 方法名(参数列表)
10  *
11  */
12 class ObjectFactory{
13     //泛型方法
14     public <T>T newInstance(Class<T> cls)throws Exception {
15         return cls.newInstance();
16     }
17     //泛型方法
18     public <T>boolean isCollection(Class<T> cls) {
19         return Collection.class.isAssignableFrom(cls);
20     }//isAssignableFrom()方法是判断是否为某个类的父类,用法:  父类.class.isAssignableFrom(子类.class)
21 }
22 class ContainerUtils{
23     public static <E>void sort(List<E> list) {}
24 }
25 public class TestGeneric03 {
26     public static void main(String[] args)
27     throws Exception{
28         ObjectFactory of=new ObjectFactory();
29         Date date=of.newInstance(Date.class);
30         System.out.println(date);
31         
32         boolean flag=of.isCollection(List.class);
33         System.out.println(flag);
34         
35     }
36 }

案例4-限定通配符:

 1 package com.company.java.generic;
 2 
 3 import java.util.ArrayList;
 4 import java.util.HashSet;
 5 import java.util.List;
 6 import java.util.Set;
 7 /**
 8  * 限定通配符应用:方法参数或返回值
 9  */
10 class PrintUtil{
11      //上界限定通配符
12      public static void doPrint(
13              List<? extends CharSequence> list) {
14          System.out.println(list);
15      }
16      //下界限定通配符
17      public static void doPrint(
18              Set<? super Integer> set) {
19          System.out.println(set);
20      }
21 }
22 public class TestGeneric04 {
23     public static void main(String[] args)
24     throws Exception{
25         Class<String> c1=String.class;
26         //"?"在这里表示通配符,代表一种实际参数
27         Class<?> c2=
28         Class.forName("java.lang.Object");
29         //List<?> list=new ArrayList<?>(); 错
30         //如何对?的值进行约束呢?
31         List<String> list1=new ArrayList<String>();
32         list1.add("A");
33         PrintUtil.doPrint(list1);
34         Set<Integer> list2=new HashSet<Integer>();
35         list2.add(2);
36         PrintUtil.doPrint(list2);
37         
38         Set<Number> list3=new HashSet<Number>();
39         list3.add(200);
40         PrintUtil.doPrint(list3);
41     }
42 }

案例5-泛型擦除:

 1 package com.company.java.generic;
 2 import java.lang.reflect.Method;
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 /**
 6  * 案例分析：演示泛型类型擦除
 7  * @author Administrator
 8  */
 9 public class TestGeneric05 {
10     public static void main(String[] args)
11     throws Exception{
12         List<String> list=new ArrayList<>();
13         list.add("A");
14         //list.add(200);
15         //list.add(0, 300);
16         //通过反射技术在运行时将200这个整数存储到集合
17         //1.获取list集合的字节码对象
18         Class<?> cls=list.getClass();
19         //2.基于字节码对象获取方法对象
20         Method method=
21         //cls.getMethod("add", Object.class);//Object.class表示往集合中存放的元素类型
22         cls.getMethod("add",int.class,Object.class);//int.class表示给集合的int位置添加元素,Object.class表示往集合中存放的元素类型
23         //3.执行list对象add方法对象
24         //method.invoke(list,200);
25         method.invoke(list,0,300);
26         System.out.println(list);
27     }
28 }