20220827学习内容 泛型

不引入泛型的问题：
当将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，
改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

因此取出集合元素时需要人为的强制类型转化到具体的目标类型，但是很容易出现
ClassCastException异常

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时
不出现问题，运行时就不会出现java.lang.ClassCastException异常呢？

答案就是使用泛型，可以将运行时的类型检查搬到编译期实现

什么是泛型
泛型是jdk5引入的类型机制，就是将类型参数化。泛型作为一种安全机制而产生

泛型机制将类型转换时的类型检查从运行时提前到了编译时，使用泛型编写的代码比杂
乱的使用object并在需要时再强制类型转换的机制具有更好的可读性和安全性。

泛型在本质上是指类型参数化。所谓类型参数化，是指用来声明数据的类型本身，也是
可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而
类型参数化，则是实际参数的类型决定了形式参数的类型。

在声明List<E>阶段E是什么类型不确定，这里的E仅仅充当占位符的作用，在具体调用时
类型才能确定，而E的所有位置将被指定的类型所替代

使用泛型的定义

public interface List<E> extends Collection<E>
这里的<>中的内容就是类型参数，一般建议使用T或者E之类的全大写
{
E get(int index);  获取的元素类型就是定义时指定的类型
void add(E element);
}

List<String> list=new ArrayList<String>();就是将String传递给E，用于替代定义中的E
String str=list.get(0); 不需要进行类型转换

List<Date> list=new ArrayList<>();//这里使用菱形语法，支持泛型推导
list.add("abc");//语法报错，编译时就会进行类型检查
list.add(123);//语法报错
list.add(new Date());
for(int i=0;i<list.size();i++){
Date temp=list.get(i);   直接获取目标类型，不需要进行类型转换
System.out.println(temp.getYear()+1900);
}

 典型场景

获取两个整数中较大的整数

Integer max(Integer a, Integer b){ 
return a>b?a:b;      
}

如果需要比较的不是Integer类型，而是Double或是Float类型，那么就需要另外
再写max()方法【方法的重载】。

引入泛型的目的实际上就是能够在编写max()方法时，不必确定参数a和b的数据类
型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()
就可以了，这将大大降低程序员编程的工作量。

Comparable接口---用于类定义中表示当前类型的对象是可比较的，接口中定义了比
较方法，要求具体类型提供实现【具体的比较规则】

Java中有一个系统预定义的接口
public interface Comparable<T> { 用于实现规范类的可比较性
int compareTo(T o);  含义是使用当前对象和参数o对象进行比较
当前类型比较时需要返回一个整数,当当前对象大于参数o时，返回一个正数；如果
等于时则返回0；如果小于时返回一个负数
}

在定义中可以参数Integer类中的方法实现
public final class Integer  最终类表示Integer不能被继承 
extends Number  所有的系统预定义的数值类型包装类都继承与Number
implements Comparable<Integer>  实现了可比较的接口，当前类不是抽象类，所以必须提供compareTo方法的实现

public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}

public static int compare(int x, int y){
return (x<y)?-1:((x==y)?0:1);
}

针对获取两个对象之间最大的对象的方法
 

public class MyTest {
//泛型方法的语法规则：要求在使用T之前进行声明
//针对泛型有个约束extends，要求传入的T对象的类型必须实现Comparable接口
public static <T extends Comparable<T>> T max(T t1, T t2) {
return t1.compareTo(t2) > 0 ? t1 : t2; 正式因为要求出入的T必须实现Comparable接口，
所以这里才可以直接调用Comparable接口中的方法
}
}

泛型方法的调用
参与比较的是Integer类型
Integer kk=MyTest.max(12, 15);
System.out.println(kk);
参与比较的是Double类型，不需要重新定义方法
Double dd=MyTest.max(12.345, 555.34);
System.out.println(dd);

