Java泛型学习笔记

为什么我们需要泛型?

例子一

    public int addInt(int x, int y) {
   
        return x + y;
    }

    public float addFloat(float x, float y) {
   
        return x + y;
    }

例子一分析

实际开发中，经常有数值类型求和的需求。
例如实现int类型的加法, 有时候还需要实现long类型的求和。
如果还需要double类型的求和，需要再重载一个输入类型是double的add方法。

例子二

        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);

        for (int i = 0; i < list.size(); i++) {
   
            // 1
            String name = (String) list.get(i);
            System.out.println("name:" + name);
        }

我们先向List集合加入了两个String类型的值，随后再加入一个Integer类型的值。
这是完全允许的，因为List默认的类型是Object类型。
然而在之后的循环中，如果忘记了之前在List中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。
因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常，因此编码过程中不易发现此类错误。

例子二分析

我们将一个对象放入集合中，集合不会记住对象的类型。
我们从集合中取出对象时，该对象的编译类型变成了Object类型，但运行时的类型仍然为本身类型。
因此，//1处取出集合元素时需要人为的强制类型转换到具体的目标类型，很容易出现“java.lang.ClassCastException”异常。

使用泛型的好处：

①多种数据类型执行相同的代码
②泛型中的类型在使用时指定，不需要强制类型转换

泛型类、泛型接口和泛型方法

什么是泛型

泛型，即“参数化类型”。
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
那么参数化类型怎么理解呢？
顾名思义，参数化类型就是将类型由原来的具体的类型变成参数。
类似于方法中的变量参数，泛型把类型也定义成参数形式（类型形参），然后在调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。
也就是说在泛型的使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型类

引入一个类型变量T（其他大写字母都可以，不过常用的就是T，E，K，V等等），并且用<>括起来，并放在类名的后面。

    /**
     * 泛型类
     */
    public class NormalGeneric<T> {
   
        private T data;

        public NormalGeneric() {
   

        }

        public NormalGeneric(T data) {
   
            this();
            this.data = data;
        }
    }

泛型类是允许有多个类型变量的。

    /**
     * 泛型类
     */
    public class NormalGeneric2<T, K> {
   
        private T data;
        private K result;

        public NormalGeneric2() {
   

        }

        public NormalGeneric2(T data, K result) {
   
            this();
            this.data = data;
            this.result = result;
        }
    }

泛型接口

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

    /**
     * 泛型接口
     */
    public interface Generator<T> {
   
        public T next();
    }

实现泛型接口的类，有两种实现方法：
1、未传入泛型实参时（泛型类实现泛型接口）：

    public class ImplGenerator<T> implements Generator<T> {
   
        private T data;
    }

在new出类的实例时，需要指定具体类型：

ImplGenerator<String> implGenerator = new ImplGenerator<>();

2、传入泛型实参（普通类实现泛型接口）

    public class ImplGenerator2 implements Generator<String> {
   
        @Override
        public String next() {
   
            return "OK";
        }
    }

在new出类的实例时，和普通的类没区别。

ImplGenerator2 implGenerator2 = new ImplGenerator2();

泛型方法

        //泛型方法，有<T>
        public <T> T genericMethod(T... a) {
   
            return a[a.length / 2];
        }
        
        //普通方法
        public int test(int x,int y){
   
            return x+y;
        }
        

调用泛型方法

        //<String>可以写也可以不写，不写的话编译器会自动识别
        genericMethod.<String>genericMethod("aaa", "bbb", "ccc");
        genericMethod.genericMethod(12, 34, 56);

泛型方法要在调用方法的时候指明泛型的具体类型。
泛型方法可以在普通类和泛型类使用。

注意：

1. 泛型类中定义的普通方法和泛型方法的区别
2. 泛型方法独立于泛型类和泛型接口，泛型方法的T和泛型类的T是不同的东西。

普通方法：

    public class Generic<T> {