一、简单工厂模式

二、工厂方法模式

三、抽象工厂模式

四、总结

工厂模式分为简单工厂模式，工厂方法模式和抽象工厂模式，它们都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来，目的是降低系统中代码耦合度，并且增强了系统的扩展性。本文对这三种模式进行介绍并且分析它们之间的区别。

一、简单工厂模式

1、定义：简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

2、实质：简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。其UML结构图如下所示：

3、优缺点

优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个系统结构的优化。
缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利。

4、使用场景

工厂类负责创建的对象比较少；
客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用

5、实现

下面就以披萨连锁店为例使用简单工厂模式。UML结构图如下：

（1）披萨店类

public class PizzaStore {SimplePizzaFactory factory;public PizzaStore(SimplePizzaFactory factory) { this.factory = factory;}public Pizza orderPizza(String type) {Pizza pizza;pizza = factory.createPizza(type);pizza.prepare();pizza.bake();pizza.cut();pizza.box();return pizza;}}

（2）披萨简单工厂类

public class SimplePizzaFactory {public Pizza createPizza(String type) {Pizza pizza = null;if (type.equals("cheese")) {pizza = new CheesePizza();} else if (type.equals("pepperoni")) {pizza = new PepperoniPizza();} else if (type.equals("clam")) {pizza = new ClamPizza();} else if (type.equals("veggie")) {pizza = new VeggiePizza();}return pizza;}
}

（3）披萨抽象类

