泛型——学习笔记

含义

泛型，顾名思义就是“泛指的类型”，即不是特定的类型。可以用泛型指代多个特定的类型，是参数化的类型。泛型只在编译阶段有效，运行阶段没有效果，编译之后会采取去泛型化操作。

泛型类型在逻辑上可看成是多个不同的类型，但是其实质都是同一个数据类型。

只不过我们在编写代码时，有时不知道类、方法、接口需要什么特定类型的数据（String、Long、Integer… ?），有时一个类或方法或接口又可能会有多个不同类型的实例。因此使用泛型来指代一种类型，方便我们书写代码。从这里也知道，泛型只会在编译时有效，也就是实例化之后需要传递特定的类型，则编译之后会将该特定类型传递给使用泛型的方法或类或接口。

泛型通配符

无边界通配符

使用<?>表示无边界的泛型通配符，表示它可以是任何类型的List，也可以是自己创建的类型。但是在实例化时必须要给出特定的类型是什么。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("good");
    list.add("first");
    loop(list);
}

public static void loop(List<?> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

上边界通配符

使用<? extends ...>表示具有上边界的泛型通配符，表示该泛型指代类型的上限，可以是该类的子类或孙子类。比如下面代码是一个上边界为Number类的泛型通配符，它实例化时只能用Number的子类或孙子类，由于String类不是他的后代类，所以String类会报错。

publicstatic void main(String[] args) {
    List<Double> list = new ArrayList<>();
    list.add(12.3);
    list.add(45.6);
    loop(list);
}

public static void loop(List<? extends Number> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

下边界通配符

下边界采用<? super ...>表示，实例化只能使用该类或到Object之间的类。由于Number也是Integer类的父类，所以可以用Number

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(12);
    list.add(45);
    loop(list);

    List<Number> list2 = new ArrayList<>();
    list2.add(12.3);
    list2.add(45.6);
    loop(list2);
}

public static void loop(List<? super Integer> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

泛型的使用

必须先声明，再使用。泛型可以用 K V T E 来表示。

1. 泛型类

定义泛型类可以增加代码的灵活度，有时我们可能并不知道类里面需要哪些参数或类型，所以使用泛型类。

public class GenericClass <T>{
    private T t;

    public GenericClass(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

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

2. 泛型方法

指方法可以使用泛型来定义。可以使用类定义的泛型，或者方法自己定义的类型。

注意：类的静态方法不能使用类定义的泛型，因为类的泛型只有在实例化时才知道是什么特定的类型，而静态类不需要类的实例化就可以使用，所以静态类编译后并不知道自己所对应的特定的类型是什么，因此会出错。

public class GenericClass<K, V> {
	
	// 方法可以使用类的泛型
    public K method1(K k, V v) {
        return (K) null;
    }
	
	// 可以使用方法定义的泛型，注意，T一定要声明
    public <T> T method2(T t, V v) {
        return (T) null;
    }

	// 注意，类的静态方法不能使用类的泛型，如下的使用会报错
    /*
    public static K method3() {
        return null;
    }
    */

	// 将其修改为如下，K指新定义的一个泛型，覆盖掉类的泛型K，与类中定义的K不一样
    public static <K> K method3() {
        return null;
    }
}

3. 泛型接口

在接口使用泛型来指代具体的类型，更加灵活。

public interface GenericInterface<T> {
    T method1(T t1, T t2);
    
    T method2(T t);
    
    T method3(T t);
}

总结