Java 强制子类从超类重写@Override方法。超类中的方法必须具有主体

我想强制

子类

从

超类

到

@Override

方法

超类中的方法不能是抽象的，因为我想提供一些基本的实现

下面是我的代码示例：

public abstract class GenericModel<T extends GenericModel> {
    long id, counter;

    public String methodToBeOverridenInSubClass(String name) {
        // some basic implementation
        // rest details will be provided by subclass
        return name;
    }

}
public class SubClass extends GenericModel<SubClass> {
    @Override
    public String methodToBeOverridenInSubClass(String name) {
        switch (name) {
            case "name": return "Real name";
            default: super.methodToBeOverridenInSubClass(name);
        }
    }
}

公共抽象类GenericModel{
长id，计数器；
public String MethodToBeOverridenSubclass（字符串名称）{
//一些基本的实现
//其余细节将由子类提供
返回名称；
}
}
公共类子类扩展了GenericModel{
@凌驾
public String MethodToBeOverridenSubclass（字符串名称）{
交换机（名称）{
案例“姓名”：返回“真实姓名”；
默认值：super.methodToBeOverridingSubclass（名称）；
}
}
}

这篇文章很有趣：

---

请给我一些帮助

您可以使用两种方法：

public abstract String methodToBeOverridenInSubClass(String name);


protected String commonMethodToUseInSubClasses(String name) {
    // some basic implementation
    return name;
}

---

这样子类必须重写

methodtobeoverridinginsubclass

，但是您仍然可以对

commonmethodtoseinsubclass

中的所有子类使用公共代码，可能您要查找的问题已由解决。 在其中，您创建了一个父类，其中实现了一个方法，该方法描述了调用其他方法（步骤）的流程。这些步骤是抽象的，因此它们由一个子类实现

维基百科的例子：

/**
* An abstract class that is common to several games in
* which players play against the others, but only one is
* playing at a given time.
*/

abstract class Game {

protected int playersCount;
abstract void initializeGame();
abstract void makePlay(int player);
abstract boolean endOfGame();
abstract void printWinner();

/* A template method : */
public final void playOneGame(int playersCount) {
    this.playersCount = playersCount;
    initializeGame();
    int j = 0;
    while (!endOfGame()) {
        makePlay(j);
        j = (j + 1) % playersCount;
    }
    printWinner();
}
}

//Now we can extend this class in order 
//to implement actual games:

class Monopoly extends Game {

/* Implementation of necessary concrete methods */
void initializeGame() {
    // Initialize players
    // Initialize money
}
void makePlay(int player) {
    // Process one turn of player
}
boolean endOfGame() {
    // Return true if game is over 
    // according to Monopoly rules
}
void printWinner() {
    // Display who won
}
/* Specific declarations for the Monopoly game. */

// ...
}

class Chess extends Game {

/* Implementation of necessary concrete methods */
void initializeGame() {
    // Initialize players
    // Put the pieces on the board
}
void makePlay(int player) {
    // Process a turn for the player
}
boolean endOfGame() {
    // Return true if in Checkmate or 
    // Stalemate has been reached
}
void printWinner() {
    // Display the winning player
}
/* Specific declarations for the chess game. */

// ...
}

---

如果超类方法不是抽象的，就不能强制子类重写。我知道这一点。我正在寻找一些解决方法，因此在

子类

中，我将覆盖

方法以覆盖子类

。然后在这个方法体中，我将从

超类

调用

methodouse

？您给了我很好的答案，解决了我的问题。非常感谢。但更详细，所以我有义务接受他的回答。这似乎不是问题的正确答案。子类需要强制实现一个超类的方法，该方法有一个body。虽然有点晚，但我认为这是正确的。子类需要定义“partial”方法initializeGame（）、endOfGame（）等，以便playOneGame（int）方法完成其工作。当然，一旦定义了其他方法，子类将调用playOneGame（int）方法。