设计模式（二）——factory method模式

核心

使用template method模式，在工厂基类（即父类）的函数A中封装抽象函数的调用细节，子类中实现抽象函数的实现细节。工厂基类函数A的函数返回值类型一定是产品类的类型。

加粗的地方就是factory模式与template method模式不同的地方，template method注重的是父类封装函数调用细节，子类直接使用的关系。factory模式强调的是工厂类中的方法，封装调用需要子类实现的抽象函数的调用逻辑，逻辑与商品类相关。

实现

abstract class ProductClass{
    /**
     * 商品基类
     *
     **/
    public String name;
    ProductClass(){
        this.name = "";
    }
    ProductClass(String v_name){
        this.name = v_name;
    }
    public abstract void useProduct(ProductClass name);
}
abstract class FactoryClass{
    /**
     * 工厂基类
     *
     **/
    public ProductClass productObj;
     
    public abstract ProductClass generateProduct(String proName);
    public abstract void activityProduct(ProductClass obj);
    
    
    public ProductClass createAndActivityProduct(String proName){
        System.out.println("factoryClass create begin");
        ProductClass proObj = generateProduct(proName);
        System.out.println("factoryClass create end");
        System.out.println("factoryClass activity begin");
        activityProduct(proObj);
        System.out.println("factoryClass activity end");
        return proObj;
    }
}
class FactoryClass_Son extends FactoryClass{
    
    public ProductClass generateProduct(String proName){
        ProductClass object = new ProductClass_Son(proName);
        object.name = proName;
        this.productObj =object;
        System.out.println("generate son Product");
        return object;
    }
    
    public void activityProduct(ProductClass obj){
        ProductClass sonObj = (ProductClass_Son)obj;
        System.out.println("activity son Product " + (String)sonObj.name);
        return ;
    }
}
class ProductClass_Son extends ProductClass{
    ProductClass_Son(){
        this.name = "";
    }
    ProductClass_Son(String name){
        this.name = name;
    }
    
    public void useProduct(ProductClass obj){
        System.out.println("use productClass_Son " + obj.name);
        return;
    }
}
public class Main {
    public static void main(String[] args) {
        FactoryClass_Son v_factoryObj = new FactoryClass_Son();
        String proName = new String("vv_product");
        ProductClass v_productObj = v_factoryObj
                .createAndActivityProduct("vv_product");
        ((ProductClass_Son)v_productObj).useProduct(v_productObj);
        return;
        
    }
}

输出

factoryClass create begin
generate son Product
factoryClass create end
factoryClass activity begin
activity son Product vv_product
factoryClass activity end
use productClass_Son vv_product

作用

工厂基类实现了产品类的业务逻辑。

优点

• 子类不需要编写重复实现父类的[产品方法]逻辑。
• 新建商品子类后不需要修改[生产函数]的逻辑。

缺点

• 类多，总体代码量不一定少，增加阅读难度。
• 每一个工厂子类与商品子类是有组合的耦合关系。