Java Object-Oriented：day09 【 Inheritance、Abstract Classes】

一、抽象类-概述

概述

由来

定义

二、抽象类-abstract使用格式

抽象方法

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

定义格式：

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

代码举例：

?
1
public abstract void run()；

抽象类

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

定义格式：

?
1
2
3
abstract class 类名字 {
  
}

代码举例

?
1
2
3
public abstract class Animal {
    public abstract void run()；
}

抽象的使用

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：

1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。

Animal

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package day09.demo11;
 
/*
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
 
如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。
 */
public abstract class Animal {
 
    // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();
 
    // 这是普通的成员方法
//    public void normalMethod() {
//
//    }
 
}

Cat

?
1
2
3
4
5
6
7
8
9
10
package day09.demo11;
 
public class Cat extends Animal {
 
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
 
}

DemoMain

?
1
2
3
4
5
6
7
8
9
10
11
12
package day09.demo11;
 
public class DemoMain {
 
    public static void main(String[] args) {
//        Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象
 
        Cat cat = new Cat();
        cat.eat();
    }
 
}

运行结果

?
1
2
3
4
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=60590:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day09.demo11.DemoMain
猫吃鱼
 
Process finished with exit code 0

三、抽象类注意事项

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

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

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

父类

?
1
2
3
4
5
6
7
8
9
10
11
package day09.demo12;
 
public abstract class Fu {
 
    public Fu() {
        System.out.println("抽象父类构造方法执行！");
    }
 
    public abstract void eat();
 
}

子类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package day09.demo12;
 
public class Zi extends Fu {
 
    public Zi() {
        // super();
        System.out.println("子类构造方法执行");
    }
 
    @Override
    public void eat() {
        System.out.println("吃饭饭");
    }
}

测试类

?
1
2
3
4
5
6
7
8
9
10
package day09.demo12;
 
public class DemoMain {
 
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.eat();
    }
 
}

运行结果

?
1
2
3
4
5
6
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=60929:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day09.demo12.DemoMain
抽象父类构造方法执行！
子类构造方法执行
吃饭饭
 
Process finished with exit code 0

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

?
1
2
3
4
5
6
7
8
9
10
package day09.demo12;
 
/*
一个抽象类不一定含有抽象方法，
只要保证抽象方法所在的类是抽象类，即可。
 
这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。比如设计模式里的适配模式
 */
public abstract class MyAbstract {
}

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

Animal

?
1
2
3
4
5
6
7
8
9
10
package day09.demo13;
 
// 最高的抽象父类
public abstract class Animal {
 
    public abstract void eat();
 
    public abstract void sleep();
 
}

Dog

?
1
2
3
4
5
6
7
8
9
10
11
12
package day09.demo13;
 
// 子类也是一个抽象类
public abstract class Dog extends Animal {
 
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
 
    // public abstract void sleep();
}

Dog2Ha

?
1
2
3
4
5
6
7
8
package day09.demo13;
 
public class Dog2Ha extends Dog {
    @Override
    public void sleep() {
        System.out.println("嘿嘿嘿……");
    }
}

DogGolden

?
1
2
3
4
5
6
7
8
package day09.demo13;
 
public class DogGolden extends Dog {
    @Override
    public void sleep() {
        System.out.println("呼呼呼……");
    }
}
DemoMain
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package day09.demo13;
 
public class DemoMain {
 
    public static void main(String[] args) {
        //Animal animal = new Animal(); // 错误！
 
        //Dog dog = new Dog(); // 错误，这也是抽象类
 
        Dog2Ha ha = new Dog2Ha(); // 这是普通类，可以直接new对象。
        ha.eat();
        ha.sleep();
        System.out.println("==========");
 
        DogGolden golden = new DogGolden();
        golden.eat();
        golden.sleep();
    }
 
 
}

运行结果：

?
1
2
3
4
5
6
7
8
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=61385:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day09.demo13.DemoMain
狗吃骨头
嘿嘿嘿……
==========
狗吃骨头
呼呼呼……
 
Process finished with exit code 0

三、继承的综合案例

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

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

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

请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作

案例分析

案例实现

定义用户类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package day09.demo14;
 
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;
    }
}

定义群主类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package day09.demo14;
 
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);
 
        // 发红包需要平均拆分成为count份
        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;
    }
}

定义成员类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package day09.demo14;
 
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);
    }
}

定义测试类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package day09.demo14;
 
import java.util.ArrayList;
 
public class MainRedPacket {
 
    public static void main(String[] args) {
        Manager manager = new Manager("群主", 100);
 
        Member one = new Member("成员A", 0);
        Member two = new Member("成员B", 0);
        Member three = new Member("成员C", 0);
 
        manager.show(); // 100
        one.show(); // 0
        two.show(); // 0
        three.show(); // 0
        System.out.println("===============");
 
        // 群主总共发20块钱，分成3个红包
        ArrayList<Integer> redList = manager.send(20, 3);
        // 三个普通成员收红包
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);
 
        manager.show(); // 100-20=80
        // 6、6、8，随机分给三个人
        one.show();
        two.show();
        three.show();
    }
 
}

运行结果

?
1
2
3
4
5
6
7
8
9
10
11
12
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=50542:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day09.demo14.MainRedPacket
我叫：群主，我有多少钱：100
我叫：成员A，我有多少钱：0
我叫：成员B，我有多少钱：0
我叫：成员C，我有多少钱：0
===============
我叫：群主，我有多少钱：80
我叫：成员A，我有多少钱：6
我叫：成员B，我有多少钱：8
我叫：成员C，我有多少钱：6
 
Process finished with exit code 0
posted @   活的潇洒80  阅读(235)  评论(0)  编辑  收藏  举报
编辑推荐：
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
历史上的今天：
2019-05-02 Linux性能优化实战学习笔记：第三讲
点击右上角即可分享
微信分享提示
AI IDE Trae