如何確保這是我的類簽名中引用的泛型類型？

Question

假設我們有三個類 - AbstractMessage，AbstractEngine和AbstractAction。這三個類都以通用的方式相互引用，因此每個引擎都有相應的消息和操作，您可以直接在代碼中引用它們。

public class MyMessage<M extends AbstractMessage<M,E,A>, E extends AbstractEngine<M,E,A>, A extends AbstractAction<M,E,A>> { 

這工作正常，但是當我嘗試在最高級別執行行爲時遇到了一些問題。我的AbstractAction類具有正是如此定義的applyTo方法：

protected abstract M applyTo(E engine, Object guarantee); 

和我AbstractEngine類有這個

private final M apply(A action) { 
    return action.apply(this, this.guarantee); 
} 

而正是在這條線，它不太願意 - 抱怨說：

The method applyTo(E, Object) in the type AbstractAction<M,E,A> is not 
applicable for the arguments (AbstractEngine<M,E,A>, Object) 

現在其原因很明顯 - 所討論的E可能是一些OTHER AbstractEngine，並且無法知道我們調用它的子類是否實際上是一個E。

我的問題是，我怎麼能說對確定性，如果你要class MyEngine extends AbstractEngine<M...,E...,A...>這MyEngine是MUST是E？並有這種確定性烘烤到AbstractEngine？

下面是一個說明問題的小例子。

class EngineExample { 

    static abstract class AbEng<A extends AbAct<A,M,E>, M extends AbMes<A,M,E>, E extends AbEng<A,M,E>> { 

     final M func(A act) { 
      return act.apply(this); // compile error here 
     } 

    } 

    static abstract class AbMes<A extends AbAct<A,M,E>, M extends AbMes<A,M,E>, E extends AbEng<A,M,E>> { 

    } 

    static abstract class AbAct<A extends AbAct<A,M,E>, M extends AbMes<A,M,E>, E extends AbEng<A,M,E>> { 

     abstract void apply(E e); 

    } 

    static class RealEng extends AbEng<RealAct, RealMes, RealEng> { 

    } 

    static class RealMes extends AbMes<RealAct, RealMes, RealEng> { 

    } 

    static class RealAct extends AbAct<RealAct, RealMes, RealEng> { 

     void apply(RealEng eng) { 
      System.out.println("applied!"); 
     } 
    } 

} 

Answer 1

使用寬鬆有效的參數類型

最簡單的辦法，就是沒有實際執行的是this isInstanceOf E。抽象的規則已經保證這是一個安全的操作，所以如果你改變參數來允許任何引擎，它就會工作。

abstract Action<E> { 
    public void apply(Engine<?> e, Object o) { 
    e.doSomething(o); 
    } 
} 

或

abstract Action<E> { 
    <T extends Engine<?>> public T apply(T e, Object o) { 
    return e.doSomething(o); 
    } 
} 

使用類型安全的包裝

另一種解決方案是創建一個綁定在一起這3個其他類，和移動交互調用的包裝。

abstract System<A extends Action, M extends Message, E extends Engine> { 
    abstract void apply(A action, E engine) { 
     engine.render(action.apply()) 
    } 
} 

或者讓包裝類獲取這3個實例並使用傳入的版本。這基本上是「允許任何足夠接近」的解決方案，並增加另一個班級來管理他們如何能夠和不能相互交流。

預製檢查

您也可以在建設提供參考投拋出一個錯誤，如果投的設置是無效的。

private final E dis = (E) this; 

這真的只是從會轉移問題上的編譯時間，有時運行時間，所以一般來講，不是一個安全/穩定的解決方案。

---

下一個解決方案是針對您的案例（使用我們的討論中的信息）。基本上，您想要在A類和B類可以繼承的抽象類中定義一個方法，但A和B不應該使用它們的基類互換。

只要使用多態和使用泛型只是作爲一種分離器

下面是一個使用多態，而不是MVCe的修改，使用泛型只能作爲一種類型類別的排他鎖機制。基本上，Type是一個語義接口，可以說是否語義上，這些類相互交談是有意義的。 （物理引擎和光引擎可能共享一些功能，但讓它們互換是沒有意義的。）

class test { 

