巨巨巨实用的设计模式-策略模式

策略模式

策略模式是一种常见的设计模式，用于封装不同的算法，并使其可以相互替换。

通过使用策略模式，可以使代码更加灵活、可扩展和易于维护。在实际开发中，我们可以使用策略模式来解决各种不同的问题。

主要是规范化代码，避免if，else的来回嵌套。

比如，我们所在的是个做早餐的公司，开拓市场的时候势必要调研喜好，这个时候我们就需要根据所对应的省份人群的喜好来搭配一个基础套餐，正常在代码中我们可能要用很多嵌套比如：

public static void main(String[] args) {
    String province = "广东";
    /*根据业务的扩展可能会新增很多省份的子公司*/
    if (province.equals("广东")){
        System.out.println("广东人喜好的早餐搭配");
    } else if (province.equals("山西")) {
        System.out.println("山西喜好的早餐搭配");
    } else if (province.equals("河南")) {
        System.out.println("河南喜好的早餐搭配");
    }
}

这里因为代码中没有逻辑所以看着不费劲，在实际的工作中会有很多业务逻辑，使得代码的可读性变得很差，这里我们使用策略模式可以让代码更加清晰明了，策略模式首先的话可以用接口或者抽象类来实现，首先我们要定义一个接口：(接口的定义可以规范实现类的入参和出参，让实现类规范)

package com.yxb.service;

import com.yc.dompet.enums.order.MorningTeaEnum;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public interface BreakfastService {
    Object breakFastFangan();
}

然后我们的实现类来继承接口：

package com.yxb.service.impl;
​
import com.yc.dompet.enums.order.MorningTeaEnum;
import com.yxb.service.BreakfastService;
​
/**
 * @author : loong
 * @Description:
 * @Date: 2024-09-18
 */
public class GuangdongBreakfastImpl implements BreakfastService {
​
    @Override
    public Object breakFastFangan() {
        String reganmian = MorningTeaEnum.CHANGFEN.breakfast;
        String hulatang = MorningTeaEnum.HAIXIANZHOU.breakfast;
        String ren = ("广东人的早餐热衷于"+"吃："+reganmian+"，喝："+hulatang);
        return ren;
    }
}

package com.yxb.service.impl;
​
import com.yc.dompet.enums.order.MorningTeaEnum;
import com.yxb.service.BreakfastService;
​
import java.util.List;
​
/**
 * @author : loong
 * @Description:
 * @Date: 2024-09-18
 */
public class HenanBreakfastImpl implements BreakfastService {
​
    @Override
    public Object breakFastFangan() {
        String hulatang = MorningTeaEnum.HULATANG.breakfast;
        String reganmian = MorningTeaEnum.REGANMIAN.breakfast;
        String ren = ("河南人的早餐热衷于"+"吃："+reganmian+"，喝："+hulatang);
        return ren;
    }
}

package com.yxb.service.impl;
​
import com.yc.dompet.enums.order.MorningTeaEnum;
import com.yxb.service.BreakfastService;
​
/**
 * @author : loong
 * @Description:
 * @Date: 2024-09-18
 */
public class ShanxiBreakfastImpl implements BreakfastService {
​
    @Override
    public Object breakFastFangan() {
        String hulatang = MorningTeaEnum.MAOERDUO.breakfast;
        String reganmian = MorningTeaEnum.CU.breakfast;
        String ren = ("山西人的早餐热衷于"+"吃："+reganmian+"，喝："+hulatang);
        return ren;
    }
}

然后在定义一个可以进行实现类之间进行来回切换的类，这个类里的构造器里我们要放上我们的接口，并定义一个方法，以便我们使用那些实现类：（上下文切换）

package com.yxb.service.impl;
​
import com.yxb.service.BreakfastService;
​
/**
 * @author : loong
 * @Description:
 * @Date: 2024-09-18
 */
public class BreakfastContxt {
    private BreakfastService breakfastService;
​
    public BreakfastContxt(BreakfastService breakfastService) {
        this.breakfastService = breakfastService;
    }
    public Object breank(){
​
        return this.breakfastService.breakFastFangan();
    }
}

然后我们就可以在实际使用中通过我们上下文切换的类来调用所需的业务逻辑了

package com.yxb.service.impl;
​
/**
 * @author : loong
 * @Description:
 * @Date: 2024-09-18
 */
public class breakFastDemo {
    public static void main(String[] args) {
        /*通过上下文切换的类，里面放上我们所需要的实现类就可以使用了*/
        BreakfastContxt breakfastContxt = new BreakfastContxt(new ShanxiBreakfastImpl());
        Object breank = breakfastContxt.breank();
        System.out.println(breank.toString());
    }
​
}

最近工作巨忙，没时间学习，今天学习了一下策略模式，很有用的一种模式！
​