abstract public class Pizza {String name;String dough;String sauce;ArrayList<String> toppings = new ArrayList<String>();public String getName() {return name;}public void prepare() {System.out.println("Preparing " + name);}public void bake() {System.out.println("Baking " + name);}public void cut() {System.out.println("Cutting " + name);}public void box() {System.out.println("Boxing " + name);}public String toString() {// code to display pizza name and ingredientsStringBuffer display = new StringBuffer();display.append("---- " + name + " ----\n");display.append(dough + "\n");display.append(sauce + "\n");for (String topping : toppings) {display.append(topping + "\n");}return display.toString();}
}

（4）具体的披萨子类

public class CheesePizza extends Pizza {public CheesePizza() {name = "Cheese Pizza";dough = "Regular Crust";sauce = "Marinara Pizza Sauce";toppings.add("Fresh Mozzarella");toppings.add("Parmesan");}
}

public class VeggiePizza extends Pizza {public VeggiePizza() {name = "Veggie Pizza";dough = "Crust";sauce = "Marinara sauce";toppings.add("Shredded mozzarella");toppings.add("Grated parmesan");toppings.add("Diced onion");toppings.add("Sliced mushrooms");toppings.add("Sliced red pepper");toppings.add("Sliced black olives");}
}

public class ClamPizza extends Pizza {public ClamPizza() {name = "Clam Pizza";dough = "Thin crust";sauce = "White garlic sauce";toppings.add("Clams");toppings.add("Grated parmesan cheese");}
}

public class PepperoniPizza extends Pizza {public PepperoniPizza() {name = "Pepperoni Pizza";dough = "Crust";sauce = "Marinara sauce";toppings.add("Sliced Pepperoni");toppings.add("Sliced Onion");toppings.add("Grated parmesan cheese");}
}

（5）测试

public class PizzaTestDrive {public static void main(String[] args) {SimplePizzaFactory factory = new SimplePizzaFactory();PizzaStore store = new PizzaStore(factory);Pizza pizza = store.orderPizza("cheese");System.out.println("We ordered a " + pizza.getName() + "\n");System.out.println(pizza);pizza = store.orderPizza("veggie");System.out.println("We ordered a " + pizza.getName() + "\n");System.out.println(pizza);}
}

运行结果：

二、工厂方法模式

1、定义：工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

2、实质：此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品。其UML结构图如下所示：

3、优点：核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，使系统的扩展性变得很好，符合面向对象编程的开闭原则。

4、使用场景

对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况；
只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的

5、实现

下面就以披萨连锁店为例使用工厂方法模式。UML结构图如下：

（1）披萨店抽象类

public abstract class PizzaStore {abstract Pizza createPizza(String item);public Pizza orderPizza(String type) {Pizza pizza = createPizza(type);System.out.println("--- Making a " + pizza.getName() + " ---");pizza.prepare();pizza.bake();pizza.cut();pizza.box();return pizza;}
}

（2）披萨抽象类

public abstract class Pizza {String name;String dough;String sauce;ArrayList<String> toppings = new ArrayList<String>();void prepare() {System.out.println("Prepare " + name);System.out.println("Tossing dough...");System.out.println("Adding sauce...");System.out.println("Adding toppings: ");for (String topping : toppings) {System.out.println("   " + topping);}}void bake() {System.out.println("Bake for 25 minutes at 350");}void cut() {System.out.println("Cut the pizza into diagonal slices");}void box() {System.out.println("Place pizza in official PizzaStore box");}public String getName() {return name;}public String toString() {StringBuffer display = new StringBuffer();display.append("---- " + name + " ----\n");display.append(dough + "\n");display.append(sauce + "\n");for (String topping : toppings) {display.append(topping + "\n");}return display.toString();}
}

（3）具体的披萨店子类

public class NYPizzaStore extends PizzaStore {Pizza createPizza(String item) {if (item.equals("cheese")) {return new NYStyleCheesePizza();} else if (item.equals("veggie")) {return new NYStyleVeggiePizza();} else if (item.equals("clam")) {return new NYStyleClamPizza();} else if (item.equals("pepperoni")) {return new NYStylePepperoniPizza();} else return null;}
}

public class ChicagoPizzaStore extends PizzaStore {Pizza createPizza(String item) {if (item.equals("cheese")) {return new ChicagoStyleCheesePizza();} else if (item.equals("veggie")) {return new ChicagoStyleVeggiePizza();} else if (item.equals("clam")) {return new ChicagoStyleClamPizza();} else if (item.equals("pepperoni")) {return new ChicagoStylePepperoniPizza();} else return null;}
}

（4）具体的披萨子类

①纽约分店风格

public class NYStyleCheesePizza extends Pizza {public NYStyleCheesePizza() { name = "NY Style Sauce and Cheese Pizza";dough = "Thin Crust Dough";sauce = "Marinara Sauce";toppings.add("Grated Reggiano Cheese");}
}

public class NYStyleClamPizza extends Pizza {public NYStyleClamPizza() {name = "NY Style Clam Pizza";dough = "Thin Crust Dough";sauce = "Marinara Sauce";toppings.add("Grated Reggiano Cheese");toppings.add("Fresh Clams from Long Island Sound");}
}

public class NYStylePepperoniPizza extends Pizza {public NYStylePepperoniPizza() {name = "NY Style Pepperoni Pizza";dough = "Thin Crust Dough";sauce = "Marinara Sauce";toppings.add("Grated Reggiano Cheese");toppings.add("Sliced Pepperoni");toppings.add("Garlic");toppings.add("Onion");toppings.add("Mushrooms");toppings.add("Red Pepper");}
}

public class NYStyleVeggiePizza extends Pizza {public NYStyleVeggiePizza() {name = "NY Style Veggie Pizza";dough = "Thin Crust Dough";sauce = "Marinara Sauce";toppings.add("Grated Reggiano Cheese");toppings.add("Garlic");toppings.add("Onion");toppings.add("Mushrooms");toppings.add("Red Pepper");}
}

②芝加哥分店风格

public class ChicagoStyleCheesePizza extends Pizza {public ChicagoStyleCheesePizza() { name = "Chicago Style Deep Dish Cheese Pizza";dough = "Extra Thick Crust Dough";sauce = "Plum Tomato Sauce";toppings.add("Shredded Mozzarella Cheese");}void cut() {System.out.println("Cutting the pizza into square slices");}
}

public class ChicagoStyleClamPizza extends Pizza {public ChicagoStyleClamPizza() {name = "Chicago Style Clam Pizza";dough = "Extra Thick Crust Dough";sauce = "Plum Tomato Sauce";toppings.add("Shredded Mozzarella Cheese");toppings.add("Frozen Clams from Chesapeake Bay");}void cut() {System.out.println("Cutting the pizza into square slices");}
}

public class ChicagoStylePepperoniPizza extends Pizza {public ChicagoStylePepperoniPizza() {name = "Chicago Style Pepperoni Pizza";dough = "Extra Thick Crust Dough";sauce = "Plum Tomato Sauce";toppings.add("Shredded Mozzarella Cheese");toppings.add("Black Olives");toppings.add("Spinach");toppings.add("Eggplant");toppings.add("Sliced Pepperoni");}void cut() {System.out.println("Cutting the pizza into square slices");}
}

public class ChicagoStyleVeggiePizza extends Pizza {public ChicagoStyleVeggiePizza() {name = "Chicago Deep Dish Veggie Pizza";dough = "Extra Thick Crust Dough";sauce = "Plum Tomato Sauce";toppings.add("Shredded Mozzarella Cheese");toppings.add("Black Olives");toppings.add("Spinach");toppings.add("Eggplant");}void cut() {System.out.println("Cutting the pizza into square slices");}
}

（5）测试

public class PizzaTestDrive {public static void main(String[] args) {PizzaStore nyStore = new NYPizzaStore();PizzaStore chicagoStore = new ChicagoPizzaStore();Pizza pizza = nyStore.orderPizza("cheese");System.out.println("Ethan ordered a " + pizza.getName() + "\n");pizza = chicagoStore.orderPizza("cheese");System.out.println("Joel ordered a " + pizza.getName() + "\n");pizza = nyStore.orderPizza("clam");System.out.println("Ethan ordered a " + pizza.getName() + "\n");pizza = chicagoStore.orderPizza("clam");System.out.println("Joel ordered a " + pizza.getName() + "\n");}
}

运行结果：

三、抽象工厂模式

1、定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。抽象工厂模式中存在四种角色，分别是抽象工厂角色，具体工厂角色，抽象产品角色，具体产品角色。其UML结构图如下所示：

2、功能：主要功能是它能够隔离要生成的具体产品类，由于这些类的实际类名被隐藏在工厂内部，因此客户端根本不需要关心如何对它们进行实例化的细节。每种设计模式都是针对特定问题的解决方案，而抽象工厂模式面临的问题则是当涉及到有多个产品等级结构寸，如何更好地进行软件体系结构的设计。

3、优缺点

（1）优点：

分离了具体的类。客户通过抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中。
易于交换产品系列。一个具体工厂类只在初始化时出现一次，这使得改变一个应用的具体工厂变得很容易，只需改变具体的工厂即可使用不同的产品配置。
有利于产品的一致性。当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要，而抽象工厂很容易实现这一点。

（2）缺点：难以支持新种类的产品。因为抽象工厂接口确定了可以被创建的产品集合，所以难以扩展抽象工厂以生产新种类的产品。

4、适用场景

一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
需要强调一系列相关的产品对象的设计以便进行联合使用时。
提供一个产品类库，而只想显示它们的接口而不是实现时。

5、实现

下面就以披萨连锁店为例使用工厂方法模式。UML结构图如下：

（1）披萨原料工厂接口

public interface PizzaIngredientFactory {public Dough createDough();public Sauce createSauce();public Cheese createCheese();public Veggies[] createVeggies();public Pepperoni createPepperoni();public Clams createClam();}

（2）披萨原料接口

public interface Dough {public String toString();
}

public interface Sauce {public String toString();
}

public interface Cheese {public String toString();
}

public interface Veggies {public String toString();
}

public interface Pepperoni {public String toString();
}

public interface Clams {public String toString();
}

（3）披萨店抽象类

public abstract class PizzaStore {protected abstract Pizza createPizza(String item);public Pizza orderPizza(String type) {Pizza pizza = createPizza(type);System.out.println("--- Making a " + pizza.getName() + " ---");pizza.prepare();pizza.bake();pizza.cut();pizza.box();return pizza;}
}

（4）具体的披萨店子类

public class NYPizzaStore extends PizzaStore {protected Pizza createPizza(String item) {Pizza pizza = null;PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();if (item.equals("cheese")) {pizza = new CheesePizza(ingredientFactory);pizza.setName("New York Style Cheese Pizza");} else if (item.equals("veggie")) {pizza = new VeggiePizza(ingredientFactory);pizza.setName("New York Style Veggie Pizza");} else if (item.equals("clam")) {pizza = new ClamPizza(ingredientFactory);pizza.setName("New York Style Clam Pizza");} else if (item.equals("pepperoni")) {pizza = new PepperoniPizza(ingredientFactory);pizza.setName("New York Style Pepperoni Pizza");} return pizza;}
}

public class ChicagoPizzaStore extends PizzaStore {protected Pizza createPizza(String item) {Pizza pizza = null;PizzaIngredientFactory ingredientFactory =new ChicagoPizzaIngredientFactory();if (item.equals("cheese")) {pizza = new CheesePizza(ingredientFactory);pizza.setName("Chicago Style Cheese Pizza");} else if (item.equals("veggie")) {pizza = new VeggiePizza(ingredientFactory);pizza.setName("Chicago Style Veggie Pizza");} else if (item.equals("clam")) {pizza = new ClamPizza(ingredientFactory);pizza.setName("Chicago Style Clam Pizza");} else if (item.equals("pepperoni")) {pizza = new PepperoniPizza(ingredientFactory);pizza.setName("Chicago Style Pepperoni Pizza");}return pizza;}
}

（5）具体的披萨原料工厂

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {public Dough createDough() {return new ThinCrustDough();}public Sauce createSauce() {return new MarinaraSauce();}public Cheese createCheese() {return new ReggianoCheese();}public Veggies[] createVeggies() {Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };return veggies;}public Pepperoni createPepperoni() {return new SlicedPepperoni();}public Clams createClam() {return new FreshClams();}
}

