JAVA学习笔记（二十七）

抽象的概念

抽象方法和抽象类的格式

抽象方法:就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类:抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

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

抽象方法和抽象类的使用

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

1.不能直接创建new抽象类对象。必须用一个子类来继承抽象父类

2.子类必须覆盖重写抽象父类当中所有的抽象方法。

3覆盖重写(实现):子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

4.创建子类对象进行使用。

父类

 public abstract class Animal{
     // 这是一个抽象方法，代表吃东西，但是具体吃什么(大括号的内容)不确定
     public abstract void eat();
     
 }

子类

 public class Cat extends Animal {
     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();
     }
 }

抽象方法和抽象类的注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。 1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象.

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

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

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

 public abstract class Fu {
     publi Fu() {
         System.out.printIn("抽象父类构造方法执行!");
     }
     public abstract void eat();
 }

 public class Zi extends Fu {
     public Zi() {
         // super();
         System.out.printIn("子类构造方法执行!");
     }
     @Override
     public void eat(); 
     System.out.printIn("吃饭饭");
     } 
 }

 public static void main(String[] args){ 
     Zi zi = new Zi();
     zi.eat();
 }
 //抽象父类构造方法执行!
 //子类构造方法执行!
 //吃饭饭

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

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

一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类，即可

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。

 public abstract class MyAbstract {
 ​
 }

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

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

最高父类

 // 最高的抽象父类
 public abstract class Animal {
    public abstract void sleep();
    public abstract void eat();
 }

次级父类(子类)

 //子类也是一个抽象类
 public abstract class Dog extends Animal {
     @Override
     public void eat() {
         System.out.printIn("狗吃骨头");
     }
     // public abstract void sleep();
 }

子类

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

 public class Dog2Ha extends Dog {
     @Override
     public void sleep() {
         System.out.printIn("嘿嘿嘿....");
     }
 }

运行

 public static void main(String[] args) {
     //Animal animal = new Animal(); // 错误!
     //Dog dog = new Dog(); // 错误，这也是抽象类
     Dog2Ha ha = new Dog2Ha(); // 这是普通类，可以直接new对象。
     ha.eat();//狗吃骨头
     ha.sleep();//嘿嘿嘿....
     
     System.out.println("==========");
     
     DogGolden golden = new DogGolden();
     golden .eat();//狗吃骨头
     golden.sleep();//呼呼呼.....
 }

发红包练习

用户类 GS

 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.printIn("余额不足");
             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( name: "群主"， money: 100);
 ​
         Member one = new Member( name: "成员A", money: 0 );
         Member two = new Member( name: "成员B",  money: 0 );
         Member three = new Member( name:"成员C", money: 0 );
 ​
         manager.show();
         one.show();
         two.show();
         three.show();
         System.out.println("=============");
 ​
         // 群主总共发20块钱，分成3个红包
         ArrayList<Integer>redList = manager.send( totalMoney: 20, count: 3);
         // 三个普通成员收红包
         one.receive(redList);
         two.receive(redList);
         three.receive(redList);
        
         manager.show();
         one.show();
         two.show();
         three.show();
     }
 }