设计模式之工厂方法模式

一.模式定义：

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

UML类图

二：代码实现

对下面这段代码进行改造

public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        ProductA product = application.getObject();
        product.method1();
    }
}
class ProductA{
    public void method1(){
        System.out.println("ProductA.method1 executed. ");
    }
}
class Application{
    private ProductA createProductA(){
        //...init
        //...
        return new ProductA();
    }
    ProductA getObject(){
        ProductA product = createProductA();
        // ...
        return product;
    }
}

接下来可能出现ProductB，ProductC...，但都会包含method1方法。接下来就可以使用工厂方法模式。

先使用简单工厂模式实现，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。

public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        Product product = application.getObject("1");
        product.method1();
    }
}
interface Product{
    public void method1();
}
class ProductA implements Product{
    public void method1(){
        System.out.println("ProductA.method1 executed. ");
    }
}
class ProductA1 implements Product{
    public void method1(){
        System.out.println("ProductA1.method1 executed. ");
    }
}
class SimpleFactory{
    public static Product createProduct(String type){
        if(type.equals("0")){
            return new ProductA();
        }else if(type.equals("1")){
            return new ProductA1();
        }else{
            return null;
        }
    }
}
class Application{
    private Product createProduct(String type){
        //...init
        //...
        return SimpleFactory.createProduct(type);
    }
    Product getObject(String type){
        Product product = createProduct(type);
        // ...
        return product;
    }
}

下面是工厂方法模式的实现：

public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new ConcreteProductA();
        Product product = application.getObject();
        product.method1();
    }
}
interface Product{
    public void method1();
}
class ProductA implements Product{
    public void method1(){
        System.out.println("ProductA.method1 executed. ");
    }
}
class ProductA1 implements Product{
    public void method1(){
        System.out.println("ProductA1.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 ConcreteProductA1 extends Application{

    @Override
    Product createProduct() {
        //...
        return new ProductA1();
    }
}

三：应用场景

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

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

四：主要优点

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

2.符合单一职责原则。

3.符合开闭原则。

五：源码中的应用

// java api
//静态工厂方法

Calendar.getInstance()
NumberFormat.getInstance()
ResourceBundle.getBundle()

//工厂方法
java.net.URLStreamHandlerFactory
javax.xml.bind.JAXBContext.createMarshaller