java泛型里会有class SelfBounded<T extends SelfBounded<T>> { }这种写法，泛型类有一个类型参数T，但这个T有边界SelfBounded<T>。这边界里有两个疑问：
这两点确实挺让人疑惑，思考这个类定义时容易陷入“死循环”。
注意，自限定的要点实际就是这两个“疑问”。
class BasicHolder<T> {
T element;
void set(T arg) { element = arg; }
T get() { return element; }
void f() {
System.out.println(element.getClass().getSimpleName());
}
}
class Subtype extends BasicHolder<Subtype> {}
public class CRGWithBasicHolder {
public static void main(String[] args) {
Subtype st1 = new Subtype(), st2 = new Subtype(), st3 = new Subtype();
st1.set(st2);
st2.set(st3);
Subtype st4 = st1.get().get();
st1.f();
}
} /* Output:
Subtype
*///:~
BasicHolder<T>泛型类的类型参数并没有什么边界，在继承它的时候，你本可以class A extends BasicHolder<B> {}这样普普通通的用。class Subtype extends BasicHolder<Subtype> {}这样用，就构成自限定了。从定义上来说，它继承的父类的类型参数是它自己。从使用上来说，Subtype对象本身的类型是Subtype，且Subtype对象继承而来的成员(element)、方法的形参(set方法)、方法的返回值(get方法)也是Subtype了（这就是自限定的重要作用）。这样Subtype对象就只允许和Subtype对象（而不是别的类型的对象）交互了。
class Subtype extends BasicHolder<Subtype> {}这样用，看起来是类定义还没有结束，就把自己的名字用到了边界的泛型类的类型参数。虽然感觉稍微有点不合理，但这里就强行理解一下吧。自限定的用法：父类作为一个泛型类或泛型接口，用子类的名字作为其类型参数。class Subtype extends BasicHolder<Subtype>这样用可以让Subtype对象只允许和Subtype对象交互，这里再把Subtype抽象成类型参数T，不就刚好变成了T extends SelfBounded<T>这样的写法。BasicHolder<T>泛型类有个成员变量和set方法，所以st1.set(st2); st2.set(st3);可以像链表一样，节点的后继指向一个节点，后者又可以指向另外的节点。下面是自限定类型的标准用法。
class SelfBounded<T extends SelfBounded<T>> {//自限定类型的标准用法
//所有
T element;
SelfBounded<T> set(T arg) {
element = arg;
return this;
}
T get() { return element; }
}
class A extends SelfBounded<A> {}
public class SelfBounding {
public static void main(String[] args) {
A a = new A();//a变量只能与A类型变量交互，这就是自限定的妙处
SelfBounded<A> b = new SelfBounded<A>();
}
} ///:~
SelfBounded<T>的边界要求。根据上个章节的讲解，一个普通的泛型类我们都可以继承它来做到自限定，且因为要使用SelfBounded泛型类之前，我们必须有一个实际类型能符合SelfBounded<T>的边界要求，所以这里就模仿上一章，创建一个新类来符合这个边界，即class A extends SelfBounded<A> {}，这样新类A便符合了SelfBounded<T>的边界。SelfBounded<A> b = new SelfBounded<A>();，但是这个b变量本身的类型是SelfBounded<A>，成员函数的形参或返回值的类型却是A，这个效果看起来不是我们想要的自限定的效果。（b变量不可以和别的SelfBounded<A>对象交互，因为它继承来的成员函数的类型限定是A，这样把别的SelfBounded<A>对象传给成员函数会造成ClassCastException，这属于父类对象传给子类引用，肯定不可以。所以说没有达到自限定。）class A extends SelfBounded<A> {}创建的时候就已经一举三得了。1.出现SelfBounded尖括号里面的A需要满足边界SelfBounded<T>，它自己的类定义已经满足了。2.给了SelfBounded泛型类的定义是为了使用它，新类A的对象也能使用到它，只不过这里是继承使用。3.根据上一章的讲解，新类A的类定义形成了自限定。class SelfBounded<T extends SelfBounded<T>>类定义中，SelfBounded作为了自己的泛型类型参数的边界，这样，想创建一个新类作为T类型参数以符合边界时，这个新类就必须继承到SelfBounded的所有成员（这也是我们想要的效果）。所以就可以class A extends SelfBounded<A> {}这样一步到位。这也解释了简介里的第一个“疑问”。对了，对于第一个疑问，你可能想看一下，如果边界里的泛型类不是自己，会是什么情况：
class testSelf<T> {
//假设这里也有一些成员变量，成员方法
}
class SelfBounded<T extends testSelf<T>> {//类型参数的边界不是自己的名字SelfBounded
T element;
SelfBounded<T> set(T arg) {
element = arg;
return this;
}
T get() { return element; }
}
class testA extends testSelf<testA> {}//这个新类可作为SelfBounded的类型参数T，因为符合了边界
public class SelfBounding {
public static void main(String[] args) {
SelfBounded<testA> a = new SelfBounded<testA>();
}
} ///:~
按照一般使用SelfBounded泛型类的两个步骤，首先需要创建新类class testA extends testSelf<testA> {}来符合边界，然后新类型作为类型参数使用来创建SelfBounded对象，即SelfBounded<testA> a = new SelfBounded<testA>()。但a变量的效果却不是我们想要的自限定的效果，总之看起来很奇怪。
一旦你把class SelfBounded<T extends testSelf<T>>的边界改成<T extends SelfBounded<T>>，那么新类testA，那么它的定义就应该是class testA extends SelfBounded<testA> {}，然后正因为testA继承了SelfBounded<testA>，所以testA就获得了父类SelfBounded的成员方法且这些成员方法的形参或返回值都是testA。
通过这个反例便进一步解释了简介的第一个“疑问”。
对本章第一个例子作进一步的拓展吧：
class SelfBounded<T extends SelfBounded<T>> {
T element;
SelfBounded<T> set(T arg) {
element = arg;
return this;
}
T get() { return element; }
}
class A extends SelfBounded<A> {}
class B extends SelfBounded<A> {} // Also OK
class C extends SelfBounded<C> {
C setAndGet(C arg) { set(arg); return get(); }
}
class D {}
// Can't do this:
// class E extends SelfBounded<D> {}
// Compile error: Type parameter D is not within its bound
// Alas, you can do this, so you can't force the idiom:
class F extends SelfBounded {}
public class SelfBounding {
public static void main(String[] args) {
A a = new A();
a.set(new A());
a = a.set(new A()).get();
a = a.get();//最终a是null
C c = new C();
c = c.setAndGet(new C());//c换成这行新new出来的C对象了
}
} ///:~
class B extends SelfBounded<A>这样使用也是可以的，毕竟继承SelfBounded时，给定的具体类型A确实满足了边界。不过B对象没有自限定的效果了。class C extends SelfBounded<C>展示了：在自己新增的成员方法里，去调用继承来的成员方法。注意，继承来的方法被限定类型为C即自身了，这就是自限定的效果。class E extends SelfBounded<D>无法通过编译，因为给定的具体类型A不符合边界。class F extends SelfBounded，你可以继承原生类型，此时T会作为它的上限SelfBounded（边界）来执行。如下图：
也可以将自限定用于泛型方法：
//借用之前定义好的SelfBounded
class testNoBoundary<T> {}//我自己新加的
public class SelfBoundingMethods {
static <T extends SelfBounded<T>> T f(T arg) {
return arg.set(arg).get();
}
static <T extends testNoBoundary<T>> T f1(T arg) {
return arg;
}
public static void main(String[] args) {
A a = f(new A());
class selfBound extends testNoBoundary<selfBound> {}
selfBound b = f1(new selfBound());
}
} ///:~
f静态方法要求T自限定，且边界是SelfBounded。那么之前定义的A类型就符合要求了。f1静态方法，它也要求T自限定，且边界是testNoBoundary。注意testNoBoundary泛型类对类型参数T没有边界要求。class selfBound extends testNoBoundary<selfBound> {}这里用了局部内部类创建了一个符合边界要求的新类型。java中使用enum关键字来创建枚举类，实际创建出来的枚举类都继承了java.lang.Enum。也正因为这样，所以enum不能再继承别的类了。其实enum就是java的一个语法糖，编译器在背后帮我们继承了java.lang.Enum。
下面就是一个枚举类的使用：
public enum WeekDay {
Mon("Monday"), Tue("Tuesday"), Wed("Wednesday"), Thu("Thursday"), Fri( "Friday"), Sat("Saturday"), Sun("Sunday");
private final String day;
private WeekDay(String day) {
this.day = day;
}
public static void printDay(int i){
switch(i){
case 1: System.out.println(WeekDay.Mon); break;
case 2: System.out.println(WeekDay.Tue);break;
case 3: System.out.println(WeekDay.Wed);break;
case 4: System.out.println(WeekDay.Thu);break;
case 5: System.out.println(WeekDay.Fri);break;
case 6: System.out.println(WeekDay.Sat);break;
case 7: System.out.println(WeekDay.Sun);break;
default:System.out.println("wrong number!");
}
}
public String getDay() {
return day;
}
public static void main(String[] args) {
WeekDay a = WeekDay.Mon;
}
}
发现通过idea看WeekDay.class文件时看不出继承java.lang.Enum的。只有通过javap命令才能看出来。先看一下java.lang.Enum的定义，Enum<E extends Enum<E>>是自限定类型的标准写法：
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable { }
截取部分汇编来看：
public final class WeekDay extends java.lang.Enum<WeekDay> {
public static final WeekDay Mon;
public static final WeekDay Tue;
public static final WeekDay Wed;
public static final WeekDay Thu;
public static final WeekDay Fri;
public static final WeekDay Sat;
public static final WeekDay Sun;
public static WeekDay[] values();
public static WeekDay valueOf(java.lang.String);
发现确实WeekDay做到了自限定，因为继承来的成员和方法的类型都被限定成WeekDay它自己了。
分析一下java.lang.Enum这么设计的好处：
Enum作为一个抽象类，我们使用enum关键字创建出来的枚举类实际都是Enum的子类，因为class Enum<E extends Enum<E>>的类定义是这种标准的自限定类型，所以编译器直接生成的类必须是WeekDay extends java.lang.Enum<WeekDay>（即本文中讲的：需先创建一个符合边界条件的实际类型，但创建的同时又继承Enum本身，所以就一步到位了）。Enum的子类，结合上条分析，每种Enum子类的自限定类型都是Enum子类自身。这样WeekDay的实例就只能和WeekDay的实例交互（星期几和星期几比较），Month的实例就只能和Month的实例交互（月份和月份比较）。Integer的类定义是：
public interface Comparable<T> {
public int compareTo(T o);
}
public final class Integer extends Number implements Comparable<Integer> {//省略}
可以看到Integer实现了Comparable<Integer>，这也是自限定，这样，从Comparable接口继承来的compareTo方法的形参类型就是Integer它自己了。和章节《普通泛型类——构成自限定》里的例子一样。
但接口Comparable的定义可没要求类型参数T必须自限定啊，它甚至连T的边界都没有，当然，这样的好处就是把决定权交给了Comparable的使用者，当使用者想要自限定时，就按照自限定的写法创建新类就好了。