Java 23種設計模式的詳細解析
以下是Java 23種設計模式的詳細解析，包含意圖、特點、實現要點及代碼演示，按創建型、結構型、行為型分類整理：
一、創建型模式（5種）
專注于對象創建機制，隱藏創建邏輯，提高靈活性。
1. 單例模式（Singleton）
- 意圖：確保一個類僅有一個實例，并提供全局訪問點。
- 特點：
- 唯一實例，全局可訪問；
- 避免頻繁創建銷毀，節省資源；
- 需處理線程安全問題。
- 實現要點：
- 私有構造器阻止外部實例化；
- 靜態方法/變量持有唯一實例。
// 餓漢式（線程安全，類加載時初始化）
public class Singleton {
private static final Singleton INSTANCE = new Singleton();
private Singleton() {} // 私有構造器
public static Singleton getInstance() { return INSTANCE; }
}
// 懶漢式（雙重校驗鎖，延遲初始化）
public class LazySingleton {
private static volatile LazySingleton instance;
private LazySingleton() {}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
}
2. 工廠模式（Factory）
- 意圖：通過工廠類封裝對象創建邏輯，客戶端無需關注具體實現。
- 特點：
- 解耦對象創建與使用；
- 新增產品只需擴展工廠，符合開閉原則；
- 適用于產品類型較少的場景。
- 實現要點：
- 定義產品接口；
- 工廠類根據參數返回具體產品實例。
// 產品接口
interface Shape { void draw(); }
// 具體產品
class Circle implements Shape {
@Override public void draw() { System.out.println("畫圓形"); }
}
// 工廠類
class ShapeFactory {
public Shape getShape(String type) {
if (type.equalsIgnoreCase("CIRCLE")) return new Circle();
return null;
}
}
// 使用
public class FactoryDemo {
public static void main(String[] args) {
ShapeFactory factory = new ShapeFactory();
factory.getShape("CIRCLE").draw(); // 輸出：畫圓形
}
}
3. 抽象工廠模式（Abstract Factory）
- 意圖：創建一系列相關或依賴的產品族，無需指定具體類。
- 特點：
- 針對“產品族”（如“現代家具”包含椅子、桌子）；
- 切換產品族只需更換工廠，客戶端無需修改；
- 新增產品需修改工廠接口，靈活性較低。
- 實現要點：
- 抽象工廠定義產品族的創建方法；
- 具體工廠實現特定產品族的創建。
// 抽象產品
interface Chair { void sit(); }
interface Table { void put(); }
// 具體產品（現代風格）
class ModernChair implements Chair {
@Override public void sit() { System.out.println("坐現代椅子"); }
}
// 抽象工廠
interface FurnitureFactory {
Chair createChair();
Table createTable();
}
// 具體工廠
class ModernFactory implements FurnitureFactory {
@Override public Chair createChair() { return new ModernChair(); }
@Override public Table createTable() { return new ModernTable(); }
}
// 使用
public class AbstractFactoryDemo {
public static void main(String[] args) {
FurnitureFactory factory = new ModernFactory();
factory.createChair().sit(); // 輸出：坐現代椅子
}
}
4. 建造者模式（Builder）
- 意圖：分步構建復雜對象，分離構建過程與最終表示。
- 特點：
- 步驟清晰，支持定制對象的不同部件；
- 同一構建過程可生成不同產品；
- 由指揮者控制構建順序。
- 實現要點：
- 建造者接口定義部件構建方法；
- 指揮者調用建造者方法完成組裝。
// 產品
class Computer {
private String cpu;
private String ram;
// getter/setter省略
}
// 建造者接口
interface ComputerBuilder {
void buildCpu();
void buildRam();
Computer getResult();
}
// 具體建造者（高配電腦）
class HighEndBuilder implements ComputerBuilder {
private Computer computer = new Computer();
@Override public void buildCpu() { computer.setCpu("i9"); }
@Override public void buildRam() { computer.setRam("32GB"); }
@Override public Computer getResult() { return computer; }
}
// 指揮者
class Director {
public Computer construct(ComputerBuilder builder) {
builder.buildCpu();
builder.buildRam();
return builder.getResult();
}
}
// 使用
public class BuilderDemo {
public static void main(String[] args) {
Computer computer = new Director().construct(new HighEndBuilder());
System.out.println(computer.getCpu()); // 輸出：i9
}
}
5. 原型模式（Prototype）
- 意圖：通過復制現有對象創建新對象，避免重復初始化。
- 特點：
- 簡化創建流程，適合初始化耗時的對象；
- 分為淺拷貝（引用類型共享）和深拷貝（完全復制）；
- 無需知道類名即可創建對象。
- 實現要點：
- 實現
Cloneable接口； - 重寫
clone()方法實現復制邏輯。
- 實現
class Sheep implements Cloneable {
private String name;
public Sheep(String name) { this.name = name; }
@Override protected Sheep clone() throws CloneNotSupportedException {
return (Sheep) super.clone(); // 淺拷貝
}
}
// 使用
public class PrototypeDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep original = new Sheep("多利");
Sheep clone = original.clone();
System.out.println(clone.name); // 輸出：多利
}
}
二、結構型模式（7種）
處理類或對象的組合，優化結構以實現功能復用。
6. 適配器模式（Adapter）
- 意圖：將一個類的接口轉換為客戶端期望的另一個接口。
- 特點：
- 解決接口不兼容問題（如舊系統對接新系統）；
- 分為類適配器（繼承）和對象適配器（組合，更靈活）；
- 不修改原有代碼，符合開閉原則。
- 實現要點：
- 適配器實現目標接口；
- 內部持有適配者實例，轉發請求。
// 目標接口
interface Target { void request(); }
// 適配者
class Adaptee {
public void specificRequest() { System.out.println("適配者方法"); }
}
// 適配器
class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }
@Override public void request() { adaptee.specificRequest(); }
}
// 使用
public class AdapterDemo {
public static void main(String[] args) {
Target target = new Adapter(new Adaptee());
target.request(); // 輸出：適配者方法
}
}
7. 裝飾器模式（Decorator）
- 意圖：動態給對象添加額外功能，不改變其結構。
- 特點：
- 比繼承更靈活，可多層嵌套裝飾；
- 裝飾器與被裝飾者實現同一接口，客戶端透明；
- 適用于功能擴展頻繁的場景（如IO流）。
- 實現要點：
- 裝飾器抽象類實現組件接口，并持有組件實例；
- 具體裝飾器擴展額外功能。
// 抽象組件
interface Coffee {
String getDesc();
double cost();
}
// 具體組件（基礎咖啡）
class SimpleCoffee implements Coffee {
@Override public String getDesc() { return "純咖啡"; }
@Override public double cost() { return 5.0; }
}
// 裝飾器
class MilkDecorator extends CoffeeDecorator {
public MilkDecorator(Coffee coffee) { super(coffee); }
@Override public String getDesc() { return super.getDesc() + " + 牛奶"; }
@Override public double cost() { return super.cost() + 2.0; }
}
// 使用
public class DecoratorDemo {
public static void main(String[] args) {
Coffee coffee = new MilkDecorator(new SimpleCoffee());
System.out.println(coffee.getDesc() + "：" + coffee.cost()); // 純咖啡 + 牛奶：7.0
}
}
8. 代理模式（Proxy）
- 意圖：為對象提供代理，控制對原對象的訪問。
- 特點：
- 代理與目標對象實現同一接口，客戶端無感知；
- 可實現權限控制、延遲加載、日志記錄等；
- 分為靜態代理和動態代理（如JDK Proxy）。
- 實現要點：
- 代理類持有目標對象引用；
- 代理方法中添加額外邏輯后調用目標方法。
// 抽象主題
interface Image { void display(); }
// 真實主題（耗時操作）
class RealImage implements Image {
private String filename;
public RealImage(String filename) { this.filename = filename; load(); }
private void load() { System.out.println("加載圖片：" + filename); }
@Override public void display() { System.out.println("顯示圖片"); }
}
// 代理類（延遲加載）
class ProxyImage implements Image {
private RealImage realImage;
private String filename;
public ProxyImage(String filename) { this.filename = filename; }
@Override public void display() {
if (realImage == null) realImage = new RealImage(filename);
realImage.display();
}
}
// 使用
public class ProxyDemo {
public static void main(String[] args) {
Image image = new ProxyImage("photo.jpg");
image.display(); // 首次：加載并顯示；再次：直接顯示
}
}
9. 外觀模式（Facade）
- 意圖：為子系統提供統一接口，簡化客戶端訪問。
- 特點：
- 封裝子系統復雜性，提供“一站式”接口；
- 隔離客戶端與子系統，降低耦合；
- 不改變子系統內部邏輯。
- 實現要點：
- 外觀類持有子系統實例；
- 提供高層方法封裝子系統交互。
// 子系統
class DVDPlayer { public void on() { System.out.println("DVD打開"); } }
class Projector { public void on() { System.out.println("投影儀打開"); } }
// 外觀類
class HomeTheaterFacade {
private DVDPlayer dvd;
private Projector projector;
public HomeTheaterFacade(DVDPlayer dvd, Projector projector) {
this.dvd = dvd;
this.projector = projector;
}
public void watchMovie() {
projector.on();
dvd.on();
}
}
// 使用
public class FacadeDemo {
public static void main(String[] args) {
new HomeTheaterFacade(new DVDPlayer(), new Projector()).watchMovie();
// 輸出：投影儀打開 → DVD打開
}
}
10. 橋接模式（Bridge）
- 意圖：分離抽象與實現，使兩者可獨立變化。
- 特點：
- 解決抽象與實現的多對多繼承問題（避免類爆炸）；
- 抽象層與實現層通過組合關聯，而非繼承；
- 適合跨維度擴展場景（如“形狀”與“顏色”）。
- 實現要點：
- 抽象類持有實現接口的引用；
- 抽象類的方法通過實現接口完成。
// 實現接口（顏色）
interface Color { void apply(); }
class Red implements Color { @Override public void apply() { System.out.println("紅色"); } }
// 抽象類（形狀）
abstract class Shape {
protected Color color;
public Shape(Color color) { this.color = color; }
abstract void draw();
}
// 具體抽象（圓形）
class Circle extends Shape {
public Circle(Color color) { super(color); }
@Override void draw() {
System.out.print("畫圓形，顏色：");
color.apply();
}
}
// 使用
public class BridgeDemo {
public static void main(String[] args) {
new Circle(new Red()).draw(); // 輸出：畫圓形，顏色：紅色
}
}
11. 組合模式（Composite）
- 意圖：將對象組合成樹形結構，統一處理單個對象和組合對象。
- 特點：
- 樹形結構中，葉子節點與組合節點統一接口；
- 支持遞歸遍歷（如文件系統的文件與文件夾）；
- 客戶端無需區分葉子與組合，操作一致。
- 實現要點：
- 抽象組件定義統一接口；
- 組合節點持有子組件列表，實現添加/刪除/遍歷。
// 抽象組件
interface Component {
void operation();
void add(Component c);
}
// 葉子節點（文件）
class File implements Component {
private String name;
public File(String name) { this.name = name; }
@Override public void operation() { System.out.println("文件：" + name); }
@Override public void add(Component c) {} // 葉子不支持添加
}
// 組合節點（文件夾）
class Folder implements Component {
private List<Component> children = new ArrayList<>();
private String name;
public Folder(String name) { this.name = name; }
@Override public void operation() {
System.out.println("文件夾：" + name);
children.forEach(Component::operation);
}
@Override public void add(Component c) { children.add(c); }
}
// 使用
public class CompositeDemo {
public static void main(String[] args) {
Folder root = new Folder("根目錄");
root.add(new File("a.txt"));
root.operation(); // 輸出：文件夾：根目錄 → 文件：a.txt
}
}
12. 享元模式（Flyweight）
- 意圖：共享細粒度對象，減少內存消耗。
- 特點：
- 區分“內部狀態”（共享，如顏色）和“外部狀態”（非共享，如位置）；
- 通過享元池管理共享對象，避免重復創建；
- 適合對象數量多、重復度高的場景（如圍棋棋子）。
- 實現要點：
- 享元工廠負責創建和緩存享元對象；
- 外部狀態通過方法參數傳入。
// 享元接口
interface Shape { void draw(int x, int y); }
// 具體享元（圓形）
class Circle implements Shape {
private String color; // 內部狀態
public Circle(String color) { this.color = color; }
@Override public void draw(int x, int y) { // 外部狀態
System.out.println("圓形(" + color + ") at (" + x + "," + y + ")");
}
}
// 享元工廠
class ShapeFactory {
private static final Map<String, Shape> circles = new HashMap<>();
public static Shape getCircle(String color) {
return circles.computeIfAbsent(color, k -> {
System.out.println("創建" + color + "圓形");
return new Circle(color);
});
}
}
// 使用
public class FlyweightDemo {
public static void main(String[] args) {
Shape red1 = ShapeFactory.getCircle("紅色");
Shape red2 = ShapeFactory.getCircle("紅色"); // 復用
red1.draw(10, 20); // 圓形(紅色) at (10,20)
}
}
三、行為型模式（11種）
關注對象間的通信、職責分配和行為交互。
13. 策略模式（Strategy）
- 意圖：定義算法族，使其可互換，客戶端可動態選擇。
- 特點：
- 算法獨立封裝，易于擴展（新增策略只需實現接口）；
- 解決“if-else”過多導致的代碼臃腫；
- 客戶端需知道所有策略類。
- 實現要點：
- 策略接口定義算法方法；
- 上下文持有策略引用，動態切換策略。
// 策略接口
interface Payment { void pay(int amount); }
// 具體策略（支付寶）
class Alipay implements Payment {
@Override public void pay(int amount) { System.out.println("支付寶支付：" + amount); }
}
// 上下文
class ShoppingCart {
private Payment payment;
public void setPayment(Payment payment) { this.payment = payment; }
public void checkout(int amount) { payment.pay(amount); }
}
// 使用
public class StrategyDemo {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
cart.setPayment(new Alipay());
cart.checkout(100); // 輸出：支付寶支付：100
}
}
14. 模板方法模式（Template Method）
- 意圖：定義算法骨架，子類實現具體步驟。
- 特點：
- 固定流程，靈活定制步驟（如游戲的初始化→開始→結束）；
- 父類調用子類方法（好萊塢原則：“別找我，我找你”）；
- 符合開閉原則（擴展步驟而非修改骨架）。
- 實現要點：
- 抽象父類定義模板方法（包含固定步驟）；
- 抽象方法由子類實現具體邏輯。
// 抽象模板
abstract class Game {
abstract void initialize();
abstract void start();
// 模板方法（固定流程）
public final void play() {
initialize();
start();
}
}
// 具體實現（足球）
class Football extends Game {
@Override void initialize() { System.out.println("足球初始化"); }
@Override void start() { System.out.println("足球開始"); }
}
// 使用
public class TemplateDemo {
public static void main(String[] args) {
new Football().play(); // 輸出：足球初始化 → 足球開始
}
}
15. 觀察者模式（Observer）
- 意圖：對象間一對多依賴，當一個對象變化時通知所有依賴者。
- 特點：
- 松耦合：主題無需知道觀察者細節；
- 支持動態添加/移除觀察者；
- 適合事件驅動場景（如GUI事件、消息通知）。
- 實現要點：
- 主題維護觀察者列表，提供注冊/移除/通知方法；
- 觀察者實現更新接口，接收主題通知。
// 主題接口
interface Subject {
void register(Observer o);
void notifyObservers(String msg);
}
// 觀察者接口
interface Observer { void update(String msg); }
// 具體主題（公眾號）
class WechatSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
@Override public void register(Observer o) { observers.add(o); }
@Override public void notifyObservers(String msg) {
observers.forEach(o -> o.update(msg));
}
}
// 具體觀察者（用戶）
class User implements Observer {
private String name;
public User(String name) { this.name = name; }
@Override public void update(String msg) {
System.out.println(name + "收到：" + msg);
}
}
// 使用
public class ObserverDemo {
public static void main(String[] args) {
WechatSubject subject = new WechatSubject();
subject.register(new User("張三"));
subject.notifyObservers("新文章發布"); // 張三收到：新文章發布
}
}
16. 迭代器模式（Iterator）
- 意圖：提供遍歷集合的統一接口，無需暴露內部結構。
- 特點：
- 客戶端無需關心集合類型（列表、樹等），通過迭代器遍歷；
- 支持多種遍歷方式（正向、反向）；
- 符合單一職責原則（集合負責存儲，迭代器負責遍歷）。
- 實現要點：
- 迭代器接口定義
hasNext()和next()方法； - 集合提供獲取迭代器的方法。
- 迭代器接口定義
// 迭代器接口
interface Iterator {
boolean hasNext();
Object next();
}
// 集合接口
interface Container { Iterator getIterator(); }
// 具體集合（名字列表）
class NameContainer implements Container {
private String[] names = {"A", "B", "C"};
@Override public Iterator getIterator() {
return new NameIterator();
}
private class NameIterator implements Iterator {
int index = 0;
@Override public boolean hasNext() { return index < names.length; }
@Override public Object next() { return names[index++]; }
}
}
// 使用
public class IteratorDemo {
public static void main(String[] args) {
Container container = new NameContainer();
Iterator it = container.getIterator();
while (it.hasNext()) { System.out.println(it.next()); } // A、B、C
}
}
17. 責任鏈模式（Chain of Responsibility）
- 意圖：將請求沿處理鏈傳遞，直到被處理。
- 特點：
- 發送者與接收者解耦，無需知道誰處理請求；
- 可動態調整鏈結構（如審批流程：組長→經理→總監）；
- 可能導致請求未被處理。
- 實現要點：
- 處理器持有下一個處理器引用；
- 每個處理器判斷是否處理請求，否則傳遞給下一個。
// 抽象處理器
abstract class Handler {
protected Handler next;
public void setNext(Handler next) { this.next = next; }
abstract void handle(int request);
}
// 處理1-10
class Handler1 extends Handler {
@Override void handle(int request) {
if (request <= 10) System.out.println("Handler1處理：" + request);
else if (next != null) next.handle(request);
}
}
// 處理11-20
class Handler2 extends Handler {
@Override void handle(int request) {
if (request <= 20) System.out.println("Handler2處理：" + request);
else if (next != null) next.handle(request);
}
}
// 使用
public class ChainDemo {
public static void main(String[] args) {
Handler h1 = new Handler1();
Handler h2 = new Handler2();
h1.setNext(h2);
h1.handle(5); // Handler1處理：5
h1.handle(15); // Handler2處理：15
}
}
18. 命令模式（Command）
- 意圖：將請求封裝為對象，使請求可參數化、隊列化或撤銷。
- 特點：
- 解耦請求發送者與接收者（如遙控器與燈）；
- 支持命令排隊、日志記錄、事務回滾；
- 新增命令只需實現接口，擴展性好。
- 實現要點：
- 命令接口定義
execute()方法； - 具體命令持有接收者引用，調用其方法。
- 命令接口定義
// 命令接口
interface Command { void execute(); }
// 接收者（燈）
class Light {
public void on() { System.out.println("燈亮"); }
}
// 具體命令（開燈）
class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light) { this.light = light; }
@Override public void execute() { light.on(); }
}
// 調用者（遙控器）
class Remote {
private Command command;
public void setCommand(Command command) { this.command = command; }
public void press() { command.execute(); }
}
// 使用
public class CommandDemo {
public static void main(String[] args) {
Remote remote = new Remote();
remote.setCommand(new LightOnCommand(new Light()));
remote.press(); // 輸出：燈亮
}
}
19. 備忘錄模式（Memento）
- 意圖：保存對象狀態，以便后續恢復。
- 特點：
- 封裝狀態存儲細節，原發器無需暴露內部狀態；
- 適合游戲存檔、編輯器撤銷等場景；
- 需平衡內存開銷（過多快照占用資源）。
- 實現要點：
- 備忘錄存儲原發器狀態；
- 管理者負責保存和恢復備忘錄。
// 備忘錄
class Memento {
private String state;
public Memento(String state) { this.state = state; }
public String getState() { return state; }
}
// 原發器
class Originator {
private String state;
public void setState(String state) { this.state = state; }
public Memento save() { return new Memento(state); }
public void restore(Memento m) { state = m.getState(); }
}
// 管理者
class CareTaker {
private Memento memento;
public void save(Memento m) { memento = m; }
public Memento get() { return memento; }
}
// 使用
public class MementoDemo {
public static void main(String[] args) {
Originator o = new Originator();
CareTaker c = new CareTaker();
o.setState("狀態1");
c.save(o.save()); // 保存
o.setState("狀態2");
o.restore(c.get()); // 恢復為狀態1
}
}
20. 狀態模式（State）
- 意圖：允許對象在內部狀態變化時改變行為，類似狀態機。
- 特點：
- 將狀態邏輯封裝到不同狀態類，避免“if-else”堆砌；
- 狀態轉換清晰，可由狀態類或上下文控制；
- 適合狀態較多且轉換復雜的場景（如訂單狀態）。
- 實現要點：
- 狀態接口定義行為方法；
- 上下文持有當前狀態，委托狀態對象處理行為。
// 狀態接口
interface State { void doAction(Context context); }
// 具體狀態（開啟）
class StartState implements State {
@Override public void doAction(Context context) {
System.out.println("系統開啟");
context.setState(this);
}
}
// 上下文
class Context {
private State state;
public void setState(State state) { this.state = state; }
}
// 使用
public class StateDemo {
public static void main(String[] args) {
Context context = new Context();
new StartState().doAction(context); // 輸出：系統開啟
}
}
21. 訪問者模式（Visitor）
- 意圖：在不修改對象結構的前提下，為對象添加新操作。
- 特點：
- 分離“數據結構”與“操作行為”，新操作只需新增訪問者；
- 適合數據結構穩定但操作多變的場景（如報表統計）；
- 修改結構需修改所有訪問者，靈活性低。
- 實現要點：
- 元素接口定義
accept(Visitor)方法； - 訪問者接口定義對每個元素的操作方法。
- 元素接口定義
// 元素接口
interface Element { void accept(Visitor v); }
// 具體元素（員工A）
class EmployeeA implements Element {
@Override public void accept(Visitor v) { v.visit(this); }
}
// 訪問者接口
interface Visitor { void visit(EmployeeA a); }
// 具體訪問者（計算工資）
class SalaryVisitor implements Visitor {
@Override public void visit(EmployeeA a) {
System.out.println("計算員工A工資");
}
}
// 使用
public class VisitorDemo {
public static void main(String[] args) {
Element e = new EmployeeA();
e.accept(new SalaryVisitor()); // 輸出：計算員工A工資
}
}
22. 中介者模式（Mediator）
- 意圖：用中介者封裝對象間的交互，減少直接依賴。
- 特點：
- 將網狀依賴轉為星狀依賴，降低復雜度；
- 集中管理交互邏輯，便于維護；
- 中介者可能成為“上帝類”，需避免邏輯過重。
- 實現要點：
- 中介者接口定義交互方法；
- 同事類持有中介者引用，通過中介者通信。
// 中介者接口
interface Mediator { void send(String msg, Colleague c); }
// 同事類
abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator m) { mediator = m; }
}
// 具體同事（用戶1）
class User1 extends Colleague {
public User1(Mediator m) { super(m); }
public void send(String msg) { mediator.send(msg, this); }
public void receive(String msg) { System.out.println("User1收到：" + msg); }
}
// 具體中介者（聊天室）
class ChatMediator implements Mediator {
private User1 u1;
private User2 u2;
@Override public void send(String msg, Colleague c) {
if (c == u1) u2.receive(msg);
else u1.receive(msg);
}
}
// 使用
public class MediatorDemo {
public static void main(String[] args) {
Mediator m = new ChatMediator();
User1 u1 = new User1(m);
User2 u2 = new User2(m);
u1.send("你好"); // User2收到：你好
}
}
23. 解釋器模式（Interpreter）
- 意圖：定義語言語法的解釋器，用于解析特定格式的語句。
- 特點：
- 適合簡單語法（如正則表達式、表達式計算）；
- 語法復雜時會導致類爆炸（如SQL解析）；
- 可擴展新語法規則。
- 實現要點：
- 抽象表達式定義解釋方法；
- 終結符表達式處理基本語法單元，非終結符表達式處理組合語法。
// 抽象表達式
interface Expression { boolean interpret(String context); }
// 終結符表達式（匹配單個字符）
class TerminalExpression implements Expression {
private String data;
public TerminalExpression(String data) { this.data = data; }
@Override public boolean interpret(String context) {
return context.contains(data);
}
}
// 非終結符表達式（或運算）
class OrExpression implements Expression {
private Expression e1, e2;
public OrExpression(Expression e1, Expression e2) {
this.e1 = e1;
this.e2 = e2;
}
@Override public boolean interpret(String context) {
return e1.interpret(context) || e2.interpret(context);
}
}
// 使用
public class InterpreterDemo {
public static void main(String[] args) {
Expression expr = new OrExpression(new TerminalExpression("a"), new TerminalExpression("b"));
System.out.println(expr.interpret("abc")); // true（含a）
}
}
總結
設計模式是解決特定問題的成熟方案，核心價值在于：
- 創建型：控制對象創建，降低耦合；
- 結構型：優化類/對象組合，實現復用；
- 行為型：規范對象交互，明確職責。
實際開發中需結合業務場景選擇，避免過度設計。
浙公網安備 33010602011771號