我的 Java 入门进阶之路（五）

最新推荐文章于 2024-03-04 11:42:29 发布

m0rta1

最新推荐文章于 2024-03-04 11:42:29 发布

阅读量321

点赞数 3

分类专栏： JavaSE Notes

本文链接：https://blog.csdn.net/haduwi/article/details/107051615

版权

JavaSE Notes 专栏收录该内容

24 篇文章 2 订阅

订阅专栏

文章目录

一、继承：

1.1、概述：

由来：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示：

在这里插入图片描述

其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。继承描述的是事物之间的所属关系，这种关系是：is-a （就是继承关系）的关系。例如，图中鹿属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

定义：

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

优点：

提高代码的复用性。
类与类之间产生了关系，是多态的前提。

1.2、继承的格式：

在这里插入图片描述
继承演示，代码如下：

定义员工类Employee，做为父类：

// 定义一个父类：员工
public class Employee {

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

}

定义讲师类Teacher继承员工类Employee:

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

}

定义测试类:

/*
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ...
}
 */
public class DemoExtends {

    public static void main(String[] args) {
        // 创建了一个子类对象
        Teacher teacher = new Teacher();
        // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
        teacher.method();
    }

}

1.3、继承后的特点 – 成员变量：

当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？

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

父类：

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); //10 只能使用父类的东西，没有任何子类内容
        System.out.println("===========");

        Zi zi = new Zi();

        System.out.println(zi.numFu); // 10
        System.out.println(zi.numZi); // 20
        System.out.println("===========");

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

        // 这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类当中定义的，
        zi.methodFu(); // 100
    }

}

注意： 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找。

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

父类：

public class Fu {

    int num = 10;

}

子类：

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 DemoExtendsField {

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

        zi.method();
    }

}

小贴士：

局部变量：直接写成员变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名
父类中的成员变量是非私有的，子类中可以直接访问。若父类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

1.4、继承后的特点 – 成员方法：

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

成员方法不重名：

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

父类：

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 Demo01ExtendsMethod {

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

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

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

}

注意事项：

无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。
重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

1.5、成员方法重名——重写(Override)：

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(Override)。

方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

演示代码如下：

在这里插入图片描述

重写的应用： 子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能，代码如下：

老版手机类：

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();
    }

}

在这里插入图片描述

小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。

注意事项：

必须保证父子类之间方法的名称相同，参数列表也相同。@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
子类方法的返回值必须【小于等于】父类方法的返回值范围。小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
子类方法的权限必须【大于等于】父类方法的权限修饰符。小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。

1.6、继承后的构造方法——构造方法：

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

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

父类：

public class Fu {

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

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

}

子类：

public class Zi extends Fu {

    public Zi() {
        super(); // 在调用父类无参构造方法 ，自动增送 ，可以不写
        //super(20); // 在调用父类重载的构造方法
        System.out.println("子类构造方法！");
    }

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

}

测试类：

public class Demo01Constructor {

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

}

继承关系中，父子类构造方法的访问特点：

子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
子类构造可以通过super关键字来调用父类重载构造。
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

1.7、super 和 this：

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

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

在这里插入图片描述

super和this的含义super：

super 代表父类的存储空间标识(可以理解为父亲的引用)。this：代表当前对象的引用(谁调用就代表谁)。

super 和 this的用法：

1. 访问成员：
在这里插入图片描述
用法演示，代码如下：

在这里插入图片描述
2. 访问构造方法：

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

3. 子类和父类是一种相对的概念。

二、抽象类：

2.1、概述：

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

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

2.2、abstract使用格式：

抽象方法：

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

在这里插入图片描述

抽象类：

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

定义格式:

abstract class 类名 {

}

代码举例：

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

2.4、抽象的使用：

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

代码举例：
在这里插入图片描述

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

2.5、注意事项：（重点,理解为主）

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

三、继承综合案例：

群主发红包:

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

群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
成员领取红包后，保存到成员余额中。请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

案例分析：

在这里插入图片描述

案例实现：

定义一个用户类：

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

    public User() {
    }

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

    public void show() {
        System.out.println("用户为：" +this.name+" 账户上有 "+this.money+" 块钱");
    }

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

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

定义一个群主类：

package com.xxw.advancecodes;

import java.math.BigDecimal;
import java.util.ArrayList;

public class haremMaster extends User{
    public haremMaster() {

    }

    public haremMaster(String name, double money) {
        super(name, money);
    }

    public ArrayList<Double> givePacket(int totalMoney,int sum){
        ArrayList<Double> redList = new ArrayList<>();
        double money = super.getMoney(); // 获取群主当前余额多少
        if(money < totalMoney){
            System.out.println("老板你钱不够呀，别装大款啦，有多少就发多少。");
            return redList ;
        }
        super.setMoney(money-totalMoney); // 重置一下群主的金额
        double averMoney = new BigDecimal((double)totalMoney/sum).
        setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue(); // 保留两位小数
        for (int i = 0; i < sum; i++) {
            redList.add(averMoney);
        }
        return redList;
    }
}

定义一个群员类：

package com.xxw.advancecodes;

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

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

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

    public void receivePacket(ArrayList<Double> list){

        if (list.size()>0){ // 判断集合是否为空 , 为空不执行
            // 随机抽取一个红包
            int index = new Random().nextInt(list.size());
            // 获取这个成员本来有多少钱
            double money = super.getMoney();
            // 把红包的钱存入个人账户
            super.setMoney(list.get(index)+money);
            // 删除集合中被选中的这个红包,防止下一次又选到这个红包了
            list.remove(index);
        }
    }
}

测试类：

// 发红包 ， 普通红包案例
package com.xxw.advancecodes;

import java.util.ArrayList;
import java.util.Scanner;

public class redPacket {
    public static void main(String[] args) {
        haremMaster master = new haremMaster("老大",100);
        Member member01 = new Member("小弟一号",0);
        Member member02 = new Member("小弟二号",2.5);
        Member member03 = new Member("小弟三号",10);
        Member member04 = new Member("小弟四号",250);

        // 打印一下初始值
        master.show();
        member01.show();
        member02.show();
        member03.show();
        member04.show();

        System.out.println("=================================");
        System.out.print("群主你想发几块钱的红包呢？");
        int inputMoney = new Scanner(System.in).nextInt(); // 输入发红包的金额

        System.out.println("=============恭喜发财==============");

        ArrayList<Member> members = new ArrayList<>(); // 把成员放到一个集合
        // 添加成员
        members.add(member01);
        members.add(member02);
        members.add(member03);
        members.add(member04);
        ArrayList<Double> redList = master.givePacket(inputMoney,members.size());
        for (int i = 0; i < members.size(); i++) {
            members.get(i).receivePacket(redList); // 成员抢红包
        }

        // 抢红包后各自的余额显示
        master.show();
        member01.show();
        member02.show();
        member03.show();
        member04.show();

        System.out.println("=============抢红包结束=============");
    }
}