泛型引入背景

当我们调用一个方法的时候，有时候要传参数给方法，但是在调用方法之前我们需要对方法的接受参数类型进行确定，这在设计系统时是有局限性的。试想方法在被调用的时候根据传入的参数类型来确定接受类型，这将大大的提高代码的扩展性，因此有必要了解一下泛型的相关概念。

泛型基本概念

    //泛型机制：JDK1.5之后引入的一个概念
    //把类型明确工作，推迟到创建对象，或调用方法时，才去明确的一种机制。
    //泛型的语法：<数据类型,数据类型>
    //泛型可以加在 接口上，类型，方法上
    //泛型的好处：1.避免了向下转型，2.将问题提前到了编译期
    //泛型的特点：泛型只在编译期有效，在运行期就擦除了。
    //泛型可以限定，我这个集合中存储什么样的引用数据类型
    //JDK1.7之前 泛型前面后面都得写上，JDK1.7可以省略右半边不写

泛型避免向下转型实例

 ArrayList list2 = new ArrayList();
        list2.add("aaaaa");
        list2.add("bbbb");
        list2.add("ccc");
        list2.add("ddd");

        Object obj = list2.get(0);
        String string= (String) obj;   //向下转型
        int length = string.length();

        ArrayList<String> list3= new ArrayList(); //<String>就是泛型
        list3.add("aaaaa");
        list3.add("bbbb");
        list3.add("ccc");
        list3.add("ddd");

        String s = list3.get(0);    //加入泛型后，返回的就是输入的准确类型
        System.out.println(s);

把泛型加在类上

public class MyClass<T> { //泛型<T>  泛型必须是引用数据类型
    T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

泛型加在接口上

public interface MyInterface<T,U,R> { //泛型接口
    public R show(T t,U u);
}
 //接口上的泛型，在你创建该接口的子类对象时，必须要明确这个泛型，具体是什么数据类型
        MyDemo2<Integer, String, String> integerStringStringMyDemo2 = new MyDemo2<>();

        Collection<Integer> collection=new ArrayList<Integer>();
            //匿名内部类 在创建接口的子类对象时，就必须明确接口上的泛型，到底是什么类型
        new MyInterface<String,String,String>(){
            @Override
            public String show(String s, String s2) {
                return null;
            }
        };

//泛型接口上的泛型，什么时候明确，你可以在子类里面去明确
public class MyDemo implements MyInterface<String,Integer,Integer>{
    @Override
    public Integer show(String s, Integer integer) {
        return null;
    }
}

泛型通配符

A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E: 向下限定，E及其子类
C:? super E: 向上限定，E及其父类

public class MyTest {
    public static void main(String[] args) {
      //  ArrayList<Animal> objects = new ArrayList<Dog>(); //报错 前后泛型一致
        //? 泛型统配符
        ArrayList<?> objects = new ArrayList<Dog>(); //

        //向上限定<? super Cat>
        //后面只能写该类的父类，或该类本身
        ArrayList<? super Cat> objects2 = new ArrayList<Cat>(); //
        //<? extends Animal> 向下限定，后面只能写该类的子类，或该类本身
        ArrayList<? extends Animal> objects3 = new ArrayList<Cat>(); //

        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        ArrayList<Integer> integers2 = new ArrayList<>();
        integers2.add(100);
        integers.addAll(integers2);
    }
}

class Animal{
}
class Dog extends Animal{
}
class Cat extends Animal{
}