泛型

概念

泛型：参数化类型，在不创建新的类型的情况下，通过泛型指定不同的类型来控制形参具体限制的类型。

参数化类型：就是将类型有原来的具体的类型进行参数化，变成一个不确定的类型，在使用或者调用的时候再传入具体的参数类型。

为什么使用泛型

示例代码：

public class Generic {

    public static void main(String[] args) {

        List list = new ArrayList();
        list.add("这是一个字符串");
        //自动装箱操作
        list.add(100);

        for (int i = 0; i < list.size(); i++) {
            String s = (String)list.get(i);
            System.out.println("打印" + i + ":" + s);
        }
    }
}

实际输出：

打印0:这是一个字符串
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
    at generic.Generic.main(Generic.java:15)
Disconnected from the target VM, address: '127.0.0.1:51298', transport: 'socket'

Process finished with exit code 1

我们看到在第二次输出的时候给我们抛出了一个运行时错误。

public class ClassCastException extends RuntimeException:所有继承 RuntimeException 的都是运行时错误

我们看一下上面的例子，ArrayList可以存放任意类型，所有我们在这里添加 String 和 Integer 都是可以的，但是我们在取出这个值得时候，在获取 Integer 的时候发生了错误，那有没有什么办法能够防止这种现象呢？这就是泛型

image.png

我们可以看到在我们加入一个 <String> 之后，程序就编译不过了。而 <X> 就是定义泛型的方式。上面的内容就变成了这个 list 只允许操作 String 类型的值，所有当我们试图添加一个 Integer 进去的时候程序就告诉我们，这样是不行的~

泛型的使用

泛型有三种使用方式

• 泛型类
• 泛型接口
• 泛型方法

泛型类

将泛型用到类的定义的时候，被称为泛型类。

示例：

/*
* T：泛型标识,可以为任意标识，但为通俗易懂，尽量使用T/E/K/V标识泛型
* class 类名称 <T> {
*   private T var;
*
* }
* */

//实例化泛型时，必须置顶T为具体类型
public class GenericClass<T> {
    private T t; //这个成员变量的类型为 T，具体是什么类型，创建这个对象的时候必须指定，指定的 T 就是这个参数的类型


    public GenericClass() {
    }

    //构造参数 T 同上
    public GenericClass(T t) {
        this.t = t;
    }

    // set get 方法 T 同上
    public T getT() {
        return t;
    }

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


}

具体使用

class Test {
    public static void main(String[] args) {

        GenericClass generic = new GenericClass<>();
        generic.setT("1");
        generic.setT(2.13f);
        System.out.println(generic.getT());

    }
}

定义的泛型类 ，可以不传入泛型实参，这个时候是不限制类型的，只有当传入具体类型的时候，才会根据传入的类型进行限制。

image.png

可以看到在我们传入一个小数类型的时候就会报错。
那么是不是我们将 String 改为 double 就可以了呢？

image.png

已经提示我们了，不可以为原始类型，也就是不能是一个基本类型，而我们传入的 2.14f 也会被自动装箱。

所有泛型的定义是不支持基本类型

image.png

改成 Double 即可。

泛型接口

接口的定义和泛型类基本相同。

//定义了一个泛型接口,T为泛型参数
public interface GenericInterface<T> {
    public T fun();
}

实现泛型接口的两种方式：

1. 实现类指明具体的参数类型。

//接口指明了具体类型，类无须继续制定。
class FruitGenerator implements GenericInterface<String>{

    @Override
    public void fun(String s) {
        System.out.println(s);
    }
}

2. 实现类依旧使用泛型

//此处实现类需要继续指明泛型
class FruitGenerator<T> implements GenericInterface<T>{

    @Override
    public void fun(T t) {
        System.out.println(t.toString());;
    }
}

泛型方法

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

泛型方法的定义：

    /*
    * 
    * @param tClass 出入的泛型实参
    * @return T 返回值为 T 类型
    * 
    * 注意：
    * 1.public 和 返回值中间的 <T> 非常重要，可以理解为声明此方法为泛型方法。
    * 2.只有声明了 <T> 的方法才是泛型方法，泛型类中的/使用了泛型的成员方法/并不是泛型方法。
    * 3.<T> 表明该方法将使用泛型类型 T,此时才可以在方法中使用泛型类型 T.
    * 4.与泛型的定义一样，此处 T 可以随便写为任意标识，常见的如 T、E、K、V等
    * */
    public <T> T genericMethod(Class<T> tClass)throws InstantiationException,IllegalAccessException{
    
        T instance = tClass.newInstance();
        return instance;
    }

