2022/06/09 day10：抽象类

2. 抽象类

2.1 概述

由来：
父类中的方法，被它的子类们重写，子类各自实现都不相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。
java语法规定，包含抽象方法的类就是抽象类。

定义
抽象方法 ： 没有方法体的方法。
抽象类：包含抽象方法的类。

2.2 抽象方法与抽象类(abstract)

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

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

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

例子：

public abstract class Animal {


    //因为子类是具体到功能的，父类又是多层抽象出来的，所以无法动作。
    //这就是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();

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


    }
}

抽象的使用：
继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

如何使用抽象类和抽象方法：四个步骤

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

例子：

public class Cat extends Animal {

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

public class DemoMain {
    public static void main(String[] args) {
//        Animal animal = new Animal();//错误写法！不能直接创建抽象类对象

        Cat cat = new Cat();
        cat.eat();
    }
}

2.3 抽象类的注意事项

注意事项：

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

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

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

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

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

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

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

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

例子：

/*这是一个最高的抽象父类

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

//子类也是一个抽象类
public abstract class Dog extends Animal{


    @Override
    public void eat() {
        System.out.println("狗吃骨头！");
    }

//    @Override
//    public void sleep() {
//
//    }
}

/*
子类
 */
public class Dog2Ha extends Dog{
    @Override
    public void sleep() {

        System.out.println("哈哈哈...");
    }
}

/*
子类
 */
public class DogGolden extends Dog{


    @Override
    public void sleep() {
        System.out.println("呼呼呼...");
    }
}

public class DemoMain {
    public static void main(String[] args) {
//        Animal animal = new Animal() ;//抽象类不能直接实体化对象
//        Dog dog = new Dog() //抽象类不能直接实体化对象


        Dog2Ha dog2Ha = new Dog2Ha();//普通类，可以直接new对象
        dog2Ha.sleep();//这是普通成员方法直接
        dog2Ha.eat();

        DogGolden dogGolden = new DogGolden();
        dogGolden.sleep();
        dogGolden.eat();
    }
}

3. 继承的综合案例

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

1. 群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。
2. 成员领取红包后，保存到成员余额中。
   请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。

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

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

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

    }
}

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();//80
        //6 6 8 随机分给三个人
        one.show();//8
        two.show();//6
        three.show();//6


    }
}

                                                                                 ——此文档为学习笔记！