Day08练习

A:简答题

1、继承的好处是什么?
	代码重用性高 
	代码易维护
    多态的前提

2、Java中的类的继承特点是什么以及继承的注意事项?
特点
	java语言中只支持单继承
	支持多层继承(子类->父类->...)
注意事项
	子类不能继承父类的私有属性
	子类不能继承父类的构造方法 可以通过关键字super去访问父类构造方法

3、this和super分别是什么，他们各自的应用场景是什么?
this是本类对象的引用
super是父类对象的引用
应用场景
	访问属性
		this.属性名; 从本类开始查找属性 若找不到则从父类继续查找
		super.属性名; 从父类开始查找属性
	调用方法
    	this.方法名(); 从本类开始查找方法 若找不到则从父类继续查找
    	super.方法名(); 从父类开始查找方法
    调用构造方法
    	this(); 调用本类构造器 必须放在构造器首行
    	super(); 调用父类构造器 必须放在子类构造器首行
    	this和super不能同时在构造器中使用

4、什么是方法重写?需要注意哪些问题?
方法重写是子类与父类的方法一样 将父类的方法覆盖掉
注意事项
	子类最好与父类的方法一样
	父类的私有方法子类不能重写
	子类在方法重写时 权限修饰符不能小于父类的权限修饰符
	子类不能重写父类的静态方法

5、方法重写和重载有什么区别?
发生范围
	重写：父类与子类
	重载：本类
方法名
	重写：一致
	重载：一致
形参列表
	重写：一致
	重载：个数 顺序 类型至少有一个不同
返回类型
	重写：一致或者子类的返回类型是父类的返回类型的子类
	重载：无要求
修饰符
	重写：子类的修饰符不能小于父类的返回类型
	重载：无要求

6、子父类中构造方法的执行有什么特点?为什么要这样?
先执行父类的构造方法再执行子类的构造方法
子类继承父类的成员所以在子类初始化前先初始化父类的数据

7、静态代码块，构造代码块，构造方法的执行顺序是什么以及执行特点?
顺序
	静态代码块 > 构造代码块 > 构造方法
特点
	静态代码块：类中方法外 static修饰 用于给类初始化 加载时就执行 只执行一次
	构造代码块：类中方法外 将多个构造方法相同的代码放在一起 每次调用都执行 在构造方法前执行
	构造方法：初始化对象属性

8、final关键字是什么意思，可以修饰那些成员?被修饰的成员有哪些特点?
final关键字就是一个修饰符
修饰范围	
	final关键字就是修饰类 变量 成员方法
特点
    修饰类:被修饰类不能被继承
    修饰方法:被修饰的方法不能被重写
    修饰变量:被修饰的变量不能被重新赋值,因为这个量其实是一个常量

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

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

package org;
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

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);
    }
}
/*
fu
zi
30
20
10
*/

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

package org;
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);
    }
}
/*
String name
int age
*/

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

package org;
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、给出以下代码，请问该程序的运行结果是什么？

package org;
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、给出以下代码，请问该程序的运行结果是什么？如有问题，请指正。

package org;

class A {
    int x = 0;
    A(int w) {
        x = w;
    }
}

class B extends A {
    int x = 0;
    B(int w) {//系统无法给默认的super 所以需要自己调用父类构造器
        x = w + 1;
    }
}

class Demo {
    public static void main(String[] args) {
        B b = new B(100);
    }
}
/*
在第12行处添加super(w);
*/

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

package org;

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();//系统无法识别 需要在Demo类中添加一个无参构造
        new Demo(123);
    }
}
/*
在Demo类中添加 public Demo() {}
123
*/

C:编程题

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

动物园里有很多种动物：
比如说，狗，猫等。
狗有姓名和年龄，猫也有姓名和年龄。
狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。
狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。
请用所学知识，对这个问题进行解决。
父类: 成员变量 成员方法
子类: 重写方法 特有方法
测试类: 普通调用

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄", 2);
        System.out.println(dog.getName());
        System.out.println(dog.getAge());
        dog.run();
        dog.eat();
        System.out.println("======");
        Cat cat = new Cat("小黄", 1);
        System.out.println(cat.getName());
        System.out.println(cat.getAge());
        cat.run();
        cat.eat();
    }
}
/*
大黄
2
跑步
狗吃骨头
======
小黄
1
跑步
猫吃鱼
*/

public class Animal {
    private String name;
    private int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void run(){
        System.out.println("跑步");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);
    }

    public void eat() {
        System.out.println("猫吃鱼");
    }
}