每日练习8.22

1.正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int a,b;
        while(in.hasNextInt()){
            a = in.nextInt();
            b = in.nextInt();
            System.out.println(lcm(a,b));
        }
    }
    public static int lcm(int a,int b){
        int mul = a*b;
        return mul/gcd(a,b);
    }
    public static int gcd(int a,int b){
        int temp = a;
        while(a%temp!=0 || b%temp!=0){
            temp--;
        }
        return temp;
    }
}

---

1.Test.main()函数执行后的输出是（ D）

class Test {
    public static void main(String[] args) {
        System.out.println(new B().getValue());//10.return 17
    }
    static class A {
        protected int value;
        public A (int v) {
            setValue(v);
        }
        public void setValue(int value) {
            this.value= value;
        }
        public int getValue() {
            try {
                value ++;//2.value = 11   7.value = 17
                return value;
            } finally {
                this.setValue(value);
                System.out.println(value);//4.第一次输出22   9.第二次输出34
            }
        }
    }



    static class B extends A {
        public B () {
            super(5);
            setValue(getValue()- 3);//5.setValue(8)
        }
        public void setValue(int value) {
            super.setValue(2 * value);//1.value = 10   3.value = 22 //6.setValue(16)  8.34
        }
    }
}

A 11 17 34
B 22 74 74
C 6 7 7
D 22 34 17

本题中，始终需要遵循一个原则，即： 调用的方法都是实例化的子类中的重写方法，只有明确调用了super.xxx关键词或者是子类中没有该方法时，才会去调用父类相同的同名方法。

首先，在main函数中，【new B()】new了一个B类的实例化对象，在实例化对象时，调用了B类中的构造函数，执行【super(5)】，也就是public A(int v)------>setValue(v)，由于调用的方法必须是实例化子类中重写的方法的原则。因此，这里调用的是B类中的setValue(v)方法，此时B实例的value值设置为2 x 5 = 10，后执行super.setValue(10)，将value=10的值存储起来。

执行完super(5)后，执行构造函数中的【setValue(getValue()- 3)】中【getValue()】，由于B类中没有getValue()方法，则调用父类（A类）中的getValue()方法，value++所得到的值为11，并存储在value中（先执行finally中的部分，后执行try中的return），在finally中，调用了【this.setValue(value)】，由于调用的方法必须是实例化子类中重写的方法的原则，调用的是B类中的setValue(v)方法，此时B实例的value值设置为2 x 11= 22，之后执行System.out.println(value)，即在控制台上打印22；

执行完finally中的部分，后执行try中的return,将value++执行后，存储在value中的11，return回去；执行【setValue(getValue()- 3)】，即：setValue(8)。

执行setValue(8)时，由于调用的方法必须是实例化子类中重写的方法的原则，则调用B类中的setValue(v)方法，此时B实例的value值设置为2 x 8= 16；此时B类中的构造函数执行结束。

在实例化对象以后，执行【new B().getValue()】，由于B类中没有getValue()方法，则调用父类（A类）中的getValue()方法，value++所得到的值为17，并存储在value中，在finally中，调用了【this.setValue(value)】，由于调用的方法必须是实例化子类中重写的方法的原则，调用的是B类中的setValue(v)方法，此时B实例的value值设置为2 x 17= 34，之后执行System.out.println(value)，即在控制台上打印34；

执行完finally中的部分，后执行try中的return,将value++执行后，存储在value中的17，return回去；执行【System.out.println(new B().getValue())】，即在控制台上打印17。