我注意到我的递归fibonacci算法只适用于大于12的值。
我猜你的意思是写“值小于12”。不管怎样，这都不是真的：您的解决方案适用于大于12的值，直到结果类型溢出为止。
也就是说，您的代码存在多个问题。
不要测试 if(memory==null) 在构造函数中。这总是真的。 memory[f-1] != 0 && memory[f-2] != 0 && f>2 -你为什么要测试 f > 2 在这里？只有在开始测试时才有意义，以避免访问负数组元素。否则测试是多余的。
整个功能比必要的更复杂。分离访问记忆值的逻辑，使其更清晰、更简单、更不容易出错：

public int recursive(int f){
    if (f > 2 && memory[f - 2] == 0) {
        memory[f - 2] = recursive(f - 2);
    }
    if (f > 1 && memory[f - 1] == 0) {
        memory[f - 1] = recursive(f - 1);
    }
    memory[f] = memory[f - 2] + memory[f - 1];
    return memory[f];
}

  … 当然，你可以而且应该进一步简化：

public int recursive(int f){
    if (memory[f] == 0) {
        memory[f] = recursive(f - 2) + recursive(f - 1);
    }
    return memory[f];
}

这也一样。但是，不是每个函数调用都对记忆值执行多个冗余检查，而是简单地处理自己的值（即。 f 的），并要求自己的休息。
从根本上说，将它作为一个带有构造函数和附加函数的类是毫无意义的：该函数只能用于获取单个值的fibonacci数，此外，构造函数和函数调用中的fibonacci数必须相同（这很容易出错！）。例如，以下代码崩溃： new Fibonacci2(10).recursive(15) . 这也是： new Fibonacci2(1) . 好的代码不会允许这样的错误发生。
以下是一个不存在这些问题的解决方案：

class Fib {
    static int memory[];

    private static void resizeMemory(int newSize, int[] oldValues) {
        if (newSize < 3) newSize = 3;
        memory = new int[newSize];
        System.arraycopy(oldValues, 0, memory, 0, oldValues.length);
    }

    public static int fib(int n) {
        if (memory == null || memory.length <= n) {
            resizeMemory(n + 1, new int[] {0, 1, 1});
        }

        if (n == 0) return 0;
        if (memory[n] == 0) memory[n] = fib(n - 2) + fib(n - 1);
        return memory[n];
    }
}

但我还是不会像这样写一个“真正的”斐波那契实现 — 维护一个全局内存缓存会带来复杂性，而且没有真正的用途。这里有一个不使用缓存的高效实现。实际上，如果你计算很多斐波那契数，它的效率只会降低，即使这样，这也不可能成为瓶颈。
为了说明这一点，这里是这样的：

private static int fibImpl(int n, int a, int b) {
    if (n == 0) return a;
    if (n == 1) return b;
    return fibImpl(n - 1, b, a + b);
}

public static int fib(int n) {
    return fibImpl(n, 0, 1);
}