工厂模式有哪些好处（工厂模式和简单工厂模式的区别）

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

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

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

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

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

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

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

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

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

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

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

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

它们的类图如下：

工厂模式有哪些好处,工厂模式和简单工厂模式的区别(1)

示例代码：

/**
* 车的接口
*/
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 "奔驰在跑，心所向，驰以恒!";
}
}

简单工厂模式示例

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

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

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

示例代码：

/**
* 简单工厂模式
*/
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());
}
}

运行结果：

奥迪在跑，突破科技，启迪未来！
宝马在跑，无处不担当！
奔驰在跑，心所向，驰以恒!

抽象工厂模式

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

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

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

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

类图：

工厂模式有哪些好处,工厂模式和简单工厂模式的区别(3)

示例代码：

/**
* 抽象汽车工厂
*/
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());
}
}

运行结果：