public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {public Dough createDough() {return new ThickCrustDough();}public Sauce createSauce() {return new PlumTomatoSauce();}public Cheese createCheese() {return new MozzarellaCheese();}public Veggies[] createVeggies() {Veggies veggies[] = { new BlackOlives(), new Spinach(), new Eggplant() };return veggies;}public Pepperoni createPepperoni() {return new SlicedPepperoni();}public Clams createClam() {return new FrozenClams();}
}

（5）具体的披萨原料类

①dough

public class ThickCrustDough implements Dough {public String toString() {return "ThickCrust style extra thick crust dough";}
}

public class ThinCrustDough implements Dough {public String toString() {return "Thin Crust Dough";}
}

②sauce

public class PlumTomatoSauce implements Sauce {public String toString() {return "Tomato sauce with plum tomatoes";}
}

public class MarinaraSauce implements Sauce {public String toString() {return "Marinara Sauce";}
}

③cheese

public class MozzarellaCheese implements Cheese {public String toString() {return "Shredded Mozzarella";}
}

public class ReggianoCheese implements Cheese {public String toString() {return "Reggiano Cheese";}
}

public class ParmesanCheese implements Cheese {public String toString() {return "Shredded Parmesan";}
}

④veggies

public class BlackOlives implements Veggies {public String toString() {return "Black Olives";}
}

