泛型的一些使用解读

之前发过简单泛型和通配符的使用，这里对泛型的使用做一些总结。

1、泛型的元组：就是可以通过调用一次方法 返回多个对象的东西。大家都知道 返回值只能有一个，怎么样能返回多个不同类型的对象呢，在这里就是用到了元组。
官方定义是： 将一组对象直接打包存储于其中的一个单一对象

使用情况：仅一次方法调用就能返回多个不同类型对象。大家应该经常遇到这样的需求，但是就我们所知的return语句只允许返回单个对象。

解决方案
方案一：直接控制方法值返回Map<String,Object>对象，每次在方法返回对象时，动态创建所需要返回的多个对象的对象Map集合。
方案二：创建一个对象，用它来持有想要返回的多个对象，需要在每次需要的时候，专门创建一个类来完成这样的工作。
方案三：通过泛型的创建一个元组类库，一次性解决该问题，以后可直接使用该类库作为返回对象。同时，我们在编译器就能确保类型安全。

方案一和方案二都是经常会用到的方式，这里我们只看方案三

通常，元组可以具有任意长度，同时，元组对象可以是任意不同的类型，不过我们希望能够为对象指明其类型，并且从容器中读取出来时，可以得到正确的类型，要处理不同长度的问题，需要创建多个不同的元组，如下例子是一个二维选组对象，它可以保存两个任意类型的对象，并且隐含的保持了其中元素的次序。

/**
 * 两对象元组基类
 * @param <A> 泛型对象A
 * @param <B> 泛型对象B
 */
public class Tuple<A, B> {
    private A a;
    private B b;
    public Tuple(A a, B b){
        this.a = a;
        this.b = b;
    }
    public A getA() {
        return a;
    }
    public B getB() {
        return b;
    }
    @Override
    public String toString(){
        return "(" + a + "." + b + ")";
    }
}

我们可以利用继承机制实现长度更长的元组，组成所需要的元组基类。如：

/**
 * 三对象元组基类
 * @param <A> 泛型对象A
 * @param <B> 泛型对象B
 * @param <C> 泛型对象C
 */
public class ThreeTuple<A, B, C> extends Tuple<A, B> {
    private C c;
    public ThreeTuple(A a, B b, C c) {
        super(a, b);
        this.c = c;
    }
    public C getC() {
        return c;
    }
    @Override
    public String toString(){
        return "(" + getA() + "." + getB() + "." + c + ")";
    }
}

在我们使用元组的时候，只需选择长度合适的元组，将其作为方法的返回值，然后在return语句中创建该元组，并返回即可。如：

public class TestTuple {
    /**测试元组
     * @param args
     * @author lihq 2019-7-19
     */
    public static void main(String[] args) {
        Tuple<Test,String> tuple= new TestTuple().returnTuple();
        Test test = tuple.getA();
        String str = tuple.getB();
    }
    public Tuple returnTuple(){
        return new Tuple(new Test(), "str");
    }
}

2、泛型接口：泛型接口和泛型类其实并没有什么太大区别，都是持有对象。

public interface Generic<T>{
    T sky();
}

3、泛型方法：泛型方法有一个基本原则，尽量使用泛型方法而不是泛型类。只要能够用泛型方法达到需求，就应该只用泛型方法，这样能使得代码更加清晰。
泛型方法的定义：泛型参数列表置于返回值前，例如 public <T> void f(T t）

public class GenericMethods {
    public <T> void f(T t){
        System.out.println(t.getClass().getSimpleName());
    }
    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("");
        gm.f(1);
        gm.f(2.0);
        gm.f(2.0f);
        gm.f('a');
        gm.f(gm);
    }
}

运行结果：

4、泛型的类型擦除：下面是一个很经典的例子

List<String> list1 = new ArrayList<String>();
List<Integer> list2 = new ArrayList<Integer>();
System.out.println(list1.getClass() == list2.getClass());

这里的输出结果是什么呢，正确答案是true，明明泛型的类型是不一样的，可是判断结果却相同，这就是泛型的类型擦除带来的效果。

因为在泛型代码内部，无法获取任何有关泛型参数类型的任何信息！Java的泛型就是使用擦除来实现的，当你在使用泛型的时候，任何信息都被擦除，你所知道的就是你在使用一个对象。所以List< Integer>和List< String>在运行时，会被擦除成他们的原生类型List。

在有些时候擦除会导致你无法调用传入类的方法，这时候可以给定泛型的边界。

class Person{
    public void sayHello(){
        System.out.println("Hello World!");
    }
}

class Animal<T extends Person>{
    private T t;
    public Animal(T t){
        this.t = t;
    }
    public void say(){
        //这里如果泛型是<T>的话，虽然调用的时候传进来的是Person，但是在编译的时候这里是Object。
        //而Object是没有sayHello()这个方法的，可以给泛型增加边界，这个边界声明了T必须具有类型Person或者从Person导出的类型。
        t.sayHello();
    }
}

