面向?qū)ο蠛驮O(shè)計模式(2)-- 設(shè)計模式之創(chuàng)建型

面向?qū)ο蟮幕驹O(shè)計原則(SOLID):

單一職責(zé)(Single Responsibility),類或者對象最好是只有單一職責(zé),在程序設(shè)計中如果發(fā)現(xiàn)某個類承擔(dā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)編程。

合成復(fù)用原則(Composite Reuse Principle, CRP):復(fù)用時要盡量使用組合/聚合關(guān)系(關(guān)聯(lián)關(guān)系),少用繼承。

迪米特法則(Law of Demeter, LoD):一個軟件實體應(yīng)當(dā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)型模式,共七種:適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。

行為型模式,共十一種:策略模式、模板方法模式、觀察者模式、迭代子模式、責(zé)任鏈模式、命令模式、備忘錄模式、狀態(tài)模式、訪問者模式、中介者模式、解釋器模式。

創(chuàng)建型:

1)單例模式( Singleton )

??????? 保證一個類僅有一個實例,并提供一個訪問它的全局控制點。讓類自身負責(zé)保存它的唯一實例。 這個類可以保證沒有其他實例可以被創(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ù)。可見性要更加復(fù)雜一些,

?*它必須確保釋放鎖之前對共享數(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) {

??????? // 再次將實例分配給局部變量,檢查它是否被其他線程初始化

??????? // 在當(dāng)前線程被阻塞進入鎖定區(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 )

??????? 將一個復(fù)雜對象的構(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());

? }

}

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點,簡書系信息發(fā)布平臺,僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容