手记
下载APP

Java核心技术第八章-泛型

摘要

本文根据《Java核心技术 卷一》一书的第八章总结而成,部分文章摘抄书内,作为个人笔记。
文章不会过于深入,望读者参考便好。

为什么要使用泛型程序设计

泛型程序设计(Generic programming) 意味着编写的代码可以被很多不同类型的对象所重用。

类型参数的好处

在没有泛型类之前,ArrayList类只维护一个Object引用的数组:

public class ArrayList {
   private Object[] elementData; // 用于存放数据
   public Object get(int i) { . . . }
   public void add(Object o) { . . . }
	 ...
}

问题

1.获取一个值时必须进行强制类型转换
2.这里没有错误检査。可以向数组列表中添加任何类的对象,如果数组的类型不一致,将 get 的结果进行强制强制类型,就会错误。

泛型提供了一个更好的解决方案: 类型参数:

ArrayList<String> array = new ArrayList<String>():

利用类型参数的信息,我们就可以在添加数据的时候保持类型统一,调用get方法时候也不需要进行强制类型转换,因为我们在初始化的时候就定义了类型,编译器识别返回值的类型就会帮我们转换该类型。

定义一个简单泛型类

public class Pair<T> {
    private T num;

    public Pair(T num) { this.num = num; }
    public T getNum() { return num; }
    public void setNum(T num) { this.num = num; }
}

我们可以看到,在Pair类名后面添加了一个,这个是泛型类的类型变量,而且还可以有多个类型变量,如

public class Pair<T,U> {
    ...
}

如果我们实例化Pair类,例如:

new Pair<String>;

那么我们就可以把上述的Pair类想象成如下:

public class Pair<String> {
    private String num;

    public Pair(String num) { this.num = num; }
    public String getNum() { return num; }
    public void setNum(String num) { this.num = num; }
}

是不是很简单呢?在Java库中,使用变量E表示集合的元素类型,K和V分别表示表的关键字与值的类型,T、U、S表示任意类型。

泛型方法

定义一个带有类型参数的方法

    public static <T> T getMiddle(T... a) {
        return a[a.length / 2];
    }

可以看到类型变量(< T >)放在修饰符( public static )的后面,返回类型(T)的前面。泛型方法可以定义在普通类或泛型类中。

类型变量的限定

如果我们需要对类型变量加以约束,例如:传入的变量必须实现Comparable接口,因为需要该变量调用compareTo的方法。这样我们就可以使用extends关键字对变量进行限定。

    public <T extends Comparable> T max(T a) {
        a.compareTo(...);
        ...
    }

无论变量需要限定为继承某个类或者实现某个接口,都是使用extends关键字进行限定。

泛型代码和虚拟机

类型擦除

无论我们在代码中怎么定义一个泛型类、泛型方法,都提供了一个相应的原始类型。原始类型的名字就是删去类型参数后的泛型类姓名。如 <T> 的原始类型为 Object<T extends MyClass>的原始类型为MyClass
代码就行下面这样:

public class Pair<T> {
    private T property;

    public Pair(T property) {
        this.property = property;
    }
}

类型擦除后:

public class Pair<Object> {
    private Object property;

    public Pair(Object property) {
        this.property = property;
    }
}

翻译泛型表达式

如果擦除返回类型,编译器会插入强制类型转换,就像下面这样:

Pair<Employee> buddies = . .
Employee buddy = buddies.getFirst()

擦除getFirst的返回类型后将返回Object类型,但是编译器将自动帮我们强制类型转换为Employee。
所以:编译器把这个方法执行操作分为两条指令:

对原始方法Pair.getFirst的调用
将返回的Object类型强制转换为Employee类型

小节总结:

虚拟机中没有泛型,只有普通的类和方法
所有的类型参数都用他们的限定类型替换
为保持类型安全性,必要时插入强制类型转换
桥方法被合成来保持多态(本文没有讲到,不过桥方法可以忽略,Java编写不规范才会有桥方法生成)

约束与局限性

不能用基本类型实例化类型参数

不可以用八大基本数据类型去实例化类型参数,你也没见过ArrayList<int>这样的代码吧。只有ArrayList<Integer>。原因是因为基本数据类型是不属于Object的。所以只能用他们的包装类型替换。

运行时类型查询只适用于原始类型

所有的类型查询只产生原始类型,因为在虚拟机没有所谓的泛型类型。
例如:

	Pair<String> pair = new Pair<String>("johnson");
	if (pair instanceof Pair<String>) {} // Error
	if (pair instanceof Pair<T>) {} // Error
	if (pair instanceof Pair) {} // Pass

