day20

泛型

概念：所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。

从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List < String >，这表明该List只能保存字符串类型的对象。

JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

好处：

1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。

集合没有泛型时：

集合有泛型时：

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

在集合中使用泛型

@Test
    public void Test01(){
        ArrayList<String> stringArrayList = new ArrayList<String>();
        stringArrayList.add("Hello");
        //编译阶段报错
//        stringArrayList.add(111);
    }

我们看下ArrayList的类名

当我们new ArrayList时候，相应的add方法也只能添加String类型的数据了，new ArrayList只能添加Interge类型的数据了。

自定义泛型结构

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

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

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

4. 泛型不同的引用不能相互赋值。

5. 尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

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

   @Test
       public void Test03(){
           //使用时：new ArrayList<>() != new ArrayList()
           ArrayList<Object> objects = new ArrayList<>();
           //报错
   //        Test(objects);
           //泛型擦除，编译不会类型检查
           ArrayList arrayList = new ArrayList();
           arrayList.add("222");
           arrayList.add(2222222);
           Test(arrayList);
       }
       public static void Test(ArrayList<String> arrayList){
           for (Object s : arrayList) {//可以正常输出，换成String就不行了，泛型更多的针对于编译阶段
               System.out.println(s);
           }
       }
   

7. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

8. jdk1.7，泛型的简化操作：ArrayList< Fruit > flist = new ArrayList<>();

9. 泛型的指定中不能使用基本数据类型，可以使用包装类替换

10. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型

11. 异常类不能是泛型的

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

13. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

    子类不保留父类的泛型：按需实现

    没有类型 擦除

    具体类型

    子类保留父类的泛型：泛型子类

    全部保留

    部分保留

    结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

自定义泛型类

package Test1;

public class Person<E> {
    E e;
    public Person(E e) {
        this.e = e;
    }

    public E getE() {
        return e;
    }
}

package Test1;

public class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

@Test
public void Test02(){
    Person<Student> studentPerson = new Person<>(new Student("张三",11));
    Student e = studentPerson.getE();
    System.out.println(e);//Student{name='张三', age=11}
}

package Test1;

public class Father<K,V> {

}
//不保留泛型
//1.具体类型
class Son extends Father<Integer,Integer>{
}
//2.没有类型擦除
class Son1 extends Father{
}
//子类保留父类的泛型
//保留
class Son2<K,V,A,B> extends Father<K,V>{

}
//部分保留
class Son3<V,A,B> extends Father<String,V>{

}

自定义泛型接口

package Test1;

public interface Father<K,V> {

}
//不保留泛型
//1.具体类型
class Son  implements Father<Integer,Integer>{
}
//2.没有类型擦除
class Son1 implements Father{
}
//子类保留父类的泛型
//保留
class Son2<K,V,A,B> implements Father<K,V>{

}
//部分保留
class Son3<V,A,B> implements Father<String,V>{

}

自定义泛型方法

方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

泛型方法的格式

[访问权限]<泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常

public <T> void swap(T t){

}
public <T> void swap(int t){

}

泛型在继承上的体现

泛型在继承方面的体现

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

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

@Test
public void run01(){
    Object obj = null;
    String str = null;
    obj = str;

    Object arr1[] = null;
    String arr2[] = null;
    arr1 = arr2;
    List<Object> list = null;
    List<String> list1 = new ArrayList<>();
    //报错
    list = list1;
}

通配符的使用

通配符：?

类A是类B的父类，G和G是没有关系的，二者共同的父类是：G<?>

使用类型通配符：？

比如：List<?> ，Map<?,?>List<?>是List、List等各种泛型List的父类。

读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。

写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中添加对象。 唯一的例外是null，它是所有类型的成员。

注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?

注意点2：编译错误：不能用在泛型类的声明上

注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象

ArrayList<?> list2 = new ArrayList();

有限制的通配符

<? extends Number> (无穷小 , Number]只允许泛型为Number及Number子类的引用调用
<? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用
<? extends Comparable>只允许泛型为实现Comparable接口的实现类的引用调用

	@Test
    public void run02(){
        ArrayList<? extends Person> list = new ArrayList<>();
        //报错
//        list.add(new Student("11",11));
        ArrayList<? super Student> list1 = new ArrayList<>();
        list1.add(new Student("11",11));
    }