由一只鸭子引发的模式---策略模式

作者:故事我忘了^￠
个人微信公众号:程序猿的月光宝盒

---

不算是教程,充其量(本来就)是个笔 ji叭,但也希望不会浪费你的阅读时间~

----------------------------------[Head First 设计模式] 笔记

前置知识:

需要了解java的:

1.封装

2.继承

3.多态

4.抽象

前三也称为java的三大特性

Demo描述：（OO原则解决方式）

一只未知品种的鸭子,众所周知,所有鸭子都会游泳(春江水暖鸭先知),有的鸭子会飞(玩具鸭,绑上飞行器/本来就会飞,方式不同),有的鸭子会叫(玩具鸭也会叫,只是叫声不同)

第一反应其实就是用继承的方法,本来嘛,都是鸭子,都会飞,都会叫,个别的让子类重写不就完了吗

但是,老金要说但是了.假设,我作为小丑鸭子类,我本来就不需要会飞,我也不想飞,为什么你要让我实现对应的飞的功能,要飞天空任你飞,大不了伤痛我来背

这里就引出了第一个设计原则:

一.开闭原则

找出应用中可能需要改变的地方,把他们独立出来,不要和那些不需要变化的混在一起

对修改关闭,对拓展开放

那么在程序中,怎么用设计模式实现这一场景呢?

0. 整体类图

首先我们来看一下整体的UML类图,这个类图是用idea自动生成的,默认快捷键是..我百度一下,嗯 ,还是我的这篇博客 idea快捷键 里面写了

ctrl+shift+alt+u

我们来试一下:

由上可知,有个MallardDuck(绿头鸭) 继承于 鸭子父类,而这个父类里面仅仅是只有对应的行为属性,对应的行为属性也是个接口,具体类图如下:

这样的设计,可以让飞行和呱呱叫的动作被其他对象复用,因为这些行为已经跟鸭子无关了.

而我们能新增一些行为,不会影响到已经有的行为类,也不会影响使用了已经存在的行为的具体鸭子类

这里用到了两个设计原则:

二.依赖倒转原则

依赖于抽象的类,而不要依赖于具体的类;

针对接口或抽象类编程 ,而不是针对具体类编程

三. 组合/聚合复用原则

多用组合,少用继承

好了 我们上代码

1. 具体代码

1.1 关于鸭子

1.1.1 鸭子父类: Duck.java

package firstDuck.duck;

import firstDuck.behavior.IFlyBehavior;
import firstDuck.behavior.IQuackBehavior;

/**
 * 鸭子父类(抽象)
 */
public abstract class Duck {
    /** 飞的行为 定义为接口,在运行时,持有特定行为的引用*/
    protected IFlyBehavior iFlyBehavior;
    /** 叫的行为 也是被定义为接口*/
    protected IQuackBehavior iQuqBehavior;


    public Duck() {
    }

    /**
     * 调用飞的行为去飞
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:25
     */
    public void doFly() {
        this.iFlyBehavior.fly();
    }

    /**
     * 调用叫的行为去叫
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:25
     */
    public void doQuack() {
        this.iQuqBehavior.quack();
    }

    /**
     * 显示外观 相当于toString
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 22:54
     */
    public abstract void display();

    public void swim() {
        System.out.println("所有的鸭子都会浮在水面上~");
    }
}

1.1.2 鸭子子类(可以有很多这里举例1) MallardDuck.java

package firstDuck.duck.duckSon;

import firstDuck.behavior.impl.FlyWithWings;
import firstDuck.behavior.impl.Quack;
import firstDuck.duck.Duck;

/**
 * 绿头鸭
 *
 * @author 金聖聰
 * @email jinshengcong@163.com
 * @version v1.0
 * @date 2021/01/13 22:55
 */
public class MallardDuck extends Duck {

    /**
     * 绿头鸭构造器
     *
     * @return null
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:35
     */
    public MallardDuck() {
        /* 绿头鸭调用Quack类处理正真的呱呱叫 */
        super.iQuqBehavior = new Quack();
        /* 绿头鸭调用FlyWithWings类处理正真的飞行 */
        super.iFlyBehavior = new FlyWithWings();
    }

    public void display() {
        System.out.println("我是一个真正的绿头鸭");
    }
}

1.2 关于行为

1.2.1 飞行的行为 IFlyBehavior.java

这是一个接口,所有飞行类都实现他,所有的飞行类都必须实现fly()方法

