设计模式策略模式

简介

策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

代码实现

看了菜鸟教程的策略模式，刚开始似乎有点蒙，不太理解，之后看了一些大佬博客之后理解了一些，接下来自己实现以下策略模式。

我们模拟一个场景，假设你要约你的女神吃饭，但是又不知道她喜欢吃什么口味的，这个时候你就要讲究一下策略了。

/**
 * 首先定义一个餐厅接口
 * */
public interface Restaurant {
    Dish cook();
}

然后你需要去找制作各种菜品的餐厅

/**
 * 川菜馆
 * */
public class SzechuanRestaurant implements Restaurant {
    @Override
    public Dish cook() {
        // 制作川菜
        SichuanCuisine sichuanCuisine = new SichuanCuisine("这是川菜");
        return sichuanCuisine;
    }
}

/**
 * 湘菜馆
 * */
public class HunanRestaurant implements Restaurant {
    @Override
    public Dish cook() {
        // 制作湘菜
        HunanCuisine hunanCuisine = new HunanCuisine("这是湘菜");
        return hunanCuisine;
    }
}

/**
 * 西餐厅
 * */
public class WesternRestaurant implements Restaurant {
    @Override
    public Dish cook() {
        // 制作西餐
        EuropeanFood europeanFood = new EuropeanFood("这是西餐");
        return europeanFood;
    }
}

/**
 * 火锅店
 * */
public class HotPotRestaurant implements Restaurant {
    @Override
    public Dish cook() {
        // 制作火锅
        HotPot hotPot = new HotPot("这是火锅");
        return hotPot;
    }
}

餐厅找好了肯定需要这些餐厅准备好相应的菜品，首先定义菜品类。

/**
 * 菜品类，所有菜品都继承与此
 * */
public class Dish {
    Dish(String introduce){
        System.out.println(introduce);
    }
}

然后就是准备各种不同菜品

/**
 * 定义川菜
 * */
public class SichuanCuisine extends Dish {
    SichuanCuisine(String introduce) {
        super(introduce);
    }
}

/**
 * 定义湘菜
 * */
public class HunanCuisine extends Dish {
    HunanCuisine(String introduce) {
        super(introduce);
    }
}

/**
 * 定义西餐
 * */
public class EuropeanFood extends Dish {
    EuropeanFood(String introduce) {
        super(introduce);
    }
}

/**
 * 定义火锅
 * */
public class HotPot extends Dish {
    HotPot(String introduce) {
        super(introduce);
    }
}

好了，所有的餐厅和菜品都已经准备好了，接下来就是很重要的一步了，你需要制作个类似于“菜单”一样的东西把上面准备的东西放上去，然后拿着它让女神选择吃什么，女神选什么你们就去吃什么。

/**
 * 选择菜单
 * */
public class Selector {
    private Restaurant restaurant;

    // 决定去哪个餐厅
    public void setRestaurant(Restaurant restaurant) {
        this.restaurant = restaurant;
    }

    // 制作出菜品
    public Dish cook(){
        return restaurant.cook();
    }
}

测试

好了，所有东西都准备好之后就可以去约你的女神了

public class StrategyTest {
    public static void main(String[] args) {
        // 带着你的“菜单”去约女神
        Selector selector = new Selector();

        // 选择川菜馆
        selector.setRestaurant(new SzechuanRestaurant());
        selector.cook();

        // 选择湘菜馆
        selector.setRestaurant(new HunanRestaurant());
        selector.cook();

        // 选择西餐厅
        selector.setRestaurant(new WesternRestaurant());
        selector.cook();

        // 选择火锅
        selector.setRestaurant(new HotPotRestaurant());
        selector.cook();
    }
}

输出

这是川菜
这是湘菜
这是西餐
这是火锅

应用场景

• 针对同一类型问题的多种处理方式，仅仅是具体行为有差别时；
• 需要安全地封装多种同一类型的操作时；
• 出现同一抽象类有多个子类，而又需要使用 if-else 或者 switch-case 来选择具体子类时。

当然也可以去约你的女神啦 []~(￣▽￣)~*

本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名,转载请标明出处
最后编辑时间为: 2018/10/17 19:50