在工厂模式中，分为三种，第一种就是简单工厂模式、第二种是工厂方法模式，第三种是抽象工厂模式。所谓工厂模式，就是指有一个专门的容器之类的地方，为用户创建对象，用户不用再手动去创建对象。容器根据用户传的参数或者调用的子类来自动为其创建对象。这种设计模式在Spring中大量的使用到了。
简单工厂模式：
先介绍一下简单工厂模式，简单工厂模式中，工厂会根据用户传递的参数的不同，返回不同的对象。我们拿手机来举例子，比如有一个手机工厂，他能够生产手机，然后工厂的生成线可以生产三种手机，一种是华为，一种是小米，还有一种是中兴。当批发商需要的时候，就告诉工厂生成哪种手机就行。
首先我们得有一个手机的接口：
public interface Phone{
public void creat();
}然后我们得有三条手机生产的方法：
public class HuaWei implements Phone{
@Override
public void create() {
System.out.println("我是中国的华为");
}
}
public class XiaoMi implements Phone{
@Override
public void create() {
System.out.println("我是中国的小米");
}
}
public class ZhongXing implements Phone{
@Override
public void create() {
System.out.println("我是中国的中兴");
}
}
好了，既然有了这些，我们此时需要工厂了：
public class PhoneFactory {
public Shape getShape(String type) {
if ("HuaWei".equals(type)) {
return new HuaWei();
} else if ("XiaoMi".equals(type)) {
return new XiaoMi();
} else if ("ZhongXing".equals(type)) {
return new ZhongXing();
} else {
return null;
}
}
}接着我们调用测试一下即可，值需要传入参数即可：
public class SimpleFactoryTest {
public static void main(String[] args) {
PhoneFactory phoneFactory = new PhoneFactory ();
phoneFactory.getPhone("HuaWei").create();
phoneFactory.getPhone("XiaoMi").create();
phoneFactory.getPhone("ZhongXing").create();
}
}工厂方法模式：
这是简单工厂模式，但是传参数也不是回事儿，看着还是挺别扭的，有没有办法直接根据子类来决定调用哪个生产方法呢？当然有，这时我们可以来看一下工厂方法模式。这里其实只需要扩展一下工厂方法即可，其余手机生产方式还是一样。我们将上面的PhoneFactory改为下面的代码：
public interface Factory {
public Phone getPhone();
}然后扩展三个创建对象的工厂方法，也就是实现Factory：
public class HuaWeiFactory implements Factory {
@Override
public Phone getPhone() {
return new HuaWei();
}
}public class XiaoMiFactory implements Factory {
@Override
public Phone getPhone() {
return new XiaoMi();
}
}public class ZhongXingFactory implements Factory {
@Override
public Phone getPhone() {
return new ZhongXing();
}
}接着我们在调用的时候，就可以根据子类来让工厂选择创建哪一个的对象了：
public class MethodFactoryTest {
public static void main(String[] args) {
Factory huaWeiFactory = new HuaWeiFactory();
huaWeiFactory .getPhone().create();
Factory xiaoMiFactory = new XiaoMiFactory();
xiaoMiFactory.getPhone().create();
Factory zhongXingFactory = new ZhongXingFactory();
zhongXingFactory.getPhone().create();
}
}抽象工厂模式：
在实际生活中，我们都知道，这三家手机厂商都是有各自的生态链的，比如华为除了手机，还涉及芯片、通讯等，小米除了手机，还涉及其很多智能家居等，中兴同样也是，除了手机，其通讯也是很不错的，那么我们假设这三家企业除了手机以外，都涉及到生成耳机，一般都是跟手机配套的，那现在就需要使用到抽象工厂模式。这里我们可以把上面那些工厂看成一个独立个体，再创建三个独立生产耳机的工厂个体，再建立一个超级工厂来管理这些独立个体。
其实总的来说跟工厂方法模式差不多，只是在工厂里面再加上新的方法，相当于加上新的工厂，之前的手机生产线不用改变，再添加三条耳机生产线：
public interface Earphone{
public void create();
}
public class HuaWeiEarphone implements Earphone{
@Override
public void create() {
System.out.println("我是华为耳机");
}
}public class XiaoMiEarphone implements Earphone{
@Override
public void create() {
System.out.println("我是小米耳机");
}
}public class ZhongXingEarphone implements Earphone{
@Override
public void create() {
System.out.println("我是中兴耳机");
}
}接着我们在工厂里面增加即可：
public interface Factory {
public Phone getPhone();
public Earphone getEarphone();
}public class HuaWeiFactory implements Factory {
@Override
public Phone getPhone() {
return new HuaWei();
}
@Override
public Earphone getEarphone() {
return new HuaWeiEarphone();
}
}public class XiaoMiFactory implements Factory {
@Override
public Phone getPhone() {
return new XiaoMi();
}
@Override
public Earphone getEarphone() {
return new XiaoMiEarphone();
}
}public class ZhongXingFactory implements Factory {
@Override
public Phone getPhone() {
return new ZhongXing();
}
@Override
public Earphone getEarphone() {
return new ZhongXingEarphone();
}
}最后调用：
public class AbstractFactoryTest {
public static void main(String[] args) {
Factory huaWeiFactory = new HuaWeiFactory();
huaWeiFactory.getPhone().create();
huaWeiFactory.getEarphone.create();
Factory xiaoMiFactory = new XiaoMiFactory();
xiaoMiFactory.getPhone().create();
xiaoMiFactory.getEarphone.create();
Factory zhongXingFactory = new ZhongXingFactory();
zhongXingFactory.getPhone().create();
zhongXingFactory.getEarphone.create();
}
}针对于这三种工厂模式，其实很好的体现了面向对象编程的六大原则之一的依赖倒置原则。具体指的就是编程的时候依赖于抽象而不是依赖于具体。
在写完上面三个工厂后，我自己的一些思考是这样的，其实针对于这三种，很难具体分出具体是什么，比如工厂方法模式与抽象工厂模式，无法就是一个是一个工厂，一个是多个工厂组建成超级工厂而已。有时候我们写业务的时候，刚开始需求可能只有一个，这时用到工厂方法模式，后期需求增加，可能就需要增加工厂，此时就变成抽象工厂模式了。所以我个人认为这两者其实界限不是特别的明显，无非就是一个和多个等级的关系，其实认同为一个也问题不大。
