泛型多態混淆？

Question

我有一個抽象工廠就像這樣：

public abstract class DAOFactory { 
    public abstract EntryDAO<EntryDTO> getEntryDAO(); 
    ... 
} 

隨着我的DAO和DTO接口，像這樣：

public interface EntryDTO extends GenericDTO { 
} 

public interface EntryDAO<T extends EntryDTO> extends GenericDAO<T, Serializable> { 
} 

，我的實像這樣：現在

public class EntryDTOImpl implements EntryDTO { 
} 

public class EntryDAOImpl<T extends EntryDTO> extends GenericDaoImpl<EntryDTOImpl, ObjectId> 
implements EntryDAO<T> { 
} 

，如果我創建工廠並覆蓋getEntryDAO方法，如下所示：

public class MyDAOFactory extends DAOFactory { 
    @Override 
    public EntryDAO<EntryDTO> getEntryDAO() { 
     try { 
      return new EntryDAOImpl<EntryDTOImpl>(); 
     } catch (UnknownHostException e) { 
      e.printStackTrace(); 
     } 
    } 

我得到一個編譯時錯誤：

Type mismatch: cannot convert from EntryDAOImpl to EntryDAO

編輯

我已經更新了我的抽象工廠就像這樣：

public abstract <T extends EntryDTO> EntryDAO<T> getEntryDAO(); 

在我的工廠實現所做的更改：

@Override 
public <T extends EntryDTO> EntryDAO<T> getEntryDAO() { 
    try { 
     return new EntryDAOImpl<EntryDTOImpl>(); 
    } catch (UnknownHostException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
} 

現在我就在編譯時錯誤：

Type mismatch: cannot convert from EntryDAOImpl<EntryDTOImpl> to EntryDao<T>

Answer 1

定義抽象方法，這種方法（通知?代替T）：

public abstract EntryDAO<? extends EntryDTO> getEntryDAO(); //should work for you 

我重建場景，我明白它的方式：回subclass1<subclass2>爲interface1<interface2>

例如，這個效果很好：

public static List<? extends CharSequence> dostuff1() { 
    return new ArrayList<String>(); 
} 

但是，這並不工作：

public <B extends CharSequence> List<B> dostuff2() { 
    return new ArrayList<String>(); 
} 

這使你得到了相同的編譯時錯誤：Type mismatch: cannot convert from ArrayList<String> to List<B>

Answer 2

出現這種情況的原因是，你想返回一個EntryDaoImpl<EntryDTOImpl>，它是EntryDao<EntryDTOImpl>的子類型，但不是EntryDao<EntryDTO>，它是該方法的返回類型。

解決方案：

我相信你想要的getEntryDao方法的返回類型更改爲

EntryDAO<? extends EntryDTO>。

Answer 3

只需將返回類型從EntryDao<T>更改爲EntryDao<? extends T>即可。這將這樣的伎倆：

@Override 
public <T extends EntryDto> EntryDao<? extends T> getEntryDao() { 
    try { 
     return new EntryDAOImpl<EntryDTOImpl>(); 
    } catch (UnknownHostException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    return dao; 
} 

現在，作爲一個理由，假設EntryDao<T>有返回方法T像

T load(Serializable id); 

，並接受T像

void save(T t); 

現在假設PersonDTO extends EntryDTO方法，和CarDTO extends EntryDTO。

如果EntryDao<EntryDTO>可從EntryDao<EntryDTOImpl>轉讓，它也可以從EntryDao<PersonDTO>和EntryDao<CarDTO>轉讓。

然後，你可以這樣做：

EntryDao<EntryDTO> x = new EntryDao<PersonDTO>();  // currently this is a compile time error 

如果是合法的，你可以這樣做：

x.save(new CarDTO()); // a run time error, because x can only save Persons, not Cars 

但什麼是EntryDao<? extends EntryDTO>？這只是EntryDao與所有T - 接收方法如save(T)刪除。