設計模式

1. 工廠模式

工廠模式就像一個生產線，它能夠創建出不同種類的產品。它的使用場景是當需要創建一些類的對象時，可以將這些類放在工廠中統一管理，通過工廠方法來創建對象。

優點：能夠統一管理對象的創建，降低了代碼的耦合性，方便擴展和維護。

缺點：需要額外的工廠類來創建對象，增加了代碼量。

【資料圖】

// 抽象產品類public abstract class Product {    public abstract void operation();}// 具體產品類public class ConcreteProductA extends Product {    @Override    public void operation() {        System.out.println("ConcreteProductA operation");    }}// 具體產品類public class ConcreteProductB extends Product {    @Override    public void operation() {        System.out.println("ConcreteProductB operation");    }}// 工廠類public class Factory {    public static Product createProduct(String type) {        switch (type) {            case "A":                return new ConcreteProductA();            case "B":                return new ConcreteProductB();            default:                return null;        }    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Product productA = Factory.createProduct("A");        Product productB = Factory.createProduct("B");        productA.operation();        productB.operation();    }}

2. 抽象工廠模式

抽象工廠模式類似于一個工廠的工廠，它可以創建一組相關或者相互依賴的對象。使用場景是當需要創建一組有關聯的對象時，可以使用抽象工廠模式。

優點：能夠統一創建一組相關或者相互依賴的對象，減少了耦合性。

缺點：擴展新的產品族比較困難。

以下是一個基于 Android 的抽象工廠模式的實現示例：

// 抽象產品類public abstract class Button {    public abstract void display();}// 具體產品類public class AndroidButton extends Button {    @Override    public void display() {        System.out.println("Android Button");    }}// 具體產品類public class IOSButton extends Button {    @Override    public void display() {        System.out.println("iOS Button");    }}// 抽象產品類public abstract class TextField {    public abstract void display();}// 具體產品類public class AndroidTextField extends TextField {    @Override    public void display() {        System.out.println("Android TextField");    }}// 具體產品類public class IOSTextField extends TextField {    @Override    public void display() {        System.out.println("iOS TextField");    }}// 抽象工廠類public abstract class AbstractFactory {    public abstract Button createButton();    public abstract TextField createTextField();    }// 具體工廠類 public class AndroidFactory extends AbstractFactory { @Override public Button createButton() { return new AndroidButton(); }@Overridepublic TextField createTextField() {    return new AndroidTextField();}}// 具體工廠類 public class IOSFactory extends AbstractFactory { @Override public Button createButton() { return new IOSButton(); }@Overridepublic TextField createTextField() {    return new IOSTextField();}}// 客戶端代碼public class Client { public static void main(String\[\] args) { AbstractFactory factory = new AndroidFactory(); Button button = factory.createButton(); TextField textField = factory.createTextField(); button.display(); textField.display(); } }

3. 生成器模式

生成器模式就像一位廚師，它可以根據顧客的需求來烹飪出不同的菜品。使用場景是當需要構建復雜對象時，可以使用生成器模式，將對象的構建過程分步驟來完成。

優點：能夠分步驟構建對象，便于控制對象的構建過程，易于擴展和維護。

缺點：需要定義多個具體的生成器類，增加了代碼量。

// 產品類public class Meal {    private String drink;    private String food;    private String dessert;    public void setDrink(String drink) {        this.drink = drink;    }    public void setFood(String food) {        this.food = food;    }    public void setDessert(String dessert) {        this.dessert = dessert;    }    public String getDrink() {        return drink;    }    public String getFood() {        return food;    }    public String getDessert() {        return dessert;    }}// 抽象生成器類public abstract class MealBuilder {    protected Meal meal = new Meal();    public abstract void buildDrink();    public abstract void buildFood();    public abstract void buildDessert();    public Meal getMeal() {        return meal;    }}// 具體生成器類public class MealA extends MealBuilder {    @Override    public void buildDrink() {        meal.setDrink("Coke");    }    @Override    public void buildFood() {        meal.setFood("Hamburger");    }    @Override    public void buildDessert() {        meal.setDessert("Ice cream");    }}// 具體生成器類public class MealB extends MealBuilder {    @Override    public void buildDrink() {        meal.setDrink("Sprite");    }    @Override    public void buildFood() {        meal.setFood("Pizza");    }    @Override    public void buildDessert() {        meal.setDessert("Cake");    }}// 指揮者類public class Waiter {    private MealBuilder mealBuilder;    public void setMealBuilder(MealBuilder mealBuilder) {        this.mealBuilder = mealBuilder;    }    public Meal getMeal() {        mealBuilder.buildDrink();        mealBuilder.buildFood();        mealBuilder.buildDessert();        return mealBuilder.get}// 客戶端代碼 public class Client { public static void main(String\[\] args) { Waiter waiter = new Waiter(); MealBuilder mealBuilder = new MealA(); waiter.setMealBuilder(mealBuilder); Meal meal = waiter.getMeal(); System.out.println("Drink: " + meal.getDrink()); System.out.println("Food: " + meal.getFood()); System.out.println("Dessert: " + meal.getDessert()); } }

