java继承和多态的试题分析

java继承和多态的试题分析

第一题：写出下面题目的运行结果

• 题目：

    interface A{}
    class B implements A {
        public String func() {
            return "func";
        }
    }
    class Demo {
        public static void main(String[] args) {
            A a=new B();
            System.out.println(a.func());
        }
    }

• 答案：
• 分析：题目中只有 A a=new B()，并没有向下转型，接口中没有定义func（）函数，所以不能调用，什么都不能输出。

第二题：写出程序结果

• 题目：

    class Fu {
        boolean show(char a){
            System.out.println(a);
            return true;
        }
    }
    class Demo extends Fu {
        public static void main(String[] args) {
            int i=0;
            Fu f=new Demo();
            Demo d=new Demo();
            for(f.show('A'); f.show('B')&&(i<2);f.show('C')) {
                i++;
                d.show('D');
            }   
        }
        boolean show(char a) {
            System.out.println(a);
            return false;
        }
    }

• 答案：
  A
  B
• 分析：判断中首先判断起始条件,执行了子类的show(‘A’) 然后,执行 show(‘B’)=false 所以条件不成立,直接结束循环。

第三题：写出程序结果

• 题目：

    interface A{}
    class B implements A {
        public String test()
        {
            return "yes";
        }
    }
    class Demo {
        static A get() {
            return new B();
        }
        public static void main(String[] args) {
            A a=get();
            System.out.println(a.test());
        }
    }

• 答案：

• 分析：test()是B特有方法,所以要进行强制转换 B b=(B) a;通过b.test()来输出为空。

第四题：写出程序结果

• 题目：

    class Super {
        int i=0;
        public Super(String a) {
            System.out.println("A");
            i=1;    
        }
        public Super() {
            System.out.println("B");
            i+=2;
        }
    }
    class Demo extends Super {
        public Demo(String a) {
            System.out.println("C");
            i=5;                
        }
        public static void main(String[] args) {
            int i=4;
            Super d = new Demo("A");
            System.out.println(d.i);
        }
    }

• 答案：
  B
  C
  5
  5

• 分析：系统默认了一个super（），会先执行父类构造函数，打印B C，然后调用调用Demo的构造器打印C 和 5，最后再调用对象的i值5。

第五题：写出程序结果

• 题目：

    class Fu {
        int num=4;
        void show() {
            System.out.println("showFu");
        }
    }
    class Zi extends Fu {
        int num=5;
        void show() {
            System.out.println("showZi");
        }
    }
    class T {
        public static void main(String[] args) {
            Fu f=new Zi();
            Zi z=new Zi();
            System.out.println(f.num); 
            System.out.println(z.num); 
            f.show();
            z.show(); 
        }
    }

• 答案：
  4
  5
  showzi
  showzi

• 分析：多态的特性编译的时候能不能访问看父类，运行时看父类所以打印了4，第二个是本来的引用变量所以打印5；f.show()、z.show()因为父类中有这个方法但是在子类中被重写了。

第六题：写出程序结果

• 题目：

    interface A {
        void show();
    }
    interface B {
        void add(int a,int b);
    }
    class C implements A,B {
        private int a,b;
        public void add(int a,int b){
            this.a =a;
            this.b = b;
        }
        public void show() {
           System.out.println(a+b); 
        }
    }
    class D {
        public static void main(String[] args) {
            C c=new C();
            c.add(4,2);
            c.show();
        }
    }

• 答案：
  6

• 分析：c.add(4,2)将值传入了c指向的对象，c.show()将两个值加起来打印出来了。

第七题：写出程序结果

• 题目：

    class Super {
        int i=0;    
        public Super(String s) {
            i=1;    
        }
    }
    class Demo extends Super{
        public Demo(String s){
            i=2;            
        }
        public static void main(String[] args){
            Demo d=new Demo("yes");
            System.out.println(d.i);
        }
    }

• 答案：
  2

• 分析：系统加了一个默认的super()构造器，然后在调用了Demo(String s)构造器将i的值更改为2。

第八题：写出程序结果

• 题目：

    class Super{
        public int get()
        {return 4;}
    }
    class Demo15 extends Super{
        public long get(){return 5;}
        public static void main(String[] args){
            Super s=new Demo15();
            System.out.println(s.get());
        }
    }

• 答案：

• 分析：返回类型不一样不能完成覆盖，会报错。