不能创建参数化类型的数组

    Pair<String>[] pairs = new Pair<String>[10]; //error

为什么不能这样定义呢?因pairs的类型是Pair[],可以转换为Object[],如果试图存储其他类型的元素,就会抛出ArrayStoreException异常,

	pairs[0] = 10L; //抛异常

总之一句话,不严谨。所以不能创建参数化类型的数组。

不能实例化类型变量

不能使用 new T(…)、new T[…] 或 T.class。因为类型擦除后,T将变成Object,而且我们肯定不是希望实例化Object。
不过在Java8之后,我们可以使用Supplier<T>接口实现,这是一个函数式接口,表示一个无参数而且有返回类型为T的函数:

public class Pair<T> {
    private T first;
    private T second;

    private Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public static <T> Pair<T> makePair(Supplier<T> constr) {
        return new Pair<>(constr.get(), constr.get());
    }
    
	public static void main(String[] args) {
        Pair<String> pair = Pair.makePair(String::new);
    }
}

泛型类中的静态上下文中类型变量无效

不能在静态域或方法中引用类型变量。例如:

public class Pair<T> {
    private static T instance; //Error

    public static T getInstance() { //Error
        if (instance == null) 
            instance = new Pair<T>();
        return instance;
    }
}

因为类中的类型变量(<T>)是在对象中的作用域有效,而不是在类中的作用域有效。如果要使用泛型方法,可以参照文章上面的泛型方法哦~

不能抛出或捕获泛型类的实例

即不能抛出也不能捕获泛型类的对象,甚至扩展Throwable都是不合法的:

public class Pair<String> extend Exceotion {} //Error
public static <T extends Throwable> void doWork(Class<T> t) {
	try {
	 	...
	} catch (T e) { //Error
		...
	}
}

但是在抛出异常后对异常使用类型变量是允许的(个人感觉没见过这样的代码)。

public static <T extends Throwable> void doWork(Class<T> t) throw T { //Pass
	try {
	 	...
	} catch (Exception e) {
		throw e;
	}
}

泛型类型的继承规则

Manager类继承Employee类。但是Pair<Employee>Pair<Manager>是没有关联的。就像下面的代码,就会提示报错,传递失败:

        Pair<Manager> managerPair = new Pair<Manager>();
        Pair<Employee> employeePair = managerPair; //Error

通配符类型

通配符概念

通配符类型中,允许类型参数变化,使用 ? 标识通配符类型:

Pair<? extends Employee>

若Pair类如下

public class Pair<T> {
    private T object;

    public void setObject(T object) {
        this.object = object;
    }
}

那么使用通配符可以解决泛型类型的继承规则问题,如:

        Pair<Manager> managerPair = new Pair<Manager>();
        Pair<? extends Employee> employeePair = managerPair; //Pass
        Manager manager = new Manager();
        employeePair.setObject(manager); //Error

使用<? extends Employee>,编译器只知道employeePair 是Employee的子类,但是不清楚具体是什么子类,所以最后一步employeePair.setObject(manager)不能执行。

通配符的超类型限定

通配符还有一个附加的能力,就是可以指定一个超类型限定,如:

public class Pair<T> [
	...
	public static void salary(Pair<? super Manager> result) {
        //...
    }
}

<? super Manager>这个通配符为Manager的所有超类型(包含Manger),例如:

        Pair<Manager> managerPair = new Pair<Manager>();
        Pair<Employee> employeePair = new Pair<Employee>();

        Pair.salary(managerPair); //Pass
        Pair.salary(employeePair); //Pass

		// 假如 ManagerChild为Manager子类
        Pair<ManagerChild> managerChildPair = new Pair<ManagerChild>();
        Pair.salary(managerChildPair); //Error

无限定通配符

无限定通配符,如:Pair<?>,当我们不需要理会他的实际类型时候,就可以使用无限定通配符,上代码:

    public static boolean hasNull(Pair<?> pair) {
        return pair.getObject() == null;
    }

说实话,通配符搞得我头昏脑胀的,反复不断地看文章,才开始慢慢看懂,我太难了。。。


文章到这里就结束啦,不知道各位小伙伴看懂了没,没看懂的话可能是我的功底和文章写作能力还有待提高,小伙伴们也可以去看一下《Java核心技术 卷一》这本书呢,感觉还是挺不错的。最近把这本书捡起来看也是发现基础是非常重要的,先把基础沉淀好了,再学习其他的技术点也会更容易入手,也会知其然知其所然。最近非常喜欢的一句话,送给大家:“万丈高楼平地起,勿在浮沙筑高台”。

个人博客网址: https://colablog.cn/

打开App,阅读手记
0人推荐
随时随地看视频慕课网APP