泛型Generics

1. 让数据类型变的参数化

• 定义泛型时，对应的数据类型是不确定的
• 泛型方法被调用时，会指定具体类型
• 核心目标：解决容器类型在编译时安全检查的问题

2. 泛型类

class 类名称<泛型标识(可以随便写任意标识号，一般为T)> {

    修饰符 泛型标识 // 成员变量类型

    修饰符 构造函数(泛型标识 参数)

    ......

}

• 泛型的参数不支持基本类型
• 泛型相关的信息不会进入到运行时阶段

@Data
public class GenericClassExample<T> {
    // member这个成员变量的类型为T，T的类型由外部指定
    private T member;
    // 泛型构造方法形参member的类型也为T，T的类型由外部指定
    public GenericClassExample(T member) {
        this.member = member;
    }
    public T handleSomething(T target) {
        return target;
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
        GenericClassExample<Integer> integerExample = new GenericClassExample<Integer>(123);
        System.out.println(stringExample.getMember().getClass());
        System.out.println(integerExample.getMember().getClass());
        System.out.println(stringExample.getClass());
        System.out.println(integerExample.getClass());
    }
}

•  在泛型里面使用具备继承关系的类

  • 使用通配符?，但是会使得泛型的类型检查失去意义
  • 给泛型加入上边界? extends E

public class GenericDemo {
    public static void handleMember(GenericClassExample<? extends Number> integerGenericClassExample) {
        Integer result = 111 + (Integer) integerGenericClassExample.getMember();
        System.out.println("result is " + result);
    }

    public static void main(String[] args) {
        GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
        GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
        System.out.println(stringExample.getMember().getClass());
        System.out.println(integerExample.getMember().getClass());
        System.out.println(stringExample.getClass());
        System.out.println(integerExample.getClass());
        handleMember(stringExample); // 会有类型检查提醒
    }
}

• 给泛型加入下边界? super E

public class GenericDemo {
    public static void handleMember(GenericClassExample<? super Integer> integerGenericClassExample) {
        Integer result = 111 + (Integer) integerGenericClassExample.getMember();
        System.out.println("result is " + result);
    }

    public static void main(String[] args) {
        GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
        GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
        System.out.println(stringExample.getMember().getClass());
        System.out.println(integerExample.getMember().getClass());
        System.out.println(stringExample.getClass());
        System.out.println(integerExample.getClass());
        handleMember(stringExample); // 会有类型检查提醒
    }
}

3. 泛型接口

• 与泛型类的用法基本相同，常用于数据类型的生产工厂接口中

public interface GenericIFactory<T,N> {
    T nextObject();
    N nextNumber();
}

// 普通类实现泛型接口
public class RobotFactory implements GenericIFactory<String, Integer> {
    private String[] stringRobot = new String[] {"Hello", "Hi"};
    private Integer[] integerRobot = new Integer[] {111, 000};

    @Override
    public String nextObject() {
        Random random = new Random();

        return stringRobot[random.nextInt(2)];
    }

    @Override
    public Integer nextNumber() {
        Random random = new Random();

        return integerRobot[random.nextInt(2)];
    }

    public static void main(String[] args) {
        GenericIFactory<String, Integer> factory = new RobotFactory();
        System.out.println(factory.nextObject());
        System.out.println(factory.nextNumber());
    }
}

// 泛型类实现泛型接口
public class GenericFactoryImpl<T, N> implements GenericIFactory<T, N> {
    @Override
    public T nextObject() {
        return null;
    }

    @Override
    public N nextNumber() {
        return null;
    }
}

4. 泛型方法

• 既能用在泛型类、泛型接口里，也能用在普通类或者接口里

@Data
public class GenericClassExample<T> {
    // member这个成员变量的类型为T，T的类型由外部指定
    private T member;
    // 泛型构造方法形参member的类型也为T，T的类型由外部指定
    public GenericClassExample(T member) {
        this.member = member;
    }
    public T handleSomething(T target) {
        return target;
    }
    public String sayHello(String name) {
        return "Hello " + name;
    }
    // 泛型方法
    public static <E> void printArray(E[] inputArray) {
        for(E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
}

public class GenericDemo {
    public static void handleMember(GenericClassExample<? super Integer> integerGenericClassExample) {
        Integer result = 111 + (Integer) integerGenericClassExample.getMember();
        System.out.println("result is " + result);
    }

    public static void main(String[] args) {
        GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
        GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
        System.out.println(stringExample.getMember().getClass());
        System.out.println(integerExample.getMember().getClass());
        System.out.println(stringExample.getClass());
        System.out.println(integerExample.getClass());
        handleMember(integerExample);
        Integer[] integers = {1, 2, 3, 4, 5, 6};
        Double[] doubles = {1.1, 1.2, 1.3, 1.4, 1.5, 1.6};
        Character[] characters = {'A', 'B', 'C'};
        stringExample.printArray(integers);
        stringExample.printArray(doubles);
        stringExample.printArray(characters);
    }
}

5. 泛型字母的含义

• E - Element：在集合中使用，因为集合中存放的是元素
• T - Type：Java类
• K - Key：键
• V - Value：值
• N - Number：数值类型