说说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学习心得，如有总结不对的地方欢迎指出探讨！最后奉上星爷片中的经典台词：

年轻人！我们梦中相见！