Java之美[從菜鳥到高手演變]之設計模式四

時間  2019-11-18
標籤 java 之美 菜鳥 高手 演變 設計 模式 欄目 Java 简体版
原文   原文鏈接

其實每一個設計模式都是很重要的一種思想，看上去很熟，實際上是由於咱們在學到的東西中都有涉及，儘管有時咱們並不知道，其實在Java自己的設計之中到處都有體現，像AWT、JDBC、集合類、IO管道或者是Web框架，裏面設計模式無處不在。由於咱們篇幅有限，很難講每個設計模式都講的很詳細，不過我會盡我所能，儘可能在有限的空間和篇幅內，把意思寫清楚了，更好讓你們明白。本章不出意外的話，應該是設計模式最後一講了，首先仍是上一下上篇開頭的那個圖：java

本章講講第三類和第四類。程序員

1九、備忘錄模式（Memento）web

主要目的是保存一個對象的某個狀態，以便在適當的時候恢復對象，我的以爲叫備份模式更形象些，通俗的講下：假設有原始類A，A中有各類屬性，A能夠決定須要備份的屬性，備忘錄類B是用來存儲A的一些內部狀態，類C呢，就是一個用來存儲備忘錄的，且只能存儲，不能修改等操做。作個圖來分析一下：正則表達式

Original類是原始類，裏面有須要保存的屬性value及建立一個備忘錄類，用來保存value值。Memento類是備忘錄類，Storage類是存儲備忘錄的類，持有Memento類的實例，該模式很好理解。直接看源碼：算法

[java] view plain copy print ?
  1. public class Original {  
  2.       
  3.     private String value;  
  4.       
  5.     public String getValue() {  
  6.         return value;  
  7.     }  
  8.   
  9.     public void setValue(String value) {  
  10.         this.value = value;  
  11.     }  
  12.   
  13.     public Original(String value) {  
  14.         this.value = value;  
  15.     }  
  16.   
  17.     public Memento createMemento(){  
  18.         return new Memento(value);  
  19.     }  
  20.       
  21.     public void restoreMemento(Memento memento){  
  22.         this.value = memento.getValue();  
  23.     }  
  24. }  
public class Original {
	
	private String value;
	
	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	public Original(String value) {
		this.value = value;
	}

	public Memento createMemento(){
		return new Memento(value);
	}
	
	public void restoreMemento(Memento memento){
		this.value = memento.getValue();
	}
}
[java] view plain copy print ?
  1. public class Memento {  
  2.       
  3.     private String value;  
  4.   
  5.     public Memento(String value) {  
  6.         this.value = value;  
  7.     }  
  8.   
  9.     public String getValue() {  
  10.         return value;  
  11.     }  
  12.   
  13.     public void setValue(String value) {  
  14.         this.value = value;  
  15.     }  
  16. }  
public class Memento {
	
	private String value;

	public Memento(String value) {
		this.value = value;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}
}
[java] view plain copy print ?
  1. public class Storage {  
  2.       
  3.     private Memento memento;  
  4.       
  5.     public Storage(Memento memento) {  
  6.         this.memento = memento;  
  7.     }  
  8.   
  9.     public Memento getMemento() {  
  10.         return memento;  
  11.     }  
  12.   
  13.     public void setMemento(Memento memento) {  
  14.         this.memento = memento;  
  15.     }  
  16. }  
public class Storage {
	
	private Memento memento;
	
	public Storage(Memento memento) {
		this.memento = memento;
	}

	public Memento getMemento() {
		return memento;
	}

	public void setMemento(Memento memento) {
		this.memento = memento;
	}
}

測試類：spring

[java] view plain copy print ?
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.           
  5.         // 建立原始類   
  6.         Original origi = new Original("egg");  
  7.   
  8.         // 建立備忘錄   
  9.         Storage storage = new Storage(origi.createMemento());  
  10.   
  11.         // 修改原始類的狀態   
  12.         System.out.println("初始化狀態爲：" + origi.getValue());  
  13.         origi.setValue("niu");  
  14.         System.out.println("修改後的狀態爲：" + origi.getValue());  
  15.   
  16.         // 回覆原始類的狀態   
  17.         origi.restoreMemento(storage.getMemento());  
  18.         System.out.println("恢復後的狀態爲：" + origi.getValue());  
  19.     }  
  20. }  
