1: 简单工厂

简介

该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象。其UML类图如下: 

​设计模式之【简单工厂】_工厂方法模式

代码实例 

 

public class FactoryPattern {

    public interface Product {
        void execute();
    }

    //产品1
    public static class ProductImpl implements Product {

        @Override
        public void execute() {
            System.out.println("产品1功能实现");
        }
    }

    //产品2
    public static class Produc2tImpl implements Product {

        @Override
        public void execute() {
            System.out.println("产品2功能实现");
        }
    }

    /**
     * 创建对象工厂
     */
    public static class ProductFactory {

        public static Product createProduct(String productType) {
            Product product = null;
            if (productType.equals("产品1") ) {
                product = new ProductImpl();
            } else if (productType.equals("产品2")) {
                product = new Produc2tImpl();
            }
            return product;
        }
    }

    public static void main(String[] args) {
        Product product = ProductFactory.createProduct("产品1");
        product.execute();
        Product product2 = ProductFactory.createProduct("产品2");
        product2.execute();

    }
}


总结


优点:
  工厂角色负责产生具体的实例对象，所以在工厂类中需要有必要的逻辑，通过客户的输入能够得到具体创建的实例；所以客户端就不需要感知具体对象是如何产生的，只需要将必要的信息提供给工厂即可。
缺点:
   简单工厂模式是违反“开闭原则”，即对扩展开放，对修改关闭；因为如果要新增具体产品，就需要修改工厂类的代码。


​针对简单工厂模式暴露出来的弊端，我们需要对代码再进行改进，由此延伸出工厂方法模式

2:工厂方法模式

​

简介

​定义一个用来创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类。和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，其UML类图如下:

​

​设计模式之【简单工厂】_抽象工厂模式_02

​

代码示例

​

//创建工厂类
public interface Factory {
    ProductA createProductA();
    ProductB createProductB();
}


//创建具体对象的工厂
public class Factory1 implements Factory{
    @Override
    public ProductA createProductA() {
        return new ProductA();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB();
    }
}

//测试类
public class TestFactory {

    public static void main(String[] args) {
        Factory1 factory1 = new Factory1();
        factory1.createProductA().execute();
        factory1.createProductB().execute();
    }
}

​

总结

​

对于简单工厂模式而言，创建对象的逻辑判断放在了工厂类中，客户不感知具体的类，但是其违背了开闭原则，如果要增加新的具体类，就必须修改工厂类。
对于工厂方法模式而言，是通过扩展来新增具体类的，符合开闭原则，但是在客户端就必须要感知到具体的工厂类，也就是将判断逻辑由简单工厂的工厂类挪到客户端。

​

3:抽象工厂模式

 简介

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品的时候，即为工厂方法模式，而工厂如果生产两个或以上的商品即变为抽象工厂模式。

​

​其UML类图如下：

​

​设计模式之【简单工厂】_简单工厂模式_03

​

代码示例

​

//创建产品的两个功能
public interface AbstractFactory {
    void funcation1();
    void funcation2();
}

//工厂产品A,对应的两个功能
public class ProductAFactory implements AbstractFactory {

    @Override
    public void funcation1() {
        System.out.println("产品A，功能1:");
        new FuncationA().function();
    }

    @Override
    public void funcation2() {
        System.out.println("产品A，功能2:");
        new FuncationB().function();
    }
}

//工厂产品B,对应的两个功能
public class ProductBFactory implements AbstractFactory {
    
    @Override
    public void funcation1() {
        System.out.println("产品B，功能1:");
        new FuncationA().function();
    }

    @Override
    public void funcation2() {
        System.out.println("产品B,功能2:");
        new FuncationB().function();
    }
}

//功能抽象类
public interface Function {
    void function();
}

//功能A的具体实现
public class FuncationA implements Function{
    @Override
    public void function() {
        System.out.println("开关功能");
    }
}

//功能B的具体实现
public class FuncationB implements Function{
    @Override
    public void function() {
        System.out.println("起飞功能");
    }
}

//测试
public class TestMain {
    public static void main(String[] args) {
        ProductAFactory productAFactory = new ProductAFactory();
        productAFactory.funcation1(); //产品A，功能1:开关功能
        productAFactory.funcation2(); //产品A，功能2:起飞功能
        ProductBFactory productBFactory = new ProductBFactory();
        productBFactory.funcation1(); //产品B，功能1:开关功能
        productBFactory.funcation2(); //产品B,功能2:起飞功能
    }
}

​

总结

​抽象工厂模式的缺点在于产品类的扩展，将会是十分费力的，假如在需要加入新的产品，那么几乎所有的工厂类都需要进行修改，所以在使用抽象工厂模式时，对产品等级结构的划分是十分重要的。

​

三种工厂总结

无论是简单工厂模式，工厂方法模式还是抽象工厂模式，它们都具有类似的特性，适用场景也十分类似，它们的最终目的都是为了解耦。在实际使用过程中，我们不必去在意这个模式到底是抽象工厂模式，还是工厂方法模式，因为两者非常容易发生转变。只有降低耦合目的达到就行了。使用工厂方法后，调用端的耦合度大大降低，对于工厂来说，可以扩展就行。三种工厂模式有各自的应用场景，实际应用时能解决问题满足需求即可，可灵活变通，无所谓高级与低级。好了，感谢大家的阅读，其中不足之处，请多多指教。