为什么这种方法不递归？

Question

我不太确定如何在不将整个代码都发布到这里的情况下问这个问题（这相当多），但是我会尽力而为。

我有一个实现接口的枚举类。 整个程序的目的是在Fields中表示一堆整数。 因此，有一个具体类TrueField是从抽象类AbstractField派生的，该类具有名为boolean sameAs(Field that)的方法的实现。 该方法在enum类中也存在（由于接口的原因，它必须存在）：

enum SimpleField implements Field{

  Empty(),Zero(0),Binary(0,1),Unsigned(Integer.MAX_VALUE);

  private Field simpleField;

  SimpleField(int... intArray){
      simpleField = new TrueField(intArray);
  }

  @Override
  public boolean sameAs(Field that){
      return that.sameAs(simpleField);
  }
}

从TrueField实施：

public class TrueField extends AbstractField{

private final int[] intArray;

TrueField(int... thatArray){
    intArray = thatArray;
}

@Override
public int at(int index){
    if(index<0 || index>=intArray.length){
        throw new IndexOutOfBoundsException();
    }

    return intArray[index];
}

@Override
public int length(){
    return intArray.length;
}
...

AbstractField：

public abstract class AbstractField implements Field{

@Override
public abstract int length();   


@Override
public boolean sameAs(Field that){
    if(that==null)
        throw new RuntimeException("that is null");

    boolean result = true;

    if(length()==that.length()){
        for(int i=0;i<length();i++){
            if(at(i)!=that.at(i))
                result = false;
        }
    }
    else
        result = false;

    return result;
}

@Override
public String toString(){

    String result = "";

    for(int i=0;i<length();i++){
        result += at(i);

        if(length()-i>1)
            result += ",";
    }

    return "["+result+"]";
}

}

我的问题是，当我在主要方法中执行以下操作时：

Field sf = SimpleField.Binary;
Field sf2 = SimpleField.Binary;
Field tf = new TrueField(1,2);

System.out.println(sf.sameAs(sf2));

...显然，枚举类中的sameAs方法被调用。 但是为什么它不再次调用自身，所以它是递归的呢？ 由于通过接口进行了动态绑定，因此JVM看到sf是动态类型SimpleField.Binary和静态类型Field 。 我不太了解发生了什么，以及为什么它不再自称。 我希望我已经足够清楚地解释了我的问题。

Answer 1

因为你这不是递归sameAs的方法SimpleField枚举调用sameAs参数对象，这不是一个方法SimpleField ，这是一个TrueField 。

因此， sameAs Field类中的声明运行sameAs方法。

在进一步检查时，它可以是递归的，但TrueField是TrueField类中的声明也是递归的， 因为上面已添加了此代码 ， 因此我们可以看到它不是递归的。

Answer 2

该方法不是递归的，因为它没有调用自身 。

@Override
public boolean sameAs(Field that){
    return that.sameAs(simpleField);
}

此方法使用参数调用sameAs 。 该参数很可能是相同的枚举，但它仍然没有自我称呼。

这是一个简单的递归方法的示例：

public long factorial(int value) {
    return value == 0 ? 1 : factorial(value-1);
}

在此，没有多余的引用可用于再次调用该方法。 我只是在参数稍有变化的情况下再次调用它。