揭露：這篇文章包含附屬連結；如果您透過本文中提供的不同連結購買產品或服務，我可能會獲得補償。

朋友們大家好，設計模式是人們告訴我要成為高級軟體工程師必須學習的技能之一，因為它在高級軟體工程師面試中經過了嚴格的測試。

後來我了解到，設計模式對於編寫可以在生產中生存的乾淨程式碼是多麼重要。

對於不知道的人來說，設計模式是軟體設計中遇到的常見問題的可重複使用解決方案。

它們封裝了最佳實踐，並為建立靈活、可維護和可擴展的軟體提供了藍圖。

在過去的幾篇文章中，我分享了許多流行的系統設計問題，例如API網關與負載平衡器、水平與垂直擴展、 正向代理與反向代理以及50個系統設計問題，今天我將分享10種設計模式程式設計面試。

順便說一句，如果您還沒有讀過這些文章，您也可以閱讀它們，特別是如果您想學習系統設計，這是高級軟體工程師的另一個急需技能。

如果您正在學習這些概念作為面試準備的一部分，那麼我還建議您查看ByteByteGo 、 DesignGurus.io 、 Exponent 、 Educative 、 Codemia.io 、 InterviewReddy.io和Udemy等網站，它們有許多很棒的系統設計課程

PS 繼續閱讀直到最後。我有一份獎金給你。

程式設計面試的 10 個基本 OOP 設計模式

所以，這裡有10 個你可以在程式設計面試中學習的重要設計模式，雖然閱讀這篇文章可能需要更少的時間，但如果你想嘗試程式碼範例，甚至可能需要10 多分鐘，但10 分鐘就足夠了閱讀並理解這些程式碼範例。

1. 單例模式

單例模式確保一個類別只有一個實例並提供對其的全域存取點。當只需要一個物件來協調整個系統的操作時，這一點特別有用。

這是單例模式的程式碼範例

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

影響

此模式確保對特定資源的單點控制，防止不必要的實例化並確保高效的資源利用。

雖然許多人認為 Singleton 是反模式，因為它不容易進行單元測試，並且依賴注入比 Singleton 更受青睞，但它仍然是一個值得了解的好模式。

這是Singleton模式的UML圖

2.工廠方法模式

工廠方法模式定義了用於建立物件的接口，但允許子類別變更將建立的物件的類型。

它提供了一個用於建立類別實例的接口，其子類別決定要實例化哪個類別。

並且，這是此模式的範例程式碼：

public interface Product {
    void create();
}

public class ConcreteProduct implements Product {
    @Override
    public void create() {
        // Implementation
    }
}

public interface Creator {
    Product factoryMethod();
}

public class ConcreteCreator implements Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

影響

這種設計模式允許客戶端程式碼透過介面與物件交互，從而促進鬆散耦合，從而更容易擴展和維護。

下面是工廠方法模式的 UML 圖：

3.觀察者模式

觀察者模式定義了物件之間的一對多依賴關係，以便當一個物件更改狀態時，它的所有依賴項都會被通知並自動更新。

這通常用於實現分散式事件處理系統。

例子：

public interface Observer {
    void update(String message);
}

public class ConcreteObserver implements Observer {
    @Override\
    public void update(String message) {
        // Implementation
    }
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

影響

這種模式可以將主體與其觀察者之間清晰地分開，從而促進輕鬆的可擴展性和可維護性。

這是觀察者模式的 UML 圖：

4. 策略模式

策略模式定義了一系列演算法，封裝了每個演算法，並使它們可以互換。它允許客戶端在執行時選擇適當的演算法。

以下是該模式的程式碼範例：

public interface PaymentStrategy {
    void pay(int amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        // Implementation
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        // Implementation
    }
}

public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

影響

這種設計模式允許演算法獨立於使用它們的客戶端而變化，從而提高演算法替換的靈活性和易用性。

下面是Java中策略設計模式的UML圖：

5. 裝飾器模式

裝飾器模式動態地將附加職責附加到物件。裝飾器為擴充功能提供了子類化的靈活替代方案。

例子：

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        // Implementation
    }
}

public abstract class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        // Additional functionality
    }
}

影響

這種模式可以動態地為物件加入職責，從而避免需要大量的子類別。

下面是裝飾器設計模式的UML圖：

6. 適配器模式

適配器模式允許不相容的介面一起工作。它充當兩個不相容介面之間的橋樑，使它們在不更改程式碼的情況下相容。

