java中的泛型

前言

从leetcode刷题中的一个小例子谈起，假设为了题目的需要，我们需要声明一个保存链表节点的堆栈，并且相应的入栈出栈

\*
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
*\
Stack help=new Stack();
help.push(head);
...
ListNode temp=help.pop(); 

上面的代码会报错
Object can not converted to ListNode

在有泛型类之前，我们只能使用Object编写适用于多种类型的代码。
java的泛型有好处也有相应的局限性。

在java实现泛型之前，泛型程序设计的功能使用继承来实现的
比如说ArrayList类

public class ArrayList // before generic classes
{
	private Object[] elementData;
	...
	public Object get(int i){...}
	public void add(Object o){...}
}

存在的问题：
获取特定值时必须进行类型转换

ArrayList files=new ArrayList();
String filename=(String) files.get(0);

没有错误检查,强制类型转换有时会产生错误。
泛型提供类型参数(type parameter),ArrayList有一个类型参数来指示元素的类型

var files=new ArrayList<String>();

泛型在集合、迭代器中的使用

集合接口或集合类在jdk5.0都修改为带泛型的结构。
在实例化集合类时，可指明具体的泛型类型，编译器在编译时就会进行类型检查，保证数据的安全。
注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
举两个例子：
以ArrayList为例

ArrayList<Integer> list=new ArrayList<>();
list.add(123);
list.add(234);
list.add("123");//编译器会自动报错
Iterator<Integer>iterator=list.iterator();
while(iterator.hasNext()){
int stuScore=iterator.next();
System.out.println(stuScore);
}

以HashMap为例

Map<String,Integer> map=new HashMap<>();
map.put("Tom",1);
map.put("Bob",2);
map.put("cillian",3);
//这里对于Set泛型中应该写什么，注意我们上面说过一句话，泛型中写的都是类，而在Map集合中有一个内部类Map.Entry
Set<Map.Entry<String,Integer>> entry=map.entrySet();
Iterator<Map.Entry<String,Integer>> iterator=entry.iterator();
while(iterator.hasNext())
{
	Map.Entry<String,Integer> e=iterator.next();
	String key=e.getKey();
	Integer value=e.getValue();
}

泛型类、泛型接口、泛型方法

泛型类与泛型接口都比较好理解。
值得注意的是对于子父类继承的情况。

public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类
}

由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
}

相关的注意事项：

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
   <E1,E2,E3>

2. 泛型类的构造器不使用泛型标识,泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass(){}

3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致

4. 泛型不同的引用不能相互赋值。(引用类型地址性的赋值也不行）

5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。

6. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
   原因：我们的泛型是在创建对象的时候才指定的，而静态方法的创建要早于对象的创建，异常类(Exception)不能是泛型的

不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。

8. 子类对父类的保留，几乎任何都可以。
   父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

泛型方法

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

public static <E>  List<E> copyFromArrayToList(E[] arr){

ArrayList<E> list = new ArrayList<>();

for(E e : arr){
   list.add(e);
}
return list;

}

测试类中的泛型方法,泛型方法在具体调用的时候，可以用不同的类型为形参，而且

//测试泛型方法
@Test
public void test4(){
  Order<String> order = new Order<>();
  Integer[] arr = new Integer[]{1,2,3,4};
  String[] arrs = new String[]{"Tom","cillian","Bob"}; 
  //泛型方法在调用时，指明泛型参数的类型。
  List<Integer> list = order.copyFromArrayToList(arr);
  List<String> list1 = order.copyFromArrayToList(arrs);
  System.out.println(list);
  System.out.println(list1);
}

泛型中的继承

如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的
类或接口，G<B>并不是G<A>的子类型！
比如：String是Object的子类，但是List<String >并不是List<Object>
的子类,两者不能赋值。
但是： 类A是类B的父类，A<G> 是 B<G> 的父类

   AbstractList<String> list1 = null;
   List<String> list2 = null;
   ArrayList<String> list3 = null;

   list1 = list3;
   list2 = list3;

这可以看成泛型的一个局限。

通配符

通配符:?
作用：作为通用父类
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

 List<Object> list1 = null;
 List<String> list2 = null;
 List<?> list = null;
 list = list1;
 list = list2;
print(list1);
print(list2);
    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

添加(写入)：对于List<?>就不能向其内部添加数据,除了添加null。
获取：允许读取数据，读取的数据类型为Object。

list.add(null);
Object o = list.get(0);
System.out.println(o);

有限制条件的通配符

通配符指定上限
上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
通配符指定下限
下限super：使用时指定的类型不能小于操作的类，即>=
? extends A:
G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

? super A:
G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类

 List<? extends Person> list1 = null;
 List<? super Person> list2 = null;

 List<Student> list3 = new ArrayList<Student>();
 List<Person> list4 = new ArrayList<Person>();
 List<Object> list5 = new ArrayList<Object>();
 
list1 = list3;
list1 = list4;
//        list1 = list5;

//        list2 = list3;
list2 = list4;
list2 = list5;

//读取数据：
list1 = list3;
Person p = list1.get(0);
//编译不通过
//Student s = list1.get(0);

list2 = list4;
Object obj = list2.get(0);
编译不通过
//        Person obj = list2.get(0);
//写入数据：
//编译不通过
//        list1.add(new Student());
//编译通过
list2.add(new Person());
list2.add(new Student());