注：本文为《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个好处：
- “基类用导出类替代其参数”：泛型基类是所有子类的公共模板，并确保所有子类持有的类型字段，方法参数类型（参数协变）都和子类一起变化。
- 参数协变：方法参数类型会随子类变化（书上把这一点单独列出来，我也这样）
- 自限定参数：“它可以保证类型参数必须与正在被定义的类相同”
