如何將實現器在一個接口上轉換爲另一個接口？

Question

我無法找到一種方式，似乎並沒有錯的方式來做到這一點，下面給出

public interface IType {} 
public interface IMode {} 

public interface Factory<T extends IType> { 
    IMode get(T o); 

    Class<T> getIType(); 
} 

我上面的接口和類的大名單的同時實現IType和IMode與相應的工廠。

我需要能夠從一個轉換到另一個，例如，

public class A implements IType {} 
public class One implements IMode {} 

public class AToOne implements Factory<A> { 
    public IMode get(A o){ 
     return new One(); 
    } 

    public Class<A> getIType(){ 
     return A.class; 
    } 
} 

鑑於存在這些類的1對1映射，即對於每一個具體的IType有一個並且只有一個具體IMode與相應的工廠，我該如何將IType的列表轉換爲IMode的列表？

即，

private List<Factory<? extends IType>> factoryList; 

public List<IMode> getConversions(List<? extends IType> types){ 
    ??? 
} 

---

我第一次嘗試並不那麼好走，

//Fill this using the getIType() method from each factory 
Map<Class<IType>, Factory<? extends IType>> factoryList = new HashMap<Class<IType>, Factory<? extends IType>>(); 

public List<IMode> getConversions(List<IType> types){ 
    List<IMode> modes = new ArrayList<IMode>(); 

    for(IType type : types){ 
     //Derp 
     Factory<? extends IType> factory = factoryList.get(type.getClass()); 
     //Error 
     factory.get(factory.getIType().cast(type)); 
    } 
} 

錯誤：

The method get(capture#12-of ? extends IType) in the type 
Factory<capture#12-of ? extends IType> 
is not applicable for the arguments (capture#14-of ? extends IType) 

Answer 1

就像我在我的評論中提到的，你只需要使用通用的輔助方法來訪問地圖，什麼是在傳遞來執行從Factory<? extends IType>到Factory<T>，其中T的類型相匹配的未經檢查的轉換：

Map<Class<? extends IType>, Factory<? extends IType>> factoryList = 
     new HashMap<Class<? extends IType>, Factory<? extends IType>>(); 

private <T extends IType> IMode convert(T iType) { 
    //unchecked cast - implementation must guarantee map holds correct data 
    Factory<T> factory = (Factory<T>)factoryList.get(iType.getClass()); 
    //then convert 
    return factory.get(iType); 
} 

您還可以從循環這個輔助方法：

public List<IMode> getConversions(List<IType> types) { 
    List<IMode> modes = new ArrayList<IMode>(types.size()); 
    for (IType type : types) { 
     IMode iMode = convert(type); 
     modes.add(iMode); 
    } 
    return modes; 
} 

Answer 2

簡單的解決辦法是：

interface IFoo { 
} 

interface IBar { 
} 

private static class Foo implements IFoo { 
} 

private static class Bar implements IBar { 
} 

interface IFoo2IBarConverter<B extends IBar, F extends IFoo> { 
    B convert(F foo); 
} 

private static class Foo2BarConverter implements IFoo2IBarConverter<Bar, Foo> { 
    public Bar convert(Foo foo) { 
     return new Bar(); 
    } 
} 

private static class IFoo2IBarFactory { 
    private static HashMap<Class<? extends IFoo>, IFoo2IBarConverter<? extends IBar, ? extends IFoo>> converters = new HashMap<>(); 

    static { 
     converters.put(Foo.class, new Foo2BarConverter()); 
    } 

    public static<F extends IFoo, B extends IBar> B convert(F foo) { 
     // ugly unchecked cast here 
     IFoo2IBarConverter<B, F> converter = (IFoo2IBarConverter<B, F>) converters.get(foo.getClass()); 
     return converter.convert(foo); 
    } 
} 


public static void main(String[] args) { 
    Foo foo = new Foo(); 
    IBar bar = IFoo2IBarFactory.convert(foo); 
} 

您只需要一個HashMap，它將某個子類型爲IFoo的特定類映射到某個轉換器接口。轉換器將IFoo實例轉換爲IBar ..實際上轉換爲我們想要的特定類。可悲的是，我們在IFoo2IBarFactory.convert()中得到了一個醜陋的演員陣容，我不認爲有什麼辦法可以避開那個。至少它只是在一個本地化的位置，並與正確的評論和SuppressWarning你可以忍受它，我會認爲