详细内容我们看一下下面代码

package generic;

public class GenericTest {

    //这个类是泛型类，类名后面加了<T>，T 标识任意类型
    public class Generic<T>{

        //T 类型的成员
        private T key;

        //构造方法
        public Generic(T key) {
            this.key = key;
        }

        //此方法虽然使用了泛型，但并不是一个泛型方法，T只是此方法的返回值
        //这只是一个普通的成员方法，因为 T 已经被泛型类声明，所以可以继续使用
        public T getKey() {
            return key;
        }

        /*
        这个方法是有问题的，编译器是会编译不过的
        因为在类的声明中并未声明泛型 E，所以在使用 E 做形参和返回值的时候，编译器会无法识别。
        public E setKey(E key) {
            this.key = key;
        }
         */
    }

    /*
    * 这才是一个真正的泛型方法
    * 首先，在public 和返回值之间 <T>，必不可少，这表明这是一个泛型方法，并且声明了一个泛型<T>
    * 这个 T 可以出现在这个泛型方法的任意位置
    * 泛型的数量也可以是任意的多个
    *
    *  eg: public <T,K> K showKeyName(Generic<T> container){
    *           ...
    *        }
    * */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key:" + container.getKey());
        T test = container.getKey();
        return test;
    }

    // 这不是一个泛型方法，只是使用了 Generic<Number> 这个泛型类做形参而已
    public void showKeyValue1(Generic<Number> obj){
        System.out.println("key value is" + obj.getKey());
    }

    /*
    这个方法是有问题的，编译器会告诉我们找不到 E
    虽然我们声明了 T ，也表明了这是一个可以处理泛型的类型/的泛型方法
    但只声明了泛型类型 T，并未声明泛型类型 E ,因此编译器并不知道如何处理这个 E 类型
    public <T> T showKeyName(Generic<E> container){
        ...
    }
     */
    
    /*
    这个方法同样是有问题的，编译器会告诉我们找不到 T
    因为这个 T 类型，并未声明过，所以这也不是一个正确的泛型方法声明
    public void showKey(T genericObj){
        
    }
     */
}

泛型类中的泛型方法

package generic;

public class GenericFruit {

    //内部类 重写toString方法
   static class Fruit{
        @Override
        public String toString() {
            return "Fruit";
        }
    }

    static class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    static class Person {
        @Override
        public String toString() {
            return "person";
        }
    }

    //泛型类
    static class GenerateTest<T>{

        //普通方法
        public void show1(T t){
            System.out.println(t.toString());
        }

        //泛型类中声明了一个泛型方法，使用泛型E，
        //由于泛型方法在声明的时候会声明泛型 E，因此即使在泛型类中并没有声明泛型，但编译器也能正常识别。
        public <E> void show3(E e){
            System.out.println(e.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T
        //注意这个 T 是一个全新的类型。可以与泛型类中声明的 T 不是同一个类型
        public <T> void show2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {

        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        
        //因为 apple 是 fruit 的子类，所以这里可以
        generateTest.show1(apple);
        //编译报错，因为泛型类型置顶的是 Fruit,而传入的类型是 Person
//        generateTest.show1(person);
               
        generateTest.show2(apple);
        generateTest.show2(person);
        
        generateTest.show3(apple);
        generateTest.show3(person);
    }
}

静态方法与泛型

静态方法中的注意事项：

在静态方法中使用泛型，静态方法无法访问类上定义的泛型，如果静态方法操作的引用数据类型不确定的时候，必须将泛型定义在方法上。

即如果静态方法要使用泛型的话，必须将静态方法定义成泛型方法

public class StaticGenerator<T> {

    /*
    * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
    * 即使静态方法要使用泛型类中已经声明过的泛型也不可以
    * */
    public static <T> void show(T t){
        
    }
    
    /*
    public static void show(T t){}
    报错：
    'generic.StaticGenerator.this' cannot be referenced from a static context
     */
}

泛型方法能使方法独立于类而产生变化：

无论何时，如果你能做到，你就应该使用泛型方法，也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个 static 方法，是无法访问泛型类型的参数，如果需要 static 方法使用泛型能力，必须使其成为泛型方法。

泛型的上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

1.为泛型添加上边界，即传入的类型实参必须是置顶类型的子类型。

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

泛型的上下边界添加，必须与泛型的声明在一起。

代码地址：https://github.com/ios-yifan/genericDemo
参考文献：https://blog.csdn.net/s10461/article/details/53941091