java 设计模式 策略模式 以英雄联盟为背景

继续java设计模式学习之旅，
策略模式（Strategy Pattern）：定义了算法族，分别封装起来，让它们之间可相互替换，此模式让算法的变化独立于使用算法的客户。
可能看完之后还是很迷糊，但是有一个印象，方便阅读下面代码时候的思路理解。（本人是一名android讲师，这个也是很多学员喜欢犯的错误，不愿意看定义理论介绍，这样理解和统一思路就很难了）
话不多说，开始我们的游戏：
游戏设定角色有：Q、W、E、R和两个被动技能。
定义抽象父类Role：

package role;

public abstract class Role {


    public abstract void q();
    public abstract void w();
    public abstract void e();
    public abstract void r();
    public abstract void d();

}

现在有一个角色A，q技能眩晕效果，w技能加速效果，e技能减速效果，r技能击飞效果，d是闪现
角色A代码

package role;

public class RoleA extends Role{

    @Override
    public void q() {
        System.out.println("眩晕效果");

    }

    @Override
    public void w() {
        System.out.println("加速效果");

    }

    @Override
    public void e() {
        System.out.println("减速效果");

    }

    @Override
    public void r() {
        System.out.println("击飞效果");
    }

    @Override
    public void d() {
        System.out.println("闪现效果");

    }

}

我们利用面向对象的思想设计了角色A，这个时候如果添加了新的角色呢?
RoleB:q眩晕、w伤害、e、减速、r击飞、d闪现
RoleC::q眩晕、w伤害、e、护盾、r击飞、d闪现

package role;

public class RoleB extends Role{

    @Override
    public void q() {
        System.out.println("眩晕效果");

    }

    @Override
    public void w() {//和A的不一样
        System.out.println("伤害效果");

    }

    @Override
    public void e() {
        System.out.println("减速效果");

    }

    @Override
    public void r() {
        System.out.println("击飞效果");
    }

    @Override
    public void d() {
        System.out.println("闪现效果");

    }

}

package role;

public class RoleC extends Role{

    @Override
    public void q() {
        System.out.println("眩晕效果");

    }

    @Override
    public void w() {
        System.out.println("加速效果");

    }

    @Override
    public void e() {//和A的不一样
        System.out.println("护盾效果");

    }

    @Override
    public void r() {
        System.out.println("击飞效果");
    }

    @Override
    public void d() {
        System.out.println("闪现效果");

    }

}

有创建了两个角色，但是发现很多重复的代码在里面，那么就要重新设计一下架构了，首先想到的就是使用接口，每个角色实现接口去实现不同的技能，但是接口不能实现代码复用，所以此路不同。于是你会想一下设计原则：遵循设计的原则，找出应用中可能需要变化的部分，把它们独立出来，不要和那些不需要变化的代码混在一起。这边改变的就是各种技能。再根据另一个设计原则：针对接口（超类型）编程，而不是针对实现编程，于是我们把代码改造成这样：

package skill;

public interface SkillQ {

    void q();
}

package skill;

public interface SkillW {

    void w();
}

package skill;

public interface SkillE {

    void e();
}

package skill;

public interface SkillR {

    void r();
}

package skill;

public interface SkillD {

    void d();
}

定义了不同技能的接口，接下来去实现不同的技能

package bean;

import skill.SkillQ;

public class QXY implements SkillQ{

    public void q() {
        System.out.println("眩晕效果");

    }

}

package bean;

import skill.SkillW;

public class WJiaS implements SkillW{

    public void w() {
        System.out.println("加速效果");

    }

}

package bean;

import skill.SkillW;

public class WSS implements SkillW{

    public void w() {
        System.out.println("伤害效果");

    }

}

不同的接口和技能实现类都写好了，需要重构Role父类

package role;

import skill.SkillD;
import skill.SkillE;
import skill.SkillQ;
import skill.SkillR;
import skill.SkillW;

public abstract class Role {
    private SkillQ skillQ;
    private SkillW skillW;
    private SkillE skillE;
    private SkillR skillR;
    private SkillD skillD;

    public Role setSkillQ(SkillQ skillQ) {
        this.skillQ = skillQ;
        return this;
    }
    public Role setSkillW(SkillW skillW) {
        this.skillW = skillW;
        return this;
    }
    public Role setSkillE(SkillE skillE) {
        this.skillE = skillE;
        return this;
    }
    public Role setSkillR(SkillR skillR) {
        this.skillR = skillR;
        return this;
    }
    public Role setSkillD(SkillD skillD) {
        this.skillD = skillD;
        return this;
    }

    public void q(){
        skillQ.q();
    }
    public void w(){
        skillW.w();
    }
    public void e(){
        skillE.e();
    }
    public void r(){
        skillR.r();
    }
    public void d(){
        skillD.d();
    }

}

重构RoleA：

package role;

public class RoleA extends Role{

}

测试类：

package test;

import role.RoleA;
import bean.DShanXian;
import bean.EJianSu;
import bean.QXY;
import bean.RJiFei;
import bean.WJiaS;

public class Test {

    public static void main(String[] args) {
        RoleA roleA=new RoleA();
        roleA.setSkillQ(new QXY())
        .setSkillW(new WJiaS())
        .setSkillE(new EJianSu())
        .setSkillR(new RJiFei())
        .setSkillD(new DShanXian());

        roleA.q();
        roleA.w();
        roleA.e();
        roleA.r();
        roleA.d();

    }
}

结果：

眩晕效果
加速效果
减速效果
击飞效果
闪现效果

看着创建了很多的java文件，其实每个技能我们都去单独管理。
我们已经定义了一个算法族（各种技能），且根据需求可以进行相互替换，算法（各种技能）的实现独立于客户（角色）。现在是不是很好理解策略模式的定义了。

java的面向对象的设计思想，每种功能的独立面向接口的设计，不同功能不同实现，相互独立。

一边学习，一边记录。