前文推送
設(shè)計模式
Kotlin基礎(chǔ)知識
1. 定義
抽象工廠模式(Abstract Factory Pattern):提供一個創(chuàng)建一系列相關(guān)或相互依賴對象的接口,而無須指定它們具體的類。抽象工廠模式又稱為Kit模式,屬于對象創(chuàng)建型模式。
2. 結(jié)構(gòu)
AbstractFactory:抽象工廠,定義創(chuàng)建實例的抽象方法;
ConcreteFactory:具體工廠,實現(xiàn)具體邏輯;
AbstractProduct:抽象產(chǎn)品,定義產(chǎn)品的抽象方法;
Product:具體產(chǎn)品,實現(xiàn)具體邏輯;
3. 代碼
3.1 Java
AbstractProductA與AbstractProductB:
1 abstract class AbstractProductA {2 abstract void printA();3 }4 5 abstract class AbstractProductB {6 abstract void printB();7 }
定義了兩個抽象產(chǎn)品角色,分別有抽象方法printA和printB。
ConcreteProductA1、ConcreteProductA2、ConcreteProductB1及ConcreteProductB2:
1 class ConcreteProductA1 extends AbstractProductA { 2 void printA() { 3 System.out.println("printA of ConcreteProductA1"); 4 } 5 } 6 7 class ConcreteProductA2 extends AbstractProductA { 8 void printA() { 9 System.out.println("printA of ConcreteProductA2");10 }11 }12 13 class ConcreteProductB1 extends AbstractProductB {14 void printB() {15 System.out.println("printB of ConcreteProductB1");16 }17 }18 19 class ConcreteProductB2 extends AbstractProductB {20 void printB() {21 System.out.println("printB of ConcreteProductB2");22 }23 }
定義了四個具體產(chǎn)品角色,分別實現(xiàn)了父類對應(yīng)的printA和printB方法。
A1和B1屬于同一個產(chǎn)品族的不同產(chǎn)品等級的兩種產(chǎn)品,A2和B2類似。其中:
產(chǎn)品等級——同一類產(chǎn)品的產(chǎn)品等級相同,如海爾冰箱、西門子冰箱等;
產(chǎn)品族——同一家工廠生產(chǎn)的不同產(chǎn)品等級的產(chǎn)品,如海爾冰箱、海爾洗衣機(jī)等。
AbstractFactory:
1 abstract class AbstractFactory {2 abstract AbstractProductA createProductA();3 abstract AbstractProductB createProductB();4 }
定義了抽象工廠角色,及抽象方法createProductA和createProductB。
ConcreteFactory1與ConcreteFactory2:
1 class ConcreteFactory1 extends AbstractFactory { 2 AbstractProductA createProductA() { 3 System.out.println("create ProductA1"); 4 5 return new ConcreteProductA1(); 6 } 7 8 AbstractProductB createProductB() { 9 System.out.println("create ProductB1");10 11 return new ConcreteProductB1();12 }13 }14 15 class ConcreteFactory2 extends AbstractFactory {16 AbstractProductA createProductA() {17 System.out.println("create ProductA2");18 19 return new ConcreteProductA2();20 }21 22 AbstractProductB createProductB() {23 System.out.println("create ProductB2");24 25 return new ConcreteProductB2();26 }27 }
定義了兩個具體工廠角色,分別實現(xiàn)了createProductA和createProductB方法。
AbstractFactoryPattern:
1 public class AbstractFactoryPattern { 2 public static void main(String[] args) { 3 System.out.println("Abstract Factory Pattern"); 4 5 AbstractFactory factory = new ConcreteFactory1(); 6 AbstractProductA productA = factory.createProductA(); 7 AbstractProductB productB = factory.createProductB(); 8 productA.printA(); 9 productB.printB();10 11 factory = new ConcreteFactory2();12 productA = factory.createProductA();13 productB = factory.createProductB();14 productA.printA();15 productB.printB();16 }17 }
不同產(chǎn)品族的具體產(chǎn)品實例,用不同的具體工廠來創(chuàng)建。
輸出:
3.2 Kotlin
AbstractProductA與AbstractProductB:
1 abstract class AbstractProductA {2 abstract fun printA()3 }4 5 abstract class AbstractProductB {6 abstract fun printB()7 }
ConcreteProductA1、ConcreteProductA2、ConcreteProductB1及ConcreteProductB2:
1 class ConcreteProductA1 : AbstractProductA() { 2 override fun printA() { 3 println("printA of ConcreteProductA1") 4 } 5 } 6 7 class ConcreteProductA2 : AbstractProductA() { 8 override fun printA() { 9 println("printA of ConcreteProductA2")10 }11 }12 13 class ConcreteProductB1 : AbstractProductB() {14 override fun printB() {15 println("printB of ConcreteProductB1")16 }17 }18 19 class ConcreteProductB2 : AbstractProductB() {20 override fun printB() {21 println("printB of ConcreteProductB2")22 }23 }
AbstractFactory:
1 abstract class AbstractFactory {2 abstract fun createProductA(): AbstractProductA3 abstract fun createProductB(): AbstractProductB4 }
ConcreteFactory1與ConcreteFactory2:
1 class ConcreteFactory1 : AbstractFactory() { 2 override fun createProductA(): AbstractProductA { 3 println("create ProductA1") 4 5 return ConcreteProductA1() 6 } 7 8 override fun createProductB(): AbstractProductB { 9 println("create ProductB1")10 11 return ConcreteProductB1()12 }13 }14 15 class ConcreteFactory2 : AbstractFactory() {16 override fun createProductA(): AbstractProductA {17 println("create ProductA2")18 19 return ConcreteProductA2()20 }21 22 override fun createProductB(): AbstractProductB {23 println("create ProductB2")24 25 return ConcreteProductB2()26 }27 }
AbstractFactoryPattern:
1 fun main(args: Array<String>) { 2 println("Abstract Factory Pattern") 3 4 var factory: AbstractFactory = ConcreteFactory1() 5 var productA = factory.createProductA() 6 var productB = factory.createProductB() 7 productA.printA() 8 productB.printB() 9 10 factory = ConcreteFactory2()11 productA = factory.createProductA()12 productB = factory.createProductB()13 productA.printA()14 productB.printB()15 }
輸出同上。
4. 優(yōu)缺點
4.1 優(yōu)點
抽象工廠模式隔離了具體類的生成,使得客戶并不需要知道什么被創(chuàng)建。由于這種隔離,更換一個具體工廠就變得相對容易。所有的具體工廠都實現(xiàn)了抽象工廠中定義的那些公共接口,因此只需改變具體工廠的實例,就可以在某種程度上改變整個軟件系統(tǒng)的行為。另外,應(yīng)用抽象工廠模式可以實現(xiàn)高內(nèi)聚低耦合的設(shè)計目的,因此抽象工廠模式得到了廣泛的應(yīng)用;
當(dāng)一個產(chǎn)品族中的多個對象被設(shè)計成一起工作時,它能夠保證客戶端始終只使用同一個產(chǎn)品族中的對象。這對一些需要根據(jù)當(dāng)前環(huán)境來決定其行為的軟件系統(tǒng)來說,是一種非常實用的設(shè)計模式;
增加新的具體工廠和產(chǎn)品族很方便,無須修改已有系統(tǒng),符合“開閉原則”。
4.2 缺點
在添加新的產(chǎn)品對象時,難以擴(kuò)展抽象工廠來生產(chǎn)新種類的產(chǎn)品,這是因為在抽象工廠角色中規(guī)定了所有可能被創(chuàng)建的產(chǎn)品集合,要支持新種類的產(chǎn)品就意味著要對該接口進(jìn)行擴(kuò)展,而這將涉及到對抽象工廠角色及其所有子類的修改,顯然會帶來較大的不便;
開閉原則的傾斜性(增加新的工廠和產(chǎn)品族容易,增加新的產(chǎn)品等級結(jié)構(gòu)麻煩)。
5. 適用場景
一個系統(tǒng)不應(yīng)當(dāng)依賴于產(chǎn)品類實例如何被創(chuàng)建、組合和表達(dá)的細(xì)節(jié),這對于所有類型的工廠模式都是重要的;
系統(tǒng)中有多于一個的產(chǎn)品族,而每次只使用其中某一產(chǎn)品族;
屬于同一個產(chǎn)品族的產(chǎn)品將在一起使用,這一約束必須在系統(tǒng)的設(shè)計中體現(xiàn)出來;
系統(tǒng)提供一個產(chǎn)品類的庫,所有的產(chǎn)品以同樣的接口出現(xiàn),從而使客戶端不依賴于具體實現(xiàn)。
不要讓青春留下太多遺憾,專注
http://www.cnblogs.com/tgyf/p/7105561.html