Question

尝试在Java项目中实现泛型和继承类。出于这个原因，我创建了“Base”类和接口，它们将继承所有特定的类和接口。

我的意思是，我有一个基本接口

public interface BaseServices<T> {
    public boolean validate(T item, int id) throws Exception;
}

该接口的基本实现

public class BaseServicesImpl implements BaseServices<BaseBO> {

@Autowired
BaseDao dao;
CategoryBO bo;

public BaseServicesImpl()
{
    this.bo = new CategoryBO();
}

    @Override
       public boolean validate(BaseBO item, int id) throws Exception {
       return dao.validate("name",item.toString(), id);
    } 
}

其中BaseBO是所有其他对象将扩展的业务对象。

然后，对于一个特定的对象，我将有一个扩展Base 1的特定接口。

public interface CategoryServices extends BaseServices {
    }

及其实施：

public class CategoryServicesImpl extends BaseServicesImpl implements CategoryServices<CategoryBO> {

    @Autowired
    CategoryDao categoryDao;

    public CategoryServicesImpl()
    {
        this.dao = categoryDao;
    }

    @Override
    public boolean validate(CategoryBO item, int id) throws Exception {
            return dao.validate("name",item.getName(), id);
    }
}

某些对象可以实现通用的“Validate”方法（仅验证名称）或将其扩展为类requiredPublic class CategoryServicesImpl扩展的类BaseServicesImpl实现CategoryServices。

我该如何使这项工作？可能吗？我正在努力尽我所能重用我的代码。如果还有其他方法，请告诉我。

EDITED：我正在尝试做的是，有一个基类，所有类的所有常用方法，比如说，基本的创建，编辑，删除，获取，getAll等。然后在每个类我也可以拥有并覆盖这些方法，因为在某些类中它们会有所不同，但在大多数情况下，它们只会执行相同操作，因此它将调用在Base类中定义的泛型。

Answer 1

只需进行一些更改，您就可以轻松实现自己想要的目标：

public interface BaseServices<T extends BaseBO> {

    boolean validate(T item, int id) throws Exception;
}

public interface CategoryServices 
    extends BaseServices<CategoryBO> {
}

public class BaseServicesImpl<T extends BaseBO> 
    implements BaseServices<T> {

    @Override
    public boolean validate(T item, int id) throws Exception {
        return true;
    }
}

public class CategoryServicesImpl 
    extends BaseServicesImpl<CategoryBO> 
    implements CategoryServices {

    @Override
    public boolean validate(CategoryBO item, int id) throws Exception {
        return true;
    }
}

关键是让您的通用T类型成为BaseBO的后代，然后将您的BaseServicesImpl类调整为通用类。

Answer 2

警告 see my comment on good design。简单是良好软件的关键。过度工程是走向疯狂的道路。

如果您有一个接口，并且需要在实现该接口的类之间共享某些方法的实现，则可以使用Abstract Base Class来实现您需要共享的方法。

public interface Service<T> { 
    //note, interfaces are implictly public
    boolean validate(T item, int id) throws Exception;
    void foo();
    void bar();
}

public abstract class BaseService<T> {
    boolean validate(T item, int id) throws Exception {
        return false; // a default implementation
    }
    public abstract void foo();
    public abstract void bar();
}

public class FooService<T> extends BaseService<T>{
    public void foo() {
        println("foo"); 
    }
    public void bar() {
        println("bar"); 
    }
}

使用Java 8，它也可以提供default implementations in an interface。

public interface Service<T> { 
    boolean validate(T item, int id) throws Exception;
    void foo();
    void bar();
}

但请注意，这可能导致一种多重继承，这可能会使您的代码难以推理。

实现通用接口和继承

2 个答案: