Java Day09

第一章 继承

1.1 概述

• 由来：多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需定义这些属性和行为，只需要继承那一个类即可。其中，多个类可以称为子类，单独的那一个类称为父类、超类或基类。继承描述的是事物之间的所属关系，这种关系是：is-a的关系。例如：狮子是动物，蚂蚁是昆虫等。可见父类更加的通用，子类更具体。我们通过继承可以使多种事物之间形成一种关系。
• 定义：继承就是子类继承父类的属性和行为，是的子类对象具有与父类相同的属性，相同的行为。子类可以直接访问父类中的非私有的属性和行为。
• 好处：
  • 提高了代码的复用性。
  • 类与类之间产生了关系，是多态的前提。

1.2 继承的格式

通过extends关键字，可以声明一个子类继承另一个父类，定义格式如下：

class 父类 {
    ...
}

class 子类 extends 父类 {
    ...
}

例如：

// 定义一个父类：员工
public class Employee {
    public void method() {
        System.out.println("方法执行");
    }
}

// 定义了一个员工的子类：讲师
public class Teacher extends Employee{

}

// 定义了员工的另一个子类：助教
public class Assistant extends Employee {

}

/*
* 在继承的关系中，子类就是一个父类，也就是说，子类可以被当作父类看待。
* 例如：父类是员工，子类是讲师，那么讲师就是一个员工
*
* 定义父类的格式：（一个普通的类的定义）
* public class 父类名称 {
*   //...
* }
*
* 定义子类的格式：
* public class 子类名称 extends 父类名称 {
*   //...
* }
*
*
* */

public class Demo01Extends {
    public static void main(String[] args) {
        // 创建了一个子类对象
        Teacher teacher = new Teacher();

        // teacher中虽然什么都没写，但是会继承来自父类的method方法
        teacher.method();

        // 创建另一个子类助教的对象
        Assistant assistant = new Assistant();

        //
        assistant.method();
    }
}

1.3 继承后的特点——成员变量

下面我们来看一下，当类之间产生了关系后，其中各类中的成员变量产生了什么关系？

1.3.1 成员变量不重名

• 如果子类父类中出现不重名的成员变量，这时的访问是没有影响的，代码如下：

public class Fu {
    int num = 10;
}

/*
 * 局部变量：直接写成员变量名
 * 本类的成员变量：this.成员变量名
 * 父类的成员变量：super.成员变量名
 *
 *
*/

public class Zi extends Fu {
    int num = 20;

    public void method() {
        int num = 30;
        System.out.println(num);  // 30,局部变量
        System.out.println(this.num);  // 20，本类的成员变量
        System.out.println(super.num);  // 10, 父类的成员变量
    }

}

public class Demo01ExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }

}

1.3.2 成员变量重名

• 如果子类父类中出现重名的成员变量，这时的访问是有影响的，代码如下：

public class Fu {
    int numFu = 10;
    int num = 100;

    // 使用的是本类当中的方法，不会向下找子类的
    public void methodFu() {
        System.out.println(num);
    }

}

public class Zi extends Fu {
    int numZi = 20;
    int num = 200;

    public void methodZi() {
        // 因为本类当中有num，所以这里用的是本类的num
        System.out.println(num);
    }
}

/*
* 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
*   直接：
*       直接通过子类对象访问成员变量
*       等号左边是谁，就优先用谁，没有则向上找。
*   间接：
*       通过成员方法访问成员变量
*       该方法属于谁，就优先用谁，没有则向上找
*
* */

public class Demo01ExtendsField {
    public static void main(String[] args) {
        Fu fu = new Fu();  // 创建父类对象
        System.out.println(fu.numFu);  // 只能使用父类的东西，没有任何子类内容

        Zi zi = new Zi();
        System.out.println(zi.numFu);
        System.out.println(zi.numZi);
        System.out.println("=====================");

        // 等号左边是谁，就优先用谁
        System.out.println(zi.num);  // 优先使用子类：200
        // System.out.println(zi.aaa);  // 到处都没有就编译报错。

        // 这个方法是子类的，优先使用子类的，没有再向上找
        zi.methodZi();

        // 这个方法是在父类当中定义的
        zi.methodFu();
    }
}

• 子父类中出现了同名的成员变量时，在子类中需要访问父类中的非私有成员变量时，需要使用super关键字，修饰父类成员变量，类似于我们之前学过的this。

super.父类中成员变量名;

• 父类中的成员变量是非私有的，子类中可以直接访问，若父类中的成员变量是私有的，子类是不能直接刚问的，只能通过getXxx方法。

1.4 继承后的特点——成员方法

下面我们来看一下，当类产生了关系之后，各类的成员方法又产生了哪些影响？

1.4.1 成员方法不重名

• 如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的成员方法，若子类当中有对应的成员方法子按照子类中的方法执行，否则就执行父类当中相应的父类的方法。代码如下：

/*
* 在父子类的继承关系中，创建子类对象，访问成员方法的规则：
*   创建的对象是谁，就优先使用谁，如果没有就向上找。
*
* 注意事项：
*   无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
*
* 重写（Override）
* 概念：在继承关系当中，方法的名称一样，参数列表也一样。
*
* 重写（Override）：方法的名称一样，参数列表也一样，又称为覆盖，覆写。
* 重载（Overload）：方法的名称一样，参数列表不一样。
*
* */

public class Fu {

    public void methodFu() {
        System.out.println("父类方法执行");
    }

    public void method() {
        System.out.println("父类重名方法执行！！！！");
    }

}

public class Zi extends Fu {

    public void methodZi() {
        System.out.println("子类方法执行！！！！");
    }

    public void method() {
        System.out.println("子类重名方法执行！！！！");
    }
}



public class DemoExtendsMethod {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.methodZi();
        zi.methodFu();

        // 创建的是new了子类对象，所以优先使用子类方法。
        zi.method();
    }
}

1.4.2 成员方法重名——重写(Override)

• 若子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(Override)
  • 方法重写：子类中出现与父类一摸一样（返回值类型，方法名，参数列表都相同）的方法时，会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

代码如下：

/*
* 覆盖重写的注意事项：
*   1、必须保证父子类之间方法的名称相同，参数列表也相同。
* @Override:写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
*   2、子类方法的返回值必须小于等于父类方法的返回值范围。
*   3、子类方法的权限必须大于等于父类方法的权限修饰符
*       提示：public > protected > (default) > private
*   备注：不是关键字default，而是什么都不写，留空
*
* */

public class Fu {
    public Object method() {
        return null;
    }
}


public class Zi extends Fu {
    @Override
    public String method() {
        return null;
    }
}

• 重写的应用：子类可以根据需要，定义特定于自己的行为，即沿袭了父类的功能名称，又根据子类的需要重新实现了父类的方法，从而进行扩展增强。例如：

public class Phone {
    public void call() {
        System.out.println("打电话");

    }

    public void send() {
        System.out.println("发短信");
    }

    public void show() {
        System.out.println("现实号码");
    }

}

// 定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {
    @Override
    public void show() {
        super.show();  // 把父类的show方法拿过来重复利用

        // 自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

public class Demo01Phone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("===================");

        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();
    }
}

1.5 继承后的特点——构造方法

下面我们来看一下，当类之间产生了关系之后，对于各个类中的构造方法产生了哪些影响？

首先我们先回忆一下构造方法定义的格式和作用：

• 构造方法的名字是与类名一致的，所以子类是无法继承父类的构造方法的。
• 构造方法的作用是初始化成员变量的，所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super(),表示调用父类的构造方法，父类成员变量初始化后，才能给子类使用，代码如下：

/*
* 继承关系中，父子类构造方法的访问特点：
* 1、子类构造方法当中有一个默认隐含的"super()" 调用，所以一定是先调用的父类的构造方法，后调用的子类构造方法
* 2、可以通过super关键字来子类构造调用父类重载构造。
* 3、super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造
* 总结：
*   子类必须调用父类构造方法，不写则赠送super()，写了则用写的指定super调用，super只能有一个还必须是第一个
*
* */

public class Fu {
    public Fu() {
        System.out.println("父类无参构造");
    }

    public Fu(int num) {
        System.out.println("父类构造方法！！！");
    }

}

ublic class Zi extends Fu {
    public Zi() {

        super(20);  // 在调用父类重载的构造方法
        System.out.println("子类构造方法！！！");
    }

//    public void method() {
//        super();  // 错误写法，只有子类构造方法，才能调用父类构造方法。
//    }
}

public class Demo01Constructor {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }


}

1.6 super和this的含义

父类空间优先于子类对象产生

• 在每次创建对象的时候，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员，代码体现在子类的构造方法调用是，一定要先调用父类的构造方法，如下图：

super和this的含义：

• super：代表父类的存储空间（可以理解为父类的引用）。
• this：代表当前对象的引用（谁调用就代表谁）。

super和this的用法

• 访问成员变量

this.成员变量    --本类的
super.成员变量   --父类的

this.成员方法名()   --本类的
super.成员方法名()  --父类的

/*
* super关键字用来访问父类内容，而this关键字
* 1、在本类的成员方法中，访问本类的成员变量。
* 2、在本类的成员方法中，访问本类的另一个成员方法。
* 3、在本类的构造方法中，访问本类的另一个构造方法。
* 注意：在第三种用法中，this(...)调用也必须是构造方法的第一个语句，唯一一个
*      super和this两种构造调用，不能同时使用。
* */

public class Fu {
    int num = 40;
}

public class Zi extends Fu {
    int num = 20;

    public Zi() {
        this(123);  // 本类的无参构造，调用本类的有参构造。
    }

    public Zi(int n) {

    }

    public Zi(int n, int m) {

    }

    public void showNum() {
        int num = 10;
        System.out.println(num);  // 局部变量
        System.out.println(this.num);  // 本类中的成员变量
        System.out.println(super.num);  // 父类中的成员变量
    }

