泛型<>

https://zhuanlan.zhihu.com/p/382239048
https://blog.csdn.net/qq_27093465/article/details/73249434

泛型<>

1. 为什么使用泛型

早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
通过泛型确定对象的类型，如果有类型转换错误，在编译阶段语法检查就会检出，这样可以避免了我们类型强转时出现异常

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，
JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。
Collection<E>, List<E>， ArrayList<E> 这个<E>就是类型参数，即泛型。

2. 什么是泛型

泛型：是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。

注意:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

泛型实际就是一个<>引起来的参数类型，这个参数类型具体在使用的时候才会确定具体的类型。相当于一个占位，让代码可以适应多种类型。；

使用了泛型以后，可以确定集合中存放数据的类型，在编译时期就可以检查出来；

泛型本质是obejct类型，是引用类型，引用类型保存的是一个对象的内存地址，所以泛型的类型：必须是引用数据类型，不能是基本数据类型；

使用泛型的好处

避免了类型强转的麻烦。
它提供了编译期的类型安全，确保在泛型类型（通常为泛型集合）上只能使用正确类型的对象，避免了在运行时出现ClassCastException。

泛型的使用

泛型虽然通常会被大量的使用在集合当中，但是我们也可以完整的学习泛型只是。泛型有三种使用方式，分别为：泛型类、泛型方法、泛型接口。将数据类型作为参数进行传递。

4.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种集合框架容器类，如：List、Set、Map。

泛型类的定义格式：
修饰符 class 类名<代表泛型的变量> {  }

/**
 * @param <T> 这里解释下<T>中的T:
 *           此处的T可以随便写为任意标识，常见的有T、E等形式的参数表示泛型          
 */
public class GenericsClassDemo<T> {
 //t这个成员变量的类型为T,T的类型由外部指定
 private T t;

 //泛型构造方法形参t的类型也为T，T的类型由外部指定
 public GenericsClassDemo(T t) {
 this.t = t;
    }

 //泛型方法getT的返回值类型为T，T的类型由外部指定
 public T getT() {
 return t;
    }
}

泛型在定义的时候不具体，使用的时候才变得具体。在使用的时候确定泛型的具体数据类型。
即：在创建对象的时候确定泛型。
例如：Generic<String> genericString = new Generic<String>("helloGenerics");
此时，泛型标识T的类型就是String类型，那我们之前写的类就可以这么认为：
public class GenericsClassDemo<String> {
 private String t;

 public GenericsClassDemo(String t) {
 this.t = t;
    }

 public String getT() {
 return t;
    }
}
当你的泛型类型想变为Integer类型时，也是很方便的。直接在创建时，T写为Integer类型即可：
Generic<Integer> genericInteger = new Generic<Integer>(666);

注意：定义的泛型类，就一定要传入泛型类型实参么？
并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。即跟之前的经典案例一样，没有写ArrayList的泛型类型，容易出现类型强转的问题。

泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型 。

定义格式：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如：
/**
 *
 * @param t 传入泛型的参数
 * @param <T> 泛型的类型
 * @return T 返回值为T类型
 * 说明：
 *   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *   2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *   3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *   4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
 */
 public <T> T genercMethod(T t){
 System.out.println(t.getClass());
 System.out.println(t);
 return t;
    }

调用方法时，确定泛型的类型
public static void main(String[] args) {
 GenericsClassDemo<String> genericString = new GenericsClassDemo("helloGeneric"); 
 String str = genericString.genercMethod("hello");//传入的是String类型,返回的也是String类型
 Integer i = genericString.genercMethod(123);//传入的是Integer类型,返回的也是Integer类型
}

这里可以看出，泛型方法随着我们的传入参数类型不同，他得到的类型也不同。泛型方法能使方法独立于类而产生变化。

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中。

定义格式
修饰符 interface接口名<代表泛型的变量> {  }

看一下下面的例子，你就知道怎么定义一个泛型接口了：
/**
 * 定义一个泛型接口
 */
public interface GenericsInteface<T> {
 public abstract void add(T t); 
}

使用格式

指定父类泛型，那么子类就不需要再指定泛型了，可以直接使用
如果父类不指定泛型，那么子类也会变成一个泛型类，那这个T的类型可以在创建子类对象的时候确定

1、定义类时确定泛型的类型
public class GenericsImp implements GenericsInteface<String> {
 @Override
 public void add(String s) {
 System.out.println("设置了泛型为String类型");
    }
}

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
public class GenericsImp<T> implements GenericsInteface<T> {
 @Override
 public void add(T t) {
 System.out.println("没有设置类型");
    }
}

确定泛型：
public class GenericsTest {
 public static void main(String[] args) {
 GenericsImp<Integer> gi = new GenericsImp<>();
 gi.add(66);
    }
}

经典应用就是集合

泛型类和泛型接口细节：

泛型类可以定义多个参数类型
泛型类的构造器不能有多个不确定类型参数
不同的泛型的引用类型不可以相互赋值

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

// ？代表可以接收任意类型
// 泛型不存在继承、多态关系,泛型左右两边要一样
//ArrayList<Object> list = new ArrayList<String>();这种是错误的

//泛型通配符?:左边写<?> 右边的泛型可以是任意类型
ArrayList<?> list1 = new ArrayList<Object>();
ArrayList<?> list2 = new ArrayList<String>();
ArrayList<?> list3 = new ArrayList<Integer>();

注意：泛型不存在继承、多态关系,泛型左右两边要一样，jdk1.7后右边的泛型可以省略

而泛型通配符?，右边的泛型可以是任意类型。

泛型通配符?主要应用在参数传递方面

public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    test(list1);
    ArrayList<String> list2 = new ArrayList<String>();
    test(list2);
}

public static void test(ArrayList<?> coll){
}

通配符高级使用

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

泛型的下限：

格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

比如：现已知Object类，Animal类，Dog类，Cat类，其中Animal是Dog，Cat的父类

class Animal{}//父类

class Dog extends Animal{}//子类

class Cat extends Animal{}//子类

泛型的上限<? extends 类 >：
//        ArrayList<? extends Animal> list = new ArrayList<Object>();//报错
 ArrayList<? extends Animal> list2 = new ArrayList<Animal>();
 ArrayList<? extends Animal> list3 = new ArrayList<Dog>();
 ArrayList<? extends Animal> list4 = new ArrayList<Cat>();
可以看出，泛型的上限只能是该类型的类型及其子类。

泛型的下限<? super 类 >：
 ArrayList<? super Animal> list5 = new ArrayList<Object>();
 ArrayList<? super Animal> list6 = new ArrayList<Animal>();
//        ArrayList<? super Animal> list7 = new ArrayList<Dog>();//报错
//        ArrayList<? super Animal> list8 = new ArrayList<Cat>();//报错
可以看出，泛型的下限只能是该类型的类型及其父类。

一般泛型的上限和下限也是用来参数的传递：
再比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}