编写两个类，A和B,A创建的对象可以计算两个正整数的最大公约数，B创建的对象可以计算两个数的最小公倍数。要求：B类中有一个成员变量是用A类声明对象的。

下面是代码实现：

class A:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
    
    def gcd(self):
        a = self.num1
        b = self.num2
        while b:
            a, b = b, a % b
        return a


class B:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
        self.a = A(num1, num2)
    
    def lcm(self):
        gcd = self.a.gcd()
        return self.num1 * self.num2 // gcd


# 测试
a = A(6, 9)
print(a.gcd())  # 输出 3

b = B(6, 9)
print(b.lcm())  # 输出 18

在类B中，我们声明了一个成员变量`self.a`，它是用类A声明的对象，这样我们就可以在类B中直接使用类A的方法了。在`lcm`方法中，我们首先调用类A的`gcd`方法计算出两个数的最大公约数，然后用它来计算最小公倍数。

相关问题

用java编写两个类a和b,A创建的对象可以计算两个正整数的最大公约数,B 创建的对象可以计算两个数的最小公倍数。要求：B 类中有一个成员变量是用A类声明对象的。

以下是Java代码实现：

public class A {
    public int getGCD(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return getGCD(b, a % b);
        }
    }
}

public class B {
    private A a;

    public B(A a) {
        this.a = a;
    }

    public int getLCM(int a, int b) {
        return a * b / this.a.getGCD(a, b);
    }
}

在类A中，我们定义了一个方法getGCD，它使用欧几里得算法来计算两个正整数的最大公约数。在类B中，我们定义了一个成员变量a，它是用A类声明的对象。在构造函数中，我们将A类的对象传递给B类的构造函数。然后，我们定义了一个方法getLCM，它使用类A中的getGCD方法来计算两个数的最小公倍数。

编写两个类:A 和 B，A 创建的对象可以计算两个正整数的最大公约数，B 创建的对象可以计算两个数的最小公倍数。要求:B类中有一个成员变量是用A类声明对象。

Python 代码如下：

class A:
    def gcd(self, a, b):
        if b == 0:
            return a
        else:
            return self.gcd(b, a % b)

class B:
    def __init__(self):
        self.a = A()

    def lcm(self, a, b):
        return a * b // self.a.gcd(a, b)

其中，类 A 中的 gcd 方法使用递归算法计算两个正整数的最大公约数。类 B 中的 lcm 方法先调用 A 类中的 gcd 方法计算最大公约数，然后用两个数的乘积除以最大公约数得到最小公倍数。类 B 中的成员变量 a 是用 A 类声明的对象。