Java错题总结-继承和方法初始化问题

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

public class Main {
    public static void main(String [] args){
        System.out.println(new B().getValue());
    }
    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++;
                return value;
            } catch(Exception e){
                System.out.println(e.toString());
            } finally {
                this.setValue(value);
                System.out.println(value);
            }
            return value;
        }
    }
    static class B extends A{
        public B() {
            super(5);
            setValue(getValue() - 3);
        }
        public void setValue(int value){
            super.setValue(2 * value);
        }
    }
}

要点:

• super()方法调用的是父类的构造方法.

• main方法中new B()会执行B的无参构造,B的无参又通过super(5)访问A的有参,A的有参中执行了setValue(v)方法,但是因为B中重写了该方法所以此时执行的是B中的setValue(v)方法.

• finally 中的代码会在try中的代码执行完后但是return的值还没有返回的时候执行,return的值会保存在临时栈中

执行步骤:

正确答案：22,34,17

public class Main {
    public static void main(String [] args){
        System.out.println(new B().getValue());//1.new B()访问B的无参
                                               //19.执行getValue(),B中没有该方法所以执行的是A的
                                               //27.输出第三个值17
    }
    static class A{
        protected int value;//6.value=10
                            //9.value=11
                            //13.value=22
                            //18.value=16,至此new B()执行结束
                            //21.value=17
                            //24.value=34

        public A(int v) {
            setValue(v);//3.v=5 因为B重写了该方法所以这里执行的是B中的setValue           
        }
        public void setValue(int value){
            this.value = value;//5. value=10
                               //12.value=22
                               //17.value=16
                               //23.value=34
        }
        public int getValue(){
            try{
                value++;//8.自增value=11,return的值为11,但是在返回前先去执行finally 
                        //20.自增value=17.return的值为17,保存到临时栈再去执行finally 
                return value;//14.这里返回的是11
                             //26.这里返回 17
            } catch(Exception e){
                System.out.println(e.toString());
            } finally {
                this.setValue(value);//10.value=11 这里的this指的是B对象所以`setValue`执行的是B的
                                     //21.value=17 还是执行B的setValue
                System.out.println(value);//13.value=22这里输出第一个值22
                                          //25.value=34输出第二个值34
            }
            return value;
        }
    }
    static class B extends A{
        public B() {
            super(5);//2.访问父类A的有参
            setValue(getValue() - 3);//7. 先执行getValue()因为B没有重写所以去A中执行
                                     //15.又回到这里getValue()返回值为11,参数值为8
        }
        public void setValue(int value){
            super.setValue(2 * value);//4.value=5 又执行了父类的setvalue,参数计算值为10
                                      //11.value=11 再执行父类setValue,参数运算值为22
                                      //16.value=8,参数值为16,再次执行父类的setValue
                                      //22.value=17,执行父类的setValue,参数为34
        }
    }
}