Java泛型(8)：自限定&參數協變

自限定

自限定將強制泛型當做自己的邊界參數來使用。自限定所做的，就是要求在繼承關系中，像下面這樣使用這個類：

class A extends SelfBounded<A> {}

它的意義是可以保證類型參數必須與正在被定義的類相同。自限定只能強制作用於繼承關系。如果使用自限定，就應該了解這個類所用的類型參數將與使用這個參數的類具有相同的基本類型。

下面是一個自限定的例子【1】：

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> {} // It's OK.

class C extends SelfBounded<C> {
    C setAndGet(C arg) { set(arg); return get(); }
}

class D {}
// class E extends SelfBounded<D> {} // [Compile error]: Type parameter D is not within its bound

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();
        C c = new C();
        c = c.setAndGet(new C());
    }
}

我們發現class E是不能編譯的。如果移除自限定這個限制（class SelfBounded<T>），這樣E就可以編譯了。但是就不能限制E這樣的非自限定類型繼承SelfBounded類了。

 

參數協變

先看一個協變返回類型的例子【2】：

class Base {}
class Derived extends Base {}

interface OrdinaryGetter {
    Base get();
}

interface DerivedGetter extends OrdinaryGetter {
    // DerivedGetter.get()覆蓋了OrdinaryGetter.get()
    @Override Derived get();
}

public class CovariantReturnTypes {
    void test(DerivedGetter d) {
        Derived result1 = d.get(); // 調用的DerivedGetter.get()
        Base result2 = d.get(); // 也調用的DerivedGetter.get()
    }
}

 而自限定泛型將產生確切的導出類型作為其返回值。請看例【3】：

interface GenericGetter<T extends GenericGetter<T>> {
    T get();
}

interface Getter extends GenericGetter<Getter> {}

public class GenericsAndReturnTypes {
    void test(Getter g) {
        Getter result1 = g.get();
        GenericGetter result2 = g.get(); // Also the base type
    }
}

例【2】可以證明，返回值並不是區分兩個不同方法的途徑。而下面的例【4】則說明參數類型可以區分兩個不同的方法。所以例【2】是覆蓋（override）而例【4】是重載（overload）。

class OrdinarySetter {
    void set(Base base) {
        System.out.println("OrdinarySetter.set(Base)");
    }
}

class DerivedSetter extends OrdinarySetter {
    // @Override // [Compile Error]: Can't override. It's overload not override!
    void set(Derived derived) {
        System.out.println("DerivedSetter.set(Derived)");
    }
}

// 在非泛型代碼中，參數類型不能隨子類型發生變化。
public class OrdinaryArguments {
    public static void main(String[] args) {
        Base base = new Base();
        Derived derived = new Derived();
        DerivedSetter ds = new DerivedSetter();
        ds.set(derived); // 調用DerivedSetter的set
        ds.set(base); // 調用OrdinarySetter的set
    }
}

但是，在使用自限定類型時，在導出類中只有一個方法，並且這個方法接受導出類型而不是基類型作為參數。例子【5】：

interface SelfBoundSetter<T extends SelfBoundSetter<T>> {
    void set(T arg);
}

interface Setter extends SelfBoundSetter<Setter> {}

public class SelfBoundingAndCovariantArguments {
    void testA(Setter s1, Setter s2, SelfBoundSetter sb1, SelfBoundSetter sb2) {
        s1.set(s2);
        // 編譯器不能識別將基類型當做參數傳遞給set的嘗試，因為沒有任何方法具有這樣的簽名。事實上，這個參數已經被覆蓋。
        // s1.set(sb1); // [Compile Error]: set(Setter) in SelfBoundSetter<Setter> cannot be applied to (SelfBoundSetter)
        sb1.set(s1);
        sb1.set(sb2);
    }
}

如果上例不使用自限定類型，普通繼承機制就會介入，而你將能夠重載，就像在非泛型的情況下一樣（自限定類型可以避免這種情況發生）：

class GenericSetter<T> { // Not self-bounded
    void set(T arg){
        System.out.println("GenericSetter.set(Base)");
    }
}

class DerivedGS extends GenericSetter<Base> {
    // @Override // [Compile Error]: Can't override. It's overload not override.
    void set(Derived derived){
        System.out.println("DerivedGS.set(Derived)");
    }
}

public class PlainGenericInheritance {
    public static void main(String[] args) {
        Base base = new Base();
        Derived derived = new Derived();
        DerivedGS dgs = new DerivedGS();
        dgs.set(derived);
        dgs.set(base); // Compiles: overloaded, not overridden!
    }
}