言成言成啊 | Kit Chen's Blog

继承案例以及抽象类

2019-09-19

继承案例–发红包

设计实现

  • 发红包
    • 返回值:ArrayList
    • 方法名称:send
    • 参数列表:
      • 总共发多少钱:int totalMoney
      • 分成多少份:int count
  • 收红包
    • 返回值:void
    • 方法名称:receive
    • 参数列表:ArrayList list

具体实现

  • User类
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);
}

}
  • Manager类
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;

}

}
  • Member类
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即可

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

  1. 不能直接创建new抽象类对象
  2. 必须用一个子类来继承抽象父类
  3. 子类覆盖重写抽象父类当中所有的抽象方法
    覆盖重写:子类去掉抽象方法中的abstract,然后补上方法体大括号
  4. 创建子类对象使用

案例

  • Animal类
1
2
3
4
5
6
7
8
9
public abstract class Animal {
//这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
public abstract void eat();

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

}
}
  • Cat类
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();//输出:猫吃鱼
}

注意事项:

  1. 一个抽象类不一定含有抽象方法
    只要保证抽象方法所在的类是抽象类,即可
    这样没有抽象方法的抽象类,也能直接创建对象,在一些特殊场景下有用途
  2. 抽象类的子类必须重写父类中所有的抽象方法,否则,编译会无法通过而报错。除非该子类也是抽象类。
阅读量