在程序中类是表示客观世界存在的某类群体的一些基本特征的抽象，对象就是一个个具体的东西，也可以理解为类的一个具体实例。
工厂模式属于创建型模式，它提供一种创建对象的方式。
单一职责原则要求：类的职责要单一，不能将太多的职责放在一个类中，也就是一个接口或者类只能有一个职责。
拿一个对象来说，他有哪些职责呢？
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、抽象工厂模式
当我们创建一个对象的时候，构造方法里需要传入参数的时候，一般就要考虑是否选用工厂模式，选用哪种工厂模式了。
运用工厂模式的好处就是当你构造方法参数变化的时候，使用工厂模式后，修改起来非常简单，只需要修改工厂即可；如果没有工厂模式，那么客户端调用的地方，创建对象的地方都需要改动。
