设计模式4-工厂模式策略模式
目录
一 工厂模式
1.1 思想
1.2 案例
1.2.1 接口
1.2.2 实现类
1.2.3 工厂类
1.2.4 调用
二 策略模式
2.1 思想
2.2 案例
2.2.1 接口
2.2.2 实现类
2.2.3 策略类
2.2.4 调用
三 工厂模式+策略模式
3.1 思想
3.2 案例
3.2.1 接口
3.2.2 实现类
3.2.3 定义Factory
3.2.4 调试
一 工厂模式
1.1 思想
* 1.定义一个接口
* 2.定义一个实现类
* 3.定义一个根据传入参数，产生对象的工厂类
* 4.通过工厂类调用具体对象的方法
1.2 案例
1.2.1 接口
public interface BankInfo {
public void payMoney();
}
1.2.2 实现类
public class BocBank implements BankInfo{
@Override
public void payMoney() {
System.out.println("中国银行取钱50元");
}
}
public class IcbcBank implements BankInfo{
@Override
public void payMoney() {
System.out.println("工商银行银行取钱50元");
}
}
1.2.3 工厂类
public class ObjectFactory {
public BankInfo buildObjectInfo(String str){
if (str == null){
return null;
}
else if ("boc".equals(str)) {
return new BocBank();
}
else if ("icbc".equals(str)) {
return new IcbcBank();
}
else {
return null;
}
}
}
1.2.4 调用
/**
* @ClassName: TestFt
* @Description: TODO
* @Author: admin
* 1.定义一个接口
* 2.定义一个实现类
* 3.定义一个根据传入参数，产生对象的工厂类
* 4.通过工厂类调用具体对象的方法
*
*
* @Date: 2024/08/01 20:56:05
* @Version: V1.0
**/
public class TestFt {
public static void main(String[] args) {
ObjectFactory objectFactory = new ObjectFactory();
BankInfo bankInfoBank = objectFactory.buildObjectInfo("icbc");
bankInfoBank.payMoney();
}
}二 策略模式
2.1 思想
1.定义一个策略接口，在接口中声明一个行为方法
* 2.定义多个策略实现类，并实现策略接口，重写行为方法，实现各自逻辑
* 3.定义一个context上下文，用于调用具体的策略方法，供客户端使用；通过new context的构造函数传入策略对象，然后通过此对象调用策略行为方法。
2.2 案例
2.2.1 接口
public interface BankInfo {
public void payMoney(int a,int b);
}
2.2.2 实现类
public class BocBank implements BankInfo{
@Override
public void payMoney(int a,int b) {
System.out.println("中国银行，累加："+(a+b));
}
}
public class IcbcBank implements BankInfo{
@Override
public void payMoney(int a, int b) {
System.out.println("中国工商银行，扣减："+(a-b));
}
}
2.2.3 策略类
public class StaragePattern {
private BankInfo bankInfo;
public StaragePattern(BankInfo bankInfo) {
this. bankInfo = bankInfo;
}
public void contextInfo(int a,int b){
bankInfo.payMoney(a,b);
}
}
2.2.4 调用
/**
* @ClassName: TestS
* @Description: TODO
* 1.定义一个策略接口，在接口中声明一个行为方法
* 2.定义多个策略实现类，并实现策略接口，重写行为方法，实现各自逻辑
* 3.定义一个context上下文，用于调用具体的策略方法，供客户端使用；通过new context的构造函数传入策略对象，然后通过此对象调用策略行为方法。
* https://zhuanlan.zhihu.com/p/680317010
* @Author: admin
* @Date: 2024/08/02 11:28:34
* @Version: V1.0
**/
public class TestS {
public static void main(String[] args) {
// StaragePattern staragePattern = new StaragePattern(new BocBank());
// staragePattern.contextInfo(30,20);
}
}三 工厂模式+策略模式
3.1 思想
1.定义接口实现InitializingBean，重写 void afterPropertiesSet()，在服务启动时候，自动执行子类中的afterPropertiesSet()方法。
3.2 案例
3.2.1 接口
public interface HandlerStrategyFactory extends InitializingBean {
void getCoca(String parameter);
}
3.2.2 实现类
@Component
public class CocaHandlerV2 implements HandlerStrategyFactory{
@Override
public void getCoca(String parameter)
{
System.out.println("我是可口可乐-策略+工厂 "+parameter);
}
@Override
public void afterPropertiesSet() throws Exception
{
//K //V
Factory.register("Coca",this);
}
}
@Component
public class PepsiHandlerV2 implements HandlerStrategyFactory{
@Override
public void getCoca(String parameter)
{
System.out.println("我是百事可乐-策略+工厂 "+parameter);
}
@Override
public void afterPropertiesSet() throws Exception
{
Factory.register("Pepsi",this);
}
}
3.2.3 定义Factory
public class Factory {
private static Map<String, HandlerStrategyFactory> strategyMap = new ConcurrentHashMap<>();
public static HandlerStrategyFactory getInvokeStrategy(String str)
{
return strategyMap.get(str);
}
public static void register(String str ,HandlerStrategyFactory handler)
{
System.out.println("str: "+str+"\t handler: "+handler);
if (null == str || null == handler)
{
return;
}
strategyMap.put(str,handler);
}
}
3.2.4 调试
@SpringBootTest
public class DesignPatternTest
{
/**
* 策略+工厂V2
*/
@Test
public void methodV2()
{
String parameter = "Coca";
HandlerStrategyFactory invokeStrategy = Factory.getInvokeStrategy(parameter);
invokeStrategy.getCoca(parameter);
}
}
结果图：