public class Test {

	public static void main(String[] args) {
		
		// 建立原始類
		Original origi = new Original("egg");

		// 建立備忘錄
		Storage storage = new Storage(origi.createMemento());

		// 修改原始類的狀態
		System.out.println("初始化狀態爲：" + origi.getValue());
		origi.setValue("niu");
		System.out.println("修改後的狀態爲：" + origi.getValue());

		// 回覆原始類的狀態
		origi.restoreMemento(storage.getMemento());
		System.out.println("恢復後的狀態爲：" + origi.getValue());
	}
}

輸出：設計模式

初始化狀態爲：egg
修改後的狀態爲：niu
恢復後的狀態爲：egg數據結構

簡單描述下：新建原始類時，value被初始化爲egg，後通過修改，將value的值置爲niu，最後倒數第二行進行恢復狀態，結果成功恢復了。其實我以爲這個模式叫「備份-恢復」模式最形象。框架

20、狀態模式（State）數據結構和算法

核心思想就是：當對象的狀態改變時，同時改變其行爲，很好理解！就拿QQ來講，有幾種狀態，在線、隱身、忙碌等，每一個狀態對應不一樣的操做，並且你的好友也能看到你的狀態，因此，狀態模式就兩點：一、能夠經過改變狀態來得到不一樣的行爲。二、你的好友能同時看到你的變化。看圖：


State類是個狀態類，Context類能夠實現切換，咱們來看看代碼：

[java] view plain copy print ?
  1. package com.xtfggef.dp.state;  
  2.   
  3. /** 
  4.  * 狀態類的核心類 
  5.  * 2012-12-1 
  6.  * @author erqing 
  7.  * 
  8.  */  
  9. public class State {  
  10.       
  11.     private String value;  
  12.       
  13.     public String getValue() {  
  14.         return value;  
  15.     }  
  16.   
  17.     public void setValue(String value) {  
  18.         this.value = value;  
  19.     }  
  20.   
  21.     public void method1(){  
  22.         System.out.println("execute the first opt!");  
  23.     }  
  24.       
  25.     public void method2(){  
  26.         System.out.println("execute the second opt!");  
  27.     }  
  28. }  
package com.xtfggef.dp.state;

/**
 * 狀態類的核心類
 * 2012-12-1
 * @author erqing
 *
 */
public class State {
	
	private String value;
	
	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	public void method1(){
		System.out.println("execute the first opt!");
	}
	
	public void method2(){
		System.out.println("execute the second opt!");
	}
}
[java] view plain copy print ?
  1. package com.xtfggef.dp.state;  
  2.   
  3. /** 
  4.  * 狀態模式的切換類   2012-12-1 
  5.  * @author erqing 
  6.  *  
  7.  */  
  8. public class Context {  
  9.   
  10.     private State state;  
  11.   
  12.     public Context(State state) {  
  13.         this.state = state;  
  14.     }  
  15.   
  16.     public State getState() {  
  17.         return state;  
  18.     }  
  19.   
  20.     public void setState(State state) {  
  21.         this.state = state;  
  22.     }  
  23.   
  24.     public void method() {  
  25.         if (state.getValue().equals("state1")) {  
  26.             state.method1();  
  27.         } else if (state.getValue().equals("state2")) {  
  28.             state.method2();  
  29.         }  
  30.     }  
  31. }  
package com.xtfggef.dp.state;

/**
 * 狀態模式的切換類   2012-12-1
 * @author erqing
 * 
 */
public class Context {

	private State state;

	public Context(State state) {
		this.state = state;
	}

	public State getState() {
		return state;
	}

	public void setState(State state) {
		this.state = state;
	}

	public void method() {
		if (state.getValue().equals("state1")) {
			state.method1();
		} else if (state.getValue().equals("state2")) {
			state.method2();
		}
	}
}

測試類：

[java] view plain copy print ?
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.           
  5.         State state = new State();  
  6.         Context context = new Context(state);  
  7.           
  8.         //設置第一種狀態   
  9.         state.setValue("state1");  
  10.         context.method();  
  11.           
  12.         //設置第二種狀態   
  13.         state.setValue("state2");  
  14.         context.method();  
  15.     }  
  16. }  