在泛型出现之前，Java的程序员可以采用一种变通的办法：将参数的类型均声明为Object类型。
由于Object类是所有类的父类，所以它可以指向任何类对象，但这样做不能保证类型安全。泛型
则弥补了Object做法所缺乏的类型安全，也简化了过程，不必显示地在Object与实际操作的数据
类型之间进行强制转换。通过泛型，所有的强制类型转换都是自动和隐式的。因此，泛型扩展了
重复使用代码的能力，而且既安全又简单。

使用泛型的好处：
- 解决类型安全隐患，泛型的类或接口在取出对象时将不需要再进行向下类型转换，因为存储的
时候就是该类型。
- 泛型的使用让安全问题在编译时就报错而不是运行后抛出异常，这样便于程序员及时准确地发
现问题
- 使用泛型只是带来了附加的类型安全。因为编译器知道将放进集合的类型的更多信息，所以类
型检查从执行时挪到了编译时，这会提高可靠性并加快开发速度

 通配符参数
使用一般用于接收参数 
void doSomething(Stats<?> ob) 表示这个参数ob可以是任意的Stats类型。
其中？表示一个不确定的类型，它的值会在调用时确定下来。 

List<?> list = new ArrayList<String>();注意不能写成List<Object> list=new ArrayList<String>() 

public class Test{
    public void pp(List<?> list){
        list.add("123"); //语法报错
    }
    public static void main(String[] args){
        List<String> list=new ArrayList<>();
        list.add("bbbb");
        Test t=new Test();
        t.pp(list);
    }
}

这里的List<?>中的?表示可以传人任意的类型参数，其中List<?> list可以匹配任意参数化的类型，
但是到底匹配的是什么类型，只有以后才知道，所以cols=new ArrayList<Integer>和cols = 
new ArrayList<String>都可以， 但是cols.add("abc")或cols.add(new Date())都不行

public static void printCollection(Collection<?> collection){
    for(Object obj:collection)    
        System.out.println(obj);
       //collection.add("abc");//报错，因为collection不知道未来匹配的一定是String类型
      collection.size();//不报错，此方法与参数类型没有关系
      collection=new HashSet<Date>();//这是可以的
}

基础语法

总结泛型类

public class A<T,ID>{
  private ID id;
  private T name;
}

定义泛型接口 

public interface IA<T>{
   public T pp();
}

定义泛型类上给泛型添加约束 

public class MyClass<T extends IA>{}

在泛型类或者泛型接口中不允许直接使用super
// 在这里, Integer 可以认为是 Integer 的 "父类"
List<? super Integer> array = new ArrayList<Integer>();
// Number 是 Integer 的 父类
List<? super Integer> array = new ArrayList<Number>();
// Object 是 Integer 的 父类
List<? super Integer> array = new ArrayList<Object>();

如果要求泛型实现两个或者两个以上的接口

public class MyClass<T extends 接口1 & 接口2>{}
要求传入的类型T必须同时实现了接口1和接口2 

如果要求泛型必须继承B类，同时实现IC接口
public class MyClass<T extends B & IC >{}
如果要求泛型继承一个类并且实现接口
public class MyClass<T extends 类型 & 接口>{}
<? extends T>只能用于方法返回，告诉编译器此返参的类型的最小继承边界为T，
T和T的父类都能接收，但是入参类型无法确定，只能接受null的传入
<? super T>只能用于限定方法入参，告诉编译器入参只能是T或其子类型，而返参只能用Object类接收
- `?`既不能用于入参也不能用于返参
- 频繁往外读取内容的，适合用上界extends
- 经常往里插入的，适合用下界Super

泛型方法：

所谓泛型方法，就是带有类型参数的方法，它既可以定义在泛型类中
例如public void show(T aa)，在使用泛型上没有任何特殊语法要求），
也可以定义在普通类中（需要自定义参数类型，那么把泛型参数放在方法上
就可以了，就是放在返回值类型之前，例如public <T> void show(T aa)）, 
静态方法不能访问类的泛型，如果需要泛型只能在方法上使用泛型，例如
public static <T> void show(T aa)