泛型的高级应用

泛型的高级应用

泛型的高级应用分为三种：一、？二、extends 三、super

一、泛型中的通配符“？”相当于多态中的Object，泛型中要兼容所有的类型要用“？”使用通配符“？”后，里面的元素只能调用Object的函数。

二、泛型的上限：extends，限定父类

上限的应用场合：，往集合当中加入元素

三、泛型的下限：super

多个子类的公共部分即他们的父类

下限的应用场合：从集合当中把元素读取出来，进行操作（调用所有集合中的元素的父类的方法）

我们要注意的是：泛型没有多态，因为泛型只有编译期。

下面我们通过实例代码来理解：

[java]  view plain  copy

1. package cn.hncu.generic.three;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.List;  
6.   
7.   
8. /** 
9.  * @author 军街 
10.  *泛型的高级应用(1? 2super 3extends) 
11.  *这个例子是写通配符 ?的 
12.  */  
13. public class GenericAdvDemo1 {  
14.       
15.     public static void main(String[] args) {  
16.         List<String> list=new ArrayList<String>();  
17.         list.add("***");  
18.         list.add("aaa");  
19.         list.add("hello word");  
20.         print(list);  
21.         List<Integer> list2=new ArrayList<Integer>();  
22.         list2.add(100);  
23.         list2.add(111);  
24.         list2.add(123);  
25.         print(list2);  
26.           
27.           
28.     }  
29.   
30.     private static void print(List<?> list) {  
31.         Iterator<?> it=list.iterator();  
32.         while(it.hasNext()){  
33.             System.out.println(it.next());  
34.         }  
35.     }  
36.   
37. }  

[java]  view plain  copy

1. package cn.hncu.generic.three;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.List;  
6.   
7. /** 
8.  * @author 军街 
9.  *泛型的高级应用 extends 
10.  */  
11. public class GenericAdcDemo2 {  
12.     public static void main(String[] args) {  
13.         List<Person> list=new ArrayList<Person>();  
14.         list.add(new Person("Jack", 20));  
15.         list.add(new Person("Cv", 21));  
16.         list.add(new Person("WWW", 22));  
17.         print(list);  
18.           
19.         List<Student> list2=new ArrayList<Student>();  
20.         list2.add(new Student("qqq", 22, 1));  
21.         list2.add(new Student("eee", 23, 2));  
22.         list2.add(new Student("qwer", 20, 3));  
23.         print(list2);  
24.     }  
25.     public static void print(List<? extends Person> list){  
26.         Iterator<? extends Person> it=list.iterator();  
27.         while(it.hasNext()){  
28.             System.out.println(it.next());  
29.         }  
30.     }  
31. }  
32. class Person{  
33.     String name;  
34.     int age;  
35.     public Person(String name, int age) {  
36.         super();  
37.         this.name = name;  
38.         this.age = age;  
39.     }  
40.     public String getName() {  
41.         return name;  
42.     }  
43.     public int getAge() {  
44.         return age;  
45.     }  
46.     @Override  
47.     public String toString() {  
48.         return "Person [name=" + name + ", age=" + age + "]";  
49.     }  
50.       
51. }  
52. class Student extends Person{  
53.     private int no;  
54.   
55.     public Student(String name, int age, int no) {  
56.         super(name, age);  
57.         this.no = no;  
58.     }  
59.   
60.     @Override  
61.     public String toString() {  
62.         return "Student [no=" + no + ", name=" + name + ", age=" + age + "]";  
63.     }  
64.   
65.       
66.       
67. }  

T 和 ?的区别

？表示任意的都可以，T则是作为参数定义的。

java 泛型中 T 和 问号（通配符）的区别
类型本来有：简单类型和复杂类型，引入泛型后把复杂类型分的更细了；
 
 
现在List<Object>, List<String>是两种不同的类型;且无继承关系；
泛型的好处如：
开始版本
  public void write(Integer i, Integer[] ia);
  public void write(Double  d, Double[] da);
泛型版本
  public <T> void write(T t, T[] ta);
简便了代码
定义泛型
 
 
1.定义在类后面
紧跟类名后面
  public class TestClassDefine<T, S extends T>{}
定义泛型 T, S, 且S 继承 T
2.定义在方法装饰符后面
紧跟修饰符后面（public）
  public <T, S extends T> T testGenericMethodDefine(T t, S s){}
定义泛型 T, S, 且S 继承 T
实例化泛型
 
 
1.实例化定义在类上的泛型
第一声明类变量或者实例化时。例如
     List<String> list;
     list = new ArrayList<String>;
第二继承类或者实现接口时。例如
 public class MyList<E> extends ArrayList<E> implements List<E> {...} 

 
 
2.实例化定义方法上的泛型<br/>
当调用范型方法时，编译器自动对类型参数(泛型)进行赋值，当不能成功赋值时报编译错误
通配符(?)
上面有泛型的定义和赋值；当在赋值的时候，上面一节说赋值的都是为具体类型，当赋值的类型不确定的时候，我们用通配符(?)代替了：
如
 List<?> unknownList;
  List<? extends Number> unknownNumberList;
  List<? super Integer> unknownBaseLineIntgerList; 

 
 

  
  
在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能向其中添加元素， 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL