简单工厂模式（静态工厂），工厂方法模式，抽象工厂模式

一、简单工厂模式

一个栗子： 
抽象LOL英雄基类，(接口也可以)，这是产品的抽象类。

public abstract class Lol {
    /**
     * 描述各个英雄
     */
    public abstract void desc();
}

先说亚索（具体的产品类）：

public class Ys extends Lol {
    @Override
    public void desc() {
        System.out.println("哈塞给");
    }
}

劫（具体的产品类）：

public class Jie extends Lol {
    @Override
    public void desc() {
        System.out.println("无形之刃，最为致命");
    }
}

锐萌萌（具体的产品类）：

public class Ruiwen extends Lol {
    @Override
    public void desc() {
        System.out.println("断剑重铸之日，，，，");
    }
}

准备工作做完了，我们来一简单工厂类，菜单如下：

public class SimpleLolFactory {
    public static final int TYPE_YS = 1;
    public static final int TYPE_Jie = 2;
    public static final int TYPE_RW = 3;

    public static Lol playWhich(int type) {
        switch (type) {
            case TYPE_YS:
                return new Ys();
            case TYPE_Jie:
                return new Jie();
            case TYPE_RW:
            default:
                return new Ruiwen();
        }
    }
}

 

/**
 * 简单工厂模式
 */
 Lol lol = SimpleLolFactory.playWhich(SimpleLolFactory.TYPE_RW);
 lol.desc();

输出：

断剑重铸之日，，，，

缺点

扩展性差（新增英雄，除了新增一个英雄产品类，还需要修改工厂类方法（增加case）），当不同的产品需要不同额外参数的时候 不支持。

二、工厂方法模式    个人理解： 将简单工厂里的工厂类用继承的方式细分

2.1 实例概况

• 当客户需求增加，需要生产另一种产品（B类），但是目前系统只能生产A类产品，此时增加分厂B来生产B类产品

2.2 使用步骤

步骤1： 创建抽象工厂类，定义具体工厂的公共接口

abstract class Factory{
    public abstract Product Manufacture();
}

步骤2： 创建抽象产品类 ，定义具体产品的公共接口；

abstract class Product{
    public abstract void Show();
}

步骤3： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；

//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品B类
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

步骤5：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

//生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();

        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

结果：

生产出了产品A
生产出了产品C

---

3、优点

• 新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可

  简单工厂模式需要修改工厂类的判断逻辑（上面提到的 case）

• 符合单一职责原则
  每个具体工厂类只负责创建对应的产品

  简单工厂中的工厂类存在复杂的switch逻辑判断

• 不使用静态工厂方法，可以形成基于继承的等级结构。

  简单工厂模式的工厂类使用静态工厂方法

 

---

4、缺点

• 添加新产品时，除了增加新产品类外，还要提供与之对应的具体工厂类，系统类的个数将成对增加，在一定程度上增加了系统的复杂度；
• 一个具体工厂只能创建一种具体产品

三、抽象工厂模式

interface IProduct1 {  
    public void show();  
}  
interface IProduct2 {  
    public void show();  
}  
  
class Product1 implements IProduct1 {  
    public void show() {  
        System.out.println("这是1型产品");  
    }  
}  
class Product2 implements IProduct2 {  
    public void show() {  
        System.out.println("这是2型产品");  
    }  
}  
  
interface IFactory {  
    public IProduct1 createProduct1();  
    public IProduct2 createProduct2();  
}  
class Factory implements IFactory{  
    public IProduct1 createProduct1() {  
        return new Product1();  
    }  
    public IProduct2 createProduct2() {  
        return new Product2();  
    }  
}  
  
public class Client {  
    public static void main(String[] args){  
        IFactory factory = new Factory();  
        factory.createProduct1().show();  
        factory.createProduct2().show();  
    }  
}

 无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

 

---