Java重写静态方法

Question

我发现自己需要重写一个静态方法，只是因为它最有意义，但我也知道这是不可能的。

超类，Entity.java：

abstract public class Entity<T> { 
    public Entity() { 
     //set up database connection 
    } 

    abstract public static Map<Object, T> getAll(); 

    abstract public void insert(); 

    abstract public void update(); 

    protected void getData(final String query) { 
     //get data via database 
    } 

    protected void executeQuery(final String query) { 
     //execute sql query on database 
    } 
} 

在众多的具体实现，Account.java：

public class Account extends Entity<Account> { 
    private final static String ALL_QUERY = "SELECT * FROM accounts"; 
    private final static String INSERT_QUERY = "INSERT INTO accounts (username, password) VALUES(?, ?)"; 
    private final static String UPDATE_QUERY = "UPDATE accounts SET password=? WHERE username=?"; 

    private String username; 
    private String password; 

    public Account(final String username, final String password) { 
     this.username = username; 
     this.password = password; 
    } 

    public String getUsername() { 
     return username; 
    } 

    public void setUsername(final String username) { 
     this.username = username; 
    } 

    public String getPassword() { 
     return password; 
    } 

    public void setPassword(final String password) { 
     this.password = password; 
    } 

    @Override 
    public static Map<Object, Account> getAll() { 
     //return a map using the ALL_QUERY string, calls getData(string); 
    } 

    @Override 
    public void insert() { 
     //insert this using INSERT_QUERY, calls executeQuery(string); 
    } 

    @Override 
    public void update() { 
     //update this using UPDATE_QUERY, calls executeQuery(string); 
    } 
} 

我没有去深入解释的代码，但任何一般反馈意见也将不胜感激，我希望这些意见能够充分解释。

所以基本上我认为我们都可以同意使用Account.getAll()比new Account().getAll()更有意义（如果我会为它引入一个虚拟语法）。 但是我确实希望扩展Entity类，目前只是为了方便，但后来我可能必须使用Entity的套件/列表/多套件，并对其中的所有套件执行update()动作，例如，如果我愿意建立一些排队，每分钟更新一次。

那么，有没有办法正确构建getAll()？

问候。

Answer 1

你会对所有元素运营单独的类：

abstract public class Collection<T extends Entity<T>> { 
    abstract public static List<T> getAll(); 
    public void printAll() { 
     // Print all entries of List obtained from getAll() 
    } 
} 

，你可以使用如：

public class Accounts extends Collection<Account> { 
    @Override 
    public List<Account> getAll() { 
     //return a list using the ALL_QUERY string, calls getData(string); 
    } 
} 

Answer 2

这并不在我看来，这是真的“，只是因为它最有意义“。

在您的实体搭售持久性不是一个好主意。已经有很多模式可以为这个问题提供合适的设计。

例如，在域驱动设计中，“持久性无知”是人们试图实现的目标。考虑制定储备库为每个实体：

interface Repository<T> { 
    List<T> findAll(); 
    void insert(T); 
    void update(T); 
} 

这样你就可以通过任何你想要的方式重写它：

interface UserRepository extends Repository<User> { 
    // some other methods which is meaningful for User 
    User findByLoginName(String loginName); 
} 


class UserRepositoryImpl implements UserRepository { 
    List<User> findAll() { 
     // call whatever query 
    } 
    void insert(T){...} 
    void update(T){...} 
    User findByLoginName(String loginName) {...} 
} 

有了适当的设计和组件来处理实体的检索/存储，你可以有一个不太持久的耦合实体，并且可以执行正确的“覆盖”。