java編程思想 第十五章自限定類型

public class Test {
    public static void main(String[] args) {
        Sub s1 = new Sub(),s2 = new Sub();
        s1.set(s2);
        s2 = s1.get();

        SubX x = new SubX();
        //!x.set(x);                由於SubX繼承自Basic<Sub>，所以只能傳入和輸出Sub型
        //!x = x.get();
        s1 = x.get();

        Sub2 s3 = new Sub2(),s4 = new Sub2();
        s3.set(s4);
        //!s3 = s4.get();           如果不用古怪的循環泛型就不能這麼做，因爲get返回Basic
        S s = new S();
        Te<S> te = new Te<>();
        te.set(s);
        Te<? extends S> te2 = new Te<>();
        //! te2.set(s);             這當然不行

        A a = new A();
        B b = new B();

        //!b = a.set(a);
        //!b = (B)a.set(a);             這兩種返回的是A而不是B
        //!b = a.set2(a);               這是不行的，返回的是SelfBounded<A> 而不是B
        //!b = (B)a.set2(a);            轉型也是不允許的，因爲他最終是一個A，運行時報錯
        //!b = a.set(b);                參數不對，接受A，給了B

        a = a.set(a);
        SelfBounded<A> sa = a.set(a);
        //a = a.set2(a);                當然不行，返回一個SelfBounded<A>,不能用A接受
        a = (A)a.set2(a);               //轉型是可以的，因爲本身還是A
        a.set2(a).set(a);
    }
}

class Basic<T> {
    void set(T t) {item = t; }
    T get() {return item; }
    T item;
}

class Sub extends Basic<Sub> {
    void f() {item.print();}
    void print() {System.out.println("sub");}
}

class SubX extends Basic<Sub> {}

class Basic2 {
    void set(Basic2 t) {item = t; }
    Basic2 get() {return item; }
    Basic2 item;
}

class Sub2 extends Basic2 {
    void print() {System.out.println("sub");}
}

/*class Basic3<T extends Sub3> {            //這個的用途和上兩個例子完全不同
    void set(T t) {item = t; }
    T get() {return item; }
    T item;
}

class Sub3 extends Basic3<Sub3> {
    void print() {System.out.println("sub");}
}
*/

class S {}
class Te<T extends S> {
    T item;
    void set(T t) {item = t; }
}

class SelfBounded<T extends SelfBounded<T>> {
    T set(T t) {item = t; return item; }
    SelfBounded<T> set2(T t) {item = t; return item; }
    T item;
}

class A extends SelfBounded<A> {}
class B extends SelfBounded<A> {}