按要求编写Java程序： （1）编写一个接口 Interface IComputable，包括一个方法 int compute( )； （2）编写一个类 A 实现 IComputable 接口， 其中的 int compute( )方法要求计算 并返回 1！+2！+...+10!的值； （3）编写一个类 B 实现 IComputable 接口，其中的 int compute( )方法要求计算并 返回 100 以内既能被 3 整除又能被 7 整除的整数个数； （4）编写类 C，有一个方法 void getResult 输出 compute( )方法的计算结果，使得 无论有多少个类实现了 IComputable 接口，都可以用 getResult 方法得到计算结果； （5）编写测试类 Test，在测试类 Test 的 main 方法中测试实现接口的类。

以下是按要求编写的 Java 程序：

// 定义接口 IComputable
interface IComputable {
    int compute();
}

// 实现接口 IComputable 的类 A
class A implements IComputable {
    // 实现接口中的方法 compute
    public int compute() {
        int result = 0;
        int factorial = 1;
        for (int i = 1; i <= 10; i++) {
            factorial *= i;
            result += factorial;
        }
        return result;
    }
}

// 实现接口 IComputable 的类 B
class B implements IComputable {
    // 实现接口中的方法 compute
    public int compute() {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0 && i % 7 == 0) {
                count++;
            }
        }
        return count;
    }
}

// 类 C，包含一个静态方法 getResult，输出 compute 方法的计算结果
class C {
    public static void getResult(IComputable obj) {
        System.out.println(obj.compute());
    }
}

// 测试类 Test
public class Test {
    public static void main(String[] args) {
        // 创建类 A 和类 B 的实例，并分别调用 getResult 方法
        A a = new A();
        C.getResult(a); // 输出 4037913
        B b = new B();
        C.getResult(b); // 输出 4
    }
}

该程序中定义了一个名为 IComputable 的接口，只有一个方法 compute，返回一个整数。接着定义了一个类 A，实现了接口 IComputable 中的 compute 方法，实现为求 1! + 2! + ... + 10! 的值，并返回结果。类 B 也实现了 IComputable 接口，其 compute 方法实现为求能被 3 整除又能被 7 整除的整数个数，并返回结果。类 C 中包含一个静态方法 getResult，接受一个 IComputable 类型的参数 obj，调用 obj 的 compute 方法并输出结果。最后，在 Test 类中创建了类 A 和类 B 的实例，并分别调用 C 中的 getResult 方法输出计算结果。