4. 原型模式

原型模式就像復印機，它可以復制出一個完全一樣的對象。使用場景是當需要創建一個新對象，但又希望該對象具有某些已有對象的屬性時，可以使用原型模式。

優點：可以快速創建一個新對象，而且創建的對象和原型對象完全一樣。

缺點：如果原型對象的屬性比較復雜，復制起來可能比較耗時。

// 原型接口public interface Prototype {    Prototype clone();}// 具體原型類public class AndroidWidget implements Prototype {    private String type;    private int size;    public AndroidWidget(String type, int size) {        this.type = type;        this.size = size;    }    public String getType() {        return type;    }    public int getSize() {        return size;    }    @Override    public Prototype clone() {        return new AndroidWidget(type, size);    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        AndroidWidget widget1 = new AndroidWidget("Button", 10);        AndroidWidget widget2 = (AndroidWidget) widget1.clone();        System.out.println(widget1.getType() + " " + widget1.getSize());        System.out.println(widget2.getType() + " " + widget2.getSize());    }}

5. 單例模式

單例模式就像一個國家的國王，一個國家只有一個國王，而且國王一直存在。使用場景是當需要保證一個類只有一個實例時，可以使用單例模式。

優點：可以保證一個類只有一個實例，避免多個實例造成的資源浪費。

缺點：單例模式可能會造成單例類的職責過重。

// 單例類public class AndroidManager {    private static AndroidManager instance;    private AndroidManager() {    }    public static AndroidManager getInstance() {        if (instance == null) {            synchronized (AndroidManager.class) {                if (instance == null) {                    instance = new AndroidManager();                }            }        }        return instance;    }    public void display() {        System.out.println("Android Manager is displaying.");    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        AndroidManager manager1 = AndroidManager.getInstance();        AndroidManager manager2 = AndroidManager.getInstance();        System.out.println(manager1 == manager2);        manager1.display();    }}

6. 適配器模式

適配器模式就像一個插頭轉換器，可以將一個插頭的形狀轉換為另一種插頭的形狀。使用場景是當需要將一個類的接口轉換為另一個類的接口時，可以使用適配器模式。

優點：可以讓不兼容的接口協同工作。

缺點：適配器模式可能會導致系統中出現過多的適配器類。

// 目標接口public interface AndroidTarget {    void play(String fileName);}// 適配者類public class WindowsMediaPlayer {    public void playFile(String fileName) {        System.out.println("Playing " + fileName + " using Windows Media Player.");    }}// 適配器類public class WindowsMediaPlayerAdapter implements AndroidTarget {    private WindowsMediaPlayer mediaPlayer;    public WindowsMediaPlayerAdapter(WindowsMediaPlayer mediaPlayer) {        this.mediaPlayer = mediaPlayer;    }    @Override    public void play(String fileName) {        mediaPlayer.playFile(fileName);    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        WindowsMediaPlayer mediaPlayer = new WindowsMediaPlayer();        AndroidTarget target = new WindowsMediaPlayerAdapter(mediaPlayer);        target.play("music.mp3");    }}

7. 橋接模式

橋接模式就像一座橋梁，可以連接兩個不同的地方。使用場景是當需要將一個類的抽象部分與實現部分分離開來時，可以使用橋接模式。

優點：可以讓抽象部分和實現部分獨立地變化，從而提高系統的靈活性。

缺點：橋接模式可能會增加系統的復雜度。