public class Garlic implements Veggies {public String toString() {return "Garlic";}
}

public class Eggplant implements Veggies {public String toString() {return "Eggplant";}
}

public class Mushroom implements Veggies {public String toString() {return "Mushrooms";}
}

public class Onion implements Veggies {public String toString() {return "Onion";}
}

public class RedPepper implements Veggies {public String toString() {return "Red Pepper";}
}

public class Spinach implements Veggies {public String toString() {return "Spinach";}
}

⑤pepproni

public class SlicedPepperoni implements Pepperoni {public String toString() {return "Sliced Pepperoni";}
}

⑥clams

public class FreshClams implements Clams {public String toString() {return "Fresh Clams from Long Island Sound";}
}

public class FrozenClams implements Clams {public String toString() {return "Frozen Clams from Chesapeake Bay";}
}

（6）披萨抽象类

public abstract class Pizza {String name;Dough dough;Sauce sauce;Veggies veggies[];Cheese cheese;Pepperoni pepperoni;Clams clam;abstract void prepare();void bake() {System.out.println("Bake for 25 minutes at 350");}void cut() {System.out.println("Cutting the pizza into diagonal slices");}void box() {System.out.println("Place pizza in official PizzaStore box");}void setName(String name) {this.name = name;}String getName() {return name;}public String toString() {StringBuffer result = new StringBuffer();result.append("---- " + name + " ----\n");if (dough != null) {result.append(dough);result.append("\n");}if (sauce != null) {result.append(sauce);result.append("\n");}if (cheese != null) {result.append(cheese);result.append("\n");}if (veggies != null) {for (int i = 0; i < veggies.length; i++) {result.append(veggies[i]);if (i < veggies.length-1) {result.append(", ");}}result.append("\n");}if (clam != null) {result.append(clam);result.append("\n");}if (pepperoni != null) {result.append(pepperoni);result.append("\n");}return result.toString();}
}

（7）具体的披萨子类

public class CheesePizza extends Pizza {PizzaIngredientFactory ingredientFactory;public CheesePizza(PizzaIngredientFactory ingredientFactory) {this.ingredientFactory = ingredientFactory;}void prepare() {System.out.println("Preparing " + name);dough = ingredientFactory.createDough();sauce = ingredientFactory.createSauce();cheese = ingredientFactory.createCheese();}
}

public class ClamPizza extends Pizza {PizzaIngredientFactory ingredientFactory;public ClamPizza(PizzaIngredientFactory ingredientFactory) {this.ingredientFactory = ingredientFactory;}void prepare() {System.out.println("Preparing " + name);dough = ingredientFactory.createDough();sauce = ingredientFactory.createSauce();cheese = ingredientFactory.createCheese();clam = ingredientFactory.createClam();}
}

public class PepperoniPizza extends Pizza {PizzaIngredientFactory ingredientFactory;public PepperoniPizza(PizzaIngredientFactory ingredientFactory) {this.ingredientFactory = ingredientFactory;}void prepare() {System.out.println("Preparing " + name);dough = ingredientFactory.createDough();sauce = ingredientFactory.createSauce();cheese = ingredientFactory.createCheese();veggies = ingredientFactory.createVeggies();pepperoni = ingredientFactory.createPepperoni();}
}

