抽象方法和抽象類

• 抽象方法
  1. 使用 abstract 修飾的方法，沒有方法體，只有聲明。
  2. 定義的是一種“規範”，就是告訴子類必須要給抽象方法提供具體的實現。
• 抽象類
  1. 包含抽象方法的類就是抽象類。
  2. 通過抽象類，我們就可以做到嚴格限制子類的設計，使子類之間更加通用。

//抽象類的定義
public abstract class 類名 {}

//抽象方法的定義
public abstract void eat();

• 抽象類中不一定有抽象方法，有抽象方法的類一定是抽象類

• 抽象類不能實例化

• 抽象類可以有構造方法

• 抽象類的子類

• 要麼重寫抽象類中的所有抽象方法

• 要麼是抽象類

抽象類和抽象方法的基本用法

//抽象類
abstract class Animal {
    abstract public void shout(); // 抽象方法
}

class Dog extends Animal {
    // 子類必須實現父類的抽象方法，否則編譯錯誤
    public void shout() {
        System.out.println("汪汪汪！");
    }

    public void seeDoor() {
        System.out.println("看門中....");
    }
}

// 測試抽象類
public class TestAbstractClass {
    public static void main(String[] args) {
        Dog a = new Dog();
        a.shout();
        a.seeDoor();
    }
}

抽象類的使用要點:

1. 有抽象方法的類只能定義成抽象類

2. 抽象類不能實例化，即不能用 new 來實例化抽象類。

3. 抽象類可以包含屬性、方法、構造方法。但是構造方法不能用來 new 實例，只能用來被子類調用。

4. 抽象類只能用來被繼承。

5. 抽象方法必須被子類實現。

抽象類的案例

• 案例需求

  定義貓類(Cat)和狗類(Dog)

  貓類成員方法：eat（貓吃魚）drink（喝水…）

  狗類成員方法：eat（狗吃肉）drink（喝水…）

• 實現步驟

  1. 貓類和狗類中存在共性內容，應向上抽取出一個動物類（Animal）

  2. 父類Animal中，無法將 eat 方法具體實現描述清楚，所以定義為抽象方法

  3. 抽象方法需要存活在抽象類中，將Animal定義為抽象類

  4. 讓 Cat 和 Dog 分別繼承 Animal，重寫eat方法

  5. 測試類中創建 Cat 和 Dog 對象，調用方法測試

• 代碼實現

// 動物類
abstract class Animal {

    public void drink() {
        System.out.println("喝水");
    }

    public Animal() {
    }

    public abstract void eat();
}

// 貓類 繼承抽象類 並重寫其中方法
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("貓吃魚");
    }
}

// 狗類 繼承抽象類 並重寫其中方法
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨頭...");
    }

}

public class test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.drink();

        Cat c = new Cat();
        c.drink();
        c.eat();

        // Animal a = new Animal(); 抽象類不能實例化
        // a.eat();
    }
}

模板設計模式

• 設計模式

   

      設計模式（Design pattern) 是一套被反覆使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。 使用設計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性、程式的重用性。

• 模板設計模式

   

       把抽象類整體就可以看做成一個模板，模板中不能決定的東西定義成抽象方法 讓使用模板的類（繼承抽象類的類）去重寫抽象方法實現需求

• 模板設計模式的優勢

   

       模板已經定義了通用結構，使用者只需要關心自己需要實現的功能即可

• 示例代碼

/*
    作文模板類
 */
abstract class CompositionTemplate {

    public final void write() {
        System.out.println("<<我的爸爸>>");

        body();

        System.out.println("啊~ 這就是我的爸爸");

    }

    public abstract void body();
}

// 實現類A
class Tom extends CompositionTemplate {

    @Override
    public void body() {
        System.out.println("那是一個秋天, 風兒那麼纏綿,記憶中, " +
                "那天爸爸騎車接我放學回家,我的腳卡在了自行車鏈當中, 爸爸蹬不動,他就站起來蹬...");
    }
}
// 實現類B
class Tony extends CompositionTemplate {
    @Override
    public void body() {

    }

    /*
     * public void write(){
     * 
     * }
     */
}

// 測試類
public class test {
    public static void main(String[] args) {
        Tom t = new Tom();
        t.write();
    }
}

本文來自博客園，作者：link-零，轉載請註明原文鏈接：https://www.cnblogs.com/e-link/p/16742993.html❤❤❤