面向對象的基本設計原則（SOLID）：
單一職責（Single Responsibility），類或者對象最好是只有單一職責，在程序設計中如果發現某個類承擔著多種義務，可以考慮進行拆分。
開閉原則（Open-Close，Open for extension，close for modification），設計要對擴展開放，對修改關閉。換句話說，程序設計應保證平滑的擴展性，盡量避免因為新增同類功能而修改已有實現，這樣可以少產出些回歸問題。
里氏替換（Liskov Substitution），這是面向對象的基本要素之一，進行繼承關系抽象時，凡是可以用父類或者基類的地方，都可以用子類替換。
接口分離（Interface Segregation），我們在進行類和接口設計時，如果再一個接口里定義了太多方法，其子類很可能面臨兩難，就是只有部分方法對它是有意義的，這就破壞了程序的內聚性。對于這種情況，可以通過拆分成功能單一的多個接口，將行為進行解耦。在未來維護中，如果某個接口設計有變，不會對使用其他接口的子類構成影響。
依賴反轉（Dependency Inversion）：
A.高層次的模塊不應該依賴于低層次的模塊，他們都應該依賴于抽象。
B.抽象不應該依賴于具體實現，具體實現應該依賴于抽象。
也即針對接口編程，而不是針對實現編程。
合成復用原則(Composite Reuse Principle, CRP)：復用時要盡量使用組合/聚合關系（關聯關系），少用繼承。
迪米特法則(Law of Demeter, LoD)：一個軟件實體應當盡可能少地與其他實體發生相互作用。
我覺得這個原則有兩個意思：1、一個對象應該對其他對象保持最少的了解，對于被依賴的類而言，意思就是向外公開的public方法應該盡可能的少；2、不要和“陌生人”說話、只與你的直接朋友通信。直接朋友通常表現為關聯，聚合和組成關系，兩個對象之間聯系很緊密，通常以成員變量，方法的參數和返回值的形式出現。局部變量、臨時變量則不是直接的朋友。我們要求陌生的類不要作為局部變量出現在類中。
總體來說設計模式分為三大類：
創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
結構型模式，共七種：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。
創建型：
1）單例模式( Singleton )
??????? 保證一個類僅有一個實例,并提供一個訪問它的全局控制點。讓類自身負責保存它的唯一實例。 這個類可以保證沒有其他實例可以被創建（通過截取創建新對象的請求 ）， 并且它可以提供一個訪問該實例的方法。
下圖是利用 Java 的語言特性實現的線程安全且能延遲初始化的單例模式，Singleton 中維護著靜態私有的 SingleHolder 類， SingleHolder 類中持有個靜態常量 sHolder ，Client 若通過getSingleInstance 方法獲取 Singleton 對象則直接返回 SingleHolder 類的 sHolder。
實現示例代碼：
/**
?* “餓漢式”的單例實現方式
?*
?*可以保證線程安全
?*/
public final class Director{
? /**
?? *靜態的本類實例
?? */
? private static final Director INSTANCE = newDirector();
? /**
?? *私有化的構造方法保證不被其它類調用
?? */
? private Director() {
? }
? /**
?? *客戶端調用獲取單例實例
?? *
?? *@return 單例實例
?? */
? public static Director getInstance() {
??? return INSTANCE;
? }
}
/**
?*采用枚舉類型的單例模式
?*/
public enum EnumDirector{
? @Override
? public String toString() {
??? return getDeclaringClass().getCanonicalName() + "@" +hashCode();
? }
}
/**
?* “懶漢式”的單例模式
?*
?*內部類在被引用之前不會被類加載器加載，直到客戶端調用的時候才被加載
?*
?*這個方案是線程安全的
?*/
public final class LazyInitializationDirector{
? /**
?? *私有構造方法
?? */
? 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 變量所需的編碼較少，并且運行時開銷也較少，
?*但是它所能實現的功能也僅是 synchronized 的一部分。
?*
?*鎖提供了兩種主要特性：互斥（mutual exclusion） 和可見性（visibility）。
?*互斥即一次只允許一個線程持有某個特定的鎖，因此可使用該特性實現對共享數據的協
?*調訪問協議，這樣，一次就只有一個線程能夠使用該共享數據。可見性要更加復雜一些，
?*它必須確保釋放鎖之前對共享數據做出的更改對于隨后獲得該鎖的另一個線程是可見的
?*/
public final class ThreadSafeDoubleCheckLocking{
? private static volatile? ThreadSafeDoubleCheckLocking INSTANCE;
? private ThreadSafeDoubleCheckLocking() {
??? // 防止通過反射進行實例化
??? if? (null != INSTANCE) {
????? throw new? IllegalStateException("該實例已經存在");
??? }
? }
? public static? ThreadSafeDoubleCheckLocking getInstance() {
??? // 采用局部變量的形式可以提高約 25% 的性能
? ??ThreadSafeDoubleCheckLocking instance= INSTANCE;
??? // 如果已經被實例化則直接返回該實例
??? if? (null ==instance) {
????? // 無法確定其他的線程是否已經完成初始化
????? // 為了確保我們需要鎖定一個對象來進行確認
????? synchronized (ThreadSafeDoubleCheckLocking.class) {
??????? // 再次將實例分配給局部變量，檢查它是否被其他線程初始化
??????? // 在當前線程被阻塞進入鎖定區域時。如果它被初始化則直接返回之前創建的實例
??????? 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("該實例已經存在");
??? }
? }
? /**
?? *此方法被第一次調用時才會生成單例實例，實現懶加載
?? */
? 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 )
????? 針對每一種產品提供一個工廠類，通過不同的工廠實例來創建不同的產品實例。
為每一種產品提供一個工廠類，不同工廠類實現同一個工廠接口，返回不同產品。
實現示例代碼：
假定現在有兩個廚師，一個只會做中餐，另一個只會做西餐，餐品分為熟食和生食兩類。顧客需要顧客需要根據自己的口味來選擇對應的廚師并告知其需要熟食還是生食，廚師根據顧客的口味來進行烹制。
/**
?*廚師
?*/
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 )
????? 應對產品族概念而生。與工廠模式相比，抽象工廠模式是為了應對產品族。
實現示例代碼：
假定一支遠洋的隊伍由船、船長以及水手組成，隊伍有年輕和成熟之分。年輕的隊伍有著年輕的船長、年輕的水手以及嶄新的船只；而成熟的隊伍有著老船長、老水手以及老舊的船只。不同隊伍有著不同的主題，隊伍中不同的物體存在一定的依賴性。
/**
?*船上成員以及船
?*/
public interface Member{
? String getDescription();
}
/**
?*船長
?*/
public interface Captain extends Member{
}
/**
?*水手
?*/
public interface Sailor extends Member{
}
/**
?*船
?*/
public interface Ship extends Member{
}
/**
?*團隊工廠要實現的功能
?*/
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;
? }
}
/**
?*久經考驗的團隊
?*/
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("正在創建一支年輕的隊伍...");
??? LOGGER.info("-->" + app.getmCaptain().getDescription());
??? LOGGER.info("-->" + app.getmShip().getDescription());
??? LOGGER.info("-->" + app.getmSailor().getDescription());
??? app.createTeam(newPermanentTeamFactory());
??? LOGGER.info("正在創建一支久經考驗的隊伍...");
??? 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 )
??????? 將一個復雜對象的構建與它的表示分離，使得同樣的構造過程可以產生不同的對象。
作為 Product 的內部類，Builder 統一了 Product 的整個構建過程，同時在 build 過程中，可以由于 set 值順序不同等原因產生不同的效果。
實現示例代碼：
假定需要生成一個虛擬的人物模型，人物主要包括幾個簡單的屬性：姓名、年齡、國籍以及膚色。假如一個數據模型的擁有很多屬性，如果單純使用構造方法來實例化對象，勢必會造成構造方法參數爆炸的問題，也可以稱之為“反可伸縮構造方法模式”。代碼的可讀性和可靠性大大降低。此時，可以為這個對象創建的過程指定一個創建者，我們只需要向創建者描述該對象的一些具體細節，接下來的構造過程就統統交給創建者完成了。
/**
?*國籍
?*/
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();
? }
? /**
?? *創建者
?? */
? 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());
? }
}