以下是 Java 適配器模式的程式碼範例：

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        // Implementation
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

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

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

影響

此模式允許現有系統在介面不相容的情況下一起工作，從而促進現有系統的整合。

下面是Java中適配器模式的UML圖：

7. 命令模式

命令模式將請求封裝為物件，從而允許對具有不同請求的客戶端進行參數化、請求排隊以及參數記錄。

以下是此模式的程式碼範例：

public interface Command {
    void execute();
}

public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action();
    }
}

public class Receiver {
    public void action() {
        // Implementation
    }
}

public class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void executeCommand() {
        command.execute();
    }
}

影響

這種模式促進了請求的發送者和接收者之間的鬆散耦合，從而允許命令處理的可擴展性和靈活性。

下面是 Java 中命令模式的 UML 圖：

8. 複合模式

複合模式將物件組合成樹狀結構來表示部分-整體層次結構。它允許客戶統一處理單一物件和物件組合。

以下是在 Java 中實作複合模式的程式碼範例：

public interface Component {
    void operation();
}

public class Leaf implements Component {
    @Override
    public void operation() {
        // Implementation
    }
}

public class Composite implements Component {
    private List<Component> components = new ArrayList<>();

    public void addComponent(Component component) {
        components.add(component);
    }

    @Override
    public void operation() {
        for (Component component : components) {
            component.operation();
        }
    }
}

**影響

**此模式允許客戶端程式碼統一處理單一物件和組合，從而大大簡化了客戶端程式碼。

下面是 Java 中複合模式的 UML 圖：

9. 責任鏈模式

責任鏈模式沿著處理程序鏈傳遞請求。每個處理程序決定要么處理請求，要么將其傳遞給鏈中的下一個處理程序。

以下是該模式的程式碼範例：

public abstract class Handler {
    private Handler successor;

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

    public void handleRequest() {
        if (successor != null) {
            successor.handleRequest();
        }
    }
}

public class ConcreteHandler extends Handler {
    @Override
    public void handleRequest() {
        // Handle the request
        super.handleRequest();
    }
}

影響

這種模式將發送者和接收者解耦，允許多個物件處理請求，而發送者不需要知道哪個物件最終將處理它。

下面是 Java 中責任鏈模式的 UML 圖：

10. 狀態模式

狀態模式允許物件在其內部狀態發生變化時改變其行為。該物件似乎會更改其類別。

下面是Java中狀態設計模式的程式碼範例：

public interface State {
    void handle();
}

public class ConcreteStateA implements State {
    @Override
    public void handle() {
        // Implementation for state A
    }
}

public class ConcreteStateB implements State {
    @Override
    public void handle() {
        // Implementation for state B
    }
}

public class Context {
    private State currentState;

    public void setState(State state) {
        currentState = state;
    }

    public void request() {
        currentState.handle();
    }
}

影響

狀態設計模式透過允許動態更改其內部狀態來簡化複雜的物件行為。

下面是Java中狀態設計模式的UML圖：

結論

這就是程式設計面試的 10 種基本設計模式。設計模式是開發人員工具包中的強大工具，為常見的軟體設計挑戰提供解決方案。

理解和實現這些模式可以顯著提高程式碼的可維護性、可擴展性和可擴展性。

雖然掌握這些模式可能需要時間，但明智地將它們合併到您的專案中無疑會帶來更強大、更靈活的軟體架構。

進一步學習

1. Java 中的設計模式

Explore practical implementations of design patterns in Java.

2. 基礎軟體架構

Learn foundational concepts in software architecture.

3. 深入了解 OOP 面試

Prepare for object-oriented programming interviews with real-world scenarios.

4. Java 設計模式與架構（免費）

Access a free guide to Java design patterns and their applications.

5. 設計模式庫

A rich library of design pattern examples and explanations.

6. 模式範例

Learn patterns through concrete examples for better understanding.

獎金

正如承諾的，這是給你的獎金，一本免費的書。我剛剛找到一本新的免費書籍來學習分散式系統設計，您也可以在 Microsoft 上閱讀它 --- https://info.microsoft.com/rs/157-GQE-382/images/EN-CNTNT -eBook-設計分散式系統.pdf

image_credit --- 推特

原文出處：https://dev.to/somadevtoo/top-10-design-patterns-for-programming-interviews-8j4