Java 如何根据传递给它的值更改行为或函数

我有两个函数，一个叫做min，另一个叫做max。 最小值从正无穷开始寻找它能得到的最小值，最大值从负无穷开始并试图找到最大值

private Node Max(State node, int depth, double max, double beta, Player player) {

        if(node.searchLimitReached() || node.over || depth <= 0)
            return new Node(node , heuristic(node, player));

        double value = Double.NEGATIVE_INFINITY;
        Node nextNode = new Node();
        Node bestNode = new Node();
        Iterator<State> iterator = node.next().iterator();

        while(!node.searchLimitReached() && iterator.hasNext()) {

            nextNode = Min(iterator.next(), depth-1, max, beta, player);
            if(nextNode.value > value) {
                value = nextNode.value;
                bestNode = nextNode;
            }

            if(value >= beta)
                return bestNode;

            max = Math.max(max, value);

        }
        return bestNode;
    }

private Node Max（State Node、int depth、double Max、double beta、Player）{
if（node.searchLimitReach（）| | node.over | |深度值）{
value=nextNode.value；
bestNode=nextNode；
}
如果（值>=beta）
返回最佳节点；
max=Math.max（max，value）；
}
返回最佳节点；
}

private Node Min（状态节点、int深度、双alpha、双Min、播放器）{
如果（node.searchLimitReach（）| | | node.over | | depth我想您可以尝试类似的方法（我没有检查Java代码）：

更抽象的方法是传入函数或每个不同的操作，但存在太多差异（即使差异很小），因此认为这是一个合理的解决方案。
    private Node Min(State node, int depth, double alpha, double min, Player player) {

        if(node.searchLimitReached() || node.over || depth <= 0)
            return new Node(node, heuristic(node, player));

        double value = Double.POSITIVE_INFINITY;
        Node nextNode = new Node();
        Node bestNode = new Node();
        Iterator<State> iterator = node.next().iterator();

        while(!node.searchLimitReached() && iterator.hasNext()) {
            nextNode = Max(iterator.next(), depth-1, alpha, min, player);

            if(nextNode.value < value) {
                value = nextNode.value;
                bestNode = nextNode;
            }

            if(value <= alpha)
                return bestNode;

            min = Math.min(min, value);
        }
        return bestNode;
    }

private Node Extreme(State node, int depth, double a, double b, Player player, boolean which) {
  if(node.searchLimitReached() || node.over || depth <= 0)
      return new Node(node, heuristic(node, player));

  double value = which ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
  Node nextNode = new Node();
  Node bestNode = new Node();
  Iterator<State> iterator = node.next().iterator();

  while(!node.searchLimitReached() && iterator.hasNext()) {
      nextNode = Extreme(iterator.next(), depth-1, a, b, player, !which);
      if(which && nextNode.value > value || !which && nextNode.value < value) {
          value = nextNode.value;
          bestNode = nextNode;
      }

      if(which && value >= b || !which && value <= a)
          return bestNode;

      if (which) a = Math.max(a, value);
      else b = Math.min(b, value);
  }
  return bestNode;
}

private Node Min(State node, int depth, double max, double beta, Player player) {
  return Extreme(node, depth, max, beta, player, true);
}

private Node Max(State node, int depth, double alpha, double min, Player player) {
  return Extreme(node, depth, alpha, min, player, false);
}