public class VeggiePizza extends Pizza {PizzaIngredientFactory ingredientFactory;public VeggiePizza(PizzaIngredientFactory ingredientFactory) {this.ingredientFactory = ingredientFactory;}void prepare() {System.out.println("Preparing " + name);dough = ingredientFactory.createDough();sauce = ingredientFactory.createSauce();cheese = ingredientFactory.createCheese();veggies = ingredientFactory.createVeggies();}
}

（8）测试

public class PizzaTestDrive {public static void main(String[] args) {PizzaStore nyStore = new NYPizzaStore();PizzaStore chicagoStore = new ChicagoPizzaStore();Pizza pizza = nyStore.orderPizza("cheese");System.out.println("Ethan ordered a " + pizza + "\n");pizza = chicagoStore.orderPizza("cheese");System.out.println("Joel ordered a " + pizza + "\n");pizza = nyStore.orderPizza("clam");System.out.println("Ethan ordered a " + pizza + "\n");pizza = chicagoStore.orderPizza("clam");System.out.println("Joel ordered a " + pizza + "\n");}
}

运行结果：

四、总结

1、三种工厂模式的简单对比

简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

2、工厂方法模式和抽象工厂模式的核心区别

工厂方法模式利用继承，抽象工厂模式利用组合
工厂方法模式产生一个对象，抽象工厂模式产生一族对象
工厂方法模式利用子类创造对象，抽象工厂模式利用接口的实现创造对象

《Head First 设计模式》之工厂模式（Factory）—— 披萨连锁店相关推荐

设计模式之工厂模式（披萨店案例）
设计模式之工厂模式(披萨店案例) 披萨类如下: import java.util.ArrayList;public abstract class Pizza {String name;String d ...
设计模式(四)——工厂模式(Factory Pattern)
工厂模式(Factory Pattern) 意义工厂模式实现了创建者和调用者的分离.将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦.从而提高项目的扩展和维护性 ...
设计模式之工厂模式(Factory)
设计模式之工厂模式设计模式之工厂模式简介代码准备需求一需求二简单工厂工厂方法抽象工厂需求三总结设计模式之工厂模式简介工厂顾名思义就是创建产品,根据产品是具体产品还是具体工厂可 ...
【设计模式】工厂模式 Factory Pattern
1)简单工厂(不是模式) 简单工厂只是一种变成习惯,并非23种设计模式之一. 简单工厂提供将实例话那种类型留给运行时判断,而非编译时指定.简单工厂模式就是由一个工厂类根据传入的参数决定创建出哪一个类的 ...
设计模式（一）工厂模式Factory（创建型）
设计模式一工厂模式Factory 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的.但是在一些情况下, new操作符直接生成对象会带来一些问题. ...
设计模式 - 学习笔记 - 工厂模式Factory Pattern
设计模式 - 学习笔记 - 工厂模式Factory Pattern 1. 简单工厂 1.1 应用场景 1.2 UML 1.3 优劣分析好处缺点 1.4 代码示例抽象产品 AbstractProd ...
【JAVA进阶系列】JAVA 设计模式 -- 抽象工厂模式(Abstract Factory)
[JAVA进阶系列]JAVA 设计模式 -- 抽象工厂模式(Abstract Factory) [1.1]抽象工厂模式简介抽象工厂者模式的类结构图 AbstractProduct(抽象产品),Abs ...
设计模式 ~ 创建型模式 ~ 工厂模式 ~ Factory Pattern。
设计模式 ~ 创建型模式 ~ 工厂模式 ~ Factory Pattern. 文章目录设计模式 ~ 创建型模式 ~ 工厂模式 ~ Factory Pattern. eg. 简单工厂模式. 结构. 优 ...
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
工厂模式 Factory Pattern(简单工厂.工厂方法.抽象工厂) 工厂模式-创建型模式-提供了创建对象的最佳方式. 在工厂模式中,创建对象时不会对客户端暴露创建逻辑,并且是通过一个共同的接口来 ...
设计模式之工厂模式（三）
上一次我们已经通过代码,简单的认识了工厂方法模式,具体的思路请移步到设计模式之工厂模式(二),进行查看.这次,让我们通过设计模式的思想,来好好认识下工厂方法模式. 创建者和产品所有工厂模式都用来封装 ...

《Head First 设计模式》之工厂模式（Factory）—— 披萨连锁店

一、简单工厂模式

二、工厂方法模式

三、抽象工厂模式

四、总结

《Head First 设计模式》之工厂模式（Factory）—— 披萨连锁店相关推荐

最新文章

热门文章