闲言
最近鄙人在看《设计模式之禅》这本书，巩固一下常用的设计模式，本文的例子就直接用的书中的例子，因为作者写的通俗易懂，让我看的欲罢不能，给作者大大比心！！（其实我就是懒）
工厂模式的优点自不必说，首先，良好的封装性，在使用的时候我们不必考虑对象创建的各种约束条件，只需要知道要生产的产品的类名就可以了。其次，优秀的可拓展性，如果业务有变化，需要增加或者删除一个产品类，只需要修改工厂类就可以了，做到了真正的拥抱变化。最后，工厂模式是典型的解耦框架，符合迪米特法则，也符合依赖倒置的原则。
1.工厂模式定义
工厂模式在我们日常开发中式使用频率非常高的一种设计模式，其定义为：定义一个用于创建对象的接口，让子类决定创建那个类，该模式使一个类的实例化延迟到其子类。
也就是说我们创建一个接口，用这个接口去生产具体的类，不用关心类是怎么创建的，如何初始化，只须关心要生产的是具体哪一个类，至于如何创建，我们去交给工厂来实现。
2.通用实现
以上图女娲造人为例，我们现在要生产出具体肤色的人，先创建一个接口AbstractHumanFactory，用于规定工厂中创建人类的方法，再创建一个人类的接口，里面规定了无论那种肤色的人都有的方法，肤色和语言，方法的具体实现由下面具体肤色的人来实现。下面上代码：
//抽象工厂类
public abstract class AbsFactory {
public abstract <T extends Human>T createHuman(Class<T> cls);
}
//人类接口
interface Human {
void getColor();
void talk();
}
//工厂类
public class FactoryImpl extends AbsFactory{
@Override
public <T extends Human> T createHuman(Class<T> cls) {
Human human=null;
try {
human=(T)Class.forName(cls.getName()).newInstance();
} catch (Exception e) {
System.out.println("创建人类失败");
}
return (T)human;
}
}
//黑人
public class BlackHuman implements Human{
@Override
public void getColor() {
System.out.println("我是黑种人，我的皮肤是黑色的。");
}
@Override
public void talk() {
System.out.println("一般人听不懂黑人在说什么。");
}
}
//黄种人
public class YellowHuman implements Human{
@Override
public void getColor() {
System.out.println("我是黄种人，我的皮肤是黄色的。");
}
@Override
public void talk() {
System.out.println("我们黄种人说的一般都是双字节");
}
}
//白人
public class WhiteHuman implements Human{
@Override
public void getColor() {
System.out.println("我是白种人，我的皮肤是白色的。");
}
@Override
public void talk() {
System.out.println("白种人说的一般都是单字节。");
}
}
下面是场景类，也就是我们的使用场景：
public class NvWa {
public static void main(String[] args) {
AbsFactory factory=new FactoryImpl();
Human white=factory.createHuman(WhiteHuman.class);
white.getColor();
white.talk();
Human yellow=factory.createHuman(YellowHuman.class);
yellow.getColor();
yellow.talk();
Human black=factory.createHuman(BlackHuman.class);
black.getColor();
black.talk();
}
}
运行结果：
我是白种人，我的皮肤是白色的。
白种人说的一般都是单字节。
我是黄种人，我的皮肤是黄色的。
我们黄种人说的一般都是双字节
我是黑种人，我的皮肤是黑色的。
一般人听不懂黑人在说什么。
Process finished with exit code 0
以上就是工厂模式的通用实现。
3.简单工厂模式
![]()
简单工厂示UML图
在类图中，我们把AbsstractHumanFactory删除，同时把HumanFactory中的createHuman方法修改成静态方法，而在我们的场景类NvWa中也要做相应修改。
//工厂类
public class FactoryImpl{
public static <T extends Human> T createHuman(Class<T> cls) {
Human human=null;
try {
human=(T)Class.forName(cls.getName()).newInstance();
} catch (Exception e) {
System.out.println("创建人类失败");
}
return (T)human;
}
}
//场景类
public class NvWa {
public static void main(String[] args) {
Human white=FactoryImpl.createHuman(WhiteHuman.class);
white.getColor();
white.talk();
Human yellow=FactoryImpl.createHuman(YellowHuman.class);
yellow.getColor();
yellow.talk();
Human black=FactoryImpl.createHuman(BlackHuman.class);
black.getColor();
black.talk();
}
}
运行结果：
我是白种人，我的皮肤是白色的。
白种人说的一般都是单字节。
我是黄种人，我的皮肤是黄色的。
我们黄种人说的一般都是双字节
我是黑种人，我的皮肤是黑色的。
一般人听不懂黑人在说什么。
简单工厂的应用场景：当一个模块只需要一个工厂类，没有必要把他生产出来，使用静态方法就可以了。
这句话是书上的原话，其实我是没怎么看懂，但是后来看到后面还有多工厂模式，我就明白了。有时候，业务比较复杂，很多产品的创建方式，对对象的属性值得初始化都不相同，如果都放到一个工厂中去，会使代码结构不清晰，所以我们为每一个产品（或创建方式一致的一类产品）都定义一个工厂，于是，多工厂模式诞生了。如果业务逻辑比较简单的时候，一个工厂就可以搞定所有产品的生产的时候，我们就用简单工厂模式。下面我们来学习一下工厂模式的另一个变种。
4.多工厂模式
我们在AbstractHumanFactory中的抽象方法中去掉了传参，因为每一个具体的工厂的职责都非常明确，创建自己负责的产品类对象。女娲类也需要做相应修改。
public abstract class AbsFactory {
public abstract <T extends Human>T createHuman();
}
public class BlackHumanFactory extends AbsFactory{
@Override
public Human createHuman() {
return new BlackHuman();
}
}
public class WhiteHumanFactory extends AbsFactory{
@Override
public Human createHuman() {
return new WhiteHuman();
}
}
public class YellowHumanFactory extends AbsFactory{
@Override
public Human createHuman() {
return new YellowHuman();
}
}
public class NvWa {
public static void main(String[] args) {
Human white=(new WhiteHumanFactory()).createHuman();
white.getColor();
white.talk();
Human yellow=(new YellowHumanFactory()).createHuman();
yellow.getColor();
yellow.talk();
Human black=(new BlackHumanFactory()).createHuman();
black.getColor();
black.talk();
}
}
运行结果和上面一样，这里不再展示。
