编写一个类，该类有如下方法:。 public int f(inta.int b) {+ .. //要求该方法返回a和b的最大公约数+ } 再编写一个该类的子类，要求子类重写方法f0.而且重写的方法将返回两个整数的最小公倍数。+ 要求:在重写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将(a*b)/m返回;在应用的程序的主类中分别使用父类和子类创建对象，并分别调用方法f0计算两个正整数的最大公约数和最小公倍数。完整java语句

完整的 Java 语句如下：

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

public class LCMUtil extends MathUtil {
    @Override
    public int f(int a, int b) {
        int m = super.f(a, b);
        return (a * b) / m;
    }
}

public class Main {
    public static void main(String[] args) {
        MathUtil mathUtil = new MathUtil();
        int gcd = mathUtil.f(12, 18);
        System.out.println("12和18的最大公约数是：" + gcd);
        LCMUtil lcmUtil = new LCMUtil();
        int lcm = lcmUtil.f(12, 18);
        System.out.println("12和18的最小公倍数是：" + lcm);
    }
}

相关问题

编写一个类，该类有如下方法： public int f(int a,int b){ … //要求该方法返回a和b的最大公约数 } 再编写一个该类的子类，要求子类重写方法f(),而且重写的方法将返回两个整数的最小公倍数

下面是一个Java的实现示例：

public class MathUtil {

    public int f(int a, int b) {
        // 求最大公约数
        int gcd = 1;
        for (int i = 1; i <= a && i <= b; i++) {
            if (a % i == 0 && b % i == 0) {
                gcd = i;
            }
        }
        return gcd;
    }

    public static void main(String[] args) {
        MathUtil mu = new MathUtil();
        System.out.println(mu.f(12, 18)); // 输出 6
    }
}

class MathUtilSub extends MathUtil {

    @Override
    public int f(int a, int b) {
        // 求最小公倍数
        int lcm = a * b / super.f(a, b);
        return lcm;
    }

    public static void main(String[] args) {
        MathUtilSub mus = new MathUtilSub();
        System.out.println(mus.f(12, 18)); // 输出 36
    }
}

其中，`MathUtil` 类中的 `f()` 方法实现了求最大公约数的功能；而子类 `MathUtilSub` 重写了 `f()` 方法，实现了求最小公倍数的功能。在子类中，我们使用了 `super.f(a, b)` 来调用父类的 `f()` 方法，以获取最大公约数。

示例代码中还包含了一个 `main()` 方法，用于测试 `MathUtil` 和 `MathUtilSub` 类的功能。

编写一个类，该类有如下方法:。 public int f(inta.int b) {+ .. //要求该方法返回a和b的最大公约数+ } 再编写一个该类的子类，要求子类重写方法f0.而且重写的方法将返回两个整数的最小公倍数。+ 要求:在重写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将(a*b)/m返回;在应用的程序的主类中分别使用父类和子类创建对象，并分别调用方法f0计算两个正整数的最大公约数和最小公倍数。

请看下面的代码示例：

// 定义一个父类
public class Calculation {
    public int f(int a, int b) {
        // 计算a和b的最大公约数
        int m = gcd(a, b);
        return m;
    }

    // 求最大公约数
    private int gcd(int a, int b) {
        if (a == 0 || b == 0) {
            return a + b;
        }
        return gcd(b, a % b);
    }
}

// 定义一个子类
public class CalculationChild extends Calculation {
    @Override
    public int f(int a, int b) {
        // 首先调用父类中的方法求最大公约数
        int m = super.f(a, b);
        // 计算最小公倍数
        int lcm = a * b / m;
        return lcm;
    }
}

// 测试用例
public class Main {
    public static void main(String[] args) {
        // 创建父类对象
        Calculation cal1 = new Calculation();
        int gcd1 = cal1.f(12, 18);
        System.out.println("12和18的最大公约数是：" + gcd1);

        // 创建子类对象
        CalculationChild cal2 = new CalculationChild();
        int lcm1 = cal2.f(12, 18);
        System.out.println("12和18的最小公倍数是：" + lcm1);
    }
}

运行结果：

12和18的最大公约数是：6
12和18的最小公倍数是：36

在上面的代码中，我们定义了一个父类 Calculation，其中包含一个求最大公约数的方法 f。然后我们定义了一个子类 CalculationChild，继承自 Calculation，并重写了方法 f，计算最小公倍数。在重写的方法中，我们首先调用父类的方法求得最大公约数，然后用两个数的乘积除以最大公约数得到最小公倍数。最后，在主类中分别创建父类和子类的对象，调用相应的方法分别计算最大公约数和最小公倍数。