// 抽象類public abstract class Shape {    protected Color color;    public Shape(Color color) {        this.color = color;    }    public abstract void draw();}// 具體類public class Circle extends Shape {    private int x, y, radius;    public Circle(int x, int y, int radius, Color color) {        super(color);        this.x = x;        this.y = y;        this.radius = radius;    }    @Override    public void draw() {        System.out.println("Drawing a " + color.getColor() + " circle at (" + x + ", " + y + ") with radius " + radius);    }}// 接口public interface Color {    String getColor();}// 實現類public class RedColor implements Color {    @Override    public String getColor() {        return "red";    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Shape shape = new Circle(10, 20, 30, new RedColor());        shape.draw();    }}

8. 組合模式

組合模式就像一棵樹，樹由節點和葉子節點組成。使用場景是當需要將一組對象組織成樹形結構，并對樹中所有對象都進行相同的操作時，可以使用組合模式。

優點：可以使客戶端代碼簡化，將復雜的對象結構簡化為樹形結構。

缺點：組合模式可能會使設計變得更加抽象。

// 抽象類public abstract class File {    private String name;    public File(String name) {        this.name = name;    }    public String getName() {        return name;    }    public abstract void display();}// 葉子節點類public class TextFile extends File {    public TextFile(String name) {        super(name);    }    @Override    public void display() {        System.out.println("Displaying text file " + getName());    }}// 葉子節點類public class ImageFile extends File {    public ImageFile(String name) {        super(name);    }    @Override    public void display() {        System.out.println("Displaying image file " + getName());    }}// 葉子節點類public class VideoFile extends File {    public VideoFile(String name) {        super(name);    }    @Override    public void display() {        System.out.println("Displaying video file " + getName());    }}// 組合節點類public class Folder extends File {    private List files;    public Folder(String name) {        super(name);        files = new ArrayList<>();    }    public void addFile(File file) {        files.add(file);    }    public void removeFile(File file) {        files.remove(file);    }    @Override    public void display() {        System.out.println("Displaying folder " + getName());        for (File file : files) {            file.display();        }    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Folder root = new Folder("root");        Folder folder1 = new Folder("folder1");        Folder folder2 = new Folder("folder2");        root.addFile(folder1);        root.addFile(folder2);        TextFile textFile1 = new TextFile("textFile1.txt");        ImageFile imageFile1 = new ImageFile("imageFile1.jpg");        VideoFile videoFile1 = new VideoFile("videoFile1.mp4");        folder1.addFile(textFile1);        folder1.addFile(imageFile1);        folder2.addFile(videoFile1);        root.display();    }}

9. 裝飾模式

裝飾模式就像給一個人穿衣服，可以在不改變其本質的情況下，為其添加新的功能。使用場景是當需要動態地給一個對象添加一些額外的職責時，可以使用裝飾模式。

優點：可以在不修改原始對象的情況下，動態地給對象添加新的功能。

缺點：裝飾模式可能會導致系統中出現過多的裝飾器類。

// 抽象類public abstract class Component {    public abstract void operation();}// 具體類public class ConcreteComponent extends Component {    @Override    public void operation() {        System.out.println("Performing operation in concrete component.");    }}// 抽象裝飾類 public abstract class Decorator extends Component { private Component component;public Decorator(Component component) {    this.component = component;}@Overridepublic void operation() {    if (component != null) {        component.operation();    }}}// 具體裝飾類 public class ConcreteDecorator extends Decorator { public ConcreteDecorator(Component component) { super(component); }@Overridepublic void operation() {    super.operation();    addBehavior();}private void addBehavior() {    System.out.println("Adding behavior in concrete decorator.");}}// 客戶端代碼 public class Client { public static void main(String\[\] args) { Component component = new ConcreteComponent(); Decorator decorator = new ConcreteDecorator(component); decorator.operation(); } }

10. 代理模式

代理模式常常用于一些需要控制訪問的對象，例如需要限制客戶端直接訪問真實對象，可以通過代理對象來進行訪問控制。

// 抽象主題public interface Subject {    void request();}// 真實主題public class RealSubject implements Subject {    @Override    public void request() {        System.out.println("Real subject request.");    }}// 代理類public class Proxy implements Subject {    private RealSubject realSubject;    public Proxy() {        this.realSubject = new RealSubject();    }    @Override    public void request() {        beforeRequest();        realSubject.request();        afterRequest();    }    private void beforeRequest() {        System.out.println("Before request.");    }    private void afterRequest() {        System.out.println("After request.");    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Subject subject = new Proxy();        subject.request();    }}

