Question

嘿，你们在那里的人，

我在问自己以下问题。这应该用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 extends B扩展的。我现在要访问A，B和C中的所有值。我该如何执行强制操作，即无论何时添加新的子类，程序员都必须定义这些AInterface枚举（可选），以及如何强制他实现一个在类层次结构上递归调用的方法（不是可选的）。我不需要定义一个抽象方法或覆盖一个抽象方法的帮助。我想做的是不覆盖现有实例，也不向要调用的每个继承类添加一个抽象方法。

老实说，我不知道如何问这个问题，但是我希望外面的人理解我的意思。如果不发表评论。

Answer 1

方法的可见性很重要。您不能强迫子类实现现在不再抽象的possibleFurtherRequests，但这是它们唯一需要的方法。您也不能强迫他们调用super方法。代码审查为此很好地工作。

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

通过类层次结构进行尾递归

1 个答案: