抽象类的学习

如果父类当中的方法不确定如何进行，那么就是一个抽象方法

• 计算图形的面积
• 动物吃东西的方法

public abstract class Animal {
//抽象方法，没有大括号
	public abstract void eat()；
//普通成员方法
	public void normalMethod(){}
}

• 不能直接new抽象类对象
• 必须用一个子类来继承抽象父类
• 子类需要补上父类中抽象方法中的内容（覆盖），不然会报错

public abstract class Animal {
//抽象方法，没有大括号
@override
	public  void eat(){System.out.println("猫吃鱼")}；

}

public class CatTest {
public static void main(String[] args) {
// 创建子类对象
	Cat c = new Cat();
// 调用run方法
	c.eat();
}
}

• 子类也是抽象的情况

抽象父类

public abstract class Animal{ 
	public abstract void eat();
	public abstract void sleep();
}

抽象子类

public abstract class Dog{ 
@override
	public void eat(){System.out.println("吃骨头")};
	public abstract void sleep();
}

jinmao

public abstract class hashiqi{ 
@override
	public void sleep(){System.out.println("呼呼")};
}

hashiqi

public abstract class hashiqi{ 
@override
	public void sleep(){System.out.println("haha")};
}

main函数

public class MAIN
{
	public static void main(String[] args){
    hashiqi a=new hashiqi();
    #输出哈哈
    a.sleep();
    a.eat();
    jinmao b=new jinmao();
    #输出呼呼
    b.sleep();
    b.eat();
    
	}
	}

红包案例分析
逻辑图
用户类

public class User {
// 成员变量
	private String username; // 用户名
	private double leftMoney; // 余额
// 构造方法，无参加有参
public User() { }
public User(String username, double leftMoney) {
	this.username = username;
	this.leftMoney = leftMoney;
}
// get/set方法，修改private变量
public String getUsername() {
	return username;
}
public void setUsername(String username) {
	this.username = username;
}
public double getLeftMoney() {
	return leftMoney;
}
public void setLeftMoney(double leftMoney) {
	this.leftMoney = leftMoney;
}
// 展示信息的方法
public void show() {
	System.out.println("用户名:"+ username +" , 余额为:" + leftMoney + "元");
}
}

子类，使用super去修改父类的元素

 super.getMoney()
 super.setMoney()

群主类

public class QunZhu extends User {
// 添加构造方法
public QunZhu() {
	//默认会调用super()
}
public QunZhu(String username, double leftMoney) {
// 通过super 调用父类构造方法,有两个参数的时候调用父类的super(username, leftMoney)
	super(username, leftMoney);
}
/*
群主发红包，就是把一个整数的金额，分层若干等份。
1.获取群主余额,是否够发红包.
不能则返回null,并提示.
能则继续.
2.修改群主余额.
3.拆分红包.
3.1.如果能整除，那么就平均分。
3.2.如果不能整除，那么就把余数分给最后一份。
*/
public ArrayList<Double> send(int money, int count) {
// 获取群主余额
	double leftMoney = getLeftMoney();
	if(money > leftMoney) {
	System.out.println("余额不足");
	return null;
	}
// 修改群主余额的
	super.setLeftMoney(leftMoney ‐ money);
// 创建一个集合,保存等份金额
	ArrayList<Double> list = new ArrayList<>();
// 扩大100倍,相当于折算成'分'为单位,避免小数运算损失精度的问题
	money = money * 100;
// 每份的金额
	int m = money / count;
// 不能整除的余数
	int l = money % count;
// 无论是否整除,n‐1份,都是每份的等额金额
for (int i = 0; i < count ‐ 1; i++) {
// 缩小100倍,折算成 '元'
	list.add(m / 100.0);
}
// 判断是否整除
if (l == 0) {
// 能整除, 最后一份金额,与之前每份金额一致
	list.add(m / 100.0);
} else {
// 不能整除, 最后一份的金额,是之前每份金额+余数金额
	list.add((m + l) / 100.00);
}
// 返回集合
	return list;
}
}

成员类

public class Member extends User {
public Member() {
}
public Member(String username, double leftMoney) {
	super(username, leftMoney);
}
// 打开红包,就是从集合中,随机取出一份,保存到自己的余额中
public void openHongbao(ArrayList<Double> list) {
// 创建Random对象
	Random r = new Random();
// 随机生成一个角标
	int index = r.nextInt(list.size());
// 移除一个金额，返回被删除的元素
	Double money = list.remove(index);
	//本来有的钱
	int money=super.getMoney()+money;
// 直接调用父类方法,设置到余额
	super.setLeftMoney( money );
}
}

测试类

public class Test {
public static void main(String[] args) {
// 创建一个群主对象
	QunZhu qz = new QunZhu("群主" , 200);
// 创建一个键盘录入
	Scanner sc = new Scanner();
	System.out.println("请输入金额:");
	int money = sc.nextInt();
	System.out.println("请输入个数:");
	int count = sc.nextInt();
// 发送红包
	ArrayList<Double> sendList = s.send(money,count);
// 判断,如果余额不足.send函数返回是null的情况
	if(sendList == null){
	System.out.println(" 余额不足...");
	return;
}
// 创建三个成员
	Member m = new Member(“成员A”,0);
	Member m2 = new Member(“成员B”,0);
	Member m3 = new Member(“成员C”,0);
// 打开红包
	m.openHongbao(sendList);
	m2.openHongbao(sendList);
	m3.openHongbao(sendList);
// 展示信息
	qz.show();
	m.show();
	m2.show();
	m3.show();
}
}