public class Test {

	public static void main(String[] args) {
		
		State state = new State();
		Context context = new Context(state);
		
		//設置第一種狀態
		state.setValue("state1");
		context.method();
		
		//設置第二種狀態
		state.setValue("state2");
		context.method();
	}
}

輸出：

execute the first opt!
execute the second opt!

根據這個特性，狀態模式在平常開發中用的挺多的，尤爲是作網站的時候，咱們有時但願根據對象的某一屬性，區別開他們的一些功能，好比說簡單的權限控制等。
2一、訪問者模式（Visitor）

訪問者模式把數據結構和做用於結構上的操做解耦合，使得操做集合可相對自由地演化。訪問者模式適用於數據結構相對穩定算法又易變化的系統。由於訪問者模式使得算法操做增長變得容易。若系統數據結構對象易於變化，常常有新的數據對象增長進來，則不適合使用訪問者模式。訪問者模式的優勢是增長操做很容易，由於增長操做意味着增長新的訪問者。訪問者模式將有關行爲集中到一個訪問者對象中，其改變不影響系統數據結構。其缺點就是增長新的數據結構很困難。—— From 百科

簡單來講，訪問者模式就是一種分離對象數據結構與行爲的方法，經過這種分離，可達到爲一個被訪問者動態添加新的操做而無需作其它的修改的效果。簡單關係圖：


來看看原碼：一個Visitor類，存放要訪問的對象，

[java] view plain copy print ?
  1. public interface Visitor {  
  2.     public void visit(Subject sub);  
  3. }  
public interface Visitor {
	public void visit(Subject sub);
}
[java] view plain copy print ?
  1. public class MyVisitor implements Visitor {  
  2.   
  3.     @Override  
  4.     public void visit(Subject sub) {  
  5.         System.out.println("visit the subject："+sub.getSubject());  
  6.     }  
  7. }  
public class MyVisitor implements Visitor {

	@Override
	public void visit(Subject sub) {
		System.out.println("visit the subject："+sub.getSubject());
	}
}

Subject類，accept方法，接受將要訪問它的對象，getSubject()獲取將要被訪問的屬性，

[java] view plain copy print ?
  1. public interface Subject {  
  2.     public void accept(Visitor visitor);  
  3.     public String getSubject();  
  4. }  
public interface Subject {
	public void accept(Visitor visitor);
	public String getSubject();
}
[java] view plain copy print ?
  1. public class MySubject implements Subject {  
  2.   
  3.     @Override  
  4.     public void accept(Visitor visitor) {  
  5.         visitor.visit(this);  
  6.     }  
  7.   
  8.     @Override  
  9.     public String getSubject() {  
  10.         return "love";  
  11.     }  
  12. }  
public class MySubject implements Subject {

	@Override
	public void accept(Visitor visitor) {
		visitor.visit(this);
	}

	@Override
	public String getSubject() {
		return "love";
	}
}

測試：

[java] view plain copy print ?
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.           
  5.         Visitor visitor = new MyVisitor();  
  6.         Subject sub = new MySubject();  
  7.         sub.accept(visitor);      
  8.     }  
  9. }  
public class Test {

	public static void main(String[] args) {
		
		Visitor visitor = new MyVisitor();
		Subject sub = new MySubject();
		sub.accept(visitor);	
	}
}

輸出：visit the subject：love

該模式適用場景：若是咱們想爲一個現有的類增長新功能，不得不考慮幾個事情：一、新功能會不會與現有功能出現兼容性問題？二、之後會不會再須要添加？三、若是類不容許修改代碼怎麼辦？面對這些問題，最好的解決方法就是使用訪問者模式，訪問者模式適用於數據結構相對穩定的系統，把數據結構和算法解耦，
2二、中介者模式（Mediator）

中介者模式也是用來下降類類之間的耦合的，由於若是類類之間有依賴關係的話，不利於功能的拓展和維護，由於只要修改一個對象，其它關聯的對象都得進行修改。若是使用中介者模式，只需關心和Mediator類的關係，具體類類之間的關係及調度交給Mediator就行，這有點像spring容器的做用。先看看圖：