    public void methodA() {
        System.out.println("AAA");
    }

    public void methodB() {
        this.methodA();
        System.out.println("BBB");
    }

}

• 访问构造方法

this(...)    --子类的构造方法
super(...)   --父类的构造方法

注意：子类的每个构造方法中均有默认的super()，调用父类的空参构造，手动调用父类构造会覆盖默认的super()。super()和this()都必须是在构造方法的第一行，所以不能同时出现。

1.7 继承的特点

• java只支持单继承，不支持多继承。

// 一个类只能又一个父类，不可以又多个父类
class C extends A{}  // OK
class C extends A, B{}  // error

• java支持多层继承(继承体系)

class A{}
class B extends A{}
class C extends B{}

第二章 抽象类

2.1 概述

由来：父类中的方法，被他们的子类们重写，子类各自的实现都不尽相同，那么父类的方法声明和方法主题，只有声明还有意义，而方法主题则没有存在的意义了，我们把没有方法主题的方法成为抽象方法，Java语法规定，包含抽象方法的类就是抽象类。

定义：

• 抽象方法：没有方法体的方法。
• 抽象类：包含抽象方法的类。

2.2 abstract使用格式

抽象方法：使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

• 定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表);

• 代码举例：

public abstract void run();

抽象类：如果一个类包含抽象方法，那么该类必须是抽象类。

• 定义格式：

abstract class 类名 {
    ...
}

• 代码举例：

pulbic abstract class Animal {
    public abstract void run();
}

抽象的使用：

继承抽象方法的子类必须重写父类所有的抽象方法。否则，该子类也必须为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

代码举例：

/*
* 抽象方法：就是加上abstract关键字分，然后去掉大括号，直接分号结束。
* 抽象类：抽象方法所在的类，必须是抽象类才行，在class之前写上abstract即可。
*
* 如何使用抽象类和抽象方法：
* 1、不能直接创建抽象类对象。
* 2、必须用一个子类来继承抽象父类。
* 3、子类必须覆盖重写抽象父类当中所有的抽象方法。
* 覆盖重写：去掉抽象方法的abstract关键字，然后补上大括号。
* 4、创建子类对象进行使用。
* */

public abstract class Animal {

    // 这是一个抽象方法，代表吃东西，但是具体吃什么，不确定
    public abstract void eat();

    // 普通的成员方法
    public void normalMethod() {

    }
}

public class Cat extends Animal {

    @Override
    public void eat() {

    }
}

public class DemoMain {
    public static void main(String[] args) {
        // Animal animal = new Animal();  // 错误，不能直接创建抽象类。
        Cat cat = new Cat();
    }
}

2.3 注意事项

关于抽象类的使用，以下为语法上要注意的细节。

• 抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象。
• 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
• 抽象类中，不一定包含抽象方法，但是有抽象方法的类必须是抽象类。
• 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错，除非子类也是抽象类。

第三章 继承的综合案例

3.1 综合案例：群主发普通红包

群主发普通红包，某群有多名成员，群主给成员发普通红包，普通红包的规则：

• 群主的一笔金额，从群主余额中扣除，平均分成n等分，让成员领取。
• 成员领取红包后，保存到成员余额中。

3.2 案例分析

3.3 案例实现

定义用户类：

public class User {
    private String name;
    private int money;

    public User() {
    }

    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }

    public void show() {
        System.out.println("我叫：" + name + "，我有" + money + "元。");
    }

    public String getName() {
        return name;
    }

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

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

定义群主类：

import java.util.ArrayList;

public class Manager extends User{
    public Manager() {

    }
    public Manager(String name, int money) {
        super(name, money);
    }

    public ArrayList<Integer> send(int totalMoney, int count) {
        // 首先需要一个集合，用来存储若干个红包的金额
        ArrayList<Integer> redList = new ArrayList<>();

        // 首先看一下群主当前的余额
        int leftMoney = super.getMoney();  // 群主当前余额
        if (totalMoney > leftMoney) {
            System.out.println("余额不足！");
            return redList;
        }

        // 扣钱，其实就是重新设置余额
        super.setMoney(leftMoney - totalMoney);

        // 发红包平均拆分
        int avg = totalMoney / count;
        int mod = totalMoney % count;  // 余数，也就是剩下的零头

        // 除不开的零头，包在最后一个红包当中
        // 下面把红包放在一个集合中
        for (int i = 0; i < count - 1; i++) {
            redList.add(avg);
        }

        // 最后一个红包
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}

定义成员类：

import java.util.ArrayList;
import java.util.Random;

public class Member extends User {
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list) {
        // 从多个红包当中随便抽取一个，给我自己
        // 随便获取一个集合当中的索引编号
        int index = new Random().nextInt(list.size());

        // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己
        int delta = list.remove(index);

        // 当前成员自己本来有多少钱
        int money = super.getMoney();
        super.setMoney(money + delta);
    }
}