泛型

什么是泛型？

泛型，即‘参数化类型’，顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

为什么要使用泛型？

先看一个例子：

    List list = new ArrayList();
    list.add("abc");
    list.add(1);

    for (Object o : list) {
        String str = (String)o;
        System.out.println(str.length());
    }

在这个小Demo运行的结果：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
现以这样的结果不是我们想要的，但是如何避免这样的错误呢？

所以这个时候，就要使用泛型了：

    List<String> list = new ArrayList<>();
    list.add("abc");
    //list.add(1);  //报错，不能添加非字符串类型
    list.add("efg");

我们在声明的时候，加上泛型，是一个字符串类型，所以如果使用这个集合添加别的类型的值，他就会报错，并且还是在编译阶段就报错。

所以使用泛型可以有效有避免在编译中所遇到的错误，可以快速的发现错误并修改。

泛型的特性

下面有一个例子，在家猜一下答案：

    List<String> stringList = new ArrayList<>();
    List<Integer> integerList = new ArrayList<>();
    System.out.println(stringList.equals(integerList));

上面这一段代码中，定义了两个集合，然后集合中都没有存储数据，但是他们的泛型是不一样的，最后比较一下，他们的结果：true。

这就是泛型的特性，泛型的擦除 ，泛型只在译编阶段有效果，在编译的时候，只要编译正确就会将泛型的相关信息给擦除了，所以说泛型的信息不会进入到运行阶段。

当然，有的时候，定义泛型之后，还需要存储别的类型，这个时候，可以使用反射来往容器里面存数据。

泛型的分类

泛型分为三种：泛型类，泛型接口，泛型方法。
泛型常见的字母：

T Type 表示类型。
K 代表键值对中的Key
V 代表键值对中的Value
E 代表Element
？表示不确定类型

泛型类

定义一个泛型类：

    public class Student<T> {
        T id;

        public T getId(T id) {
            return id;
        }

        public void setId(T id) {
            this.id = id;
        }
    }

使用：

    Student<Integer> stu = new Student<>();
    stu.setId(1);
    Integer id = stu.getId();
    System.out.println(id);    //1

    Student<String> stuStr = new Student<>();
    stuStr.setId("10001");
    String strid = stuStr.getId();
    System.out.println(strid);  //10001
    
    Student stuStr = new Student);
    stuStr.setId("2222");
    Object objid  = stuStr.getId();
    System.out.println(objid);  //2222

在上面的例子中，我们可以看到，使用不同的泛型声明对象，存进去和取出来的id类型是不是一样的，并且，如果没有定义泛型，默认的就是Object类型。就是一种泛型的擦除。如果定义的话，那么所有的Student类里面的<T>都会替换成声明进修的类型。

泛型类的继承

在泛型的继承里面，重写的方法都是由父类的泛型所决定的，如果父类没有决定泛型，那么子类也不可以指定泛型，如果父类和子类都没有指定泛型，那么<T>就会由Object来代替。在子类里面定义属性的时候，是根据子类的泛型的。
父类指定泛型

    class Test extends Student<String>{
        @Override
        public String getId() {
            return super.getId();
        }

        @Override
        public void setId(String id) {
            super.setId(id);
        }
    }

父类子类都没有泛型

    class Test1 extends Student{

        @Override
        public Object getId() {
            return super.getId();
        }

        @Override
        public void setId(Object id) {
            super.setId(id);
        }
    }

父类子类都有泛型

    class Test2<T> extends Student<T> {

        @Override
        public T getId() {
            return super.getId();
        }

        @Override
        public void setId(T id) {
            super.setId(id);
        }
    }

只有子类有泛型

    class Test2<T> extends Student {

        @Override
        public Object getId() {
            return super.getId();
        }

        @Override
        public void setId(Object id) {
            super.setId(id);
        }
    }

泛型接口

泛型的接口使用的时候，和泛型的类的定义是一个的，不管现实还是继承都和泛型类一样。

public interface GenericInterface<T> {}

泛型方法

泛型方法的格式：

修饰符 <代表泛型的变量> 返回值类型 方法名（参数列表）{}

含有泛型的方法，在调用方法的时候确定泛型的数据类型，传递什么类型的参数，泛型就是什么类型的。
定义一个泛型方法并使用：

    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        demo01.test("a");   //a
        demo01.test(2);     //2
        demo01.test(false); //false
        demo01.test(0.01);  //0.01

        Demo01.staticTest(4);   ///4
    }

    /*
        普通泛型方法
     */
    public <T> void test(T t) {
        System.out.println(t);
    }

    /*
        静态泛型方法
     */
    public static <T> void staticTest(T t) {
        System.out.println(t);
    }

细节决定成败!
个人愚见，如有不对，恳请扶正!

Java泛型（三十三）

泛型