面向?qū)ο蟮幕驹O(shè)計原則（SOLID）：
單一職責（Single Responsibility），類或者對象最好是只有單一職責策彤，在程序設(shè)計中如果發(fā)現(xiàn)某個類承擔著多種義務(wù)，可以考慮進行拆分币呵。
開閉原則（Open-Close涌穆，Open for extension，close for modification）独旷，設(shè)計要對擴展開放署穗，對修改關(guān)閉寥裂。換句話說，程序設(shè)計應(yīng)保證平滑的擴展性案疲，盡量避免因為新增同類功能而修改已有實現(xiàn)封恰，這樣可以少產(chǎn)出些回歸問題。
里氏替換（Liskov Substitution）褐啡，這是面向?qū)ο蟮幕疽刂慌堤颍M行繼承關(guān)系抽象時，凡是可以用父類或者基類的地方备畦，都可以用子類替換低飒。
接口分離（Interface Segregation），我們在進行類和接口設(shè)計時懂盐，如果再一個接口里定義了太多方法褥赊，其子類很可能面臨兩難，就是只有部分方法對它是有意義的莉恼，這就破壞了程序的內(nèi)聚性拌喉。對于這種情況，可以通過拆分成功能單一的多個接口俐银，將行為進行解耦尿背。在未來維護中，如果某個接口設(shè)計有變捶惜，不會對使用其他接口的子類構(gòu)成影響田藐。
依賴反轉(zhuǎn)（Dependency Inversion）：
A.高層次的模塊不應(yīng)該依賴于低層次的模塊，他們都應(yīng)該依賴于抽象售躁。
B.抽象不應(yīng)該依賴于具體實現(xiàn)坞淮，具體實現(xiàn)應(yīng)該依賴于抽象。
也即針對接口編程陪捷，而不是針對實現(xiàn)編程回窘。
合成復用原則(Composite Reuse Principle, CRP)：復用時要盡量使用組合/聚合關(guān)系（關(guān)聯(lián)關(guān)系），少用繼承市袖。
迪米特法則(Law of Demeter, LoD)：一個軟件實體應(yīng)當盡可能少地與其他實體發(fā)生相互作用啡直。
我覺得這個原則有兩個意思：1、一個對象應(yīng)該對其他對象保持最少的了解苍碟，對于被依賴的類而言酒觅，意思就是向外公開的public方法應(yīng)該盡可能的少；2微峰、不要和“陌生人”說話舷丹、只與你的直接朋友通信蜓肆。直接朋友通常表現(xiàn)為關(guān)聯(lián)，聚合和組成關(guān)系症概，兩個對象之間聯(lián)系很緊密蕾额，通常以成員變量彼城，方法的參數(shù)和返回值的形式出現(xiàn)。局部變量募壕、臨時變量則不是直接的朋友调炬。我們要求陌生的類不要作為局部變量出現(xiàn)在類中。
總體來說設(shè)計模式分為三大類：
創(chuàng)建型模式筐眷，共五種：工廠方法模式习柠、抽象工廠模式资溃、單例模式烈炭、建造者模式、原型模式趴捅。
結(jié)構(gòu)型模式霹疫，共七種：適配器模式丽蝎、裝飾器模式、代理模式红省、外觀模式国觉、橋接模式麻诀、組合模式痕寓、享元模式缸逃。
行為型模式厂抽，共十一種：策略模式、模板方法模式昭殉、觀察者模式挪丢、迭代子模式卢厂、責任鏈模式慎恒、命令模式、備忘錄模式死嗦、狀態(tài)模式越除、訪問者模式外盯、中介者模式饱苟、解釋器模式。
創(chuàng)建型：
1）單例模式( Singleton )
??????? 保證一個類僅有一個實例,并提供一個訪問它的全局控制點肋殴。讓類自身負責保存它的唯一實例护锤。 這個類可以保證沒有其他實例可以被創(chuàng)建（通過截取創(chuàng)建新對象的請求 ）烙懦， 并且它可以提供一個訪問該實例的方法赤炒。
下圖是利用 Java 的語言特性實現(xiàn)的線程安全且能延遲初始化的單例模式，Singleton 中維護著靜態(tài)私有的 SingleHolder 類雪情， SingleHolder 類中持有個靜態(tài)常量 sHolder 你辣，Client 若通過getSingleInstance 方法獲取 Singleton 對象則直接返回 SingleHolder 類的 sHolder舍哄。
實現(xiàn)示例代碼：
/**
?* “餓漢式”的單例實現(xiàn)方式
?*
?*可以保證線程安全
?*/
public final class Director{
? /**
?? *靜態(tài)的本類實例
?? */
? private static final Director INSTANCE = newDirector();
? /**
?? *私有化的構(gòu)造方法保證不被其它類調(diào)用
?? */
? private Director() {
? }
? /**
?? *客戶端調(diào)用獲取單例實例
?? *
?? *@return 單例實例
?? */
? public static Director getInstance() {
??? return INSTANCE;
? }
}
/**
?*采用枚舉類型的單例模式
?*/
public enum EnumDirector{
? @Override
? public String toString() {
??? return getDeclaringClass().getCanonicalName() + "@" +hashCode();
? }
}
/**
?* “懶漢式”的單例模式
?*
?*內(nèi)部類在被引用之前不會被類加載器加載表悬，直到客戶端調(diào)用的時候才被加載
?*
?*這個方案是線程安全的
?*/
public final class LazyInitializationDirector{
? /**
?? *私有構(gòu)造方法
?? */
? private LazyInitializationDirector() {
? }
? /**
?? *@return 單例實例
?? */
? public static? LazyInitializationDirector getInstance() {
??? return InstanceHolder.INSTANCE;
? }
? /**
?? *延遲加載蟆沫，生成 {@link? LazyInitializationDirector} 的實例
?? */
? private static class InstanceHolder{
? ? private static final? LazyInitializationDirector INSTANCE = newLazyInitializationDirector();
? }
}
/**
?*線程安全饥追、雙檢查鎖的單例模式
?*
?* volatile所修飾的變量可以被看作是一種 “程度較輕的 synchronized ”；
?*與? synchronized 塊相比，volatile 變量所需的編碼較少捏顺，并且運行時開銷也較少幅骄，
?*但是它所能實現(xiàn)的功能也僅是 synchronized 的一部分本今。
?*
?*鎖提供了兩種主要特性：互斥（mutual exclusion） 和可見性（visibility）冠息。
?*互斥即一次只允許一個線程持有某個特定的鎖逛艰，因此可使用該特性實現(xiàn)對共享數(shù)據(jù)的協(xié)
?*調(diào)訪問協(xié)議，這樣菇绵，一次就只有一個線程能夠使用該共享數(shù)據(jù)咬最。可見性要更加復雜一些惑申，
?*它必須確保釋放鎖之前對共享數(shù)據(jù)做出的更改對于隨后獲得該鎖的另一個線程是可見的
?*/
public final class ThreadSafeDoubleCheckLocking{
? private static volatile? ThreadSafeDoubleCheckLocking INSTANCE;
? private ThreadSafeDoubleCheckLocking() {
??? // 防止通過反射進行實例化
??? if? (null != INSTANCE) {
????? throw new? IllegalStateException("該實例已經(jīng)存在");
??? }
? }
? public static? ThreadSafeDoubleCheckLocking getInstance() {
??? // 采用局部變量的形式可以提高約 25% 的性能
? ??ThreadSafeDoubleCheckLocking instance= INSTANCE;
??? // 如果已經(jīng)被實例化則直接返回該實例
??? if? (null ==instance) {
????? // 無法確定其他的線程是否已經(jīng)完成初始化
????? // 為了確保我們需要鎖定一個對象來進行確認
????? synchronized (ThreadSafeDoubleCheckLocking.class) {
??????? // 再次將實例分配給局部變量硝桩，檢查它是否被其他線程初始化
??????? // 在當前線程被阻塞進入鎖定區(qū)域時碗脊。如果它被初始化則直接返回之前創(chuàng)建的實例
??????? instance= INSTANCE;
??????? if (null ==instance) {
????????? INSTANCE =? instance = newThreadSafeDoubleCheckLocking();
??????? }
????? }
??? }
??? return instance;
? }
}
/**
?* “懶漢式”的單例模式-線程安全的
?*/
public final class ThreadSafeLazyLoadDirector{
? private static volatile? ThreadSafeLazyLoadDirector INSTANCE;
? private ThreadSafeLazyLoadDirector() {
??? // 防止通過反射進行實例化
??? if? (null != INSTANCE) {
????? throw new? IllegalStateException("該實例已經(jīng)存在");
??? }
? }
? /**
?? *此方法被第一次調(diào)用時才會生成單例實例衙伶，實現(xiàn)懶加載
?? */
? public static synchronized? ThreadSafeLazyLoadDirector getInstance() {
??? if? (null == INSTANCE) {
????? INSTANCE =? newThreadSafeLazyLoadDirector();
??? }
??? return INSTANCE;
? }
}
/**
?* Singleton
?*/
public class Application{
? private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
? public static void main(String[] args) {
? ? // “餓漢式” 單例模式
??? Director director1= Director.getInstance();
??? Director director2= Director.getInstance();
??? LOGGER.info("餓漢式單例1 = {}", director1);
??? LOGGER.info("餓漢式單例2 = {}", director2);
??? // “懶漢式” 單例模式
??? LazyInitializationDirector lazyDirector1=? LazyInitializationDirector.getInstance();
??? LazyInitializationDirector lazyDirector2=? LazyInitializationDirector.getInstance();
??? LOGGER.info("懶漢式單例1 = {}", lazyDirector1);
??? LOGGER.info("懶漢式單例2 = {}", lazyDirector2);
??? // 雙檢鎖
??? ThreadSafeDoubleCheckLocking? doubleCheckLocking1=? ThreadSafeDoubleCheckLocking.getInstance();
??? LOGGER.info("雙檢鎖單例1 = {}", doubleCheckLocking1);
??? ThreadSafeDoubleCheckLocking? doubleCheckLocking2=? ThreadSafeDoubleCheckLocking.getInstance();
??? LOGGER.info("雙檢鎖單例2 = {}", doubleCheckLocking2);
??? // 線程安全的“懶漢式”單例模式
??? ThreadSafeLazyLoadDirector? lazyLoadDirector1=? ThreadSafeLazyLoadDirector.getInstance();
??? LOGGER.info("線程安全的懶漢式單例1 = {}", lazyLoadDirector1.toString());
??? ThreadSafeLazyLoadDirector? lazyLoadDirector2=? ThreadSafeLazyLoadDirector.getInstance();
??? LOGGER.info("線程安全的懶漢式單例2 = {}", lazyLoadDirector2.toString());
??? // 枚舉型的單例模式
??? EnumDirector enumDirector1= EnumDirector.INSTANCE;
??? LOGGER.info("枚舉型單例1 = {}", enumDirector1);
??? EnumDirector enumDirector2= EnumDirector.INSTANCE;
??? LOGGER.info("枚舉型單例2 = {}", enumDirector2);
? }
}
2）工廠模式( Factory )
????? 針對每一種產(chǎn)品提供一個工廠類，通過不同的工廠實例來創(chuàng)建不同的產(chǎn)品實例芬沉。
為每一種產(chǎn)品提供一個工廠類阁猜，不同工廠類實現(xiàn)同一個工廠接口剃袍，返回不同產(chǎn)品。
實現(xiàn)示例代碼：
假定現(xiàn)在有兩個廚師憔维，一個只會做中餐畏邢，另一個只會做西餐棵红，餐品分為熟食和生食兩類。顧客需要顧客需要根據(jù)自己的口味來選擇對應(yīng)的廚師并告知其需要熟食還是生食虱肄，廚師根據(jù)顧客的口味來進行烹制咏窿。
/**
?*廚師
?*/
public interface Cook{
? FoodcookFood(FoodType foodType);
}
/**
?*食物
?*/
public interface Food{
? FoodTypegetFoodType();
}
/**
?*食物類型
?*/
public enum FoodType{
? HOT("熱的"), COLD("涼的");
? privateString name;
? FoodType(String foodType) {
??? this.name =foodType;
? }
? public String getName() {
??? returnname;
? }
}
/**
?*中餐廚師
?*/
public class ChineseCook implements Cook{
? @Override
? public Food cookFood(FoodType foodType) {
??? return newChineseFood(foodType);
? }
}
/**
?*中餐
?*/
public class ChineseFood implements Food{
? privateFoodType foodType;
? public ChineseFood(FoodType foodType) {
??? this.foodType =foodType;
? }
? @Override
? public FoodType getFoodType() {
??? returnfoodType;
? }
? @Override
? public String toString() {
??? return foodType.getName()
? + "中餐";
? }
}
/**
?*西餐廚師
?*/
public class WesternCook implements Cook{
? @Override
? public Food cookFood(FoodType foodType) {
??? return newWesternFood(foodType);
? }
}
/**
?*西餐
?*/
public class WesternFood implements Food{
? privateFoodType foodType;
? public WesternFood(FoodType foodType) {
??? this.foodType =foodType;
? }
? @Override
? public FoodType getFoodType() {
??? returnfoodType;
? }
? @Override
? public String toString() {
??? return foodType.getName()
? + "西餐";
? }
}
/**
?* Factory Method
?*/
public class Application{
? private finalCook cook;
? private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
? private Application(Cook cook) {
??? this.cook =cook;
? }
? public static void main(String[] args) {
??? Application app= new Application(newWesternCook());
??? app.makeFood();
??? app= new Application(newChineseCook());
??? app.makeFood();
? }
? private void makeFood() {
??? Food food;
??? food= cook.cookFood(FoodType.COLD);
??? LOGGER.info(food.toString());
??? food= cook.cookFood(FoodType.HOT);
??? LOGGER.info(food.toString());
? }
}
3）抽象工廠模式( Abstract Factory )
????? 應(yīng)對產(chǎn)品族概念而生萝挤。與工廠模式相比怜珍，抽象工廠模式是為了應(yīng)對產(chǎn)品族凤粗。
實現(xiàn)示例代碼：
假定一支遠洋的隊伍由船嫌拣、船長以及水手組成异逐，隊伍有年輕和成熟之分。年輕的隊伍有著年輕的船長腥例、年輕的水手以及嶄新的船只院崇；而成熟的隊伍有著老船長袍祖、老水手以及老舊的船只蕉陋。不同隊伍有著不同的主題拨扶，隊伍中不同的物體存在一定的依賴性患民。
/**
?*船上成員以及船
?*/
public interface Member{
? String getDescription();
}
/**
?*船長
?*/
public interface Captain extends Member{
}
/**
?*水手
?*/
public interface Sailor extends Member{
}
/**
?*船
?*/
public interface Ship extends Member{
}
/**
?*團隊工廠要實現(xiàn)的功能
?*/
public interface TeamFactory{
? ShipcreateShip();
? CaptaincreateCaptain();
? SailorcreateSailor();
}
/**
?*老船長
?*/
public class OldCaptain implements Captain{
? static final String DESCRIPTION = "我是一名老船長";
? public String getDescription() {
??? return DESCRIPTION;
? }
}
/**
?*老水手
?*/
public class OldSailor implements Sailor{
? static final String DESCRIPTION = "我是一名老水手";
? public String getDescription() {
??? return DESCRIPTION;
? }
}
/**
?*舊船
?*/
public class OldShip implements Ship{
? static final String DESCRIPTION = "我是一艘破舊的船";
? public String getDescription() {
??? return DESCRIPTION;
? }
}
/**
?*久經(jīng)考驗的團隊
?*/
public class PermanentTeamFactory implements TeamFactory{
? public Ship createShip() {
??? return newOldShip();
? }
? public Captain createCaptain() {
??? return newOldCaptain();
? }
? public Sailor createSailor() {
??? return newOldSailor();
? }
}
/**
?*年輕船長
?*/
public class YoungCaptain implements Captain{
? static final String DESCRIPTION = "我是一名年輕的船長";
? public String getDescription() {
??? return DESCRIPTION;
? }
}
/**
?*年輕水手
?*/
public class YoungSailor implements Sailor{
? static final String DESCRIPTION = "我是年輕的水手";
? public String getDescription() {
??? return DESCRIPTION;
? }
}
/**
?*新船
?*/
public class NewShip implements Ship{
? static final String DESCRIPTION = "我是一艘嶄新的船";
? public String getDescription() {
??? return DESCRIPTION;
? }
}
/**
?*年輕團隊工廠
?*/
public class YoungTeamFactory implements TeamFactory{
? public Ship createShip() {
??? return newNewShip();
? }
? public Captain createCaptain() {
??? return newYoungCaptain();
? }
? public Sailor createSailor() {
??? return newYoungSailor();
? }
}
/**
?* AbstractFactory
?*/
public class Application{
? private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
? privateShip mShip;
? privateCaptain mCaptain;
? privateSailor mSailor;
? public void createTeam(final TeamFactory factory) {
? ??setmCaptain(factory.createCaptain());
??? setmShip(factory.createShip());
??? setmSailor(factory.createSailor());
? }
? public static void main(String[] args) {
? ? Application app= newApplication();
? ? app.createTeam(newYoungTeamFactory());
??? LOGGER.info("正在創(chuàng)建一支年輕的隊伍...");
??? LOGGER.info("-->" + app.getmCaptain().getDescription());
??? LOGGER.info("-->" + app.getmShip().getDescription());
??? LOGGER.info("-->" + app.getmSailor().getDescription());
??? app.createTeam(newPermanentTeamFactory());
??? LOGGER.info("正在創(chuàng)建一支久經(jīng)考驗的隊伍...");
??? LOGGER.info("-->" + app.getmCaptain().getDescription());
??? LOGGER.info("-->" + app.getmShip().getDescription());
??? LOGGER.info("-->" + app.getmSailor().getDescription());
? }
? public Ship getmShip() {
??? returnmShip;
? }
? public void setmShip(Ship mShip) {
??? this.mShip =mShip;
? }
? public Captain getmCaptain() {
??? returnmCaptain;
? }
? public void setmCaptain(Captain mCaptain) {
??? this.mCaptain =mCaptain;
? }
? public Sailor getmSailor() {
??? returnmSailor;
? }
? public void setmSailor(Sailor mSailor) {
??? this.mSailor =mSailor;
? }
}
4）建造者模式( Builder )
??????? 將一個復雜對象的構(gòu)建與它的表示分離托猩，使得同樣的構(gòu)造過程可以產(chǎn)生不同的對象京腥。
作為 Product 的內(nèi)部類溅蛉，Builder 統(tǒng)一了 Product 的整個構(gòu)建過程船侧，同時在 build 過程中镜撩，可以由于 set 值順序不同等原因產(chǎn)生不同的效果。
實現(xiàn)示例代碼：
假定需要生成一個虛擬的人物模型卫旱，人物主要包括幾個簡單的屬性：姓名顾翼、年齡奈泪、國籍以及膚色涝桅。假如一個數(shù)據(jù)模型的擁有很多屬性冯遂，如果單純使用構(gòu)造方法來實例化對象，勢必會造成構(gòu)造方法參數(shù)爆炸的問題壁却，也可以稱之為“反可伸縮構(gòu)造方法模式”裸准。代碼的可讀性和可靠性大大降低炒俱。此時，可以為這個對象創(chuàng)建的過程指定一個創(chuàng)建者砸王，我們只需要向創(chuàng)建者描述該對象的一些具體細節(jié)处硬，接下來的構(gòu)造過程就統(tǒng)統(tǒng)交給創(chuàng)建者完成了荷辕。
/**
?*國籍
?*/
public enum Nationality{
? CHINA("中國"), RUSSIA("俄羅斯"), USA("美國"), JAPAN("日本"), UK("英國");
? privateString name;
? Nationality(String name)? {
??? this.name =name;
? }
? @Override
? public String toString() {
??? returnname;
? }
}
/**
?*膚色
?*/
public enum SkinColor{
? YELLOW("黃色"), BLACK("黑色"), WHITE("白色");
? private String color;
? SkinColor(String color) {
??? this.color =color;
? }
? @Override
? public String toString() {
??? returncolor;
? }
}
/**
?*人
?*/
public final class Person{
? private finalString name;
? private finalInteger age;
? private finalNationality? nationality;
? public String getName() {
??? returnname;
? }
? public Integer getAge() {
??? returnage;
? }
? public Nationality getNationality() {
??? returnnationality;
? }
? public SkinColor getSkinColor() {
??? returnskinColor;
? }
? private finalSkinColor? skinColor;
? public Person(Builder builder) {
??? this.name = builder.name;
??? this.age = builder.age;
??? this.skinColor = builder.skinColor;
??? this.nationality = builder.nationality;
? }
? @Override
? public String toString() {
??? StringBuilder sb= newStringBuilder();
??? sb.append(name);
??? if? (null !=nationality) {
????? sb.append(" 是來自 " + nationality.toString() + " 的");
??? }
??? if? (null !=age) {
????? sb.append(" " + age + "歲的");
??? }
??? if? (null !=skinColor) {
????? sb.append(" 有著" + skinColor + "皮膚的");
??? }
??? sb.append("一個人");
??? return sb.toString();
? }
? /**
?? *創(chuàng)建者
?? */
? public static class Builder{
? ? privateString name;
??? privateInteger age;
??? privateNationality nationality;
??? privateSkinColor skinColor;
??? public Builder age(Integer age) {
????? this.age =age;
????? return this;
??? }
??? public Builder name(String name) {
????? if (null ==name) {
??????? throw new? IllegalArgumentException("人必須有名字!");
????? }
????? this.name =name;
????? return this;
??? }
??? public Builder nationality(Nationality nationality) {
????? this.nationality =nationality;
????? return this;
??? }
??? public Builder skinColor(SkinColor skinColor) {
????? this.skinColor =skinColor;
????? return this;
??? }
??? public Person build() {
????? return new? Person(this);
??? }
? }
}
/**
?* Builder
?*/
public class Application{
? private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);
? public static void main(String[] args) {
? ? Person personWang=
??????????? new Person.Builder().name("小王").age(25).nationality(Nationality.CHINA).skinColor(SkinColor.YELLOW).build();
??? Person personZhang=
??????????? new Person.Builder().name("小張").age(28).nationality(Nationality.USA).skinColor(SkinColor.WHITE).build();
??? Person personLiu=
? ??????????new Person.Builder().name("老王").age(48).nationality(Nationality.JAPAN).skinColor(SkinColor.YELLOW).build();
??? LOGGER.info(personWang.toString());
??? LOGGER.info(personZhang.toString());
??? LOGGER.info(personLiu.toString());
? }
}
