设计模式之工厂模式 设计模式工厂模式案例

在程序中类是表示客观世界存在的某类群体的一些基本特征的抽象，对象就是一个个具体的东西，也可以理解为类的一个具体实例。

工厂模式属于创建型模式，它提供一种创建对象的方式。

单一职责原则要求：类的职责要单一，不能将太多的职责放在一个类中，也就是一个接口或者类只能有一个职责。

拿一个对象来说，他有哪些职责呢？

1、本身职责：对象本身具有的属性和行为

2、创建职责：创建这个对象的职责

3、使用职责：使用这个对象的职责

我们一般写程序，客户端会把创建职责和使用职责耦合在一起。

工厂模式就是把对象的创建过程独立，与对象的使用过程解耦。

在实际项目过程中，不是说遇到对象创建我们就要使用工厂模式，需要生成复杂对象的时候，适合使用工厂模式；而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式，使用工厂模式，会增加系统的复杂度。

工厂模式有三种，分别是简单工厂模式，工厂方法模式，抽象工厂模式。

下面用一个汽车的例子分别进行说明，假设有奥迪，宝马，奔驰3种车型。

它们的类图如下：

示例代码：

/**

* 车的接口

*/

public interface ICar {

public abstract String run(); //奔跑

}

public class Audi implements ICar {

@Override

public String run() {

return "奥迪在跑，突破科技，启迪未来！";

}

}

public class Bmw implements ICar {

@Override

public String run() {

return "宝马车跑，无处不担当！";

}

}

public class Benz implements ICar {

@Override

public String run() {

return "奔驰在跑，心所向，驰以恒!";

}

}

1

简单工厂模式示例

把对象的创建集中到一个工厂类里，通过判断不同的配置进行不同对象的创建。

优点：类的构造方法改变时，只需要修改简单工厂类即可，客户端调用处不需要修改。

缺点：客户端需要了解工厂类的具体实现，如果配置错误，客户端则得不到想要的对象。

示例代码：

/**

* 简单工厂模式

*/

public class SimpleFactory {

public ICar getCar(String className) {

ICar car = null;

if ("Audi".equals(className)) {

car = new Audi();

} else if ("Bmw".equals(className)) {

car = new Bmw();

} else if ("Benz".equals(className)) {

car = new Benz();

}

return car;

}

}

/**

* 测试简单工厂

*/

public class TestSimpleFactory {

public static void main(String[] args) {

SimpleFactory carFactory = new SimpleFactory();

ICar audi = carFactory.getCar("Audi");

System.out.println(audi.run());

ICar bmw = carFactory.getCar("Bmw");

System.out.println(bmw.run());

ICar benz = carFactory.getCar("Benz");

System.out.println(benz.run());

}

}

运行结果：

奥迪在跑，突破科技，启迪未来！

宝马在跑，无处不担当！

奔驰在跑，心所向，驰以恒!

2

工厂方法模式

有一个工厂的接口，用于生成对象，每个对象的实际生成放到自己的工厂类中。

优点：对象的创建过程发生变化时，只需要修改它自己的工厂类即可，不对其他类产生影响，符合开闭原则。

缺点：每有一个类，就需要一个工厂类，对于简单对象的创建，反而更复杂了。

类图：

示例代码：

/**

* 工厂接口类

*/

public interface ICarFactory {

public abstract ICar getCar();

}

/**

* Audi工厂，创建Audi对象

*/

public class AudiFactory implements ICarFactory {

@Override

public ICar getCar() {

return new Audi();

}

}

/**

* Bmw工厂，创建Bmw对象

*/

public class BmwFactory implements ICarFactory {

@Override

public ICar getCar() {

return new Bmw();

}

}

/**

* Benz工厂，创建Benz对象

*/

public class BenzFactory implements ICarFactory {

@Override

public ICar getCar() {

return new Benz();

}

}

/**

* 测试工厂方法模式

*/

public class TestFactory {

public static void main(String[] args) {

ICarFactory audiFactory = new AudiFactory();

System.out.println(audiFactory.getCar().run());

ICarFactory bmwFactory = new BmwFactory();

System.out.println(bmwFactory.getCar().run());

ICarFactory benzFactory = new BenzFactory();

System.out.println(benzFactory.getCar().run());

}

}

运行结果：

奥迪在跑，突破科技，启迪未来！

宝马在跑，无处不担当！

奔驰在跑，心所向，驰以恒!

3

抽象工厂模式

使用抽象类封装创建对象的方法，具体工厂类继承抽象类，并实现具体的创建过程。

优点：抽象类可以写逻辑，把公共的逻辑放到抽象类里，便于管理。

缺点：如果抽象类有多个实现类，那么对抽象类里新增其他抽象方法或删除抽象方法时，实现类也要跟着改动，违背开闭原则。

使用抽象工厂模式的好处是，增加新功能的时候，用户直接可以选择，想用就用，不用也可以。类似于API升级，API方法新增了，用户可以调用，也可以不调用。

类图：

示例代码：

/**

* 抽象汽车工厂

*/

public abstract class AbstractCarFactory {

/**

* 创建Audi对象

*/

public abstract ICar getAudi();

/**

* 创建Bmw对象

*/

public abstract ICar getBmw();

/**

* 创建Benz对象

*/

public abstract ICar getBenz();

}

/**

* 具体汽车工厂

*/

public class CarFactory extends AbstractCarFactory {

@Override

public ICar getAudi() {

return new Audi();

}

@Override

public ICar getBmw() {

return new Bmw();

}

@Override

public ICar getBenz() {

return new Benz();

}

}

/**

* 测试抽象工厂模式

*/

public class TestAbstractFactory {

public static void main(String[] args) {

CarFactory carFarctory = new CarFactory();

System.out.println(carFarctory.getAudi().run());

System.out.println(carFarctory.getBmw().run());

System.out.println(carFarctory.getBenz().run());

}

}

运行结果：

奥迪在跑，突破科技，启迪未来！

宝马在跑，无处不担当！

奔驰在跑，心所向，驰以恒!

抽象类和接口的区别：

1、接口不能写逻辑

2、抽象类可以写逻辑，除了接口方法，还可以写普通公共方法。

4

结束语

工厂模式是设计模式中的创建型模式，它是用来创建对象的，工厂模式一般有三种：

1、简单工厂模式

2、工厂方法模式

3、抽象工厂模式

当我们创建一个对象的时候，构造方法里需要传入参数的时候，一般就要考虑是否选用工厂模式，选用哪种工厂模式了。

运用工厂模式的好处就是当你构造方法参数变化的时候，使用工厂模式后，修改起来非常简单，只需要修改工厂即可；如果没有工厂模式，那么客户端调用的地方，创建对象的地方都需要改动。