Java设计模式 - 创建型模式 - 工厂方法模式

介绍

工厂方法模式（Factory Pattern）是 Java 中最常用的设计模式之一。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类。

优缺点

优点：

• 一个调用者想创建一个对象，只要知道其名称就可以了。
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。

举例

抽象产品类

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

具体产品类A

public class ConcreteProductA extends Product{
    @Override
    public void method() {
        System.out.println("我是具体产品A");
    }
}

具体产品类B

public class ConcreteProductB extends Product{
    @Override
    public void method() {
        System.out.println("我是具体产品B");
    }
}

抽象工厂类

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

具体工厂类

public class ConcreteFactory extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
//        return new ConcreteProductB();
    }
}

客户类

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.method();
    }
}

上述代码中我们在Client类中构造了一个工厂对象，并通过其生产了一个产品对象，这里我们得到的产品对象是ConcreteProductA的实例，如果想得到ConcreteProductB的实例，更改ConcreteFactory 中的逻辑即可。
这种方式比较常见，需要哪一个产品就生产哪一个，有时候也可以利用反射的方式更简洁的来生产具体产品对象，此时，需要在工厂方法的参数列表中传入一个Class类来决定是哪一个产品类：

抽象工厂类

public abstract class Factory {
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

具体工厂类

public class ConcreteFactory extends Factory{
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product product = null;
        try {
            product = (Product)Class.forName(clz.getName()).newInstance();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

Client类

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct(ConcreteProductA.class);
        product.method();
    }
}

需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简洁、动态，如果你不喜欢这种方式，也可以尝试为每一个产品都定义一个具体的工厂

public class ConcreteFactoryA extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.method();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.method();
    }
}

像这种拥有多个工厂的方式称为多工厂方法模式。

public class ConcreteFactory extends Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
//        return new ConcreteProductB();
    }
}

像这种的方式称为简单个工厂模式或静态工厂模式。