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) {...} 
} 

有了適當的設計和組件來處理實體的檢索/存儲，你可以有一個不太持久的耦合實體，並且可以執行正確的「覆蓋」。