工厂方法模式使用频率比较高,其定义为:

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


一:通用源码

step1:抽象产品类

public abstract class Product{
    //产品类的公共方法
    public void method1() {
        //业务逻辑
    }
    //抽象方法
    public abstract void method2();
}


step2:具体产品类

public class ConcreteProduct1 extends Product{
    public abstract void method2(); {
        //业务逻辑处理
    }
}

public class ConcreteProduct2 extends Product{
    public abstract void method2(); {
        //业务逻辑处理
    }
}


step3:抽象工厂类

public abstract class Creator{
    /**
     * 创建一个产品对象,其输入参数类型可以自行设置,通常为String、Enum、Class等,也可为空
     * @param c
     * @return
     */
    public abstract <T extends Product> T createProduct(Class<T> c);
}

具体如何产生一个产品的对象呢?有具体的工厂类实现。

step4:具体工厂类

public class ConcreteFactory extends Creator {

    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        //定义一个生产的人种
        Product product = null;
        try {
            //产生一个人种
            product = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
        }

        return (T)product;
    }

}


step5:场景类

public class Client{
    public static void main(String[] args) {
        Creator creator = new ConcreteFactory();
        Product product = creator.createProduct(ConcreteProduct1.class);
        /*
         * 后续业务处理
         */
    }
}


二:使用女娲造人的例子,应用通用模板

step1:抽象产品类

public interface Human {
    //每个人种都有颜色
    public void getColor();

    //每个人种都会说话
    public void talk();
}


step2:具体产品类(这里只给出一个白色的人)

public class WhiteHuman implements Human {

    @Override
    public void getColor() {
        // TODO Auto-generated method stub
        System.out.println("我是白色儿的");
    }

    @Override
    public void talk() {
        // TODO Auto-generated method stub
        System.out.println("我说的话你听不懂,you know?");
    }

}


step3:抽象工厂类

//抽象人类创建工厂
public abstract class AbstractHumanFactory {
    //必须是Class类型,必须是Human的实现类
    public abstract <T extends Human> T createHuman(Class<T> c);
}


step4:具体工厂类

public class HumanFactory extends AbstractHumanFactory {

    @Override
    public <T extends Human> T createHuman(Class<T> c) {
        //定义一个生产的人种
        Human human = null;
        try {
            //产生一个人种
            human = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("人种生成错误");
        }

        return (T)human;
    }

}


step5:场景类

public class NvWa {
    //模拟女娲造人的过程
    public static void main(String[] args) {
        AbstractHumanFactory yinYangLu = new HumanFactory();
        //造个白色儿的
        Human wHuman = yinYangLu.createHuman(WhiteHuman.class);
        wHuman.getColor();
        wHuman.talk();
        //来个黑小子
        Human bHuman = yinYangLu.createHuman(BlackHuman.class);
        bHuman.getColor();
        bHuman.talk();
        //小麦色的亚洲宝宝
        Human yHuman = yinYangLu.createHuman(YellowHuman.class);
        yHuman.getColor();
        yHuman.talk();

    }
}


三:理解

工厂方法模式使用的比较频繁,他是典型的解耦框架。高层模块只需要知道产品的抽象类,其他的实现类都不用关心。符合迪米特法则,我不需要的就不要去交流;符合依赖倒置原则,只依赖产品类的抽象;符合里氏替换原则,使用产品子类替换产品父类。

四:写在后面

设计模式比较抽象,对现在还没工作的我来说的确有点难理解。我现在只能死记硬背,先能认出人家用的是那种设计模式。希望工作后的我能真正理解设计模式的精髓,掌握他的核心!