設計模式菜鳥教程詳細闡述

一、23種設計模式菜鳥教程

設計模式是解決軟體開發過程中經常遇到的一些重複性問題的經驗總結，可以提高代碼的可重用性、可擴展性和可維護性。23種設計模式菜鳥教程對這些經驗進行了歸類總結，包括：

創建型模式：
1. 工廠模式
2. 抽象工廠模式
3. 單例模式
4. 建造者模式
5. 原型模式

結構型模式：
6. 適配器模式
7. 橋接模式
8. 組合模式
9. 裝飾器模式
10. 外觀模式
11. 享元模式
12. 代理模式

行為型模式：
13. 職責鏈模式
14. 命令模式
15. 解釋器模式
16. 迭代器模式
17. 中介者模式
18. 備忘錄模式
19. 觀察者模式
20. 狀態模式
21. 策略模式
22. 模板方法模式
23. 訪問者模式

二、適配器模式菜鳥教程

適配器模式是將一個類的介面轉換成客戶希望的另外一個介面，讓原本由於介面不兼容而不能一起工作的那些類可以一起工作。

適配器模式包含適配器介面、具體適配器和客戶端。具體適配器實現適配器介面，並包含一個待適配的對象，在適配器介面的方法中調用待適配對象的方法，將其轉換為客戶端需要的形式。

interface Target {
    void request();
}

class Adaptee {
    void specificRequest() {
        System.out.println("Adaptee specificRequest.");
    }
}

class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();
    }
}

三、單例模式菜鳥教程

單例模式是一種創建型模式，保證一個類只有一個實例，並且提供一個訪問它的全局訪問點。

單例模式有兩種經典實現方式：懶漢式和餓漢式。

3.1 懶漢式

懶漢式指在使用到實例時才進行實例化，線程不安全的懶漢式實現代碼如下：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

為了保證線程安全，可以使用雙重檢查鎖定的方式實現懶漢式單例模式：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

3.2 餓漢式

餓漢式指在類載入時就進行實例化，線程安全的餓漢式實現代碼如下：

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

四、建造者模式菜鳥教程

建造者模式是一種創建型模式，將一個複雜對象的構建和表示分離，使得同樣的構建過程可以創建不同的表示。

建造者模式有四個角色：抽象建造者、具體建造者、產品和指揮者。抽象建造者和具體建造者負責定義和實現創建產品的各個組成部分的介面和實現，產品是要被創建的複雜對象，指揮者負責協調抽象建造者和具體建造者的工作，以及構建產品對象。

class Product {
    private List parts = new ArrayList();

    void add(String part) {
        parts.add(part);
    }

    void show() {
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

abstract class Builder {
    abstract void buildPartA();

    abstract void buildPartB();

    abstract Product getResult();
}

class ConcreteBuilder extends Builder {
    private Product product = new Product();

    @Override
    void buildPartA() {
        product.add("PartA");
    }

    @Override
    void buildPartB() {
        product.add("PartB");
    }

    @Override
    Product getResult() {
        return product;
    }
}

class Director {
    void construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
    }
}

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director();
        director.construct(builder);
        Product product = builder.getResult();
        product.show();
    }
}

五、責任鏈模式菜鳥教程

責任鏈模式是一種行為型模式，將請求的發送者和接收者解耦，並且請求沿著鏈傳遞，直到有一個對象處理該請求。

責任鏈模式有兩個關鍵角色：抽象處理者和具體處理者。抽象處理者定義處理請求的介面，具體處理者實現處理請求的方法，並指定其後繼處理者。使用責任鏈模式，請求發送者並不知道哪個對象最終會處理請求，並且每個對象也只負責自己的部分。

abstract class Handler {
    private Handler successor;

    void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    abstract void handleRequest(int request);

    void next(int request) {
        if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

class ConcreteHandler1 extends Handler {
    @Override
    void handleRequest(int request) {
        if (request > 0 && request  10 && request  20 && request <= 30) {
            System.out.println("ConcreteHandler3 handleRequest: " + request);
        } else {
            next(request);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler1.setSuccessor(handler2);
        handler2.setSuccessor(handler3);

        handler1.handleRequest(5);
        handler1.handleRequest(15);
        handler1.handleRequest(25);
        handler1.handleRequest(35);
    }
}