请编写类Test，在其main（）中实现计算“1+5+9+...+97”

以下是一个简单的实现：

public class Test {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 97; i += 4) {
            sum += i;
        }
        System.out.println("1+5+9+...+97=" + sum);
    }
}

在这个程序中，我们使用了一个循环来计算1到97之间所有4的倍数的和。我们从1开始，每次加4直到97。在循环中，我们将当前的值i加到变量sum中。最后，我们输出结果。

相关问题

编写 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();
}

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

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

// 类 C
class C {
    public void getResult(IComputable obj) {
        int result = obj.compute();
        System.out.println("计算结果为：" + result);
    }
}

// 测试类 Test
public class Test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        C c = new C();
        c.getResult(a);
        c.getResult(b);
    }
}

运行测试类 Test 的 main 方法，可以得到以下输出结果：

计算结果为：4037913
计算结果为：4

按要求编写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 方法输出计算结果。