package firstDuck.behavior;

/**
 * 飞行的行为
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public interface IFlyBehavior {
    /**
     * 飞行
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:11
     */
    void fly();
}

1.2.1.1 飞行行为的实现类 FlyNoWay.java

package firstDuck.behavior.impl;

import firstDuck.behavior.IFlyBehavior;

/**
 * 不能飞
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class FlyNoWay implements IFlyBehavior {
    @Override
    public void fly() {
        System.out.println("我不能飞啊喂~");
    }
}

1.2.1.2 飞行行为的实现类 FlyWithWings.java

package firstDuck.behavior.impl;

import firstDuck.behavior.IFlyBehavior;

/**
 * 翅膀飞
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class FlyWithWings implements IFlyBehavior {
    @Override
    public void fly() {
        System.out.println("用翅膀飞~");
    }
}

1.2.2 叫的行为 IQuackBehavior.java

叫的行为也一样,所有叫的类都实现他,所有的会叫的类都必须实现quack()方法

package firstDuck.behavior;

/**
 * description
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public interface IQuackBehavior {
    /**
     * 叫
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:11
     */
    void quack();
}

1.2.2.1 叫的行为的实现类 Quack.java

package firstDuck.behavior.impl;

import firstDuck.behavior.IQuackBehavior;

/**
 * 鸭子嘎嘎叫
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class Quack implements IQuackBehavior {
    @Override
    public void quack() {
        System.out.println("我真鸭子,我嘎嘎叫~");
    }
}

1.2.2.2 叫的行为的实现类 Squeak.java

package firstDuck.behavior.impl;

import firstDuck.behavior.IQuackBehavior;

/**
 * 橡皮鸭子吱吱叫
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class Squeak implements IQuackBehavior {
    @Override
    public void quack() {
        System.out.println("我橡皮鸭子,我吱吱叫~");
    }
}

1.2.2.3 叫的行为的实现类 Squeak.java

package firstDuck.behavior.impl;

import firstDuck.behavior.IQuackBehavior;

/**
 * 哑巴鸭不会叫
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class MuteQuack implements IQuackBehavior {
    @Override
    public void quack() {
        System.out.println("我不会叫~~");
    }
}

1.3 测试类

package firstDuck.test;

import firstDuck.duck.Duck;
import firstDuck.duck.duckSon.MallardDuck;

/**
 * 迷你鸭子模拟器 测试类
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class MiniDuckSimulator {
    public static void main(String[] args) {
        /* 绿头鸭 */
        Duck mallard = new MallardDuck();
        mallard.display();
        mallard.doFly();
        mallard.doQuack();
    }
}

输出:

所以,绿头鸭会真的嘎嘎叫,因为,在构造实例时,构造器会把继承来的iQuqBehavior初始化成Quack类型的新实例,

同样的处理方式也用在飞行行为上

3. 思考一下

在绿头鸭的构造器中,这里是在干啥

public MallardDuck() {
        /* 绿头鸭调用Quack类处理正真的呱呱叫 */
        super.iQuqBehavior = new Quack();
        /* 绿头鸭调用FlyWithWings类处理正真的飞行 */
        super.iFlyBehavior = new FlyWithWings();
    }

根据开头引出的设计原则之依赖倒转原则,不是应该针对接口编程吗,这里怎么又针对实现编程了,你在构造一个具体的叫的行为和飞的行为的实现类啊哥?靠谱一点啊老金~

行,谁说我不靠谱老子锤爆你的头~[doeg保命.gif]

一步一步来吗~

刚开始在鸭子类里建立了一堆动态行为属性(其实就俩)没有用到嘛_{现在用一下咯}

3.1 改造开始:

3.1.1 首先是鸭子类Duck.java

package firstDuck.duck;

import firstDuck.behavior.IFlyBehavior;
import firstDuck.behavior.IQuackBehavior;

/**
 * 鸭子父类(抽象)
 */
public abstract class Duck {
    /** 飞的行为 定义为接口,在运行时,持有特定行为的引用*/
    protected IFlyBehavior iFlyBehavior;
    /** 叫的行为 也是被定义为接口*/
    protected IQuackBehavior iQuqBehavior;

    /**
     * 新增飞行的setter方法
     * @param iFlyBehavior 飞的行为
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/18 23:50
     */
    public void setiFlyBehavior(IFlyBehavior iFlyBehavior) {
        this.iFlyBehavior = iFlyBehavior;
    }

