设计模式--工厂方法模式

Java工程源码

类图

---

定义
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工程方法使一个类的实例化延迟到其子类

---

优缺点
- 良好的封装性，代码结构清晰。调用者只需知道产品类名，不必知道创建对的过程，降低了模块间的耦合
- 扩展性优秀。在新增产品的情况下，适当修改具体工厂类或扩展一个工厂类即可
- 屏蔽产品类。产品类的实现如何变化，调用者无需关心，它只关心接口
- 典型的解耦框架。符合迪米特法则，我不需要的不要去交流；符合依赖倒置原则，只依赖产品类的抽象；符合里氏替换原则，使用产品子类替换产品父类

---

使用场景
- 需要生成对象的地方
- 需要灵活，可扩展的框架时
- 可以使用在异构环境中
- 可以使用在测试驱动开发的框架下

---

扩展
简单工厂模式：将原来的抽象工厂中的创建方法改成静态方法

---

注意事项
工厂方法模式最好是与其他模式(如模板方法模式，单例模式，原型模式等)混合，如此可以变化出无穷的设计

---

工厂模式介绍

分类

1. 简单工厂模式(Simple Factory)(静态工厂方法模式)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)

其中，简单工厂模式一般被看为是工厂方法模式的特例。

区别

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
一个抽象工厂对应一个抽象产品。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
一个抽象工厂对应多个抽象产品。
每个具体工厂类可以创建多个具体产品类的实例。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

源码

抽象产品类

public abstract class Product {
    /**
     * 业务逻辑处理
     */
    public void method1() {
        System.out.println("Product->method1");
    }

    /**
     * 抽象方法
     */
    public abstract void method2();
}

具体产品类1

public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        // 具体逻辑处理
        System.out.println("ConcreteProduct1->method2");
    }
}

具体产品类2

public class ConcreteProduct2 extends Product {
    @Override
    public void method2() {
        // 具体逻辑处理
        System.out.println("ConcreteProduct2->method2");
    }
}

简单工厂模式工厂类

public class SimpleFactory {
    public Product createProduct(int type) {
        switch (type) {
            case 1:
                return new ConcreteProduct1();
            case 2:
                return new ConcreteProduct2();
            default:
                return null;
        }
    }
}

场景类

public class Client {
    public static void main(String args[]) {
        // 简单工厂模式
        SimpleFactory simpleFactory = new SimpleFactory();
        Product simpleProduct1 = simpleFactory.createProduct(1);
        Product simpleProduct2 = simpleFactory.createProduct(2);
        simpleProduct1.method2();
        simpleProduct2.method2();
    }
}

简单工厂模式违背了高内聚的单一职责原则，不利于工程维护。

---

工厂方法模式 抽象工厂类

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

生产产品1的实体工厂类

public class ConcreteFactory1 extends AbsFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}

生产产品2的实体工厂类

public class ConcreteFactory2 extends AbsFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

场景类

public class Client {
    public static void main(String args[]) {
        // 工厂方法模式
        AbsFactory factory1 = new ConcreteFactory1();
        AbsFactory factory2 = new ConcreteFactory2();
        Product normalProduct1 = factory1.createProduct();
        Product normalProduct2 = factory2.createProduct();
        normalProduct1.method2();
        normalProduct2.method2();
    }
}

---

优化后的工厂方法模式 抽象工厂类

public abstract class Factory {
    public abstract Product createProduct(Class<? extends Product> c);
}

实体工厂类

public class ConcreteFactory extends Factory {
    /**
     * 利用反射机制，生产产品，这样写结合了抽象工厂模式的优点，又保留了工厂方法模式的优点，让子类决定实例化
     *
     * @return 产品
     */
    @Override
    public Product createProduct(Class<? extends Product> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            // 异常处理
            e.printStackTrace();
        }
        return product;
    }
}

场景类

public class Client {
    public static void main(String args[]) {
        // 优化工厂方法模式，新建工厂类
        Factory creator = new ConcreteFactory();
        // 生产产品1
        Product product1 = creator.createProduct(ConcreteProduct1.class);
        // 生产产品2
        Product product2 = creator.createProduct(ConcreteProduct2.class);
        // 执行产品方法
        product1.method1();
        product1.method2();
        product2.method2();
    }
}

优化后的形式可以减少工厂类的创建。