Java：是否有可能說變量類型必須滿足多重繼承/接口要求

Question

在我正在使用的一些代碼中，我有一個現有的第三方API實現了從A擴展的事物（也許不是直接的，而是通過X，也許還實現了一堆其他接口）。

現在爲我正在處理的代碼，我有一個接口IB，它提供了A提供的附加功能。因爲我的很多代碼實際上都要求傳遞給它的對象擴展了A，並且還實現了IB，但是沒有辦法爲我的成員變量聲明我能想到的。但選擇A或IB會導致很多演員陣容。

我猜如果A有/有一個接口IA會解決這個問題，但是我沒有辦法改變A，或者我的IB實現不需要擴展A（第三方代碼使用A，並且需要通過它來關心很多管理，持久性，網絡，用戶接口等）。

class Z { 
    private List<?what here?> items; 
    /**The implementer of IB should know how to find the Z instance and call this.*/ 
    private void subscribe(? item) { 
     items.add(item); 
    } 
    public void doSomethingWithItems() { 
     ...code thats requires facilities from A and IB... 
    } 

Answer 1

使用通用助手類，其類型參數使您可以使用一個類型路口：

class Z { 

    private static final class Wrapper<T extends A & IB> { 

     private final T item; 

     Wrapper(final T item) { 
      this.item = item; 
     } 

     void doWork() { 
      // code thats requires facilities from A and IB 
     } 
    } 

    private List<Wrapper<?>> wrappers; 

    private <T extends A & IB> void subscribe(T item) { 
     wrappers.add(new Wrapper<T>(item)); 
    } 
    public void doSomethingWithItems() { 
     for (final Wrapper<?> wrapper : wrappers) { 
      wrapper.doWork(); 
     } 
    } 

我介紹了這個帖子了類似的回答：Java generics type mismatch in method signature

Answer 2

您可以指定一個類型路口：

<T extends A & IB> 

的規則，如果類型之一是一類，它必須首先列出。

如果可以的話我會鍵入類：

class Z<T extends A & IB> { 
    private List<T> items; 

    private void subscribe(T item) { 
     items.add(item); 
    } 
    public void doSomethingWithItems() { 
     // the items are both A and IB 
    } 
} 

如果您不能鍵入Z，去類型的方法：

class Z { 
    private List<A>items; 

    private <T extends A & IB> void subscribe(T item) { 
     items.add(item); 
    } 
    public void doSomethingWithItems() { 
     // items are A, but if you want IB functionality you must cast. 
     // the cast is safe if items are only added via subscribe() 
    } 
} 

Answer 3

你可以做一個新的抽象類，這兩個用抽象方法實現IB，並擴展A.然後，可以讓所有需要使用的類擴展新的抽象類。

Answer 4

這將是最ideomatic如果IB是一個IA的子類型，但是如果你不能這樣做...

由於Java不支持頭等交集類型，所以很難在代碼中表達它。也就是說，Java只支持類型參數邊界中的交集類型，並且我們不能在字段聲明中使用類型參數，而不要求列表中的所有元素都是IB的相同子類型。

因此，我能想到的最好的近似值是強制約束只能在公共API，並且使用內部轉換：

class Z { 
    private List<A> items; 

    private <B extends A & IB> void subscribe(B item) { 
     items.add(item); 
    } 

    public void doSomethingWithItems() { 
     for (A a : items) { 
      IB b = (IB) a; // safe because we checked it on subscription 
      // use features of A and IB 
     } 
    } 
} 

是的，這是醜陋的。這就是爲什麼像Ceylon這樣的新型JVM語言具有第一類交叉類型的原因。也就是說，在錫蘭，人們可以簡單地寫：

class Z() { 

    List<A & IB> items; 

    void subscribe(A & IB item) { 
     items.add(item); 
    } 

    void doSomethingWithItems() { 
     for (item in items) { 
      // use features of A and IB 
     } 
    } 
}