User類統一接口，User1和User2分別是不一樣的對象，兩者之間有關聯，若是不採用中介者模式，則須要兩者相互持有引用，這樣兩者的耦合度很高，爲了解耦，引入了Mediator類，提供統一接口，MyMediator爲其實現類，裏面持有User1和User2的實例，用來實現對User1和User2的控制。這樣User1和User2兩個對象相互獨立，他們只須要保持好和Mediator之間的關係就行，剩下的全由MyMediator類來維護！基本實現：

[java] view plain copy print ?
  1. public interface Mediator {  
  2.     public void createMediator();  
  3.     public void workAll();  
  4. }  
public interface Mediator {
	public void createMediator();
	public void workAll();
}
[java] view plain copy print ?
  1. public class MyMediator implements Mediator {  
  2.   
  3.     private User user1;  
  4.     private User user2;  
  5.       
  6.     public User getUser1() {  
  7.         return user1;  
  8.     }  
  9.   
  10.     public User getUser2() {  
  11.         return user2;  
  12.     }  
  13.   
  14.     @Override  
  15.     public void createMediator() {  
  16.         user1 = new User1(this);  
  17.         user2 = new User2(this);  
  18.     }  
  19.   
  20.     @Override  
  21.     public void workAll() {  
  22.         user1.work();  
  23.         user2.work();  
  24.     }  
  25. }  
public class MyMediator implements Mediator {

	private User user1;
	private User user2;
	
	public User getUser1() {
		return user1;
	}

	public User getUser2() {
		return user2;
	}

	@Override
	public void createMediator() {
		user1 = new User1(this);
		user2 = new User2(this);
	}

	@Override
	public void workAll() {
		user1.work();
		user2.work();
	}
}
[java] view plain copy print ?
  1. public abstract class User {  
  2.       
  3.     private Mediator mediator;  
  4.       
  5.     public Mediator getMediator(){  
  6.         return mediator;  
  7.     }  
  8.       
  9.     public User(Mediator mediator) {  
  10.         this.mediator = mediator;  
  11.     }  
  12.   
  13.     public abstract void work();  
  14. }  
public abstract class User {
	
	private Mediator mediator;
	
	public Mediator getMediator(){
		return mediator;
	}
	
	public User(Mediator mediator) {
		this.mediator = mediator;
	}

	public abstract void work();
}
[java] view plain copy print ?
  1. public class User1 extends User {  
  2.   
  3.     public User1(Mediator mediator){  
  4.         super(mediator);  
  5.     }  
  6.       
  7.     @Override  
  8.     public void work() {  
  9.         System.out.println("user1 exe!");  
  10.     }  
  11. }  
public class User1 extends User {

	public User1(Mediator mediator){
		super(mediator);
	}
	
	@Override
	public void work() {
		System.out.println("user1 exe!");
	}
}
[java] view plain copy print ?
  1. public class User2 extends User {  
  2.   
  3.     public User2(Mediator mediator){  
  4.         super(mediator);  
  5.     }  
  6.       
  7.     @Override  
  8.     public void work() {  
  9.         System.out.println("user2 exe!");  
  10.     }  
  11. }  
public class User2 extends User {

	public User2(Mediator mediator){
		super(mediator);
	}
	
	@Override
	public void work() {
		System.out.println("user2 exe!");
	}
}

測試類：

[java] view plain copy print ?
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.         Mediator mediator = new MyMediator();  
  5.         mediator.createMediator();  
  6.         mediator.workAll();  
  7.     }  
  8. }  
public class Test {

	public static void main(String[] args) {
		Mediator mediator = new MyMediator();
		mediator.createMediator();
		mediator.workAll();
	}
}

輸出：

user1 exe!
user2 exe!
2三、解釋器模式（Interpreter）
解釋器模式是咱們暫時的最後一講，通常主要應用在OOP開發中的編譯器的開發中，因此適用面比較窄。


Context類是一個上下文環境類，Plus和Minus分別是用來計算的實現，代碼以下：

[java] view plain copy print ?
  1. public interface Expression {  
  2.     public int interpret(Context context);  
  3. }  
