Java 通过类层次结构发生的尾部递归

嘿，你们这些人

我在问自己以下问题。这应该在Java中完成，但因为我不知道怎么做，所以一个概念也会有帮助： 我有以下代码：

public abstract class A {

   protected enum AType implements AInterface {
     A_VALUE
   }

   public AInterface[] possibleRequests() {
      AInterface types = AType.values();
      return ArrayUtils.concat(types, possibleFurtherRequests());
   }

   public abstract AInterface[] possibleFurtherRequests();

}

public class B extends A {

   protected enum BType implements BInterface {
     B_VALUE
   }

   @Override
   protected AInterface[] possibleFurtherRequests() {
      //Here is my problem.
      return BType.values();
   }
}

public interface AInterface {
}

public interface BInterface extends AInterface {
}

我想做的是让这些

possibleRequest

-方法具有无限的深度。它们应该只能通过

A

访问，我不知道

A

类型的对象属于哪个类，也不应该知道

我所说的不确定深度的意思是，这个概念是用

C扩展B

来扩展的。现在我想访问

A

、

B

和

C

中的所有值。我如何强制，无论何时添加新的子类，程序员都必须定义这些

AInterface

-枚举（可选），以及我如何强制他实现一个方法，然后在类层次结构上递归调用该方法（非可选）。 我不需要帮助定义抽象方法，也不需要重写抽象方法。我要做的是不要覆盖现有的类，也不要向每个被调用的继承类添加抽象方法

我真的不知道该怎么问这个问题，但我希望有人能理解我的意思。

---

如果没有，请留下评论。

方法的可见性很重要。您不能强制子类实现现在不抽象的possibleFurtherRequests，但这是它们需要的唯一方法。你也不能强迫他们调用超级方法。代码审查可以很好地实现这一点

protected enum AType implements AInterface {
    A_VALUE
}

protected enum BType implements BInterface {
    B_VALUE
}

public abstract class A {

    final public AInterface[] possibleRequests() {
        return possibleFurtherRequests();
    }

    protected AInterface[] possibleFurtherRequests() {
        return AType.values();
    }

    protected AInterface[] combine(AInterface[] some, AInterface[] more) {
        AInterface[] combined = new AInterface[some.length + more.length];
        System.arraycopy(some, 0, combined, 0, some.length);
        System.arraycopy(more, 0, combined, some.length, more.length);
        return combined;
    }
}

public class B extends A {

    @Override
    protected AInterface[] possibleFurtherRequests() {
        return combine(super.possibleFurtherRequests(), BType.values());
    }
}

public interface AInterface {
}

public interface BInterface extends AInterface {
}

public void test() {
    AInterface[] result = new B().possibleRequests();
    Stream.of(result).forEach(System.out::println);
}

结果是

A_VALUE
B_VALUE

---

方法的可见性很重要。您不能强制子类实现现在不抽象的possibleFurtherRequests，但这是它们需要的唯一方法。你也不能强迫他们调用超级方法。代码审查可以很好地实现这一点

protected enum AType implements AInterface {
    A_VALUE
}

protected enum BType implements BInterface {
    B_VALUE
}

public abstract class A {

    final public AInterface[] possibleRequests() {
        return possibleFurtherRequests();
    }

    protected AInterface[] possibleFurtherRequests() {
        return AType.values();
    }

    protected AInterface[] combine(AInterface[] some, AInterface[] more) {
        AInterface[] combined = new AInterface[some.length + more.length];
        System.arraycopy(some, 0, combined, 0, some.length);
        System.arraycopy(more, 0, combined, some.length, more.length);
        return combined;
    }
}

public class B extends A {

    @Override
    protected AInterface[] possibleFurtherRequests() {
        return combine(super.possibleFurtherRequests(), BType.values());
    }
}

public interface AInterface {
}

public interface BInterface extends AInterface {
}

public void test() {
    AInterface[] result = new B().possibleRequests();
    Stream.of(result).forEach(System.out::println);
}

结果是

A_VALUE
B_VALUE

---

为什么不从

super.possibleRequests（）

获取结果，创建一个新的

AInterface[]

，然后将

super.possibleRequests（）

的结果与当前类的“enum

value

组合并返回该结果呢？你是对的，这是一种方法。我真是太蠢了。然而，这并不能回答如何实施这种行为的问题。另一个程序员可能很容易忘记调用

super.possibleRequests（）

。您不能强制继承者执行某些行为，但您可以对其进行Javadoc，以便人们知道您希望他们调用

super.possibleRequests

。为什么不从

super.possibleRequests（）

，创建一个新的

AInterface[]

，然后将来自

super.possibleRequests（）

的结果与当前类的enum

值组合，并返回该值？没错，这是一种方法。我真是太蠢了。然而，这并不能回答如何实施这种行为的问题。另一个程序员可能很容易忘记调用
super.possibleRequests（）
。您不能强制继承者执行某些行为，但您可以对其进行Javadoc，以便人们知道您希望他们调用
super.possibleRequests
。