num07---工厂方法模式

一、简单工厂模式

　　【之所以叫简单，说明没有完全做到设计模式的要求】

　　前言：活字印刷术，面向对象思想复用维护扩展灵活高内聚低耦合
　　以实现一个计算器为例：

1、创建 抽象类count， 这是一个计算类，有一个计算方法calculate
public abstract class Count {

　　public abstract double calculate(double num1, double num2) throws Exception;

}

2、创建具体的计算类【加减乘除等等】，分别继承抽象计算类count，重写各自独有的计算方法。
比如加法类：
public class Plus extends Count{

　　@Override
　　public double calculate(double num1, double num2) {

　　　　return num1 + num2;
　　}    
}

3、创建工厂类，根据用户传来的不同运算符，生成不同的计算类对象。【计算类对象由工厂生成，而不是用户手动去new创建】
public class Factory {

　　public static Count createObj(String oper){

　　　　Count count = null;
　　　　switch(oper){
　　　　　　case "+":
　　　　　　　　count = new Plus();
　　　　　　　　break;
　　　　　　case "-":
　　　　　　　　count = new Subtract();
　　　　　　　　break;
　　　　　　case "*":
　　　　　　　　count = new Ride();
　　　　　　　　break;
　　　　　　case "/":
　　　　　　　　count = new Divide();
　　　　　　　　break;
　　　　　　case "%":
　　　　　　　　count = new Remainder();
　　　　　　　　break;
　　　　　　default:
　　　　　　　　System.out.println("����������");
　　　　　　　　break;
　　　　}
　　　　return count;
　　}
}

4、测试类中main()进行验证 。
Factory factory = new Factory();    //创建工厂
Count createObj = factory.createObj(oper);    //oper 操作运算符 + - * .......
double calculate = createObj.calculate(d1, d2);

　　简单工厂模式，是在工厂类中进行逻辑判断，根据客户端的条件动态实例化相关的类，去除了客户端与具体产品的依赖，但是这样有一个问题，违反了开放封闭原则，如果新增一个逻辑，就必须修改工厂类中的逻辑判断的代码

====================================================================================================================================================

二、工厂方法模式

　　工厂模式解决了简单工厂的缺点。将工厂类接口抽象化，然后创建不同的子类工厂类，实现工厂类接口。每个子类工厂去实现具体的逻辑产品类。

　　本质上就是把原有工厂类实现的实例化代码逻辑延迟到其子类中去实现。

样例代码：

　　创建一个模型工厂接口以及两个类型的模型工厂实现类，一个徐工类，一个利勃海尔类，不同工厂分别创建对应类型的模型对象。

 * @description :建立模型父类工厂接口
 */
public interface CreateModelParentFactory {

    //创建模型方法
    public Model createModel();
    
}

 * @description :利勃海尔类模型创建工厂
 */
public class CreateLiebherrModelFactory implements CreateModelParentFactory {

    @Override
    public Liebherr createModel() {
        return new Liebherr();

    }

}

 * @description :徐工类模型创建工厂
 */
public class CreateXuGongModelFactory implements CreateModelParentFactory {

    @Override
    public Xugong createModel() {
        return new Xugong();

    }

}

创建模型类以及不同品牌的模型类子类。

 * @description :
 */
public class Model {
    public void testFunction() {
        System.out.println("我是模型父类");
    }

}

public class Liebherr extends Model{
    
    public void testFuction() {
        System.out.println("我是利勃海尔类模型");
    }

}

 */
public class Xugong extends Model {
    
    public void testFunction() {
        System.out.println("我是徐工类模型");
    }

}

测试方法：

 * @description :
 */
public class Main {
    
    public static void main(String[] args) {
        CreateLiebherrModelFactory liFactory = new CreateLiebherrModelFactory();
        Liebherr libModel = liFactory.createModel();
        libModel.testFuction();
    }

}

结果：

我是利勃海尔类模型

　　现在如果想要生产新的三一重工类的模型，就去新建三一模型类、三一类模型工厂。即可。

　　相比较简单工厂模式而言，工厂模式避免了违背开放封闭原则，又保持了封装对象的创建过程，缺点是每增加一个产品，需要增加类，增加开发量。

====================================================================================================================================================

三、抽象工厂模式

上述是一个pizza的例子，两个地点类型（北京、伦敦），两个口味（cheess、pepper），

对应到模型的例子中，两个品牌类型（徐工、利勃海尔），两个车辆用途（挖机、吊车），代码如下：

模型类以及子类：

模型抽象工厂以及其子工厂实现类

测试：

public static void main(String[] args) {

CreateXuGongModelFactory xgFac = new CreateXuGongModelFactory();

Model xgwjObj = xgFac.createModel("wj");

xgwjObj.testFunction();

}

======================

工厂模式JDK源码分析：

======================

小结

=====================

关于三者工厂模式的联系区别：

　　　　【参考 ps: https://www.cnblogs.com/sanjun/p/9972386.html】

- 工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类
- 抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类
- 区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构的。
- 再来看看工厂方法模式与抽象工厂模式对比：

独行侠的守望

发布了104 篇原创文章 · 获赞 1 · 访问量 3万+

私信关注

num07---工厂方法模式

num07---工厂方法模式

猜你喜欢