面向實現 · 《Java 編程思想》第五版

## 面向實現代理模式和橋接模式都提供了在代碼中使用的代理類;完成工作的真正類隱藏在這個代理類的后面。當您在代理中調用一個方法時，它只是反過來調用實現類中的方法。這兩種模式非常相似，所以代理模式只是橋接模式的一種特殊情況。人們傾向于將兩者合并,稱為代理模式，但是術語“代理”有一個長期的和專門的含義，這可能解釋了這兩種模式不同的原因。基本思想很簡單:從基類派生代理，同時派生一個或多個提供實現的類:創建代理對象時，給它一個可以調用實際工作類的方法的實現。在結構上，代理模式和橋接模式的區別很簡單:代理模式只有一個實現，而橋接模式有多個實現。在設計模式中被認為是不同的:代理模式用于控制對其實現的訪問，而橋接模式允許您動態更改實現。但是，如果您擴展了“控制對實現的訪問”的概念，那么這兩者就可以完美地結合在一起 **代理模式** 如果我們按照上面的關系圖實現，它看起來是這樣的: ```Java // patterns/ProxyDemo.java // Simple demonstration of the Proxy pattern interface ProxyBase { void f(); void g(); void h(); } class Proxy implements ProxyBase { private ProxyBase implementation; Proxy() { implementation = new Implementation(); } // Pass method calls to the implementation: @Override public void f() { implementation.f(); } @Override public void g() { implementation.g(); } @Override public void h() { implementation.h(); } } class Implementation implements ProxyBase { public void f() { System.out.println("Implementation.f()"); } public void g() { System.out.println("Implementation.g()"); } public void h() { System.out.println("Implementation.h()"); } } public class ProxyDemo { public static void main(String[] args) { Proxy p = new Proxy(); p.f(); p.g(); p.h(); } } /* Output: Implementation.f() Implementation.g() Implementation.h() */ ``` 具體實現不需要與代理對象具有相同的接口;只要代理對象以某種方式“代表具體實現的方法調用，那么基本思想就算實現了。然而，擁有一個公共接口是很方便的，因此具體實現必須實現代理對象調用的所有方法。 **狀態模式** 狀態模式向代理對象添加了更多的實現，以及在代理對象的生命周期內從一個實現切換到另一種實現的方法: ```Java // patterns/StateDemo.java // Simple demonstration of the State pattern interface StateBase { void f(); void g(); void h(); void changeImp(StateBase newImp); } class State implements StateBase { private StateBase implementation; State(StateBase imp) { implementation = imp; } @Override public void changeImp(StateBase newImp) { implementation = newImp; }// Pass method calls to the implementation: @Override public void f() { implementation.f(); } @Override public void g() { implementation.g(); } @Override public void h() { implementation.h(); } } class Implementation1 implements StateBase { @Override public void f() { System.out.println("Implementation1.f()"); } @Override public void g() { System.out.println("Implementation1.g()"); } @Override public void h() { System.out.println("Implementation1.h()"); } @Override public void changeImp(StateBase newImp) { } } class Implementation2 implements StateBase { @Override public void f() { System.out.println("Implementation2.f()"); } @Override public void g() { System.out.println("Implementation2.g()"); } @Override public void h() { System.out.println("Implementation2.h()"); } @Override public void changeImp(StateBase newImp) { } } public class StateDemo { static void test(StateBase b) { b.f(); b.g(); b.h(); } public static void main(String[] args) { StateBase b = new State(new Implementation1()); test(b); b.changeImp(new Implementation2()); test(b); } } /* Output: Implementation1.f() Implementation1.g() Implementation1.h() Implementation2.f() Implementation2.g() Implementation2.h() */ ``` 在main()中，首先使用第一個實現，然后改變成第二個實現。代理模式和狀態模式的區別在于它們解決的問題。設計模式中描述的代理模式的常見用途如下: 1. 遠程代理。它在不同的地址空間中代理對象。遠程方法調用(RMI)編譯器rmic會自動為您創建一個遠程代理。 2. 虛擬代理。這提供了“懶加載”來根據需要創建“昂貴”的對象。 3. 保護代理。當您希望對代理對象有權限訪問控制時使用。 4. 智能引用。要在被代理的對象被訪問時添加其他操作。例如，跟蹤特定對象的引用數量，來實現寫時復制用法，和防止對象別名。一個更簡單的例子是跟蹤特定方法的調用數量。您可以將Java引用視為一種保護代理，因為它控制在堆上實例對象的訪問(例如，確保不使用空引用)。在設計模式中，代理模式和橋接模式并不是相互關聯的，因為它們被賦予(我認為是任意的)不同的結構。橋接模式,特別是使用一個單獨的實現，但這似乎對我來說是不必要的,除非你確定該實現是你無法控制的(當然有可能，但是如果您編寫所有代碼，那么沒有理由不從單基類的優雅中受益)。此外，只要代理對象控制對其“前置”對象的訪問，代模式理就不需要為其實現使用相同的基類。不管具體情況如何，在代理模式和橋接模式中，代理對象都將方法調用傳遞給具體實現對象。 **狀態機** 橋接模式允許程序員更改實現，狀態機利用一個結構來自動地將實現更改到下一個。當前實現表示系統所處的狀態，系統在不同狀態下的行為不同(因為它使用橋接模式)。基本上，這是一個利用對象的“狀態機”。將系統從一種狀態移動到另一種狀態的代碼通常是模板方法模式，如下例所示: ```Java // patterns/state/StateMachineDemo.java // The StateMachine pattern and Template method // {java patterns.state.StateMachineDemo} package patterns.state; import onjava.Nap; interface State { void run(); } abstract class StateMachine { protected State currentState; Nap(0.5); System.out.println("Washing"); new protected abstract boolean changeState(); // Template method: protected final void runAll() { while (changeState()) // Customizable currentState.run(); } } // A different subclass for each state: class Wash implements State { @Override public void run() { } } class Spin implements State { @Override public void run() { System.out.println("Spinning"); new Nap(0.5); } } class Rinse implements State { @Override public void run() { System.out.println("Rinsing"); new Nap(0.5); } } class Washer extends StateMachine { private int i = 0; // The state table: private State[] states = {new Wash(), new Spin(), new Rinse(), new Spin(),}; Washer() { runAll(); } @Override public boolean changeState() { if (i < states.length) { // Change the state by setting the // surrogate reference to a new object: currentState = states[i++]; return true; } else return false; } } public class StateMachineDemo { public static void main(String[] args) { new Washer(); } } /* Output: Washing Spinning Rinsing Spinning */ ``` 在這里，控制狀態的類(本例中是狀態機)負責決定下一個狀態。然而，狀態對象本身也可以決定下一步移動到什么狀態，通常基于系統的某種輸入。這是更靈活的解決方案。