2021-04-29

多态

1. 什么是向上造型？什么是向下造型？有什么特殊规定？

   子类向父类的转换成为向上转型

   父类类型转换为子类类型

2. 以下代码的执行结果是什么？ A

   public class Example {
    int i = 100;
   
    public void print() {
        System.out.println(50);
    }
   
    public static void main(String[] args) {
        Example a = new A();
        System.out.println(a.i);
        a.print();
    }
   }
   
   class A extends Example {
    int i = 200;
   
    public void print() {
        System.out.println(300);
    }
   }
   

   A．100 300

   B． 200 300

   C． 100 50

   D． 200 50

3. 给出下面的代码段: B

   class Base {
   }
   
   class Sub extends Base {
    public String getFields() {
        String name = "Sub";
        return name;
    }
   }
   
   class DoSub {
    public static void main(String[] args) {
        Base b = new Sub();
        // 插入语句处
    }
   }
   

   在插入语句处插入那条代码能够输出Sub？

   A．System.out.println(b.getFields());

   B．System.out.println(b.name);

   C．System.out.println((Base)b.getFields());

   D．System.out.println(((Sub)h).getFields());

4. 下面代码的运行结果是： B

   public class Example {
    public static void main(String[] args) {
        Base b = new Base();
        Subclass1 S1 = new Subclass1();
        Subclass2 s2 = new Subclass2();
        s1 = (Subclass1) s2;
    }
   }
   
   class Base {}
   
   class Subclass1 extends Base {
   }
   
   class Subclass2 extends Base {
   }
   

   A. 代码编译成功，运行期间没有异常抛出

   B. 代码编译失败，赋值语句s1 = （Subclass1）s2非法

   C. 代码编译成功，但运行时出现对象造型异常

   D. 代码编译失败，因为一个基类不能被多个子类继承

1. 什么是方法重写？

   在继承关系中，子类会自动继承父类中定义的方法，但有时子类需要对继承的方法进行一些修改，即对父类的方法的重写

2. 方法重写的判断依据是什么？

   重写方法和被重写方法必须具有相同的方法名、相同的参数列表和相同的返回值类型，重写方法的返回值必须大于被重写方法的访问修饰符

3. 继承有什么好处？

   提高了代码的重用性，子类继承父类的所有方法和属性

   提高了代码的可扩展性，子类可以写自己独特的属性和方法

4. Java是单继承还是多继承？

   单继承 但可以多层继承

5. 定义父类 Father, 有 age,name 属性，定义speak()方法 打印 介绍信息。定义 2 个子类，Boy 和 gril两个子类，分别实现重写speak() 方法。

6. 一个类没有继承任何类，有父类么？

   Object是Java所有类的父类 有

7. 方法重载和方法重写有什么不同？

   方法重写是在他继承的子类中

   方法重载是在同一个类中

   方法重载参数列表不能相同

   方法重写参数列表必须相同

8. 为什么很多类要重写 equals 方法 ？

   equals首先判断两个对象的内存地址是否相同，再判断是否是同一地址，最后再判断里面的属性值是否相等

9. 为什么Integer 要将 -127 ~ 128 缓存起来 ？

10. 请问以下哪个程序代码体现了对象之间的继承（is a）关系？ B

A．

public class Color {}

public class Shape {
 private Color color;
}

B.

public class Component {}

public class Cpmtaomer extends Component {
    private Component[] children;
}

C.

public class Species{}

public class Animal{ 
    private Species species;
}

D.

public class Animal{ 
    private Species species;
    public class Species{}

}

9. 以下代码的执行结果是 A

   public class Example {
    String s = "Outer";
    public static void main(String[] args) {
        S2 s2 = new S2();
        s2.display();
    }
   }
   
   class S1 {
    String s = "S1";
    void display() {
           System.out.println(s);
    }
   }
   
   class S2 extends S1 {
    String s = "S2";
   }
   

   A. S1

   B. S2

   C. null

   D. Outer

10. 关于构造器说法错误的是？ A

    A. 构造器不属于类成员方法，因此构造器不能被继承

    B. 只有构造器才能拥有和类名相同的方法名

    C. 一个类可以拥有多个重载的构造器

    D. 在子类中调用父类的非默认构造器，必须使用super（...）语句，而且该语句必须位于子类构造器的第一行

11. 现有如下代码

    class Super {
        public float getNum() {
            return 3.0f;
        }
    }
    
    class Sub extends Super {
     // 空白处
    }
    

    请问以下哪个语句放置在注释的空白处会引起编译错误？

    A. public float getNum() { return 4.0f; }

    B. public void getNum(){}

    C. public void getNum(double d){}

    D. public double getNum(float d) { return 4.0; }

12. 请写出下面的程序的运行结果、

    1. static A static B I'm A class" HelloA I'm B class HelloB

    package demo;
    
    class HelloA {
        public HelloA() {
            System.out.println("HelloA");        //构造方法
        }
    
        { 
            System.out.println("I'm A class");        //普通代码块
        }
        static {
            System.out.println("static A");       //静态的初始化代码块
        }
    }
    
    public class HelloB extends HelloA {
    
        static {
            System.out.println("static B");   子类的静态的初始化代码块
        }
    
        {
            System.out.println("I'm B class");  普通代码块
        }
    
        public HelloB() {
            System.out.println("HelloB");       构造方法
        }
    
        public static void main(String[] args) {
            new HelloB();
        }
    }
    
    

13. 请写出下面的代码运行的结果，并写出原因

    int a = 100;
    int b = 100;
    System.out.println( a == b )
    
    Integer c = 100;
    Integer d = 100;
    System.out.println( c == d )
    System.out.println( c.equals(d) )
    

    int a = 1000;
    int b = 1000;
    System.out.println( a == b )
    
    Integer c = 1000;
    Integer d = 1000;
    System.out.println( c == d )
    System.out.println( c.equals(d) )
    

    true true true true true true