自学Java第9Day

学习目标：面向对象进阶

---

学习内容：继承

---

学习时间：

下午 3 点-下午 6 点

---

学习产出：

面向对象三大特征：封装、继承、多态

继承

        Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

public class Manger extends Employee{}

        Manger称为子类（派生类），Employee称为父类（基类或超类） 

使用继承的好处

        可以把多个子类中重复的代码抽取到父类中，提高代码的复用性。

        子类可以在父类的基础上，增加其它的功能，使子类更强大。

什么时候用继承

        当类与类之间，存在相同（共性）的内容，并满足子类是父类的一种，就可以考虑用继承，来优化代码。

继承的特点

        Java只支持单继承，不支持多继承，但支持多层继承。

        单继承：一个子类只能继承一个父类。

        不支持多继承：子类不能同时继承多个父类。

        Java中所有的类都是直接或间接继承于Object类。

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码。 

练习(自己设计一个继承体系)

        现在有四种动物：布偶猫、中国狸花猫、哈士奇、泰迪。

        暂时不考虑属性，只要考虑行为。

        请按照继承的思想特点进行继承体系的设计。

        四种动物分别有以下的行为：

                ● 布偶猫：吃饭、喝水、抓老鼠

                ● 中国狸花猫：吃饭、喝水、抓老鼠

                ● 哈士奇：吃饭、喝水、看家、拆家

                ● 泰迪：吃饭、喝水、看家、蹭一蹭

代码如下：

public class Animal {
    public void eat(){
        System.out.println("吃东西");
    }
    public void drink(){
        System.out.println("喝水");
    }
}

public class Cat extends Animal{
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

public class Dog extends Animal{
    public void lookhome(){
        System.out.println("看家");
    }
}

public class Husky extends Dog{
    public void breaakhome(){
        System.out.println("拆家");
    }
}

public class Teddy extends Dog{
    public void touch(){
        System.out.println("蹭一蹭");
    }
}

public class Lihua {

}

public class Ragdoll extends Cat{

}

public class Test {
    public static void main(String[] args) {
        Ragdoll ragdoll=new Ragdoll();
        ragdoll.eat();
        ragdoll.drink();
        ragdoll.catchMouse();
        System.out.println("--------------");
        Husky husky=new Husky();
        husky.eat();
        husky.drink();
        husky.breaakhome();
    }
}

运行结果： 

吃东西
喝水
抓老鼠
--------------
吃东西
喝水
拆家

成员方法是否可以被继承

 继承中：成员变量的访问特点

        就近原则：谁离我近，我就用谁。

        先在局部位置找，本类成员位置找，父类成员位置找，逐级往上。

        System.out.println(name);                         从局部位置开始往上找
        System.out.println(this.name);                  从本类成员位置开始往上找
        System.out.println(super.name);               从父类成员位置开始往上找

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.ziShow();
    }
}
class Fu {
    String name = "Fu";
}
class Zi extends Fu {
    String name = "Zi";
    public void ziShow() {
        String name = "ziShow";
        System.out.println(name);//ziShow
        System.out.println(this.name);//Zi
        System.out.println(super.name);//Fu

    }
}

运行结果：

ziShow
Zi
Fu

---

方法的重写

        当父类的方法不能满足子类现在的需求时，需要进行方法重写。

书写格式

        在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

@Override重写注解

        1. @Override是放在重写后的方法上，校验子类重写时语法是否正确。

方法重写注意事项和要求

        1. 重写方法的名称、形参列表必须与父类中的一致。

        2. 子类重写父类方法时，访问权限子类必须大于等于父类(暂时了解：空着不写<protected<public)。

        3. 子类重写父类方法时，返回值类型子类必须小于等于父类。

        4. 建议：重写的方法尽量和父类保持一致。

        5. 只有被添加到虚方法表中的方法才能被重写。

