Java 自动调用超类方法

考虑下面的类

class A{
    public void init(){
        //do this first;
    }
    public void atEnd(){
        //do this after init of base class ends
    }
}

class B1 extends A{

    @Override
    public void init()
    {
        super.init();
        //do new stuff.
        //I do not want to call atEnd() method here...
    }
}

我有几个B1，B2，。。。已开发的Bn儿童班。它们都扩展了类A。如果我想在它们中添加一个新功能，最好是在类A中的方法中定义它。但条件是，该方法应该总是在子类的init（）方法结束之前自动调用。 这样做的一个基本方法是在子类的init（）方法的末尾再次添加atEnd（）方法调用。但是有没有其他方法可以巧妙地做到这一点

生成

init（）

final

，并为用户提供一个单独的方法来覆盖中间的

init（）

调用：

class A{
    public final void init(){
        //do this first;
    }

    protected void initCore() { }

    public void atEnd(){
        //do this after init of base class ends
    }
}

class B1 extends A{

    @Override
    protected void initCore()
    {
        //do new stuff.
    }
}

使

init（）

final

，并为人们提供一个单独的方法来覆盖中间的

init（）

调用：

class A{
    public final void init(){
        //do this first;
    }

    protected void initCore() { }

    public void atEnd(){
        //do this after init of base class ends
    }
}

class B1 extends A{

    @Override
    protected void initCore()
    {
        //do new stuff.
    }
}

---

一种方法是使

init（）

final并将其操作委托给第二个可重写的方法：

abstract class A {
  public final void init() {
    // insert prologue here
    initImpl();
    // insert epilogue here
  }
  protected abstract void initImpl();
}

class B extends A {
  protected void initImpl() {
    // ...
  }
}

---

无论何时有人调用

init（）

，序言和尾声都会自动执行，派生类不必做任何事情。

一种方法是将

init（）

设置为final，并将其操作委托给第二个可重写的方法：

abstract class A {
  public final void init() {
    // insert prologue here
    initImpl();
    // insert epilogue here
  }
  protected abstract void initImpl();
}

class B extends A {
  protected void initImpl() {
    // ...
  }
}

---

每当有人调用

init（）

，序言和尾声都会自动执行，派生类不必做任何事情。

另一个想法是在方面中进行编织。向切入点添加前后建议。

另一个想法是在一个方面进行编织。向切入点添加前后建议。

其他答案都是合理的解决办法，但要解决确切的问题：不，没有办法自动完成。您必须显式调用

super.method（）

其他答案都是合理的解决方法，但要解决确切的问题：不，没有办法自动执行此操作。您必须显式调用

super.method（）

如果这是关于保护类不变量的，AOP将是一个非常糟糕的解决方案；不变量没有提到。根据提供的信息，我不确定“非常差”是否合适。如果这是关于保护类不变量，AOP将是一个非常差的解决方案。它是关于“做事情”；不变量没有提到。根据提供的信息，我不确定“非常差”是否合适。