每日练习8.22

╰半夏微凉° 2024-04-17 05:33 31阅读 0赞

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。