Java高级特性-泛型

2019独角兽企业重金招聘Python工程师标准>>>

 

RoadMap

1. 什么是泛型

 

泛型是一种参数化类型的机制。它可以使得代码适用于各种类型，从而编写更加通用的代码，例如集合框架。

泛型是一种编译时类型确认机制。它提供了编译期的类型安全，

2. 泛型的优势

1，类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

2，消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

3，潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

3. 泛型类

定义泛型类 在 类名后面 加上 表示这是个泛型类

public class Crate {
    private T contents;
    public T emptyCrate() {
        return contents;
    }
    public void packCrate(T contents) {
        this.contents = contents;
    }
}

这个泛型类型，可以在类内任何地方出现，

如 属性类型，方法的返回值，方法的参数类型。

在生成实例的时候 必须指定具体类型。

// create an instance with generic type
Crate crateForElephant = new Crate<>();

泛型数量可以是多个

public class SizeLimitedCrate {
    private T contents;
    private U sizeLimit;
    public SizeLimitedCrate(T contents, U sizeLimit) {
        this.contents = contents;
        this.sizeLimit = sizeLimit;
    } 
}



// create an instance with generic types
SizeLimitedCrate c1 = new SizeLimitedCrate<>()

泛型类命名规范
理论上来说，泛型的类型名字可以定义成任何你想要的。为了方便起见，提高可读性，

JDK建议大家采用 单个大写字母，区分泛型与真实类名，同时提供了一些常用的建议泛型
E  表示一个元素
K  表示一个键值对的键
V 表示一个键值对的值
N 表示一个数字
T 表示一个通用类型
如果是多个通用类型，可以延续使用，S, U, V, .

3.1 多态下的泛型类

泛型类支持接口定义， 即定义一个泛型接口。

public interface Shippable {
    void ship(T t);
}

那么问题来了，这个泛型类怎么去实现？有三种方式可以实现

3.1.1 指定具体的泛型类型

在实现接口的同时 指定具体的类型 而不用泛型表示。

class ShippableRobotCrate implements Shippable {
    public void ship(Robot t) { }
}

3.1.2 继续泛化类型

在实现接口的同时，自己也变成泛化类，进一步，泛化下沉。

class ShippableAbstractCrate implements Shippable {
    public void ship(U t) { }
}

3.1.3 没有泛型的实现

    在实现接口的同时，不继续使用泛型，取而代之的是Object类型，这是个古老方法，主要是为了向前兼容，对那些没有泛型支持的兼容。

    对于编译器而言，会抛出警告，但是会通过编译。

class ShippableCrate implements Shippable {
    public void ship(Object t) { }
}

3.2 泛型类型参数的约束

1. 构造函数不能泛型， 如new T() 最终变成 new Object()
2. 不能使用静态类型的数组
3. 不能使用instanceof， 运行的时候泛型会被擦除
4. 不能使用基本类型作为泛型的参数，可以通过封装类如：Integer
5. 不能使用静态类型作为参数

4. 泛型方法

4.1 泛型方法的声明

泛型方法 与 泛型类有点类似，只是它作用与具体的方法，范围相对于泛型类 更小。

在定义方法的时候 在声明返回值的前面 使用 来声明泛型方法。

public static  void sink(T t) { }

对于方法的返回类型，也可以是泛型或者是泛型类。

// 返回一个泛型
public static  T identity(T t) { return t; }


// 返回一个泛型类
public static  Crate ship(T t) {
    System.out.println("Preparing " + t);
    return new Crate();
}

 

同样的， 泛型方法支持多个 泛型类型

// 返回一个泛型
public static  T identity(T t,U u) { return t; }

4.2 泛型方法的调用

4.2.1 显示调用

调用具体的泛型方法时，需要指定具体类型

Box.ship("package");
Box.ship(args);

4.2.2 隐式调用

调用泛型方法的时候可以向正常的方法调用一样， java编译器会自动匹配泛型

Box.ship("package");

 

5 泛型擦除

泛型的出现帮助编译器能够在编译的时候，使用正确的类型。

实际上，编译器 是将所有的泛型替换为 Object，换句话说，代码编译之后，这些泛型都将被Object所取代。这么做的目的主要是为了兼容老版本的代码(非泛型)

public class Crate {
    private Object contents;
    public Object emptyCrate() {
        return contents;
    }
    public void packCrate(Object contents) {
        this.contents = contents;
    }
}

也不用过于担心 这个泛型擦除，编译期会自动转型了那些被擦除了泛型 如：
当你调用方法： Robot r = crate.emptyCrate();
编译期 实际会编译出显示转型的代码
Robot r = (Robot) crate.emptyCrate();

6 与老代码合作

class Dragon {}
class Unicorn { }
    public class LegacyDragons {
    public static void main(String[] args) {
        List unicorns = new ArrayList();
        unicorns.add(new Unicorn());
        printDragons(unicorns);
    }
    private static void printDragons(List dragons) {
        for (Dragon dragon: dragons) { // ClassCastException
            System.out.println(dragon);
        } 
    } 
}

    虽然有了泛型擦除，但java 毕竟是动态强类型语言，在实际使用过程中，与老代码结合的使用也会出现问题。

 

7 泛型的通配与上下界

泛型的通配表示的是为知类型，通过? 表示

对一个泛型的通配有三种方式来使用它

类型	语法	Example
无界通配	?	List l =new ArrayList();
上界通配	？ extends type	List l =new ArrayList ();
下界通配	？ super type	List l =new ArrayList

 

7.1 无界通配

java 是强类型语言， 所以，对于

List