我正在维护一些 Java 8 代码，如下所示:

Class Entity  {
   protected Model theModel;

   public Entity()  {
       init();
   }

   protected void init()  {
       this.theModel = new Model();
   }
}

Class Model  {
}

Class SubModel extends Model {
}

main {
    Entity newEntity = new Entity()  {
        @Override
        protected void init()  {
            this.theModel = new SubModel();
        }
    };
}

代码目前可以正确编译和运行，但我现在需要更新它。

我的问题是:

1. 在 newEntity 的构造过程中，init() 方法的覆盖是如何工作的？
2. 对象构造函数语句中包含的此方法重写的正确术语是什么？

到目前为止，我的研究表明 Java 不能动态覆盖方法 - 不能在此基础上进行覆盖，因为方法覆盖是针对每个类而不是针对每个对象的。但是这个代码片段似乎表明 Java 可以在实践中做到这一点？

更新:请注意，在 main 中创建 newEntity 会创建一个匿名子类，并且正在调用 init() 方法仅针对该匿名子类重写。这在下面的两个优秀答案中得到了更好的解释。

最佳答案

据我所知这里没有什么特别的，只是经典constructor chaining以及应用于虚方法调用的多态性。

当你实例化你的匿名类时，它会自动调用它的 default constructor (由编译器自动给出)，在其默认构造函数成功之前，它必须首先调用其父类默认构造函数，该默认构造函数又将调用 init() 方法，因为它已被重写通过您的匿名类，以多态方式结束调用子类中的 init 方法，该方法将模型初始化为您的 SubModel 实例。

约书亚·布洛赫 (Joshua Bloch) 在他的名著 Effective Java 中针对这种模式提出了一些有趣的论点。 ，在 “第 17 项:继承或禁止的设计和文档” 部分，他写道:

“There are a few more restrictions that a class must obey to allow inheritance. Constructors must not invoke overridable methods, directly or indirectly. If you violate this rule, program failure will result. The superclass constructor runs before the subclass constructor, so the overriding method in the subclass will get invoked before the subclass constructor has run. If the overriding method depends on any initialization performed by the subclass constructor, the method will not behave as expected. To make this concrete, here's a class that violates this rule:”

然后他继续举了一个你会好好学习的例子:

“Here's a subclass that overrides the overrideMe, method which is erroneously invoked by Super's sole constructor:”

public class Super {
    // Broken - constructor invokes an overridable method
    public Super() {
        overrideMe();
    }

    public void overrideMe() {
    }
}

public final class Sub extends Super {
    private final Date date; // Blank final, set by constructor

    Sub() {
        date = new Date();
    }

    // Overriding method invoked by superclass constructor
    @Override public void overrideMe() {
        System.out.println(date);
    }

    public static void main(String[] args) {
        Sub sub = new Sub();
        sub.overrideMe();
    }
}

“You might expect this program to print out the date twice, but it prints out null the first time, because the overrideMe method is invoked by the Super constructor before the Sub constructor has a chance to initialize the date field. Note that this program observes a final field in two different states! Note also that if overrideMe had invoked any method on date, the invocation would have thrown a NullPointerException when the Super constructor invoked overrideMe. The only reason this program doesn't throw a NullPointerException as it stands is that the println method has special provisions for dealing with a null argument.”

因此，正如您所看到的，正如 Joshua Bloch 解释得很好的那样，风险潜伏在阴影中:在您可以在重写方法中执行的操作的可能性中，您有权访问构造函数链的实例变量还没有机会初始化。关键是在构造函数链完全初始化之前，您不应该被允许接触对象状态。

您可能会说在您的特定情况下不会发生这种情况，因为您没有非法更改状态并且您的覆盖方法是 protected ，而不是公开的，但问题是任何接触此代码的人都需要非常清楚地了解所有这些事情发生在幕后，发生在当前代码以外的地方。在维护期间很容易犯严重的错误，特别是当您或其他开发人员回到这里进行更改时，可能在最初定义后数月甚至数年，并且失去了所有这些危险的背景，有人引入了一个错误将很难找到和修复。

关于Java - (匿名子类)在对象实例构造期间覆盖方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43877035/