简单工厂模式与工厂模式的区别

数据源的创建比较复杂，对于复杂对象的创建，可以考虑使用简单工厂模式和工厂模式。下面介绍简单工厂模式和工厂模式。

简单工厂模式

简单工厂模式及时专门使用一个类来创建其他类的实例，被创建的额实例通常都有共同的父类。

使用步骤

步骤1. 创建抽象产品类，定义具体产品的公共接口

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

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

//具体产品类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("生产出了产品C");
    }
}

//具体产品类C
class  ProductC extends  Product{

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

步骤3. 创建工厂类，通过创建静态方法从而根据传入不同参数创建不同具体产品类的实例

class  Factory {
    public static Product Manufacture(String ProductName){
//工厂类里用switch语句控制生产哪种商品；
//使用者只需要调用工厂类的静态方法就可以实现产品类的实例化。
        switch (ProductName){
            case "A":
                return new ProductA();

            case "B":
                return new ProductB();

            case "C":
                return new ProductC();

            default:
                return null;

        }
    }
}

步骤4. 外界通过调用工厂类的静态方法，传入不同参数从而创建不同具体产品类的实例

//工厂产品生产流程
public class SimpleFactoryPattern {
    public static void main(String[] args){
        Factory mFactory = new Factory();

        //客户要产品A
        try {
//调用工厂类的静态方法 & 传入不同参数从而创建产品实例
            mFactory.Manufacture("A").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品B
        try {
            mFactory.Manufacture("B").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品C
        try {
            mFactory.Manufacture("C").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品D
        try {
            mFactory.Manufacture("D").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }
    }
}

适应场景: 将对象创建和对象使用解耦，并屏蔽了创建可能的复杂过程，但由于创建的逻辑集中在工厂类，所以简单工厂适合需求变化不频繁的场景。
缺点 工厂类负责了所有产品的实例化，违反了单一原则。如果产品类型比较多，工厂类的代码比较大，不利于扩展。必须修改工厂类原有的代码，这违反了开闭原则。

简单工厂模式

工厂模式属于创建型模式，它提供了一种创建对象的最佳方式。定义一个创建对象的接口，
让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

为什么要使用工厂模式?

创建对象的方式可以使用new关键字、反射、clone等方式，也可已使用工厂模式。对于创建比较复杂的对象，使用new关键字、反射、clone等方式创建存在如下缺点：
1.对象创建和对象使用职责耦合在一起。违反单一原则。
2.当业务扩展时，必须修改业务代码。违反开放关闭原则。

而使用工厂模式将对象的创建与使用进行解耦，屏蔽了创建对象可能的复杂过程，相对简单工厂模式，又具备有良好的扩展性和和维护性，其优点有：
1.对象的创建和使用解耦。
2.如果创建比较复杂，创建过程统一由工厂管理，减少了重复的代码，方便日后维护。
3.当业务扩展时，只需要添加工厂子类，符合开闭原则。

使用步骤

步骤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

代码转自 https://www.jianshu.com/p/e55fbddc071c