继承案例--发红包

设计实现

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

具体实现

User类

text
 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类

text
 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类

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

主函数

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

}

运行结果

text
 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，然后补上方法体大括号
创建子类对象使用

案例

Animal类

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

Cat类

text
1
2
3
4
5
6
7
public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

主函数

text
1
2
3
4
5
public static void main(String[] args) {
		//Animal animal=new Animal();//错误写法，不能直接创建抽象类
		Cat cat=new Cat();
		cat.eat();//输出：猫吃鱼
	}

注意事项：

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

接口

《Love》