Java面向对象11-泛型与通配符

泛型：就是一种不确定的数据类型。
比如：ArrayList<E> E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
泛型可以省略，如果省略，默认泛型是Object类型。


自定义泛型类

 1 package com;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 //自定义泛型类
 7 public class order<T> {
 8     private String orderName;
 9     private int orderId;
10     private T t;
11     List<T> list = new ArrayList<T>();
12     public void add(){
13         list.add(t);
14     }
15     public T getT(){
16         return t;
17     }
18     public void setT(T t){
19         this.t = t;
20     }
21     public String getOrderName() {
22         return orderName;
23     }
24     public void setOrderName(String orderName) {
25         this.orderName = orderName;
26     }
27     public int getOrderId() {
28         return orderId;
29     }
30     public void setOrderId(int orderId) {
31         this.orderId = orderId;
32     }
33     @Override
34     public String toString() {
35         return "order [orderId=" + orderId + ", orderName=" + orderName
36                 + ", t=" + t + "]";
37     }
38     
39     
40 }

 

注意：

1.在静态方法中不能使用泛型，因为静态方法早于对象创建执行

2.异常类不能是泛型的

 

泛型在继承方面的体现

类A是类B的父类，G<A>和G<B>二者不具备子父类关系，二者是并列关系。

补充：类A是类B的父类，A<G> 是 B<G>的父类

 

通配符？的使用：

 1 import org.w3c.dom.ls.LSInput;
 2 
 3 import java.util.Iterator;
 4 import java.util.List;
 5 
 6 public class test {
 7     public static void main(String[] args) {
 8         List<Object> list1 = null;
 9         List<String> list2 = null;
10 
11         List<?> list = null;
12 
13         list = list1;
14         list = list2;
15 
16         test t = new test();
17         t.show(list1);
18         t.show(list2);
19     }
20 
21     public void show(List<?> list){
22         Iterator<?> iterator = list.iterator();
23         while(iterator.hasNext()) {
24             Object obj = iterator.next();
25             System.out.println(obj);
26         }
27     }
28 
29 }

添加（写入）：对于List<?>不能向起内部添加数据，null除外

获取（读取）：允许读取数据，读取的数据类型为object

 

有限制条件的通配符的使用

 

? extends T ----- 类型上界

这个时候这个通配符可以配的范围就是 T类型对象和T类型子类的对象
形象的也可以看成是 : (-oo , T];
就是负无穷到T — 把T包含在内
那么这个时候G<? extends A>就可以作为G< A>和G< B>的父类,其中A是B的父类

? super T — 类型下界

这个时候这个通配符可以配的范围就是T类型的对象和T类型的父类的对象
形象的说也可以看成是: [T , +oo)
也就是T到正无穷
那么这时候G<? super A> 就可以作为G< A>和G < C>的父类,其中A是C的子类

 

 1  /*
 2     有限制条件的通配符的使用
 3     ? extends A:
 4     G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类
 5     ? super A:
 6     G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类
 7      */
 8     @Test
 9     public void test4(){
10         List<? extends Person> list1 = null;//<=
11         List<? super Person> list2 = null;//>=
12  
13         List<Student1> list3 = new ArrayList<Student1>();
14         List<Person> list4 = new ArrayList<Person>();
15         List<Object> list5 = new ArrayList<Object>();
16  
17         list1 = list3;
18         list1 = list4;
19 //        list1 = list5;
20  
21 //        list2 = list3;
22         list2 = list4;
23         list2 = list5;
24  
25         //读取数据：
26         list1 = list4;
27         Person p = list1.get(0);
28         //编译不通过
29 //        Student1 s = list1.get(0);
30  
31         list2 = list4;
32         Object o = list2.get(0);
33         //编译不通过
34 //        Person o = list2.get(0);
35  
36         //写入数据:
37         //编译不通过
38 //        list1.add(new Student1());
39  
40         //编译通过
41         list2.add(new Person());
42         list2.add(new Student1());
43  
44     }

 

标签：11,Java,list1,List,list2,泛型,父类,public
来源： https://www.cnblogs.com/zyx9710/p/16280259.html