创建方法的最好方法是什么，只有超级（而不是其他子类）可以调用它们？

Question

TL; DR：我希望超类能够调用子类中的函数，而不需要不同的子类能够调用彼此的重写函数。我可以用一个Handler接口来实现这一点，子接口实例化后调用私有方法，但感觉很乱（见下面的代码）。有没有更好的办法？

---

我正在写一个简单的Java游戏，玩家将在学习编程时由学生编写游戏。游戏是一对一的，每个玩家都会告诉游戏引擎他们想要采取什么行动，并在周围定购​​单位。

我试图让游戏允许学生调用任何对他们可见的函数。目标是缺乏反思，无法作弊。在大多数情况下，这可以通过将Player子类放在与游戏引擎不同的包中轻松完成。

我遇到的问题是我需要玩家重写诸如doTurn，endGame和newGame等方法。但是，没有办法让这些可见的被覆盖，而不会让其他玩家可以看到它们。玩家需要能够互相访问以检查单位所有权等。

我现在的解决方案是有一个接口让子类把它们的方法包装进来，以便超类可以调用它们。

public abstract class Player { 
    public final String NAME; 
    private Handler handler; 

    public Player(String name) { 
     handler = getHandler(); 
     NAME = name; // note this is initialized AFTER handler 
    } 

    protected abstract Handler getHandler(); 

    // can be called by stuff in this package (engine) 
    // but not another package (where players are) 
    void doTurn() { 
     handler.doTurn(); 
    } 

    protected interface Handler { 
     void doTurn(); 
    } 
} 

另一个包

...

public class BasicPlayer extends Player { 
    public BasicPlayer() { 
     super("BasicPlayer"); 
    } 

    private void secretStrategies() { 
     // Actual logic goes here 
    } 

    @Override 
    protected Handler getHandler() { 
     // Null check makes handler only visible during super 
     return NAME != null ? null : new Handler() { 
      @Override 
      public void doTurn() { 
       secretStrategies(); 
      } 
     }; 
    } 
} 

我想初始化处理程序传递到超级匿名类，但不起作用，因为那么就不能“指的是实例方法/字段，同时显式调用构造函数。“也就是说，直到超级构造函数实际发生时，BasicPlayer和Player实例还不存在。因此，为了避免玩家访问彼此的处理程序，getHandler必须仅适用于super，所以NAME！= null就在那里。这对我来说真的很难受。如果我能够通过匿名课程，即使它仍然有点不可思议，但感觉不会太差。除了是非常奇怪的设计之外，我不能让玩家把他们所有的变量/逻辑放到一个匿名的Handler中传递给超级构造器，因为在Player中有函数需要他们调用，而这些函数是即使声明为final（仍然是“实例方法”）（这对编译器来说是有意义的，但仍然令人讨厌）。

有没有更好的实现方法？

Answer 1

我不确定我是否了解您的问题。你想授予一个方法的访问权限，但是如果调用者也是一个玩家呢？玩家由Player.class标识。您可以使用默认方法实现接口。该方法可以解释调用层次结构。类似这样的：

public class Player implements PlayerInterface { 

    public void doTurn() { 
     if (callerIsPlayer()) return; 
     secretStrategies(); 
    } 
} 

public interface PlayerInterface { 

default public boolean callerIsPlayer() { 
    StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace(); 
    for (int i = 1; i < stackTraceElements.length; i++) { 
     if (stackTraceElements[i].getClassName().endsWith("Player")) { 
      return true; 
     } 
    } 
    return false; 
} 

也许这有助于某种程度。

Answer 2

让我们尝试一下其他方法：隐藏方法的类是什么？像这样：

public class Player { 

    public void doTurn() { 

     SecretStrategies secretstrategies = new SecretStrategies(); 
     secretstrategies.doSomething(); 
    } 

    private class SecretStrategies { 

     public void doSomething() { 
      System.out.println("Secret"); 
     } 

    } 
} 

Answer 3

这是接口的用途。

你可以有2个接口：一个用于Player子类进行交互（暴露之类的东西getUnits，正如你所提到的）：

interface TargetPlayer { 
    List<Unit> getUnits(); 
} 

和一个用于任何需要打电话给newGame：

interface Processable { 
    void newGame(); 
} 

Player将实现这两​​个接口：

abstract class Player implements TargetPlayer, Processable { 
    private List<Unit> units; 

    // can implement newGame, or force subtypes to implement it 

    public final List<Unit> getUnits() { 
     return units; 
    } 
} 

个

亚型可以通过TargetPlayer接口与其他Player对象交互：

class PlayerSubOne extends Player { 

    // don't use Player, use TargetPlayer 
    public void interactWith(TargetPlayer player) { 
     List<Unit> units = player.getUnits(); // can access units 

     player.newGame(); // error, doesn't exist in TargetPlayer 
    } 

    @Override 
    public void newGame() { 

    } 
} 

这是一个简单的解决。我将用更深入（和坚固）的设计来编辑答案，因为这里仍然存在一些违反原则的行为。

---

调用在同一类的构造一个抽象方法应避免，因为它may lead to bugs。

Answer 4

我相信最简单的答案是尝试泛型。如果目的只是为了接受作为输入，类和其超类的实例，那么我会建议如下：

public class A{} 
public class B extends <? super A>{} 

这基本上可以归结为B伸出的任何类，它是A或它就像超类目的。