    public static void main(String[] rawrs) { 
     RealEng re = new RealEng(); 
     RealAct ra = new RealAct(); 
     MockAct ma = new MockAct(); 
     ra.apply(re); 
     // Remove all code related to Type interface if next line should compile 
     ma.apply(re); // compile error here 
    } 

    static interface Type { 
    } 

    static interface Real extends Type { 
    }; 

    static interface Mock extends Type { 
    }; 

    static abstract class AbEng<T extends Type> { 

     final void func(AbAct<T> act) { 
      act.apply(this); // compile error here 
     } 

    } 

    static abstract class AbMes<T extends Type> { 

    } 

    static abstract class AbAct<T extends Type> { 

     abstract void apply(AbEng<T> e); 

    } 

    static class RealEng extends AbEng<Real> { 

    } 

    static class RealMes extends AbMes<Real> { 

    } 

    static class RealAct extends AbAct<Real> { 
     @Override 
     void apply(AbEng<Real> eng) { 
      System.out.println("applied!"); 
     } 
    } 

    static class MockAct extends AbAct<Mock> { 
     @Override 
     void apply(AbEng<Mock> eng) { 
      System.out.println("applied!"); 
     } 
    } 

} 

Answer 2

Java泛型中的遞歸類型參數通常很麻煩。

這裏的問題是，矛盾的是，你不能保證this引用E的實例;我們唯一知道的關於this的是它也延伸了Engine<M, A, E>但實際上並不是E。

明顯的解決辦法是增加一個鑄（(E)this），並且可能是一個可接受的解決方案，但你必須在合同（直通的javadoc或其他單證），其Engine擴展類必須分配E自己清楚。

另一種解決方案只是簡單地將這些方法簽名更改爲更靈活一點，而不是E接受任何擴展爲Engine<M, A, E>的引擎。

protected abstract M applyTo(AbstractEngine<M, A, E> engine, Object guarantee); 

還考慮儘可能減少類型參數的數量。例如Engine是否需要引用它自己的類型？它是否有任何接受或返回的方法以及必須是相同類型/類的引擎？

編輯

如果你想保持E類型參數applyTo另一種選擇是創建一個字段中鍵入AbstractEngine E這將是一個傳遞給申請。實際上這個字段會參考this，但是一旦它在施工中被安全地「鑄造」了。：

public class AbstractEngine<M extends ..., A extends ..., E extends ...> { 
    private final E engine; 

    protected AbstractEngine(final E engine) { 
     this.engine = Objects.requiresNonNull(engine); 
    } 
} 

public class MyEngine extends AbstractEngine<MyMessage, MyAction, MyEngine> { 
    public MyEngine() { 
     super(this); 
    } 
} 

這部作品的原因是，當我們宣佈MyEngine那麼編譯器不知道MyEngine是E等等「投」是安全的。然後，AbstractEngine中的代碼可以在此後安全地使用鑄造值。

明顯的不便之處是參考this的額外字段，雖然在實踐中有點內存浪費可能可以忽略不計。

在這裏，我們增加了引擎可能指定代理引擎用於其方法調用apply的可能性。也許這可能是有用的......但是如果你真的想使這裏不可能使用第三個引擎，那麼你可以改變AbstractEngine構造函數中的代碼來比較傳遞的引擎和this，並且在運行時如果它們不是相同。

protected AbstractEngine(final E engine) { 
    if (engine != this) { 
     throw new IllegalArgumentException(); 
    } 
    this.engine = engine; 
} 

不幸的是，這不可能是檢查在編譯的時候......你可以做第二個最好的事情是讓你的代碼測試，以確認所有AbstractEngine擴展類符合，因此將在建設 - 部分失敗時間。