已知如下一个类:classA｛int a1，a2；A（int i，int j）｛a1=i；a2=j；｝｝要求编写一个方法swap（）用来交换A类的两个成员变量的值

可以在 `classA` 中添加一个 `swap` 方法来实现交换成员变量的值，具体代码如下：

class classA {
public:
    int a1, a2;
    classA(int i, int j) {
        a1 = i;
        a2 = j;
    }
    void swap() {
        int tmp = a1;
        a1 = a2;
        a2 = tmp;
    }
};

这样，当需要交换 `classA` 的两个成员变量时，只需要调用 `swap` 方法即可。例如：

classA obj(1, 2);
cout << obj.a1 << " " << obj.a2 << endl; // 输出 1 2
obj.swap();
cout << obj.a1 << " " << obj.a2 << endl; // 输出 2 1

相关问题

35．按要求编写Java程序： （1）编写一个接口：InterfaceA，只含有一个方法int method(int n)； （2）编写一个类：ClassA来实现接口InterfaceA，实现int ...

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

// 定义接口 InterfaceA
interface InterfaceA {
    int method(int n);
}

// 实现接口 InterfaceA 的类 ClassA
class ClassA implements InterfaceA {
    // 实现接口中的方法 method
    public int method(int n) {
        int result = 0;
        for (int i = 1; i <= n; i++) {
            result += i;
        }
        return result;
    }
}

// 测试类 Test
public class Test {
    public static void main(String[] args) {
        // 创建 ClassA 类的实例
        ClassA classA = new ClassA();
        // 调用 ClassA 类实现的 method 方法，并输出结果
        System.out.println(classA.method(100)); // 输出 5050
    }
}

该程序中定义了一个名为 InterfaceA 的接口，只有一个方法 method，返回一个整数。接着定义了一个类 ClassA，实现了接口 InterfaceA 中的 method 方法，实现为求 1 到 n 的求和，并返回结果。最后，在 Test 类中创建了 ClassA 的实例，调用其 method 方法并输出结果。

按要求编写Java程序： （1）编写一个接口：InterfaceA，只含有一个方法int method(int n)； （2）编写一个类：ClassA来实现接口InterfaceA，实现int method(int n)接口方法时，要求计算1到n的和； （3）编写另一个类：ClassB来实现接口InterfaceA，实现int method(int n)接口方法时，要求计算n的阶乘（n!）； （4）编写测试类E，在测试类E的main方法中使用接口回调的形式来测试实现

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

// InterfaceA.java
public interface InterfaceA {
    int method(int n);
}

// ClassA.java
public class ClassA implements InterfaceA {
    public int method(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

// ClassB.java
public class ClassB implements InterfaceA {
    public int method(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        return n * method(n - 1);
    }
}

// TestE.java
public class TestE {
    public static void main(String[] args) {
        InterfaceA a1 = new ClassA();
        System.out.println("1 + 2 + ... + 10 = " + a1.method(10));

        InterfaceA a2 = new ClassB();
        System.out.println("5! = " + a2.method(5));
    }
}

在测试类E的main方法中，我们先创建了一个类ClassA的实例对象a1，再创建了一个类ClassB的实例对象a2，然后使用接口回调的方式，即通过接口类型InterfaceA来调用实现类的方法。最后输出计算结果。