在上述代碼中，代理類 Proxy實現了 Subject接口，并持有一個真實主題對象 RealSubject的引用。在 request()方法中，代理類首先執行了 beforeRequest()方法，然后調用真實主題對象的 request()方法，最后執行了 afterRequest()方法。這樣做可以在訪問真實主題對象之前或之后進行一些額外的操作，例如權限驗證、緩存數據等。

代理模式的優點是可以實現訪問控制和日志記錄等功能，同時也可以減少系統的耦合度，增加代碼的可維護性和擴展性。但代理模式也存在一些缺點，例如會增加代碼的復雜度，增加系統的運行開銷，同時也可能會降低系統的性能。

11. 責任鏈模式

責任鏈模式通常用于處理一些需要多個對象共同處理的請求，例如 Android 中的事件分發機制。下面是一個基于 Android 的責任鏈模式實現示例：

// 抽象處理器public abstract class Handler {    private Handler successor;    public void setSuccessor(Handler successor) {        this.successor = successor;    }    public void handleRequest(int request) {        if (canHandle(request)) {            handle(request);        } else if (successor != null) {            successor.handleRequest(request);        } else {            System.out.println("No handler can handle the request.");        }    }    protected abstract boolean canHandle(int request);    protected abstract void handle(int request);}// 具體處理器public class ConcreteHandler1 extends Handler {    @Override    protected boolean canHandle(int request) {        return request >= 0 && request < 10;    }    @Override    protected void handle(int request) {        System.out.println("Handling request in concrete handler 1.");    }}public class ConcreteHandler2 extends Handler {    @Override    protected boolean canHandle(int request) {        return request >= 10 && request < 20;    }    @Override    protected void handle(int request)

在上述代碼中，抽象處理器 Handler定義了一個后繼處理器 successor和一個處理請求的方法 handleRequest()，具體處理器 ConcreteHandler1和 ConcreteHandler2繼承了抽象處理器并實現了處理請求的方法。在處理請求時，如果當前處理器可以處理請求，則調用其處理請求的方法，否則將請求轉發給后繼處理器，直到找到可以處理請求的處理器為止。

責任鏈模式的優點是可以動態地組合處理器，增強系統的靈活性和可擴展性。同時，責任鏈模式還可以避免請求發送者和接收者之間的耦合關系，提高系統的可維護性和可測試性。但責任鏈模式也存在一些缺點，例如會增加系統的復雜度和運行開銷，同時也可能會降低系統的性能。

12. 命令模式

命令模式通常用于將請求封裝成對象，從而使請求參數化、隊列化和記錄化，以便支持撤銷、恢復和事務等操作。

// 命令接口public interface Command {    void execute();}// 具體命令public class ConcreteCommand1 implements Command {    private Receiver receiver;    public ConcreteCommand1(Receiver receiver) {        this.receiver = receiver;    }    @Override    public void execute() {        receiver.action1();    }}public class ConcreteCommand2 implements Command {    private Receiver receiver;    public ConcreteCommand2(Receiver receiver) {        this.receiver = receiver;    }    @Override    public void execute() {        receiver.action2();    }}// 接收者public class Receiver {    public void action1() {        System.out.println("Receiver action 1.");    }    public void action2() {        System.out.println("Receiver action 2.");    }}// 調用者public class Invoker {    private Command command;    public void setCommand(Command command) {        this.command = command;    }    public void executeCommand() {        command.execute();    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Receiver receiver = new Receiver();        Command command1 = new ConcreteCommand1(receiver);        Command command2 = new ConcreteCommand2(receiver);        Invoker invoker = new Invoker();        invoker.setCommand(command1);        invoker.executeCommand();        invoker.setCommand(command2);        invoker.executeCommand();    }}

