一、設(shè)計模式的分類
1.1 三大類
創(chuàng)建型模式 ，共五種：單例模式、抽象工廠模式、工廠方法模式、建造者模式、原型模式。結(jié)構(gòu)型模式 ，共七種：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。行為型模式 ，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責(zé)任鏈模式、命令模式、備忘錄模式、狀態(tài)模式、訪問者模式、中介者模式、解釋器模式。
1.2 簡述
1.2.1 創(chuàng)建型
Singleton，單例模式：保證一個類只有一個實(shí)例，并提供一個訪問它的全局訪問點(diǎn)
1.2.2 行為型
Iterator，迭代器模式：提供一個方法順序訪問一個聚合對象的各個元素，而又不需要暴露該對象的內(nèi)部表示。
1.2.3 結(jié)構(gòu)型
Composite，組合模式：將對象組合成樹形結(jié)構(gòu)以表示部分整體的關(guān)系，Composite使得用戶對單個對象和組合對象的使用具有一致性。
1.3 設(shè)計模式的六大原則
1.3.1 開閉原則（Open Close Principle）
開閉原則就是說對擴(kuò)展開放，對修改關(guān)閉。 在程序需要進(jìn)行拓展的時候，不能去修改原有的代碼。 程序得有強(qiáng)擴(kuò)展性，易于維護(hù)和升級。 所以需要使用接口和抽象類。 1.3.2 里氏代換原則（Liskov Substitution Principle）
面向?qū)ο笤O(shè)計的基本原則之一； 任何基類可以出現(xiàn)的地方，子類一定可以出現(xiàn)； LSP 是繼承復(fù)用的基石，只有當(dāng)衍生類可以替換掉基類，軟件單位的功能不受到影響時，基類才能真正被復(fù)用，而衍生類也能夠在基類的基礎(chǔ)上增加新的行為； LSP 是對“開-閉”原則的補(bǔ)充。實(shí)現(xiàn)“開-閉”原則的關(guān)鍵步驟就是抽象化。而基類與子類的繼承關(guān)系就是抽象化的具體實(shí)現(xiàn)，所以里氏代換原則是對實(shí)現(xiàn)抽象化的具體步驟的規(guī)范。 1.3.3 依賴倒轉(zhuǎn)原則（Dependence Inversion Principle）
這個是開閉原則的基礎(chǔ)，具體內(nèi)容：真對接口編程，依賴于抽象而不依賴于具體。
1.3.4 接口隔離原則（Interface Segregation Principle）
使用多個隔離的接口，比使用單個接口要好； 降低類之間的耦合度 1.3.5 迪米特法則（最少知道原則）（Demeter Principle）
一個實(shí)體應(yīng)當(dāng)盡量少的與其他實(shí)體之間發(fā)生相互作用，使得系統(tǒng)功能模塊相對獨(dú)立。
1.3.6 合成復(fù)用原則（Composite Reuse Principle）
原則是盡量使用合成/聚合的方式，而不是使用繼承。
二、23 種設(shè)計模式的詳解
2.1 工廠方法模式（Factory Method）
2.1.1 普通工廠模式
就是建立一個工廠類，對實(shí)現(xiàn)了同一接口的一些類進(jìn)行實(shí)例的創(chuàng)建。
創(chuàng)建思路：
一個接口 實(shí)現(xiàn)接口的一些類 一個工廠類：用來創(chuàng)建類實(shí)例 例子
比如，我們想讓一張紙打印出符合特定模板的內(nèi)容，
創(chuàng)建過程 ：
一個接口——初始模板 實(shí)現(xiàn)接口的一些類——改進(jìn)模板 一個工廠類：用來創(chuàng)建類實(shí)例——打印機(jī) 比如，一臺打印機(jī)是用來打印的工廠，我們設(shè)定一個初始模板，然后根據(jù)這個模板發(fā)展出改進(jìn)模板。 public interface Template { void Print ( ) ;
}
public class HelloTemplate implements Template { @Override public void Print ( ) { System . out
. println ( "this is HelloTemplate!" ) ; }
}
public class WorldTemplate implements Template { @Override public void Print ( ) { System . out
. println ( "this is WorldTemplate!" ) ; }
}
public class Printer { public Template produce ( String type
) { if ( "Hello" . equals ( type
) ) { return new HelloTemplate ( ) ; } else if ( "World" . equals ( type
) ) { return new WorldTemplate ( ) ; } else { System . out
. println ( "請輸入正確的類型!" ) ; return null ; } }
}
public class FactoryTest { public static void main ( String [ ] args
) { Printer printer
= new Printer ( ) ; Template tmp1
= printer
. produce ( "Hello" ) ; Template tmp2
= printer
. produce ( "World" ) ; tmp1. Print( ) ; tmp2. Print( ) ; }
}
2.1.2 多個工廠方法模式
原來通過傳入字符串的方式來決定返回哪個類的方法，是不合理的，因?yàn)槿绻麄魅氲淖址姓`，不能正確創(chuàng)建對象，這樣會不利于擴(kuò)展新類。
public class Printer { public Template produceHello ( ) { return new HelloTemplate ( ) ; } public Template produceWorld ( ) { return new WorldTemplate ( ) ; }
}
修改后的調(diào)用方式如下
public class FactoryTest { public static void main ( String [ ] args
) { Printer printer
= new Printer ( ) ; Template tmp1
= printer
. produceHello ( ) ; Template tmp2
= printer
. produceWorld ( ) ; tmp1. Print( ) ; tmp2. Print( ) ; }
}
2.1.3 靜態(tài)工廠方法模式
將多個工廠方法模式里的方法置為靜態(tài)的，就不需要創(chuàng)建實(shí)例，直接調(diào)用即可。
public class Printer { public static Template produceHello ( ) { return new HelloTemplate ( ) ; } public static Template produceWorld ( ) { return new WorldTemplate ( ) ; }
}
直接調(diào)用
public class FactoryTest { public static void main ( String [ ] args
) { Template template1
= Printer . produceHello ( ) ; Template template2
= Printer . produceWorld ( ) ; template1. Print( ) ; template2. Print( ) ; }
}
2.2 抽象工廠模式（Abstract Factory）
工廠方法模式有一個問題就是，類的創(chuàng)建依賴工廠類，也就是說，如果想要拓展程序，必須對工廠類進(jìn)行修改，這違背了閉包原則。
創(chuàng)建思路：
一個接口 實(shí)現(xiàn)接口的n個類 一個工廠接口 實(shí)現(xiàn)工廠接口的n個工廠類：其中分別對應(yīng)調(diào)用了實(shí)現(xiàn)接口的n個類 例子
比如，我們想讓制造多個種類的車輛。
創(chuàng)建過程 ：
一個接口：車輛模板 實(shí)現(xiàn)接口的n個類：不同種類 一個工廠接口：車輛制造廠 實(shí)現(xiàn)工廠接口的n個工廠類：其中分別對應(yīng)調(diào)用了實(shí)現(xiàn)接口的n個類：不同種類車輛的制造廠 public interface Car { public void run ( ) ;
}
public class Pickup implements Car { @Override public void run ( ) { System . out
. println ( "Pickup run." ) ; }
}
public class Roadster implements Car { @Override public void run ( ) { System . out
. println ( "Roadster run." ) ; }
}
public interface Factory { public Car make ( ) ;
}
public class PickupFactory implements Factory { @Override public Car make ( ) { System . out
. println ( "Make a Pickup." ) ; return new Pickup ( ) ; }
}
public class RoadsterFactory implements Factory { @Override public Car make ( ) { System . out
. println ( "Make a Roadster." ) ; return new Roadster ( ) ; }
}
public class FactoryTest { public static void main ( String [ ] args
) { Factory pickupFactory
= new PickupFactory ( ) ; Car pickup
= pickupFactory
. make ( ) ; pickup
. run ( ) ; Factory roadsterFactory
= new RoadsterFactory ( ) ; Car roadster
= roadsterFactory
. make ( ) ; roadster
. run ( ) ; }
}
2.3 單例模式（Singleton）
在 Java 應(yīng)用中，單例對象能保證在一個 JVM中，該對象只有一個實(shí)例存在。
1、某些類創(chuàng)建比較頻繁，對于一些大型的對象，這是一筆很大的系統(tǒng)開銷。
創(chuàng)建思路
私有構(gòu)造方法，防止被實(shí)例化 使用一個內(nèi)部類來維護(hù)單例——private static 獲取實(shí)例的方法——返回instance 保證對象在序列化前后保持一致的方法——返回獲取實(shí)例的方法 public class Singleton { private Singleton ( ) { } private static class SingletonFactory { private static Singleton instance
= new Singleton ( ) ; } public static Singleton getInstance ( ) { return SingletonFactory . instance
; } public Object readResolve ( ) { return getInstance ( ) ; }
}
為何這個創(chuàng)建方法是線程安全的？
單例模式使用內(nèi)部類來維護(hù)單例的實(shí)現(xiàn)，JVM 內(nèi)部的機(jī)制能夠保證當(dāng)一個類 被加載的時候，這個類的加載過程是線程互斥的。 這樣當(dāng)我們第一次調(diào)用 getInstance 的時候，JVM 能夠幫我們保證instance 只被創(chuàng)建一次，并且會保證把賦值給 instance 的內(nèi)存初始化完畢。 同時該方法也只會在第一次調(diào)用的時候使用互斥機(jī)制，這樣就解決了低性能問題。 2.4 建造者模式（Builder）
建造者模式將各種產(chǎn)品集中起來進(jìn)行管理，用來創(chuàng)建復(fù)合對象
不通過工廠來造車，而是通過一個類中的多個流水線（方法），批量造不同種類的車
創(chuàng)建思路
一個接口：車輛模板 實(shí)現(xiàn)接口的n個類：不同種類 批量生產(chǎn)各種車的Builder類 public class Builder { private List < Car > list
= new ArrayList < Car > ( ) ; public void producePickup ( int count
) { for ( int i
= 0 ; i
< count
; i
++ ) { list
. add ( new Pickup ( ) ) ; } } public void produceRoadster ( int count
) { for ( int i
= 0 ; i
< count
; i
++ ) { list
. add ( new Roadster ( ) ) ; } }
}
public class BuilderTest { public static void main ( String [ ] args
) { Builder builder
= new Builder ( ) ; builder
. producePickup ( 10 ) ; builder
. produceRoadster ( 5 ) ; }
}
2.5 原型模式（Prototype）
該模式的思想就是將一個對象作為原型，對其進(jìn)行復(fù)制、克隆，產(chǎn)生一個和原對象類似的新對象。
創(chuàng)建思路
創(chuàng)建一個類 該類實(shí)現(xiàn)Cloneable接口 創(chuàng)建clone()方法，返回Object類，拋出CloneNotSupportedException 異常 在方法中Prototype proto = (Prototype) super.clone(); 并return proto; public class Prototype implements Cloneable { public Object clone ( ) throws CloneNotSupportedException { Prototype proto
= ( Prototype ) super . clone ( ) ; return proto
; }
}
淺復(fù)制 （不徹底）：將一個對象復(fù)制后，基本數(shù)據(jù)類型的變量都會重新創(chuàng)建，而引用類型，指向的還是原對象所指向的。
深復(fù)制 （完全徹底）：將一個對象復(fù)制后，不論是基本數(shù)據(jù)類型還有引用類型，都是重新創(chuàng)建的。
public class Prototype implements Cloneable , Serializable { private static final long serialVersionUID
= 1L ; private String string
; private SerializableObject obj
; public Object clone ( ) throws CloneNotSupportedException { Prototype proto
= ( Prototype ) super . clone ( ) ; return proto
; } public Object deepClone ( ) throws IOException , ClassNotFoundException { ByteArrayOutputStream bos
= new ByteArrayOutputStream ( ) ; ObjectOutputStream oos
= new ObjectOutputStream ( bos
) ; oos
. writeObject ( this ) ; ByteArrayInputStream bis
= new ByteArrayInputStream ( bos
. toByteArray ( ) ) ; ObjectInputStream ois
= new ObjectInputStream ( bis
) ; return ois
. readObject ( ) ; } public String getString ( ) { return string
; } public void setString ( String string
) { this . string
= string
; } public SerializableObject getObj ( ) { return obj
; } public void setObj ( SerializableObject obj
) { this . obj
= obj
; } }
class SerializableObject implements Serializable { private static final long serialVersionUID
= 1L ;
}
2.6 適配器模式（Adapter）
2.6.1 類的適配器模式
核心思想：
創(chuàng)建一個 Source 類，擁有一個待適配的方法methodWaited； 目標(biāo)接口 Targetable； 創(chuàng)建 Adapter 類，通過繼承 Source，實(shí)現(xiàn) Targetable，將 Source 的方法methodWaited擴(kuò)展到 Adapter 里 場景：
核心思路：
現(xiàn)有插座：Socket類，擁有一個待適配的方法PowerSupply 目標(biāo)轉(zhuǎn)換器：目標(biāo)接口 Switch； 現(xiàn)有插頭：Device 類，通過繼承 Socket，實(shí)現(xiàn) Switch，將 Socket 的方法PowerSupply 擴(kuò)展到 Device 里
public class Socket { public void PowerSupply ( ) { System . out
. println ( "Charging......" ) ; }
}
public interface Switch { public void PowerSupply ( ) ; public void OpenUp ( ) ;
}
public class Device extends Socket implements Switch { @Override public void OpenUp ( ) { System . out
. println ( "Starting up......" ) ; }
}
public class Test { public static void main ( String [ ] args
) { Device device
= new Device ( ) ; device. OpenUp( ) ; device. PowerSupply( ) ; }
}
應(yīng)用場景：
2.6.2 對象的適配器模式
基本思路
核心思想：
創(chuàng)建一個 Source 類，擁有一個待適配的方法methodWaited； 目標(biāo)接口 Targetable； 創(chuàng)建 Adapter 類，通過實(shí)現(xiàn) Targetable，持有 Source 類的實(shí)例，將 Source 的方法methodWaited擴(kuò)展到 Adapter 里 場景：
核心思路：
現(xiàn)有插座：Socket類，擁有一個待適配的方法PowerSupply 目標(biāo)轉(zhuǎn)換器：目標(biāo)接口 Switch； 現(xiàn)有插頭：Device 類，通過繼承 Socket，持有 Switch 類的實(shí)例，將 Socket 的方法PowerSupply 擴(kuò)展到 Device 里
public class Device implements Switch { private Socket socket
; public Device ( Socket s
) { super ( ) ; socket
= s
; } @Override public void PowerSupply ( ) { socket. PowerSupply( ) ; } @Override public void OpenUp ( ) { System . out
. println ( "Starting up......" ) ; }
}
public class Test { public static void main ( String [ ] args
) { Socket socket
= new Socket ( ) ; Device device
= new Device ( socket
) ; device. OpenUp( ) ; device. PowerSupply( ) ; }
}
應(yīng)用場景：
2.6.3 接口的適配器模式
問題 ：有時我們寫的一個接口中有多個抽象方法，當(dāng)我們寫該接口的實(shí)現(xiàn)類時，必須實(shí)現(xiàn)該接口的所有方法，這明顯有時比較浪費(fèi)，因?yàn)椴⒉皇撬械姆椒ǘ际俏覀冃枰?#xff1b;接口的適配器模式思想 ：借助于一個抽象類，該抽象類實(shí)現(xiàn)了該接口，實(shí)現(xiàn)了所有的方法，而我們不和原始的接口打交道，只和該抽象類取得聯(lián)系。也即：寫一個類，繼承該抽象類，重寫我們需要的方法就行；核心思想：
創(chuàng)建一個接口，擁有數(shù)個方法； 創(chuàng)建一個抽象類，實(shí)現(xiàn)接口； 創(chuàng)建幾個類，繼承抽象類，并實(shí)現(xiàn)想實(shí)現(xiàn)的方法。 場景：
核心思路：
一棟大樓的所有房間：接口Building，有room1,room2等方法 房東的鑰匙們：抽象類KeyOrigin，內(nèi)有room1,room2等方法的實(shí)現(xiàn)； 個人持有的鑰匙：KeyPerson1類，繼承KeyOrigin類，然后實(shí)現(xiàn)自己的房間的方法。比如Person1有room2，room3。
public interface Building { public void room1 ( ) ; public void room2 ( ) ; public void room3 ( ) ; public void room4 ( ) ;
}
public abstract class KeyOrigin implements Building { public void room1 ( ) { } public void room2 ( ) { } public void room3 ( ) { } public void room4 ( ) { }
}
public class Person1 extends KeyOrigin { public void room2 ( ) { System . out
. println ( "I own room2" ) ; } public void room3 ( ) { System . out
. println ( "I own room3" ) ; }
}
public class Person2 extends KeyOrigin { public void room1 ( ) { System . out
. println ( "I own room1" ) ; }
}
public class Test { public static void main ( String [ ] args
) { KeyOrigin person1
= new Person1 ( ) ; person1
. room2 ( ) ; person1
. room3 ( ) ; KeyOrigin person2
= new Person2 ( ) ; person2
. room1 ( ) ; }
}
應(yīng)用場景：
2.7 裝飾模式（Decorator）
給一個對象增加一些新的功能，而且是動態(tài)的；
核心思想：
Sourceable 是接口，其中有method方法； Source 類是被裝飾類，實(shí)現(xiàn)Sourceable，實(shí)現(xiàn)method方法； Decorator 類是一個裝飾類，實(shí)現(xiàn)Sourceable，在它的構(gòu)造方法中傳入 Source 類實(shí)例，在實(shí)現(xiàn)method方法中調(diào)用 Source 類實(shí)例的method方法； 場景：
核心思路：
Maker 是接口，其中有makeHamburger方法； MeatPie 類是被裝飾類，實(shí)現(xiàn)Maker，實(shí)現(xiàn)makeHamburger方法； Bread 類是一個裝飾類，實(shí)現(xiàn)Maker，在它的構(gòu)造方法中傳入 Maker 類實(shí)例，在實(shí)現(xiàn)的makeHamburger方法中調(diào)用 MeatPie 類實(shí)例的makeHamburger方法；
public interface Maker { public void makeHamburger ( ) ;
}
public class MeatPie implements Maker { @Override public void makeHamburger ( ) { System . out
. println ( "Ketchup" ) ; System . out
. println ( "Vegetable" ) ; System . out
. println ( "Meat Pie" ) ; }
}
public class Bread implements Maker { private Maker maker
; public Bread ( Maker meatpie
) { super ( ) ; maker
= meatpie
; } @Override public void makeHamburger ( ) { System . out
. println ( "Bread" ) ; maker
. makeHamburger ( ) ; System . out
. println ( "Bread" ) ; }
}
public class Test { public static void main ( String [ ] args
) { Maker meatPie
= new MeatPie ( ) ; Bread bread
= new Bread ( meatPie
) ; bread
. makeHamburger ( ) ; }
}
2.8 代理模式（Proxy）
代理模式就是多一個代理類出來，替原對象進(jìn)行一些操作。
結(jié)構(gòu)：
Sourceable 是接口，其中有method方法； Source 類，實(shí)現(xiàn)Sourceable，實(shí)現(xiàn)method方法； Proxy 類是一個代理類，實(shí)現(xiàn)Sourceable，在它的構(gòu)造方法中new一個 Source 類實(shí)例，在實(shí)現(xiàn)method方法中調(diào)用 Source 類實(shí)例的method方法。 場景：
核心思路：
Maker 是接口，其中有makeHamburger方法； MeatPie 類，實(shí)現(xiàn)Maker，實(shí)現(xiàn)makeHamburger方法； BreadAdder 類是一個代理類，實(shí)現(xiàn)Maker，在它的構(gòu)造方法中new一個 MeatPie 類實(shí)例，在實(shí)現(xiàn)的makeHamburger方法中調(diào)用 MeatPie 類實(shí)例的makeHamburger方法；
public interface Maker { public void makeHamburger ( ) ;
}
public class MeatPie implements Maker { @Override public void makeHamburger ( ) { System . out
. println ( "Ketchup" ) ; System . out
. println ( "Vegetable" ) ; System . out
. println ( "Meat Pie" ) ; }
}
public class BreadAdder implements Maker { private Maker maker
; public BreadAdder ( ) { super ( ) ; maker
= new MeatPie ( ) ; } @Override public void makeHamburger ( ) { before ( ) ; maker
. makeHamburger ( ) ; after ( ) ; } public void before ( ) { System . out
. println ( "Bread" ) ; } public void after ( ) { System . out
. println ( "Bread" ) ; }
}
public class Test { public static void main ( String [ ] args
) { BreadAdder bread
= new BreadAdder ( ) ; bread
. makeHamburger ( ) ; }
}
2.9 外觀模式（Facade）
外觀模式就是將類之家的依賴關(guān)系放在一個Facade 類中，降低了類類之間的耦合度，該模式中沒有涉及到接口。
該方法比較直觀，下面是抽象開啟電腦的代碼，我們直接看代碼：
public class CPU
{ public void startup ( ) { System . out
. println ( "cpu startup!" ) ; } public void shutdown ( ) { System . out
. println ( "cpu shutdown!" ) ; }
}
public class Disk { public void startup ( ) { System . out
. println ( "disk startup!" ) ; } public void shutdown ( ) { System . out
. println ( "disk shutdown!" ) ; }
}
public class Memory { public void startup ( ) { System . out
. println ( "memory startup!" ) ; } public void shutdown ( ) { System . out
. println ( "memory shutdown!" ) ; }
}
public class Computer { private CPU cpu
; private Memory memory
; private Disk disk
; public Computer ( ) { cpu
= new CPU ( ) ; memory
= new Memory ( ) ; disk
= new Disk ( ) ; } public void startup ( ) { System . out
. println ( "start the computer!" ) ; cpu
. startup ( ) ; memory
. startup ( ) ; disk
. startup ( ) ; System . out
. println ( "start computer finished!" ) ; } public void shutdown ( ) { System . out
. println ( "begin to close the computer!" ) ; cpu
. shutdown ( ) ; memory
. shutdown ( ) ; disk
. shutdown ( ) ; System . out
. println ( "computer closed!" ) ; }
}
public class User { public static void main ( String [ ] args
) { Computer computer
= new Computer ( ) ; computer
. startup ( ) ; computer
. shutdown ( ) ; }
}
2.10 橋接模式（Bridge）
橋接模式就是把事物和其具體實(shí)現(xiàn)分開，使他們可以各自獨(dú)立的變化。
橋接的用意 是：將抽象化與實(shí)現(xiàn)化解耦，使得二者可以獨(dú)立變化
e.g. JDBC 橋 DriverManager：JDBC 進(jìn)行連接數(shù)據(jù)庫的時候，在各個數(shù)據(jù)庫之間進(jìn)行切換，基本不需要動太多的代碼，甚至絲毫不用動，原因就是JDBC 提供統(tǒng)一接口，每個數(shù)據(jù)庫提供各自的實(shí)現(xiàn)，用一個叫做數(shù)據(jù)庫驅(qū)動的程序來橋接就行了。
結(jié)構(gòu)：
一個接口：Sourceable 接口的n個實(shí)現(xiàn)類：SourceSub1、SourceSub2 … 定義一個橋(abstract)，持有 Sourceable 的一個實(shí)例 繼承橋的類 場景：
核心思路：
一個接口：DatabaseTemplate 接口的n個實(shí)現(xiàn)類：Database1、Database2 … 定義一個橋AbstractManager，持有 DatabaseTemplate 的一個實(shí)例 繼承橋的類DriverManager
public interface DatabaseTemplate { public void build ( ) ;
}
public class MySQL implements DatabaseTemplate { @Override public void build ( ) { System . out
. println ( "Build MySQL" ) ; }
}
public class PostgreSQL implements DatabaseTemplate { @Override public void build ( ) { System . out
. println ( "Build PostgreSQL" ) ; }
}
public abstract class AbstractManager { private DatabaseTemplate template
; public void setDatabase ( DatabaseTemplate databaseTemplate
) { template
= databaseTemplate
; } public DatabaseTemplate getDatabase ( ) { return template
; } public void build ( ) { template
. build ( ) ; }
}
public class DriverManager extends AbstractManager { public void build ( ) { getDatabase ( ) . build ( ) ; }
}
public class Test { public static void main ( String [ ] args
) { AbstractManager driverManager
= new DriverManager ( ) ; MySQL mySQL
= new MySQL ( ) ; driverManager
. setDatabase ( mySQL
) ; driverManager
. build ( ) ; PostgreSQL postgreSQL
= new PostgreSQL ( ) ; driverManager
. setDatabase ( postgreSQL
) ; driverManager
. build ( ) ; }
}
2.11 組合模式（Composite）
有時又叫部分-整體模式 在處理類似樹形結(jié)構(gòu)的問題時比較方便 public class TreeNode { private String name
; private TreeNode parent
; private Vector < TreeNode > children
= new Vector < TreeNode > ( ) ; public TreeNode ( String name
) { this . name
= name
; } public String getName ( ) { return name
; } public void setName ( String name
) { this . name
= name
; } public TreeNode getParent ( ) { return parent
; } public void setParent ( TreeNode parent
) { this . parent
= parent
; } public void add ( TreeNode node
) { children
. add ( node
) ; } public void remove ( TreeNode node
) { children
. remove ( node
) ; } public Enumeration < TreeNode > getChildren ( ) { return children
. elements ( ) ; }
}
public class Tree { TreeNode root
= null ; public Tree ( String name
) { root
= new TreeNode ( name
) ; } public static void main ( String [ ] args
) { Tree tree
= new Tree ( "A branch" ) ; TreeNode nodeB
= new TreeNode ( "B branch" ) ; TreeNode nodeC
= new TreeNode ( "C branch" ) ; nodeB
. add ( nodeC
) ; tree
. root
. add ( nodeB
) ; System . out
. println ( "Grow the tree finished!" ) ; }
}
2.12 享元模式（Flyweight）
享元模式的主要目的是實(shí)現(xiàn)對象的共享，即共享池，當(dāng)系統(tǒng)中對象多的時候可以減少內(nèi)存的開銷，通常與工廠模式一起使用。
FlyWeightFactory 負(fù)責(zé)創(chuàng)建和管理享元單元，當(dāng)一個客戶端請求時，工廠需要檢查當(dāng)前對象池中是否有符合條件的對象，如果有，就返回已經(jīng)存在的對象，如果沒有，則創(chuàng)建一個新對象； FlyWeight 是超類。 e.g. Java 里面的JDBC 連接池
適用于作共享的一些個對象，他們有一些共有的屬性，url、driverClassName、username、password 及dbname，這些屬性對于每個連接來說都是一樣的，所以就適合用享元模式來處理 建一個工廠類，將上述類似屬性作為內(nèi)部數(shù)據(jù)，其它的作為外部數(shù)據(jù)，在方法調(diào)用時，當(dāng)做參數(shù)傳進(jìn)來，這樣就節(jié)省了空間，減少了實(shí)例的數(shù)量。 public class ConnectionPool { private Vector < Connection > pool
; private String url
= "jdbc:mysql://localhost:3306/test" ; private String username
= "root" ; private String password
= "root" ; private String driverClassName
= "com.mysql.jdbc.Driver" ; private int poolSize
= 100 ; private static ConnectionPool instance
= null ; Connection conn
= null ; private ConnectionPool ( ) { pool
= new Vector < Connection > ( poolSize
) ; for ( int i
= 0 ; i
< poolSize
; i
++ ) { try { Class . forName ( driverClassName
) ; conn
= DriverManager . getConnection ( url
, username
, password
) ; pool
. add ( conn
) ; } catch ( ClassNotFoundException e
) { e
. printStackTrace ( ) ; } catch ( SQLException e
) { e
. printStackTrace ( ) ; } } } public synchronized void release ( ) { pool
. add ( conn
) ; } public synchronized Connection getConnection ( ) { if ( pool
. size ( ) > 0 ) { Connection conn
= pool
. get ( 0 ) ; pool
. remove ( conn
) ; return conn
; } else { return null ; } }
}
2.13 策略模式（strategy）
模式結(jié)構(gòu)
定義一系列算法，并將每個算法封裝起來，使他們可以相互替換，且算法的變化不會影響到使用算法的客戶。 設(shè)計一個接口，為一系列實(shí)現(xiàn)類提供統(tǒng)一的方法，多個實(shí)現(xiàn)類實(shí)現(xiàn)該接口， 設(shè)計一個抽象類（可有可無，屬于輔助類），提供輔助函數(shù) 場景
設(shè)計思路
設(shè)計一個接口ICalculator，為一系列實(shí)現(xiàn)類提供統(tǒng)一的方法，多個實(shí)現(xiàn)類實(shí)現(xiàn)該接口 定義一系列類，Minus、Plus、Multiply、Division，其中均有calculate方法，在方法中實(shí)現(xiàn)不同的算法； 設(shè)計一個抽象類AbstractCalculator，提供輔助函數(shù)
public interface ICalculator { public int calculate ( String exp
) ;
}
public abstract class AbstractCalculator { public int [ ] split ( String exp
, String opt
) { String array
[ ] = exp
. split ( opt
) ; int arrayInt
[ ] = new int [ 2 ] ; arrayInt
[ 0 ] = Integer . parseInt ( array
[ 0 ] ) ; arrayInt
[ 1 ] = Integer . parseInt ( array
[ 1 ] ) ; return arrayInt
; }
}
public class
Plus extends
AbstractCalculator implements
ICalculator { @Overridepublic int
calculate ( String exp
) { int arrayInt
[ ] = split ( exp
, "\\+" ) ; return arrayInt
[ 0 ] + arrayInt
[ 1 ] ; }
}
public class
Divide extends
AbstractCalculator implements
ICalculator { @Overridepublic int
calculate ( String exp
) { int arrayInt
[ ] = split ( exp
, "/" ) ; return arrayInt
[ 0 ] / arrayInt
[ 1 ] ; }
}
省略 Minus和Multiply類的建立過程，類似。
public class
StrategyTest { public static void
main ( String
[ ] args
) { String exp
= "8/2" ; ICalculator cal
= new Divide ( ) ; int result
= cal
. calculate ( exp
) ; System
. out
. println ( result
) ; }
}
2.14 模板方法模式（Template Method）
模式結(jié)構(gòu)
一個抽象類中，有一個主方法，再定義1…n 個方法，可以是抽象的，也可以是實(shí)際的方法 定義一個類，繼承該抽象類，重寫抽象方法 通過調(diào)用抽象類，實(shí)現(xiàn)對子類的調(diào)用 場景
設(shè)計思路
一個抽象類AbstractCalculator中，有一個主方法calculate，再定義1…n 個方法，可以是抽象的，也可以是實(shí)際的方法 定義幾個類，比如Plus、Minus，繼承抽象類AbstractCalculator，重寫抽象方法 通過調(diào)用抽象類AbstractCalculator，實(shí)現(xiàn)對子類的調(diào)用 public abstract class AbstractCalculator { public final int calculate ( String exp
, String opt
) { int array
[ ] = split ( exp
, opt
) ; return calculate ( array
[ 0 ] , array
[ 1 ] ) ; } abstract public int calculate ( int num1
, int num2
) ; public int [ ] split ( String exp
, String opt
) { String array
[ ] = exp
. split ( opt
) ; int arrayInt
[ ] = new int [ 2 ] ; arrayInt
[ 0 ] = Integer . parseInt ( array
[ 0 ] ) ; arrayInt
[ 1 ] = Integer . parseInt ( array
[ 1 ] ) ; return arrayInt
; }
}
public class Plus extends AbstractCalculator { @Override public int calculate ( int num1
, int num2
) { return num1
+ num2
; }
}
public class Minus extends AbstractCalculator { @Override public int calculate ( int num1
, int num2
) { return num1
- num2
; }
}
public class Test { public static void main ( String [ ] args
) { String exp
= "4+8" ; AbstractCalculator cal
= new Plus ( ) ; int result
= cal
. calculate ( exp
, "\\+" ) ; System . out
. println ( result
) ; exp
= "8-2" ; cal
= new Minus ( ) ; result
= cal
. calculate ( exp
, "\\-" ) ; System . out
. println ( result
) ; } }
2.15 觀察者模式（Observer）
當(dāng)一個對象變化時，其它依賴該對象的對象都會收到通知，并且隨著變化
模式結(jié)構(gòu)
接口類是 Observer； Observer1 和 Observer2 是實(shí)現(xiàn)于 Observer 的類，當(dāng) Observer 變化時，Observer1 和 Observer2 必然變化； 接口 Subject ； 抽象類 AbstractSubject 實(shí)現(xiàn) Subject； MySubject 繼承 AbstractSubject，其中的 operation方法 隨著加入的Observer實(shí)現(xiàn)類不同而改變； 場景
設(shè)計思路
接口 User ； Avatar1 和 Avatar2 是實(shí)現(xiàn)于 AbstractUser 的類； 接口類是 ProgramGroup； 抽象類 AbstractProgram 實(shí)現(xiàn) ProgramGroup； Program 繼承 AbstractProgram，其中的 operation 方法 隨著加入的 User 實(shí)現(xiàn)類不同而改變； public interface User { public void update ( ) ;
}
public class Avatar1 implements User { @Override public void update ( ) { System . out
. println ( "Avatar1 has received." ) ; }
}
public class Avatar2 implements User { @Override public void update ( ) { System . out
. println ( "Avatar2 has received." ) ; }
}
public interface ProgramGroup { public void add ( User user
) ; public void del ( User user
) ; public void notifyObservers ( ) ; public void operation ( ) ;
}
public abstract class AbstractProgram implements ProgramGroup { private Vector < User > vector
= new Vector < User > ( ) ; @Override public void add ( User user
) { vector
. add ( user
) ; } @Override public void del ( User user
) { vector
. remove ( user
) ; } @Override public void notifyObservers ( ) { Enumeration < User > enumo
= vector
. elements ( ) ; while ( enumo
. hasMoreElements ( ) ) { enumo
. nextElement ( ) . update ( ) ; } }
}
public class Program extends AbstractProgram { @Override public void operation ( ) { System . out
. println ( "update self!" ) ; notifyObservers ( ) ; }
}
public class Test { public static void main ( String [ ] args
) { AbstractProgram program
= new Program ( ) ; program
. add ( new Avatar1 ( ) ) ; program
. add ( new Avatar2 ( ) ) ; program
. operation ( ) ; }
}
2.16 迭代子模式（Iterator）
迭代器模式就是順序訪問聚集中的對象；
一是需要遍歷的對象，即聚集對象；
public interface Iterator { public Object previous ( ) ; public Object next ( ) ; public boolean hasNext ( ) ; public Object first ( ) ;
}
public interface Collection { public Iterator iterator ( ) ; public Object get ( int i
) ; public int size ( ) ;
}
public class MyIterator implements Iterator { private Collection collection
; private int pos
= - 1 ; public MyIterator ( Collection collection
) { this . collection
= collection
; } @Override public Object previous ( ) { if ( pos
> 0 ) { pos
-- ; } return collection
. get ( pos
) ; } @Override public Object next ( ) { if ( pos
< collection
. size ( ) - 1 ) { pos
++ ; } return collection
. get ( pos
) ; } @Override public boolean hasNext ( ) { if ( pos
< collection
. size ( ) - 1 ) { return true ; } else { return false ; } } @Override public Object first ( ) { pos
= 0 ; return collection
. get ( pos
) ; }
}
public class MyCollection implements Collection { public String string
[ ] = { "A" , "B" , "C" , "D" , "E" } ; @Override public Iterator iterator ( ) { return new MyIterator ( this ) ; } @Override public Object get ( int i
) { return string
[ i
] ; } @Override public int size ( ) { return string
. length
; }
}
public class Test { public static void main ( String [ ] args
) { Collection collection
= new MyCollection ( ) ; Iterator it
= collection
. iterator ( ) ; while ( it
. hasNext ( ) ) { System . out
. println ( it
. next ( ) ) ; } }
}
2.17 責(zé)任鏈模式（Chain of Responsibility）
有多個對象，每個對象持有對下一個對象的引用，這樣就會形成一條鏈，請求在這條鏈上傳遞，直到某一對象決定處理該請求。
模式結(jié)構(gòu)
Abstracthandler 類提供了get 和set 方法 MyHandle 類是核心，設(shè)置和修改引用對象，實(shí)例化后生成一系列相互持有的對象，構(gòu)成一條鏈。 public interface Handler { public void operator ( ) ;
}
public abstract class AbstractHandler { private Handler handler
; public Handler getHandler ( ) { return handler
; } public void setHandler ( Handler handler
) { this . handler
= handler
; } }
public class MyHandler extends AbstractHandler implements Handler { private String name
; public MyHandler ( String name
) { this . name
= name
; } @Override public void operator ( ) { System . out
. println ( name
+ "deal!" ) ; if ( getHandler ( ) != null ) { getHandler ( ) . operator ( ) ; } }
}
public class Test { public static void main ( String [ ] args
) { MyHandler h1
= new MyHandler ( "h1" ) ; MyHandler h2
= new MyHandler ( "h2" ) ; MyHandler h3
= new MyHandler ( "h3" ) ; h1
. setHandler ( h2
) ; h2
. setHandler ( h3
) ; h1
. operator ( ) ; }
}
2.18 命令模式（Command）
每個類相互解耦，任何一方都不用去依賴其他人，只需要做好自己的事兒就行
模式結(jié)構(gòu)
Invoker類 是調(diào)用者 Receiver類 是被調(diào)用者 Command 接口 MyCommand 是命令，實(shí)現(xiàn)了Command 接口，持有接收對象 背景
設(shè)計思路
Command 接口 MyCommand 是命令，實(shí)現(xiàn)了Command 接口，持有接收對象 Soldier 是士兵 Commander是司令員 public interface Command { public void exe ( ) ;
}
public class MyCommand implements Command { private Soldier receiver
; public MyCommand ( Soldier receiver
) { this . receiver
= receiver
; } @Override public void exe ( ) { receiver
. action ( ) ; }
}
public class Soldier { public void action ( ) { System . out
. println ( "Command received." ) ; }
}
public class Commander { private Command command
; public Commander ( Command command
) { this . command
= command
; } public void action ( ) { command
. exe ( ) ; }
}
2.19 備忘錄模式（Memento）
主要目的
背景
結(jié)構(gòu)
Original 類是原始類，里面有需要保存的屬性value 及創(chuàng)建一個備忘錄類，用來保存 value值； Memento 類是備忘錄類； Storage 類是存儲備忘錄的類，持有 Memento 類的實(shí)例，該模式很好理解。 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
; }
}
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
; }
}
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 ( ) ; }
}
public class Test { public static void main ( String [ ] args
) { Original origi
= new Original ( "egg" ) ; Storage storage
= new Storage ( origi
. createMemento ( ) ) ; System . out
. println ( "初始化狀態(tài)為：" + origi
. getValue ( ) ) ; origi
. setValue ( "niu" ) ; System . out
. println ( "修改后的狀態(tài)為：" + origi
. getValue ( ) ) ; origi
. restoreMemento ( storage
. getMemento ( ) ) ; System . out
. println ( "恢復(fù)后的狀態(tài)為：" + origi
. getValue ( ) ) ; }
}
2.20 狀態(tài)模式（State）
核心思想 ：
背景
結(jié)構(gòu)
State 類是個狀態(tài)類 Context 類實(shí)現(xiàn)切換 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!" ) ; }
}
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 ( "online" ) ) { state
. method1 ( ) ; } else if ( state
. getValue ( ) . equals ( "offline" ) ) state
. method2 ( ) ; }
}
public class Test { public static void main ( String [ ] args
) { State state
= new State ( ) ; Context context
= new Context ( state
) ; state
. setValue ( "online" ) ; context
. method ( ) ; state
. setValue ( "offline" ) ; context
. method ( ) ; }
}
2.21 訪問者模式（Visitor）
優(yōu)缺點(diǎn) ：
優(yōu)點(diǎn)是增加操作很容易，因?yàn)樵黾硬僮饕馕吨黾有碌脑L問者。訪問者模式將有關(guān)行為集中到一個訪問者對象中，其改變不影響系統(tǒng)數(shù)據(jù)結(jié)構(gòu)。 缺點(diǎn)就是增加新的數(shù)據(jù)結(jié)構(gòu)很困難。 簡單來說，訪問者模式就是一種分離對象數(shù)據(jù)結(jié)構(gòu)與行為的方法，通過這種分離，可達(dá)到為一個被訪問者動態(tài)添加新的操作而無需做其它的修改的效果。
結(jié)構(gòu)
接口Visitor MyVisitor類實(shí)現(xiàn)接口Visitor，其中有visit方法 接口Subject，accept 方法，接受將要訪問它的對象，getSubject()獲取將要被訪問的屬性 MySubject類實(shí)現(xiàn)接口Subject，其中accept 方法導(dǎo)入?yún)?shù)為Visitor類，調(diào)用其中的visit方法
public interface Visitor { public void visit ( Subject sub
) ;
}
public class MyVisitor implements Visitor { @Override public void visit ( Subject sub
) { System . out
. println ( "visit the subject：" + sub
. getSubject ( ) ) ; }
}
public interface Subject { public void accept ( Visitor visitor
) ; public String getSubject ( ) ;
}
public class MySubject implements Subject { @Override public void accept ( Visitor visitor
) { visitor
. visit ( this ) ; } @Override public String getSubject ( ) { return "love" ; }
}
public class Test { public static void main ( String [ ] args
) { Visitor visitor
= new MyVisitor ( ) ; Subject sub
= new MySubject ( ) ; sub
. accept ( visitor
) ; }
}
2.22 中介者模式（Mediator）
降低類類之間的耦合的，因?yàn)槿绻愵愔g有依賴關(guān)系的話，不利于功能的拓展和維護(hù)，因?yàn)橹灰薷囊粋€對象，其它關(guān)聯(lián)的對象都得進(jìn)行修改。
結(jié)構(gòu)
User 抽象類，其中在實(shí)現(xiàn)方法中傳入 Mediator 類對象 User1 和User2 繼承 User 引入了 Mediator類，提供統(tǒng)一接口 MyMediator 為其實(shí)現(xiàn)類，里面持有 User1 和User2 的實(shí)例，用來實(shí)現(xiàn)對User1 和User2 的控制 public abstract class User { private Mediator mediator
; public Mediator getMediator ( ) { return mediator
; } public User ( Mediator mediator
) { this . mediator
= mediator
; } public abstract void work ( ) ; }
public class User1 extends User { public User1 ( Mediator mediator
) { super ( mediator
) ; } @Override public void work ( ) { System . out
. println ( "user1 exe!" ) ; }
}
public class User2 extends User { public User2 ( Mediator mediator
) { super ( mediator
) ; } @Override public void work ( ) { System . out
. println ( "user2 exe!" ) ; }
}
public interface Mediator { public void createMediator ( ) ; public void workAll ( ) ;
}
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 ( ) ; }
}
2.23 解釋器模式（Interpreter）
應(yīng)用的少，主要應(yīng)用在 OOP 開發(fā)中的編譯器的開發(fā)
public interface Expression { public int interpret ( Context context
) ;
}
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
; } }
public class Minus implements Expression { @Override public int interpret ( Context context
) { return context
. getNum1 ( ) - context
. getNum2 ( ) ; }
}
public class Plus implements Expression { @Override public int interpret ( Context context
) { return context
. getNum1 ( ) + context
. getNum2 ( ) ; }
}
public class Test { public static void main ( String [ ] args
) { int result
= new Minus ( ) . interpret ( ( new Context ( new Plus ( ) . interpret ( new Context ( 9 , 2 ) ) , 8 ) ) ) ; System . out
. println ( result
) ; }
}
總結(jié)
以上是生活随笔 為你收集整理的23种设计模式解析 的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
如果覺得生活随笔 網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔 推薦給好友。
