08

A:简答题

1、继承的好处是什么?

提高代码的复用性和维护性

2、Java中的类的继承特点是什么以及继承的注意事项?

特点：JAVA中只支持单继承，不支持多继承，但支持多层继承；注意事项：子类只能继承父类非私有成员，构造方法不参与继承，静态方法可以参与继承，不要为了部分功能去继承。

3、this和super分别是什么，他们各自的应用场景是什么?

this代表是本类的一个引用，谁调用这个方法，this就代表谁，super可以调用父类的数据；this.变量名 方法名 ；this（）调用本类的空参构造；super.变量名 super.方法名 super（）调用空参构造。

4、什么是方法重写?需要注意哪些问题?

在创建子类对象时，如果对父类中的某些功能不满意时，可以在子类中对父类的方法进行重写，就是在子类中出现和父类一样的方法时，子类方法就会覆盖父类方法，运行的是子类重写的方法。注意事项：父类私有的方法子类不能重写；子类在重写父类方法时，权限修饰符不能比父类的低public>protected>缺省>private;静态方法不参与重写

5、方法重写和重载有什么区别?

方法重写是在继承的前提下才有，而方法重载时在一个类中有重名方法时，根据参数的个数和类型不同来区分同名方法的。

6、子父类中构造方法的执行有什么特点?为什么要这样?

如果子类继承父类，那么父类中的构造方法会优先于子类的构造方法执行，因为我们在创建子类的对象时，应该先完成父类数据的初始化，再初始化子类的数据。

7、静态代码块，构造代码块，构造方法的执行顺序是什么以及执行特点?

静态代码块最先执行，接下来时构造代码块，最后时构造方法；执行特点：无论new多少次对象，静态代码只执行一次，而构造代码块和构造方法每次都会执行。

8、final关键字是什么意思，可以修饰那些成员?被修饰的成员有哪些特点?

最终的，可以修饰局部变量，成员变量，也可以修饰方法和类，被修饰的变量为常量（基本数据类型），值不能被改变；如果修饰的引用数据类型，指的是地址值不能被改变；被修饰的方法不能重写，但可以继承；常量名一般大写；被修饰的类不能被继承。

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。

1、请写出程序的运行结果

​ class Fu {

​ public int num = 10;

​ public Fu() {

​ System.out.println(“fu”);

​ }

​ }

​ class Zi extends Fu{

​ public int num = 20;

​ public Zi() {

​ System.out.println(“zi”);

​ }

​ public void show() {

​ int num = 30;

​ System.out.println(num);

​ System.out.println(this.num);

​ System.out.println(super.num);

​ }

​ }

​ class Test {

​ public static void main(String[] args) {

​ Zi z = new Zi();

​ z.show();

​ }

​ }

结果：

30

20

10

2、请写出程序的运行结果

public class Demo {

public void method(int age){

System.out.println(“int age”);

}

public void method(String name){

System.out.println(“String name”);

}

public void method(String name, int age){

System.out.println(name +"—"+ age);

}

public static void main(String[] args){

Demo d = new Demo();

d.method(“小明”);

d.method(18);

}

}

结果：

int age

String name

3、给出以下代码，请问该程序的运行结果是什么？

class Demo {

String s = “Outer”;

public static void main (String[] args) {

S2 s2 = new S2();

s2.display();

}

}

class S1 {

String s = “S1”;

public void display(){

System.out.println(s);

}

}

class S2 extends S1 {

String s = “S2”;

}

结果：

S1

4、给出以下代码，请问该程序的运行结果是什么？

class S1 {

public static void main(String[] args) {

new S2();

}

public S1(){

System.out.println(“S1”);

}

}

class S2 extends S1 {

public S2 () {

System.out.println(“S2”);

}

}

结果：

S1

S2

5、给出以下代码，请问该程序的运行结果是什么？如有问题，请指正。

class A {

int x = 0;

A(int w){

x = w;

}

}

class B extends A {

int x = 0;

B(int w){

x = w+1;

}

}

class Demo {

public static void main(String[] args){

B b = new B(100);

}

}

在子类B中的有参构造首行应该有super（w:），输出结果为101

6、给出以下代码，请问该程序的运行结果是什么？如有问题，请指正。

class Demo {

int max;

void Demo(){

max = 100;

System.out.println(max);

}

Demo(int i){

max = i;

System.out.println(max);

}

public static void main (String[] args) {

new Demo();

new Demo(123);

}

}

因为Demo类中没有提供空参构造，所以不能直接new对象

C:编程题

1、编写java程序，分析如下需求，写出你分析的类有哪些，以及功能。最后写一个测试类，针对每个类的功能进行测试。

​ 动物园里有很多种动物：

​ 比如说，狗，猫等。

​ 狗有姓名和年龄，猫也有姓名和年龄。

​ 狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。

​ 狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。

​ 请用所学知识，对这个问题进行解决。

​ 父类

​ 成员变量

​ 成员方法

​ 子类

​ 重写方法

​ 特有方法

​ 测试类

​ 普通调用

public class CeShi {//测试类
    public static void main (String[] args) {
        Cat cat = new Cat();
        cat.age=2;
        cat.name="小花";
        System.out.println(cat.age);
        System.out.println(cat.name);
        cat.eat();
        Cat.run();
        Dog dog = new Dog();
        dog.age=3;
        dog.name="小胖";
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat();
        Dog.run();
    }
}
public class Animal {//动物类
    public String name;
    public int age;
    public final static void run(){
        System.out.println("跑步");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
public class Dog extends Animal {//狗类
  public void eat(){
      System.out.println("狗吃骨头");
  }
}
public class Cat extends Animal {//猫类
    public void eat(){
        System.out.println("猫吃鱼");
    }
}