Java泛型&；继承：我是不是太聪明了？

我可能是个白痴，但我还没弄明白这一点。我正在尝试为一个带有DB的简单CRUD框架设置一些类

我从一个

实体

接口和一个

用户实现实体

类开始

然后作为“dao”类，我有一个接口

GenericTableModel<T extends Entity>

但是，当我添加以下类时，情况会发生变化：

public abstract class AbstractCrud<T extends GenericTableModel> {
    private T table;

    public AbstractCrud( T t ){ this.table = t }

    public List<? extends Entity> getList(){
        return this.table.listAll()
    }

super.getList（）

不返回

用户列表

，只返回对象列表。为了获得

用户列表

我需要

UserSimpleCrud

    @Override
    public List<Users> getList(){
        return super.getList();
    }

@覆盖
公共列表getList（）{
返回super.getList（）；
}

这将自动将对象列表强制转换为

用户之一

苏欧。。。。我错过了什么？显然，除了一些灰色细胞之外！；-）

为什么

asbtractablemodel

中的

listAll（）

方法能够将列表强制转换给

用户

，但是

AbstractCrud

中的

getList（）

方法无法执行此操作？

您可以尝试一下

public abstract class AbstractCrud<T extends Entity> {
    private GenericTableModel<T> table;

    public AbstractCrud( GenericTableModel<T> table ){ this.table = table }