    /**
     * 新增叫的setter方法
     * @param iQuqBehavior 叫的行为
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/18 23:51
     */
    public void setiQuqBehavior(IQuackBehavior iQuqBehavior) {
        this.iQuqBehavior = iQuqBehavior;
    }

    public Duck() {
    }

    /**
     * 调用飞的行为去飞
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:25
     */
    public void doFly() {
        this.iFlyBehavior.fly();
    }

    /**
     * 调用叫的行为去叫
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 23:25
     */
    public void doQuack() {
        this.iQuqBehavior.quack();
    }

    /**
     * 显示外观 相当于toString
     *
     * @return void
     * @author 金聖聰
     * @email jinshengcong@163.com
     * @version v1.0
     * @date 2021/01/13 22:54
     */
    public abstract void display();

    public void swim() {
        System.out.println("所有的鸭子都会浮在水面上~");
    }
}

也就是新增两个setter方法,动态设置成员变量

从此以后,我们可以随时动态调用这两个方法改变鸭子的行为,就相当于脑子里植入了芯片,被人为所欲为~啧啧啧

测一下测一下

3.1.2 然后是新建子类 ModelDuck.java

package firstDuck.duck.duckSon;

import firstDuck.behavior.impl.FlyNoWay;
import firstDuck.behavior.impl.MuteQuack;
import firstDuck.duck.Duck;

/**
 * description
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class ModelDuck extends Duck {
    public ModelDuck(){
        /* 一开始不会飞  */
        super.iFlyBehavior = new FlyNoWay();
        /* 一开始不会叫  */
        super.iQuqBehavior = new MuteQuack();
    }

    @Override
    public void display() {
        System.out.println("我是模型鸭子");
    }
}

3.1.3 新建一个飞行行为让火箭飞! FlyByRocket.java

package firstDuck.behavior.impl;

import firstDuck.behavior.IFlyBehavior;

/**
 * description
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class FlyByRocket implements IFlyBehavior {
    @Override
    public void fly() {
        System.out.println("插了火箭了,上天,冲干饭鸭~");
    }
}

3.1.4 修改测试类

package firstDuck.test;

import firstDuck.behavior.impl.FlyByRocket;
import firstDuck.duck.Duck;
import firstDuck.duck.duckSon.MallardDuck;
import firstDuck.duck.duckSon.ModelDuck;

/**
 * 迷你鸭子模拟器 测试类
 *
 * @author 金聖聰
 * @version v1.0
 * @email jinshengcong@163.com
 */
public class MiniDuckSimulator {
    public static void main(String[] args) {
        /* 绿头鸭 */
        Duck mallard = new MallardDuck();
        mallard.display();
        mallard.doFly();
        mallard.doQuack();
        System.out.println();
        System.out.println("-----------改造后------------");
        Duck modelDuck = new ModelDuck();
        modelDuck.display();
        modelDuck.doQuack();
        modelDuck.doFly();
        /* 一开始是不会飞的,直到我给他插了火箭,摇身一变冲天干饭鸭  */
        modelDuck.setiFlyBehavior(new FlyByRocket());
        /* 现在插了火箭了,看看阿能飞了 */
        modelDuck.doFly();
    }
}

运行结果:

好了,恭喜~get策略模式

那最终官方的策略模式定义是什么呢?背下来,适合装逼~

定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户

怎么背啊,淦?

算法族想像成刚才的飞行方式,有这么多飞行方式需要用,是不是定义了一个接口用来封装?然后具体用的时候只要new具体的行为方式到setter方法里就能动态改变了?具体的模型鸭子还是不会飞吧,插火箭这个动作是你插的吧,你能插,也能拔吧?

我没有开车,get out~

所以上边的助记就是

定义了算法族(行为方式),分别封装起来(做成接口),让他们之间可以互相替换(动态set调用),此模式让算法(行为)的变化独立于使用算法(行为)的客户

总结一下:

设计原则:

1.开闭原则

对修改关闭,对拓展开放,找出程序中变化的部分,封装独立出来

2.依赖倒转

依赖于抽象,而不依赖于具体;

针对接口/抽象编程,不针对具体类编程

3.组合复用

多用组合,少用继承

4.策略模式定义

定义了算法族,分别封装起来,以让他们可以互相替换,此模式可以让算法的变化独立于使用算法的客户