三种工厂模式的创建

今天终于星期五了,最近由于碰上一个需求,中间涉及Oracle改国产数据库的改造,好家伙,差点没把我忙坏了

不过今天终于有空啦!~哈哈哈

这篇本应该是上周就结束的,但是拖到今天,我们就今天进行结束

(还有一件快乐的事情,就是_{我遇见自己喜欢的人啦!}嘻嘻)

好啦!~话不多说,我们进入今天的正题

本文总纲

我始终 认为一份思维导图是很重要的,建议大家也跟着建立一遍,绝对有着更上一层楼的感觉.(Just do it~ OK !)

---

我们主要进行用案例来掌握者几种模式,以练代学!!!效率绝对杠杠的

---

案例解析:(看对比,推荐敲一遍!~)

下面我们用一个案例来说明: 【在Spring环境下实现】

我们分别定义加减乘除类为了达到模拟计算机的效果

没有引入抽象模式时:

首先看执行类

• 比如下面我们执行加法运算时,我们就要创建一个OperationSub的类

换句话说:

• 我们要使用不同的运算时,就要创建不同的类,并且明确知道该类的名称(就是我们平时的显示new一个对象)

package com.byv.design_patterns;

public class Test {
    /**
     * 定义一个执行类
     * @param args
     */
    public static void main(String[] args) {
        AddOper addOper = new AddOper();
        addOper.setVal1(2);
        addOper.setVal2(3);
        System.out.println(addOper.getRes());
    }
}

抽象基类:

package com.byv.design_patterns;

import lombok.Data;

import java.math.BigDecimal;

/**
 * 抽象类: 计算机基类
 * 抽取公共逻辑
 */
@Data
public abstract class Operation {
    //计算的元素
    private int val1=0;
    private int val2=0;

    /**
     * 获取计算的结果,只能由子类来实现
     * @return
     */
    protected abstract int getRes();
}

加法类

package com.byv.design_patterns;

/**
 * 加法类
 */
public class AddOper extends Operation{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        return getVal1()+getVal2();
    }
}

除法类

-----------------
package com.byv.design_patterns;

/**
 * 除法类
 */
public class DivisionOper extends Operation{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        //判断是否除数合法
        return getVal2()!=0?getVal1()/getVal2():Integer.MIN_VALUE;
    }
}

乘法类

---------------
package com.byv.design_patterns;

/**
 * 乘法类
 */
public class MulticleOper extends Operation{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        return getVal1()*getVal2();
    }
}

减法类

------------
package com.byv.design_patterns;

/**
 * 减法类
 */
public class SubOper extends Operation{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        return getVal1()-getVal2();
    }
}

1.简单工厂模式

Static Factory Method:就是最简单的,上来不管三七二十一,就是把所有的对象(就是工厂) 给建造出来

上篇的工厂模式已经说过:简单工厂模式由一个工厂对象决定创建出哪一种产品实例

我们也看到上面没有采用设计模式的麻烦,那么我们怎么用简单工厂模式实现呢?(你可能会说,说啊!~别急啊,哈哈我们往下看)

再说实现之前,我们现看看简工的框架组成()

三者关系图:

Factory:

• 这是本模式的核心,含有一定的商业逻辑和判断逻辑
• 在Java中往往由一个具体类实现(OperationFactory)

Product:

• 他一般是具体产品继承父类或者实现的接口
• 在Java中由接口或者抽象类实现(Operation)

ConcretProduct:

• 工厂类所创建的对象就是此角色的实例
• 在Java由一个具体类实现
• 来用类图来清晰的表示下的他们之间的关系(OperationAdd\OperationSub)

案例:简单工厂模式实现

package com.byv.design_patterns;

import lombok.extern.java.Log;

/**
 * 简单工厂模式
 */
public class OperationFactory {
    //将所有的工厂对象创建出来,看下面的就知道
    public static Operation createOperation(String operation){
        Operation oper=null;
        switch (operation){
            case "+":
                oper=new AddOper();
                break;
            case "-":
                oper=new SubOper();
                break;
            case "*":
                oper=new MulticleOper();
                break;
            case "/":
                oper=new DivisionOper();
            default:
                System.out.println(" 输入非法,不支持此计算方式");
        }
        return oper;
    }
}

怎么调用?

上面的工厂类创建出来后,使用工厂创建对象(注意看,~我们用工厂,仔细推敲)

我们看到同样是创建一个加法运算的创建

package com.byv.design_patterns;

import com.byv.design_patterns.static_factory.OperationFactory;

public class Test {
    /**
     * 定义一个执行类
     * @param args
     */
    public static void main(String[] args) {
        //不用设计模式的
        AddOper addOper = new AddOper();
        addOper.setVal1(2);
        addOper.setVal2(3);
        System.out.println(addOper.getRes());


        //使用简单工厂模式
        //这一步真的很关键
        Operation operationAdd= OperationFactory.createOperation("+");
        operationAdd.setVal1(2);
        operationAdd.setVal2(3);
        System.out.printf(operationAdd.getRes()+"");
        
        
    }
}

工厂方法模式

