三种工厂模式的创建

今天终于星期五了,最近由于碰上一个需求,中间涉及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{//继承父类,实现自己的计算逻辑@Overrideprotected int getRes() {return getVal1()+getVal2();}
}

除法类

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

乘法类

---------------
package com.byv.design_patterns;/*** 乘法类*/
public class MulticleOper extends Operation{//继承父类,实现自己的计算逻辑@Overrideprotected int getRes() {return getVal1()*getVal2();}
}

减法类

------------
package com.byv.design_patterns;/*** 减法类*/
public class SubOper extends Operation{//继承父类,实现自己的计算逻辑@Overrideprotected 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{//继承父类,实现自己的计算逻辑@Overrideprotected int getRes() {return getVal1()-getVal2();}@Overridepublic 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{//继承父类,实现自己的计算逻辑@Overrideprotected int getRes() {return getVal1()*getVal2();}@Overridepublic 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{//继承父类,实现自己的计算逻辑@Overrideprotected int getRes() {//判断是否除数合法return getVal2()!=0?getVal1()/getVal2():Integer.MIN_VALUE;}@Overridepublic 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{//继承父类,实现自己的计算逻辑@Overrideprotected int getRes() {return getVal1()+getVal2();}@Overridepublic 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();}
}

思考!

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

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