Java的泛型相关知识

一、泛型

没有使用泛型之前，若向集合中添数据，可以添加的是任意引用类型的数据。如下：

	//al：一个存放学生成绩的集合
	ArrayList al = new ArrayList();
	al.add(11);
	al.add(10);
	al.add('c');
	al.add("oo");

此时会使得这个集合达不到预期只存成绩的目的。
使用泛型之后，可以确定集合中存放数据的类型。在编译期间就会对类型进行检查，不是泛型对应的类型就不可以添加到这个集合当中，并且遍历时可以直接使用指定类型进行遍历。如下：

	ArrayList<Integer> al = new ArrayList<>();
    al.add(11);
    al.add(10);
//  al.add('c');
//  al.add("oo");
    for(Integer i : al)
    	System.out.println(i);

注：泛型的类型都是引用数据类型，不能是基本数据类型！

---

二、自定义泛型结构

1、泛型类的定义和实例化

/**
 * GenericTest：一个普通的类
 * GenericTest<E>：一个泛型类
 * <>里面就是一个参数类型，目前里面是不确定的，仅相当于一个占位，
 * 但这个地方一定是一个引用数据类型，而不是基本数据类型
 */
public class GenericTest<E> {
    int age;
    double number;
    E unknown;
     public void method1(E e){
         
     }
     
     public void method2(E[] e){
         
     }
}

class Test{
    public static void main(String[] args) {
        //（1）实例化的时候不指定泛型：如果实例化的时候不明确指定类的泛型，默认为Object类型
        GenericTest gt1 = new GenericTest();
        gt1.method1("aa");
        gt1.method1(9.8);
        gt1.method2(new String[]{"a", "b", "c"});

        //（2）实例化时指定泛型
        GenericTest<String> gt2 = new GenericTest<>();
        gt2.unknown = "已知";
        gt2.method1("aa");
        gt2.method2(new String[]{"a", "b", "c"});
    }
}

---

2、继承

（1）父类指定泛型

父类泛型确定时，子类就不需要再指定泛型，可以直接使用。

class SubGenericTest extends GenericTest<Integer>{
    
}
class Test{
    public static void main(String[] args) {
        SubGenericTest sgt = new SubGenericTest();
        sgt.method1(98);
    }
}

（2）父类不指定泛型

父类不指定泛型，那么子类也会变成一个泛型类，那这个E的类型可以在创建子类对象的时候确定。

class SubGenericTest<E> extends GenericTest<E>{

}
class Test{
    public static void main(String[] args) {
        SubGenericTest<String> sgt = new SubGenericTest<>();
        sgt.method1("yoho");
        sgt.unknown = "woow";
    }
}

---

3、一些细节问题

（1）泛型类可以定义多个参数类型。例如：

public class GenericTest<A,B,C> {
    A a;
    B b;
    C c;
    
    public void method1(A x, B y, C z){
        
    }
}

（2）泛型类的构造器的写法：不能在构造器加泛型。

（3）不同的泛型的引用类型不能相互赋值（在编译期就会报错）。

（4）泛型如果不指定，那么就会被擦除，泛型对应的类型为Object类型。

（5）泛型类中的静态方法不能使用泛型。
因为静态方法在没有创建对象之间就已经被加载到内存中，而没有创建对象时无法指定泛型的具体类型。

（6）不能直接使用E[]数组的创建

---

4、泛型方法

不是带泛型的方法就是泛型方法，泛型方法要求这个方法的泛型的参数类型要和当前的类的泛型无关。或者说，泛型方法对应的那个泛型参数类型和当前所在的这个类是否是泛型类以及泛型是什么都无关。

public class GenericTest<A,B,C> {
    //不是泛型方法
    public void method1(A a){
        
    }
    
    //是泛型方法
    public <T> void method2(T t){
        
    }
}

class Test{
    public static void main(String[] args) {
        GenericTest<String> gt = new GenericTest<>();
        gt.method1("aa");
        gt.method2("bb");
        gt.method2(98);
        gt.method2(true);
    }
}

1、如上，泛型方法定义的时候，前面要加<T>。因为，如果不加的话，T会被当成是一种数据类型，然而代码中没有T类型，此时就会报错。
2、T的类型在调用方法时确定；
3、泛型方法可以是静态方法。

---

5、泛型参数存在继承关系的情况

class Test{
    public static void main(String[] args) {
        Object obj = new Object();
        String s = new String();
        obj = s;                //多态的一种形式
        
        Object[] objArr = new Object[10];
        String[] strArr = new String[10];
        objArr = strArr;        //也是多态的一种形式

        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        list1 = list2;	//报错
    }
}

A和B是子类和父类的关系，但G<A>和G<B>不存在继承关系，二者是并列关系。

---

6、通配符

（1）在没有通配符的情况
下面的method方法相当于方法的重复定义，会直接报错！

public class GenericTest{
    public void method(List<Object> list){

    }

    public void method(List<Integer> list){

    }

    public void method(List<String> list){

    }
}

（2）引入通配符(?)之后
如下，G<?>变成了G<A>和G<B>的父类。

class Test{
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();

        List<?> list = new ArrayList<>();
        list = list1;
        list = list2;
        list = list3;
    }
}

（3）代码示例：

public class GenericTest{
//    public void method(List<Object> list){
//
//    }
//    public void method(List<Integer> list){
//
//    }
//    public void method(List<String> list){
//
//    }
    public void method(List<?> list){
        //内部遍历时用Object即可，不用?
        for(Object obj : list){
            System.out.println(obj);
        }
        
		//数据的写入操作
        //list.add("abc");     报错，不能随意添加数据
        list.add(null);
        
        //数据的读取操作
        Object obj = list.get(0);
    }
}

class Test{
    public static void main(String[] args) {
        GenericTest gt = new GenericTest();
        gt.method(new ArrayList<String>());
        gt.method(new ArrayList<Integer>());
        gt.method(new ArrayList<Object>());
    }
}

---

7、泛型受限

泛型的上限和下限。

public class test01 {
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<>();
        List<Person> list2 = new ArrayList<>();
        List<Student> list3 = new ArrayList<>();
        /*开始使用泛型受限：泛型的上限
        List<? extends Person>就相当于：
        List<? extends Person>是List<Person>的父类，是List<Person的子类>的父类
         */
        List<? extends Person> testList1 = new ArrayList<>();
        //testList1 = list1;
        testList1 = list2;
        testList1 = list3;

        /*开始使用泛型受限：泛型的下限
        List<? super Person>就相当于：
        List<? super Person>是List<Person>的父类，是List<Person的父类>的父类
         */
        List<? super Person> testList2 = new ArrayList<>();
        testList2 = list1;
        testList2 = list2;
        //testList2 = list3;
    }
}