快速带你彻底弄懂23种设计模式-工厂方法模式

1.Factory Method模式定义：

定义一个用来创建对象的接口，由子类来决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。

2.一般当程序处于非常稳定的情况下，或者变化的非常迅速情况下，不需要引入设计模式；我们可以在变中找到稳定的部分，把其抽象出来，变的部分由其他类实现

例如执行ProductA类的method1()方法的实现如下：

public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        ProductA object = application.getObject();
        object.method1();
    }
}

class ProductA {
    //该类有一个方法
    public void method1() {
        System.out.println("ProductA.method1 executed.");
    }
}

class Application {
    ProductA createProduct() {
        //.....init
        //.....业务逻辑
        return new ProductA();
    }

    ProductA getObject() {
        ProductA product = createProduct();
        //...一些业务逻辑
        return product;
    }
}

在上面代码能发现目前有了ProductA产品，当我们需要增加产品ProductB的时候（业务的变化），我们需要分析出整个代码中：在变化的代码块中哪部分是相对稳定的，可以将其抽离出去。这里就可以引入设计模式，我们可以认为“产品”是变化的，某一个产品（如ProductA）的具体方法method1()是稳定的，可以将其放入一个接口中，未来添加变化的产品A或B或C时，由各自实现各自的method1()方法。

将上面的代码改造成简单工厂模式（不属于设计模式）：

//一般当程序处于非常稳定的情况下，或者变化的非常迅速情况下，不需要引入设计模式；
//我们可以在变中找到稳定的部分，把其抽象出来，变的部分由其他类实现
public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        Product object = application.getObject("1");
        object.method1();
    }
}

class SimpleFactorytyMethod {
    public static Product createProduct(String type) {
        if (type.equals("0")) {
            return new ProductA();
        } else if (type.equals("1")) {
            return new ProductB();
        } else {
            return null;
        }
    }
}

//稳定的部分
interface Product {
    void method1();
}

//变化的部分
class ProductA implements Product {
    //该类有一个方法
    @Override
    public void method1() {
        System.out.println("ProductA.method1 executed.");
    }
}

class ProductB implements Product {
    @Override
    public void method1() {
        System.out.println("ProductB.method1 executed.");
    }
}

//对Application部分实现重构
class Application {
    Product createProduct(String type) {
        //.....init
        //.....业务逻辑
        return SimpleFactorytyMethod.createProduct(type);
    }

    Product getObject(String type) {
        Product product = createProduct(type);
        //...一些业务逻辑
        return product;
    }
}

简单工厂模式将实例化的过程给封装起来；如何改造成工厂方法模式，将实现过程推迟到子类呢？

Product createProduct(String type)和Product getObject(String type)方法是稳定的，我们可以将这个方法所在的类定义为抽象类， 变化的是他们所对应的实现的子类。即也符合开闭原则

public class FactoryMethod {
    public static void main(String[] args) {
        Application concreteProduct = new ConcreteProductA();
        Application concreteProduct1 = new ConcreteProductB();
        Product objectA = concreteProduct.getObject();
        Product objectB = concreteProduct1.getObject();
        objectA.method1();
        objectB.method1();
    }
}

interface Product {
    void method1();
}

class ProductA implements Product {
    //该类有一个方法
    @Override
    public void method1() {
        System.out.println("ProductA.method1 executed.");
    }
}

class ProductB implements Product {
    @Override
    public void method1() {
        System.out.println("ProductB.method1 executed.");
    }
}

abstract class Application {
  //工厂方法，对应的实现会延迟到子类，方便软件未来的扩展变化
    abstract Product createProduct();

    Product getObject() {
        Product product = createProduct();
        //...一些业务逻辑
        return product;
    }
}

class ConcreteProductA extends Application {
    @Override
    Product createProduct() {
        return new ProductA();
    }
}

class ConcreteProductB extends Application {
    @Override
    Product createProduct() {
        return new ProductB();
    }
}

应用场景：

1.不知道该使用对象的确切类型的时候

2.希望为库或者框架扩展其内部组件的方法时

主要优点：

1.将具体产品和创建者解耦

2.符合单一职责原则

3.符合开闭原则

源码中的应用：

简单工厂方法模式：

Calendar.getInstance()

java.text.NumberFormat.getInstance()

java.util.ResourceBundle.getBundle()

工厂方法模式

java.net.URLStreamHandler