public class Abrasion {
    public static void main(String[] args) {
        Person person = new Person();
        Animal<Person> animal = new Animal<>(person);
        animal.say();
    }
}

泛型的类型擦除带来的一些问题：泛型不能用于显性地引用运行时类型的操作之中，例如转型，instanceof和new操作（包括new一个对象，new一个数组），因为所有关于参数的类型信息都在运行时丢失了，所以任何在运行时需要获取类型信息的操作都无法进行工作。

Object obj = new Object();
if(obj instanceof T);
T t = new T();
T[] ts = new T[10];

使用instanceof会失败，是因为类型信息已经被擦除，因此我们可以引入类型标签Class< T>，就可以转用动态的isInstance()。

class A{}
class B extends A{}
public class TestInstance<T> {
    private Class<T> t;
    public TestInstance(Class<T> t){
        this.t = t;
    }
    public boolean compare(Object obj){
        return t.isInstance(obj);
    }
    public static void main(String[] args) {
        TestInstance<A> ti = new TestInstance<A>(A.class);
        System.out.println(ti.compare(new A()));//true
        System.out.println(ti.compare(new B()));//true
    }
}

5、边界：正是因为有了擦除，把类型信息擦除了，所以，用无界泛型参数调用的方法只是那些可以用object调用的方法。但是，如果给定边界，将这个参数限制为某个类型的子集，就可以使用这些类型子集来调用方法。

interface Dog{
    void shout();
}
public class TestBorder<T extends Dog> {
    T t;
    public TestBorder(T t){
        this.t = t;
    }
    public void test(){
        t.shout();
    }
}

这里，类型T已经可以调用Dog的shout方法了。
当然，也可以指定多个边界

interface Dog{
    void shout();
}
interface Cat{
    void run();
}
interface Pig{
    void eat();
}
public class TestBorder<T extends Dog & Cat & Pig> {
    T t;
    public TestBorder(T t){
        this.t = t;
    }
    public void test(){
        t.shout();
        t.run();
        t.eat();
    }
}

extends 后面跟的第一个边界，可以为类或接口，之后的均为接口。

6、通配符和泛型的上下界：

1.上界< ? extends Class>  

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
public class Test<T>{
    public static void main(String[] args) {
        List<? extends Animal> list = new ArrayList<>();
        //指定了下边界，却不能add任何类型，甚至Object都不行，除了null，因为null代表任何类型。
        //list.add(new Dog());
        //list.add(new Cat());
        //list.add(new Animal());
        //List< ? extends Animal>可以解读为，'具有任何从Animal继承的类型'，但实际上，它意味着，它没有指定具体类型。
        //对于编译器来说，当你指定了一个List< ? extends Animal>，add的参数也变成了'? extends Animal'。
        //因此编译器并不能了解这里到底需要哪种Animal的子类型，因此他不会接受任何类型的Animal。
        list.add(null);

        list.contains(new Dog());
        list.indexOf(new Dog());
        //list.get(0)能够执行是因为，在此list存在时，编译器能够确定它是Animal的子类，所以能够安全获得。(父类引用指向子类对象)
        Animal animal = list.get(0);
    }
}

List<? extends Animal> list 你可以理解为这个list可能是List<Cat>也可能是List<Dog>或是List<Animal>，只要是Animal或其子类就行, 这时候你要存入一个Cat，有可能是往List<Dog>里存，这样是不行的，所以编译器判断不了你这个List是Cat还是Dog还是Animal(因为都可以)，所以就只能什么都不能存(null除外)；

2.下界< ? super Class>

class Animal{}
class Dog extends Animal{}
class Teddy extends Dog{}
class Cat extends Animal{}
public class Test<T>{
    public static void main(String[] args) {
        List<? super Dog> list = new ArrayList<>();
        list.add(new Dog());
        list.add(new Teddy());
        //这句不能编译成功，List<? super Dog>表示'容器内存放的是Dog的所有父类'。
　　　　 //list.add(new Animal());
        Object dog = list.get(0);
    }
}

这个地方实际上很容易让人迷糊，List < ? super Dog>， 代表容器内存放的是Dog的所有父类，所以有多态和上转型，这个容器是可以接受所有Dog父类的子类。（多态的定义：父类可以接受子类型对象）Dog和Teddy都直接或间接继承了Animal，所以Dog和Teddy是能够加入List < ? super Dog>这个容器的。

list.add(new Animal())不能添加，正是因为上一点解释的，容器内存放的是Dog的所有父类，注意 所有 这个词，正是因为能存放所有，Dog的父类可能有Animal， Object等， 所以编译器根本不能识别你要存放哪个Dog的父类，因为这不能保证类型安全的原则。这从最后的Object dog= list.get(0)可以看出。

同理对于List<? super Dog> list，你可以理解为这个list可能是List<Dog>或List<Animal>或List<Object>，所以编译器允许你存Dog或其子类,因为都能向上转型成功，但是你要存Animal就不一定成功了，因为这个List可能是List<Dog>，编译器判断不了。

3.PECS原则

如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
如果既要存又要取，那么就不要使用任何通配符。