Java泛型中自限定(Self-Bound)该怎么理解?

注:本文为《Java编程思想-第4版-15.12 自限定类型》读后笔记

Java的泛型中最令人头大的莫过于下面这段代码:

class SelfBounded<T extends SelfBounded>{}

stw?这是俄罗斯套娃的节奏?它有一个古怪的名字 “古怪的循环泛型(CRG)”

我好想又不太想平铺直叙了。。。。好吧破例一次,show you the coding:

class Basic{
	Basic b;
	public void set(Basic b){ 
		this.b = b;
		System.out.println("invoke Basic");
	}
	public void print() {
		System.out.println(b.getClass().getSimpleName());
	}
}

class SubType extends Basic{
	SubType b;
	public void set(SubType b){ 
		this.b = b;
		System.out.println("invoke sub");
	}
}

SubType st = new SubType();
st.set(new SubType());		//Ok
st.print();                 // !!!
st.set(new Basic());		//调用了继承自Basic的set函数
st.print();

///output:
invoke sub
invoke Basic
Basic

很遗憾,一不小心又写了一个bug,不过这是一个富有建设性的bug。

注意 “!!!” 位置 代码会报NulPointException,因为java不支持对象属性的重写!!注掉感叹号后,输出如上图,st.set(new Basic())其实是调用的父类的方法。

两个方法的签名分别为:

set(Basic b);

set(SubType b);

没错,正是参数的父子类关系,使得父类的方法并没有被子类重写掉!子类只是重载了父类的方法

这似乎不太妙啊!有没有办法使得所有和子类类型相关的参数都跟随子类一起变化呢?方法签名的入参也好,方法返回值也好,最好持有的类型字段也跟着变(这样就不会有上面的NPE了,子类也不用写多余的重复bug)。于是我们要引出自限定的第一个好处:“基类用导出类替代其参数”。这里其实也暗含了自限定的第二个好处:参数协变(自限定父类定义方法参数,子类就不用重复定义了,因为方法参数的类型会跟着子类改变)。很多博客和文章都把参数协变单独提出来,我觉得参数协变要归为我们前面的“基类用导出类替代其参数”。

好了,救世主登场:

class SelfBasic<T extends SelfBasic<T>>{
	T b;
	public void set(T t) {this.b = t;}
	public void print() {
		System.out.println(b.getClass().getSimpleName());
	}
}

class SelfSub extends SelfBasic<SelfSub>{}

SelfSub ss = new SelfSub();
ss.set(new SelfSub());
ss.print();
//! ss.set(new SelfBasic()); //can not compiled

///output:SelfSub

简洁又任性,不做过多解释了。

其实呢还有另外一种处理方式:

class GenericBase<T>{
	T b;
	public void set(T b){ this.b = b; }
	public void print() {
		System.out.println(b.getClass().getSimpleName());
	}
}

class GenericSub extends GenericBase<GenericSub>{}

GenericSub sub = new GenericSub();
sub.set(new GenericSub());
//! sub.set(new GenericBasic()); //can not compiled
sub.print();

///output:GenericSub

没错,就是正常的泛型持有类处理,在这个例子中和自限定的处理方式等价。不过需要注意的是:

class GenericSub extends GenericBase<GenericSub>{}

这段代码其实就是自限定的前身,那为什么会写成:

class A<T extends A<T>>{}

这种套娃的形式呢?答案就在命名上:自限定!怎么理解这个自限定?来看一段代码:

class GenericSetter<T>{
	void set(T arg) {
		System.out.println("GenericSetter.set(Base)");
	}
}

// 老版自限定
class SelfGS extends GenericSetter<SelfGS>{
	void set(SelfGS self) {
		System.out.println("SelfGS.set(SelfGS)");
	}
}

SelfGS sg = new SelfGS();
sg.set(new SelfGS());
//! sg.set(new GenericSetter()); // can not compile

///output:SelfGS.set(SelfGS)

ok!人畜无害!

 不过要是新来一个小白觉得啊哈!还不错!挺好玩!索性加了下面的代码:

class Base{}
class Derived extends Base{}

//GenericSetter 参考上一段代码

class DerivedGS extends GenericSetter<Base>{
	void set(Derived derived) {
		System.out.println("DerivedGS.set(Derived)");
	}
}

Base base = new Base();
Derived derived = new Derived();			
DerivedGS dgs = new DerivedGS();
dgs.set(base);                    //调用了父类的方法
dgs.set(derived);

///output:
GenericSetter.set(Base)
DerivedGS.set(Derived)

你就会发现我们开头提到的要命重载又发生了!!!

而如果GenericSetter<T> 定义成自限定呢

class GenericSetter<T extends GenericSetter<T>>{}

class DerivedGS0 extends GenericSetter<Base>{}//compile error:Bound mismatch: xxx

这个时候因为 Base 并不是 GenericSetter 的子类,编译器就开始有响应了:边界不匹配!

于是最后这里引出了自限定的第三个勉强称得上好处的一点:“它可以保证类型参数必须与正在被定义的类相同”

好了,我来总结一下自限定编程范式的3个好处:

  1. 基类用导出类替代其参数”:泛型基类是所有子类的公共模板,并确保所有子类持有的类型字段,方法参数类型(参数协变)都和子类一起变化。
  2. 参数协变:方法参数类型会随子类变化(书上把这一点单独列出来,我也这样)
  3. 自限定参数:“它可以保证类型参数必须与正在被定义的类相同”

终于有心情睡觉了,欢迎各位大佬一起交流 Java学习心得,如有总结不对的地方欢迎指出探讨!最后奉上星爷片中的经典台词:

年轻人!我们梦中相见!

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页