企业官网建设流程全解析

常见设计模式-创建型模式-简单工厂模式，工厂方法模式，抽象工厂模式

简单工厂模式

简单工厂模式不是设计模式，更像是一种编程习惯

举一个例子我们来感受一下简单工厂：
简单工厂
抽象父类Coffee

publicabstractclassCoffee{publicabstractStringgetName();publicvoidaddSuger(){System.out.println("添加糖");}publicvoidaddMilk(){System.out.println("添加牛奶");}}

Coffee子类AmericanCoffee

publicclassAmericanCoffeeextendsCoffee{@OverridepublicStringgetName(){return"美式咖啡";}}

Coffee子类LatteCoffee

publicclassLatteCoffeeextendsCoffee{@OverridepublicStringgetName(){return"拿铁咖啡";}}

咖啡店CoffeeStore，具有点咖啡功能，创建简单工厂对象生产咖啡，使咖啡店和咖啡解耦

publicclassCoffeeStore{publicCoffeeOrderCoffee(Stringtype){SimpleCoffeeFactorysimpleCoffeeFactory=newSimpleCoffeeFactory();Coffeecoffee=simpleCoffeeFactory.createCoffee(type);coffee.addMilk();coffee.addSuger();returncoffee;}}

简单工厂，这里没有对应咖啡就抛异常

publicclassSimpleCoffeeFactory{publicCoffeecreateCoffee(Stringtype){Coffeecoffee=null;if("AmericanCoffee".equals(type)){coffee=newAmericanCoffee();}elseif("LatteCoffee".equals(type)){coffee=newLatteCoffee();}else{thrownewRuntimeException("没有这个咖啡");}returncoffee;}}

运行

publicclassClient{publicstaticvoidmain(String[]args){CoffeeStorecoffeeStore=newCoffeeStore();Coffeecoffee=coffeeStore.OrderCoffee("LatteCoffee");System.out.println(coffee.getName());}}

静态工厂
将简单工厂的功能（生产）定义为静态方法

publicclassSimpleCoffeeFactory{publicstaticCoffeecreateCoffee(Stringtype){Coffeecoffee=null;if("AmericanCoffee".equals(type)){coffee=newAmericanCoffee();}elseif("LatteCoffee".equals(type)){coffee=newLatteCoffee();}else{thrownewRuntimeException("没有这个咖啡");}returncoffee;}}

Coffee直接调用简单工厂的静态方法

publicclassCoffeeStore{publicCoffeeOrderCoffee(Stringtype){Coffeecoffee=SimpleCoffeeFactory.createCoffee(type);coffee.addMilk();coffee.addSuger();returncoffee;}}

简单工厂使咖啡店和咖啡解耦（咖啡店不必自己生产咖啡，使用简单工厂的功能实现即可）（若咖啡店要自己生产咖啡，每有一种新咖啡就必须修改咖啡店的源代码，这样违背了开闭原则这是我们不想要的），但是简单工厂和咖啡又产生了新的耦合，后续有新的咖啡子类需要更改简单工厂里的代码，也违背了开闭原则。

开闭原则：对扩展开放，对修改关闭。

工厂方法模式

工厂方法模式完全遵循开闭原则

定义一个工厂父类（接口），将产品实例化延迟到子类工厂中（子类工厂继承父类工厂，具体产品由具体产品对应子类工厂生产，若有新产品只需添加对应子类工厂，这样不必修改源代码，只需扩展代码，符合开闭原则）

Coffee类,AmericanCoffee类,Latte类不变

先创建父类工厂（接口）

publicinterfaceCoffeeFactory{CoffeecreateCoffee();}

再创建子类工厂
AmericanCoffeeFactory

publicclassAmericanCoffeeFactoryimplementsCoffeeFactory{@OverridepublicCoffeecreateCoffee(){returnnewAmericanCoffee();}}

LatteCoffeeFactory

publicclassLatteCoffeeFactoryimplementsCoffeeFactory{@OverridepublicCoffeecreateCoffee(){returnnewLatteCoffee();}}

CoffeeStore利用多态

publicclassCoffeeStore{CoffeeFactoryfactory=null;publicCoffeeStore(CoffeeFactoryfactory){this.factory=factory;}publicCoffeeOrderCoffee(){Coffeecoffee=factory.createCoffee();coffee.addSuger();coffee.addMilk();returncoffee;}}