    public List<T> getList(){
        return this.table.listAll()
    }



public class UserSimpleCrud extends AbstractCrud<User> {
    public UserSimpleCrud(){
        super( new UsersTable() );
    }

公共抽象类AbstractCrud{
私有GenericTableModel表；
公共抽象CRUD（GenericTableModel表）{this.table=table}
公共列表getList（）{
返回此.table.listAll（）
}
公共类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）{
super（newuserstable（））；
}

您可以试试这个

public abstract class AbstractCrud<T extends Entity> {
    private GenericTableModel<T> table;

    public AbstractCrud( GenericTableModel<T> table ){ this.table = table }

    public List<T> getList(){
        return this.table.listAll()
    }



public class UserSimpleCrud extends AbstractCrud<User> {
    public UserSimpleCrud(){
        super( new UsersTable() );
    }

公共抽象类AbstractCrud{
私有GenericTableModel表；
公共抽象CRUD（GenericTableModel表）{this.table=table}
公共列表getList（）{
返回此.table.listAll（）
}
公共类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）{
super（newuserstable（））；
}

您可以试试这个

public abstract class AbstractCrud<T extends Entity> {
    private GenericTableModel<T> table;

    public AbstractCrud( GenericTableModel<T> table ){ this.table = table }

    public List<T> getList(){
        return this.table.listAll()
    }



public class UserSimpleCrud extends AbstractCrud<User> {
    public UserSimpleCrud(){
        super( new UsersTable() );
    }

公共抽象类AbstractCrud{
私有GenericTableModel表；
公共抽象CRUD（GenericTableModel表）{this.table=table}
公共列表getList（）{
返回此.table.listAll（）
}
公共类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）{
super（newuserstable（））；
}

您可以试试这个

public abstract class AbstractCrud<T extends Entity> {
    private GenericTableModel<T> table;

    public AbstractCrud( GenericTableModel<T> table ){ this.table = table }

    public List<T> getList(){
        return this.table.listAll()
    }



public class UserSimpleCrud extends AbstractCrud<User> {
    public UserSimpleCrud(){
        super( new UsersTable() );
    }

公共抽象类AbstractCrud{
私有GenericTableModel表；
公共抽象CRUD（GenericTableModel表）{this.table=table}
公共列表getList（）{
返回此.table.listAll（）
}
公共类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）{
super（newuserstable（））；
}

如果我编写自己的数据，而不是使用Spring数据（在这些情况下，Spring数据对我很有用），我会这样做：

public abstract class AbstractCrud<T extends GenericTableModel, E extends Entity> {
    private T table;

    public AbstractCrud( T t ){ this.table = t }

    public List<E> getList(){
        return this.table.listAll()
    }
}

公共抽象类AbstractCrud{
私人T表；
公共抽象CRUD（T）{this.table=T}
公共列表getList（）{
返回此.table.listAll（）
}
}

从那里

public class UserSimpleCrud extends AbstractCrud<GenericTableModel<User>, User> {
    public UserSimpleCrud()
    {
        super( new UsersTable() );
    }
}

public类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）
{
super（newuserstable（））；
}
}

---

你应该得到你想要的东西。这是我不知道的，但我认为它会对你有用。

如果我写自己的，而不是使用，比如说，Spring数据（它在这些情况下对我很有用），我会这样做：

public abstract class AbstractCrud<T extends GenericTableModel, E extends Entity> {
    private T table;

    public AbstractCrud( T t ){ this.table = t }

    public List<E> getList(){
        return this.table.listAll()
    }
}

公共抽象类AbstractCrud{
私人T表；
公共抽象CRUD（T）{this.table=T}
公共列表getList（）{
返回此.table.listAll（）
}
}

从那里

public class UserSimpleCrud extends AbstractCrud<GenericTableModel<User>, User> {
    public UserSimpleCrud()
    {
        super( new UsersTable() );
    }
}

public类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）
{
super（newuserstable（））；
}
}

---

你应该得到你想要的东西。这是我不知道的，但我认为它会对你有用。

如果我写自己的，而不是使用，比如说，Spring数据（它在这些情况下对我很有用），我会这样做：

public abstract class AbstractCrud<T extends GenericTableModel, E extends Entity> {
    private T table;

    public AbstractCrud( T t ){ this.table = t }

    public List<E> getList(){
        return this.table.listAll()
    }
}

公共抽象类AbstractCrud{
私人T表；
公共抽象CRUD（T）{this.table=T}
公共列表getList（）{
返回此.table.listAll（）
}
}

从那里

public class UserSimpleCrud extends AbstractCrud<GenericTableModel<User>, User> {
    public UserSimpleCrud()
    {
        super( new UsersTable() );
    }
}

public类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）
{
super（newuserstable（））；
}
}

---

你应该得到你想要的东西。这是我不知道的，但我认为它会对你有用。

如果我写自己的，而不是使用，比如说，Spring数据（它在这些情况下对我很有用），我会这样做：

public abstract class AbstractCrud<T extends GenericTableModel, E extends Entity> {
    private T table;

    public AbstractCrud( T t ){ this.table = t }

    public List<E> getList(){
        return this.table.listAll()
    }
}

公共抽象类AbstractCrud{
私人T表；
公共抽象CRUD（T）{this.table=T}
公共列表getList（）{
返回此.table.listAll（）
}
}

从那里

public class UserSimpleCrud extends AbstractCrud<GenericTableModel<User>, User> {
    public UserSimpleCrud()
    {
        super( new UsersTable() );
    }
}

public类UserSimpleCrud扩展了AbstractCrud{
公共用户simplecrud（）
{
super（newuserstable（））；
}
}

---

---

应该能得到你想要的。这是我不知道的，但我想它会对你有用。

这不应该是公共类

UserSimpleCrud扩展AbstractCrud

否则t在你的抽象类中没有定义。这里的*模型和*Crud有什么区别？我修改了我的评论。好的，我想你需要两个rics。一个用于表，一个用于实体。否则，您将永远不会收到特定类型的实体。

public List getList（）

将返回T的实体，您的类应该是

。我认为这会让您更接近您想要的。BheshGurung:Model类代表数据库中的一个表。Crud类将是bean（我正在使用JSF/PrimeFaces）@thst：我尝试了你的建议，但是在NetBeans（7.3.1）中，

'被标记为错误。如果我将其更改为

`就可以了，但我不确定

UserSimpleCrud

类应该如何更改……难道不是吗