设计模式之策略模式

设计模式之策略模式，本文记录设计模式学习过程中的一些思考。

策略模式

1. 为什么用

       工作中，往往会对接很多性质相同但逻辑不同的平台 或者 实现很多大部分功能相同但些许细节不同的协议，此时，利用java OO思想，一个抽象类多个实现类的这种方式，在需求变更中更改的代码逻辑较多，代码复杂度过高。故而使用策略模式，将不同的功能抽取出来形成接口族，来降低代码复杂度，以及实现类功能冗余的问题。

2. 怎么用

        文字描述：超类【抽象类】中增加不同部分的接口，并内置调用接口的方法。 子类按需内置接口的实现类。从而实现继承了超类的子类按需选择功能逻辑。

        代码实现：

package org.example.strategy.model.supper;

import org.example.strategy.service.behavior.FlyBehavior;
import org.example.strategy.service.behavior.QuackBehavior;

/**
 * 鸭子超类
 */
public abstract class Duck {

    public FlyBehavior mFlyBehavior;
    public QuackBehavior mQuackBehavior;

    public Duck() {

    }

    public void Fly() {
        mFlyBehavior.fly();
    }
    public void Quack() {
        mQuackBehavior.quack();
    }

    public void setFlyBehavior(FlyBehavior mFlyBehavior) {
        this.mFlyBehavior = mFlyBehavior;
    }

    public void setQuackBehavior(QuackBehavior mQuackBehavior) {
        this.mQuackBehavior = mQuackBehavior;
    }

    public abstract void display();

}

package org.example.strategy.model.bean;

import org.example.strategy.model.supper.Duck;
import org.example.strategy.service.behavior.impl.FlyBehaviorDD;
import org.example.strategy.service.behavior.impl.QuackBehaviorDD;

public class GreenDuck extends Duck {

    public GreenDuck() {
        mFlyBehavior = new FlyBehaviorDD();
        mQuackBehavior = new QuackBehaviorDD();
    }

    @Override
    public void display() {
        System.out.println("我是小小绿头鸭");
    }

}

package org.example.strategy.model.bean;

import org.example.strategy.model.supper.Duck;
import org.example.strategy.service.behavior.impl.FlyBehaviorDD;
import org.example.strategy.service.behavior.impl.QuackBehaviorDD;

public class RedDuck extends Duck {


    public RedDuck() {
        mFlyBehavior = new FlyBehaviorDD();
        mQuackBehavior = new QuackBehaviorDD();
    }

    @Override
    public void display() {
        System.out.println("我是红色大鸭子");
    }

}

package org.example.strategy.service.behavior;

/**
 * 叫声
 */
public interface QuackBehavior {
    void quack();
}

package org.example.strategy.service.behavior;

/**
 * 飞
 */
public interface FlyBehavior {
    void fly();
}

package org.example.strategy.service.behavior.impl;

import org.example.strategy.service.behavior.FlyBehavior;

public class FlyBehaviorBad implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞的贼笨");
    }
}

package org.example.strategy.service.behavior.impl;

import org.example.strategy.service.behavior.FlyBehavior;

public class FlyBehaviorGood implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("我嘎嘎会飞");
    }
}

package org.example.strategy.service.behavior.impl;

import org.example.strategy.service.behavior.QuackBehavior;

public class QuackBehaviorBuBu implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("BuBu~~");
    }
}

package org.example.strategy.service.behavior.impl;

import org.example.strategy.service.behavior.FlyBehavior;


public class FlyBehaviorDD implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞的兜底");
    }
}

package org.example.strategy.service.behavior.impl;

import org.example.strategy.service.behavior.QuackBehavior;

public class QuackBehaviorDD implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("DouDi~~");
    }
}

package org.example.strategy.service.behavior.impl;

import org.example.strategy.service.behavior.QuackBehavior;

public class QuackBehaviorGaGa implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("GaGa～～");
    }
}

package org.example.strategy.start;

import org.example.strategy.model.bean.GreenDuck;
import org.example.strategy.model.bean.RedDuck;
import org.example.strategy.service.behavior.impl.FlyBehaviorBad;
import org.example.strategy.service.behavior.impl.FlyBehaviorGood;
import org.example.strategy.service.behavior.impl.QuackBehaviorBuBu;
import org.example.strategy.service.behavior.impl.QuackBehaviorGaGa;

/**
 * 策略模式：
 * 分别封装行为接口，实现算法族，超类里访行为接口对象，子类里指定具体的行为对象
 * 原则：
 * 分离变化部分，封装接口，基于接口编程各种功能。此模式让行为算法的变化独立于算法使用者
 */
public class StrategyStart {

    public static void main(String[] args) {
        GreenDuck greenDuck = new GreenDuck();
        RedDuck redDuck = new RedDuck();

        greenDuck.display();
        greenDuck.Fly();
        greenDuck.Quack();
        System.out.println("~~~~~~~~~~~~~~~~");

        redDuck.display();
        redDuck.Fly();
        redDuck.Quack();
        System.out.println("~~~~~~~~~~~~~~~~");

        greenDuck.setFlyBehavior(new FlyBehaviorGood());
        greenDuck.setQuackBehavior(new QuackBehaviorBuBu());
        redDuck.setFlyBehavior(new FlyBehaviorBad());
        redDuck.setQuackBehavior(new QuackBehaviorGaGa());

        greenDuck.display();
        greenDuck.Fly();
        greenDuck.Quack();
        System.out.println("~~~~~~~~~~~~~~~~");

        redDuck.display();
        redDuck.Fly();
        redDuck.Quack();
        System.out.println("~~~~~~~~~~~~~~~~");
    }

}

3. 解决了什么问题，好处是什么

        解决了需求不断变更，导致的代码逻辑混乱，复杂度过高的问题，以及实现类功能冗余的问题。

写的很好 ⬇️

设计模式之策略模式详解_设计模式 策略模式-CSDN博客