java - 警告开发人员在 java 中调用 `super.foo()`

Question

假设我有这两个类，一个扩展另一个

public class Bar{

    public void foo(){

    }

}

public class FooBar extends Bar {

    @Override
    public void foo(){
        super.foo(); //<-- Line in question
    }

}

我想做的是警告用户调用父类(super class)的方法 foo 如果他们没有在覆盖方法中，这可能吗？

或者如果我将类类型传递给父类(super class)，是否有一种方法可以使用反射知道覆盖其父类(super class)方法的方法调用原始方法？

例如:

public abstract class Bar{

    public Bar(Class<? extends Bar> cls){
        Object instance = getInstance();
        if (!instance.getClass().equals(cls)) {
            throw new EntityException("The instance given does not match the class given.");
    }
        //Find the method here if it has been overriden then throw an exception
        //If the super method isn't being called in that method
    }

    public abstract Object getInstance();

    public void foo(){

    }

}

public class FooBar extends Bar {

    public FooBar(){
        super(FooBar.class);
    }

    @Override
    public Object getInstance(){
        return this;
    }

    @Override
    public void foo(){
        super.foo();
    }

}

也许我什至可以在 super 方法上加上注释，以表明它需要被调用？

---

编辑

注意，不是父类(super class)需要调用foo方法，而是有人调用了子类的foo方法，比如数据库close方法

如果归根结底，我什至会很高兴让方法“不可覆盖”，但仍然想给它一个自定义消息。

---

编辑2

这就是我想要的某种方式:

但是如果有上面的东西还是不错的，或者甚至给他们一个自定义消息来做其他事情，比如，不能覆盖 Bar 的 final 方法，请改为从方法的实现中调用它

Answer 1

编辑:回答已编辑的问题，其中包括:

I would even be happy with making the method "un-overrideable"

...只需将方法设置为final。这将防止子类覆盖它。来自 section 8.4.3.3 of the JLS :

A method can be declared final to prevent subclasses from overriding or hiding it.

It is a compile-time error to attempt to override or hide a final method.

要回答原始问题，请考虑使用 template method pattern相反:

public abstract class Bar {
    public foo() {
        // Do unconditional things...
        ...
        // Now subclass-specific things
        fooImpl();
    }

    protected void fooImpl();
}

public class FooBar extends Bar {
    @Override protected void fooImpl() {
        // ...
    }
} 

这当然不会强制 FooBar 的子类覆盖 fooImpl 并调用 super.fooImpl() - 但是 FooBar 可以通过再次应用相同的模式来做到这一点 - 使其自己的 fooImpl 实现最终化，并引入一个新的 protected 抽象方法。