public interface Expression {
	public int interpret(Context context);
}
[java] view plain copy print ?
  1. public class Plus implements Expression {  
  2.   
  3.     @Override  
  4.     public int interpret(Context context) {  
  5.         return context.getNum1()+context.getNum2();  
  6.     }  
  7. }  
public class Plus implements Expression {

	@Override
	public int interpret(Context context) {
		return context.getNum1()+context.getNum2();
	}
}
[java] view plain copy print ?
  1. public class Minus implements Expression {  
  2.   
  3.     @Override  
  4.     public int interpret(Context context) {  
  5.         return context.getNum1()-context.getNum2();  
  6.     }  
  7. }  
public class Minus implements Expression {

	@Override
	public int interpret(Context context) {
		return context.getNum1()-context.getNum2();
	}
}
[java] view plain copy print ?
  1. public class Context {  
  2.       
  3.     private int num1;  
  4.     private int num2;  
  5.       
  6.     public Context(int num1, int num2) {  
  7.         this.num1 = num1;  
  8.         this.num2 = num2;  
  9.     }  
  10.       
  11.     public int getNum1() {  
  12.         return num1;  
  13.     }  
  14.     public void setNum1(int num1) {  
  15.         this.num1 = num1;  
  16.     }  
  17.     public int getNum2() {  
  18.         return num2;  
  19.     }  
  20.     public void setNum2(int num2) {  
  21.         this.num2 = num2;  
  22.     }  
  23.       
  24.       
  25. }  
public class Context {
	
	private int num1;
	private int num2;
	
	public Context(int num1, int num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	
	public int getNum1() {
		return num1;
	}
	public void setNum1(int num1) {
		this.num1 = num1;
	}
	public int getNum2() {
		return num2;
	}
	public void setNum2(int num2) {
		this.num2 = num2;
	}
	
	
}
[java] view plain copy print ?
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         // 計算9+2-8的值   
  6.         int result = new Minus().interpret((new Context(new Plus()  
  7.                 .interpret(new Context(9, 2)), 8)));  
  8.         System.out.println(result);  
  9.     }  
  10. }  
public class Test {

	public static void main(String[] args) {

		// 計算9+2-8的值
		int result = new Minus().interpret((new Context(new Plus()
				.interpret(new Context(9, 2)), 8)));
		System.out.println(result);
	}
}

最後輸出正確的結果：3。

基本就這樣，解釋器模式用來作各類各樣的解釋器，如正則表達式等的解釋器等等！

設計模式基本就這麼大概講完了，整體感受有點簡略，的確，這麼點兒篇幅，不足以對整個23種設計模式作全面的闡述，此處讀者可將它做爲一個理論基礎去學習，經過這四篇博文，先基本有個概念，雖然我講的有些簡單，但基本都能說明問題及他們的特色，若是對哪個感興趣，能夠繼續深刻研究！同時我也會不斷更新，儘可能補全遺漏、修正不足，歡迎廣大讀者及時提出好的建議，咱們一塊兒學習！項目中涉及到的代碼，已經放到了個人資源裏：http://download.csdn.net/detail/zhangerqing/4835830（由於我不喜歡坐享其成，因此沒有免積分，只設置了5個，若是有人實在沒積分又急要，那麼聯繫我吧，我給你發過去）。

在閱讀的過程當中，有任何問題，請聯繫：egg。

郵箱：xtfggef@gmail.com   微博：http://weibo.com/xtfggef

更多 2
頂
11
踩
0
相關主題推薦
設計模式 java 正則表達式 web框架 編譯器
相關博文推薦
java的obcik轉航母
安裝JBPM6運行環境（JBPM6學習之...
要點Java3 編譯運行Hello Wo...
url傳中文亂碼
java(22) - 異常詳解
建立第一個JBPM6項目而且運行自帶的h...
黑馬程序員----IO流
利用Java計算String的MD5
查看評論
5樓 zhuanyeying 2013-10-26 15:19發表 [回覆] [引用] [舉報]
你好，想問下。這個中介者模式和代理模式應該是同樣的模式？只不過您以前的代理模式的例子只持有了一個對象的引用，而這個中介者模式持有了兩個對象的應用。
4樓 java_ganbin 2013-06-21 16:38發表 [回覆] [引用] [舉報]
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程