在上述代碼中，命令接口 Command定義了一個執行命令的方法 execute()，具體命令 ConcreteCommand1和 ConcreteCommand2實現了命令接口并調用了接收者的方法。接收者 Receiver定義了兩個具體的方法 action1()和 action2()，可以被具體命令調用。調用者 Invoker持有一個命令對象，并提供了執行命令的方法 `executeCommand

13. 備忘錄模式

備忘錄模式可以將對象的內部狀態封裝成備忘錄對象，以便后續恢復對象的狀態。下面是一個基于 Android 的備忘錄模式實現示例：

// 備忘錄類public class Memento {    private String state;    public Memento(String state) {        this.state = state;    }    public String getState() {        return state;    }}// 發起者類public class Originator {    private String state;    public void setState(String state) {        this.state = state;    }    public String getState() {        return state;    }    public Memento saveStateToMemento() {        return new Memento(state);    }    public void getStateFromMemento(Memento memento) {        state = memento.getState();    }}// 管理者類public class Caretaker {    private List mementoList = new ArrayList<>();    public void addMemento(Memento memento) {        mementoList.add(memento);    }    public Memento getMemento(int index) {        return mementoList.get(index);    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Originator originator = new Originator();        Caretaker caretaker = new Caretaker();        originator.setState("State 1");        originator.setState("State 2");        caretaker.addMemento(originator.saveStateToMemento());        originator.setState("State 3");        caretaker.addMemento(originator.saveStateToMemento());        Memento memento1 = caretaker.getMemento(0);        Memento memento2 = caretaker.getMemento(1);        originator.getStateFromMemento(memento1);        System.out.println("Current state: " + originator.getState());        originator.getStateFromMemento(memento2);        System.out.println("Current state: " + originator.getState());    }}

在上述代碼中，備忘錄類 Memento封裝了發起者 Originator的狀態。發起者類提供了設置狀態和獲取狀態的方法，并提供了保存狀態和恢復狀態的方法。管理者類 Caretaker存儲了多個備忘錄對象，并提供了獲取備忘錄對象的方法。在客戶端代碼中，創建一個發起者對象和一個管理者對象，并對發起者對象的狀態進行修改和保存。最后通過管理者對象獲取備忘錄對象，并使用發起者對象恢復備忘錄對象中保存的狀態。

備忘錄模式的優點是可以將狀態信息封裝在備忘錄對象中，避免了直接訪問狀態信息的問題，并提高了系統的靈活性和可維護性。同時，備忘錄模式還可以實現撤銷、恢復和事務等操作。但備忘錄模式也存在一些缺點，例如可能會導致系統的性能和內存開銷增加，并且需要消耗額外的存儲空間來存儲備忘錄對象。

14. 觀察者模式

觀察者模式通常用于實現對象之間的觀察者模式

觀察者模式通常用于實現對象之間的一對多關系，當一個對象的狀態發生改變時，會自動通知其它對象進行更新。

// 觀察者接口public interface Observer {    void update(int value);}// 主題接口public interface Subject {    void attach(Observer observer);    void detach(Observer observer);    void notifyObservers();}// 具體主題類public class ConcreteSubject implements Subject {    private List observers = new ArrayList<>();    private int state;    public void setState(int state) {        this.state = state;        notifyObservers();    }    public void attach(Observer observer) {        observers.add(observer);    }    public void detach(Observer observer) {        observers.remove(observer);    }    public void notifyObservers() {        for (Observer observer : observers) {            observer.update(state);        }    }}// 具體觀察者類public class ConcreteObserver implements Observer {    private int state;    public void update(int value) {        state = value;        System.out.println("Observer state updated to: " + state);    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        ConcreteSubject subject = new ConcreteSubject();        Observer observer1 = new ConcreteObserver();        Observer observer2 = new ConcreteObserver();        subject.attach(observer1);        subject.attach(observer2);        subject.setState(1);        subject.detach(observer1);        subject.setState(2);    }}

在上述代碼中，主題接口 Subject定義了注冊觀察者、移除觀察者和通知觀察者的方法。具體主題類 ConcreteSubject實現了主題接口，并維護了觀察者列表和狀態信息。具體觀察者類 ConcreteObserver實現了觀察者接口，并實現了更新狀態的方法。在客戶端代碼中，創建一個具體主題對象和兩個具體觀察者對象，并將觀察者對象注冊到主題對象中。隨后修改主題對象的狀態信息，通知所有觀察者進行更新。最后移除一個觀察者對象，再次修改主題對象的狀態信息，只有一個觀察者對象進行更新。

觀察者模式的優點是可以實現對象之間的松耦合，同時支持動態添加和刪除觀察者對象。觀察者模式還可以實現廣播通知功能，支持一對多和一對一等多種模式。但觀察者模式也存在一些缺點，例如可能導致性能問題和內存泄漏問題，并且需要考慮觀察者對象的線程安全問題。此外，在使用觀察者模式時需要注意避免循環依賴問題。

15. 狀態模式

狀態模式通常用于處理對象在不同狀態下的行為差異問題。狀態模式將對象的狀態抽象成一個狀態類，通過將狀態類與主體類進行關聯，從而使主體類可以在不同狀態下表現出不同的行為。下面是一個基于 Android 的狀態模式實現示例：

// 抽象狀態類public abstract class State {    public abstract void handle(Context context);}// 具體狀態類Apublic class ConcreteStateA extends State {    public void handle(Context context) {        System.out.println("State A handling...");        context.setState(new ConcreteStateB());    }}// 具體狀態類Bpublic class ConcreteStateB extends State {    public void handle(Context context) {        System.out.println("State B handling...");        context.setState(new ConcreteStateA());    }}// 上下文類public class Context {    private State state;    public Context(State state) {        this.state = state;    }    public void setState(State state) {        this.state = state;    }    public void request() {        state.handle(this);    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Context context = new Context(new ConcreteStateA());        context.request();        context.request();        context.request();        context.request();    }}

在上述代碼中，抽象狀態類 State定義了狀態的抽象方法 handle()，具體狀態類 ConcreteStateA和 ConcreteStateB分別實現了 handle()方法，并在方法中通過 Context對象調用了 setState()方法進行狀態轉換。上下文類 Context維護了當前的狀態信息，并提供了 setState()和 request()方法用于狀態轉換和行為執行。在客戶端代碼中，創建一個初始狀態為 ConcreteStateA的上下文對象，并多次調用 request()方法，輸出結果表明狀態被不斷轉換，并按照不同的狀態執行了不同的行為。

狀態模式的優點是可以將狀態相關的行為封裝到具體狀態類中，使得代碼更加清晰和易于維護。狀態模式還可以避免大量的條件分支語句，提高了代碼的可擴展性和可讀性。但狀態模式也存在一些缺點，例如需要編寫大量的狀態類和狀態轉換邏輯，可能導致代碼過于復雜。此外，狀態模式也可能導致狀態對象過多，占用過多的內存空間。

16. 策略模式

策略模式是一種行為型設計模式，用于在運行時選擇算法。它允許一個對象在不同的情況下采用不同的算法。策略模式通過將不同的算法封裝到具體策略類中，從而使得這些算法可以互相替換。下面是一個基于 Android 的策略模式實現示例：

// 抽象策略類public interface Strategy {    void doOperation(int num1, int num2);}// 具體策略類Apublic class OperationAdd implements Strategy {    public void doOperation(int num1, int num2) {        System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));    }}// 具體策略類Bpublic class OperationSubstract implements Strategy {    public void doOperation(int num1, int num2) {        System.out.println(num1 + " - " + num2 + " = " + (num1 - num2));    }}// 具體策略類Cpublic class OperationMultiply implements Strategy {    public void doOperation(int num1, int num2) {        System.out.println(num1 + " * " + num2 + " = " + (num1 * num2));    }}// 策略執行類public class Context {    private Strategy strategy;    public Context(Strategy strategy) {        this.strategy = strategy;    }    public void executeStrategy(int num1, int num2) {        strategy.doOperation(num1, num2);    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Context context = new Context(new OperationAdd());        context.executeStrategy(10, 5);        context = new Context(new OperationSubstract());        context.executeStrategy(10, 5);        context = new Context(new OperationMultiply());        context.executeStrategy(10, 5);    }}

在上述代碼中，抽象策略類 Strategy定義了算法的抽象方法 doOperation()，具體策略類 OperationAdd、OperationSubstract和 OperationMultiply分別實現了 doOperation()方法，并提供了不同的算法實現。策略執行類 Context維護了當前算法的策略對象，并提供了 executeStrategy()方法用于調用具體策略類的 doOperation()方法。在客戶端代碼中，通過創建一個策略執行類的實例，并將不同的具體策略類作為參數傳遞給策略執行類的構造方法，實現了不同算法的運行時切換。

策略模式的優點在于能夠在運行時動態地選擇算法，避免了大量的條件分支語句，并且可以很方便地擴展新的算法。策略模式還能夠將不同的算法封裝到具體策略類中，使得代碼更加清晰和易于維

17. 模板方法模式

模板方法模式是一種行為型設計模式，用于定義一個操作中的算法骨架，將一些步驟延遲到子類中實現。這種模式允許子類在不改變算法結構的情況下重新定義算法的某些步驟。在 Android 中，模板方法模式通常用于在父類中定義一些公共的操作步驟，而將具體的實現交給子類。下面是一個基于 Android 的模板方法模式實現示例：

// 抽象類public abstract class Game {    abstract void initialize();    abstract void startPlay();    abstract void endPlay();    // 模板方法    public final void play() {        // 初始化游戲        initialize();        // 開始游戲        startPlay();        // 結束游戲        endPlay();    }}// 具體類public class Cricket extends Game {    @Override    void endPlay() {        System.out.println("Cricket Game Finished!");    }    @Override    void initialize() {        System.out.println("Cricket Game Initialized! Start playing.");    }    @Override    void startPlay() {        System.out.println("Cricket Game Started. Enjoy the game!");    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        Game game = new Cricket();        game.play();    }}

在上述代碼中，抽象類 Game定義了游戲的模板方法 play()，其中包含了游戲的初始化、開始和結束三個步驟。具體的游戲類 Cricket繼承了抽象類 Game，并且實現了 initialize()、startPlay()和 endPlay()這三個步驟的具體實現。在客戶端代碼中，創建了一個 Cricket對象，并調用 play()方法來啟動游戲。

模板方法模式的優點在于能夠減少代碼的重復性，提高代碼的復用性，同時還能夠實現一種算法的統一管理和控制。此外，模板方法模式還能夠使得算法的具體實現與算法的調用分離，使得程序更加靈活和易于維護。

模板方法模式的缺點在于，由于算法的實現由子類來完成，因此可能會導致子類的數量增多，從而增加了代碼的維護成本。此外，模板方法模式也可能導致代碼的層次結構變得復雜，不易于理解和維護。

18. 訪問者模式

訪問者模式是一種行為型設計模式，用于將算法從其所操作的對象結構中分離出來，從而可以在不改變對象結構的前提下定義新的操作。這種模式將對象結構和算法分離，從而使得算法可以獨立于對象結構而變化。在 Android 中，訪問者模式通常用于對復雜對象結構進行遍歷或者進行一些統計操作。下面是一個基于 Android 的訪問者模式實現示例：

// 抽象訪問者interface Visitor {    void visit(File file);    void visit(Directory directory);}// 抽象元素類interface Element {    void accept(Visitor visitor);}// 文件類，具體元素類class File implements Element {    private final String name;    public File(String name) {        this.name = name;    }    public String getName() {        return name;    }    public void accept(Visitor visitor) {        visitor.visit(this);    }}// 目錄類，具體元素類class Directory implements Element {    private final List elements;    public Directory(List elements) {        this.elements = elements;    }    public List getElements() {        return elements;    }    public void accept(Visitor visitor) {        visitor.visit(this);    }}// 具體訪問者類class CountVisitor implements Visitor {    private int fileCount;    private int directoryCount;    public void visit(File file) {        fileCount++;    }    public void visit(Directory directory) {        directoryCount++;        for (Element element : directory.getElements()) {            element.accept(this);        }    }    public int getFileCount() {        return fileCount;    }    public int getDirectoryCount() {        return directoryCount;    }}// 客戶端代碼public class Client {    public static void main(String[] args) {        List elements = new ArrayList<>();        elements.add(new File("file1"));        elements.add(new File("file2"));        elements.add(new Directory(Arrays.asList(                new File("file3"),                new File("file4"),                new Directory(Collections.singletonList(new File("file5")))        )));        Directory rootDirectory = new Directory(elements);        CountVisitor visitor = new CountVisitor();        rootDirectory.accept(visitor);        System.out.println("File count: " + visitor.getFileCount());        System.out.println("Directory count: " + visitor.getDirectoryCount());    }}

在上述代碼中，抽象元素類 Element定義了 accept()方法，用于接受訪問者的訪問。具體元素類 File和 Directory實現了 Element接口，并且在 accept()方法中調用了訪問者的 visit()方法。抽象訪問者接口 Visitor定義了 visit()方法，具體訪問者類 CountVisitor實現了 Visitor接口，并且在 visit()方法中對元素進行統計。在客戶端代碼中，創建了一個復雜的對象結構，即一個目錄中包含了多個文件和子目錄。然后創建了一個 CountVisitor對象。

關鍵詞：