运行

publicclassClient{publicstaticvoidmain(String[]args){AmericanCoffeeFactoryamericanCoffeeFactory=newAmericanCoffeeFactory();CoffeeStorecoffeeStore=newCoffeeStore(americanCoffeeFactory);Coffeecoffee=coffeeStore.OrderCoffee();System.out.println(coffee.getName());}}

工厂方法模式，有新的咖啡只需要创建对应咖啡工厂（继承工厂父类），让子类工厂实例化对象，这样不需要修改原本代码就可以添加产品，符合开闭原则；
但每增加新的产品都需要增加一个具体产品类和一个对应具体工厂，增加了系统复杂度

抽象工厂模式

首先了解一下产品族和产品级的概念：

例如，麦当当既有麦当当汉堡，也有麦当当薯条，肯基基既有肯基基汉堡，也肯基基薯条，其中麦当当的产品（麦当当的汉堡和薯条）属于同一产品族，而麦当当的汉堡和肯基基的汉堡属于同一产品级；

工厂方法模式只生产同一级产品，而抽象工厂模式可以生产多个等级的产品。

这里以麦当当和肯基基生产快餐为例（汉堡，薯条，饮品）：

不管哪家店，它们卖的东西都得符合平台标准：

//抽象产品 汉堡interfaceHamburger{voideat();}//抽象产品 薯条interfaceChips{voideat();}//抽象产品 饮品interfaceCola{voiddrink();}

麦当当生产麦当当巨无霸、麦当当薯条、麦当当冰可乐：

classMddHamburgerimplementsHamburger{publicvoideat(){System.out.println("吃麦当当巨无霸");}}classMddChipsimplementsChips{publicvoideat(){System.out.println("吃麦当当薯条");}}classMddColaimplementsCola{publicvoiddrink(){System.out.println("喝麦当当冰可乐");}}

肯基基生产肯基基香辣鸡腿堡、肯基基薯条、肯基基冰可乐：

classKjjHamburgerimplementsHamburger{publicvoideat(){System.out.println("吃肯基基香辣鸡腿堡");}}classKjjChipsimplementsChips{publicvoideat(){System.out.println("吃肯基基薯条");}}classKjjColaimplementsCola{publicvoiddrink(){System.out.println("喝肯基基冰可乐");}}

平台规定：凡是入驻的商家，必须能提供一整套（汉堡+薯条+饮品）：

//抽象工厂interfaceFactory{HamburgercreateHamburger();//提供汉堡ChipscreateChips();//提供薯条ColacreateCola();//提供饮品}

麦当当工厂，体现了多态

classMddFactoryimplementsFactory{publicHamburgercreateHamburger(){returnnewMddHamburger();}publicChipscreateChips(){returnnewMddChips();}publicColacreateCola(){returnnewMddCola();}}

肯基基工厂，体现了多态

classKjjFactoryimplementsFactory{publicHamburgercreateHamburger(){returnnewKjjHamburger();}publicChipscreateChips(){returnnewKjjChips();}publicColacreateCola(){returnnewKjjCola();}}

顾客点单（main方法是程序主入口）

publicclassCustomer{//声明工厂，顾客点餐时再选择具体工厂privateFactoryfactory;//利用构造方法注入具体工厂//进店扫码后，系统会注入了对应的工厂（麦当当或肯基基）publicCustomer(Factoryfactory){this.factory=factory;}publicvoidorderFan(){//不管你在哪家店，点餐流程都是一模一样的//生产套餐中...Hamburgerhamburger=factory.createHamburger();Chipschips=factory.createChips();Colacola=factory.createCola();System.out.println("您的套餐已出餐：");hamburger.eat();chips.eat();cola.drink();}//main方法，程序主入口publicstaticvoidmain(String[]args){//顾客选择具体工厂Factoryfactory=newMddFactory();Customercustomer=newCustomer(factory);customer.orderFan();}}

总结

以上就是本期要讲的内容，本文介绍了简单工厂模式，工厂方法模式，抽象工厂模式，其他常见设计模式在本系列其他文章，有兴趣可了解