防止子类添加方法

Question

这似乎是一件奇怪的事情，但是在Java中有没有办法阻止子类添加新方法（包括构造函数），同时仍然允许子类重写方法？

实际情况是，我们有一个带有一些抽象方法和构造函数的抽象类

abstract class A {
  abstract A doX();
  abstract boolean isY();
  public A(String s){ ... };
}

我们希望这个类的所有具体子类只重写这些方法和构造函数。

这是关于在我们的代码中强制使用某种风格，即阻止其他人在代码中添加内容。我们可以告诉他们不要这样做，但这很少奏效，所以我们想知道是否有一种程序化的方式来实现这一点。

显然，这个类不能是final。效率不是最重要的——更干净的代码更重要。

更新-动态方法

正如答案中所指出的那样，静态地实现这一点是不可能的，因为防止创建子类的唯一方法是使用final，这是行不通的。但我可以使用动态方法，所以我目前的解决方案是将这个方面添加到项目中（该项目已经使用了AspectJ）。

   public aspect WatchA{
      before() : execute(* A.*()) || execute(* A.*(..)) {
         String methodCalled = joinPoint.getSignature().getName();
         Class<?> c = Class.forName(args[0])
         Method[] allMethods = c.getDeclaredMethods();
         boolean found = false;
         for(Method m : allMethods)
           found |= m.getName().equals(methodCalled);
         if(!found) 
           throw new RuntimeException("Do not add method "+methodCalled+" to A");
      }
   }

如果他们使用这些新方法，这将导致他们的测试失败。




Answer 1

没有这种办法。为什么要强制执行这种编码风格？

如果你真的必须执行这样的风格，你可以创建一个“规则执行器”，它检查你的类路径，并将抽象父类的方法与其子类进行比较。

Answer 2

如果你真的不想这么做。。一种方法是通过编程在抽象类构造函数中检查类中定义的方法是否是允许的方法。

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public abstract class Base {

    private static final Set<String> allowedMethodNames = new HashSet<>(Arrays.asList("doThis", "wait", "wait", "wait", "equals", "toString", "hashCode", "getClass", "notify", "notifyAll"));

    public Base() {
        Set<String> allMethods = new HashSet<>();
        for (Method aMethod : getClass().getMethods()) {
            allMethods.add(aMethod.getName());
        }
        if (!allowedMethodNames.equals(allMethods)) {
            allMethods.removeAll(allowedMethodNames);
            throw new IllegalStateException("Following methods not allowed <" + allMethods + ">");
        }
    }

    public abstract void doThis();
}

public class Disallowed extends Base {

    @Override
    public void doThis() {
        System.out.println("dooooooo");
    }

    public void doSomethingElse() {
        System.out.println("not allowed");
    }

    public static void main(String[] args) {
            new Allowed().doThis();
        new Disallowed();
    }

}

public class Allowed extends Base {

    @Override
    public void doThis() {
        System.out.println("doing this");
    }


}

当有人试图创建“不允许”的实例时，它将失败。但是“新的”是允许的（）。doThis（）会很好用的。

一种更优雅的方法是引入自定义注释处理器，并在编译期间进行相同的检查。

Answer 3

你不能那样做。只有当类是final时，才能确保不能创建任何子类。

还可以将方法设置为final（即使是在抽象类中），这样就禁止重写它们。

最好的办法是创建一个接口，其中包含所有你希望可见的方法，并强制你的应用编程接口的所有用户通过这个接口访问对象。这样，即使实现添加了自己的东西，这些东西也不可见。

一种解决方案是实现一个工厂来返回具体的类；为了“增加安全性”，您可以将所有实现与此工厂放在同一个包中，并使构造函数包成为本地的（但这通常是不实际的）：

public final class MyFactory
{
    // ....
    public MyInterface getConcrete()
    {
        return new MyInterfaceImpl();
    }
    // etc etc -- getStones(), getTar(), getFeathers() and so on
}

请注意，构建器也可以用于此目的。