设计模式之工厂模式（Factory Pattern）

What:

工厂模式又称多态性工厂模式。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

Where:

1.创建对象需要大量重复代码； 2.客户端不关心实例如何被创建、实现的细节； 3.一个类通过子类来指定创建哪个对象。

Why:

优点：

1.一个调用者想创建一个对象，只要知道其名称就可以了。 2.扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以，而不需要改动先有的类，符合“开闭原则”。 3.屏蔽产品的具体实现，调用者只关心产品的接口。 4.每个具体工厂类只负责创建对应的产品，符合单一职责原则。

缺点：

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

How:

抽象工厂(Abstract Factory)角色： 是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

具体工厂(Concrete Factory)角色 ： 这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建某一种产品对象。

抽象产品(Abstract Product)角色 ： 工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

具体产品(Concrete Product)角色 ： 这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

示例：创建汽车工厂，根据需求获取不同品牌汽车。

CarFactory抽象类（抽象工厂）：

public abstract class CarFactory { abstract Car getCar(); }

BenzFactory类，AudiFactory类，BmwFactory类（具体工厂）：

public class BenzFactory extends CarFactory{ @Override Car getCar() { return new Benz(); } } public class AudiFactory extends CarFactory { @Override Car getCar() { return new Audi(); } } public class BmwFactory extends CarFactory { @Override Car getCar() { return new Bmw(); } }

Car类（抽象产品）：

public abstract class Car { public abstract void produce(); }

Audi类，Bmw类，Benz类（具体产品）：

public class Audi extends Car{ @Override public void produce() { System.out.println("制造奥迪..."); } } public class Bmw extends Car { @Override public void produce() { System.out.println("制造宝马..."); } } public class Benz extends Car { @Override public void produce() { System.out.println("制造奔驰..."); } }

Test：测试类

public class Test { public static void main(String[] args) { //制造奔驰 CarFactory benzFactory = new BenzFactory(); benzFactory.getCar().produce(); //制造宝马 CarFactory bmwFactory = new BmwFactory(); bmwFactory.getCar().produce(); //制造奥迪 CarFactory audiFactory = new AudiFactory(); audiFactory.getCar().produce(); } }

输出结果：

制造奔驰... 制造宝马... 制造奥迪...

示例代码的UML图：

工厂模式的特例：简单工厂模式

简单工厂模式看作为工厂方法模式的一种特例，两者归为一类。

与工厂模式不一样的是，简单工厂模式只有抽象产品类，具体产品类和一个工厂类。

示例：创建蛋糕工厂，根据客户端传的参数实例化相应的对象。

Cake类：

public abstract class Cake { abstract void produce(); }

DurianCake、StrawberryCake、ChocolateCake类：

public class DurianCake extends Cake { @Override void produce() { System.out.println("制作榴莲蛋糕..."); } } public class StrawberryCake extends Cake { @Override void produce() { System.out.println("制作草莓蛋糕..."); } } public class ChocolateCake extends Cake { @Override void produce() { System.out.println("制作巧克力蛋糕..."); } }

CakeFactory类：

public class CakeFactory { public Cake getCake(String cakeName) throws Exception { //第一种方式：通过if...else...语句判断 if ("榴莲蛋糕".equals(cakeName)) { return new DurianCake(); } else if ("草莓蛋糕".equals(cakeName)) { return new StrawberryCake(); } else if ("巧克力蛋糕".equals(cakeName)) { return new ChocolateCake(); } else { throw new Exception("输入有误，请重新输入！"); } //第二种方式：通过switch...case...判断 // switch (cakeName) { // case "榴莲蛋糕": // return new DurianCake(); // case "草莓蛋糕": // return new StrawberryCake(); // case "巧克力蛋糕": // return new ChocolateCake(); // default: // throw new Exception("输入有误，请重新输入！"); // } } //第三种方式：通过反射创建对象 // public Cake getCake(Class obj){ // Cake cake = null; // try { // cake = (Cake) Class.forName(obj.getName()).newInstance(); // } catch (InstantiationException e) { // e.printStackTrace(); // } catch (IllegalAccessException e) { // e.printStackTrace(); // } catch (ClassNotFoundException e) { // e.printStackTrace(); // } // return cake; // } }

Test类：

public class Test { public static void main(String[] args) throws Exception { //第一种、第二种方式的测试代码 String cakeName = "榴莲蛋糕"; CakeFactory cake = new CakeFactory(); cake.getCake(cakeName).produce(); //第三种的测试代码 // CakeFactory cakeFactory = new CakeFactory(); // cakeFactory.getCake(DurianCake.class).produce(); } }

输出结果：

制作榴莲蛋糕...

总结

工厂模式虽然遵守开闭原则，又保持了封装对象创建过程的优点，但工厂模式的缺点也是显而易见的，就是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。相对于工厂模式，简单工厂模式的优点是不用每个产品类都对应一个产品工厂类，简化开发流程，但是缺点是如果新增产品类就需要修改工厂类，违背开闭原则，不过可以通过反射机制解决这个问题。

了解更多设计模式：

设计模式系列