练习

        利用方法的重写设计继承结构

        现在有三种动物:哈士奇、沙皮狗、中华田园犬

        暂时不考虑属性,只要考虑行为。
        请按照继承的思想特点进行继承体系的设计。

        三种动物分别有以下的行为：

                ● 哈士奇:          吃饭(吃狗粮)、              喝水、              看家、拆家

                ● 沙皮狗:          吃饭(吃狗粮、吃骨头)、喝水、              看家

                ● 中华田园犬:   吃饭(吃剩饭)、              喝水、              看家

public class Dog {
    public void eat(){
        System.out.println("吃狗粮");
    }
    public void drink(){
        System.out.println("喝水");
    }
    public void lookhome(){
        System.out.println("看家");
    }
}

public class Husky extends Dog {
    public void breakhome(){
        System.out.println("哈士奇在拆家");
    }
}

public class SharPei extends Dog{
    @Override
    public void eat(){
        super.eat();
        System.out.println("啃骨头");
    }
}

public class ChineseDog extends Dog{
    @Override
    public void eat(){
        System.out.println("吃剩饭");
    }
}

public class Test {
    public static void main(String[] args) {
        Husky husky=new Husky();
        husky.eat();
        husky.drink();
        husky.breakhome();
        husky.lookhome();
        System.out.println("-------------------------");
        ChineseDog chineseDog=new ChineseDog();
        chineseDog.eat();
        chineseDog.drink();
        chineseDog.lookhome();
        System.out.println("-------------------------");
        SharPei sharPei=new SharPei();
        sharPei.eat();
        sharPei.drink();
        sharPei.lookhome();
    }
}

运行结果：

吃狗粮
喝水
哈士奇在拆家
看家
-------------------------
吃剩饭
喝水
看家
-------------------------
吃狗粮
啃骨头
喝水
看家

继承中:构造方法的访问特点

        ● 父类中的构造方法不会被子类继承。

        ● 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。

为什么?

        ● 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。

        ● 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

怎么调用父类构造方法的?

        ● 子类构造方法的第一行语句默认都是:super()，不写也存在，且必须在第一行。

---

this、super使用总结

        ● this:理解为一个变量，表示当前方法调用者的地址值;

        ● super: 代表父类存储空间。

字键关	访问成员变量	法方员成问访	法方造构问访
this	全his.成员变量 访问本类成员变量	this.成员方法(…) 访问本类成员方法	this( ... ) 访问本类构方法
super	super.成员变量 访问父类成员变量	super.成员方法(…) 访问父类成员方法	super( ... ) 访问父类构造方法

练习

        带有继承结构的标准Javabean类

        1.经理

                成员变量：工号，姓名，工资，管理奖金
                成员方法：工作(管理其他人)，吃饭(吃米饭)

        2.厨师

                成员变量：工号，姓名，工资
                成员方法：工作(炒菜)，吃饭(吃米饭)

public class Employee {
    private String id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void work(){
        System.out.println("员工在工作");
    }
    public void eat(){
        System.out.println("吃米饭");
    }
}

public class Cook extends Employee{
    public Cook() {
    }

    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }
    @Override
    public void work(){
        System.out.println("在炒菜");
    }
}

public class Manger extends Employee{
    private double bouns;

    public Manger() {

    }
    //带全部参数的构造
    //父类+子类
    public Manger(String id, String name, double salary, double bouns) {
        super(id, name, salary);
        this.bouns = bouns;
    }

    public double getBouns() {
        return bouns;
    }

    public void setBouns(double bouns) {
        this.bouns = bouns;
    }
    @Override
    public void work(){
        System.out.println("管理其他人");
    }
}

public class Test {
    public static void main(String[] args) {
        Manger manger=new Manger("001","旭哥",12000,3000);
        System.out.println(manger.getId()+","+manger.getName()+","+manger.getSalary()+","+manger.getBouns());
        manger.work();
        manger.eat();
        System.out.println("----------------------");
        Cook cook=new Cook("002","蛋姐",10000);
        System.out.println(cook.getId()+","+cook.getName()+","+cook.getSalary());

        cook.work();
        cook.eat();
    }
}

运行结果：

001,旭哥,12000.0,3000.0
管理其他人
吃米饭
----------------------
002,蛋姐,10000.0
在炒菜
吃米饭