这个怎么理解呢,就是更智能了,用户可以根据哪个创建哪个
在设计模式上完全符合"开闭原则"

工厂模式实现方式

关系图

Product: 抽象产品Operation

ConcreteProduct: 具体产品 ---->operationAdd

Factory: 抽象工厂 IFactory

ConcreteFactory: 具体工厂(AddFactory)

案例代码实现

package com.byv.design_patterns.satand_factory;

import com.byv.design_patterns.Operation;

/**
 * 减法类
 */
public class SubOper extends Operation implements IFactory{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        return getVal1()-getVal2();
    }

    @Override
    public Operation Creation() {
        return new SubOper();
    }
}


package com.byv.design_patterns.satand_factory;

import com.byv.design_patterns.Operation;

/**
 * 乘法类
 */
public class MulticleOper extends Operation implements IFactory{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        return getVal1()*getVal2();
    }

    @Override
    public Operation Creation() {
        return new MulticleOper();
    }
}



package com.byv.design_patterns.satand_factory;

import com.byv.design_patterns.Operation;

/**
 * 除法类
 */
public class DivisionOper extends Operation implements IFactory{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        //判断是否除数合法
        return getVal2()!=0?getVal1()/getVal2():Integer.MIN_VALUE;
    }

    @Override
    public Operation Creation() {
        return new DivisionOper();
    }
}


package com.byv.design_patterns.satand_factory;

import com.byv.design_patterns.Operation;

/**
 * 加法类
 */
public class AddOper extends Operation implements IFactory{
    //继承父类,实现自己的计算逻辑
    @Override
    protected int getRes() {
        return getVal1()+getVal2();
    }

    @Override
    public Operation Creation() {
        return new AddOper();
    }
}

怎么调用?

package com.byv.design_patterns;

import com.byv.design_patterns.satand_factory.IFactory;
import com.byv.design_patterns.static_factory.OperationFactory;

public class Test {
    /**
     * 定义一个执行类
     * @param args
     */
    public static void main(String[] args) {
        //不用设计模式的
        AddOper addOper = new AddOper();
        addOper.setVal1(2);
        addOper.setVal2(3);
        System.out.println(addOper.getRes());


        //使用简单工厂模式
        //这一步真的很关键
        Operation operationAdd= OperationFactory.createOperation("+");
        operationAdd.setVal1(2);
        operationAdd.setVal2(3);
        System.out.printf(operationAdd.getRes()+"");


        //使用工厂模式
        IFactory factory=new com.byv.design_patterns.satand_factory.AddOper();
        Operation operationStandAdd=factory.Creation();
        operationAdd.setVal1(2);
        operationAdd.setVal2(3);
        System.out.printf(operationAdd.getRes()+"");
    }
}

思考!(后面补充)

为什么要使用工厂创建对象?

为什么每种对象要单独有一个工厂?

抽象工厂模式

抽象工厂模式包含如下角色：

1. AbstractFactory(抽象工厂)：用于声明生成抽象产品的方法
2. ConcreteFactory(具体工厂)：实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；
3. AbstractProduct(抽象产品)：为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；
4. Product(具体产品)：定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。

采用一个汽车代工厂造汽车的例子。假设我们是一家汽车代工厂商，我们负责给奔驰和特斯拉两家公司制造车子。我们简单的把奔驰车理解为需要加油的车，特斯拉为需要充电的车。其中奔驰车中包含跑车和商务车两种，特斯拉同样也包含跑车和商务车。

下面是抽象产品，奔驰车和特斯拉车：

public interface BenzCar {
    //加汽油
    public void gasUp();

}

public interface TeslaCar {
    //充电
    public void charge();
}

下面是具体产品，奔驰跑车、奔驰商务车、特斯拉跑车、特斯拉商务车：

public class BenzSportCar implements BenzCar {
    public void gasUp() {
        System.out.println("给我的奔驰跑车加最好的汽油");
    }
}

public class BenzBusinessCar implements BenzCar{
    public void gasUp() {
        System.out.println("给我的奔驰商务车加一般的汽油");
    }
}

public class TeslaSportCar implements TeslaCar {
    public void charge() {
        System.out.println("给我特斯拉跑车冲满电");
    }
}

public class TeslaBusinessCar implements TeslaCar {
    public void charge() {
        System.out.println("不用给我特斯拉商务车冲满电");
    }
}

下面是抽象工厂：

public interface CarFactory {

    public BenzCar getBenzCar();
    public TeslaCar getTeslaCar();
}

下面是具体工厂

public class SportCarFactory implements CarFactory {
    public BenzCar getBenzCar() {
        return new BenzSportCar();
    }

    public TeslaCar getTeslaCar() {
        return new TeslaSportCar();
    }
}

public class BusinessCarFactory implements CarFactory {
    public BenzCar getBenzCar() {
        return new BenzBusinessCar();
    }

    public TeslaCar getTeslaCar() {
        return new TeslaBusinessCar();
    }
}

思考!

“开闭原则”的倾斜性是什么?

好了完结撒花(今晚写到这!~哈哈哈哈!)