摘要
继承案例以及抽象方法和抽象类
正文
继承案例--发红包
设计实现
- 发红包
- 返回值：ArrayList
- 方法名称：send
- 参数列表：
- 总共发多少钱：int totalMoney
- 分成多少份：int count
- 收红包
- 返回值：void
- 方法名称：receive
- 参数列表：ArrayList list
具体实现
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
| public class User {
private String name;// 姓名
private int money;// 余额，也就是当前用户拥有的钱数
public User() {
}
public User(String name, int money) {
this.name = name;
this.money = 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;
}
// 展示一下当前用户有多少钱
public void show() {
System.out.println("成员：" + name + " 余额：" + 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
| 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> list = new ArrayList<Integer>();
// 首先看一下群主自己有多少钱
int leftMoney = super.getMoney();// 群主当前余额
if (totalMoney > leftMoney) {
System.out.println("余额不足");
return list;// 返回空集合
}
// 扣钱，重新设置余额
super.setMoney(leftMoney - totalMoney);
// 红包需要平均拆分成count份
int avg = totalMoney / count;
int mod = totalMoney % count;// 余数，也就是甩下的零头
// 除不开的零头，包在最后一个红包当中
// 下面把红包一个个放到集合当中
for (int i = 0; i < count; i++) {
if (i >= (count - 1)) {
list.add(avg + mod);
break;
}
list.add(avg);
}
return list;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class Member extends User {
public Member() {
super();
// TODO Auto-generated constructor stub
}
public Member(String name, int money) {
super(name, money);
// TODO Auto-generated constructor stub
}
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
| public class MainRedPacker {
public static void main(String[] args) {
Manager manager=new Manager("群主",1000);
Member one=new Member("成员A",0);
Member two=new Member("成员B",0);
Member three=new Member("成员C",0);
//展示一下个人信息
manager.show();
one.show();
two.show();
three.show();
System.out.println("=====================");
//发红包
ArrayList<Integer> list=manager.send(23, 3);
//收红包
one.receive(list);
two.receive(list);
three.receive(list);
//再次展示发红包以后各个成员的钱数
manager.show();
one.show();
two.show();
three.show();
System.out.println("=====================");
}
}
|
1
2
3
4
5
6
7
8
9
10
| 成员：群主 余额：1000
成员：成员A 余额：0
成员：成员B 余额：0
成员：成员C 余额：0
=====================
成员：群主 余额：977
成员：成员A 余额：7
成员：成员B 余额：9
成员：成员C 余额：7
=====================
|
抽象方法以及抽象类
基本概念
啥是抽象类？直接上图。
**抽象方法：**就是加上abstract关键字，然后去掉大括号，直接分号结束
**抽象类：**抽象方法所在的类，必须是抽象类才行。在class之前加上abstract即可
如何使用抽象类和抽象方法：
- 不能直接创建new抽象类对象
- 必须用一个子类来继承抽象父类
- 子类覆盖重写抽象父类当中所有的抽象方法
覆盖重写：子类去掉抽象方法中的abstract，然后补上方法体大括号
- 创建子类对象使用
案例
1
2
3
4
5
6
7
8
9
| public abstract class Animal {
//这是一个抽象方法，代表吃东西，但是具体吃什么(大括号的内容)不确定
public abstract void eat();
//这是普通的成员方法
public void normalMethod() {
}
}
|
1
2
3
4
5
6
7
| public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
|
1
2
3
4
5
| public static void main(String[] args) {
//Animal animal=new Animal();//错误写法，不能直接创建抽象类
Cat cat=new Cat();
cat.eat();//输出：猫吃鱼
}
|
注意事项：
- 一个抽象类不一定含有抽象方法
只要保证抽象方法所在的类是抽象类，即可
这样没有抽象方法的抽象类，也能直接创建对象，在一些特殊场景下有用途
- 抽象类的子类必须重写父类中所有的抽象方法，否则，编译会无法通过而报错。除非该子类也是抽象类。
