泛型

引入

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException（强制转型异常）

参数化类型：把类型当作是参数一样传递

相关术语：

• ArrayList<E>中的E称为类型参数变量

• ArrayList<Integer>中的Integer称为实际类型参数

• 整个称为ArrayList<E>泛型类型

• 整个ArrayList<Integer>称为参数化的类型

泛型的作用

容器类中使用泛型

• 避免继承着同一父类或借口的类的实例混杂在容器里面（多态）
• 无需确定容器中储存对象的类型
• 节省代码，功能相同但储存对象不同的容器类实现公用，功能由父类定义

方法中使用泛型

• 节省代码，功能相同但传参和返回值不同的方法实现公用

接口中使用泛型

• 将容器泛型和方法泛型整合
• 任何一个实现该接口的类都要实现接口中定义的泛型方法
• 而且方法的泛型随类实现时确定的泛型而变

泛型的使用格式（代码实现）

容器类中使用泛型

public class TestGenerics {
    public static void main(String[] args){
        MyObject<Integer> mo=new MyObject();//实例化一个储存Integer对象的容器
        mo.set(34,0);
        //mo.set("abc",0);无法存入String对象
        System.out.println(mo.get(0).intValue()+6);//可以直接调用不需要再强转
        MyObject<String> no=new MyObject();//实例化一个储存String对象的容器，类似
        no.set("abc",0);
        System.out.println(no.get(0).charAt(1));
    }
}
//定义一个泛型容器
class MyObject<E>{
    //使用Object类型的数组来存储对象，所有类型的对象都可以储存
    Object[] ob=new Object[10];
    //设置加入元素的方法
    public void set(E a,int index){
        ob[index]=a;
    }
    //设置取出元素的方法
    public E get(int index){
        return (E)ob[index];//这里的强转使取出时不需查找类型再次强转
    }
}

方法中使用泛型

public class TestGenerics02 {
    public static void main(String[] args){
        show(123);
        show("erf");
    }
    //定义泛型方法
    public static <E>void show(E e){
        System.out.println(e);
    }
}

泛型实现接口

public class TestGenerics03 {
    public static void main(String[] args){
        MyShow<String>[] str=new MyShow[3];
        str[0]=new MyString("afd");//只能存MyString
        str[1]=new MyString("afv");
        str[2]=new MyString("tds");
        MyShow<Integer>[] in=new MyShow[3];
        in[0]=new MyInteger(42);//只能存MyInteger
    }
}
interface MyShow<E>{
    public abstract E show(E e);
}
class MyString implements MyShow<String>{
    String st;
    public MyString(String s){
        this.st=s;
    }
    @Override
    public String show(String s) {
        return s;
    }
}
class MyInteger implements MyShow<Integer>{
    int in;
    public MyInteger(int in){
        this.in=in;
    }
    @Override
    public Integer show(Integer integer) {
        return integer;
    }
}

也就两个优点结合在一起（反而不能当容器了。。。）