Java抽象類、抽象方法的相關知識以及【發紅包案例的分析與實現】

抽象類的概念

• 通過下面的兩個例子，我們可以看出子類【正方形、三角形和圓形】都可以根據具體的圖像計算面積的方法，但是對於其父類【圖形】我們並不知道其具體的描述，因此不能計算面級的方法；
• 再通過右邊的貓喫魚、狗喫骨頭，進而描述動物喫東西的方法；如果父類當中的方法不確定如何進行{ }方法體的實現，那麼這就應該是一個抽象的方法。
  

抽象方法和抽象類的格式

• 抽象方法：就是加上abstract關鍵字，然後去掉大括號，直接分號結束。
• 抽象類：抽象方法所在的類，必須是抽象類纔行。在class之前寫上abstract即可。

public abstract class Animal {
    //這是一個抽象方法，代表喫東西，但是具體喫什麼(大括號的內容)不確定。
    public abstract void eat();
    //這是普通的成員方法
    public void normalMethod(){
    }
}

抽象方法

使用 abstract 關鍵字修飾方法，該方法就成了抽象方法，抽象方法只包含一個方法名，而沒有方法體。

• 定義格式：

修飾符 abstract 返回值類型 方法名 (參數列表)；

• 舉例：

public abstract void eat();

抽象類

如果一個類包含抽象方法，那麼該類必須是抽象類。

• 定義格式：

abstract class 類名字 {

}

• 舉例：

public abstract class Animal {
	public abstract void run()；
}

抽象類和抽象方法如何使用

1. 不能直接創建new抽象類對象。
2. 必須用一個子類來繼承抽象父類。
3. 子類必須覆蓋重寫抽象父類當中所有的抽象方法。
   覆蓋重寫（實現）：子類去掉抽象方法的abstract關鍵字，然後補上方法體大括號。
4. 創建子類對象進行使用。

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

public  class Cat extends Animal {
    @Override
    public  void eat(){
        System.out.println("貓喫魚");
    }
}

public class DemoMain {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}
運行結果：貓喫魚

抽象方法和抽象類的注意事項：

關於抽象類的使用，以下爲語法上要注意的細節，雖然條目較多，但若理解了抽象的本質，無需死記硬背。

1. 抽象類不能創建對象，如果創建，編譯無法通過而報錯。只能創建其非抽象子類的對象。

理解：假設創建了抽象類的對象，調用抽象的方法，而抽象方法沒有具體的方法體，沒有意義。

2. 抽象類中，可以有構造方法，是供子類創建對象時，初始化父類成員使用的。

理解：子類的構造方法中，有默認的super()，需要訪問父類構造方法。

abstract class Fu{
    public Fu() {
        System.out.println("抽象父類的構造方法執行！");
    }
    public abstract void eat();
}

class Zi extends Fu {

    public Zi() {
        System.out.println("子類構造方法執行");
    }
    @Override
    public void eat() {
        System.out.println("喫飯飯");
    }
}
public class DemoMain {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.eat();
    }
}
運行結果：【首先執行的是抽象父類中的構造方法、然後執行的是子類中的構造方法、然後再執行子類中的eat方法】
抽象父類的構造方法執行！
子類構造方法執行
喫飯飯

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

理解：未包含抽象方法的抽象類，目的就是不想讓調用者創建該類對象，通常用於某些特殊的類結構設計。

4. 抽象類的子類，必須重寫抽象父類中所有的抽象方法，否則，編譯無法通過而報錯。除非該子類也是抽象類。

理解：假設不重寫所有抽象方法，則類中可能包含抽象方法。那麼創建對象後，調用抽象的方法，沒有意義

package Demo;

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

//子類也是一個抽象類
abstract class Dog extends Animal1{
    public void eat() {
        System.out.println("狗喫骨頭");
    }
    //public abstract void sleep();
}

class DogGolden extends Dog{

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

class Dog2Ha extends Dog{

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

public class DemoMain {
    public static void main(String[] args) {
//        Animal1 animal1 = new Animal1(); 錯誤
//        Dog dog = new Dog(); 錯誤，這也是抽象類
        Dog2Ha ha = new Dog2Ha();//這是一個普通類，可以直接對象
        ha.eat();
        ha.sleep();
        System.out.println("-------------------");
        DogGolden golden = new DogGolden();
        golden.eat();
        golden.sleep();
    }
}
運行結果：
狗喫骨頭
嘿嘿嘿...
-------------------
狗喫骨頭
呼呼呼...

發紅包案例

發紅包案例分析：

package Demo;

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

package Demo;

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; i++) {
            redList.add(avg);
        }
        //最後一個紅包
        int last = avg + mod;
        redList.add(last);

        return redList;
    }
}

package Demo;

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());
        //根據索引，從集合當中刪除，並且得到被刪除的紅包，給我自己
        Integer delta = list.remove(index);
        //當前成員自己本來有多少錢
        int money = super.getMoney();
        //加法，並且重新設置回去
        super.setMoney(money+delta);

    }
}

package Demo;

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();
        one.show();
        two.show();
        three.show();
        System.out.println("-------------------");
        //羣主總共發20塊錢，分成3個紅包
        ArrayList<Integer> redList = manager.send(20,3);
        //3個普通成員收紅包
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);

        manager.show();
        one.show();
        two.show();
        three.show();
    }
}
運行結果：
我叫：羣主,我有多少錢：100
我叫：成員A,我有多少錢：0
我叫：成員B,我有多少錢：0
我叫：成員C,我有多少錢：0
-------------------
我叫：羣主,我有多少錢：80
我叫：成員A,我有多少錢：6
我叫：成員B,我有多少錢：8
我叫：成員C,我有多少錢：6