策略模式

设计场景

动作冒险游戏，游戏中有一系列角色(Character)，包括国王(King)、皇后(Queen)、骑士(Knight)、妖怪(Troll),这些角色可以在游戏中每一次使用一个武器(Weapon)来攻击对方，并且可以在运行时切换武器，为了增加游戏的乐趣，可以有的武器包括：匕首、宝剑、斧头、弓箭等等，可能以后又更时髦的武器出现。请设计该场景。
从游戏的场景看：角色、武器应设计为聚合关系
从字面上看：角色使用武器攻击对方角色，临时依赖的关系
Character.attack(Character,weapon)依赖关系

代码

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Character {
    String name = "";
    int xue = 0;
    String camp = null;

    public void attack(Character character,Weapon weapon) {
        System.out.println(this.getName()+"攻击了"+character.getName() + "-------" + character.getName() + "损失了" + weapon.getATK() + "血,hp变成了"+(character.getXue()-weapon.getATK()));
        character.setXue(character.getXue()-weapon.getATK());
    }

}

@Data
@NoArgsConstructor
public abstract class Weapon {
    int ATK = 0;
}

public class King extends Character{

    public King(String name, int hp, String s1) {
        this.name = name;
        this.xue = hp;
        this.camp = s1;
    }
}

public class Knight extends Character{

    public Knight(String name, int hp,  String s1) {
            this.name = name;
            this.xue = hp;
            this.camp = s1;
    }
}

public class Queen extends Character{

    public Queen(String name, int hp, String s1) {
            this.name = name;
            this.xue = hp;
            this.camp = s1;
    }

    @Override
    public void attack(Character character, Weapon weapon) {
        System.out.println("皇后技能二连击");
        for (int i = 0; i < 2; i++) {
            super.attack(character, weapon);
        }
    }
}

public class Troll extends Character{
    public Troll(String name, int hp,String s1) {
        this.name = name;
        this.xue = hp;
        this.camp = s1;
    }
}

public class Sword extends Weapon{

    public Sword(int i) {
        this.setATK(i);
    }
}

public class Main {
    public static void main(String[] args) {
        King king = new King("国王",400,"黑");
        Queen queen = new Queen("皇后",400,"白");
        Knight knight = new Knight("骑士",400,"白");
        Troll troll = new Troll("超进化喷火龙",1000,"黑");
        Sword sword1 = new Sword(91);
        Sword sword2 = new Sword(19);
        Sword sword3 = new Sword(100);
        System.out.println(king);
        System.out.println(queen);
        System.out.println(knight);
        System.out.println(troll);
        king.attack(queen,sword3);
        knight.attack(king,sword1);
        queen.attack(troll,sword2);
        System.out.println(king.getName() + "剩下" + king.getXue() + "血");
        System.out.println(queen.getName() + "剩下" + queen.getXue() + "血");
        System.out.println(knight.getName() + "剩下" + knight.getXue() + "血");
        System.out.println(troll.getName() + "剩下" + troll.getXue() + "血");
    }
}

Character(name=国王, xue=400, camp=黑)
Character(name=皇后, xue=400, camp=白)
Character(name=骑士, xue=400, camp=白)
Character(name=超进化喷火龙, xue=1000, camp=黑)
国王攻击了皇后-------皇后损失了100血,hp变成了300
骑士攻击了国王-------国王损失了91血,hp变成了309
皇后技能二连击
皇后攻击了超进化喷火龙-------超进化喷火龙损失了19血,hp变成了981
皇后攻击了超进化喷火龙-------超进化喷火龙损失了19血,hp变成了962
国王剩下309血
皇后剩下300血
骑士剩下400血
超进化喷火龙剩下962血

大家可能看着有点懵逼
这里的策略主要体现了,切换武器这里,这是非常非常基础的策略模式,没看出来也算正常,我也是跑去问贺老板的,好吧,我是菜鸡,勿喷

策略模式

一系列不同算法,将每个算法封装到具有相同接口的一系列类中,使得相互替换算法不影响客户端

优点
算法类或者方法之间可以自由切换而无需改动主函数(在上面就是切换武器这个策略)
由于算法类都实现同一个接口,所以使它们之间可以自由切换.

增加一个新的策略只需要添加一个具体的策略类即可(增加武器类),基本不需要改变原有的代码,符合“开闭原则“
避免使用多重条件选择语句(ifelse)
缺点
主类必须知道所有的策略类,并自行决定使用哪一个策略类.
策略模式将造成产生很多策略类,可以通过使用享元模式在一定程度上减少对象的数量.

核心就是算法二字

事实上,策略模式就是用来封装算法的,在我看来,策略模式和工厂模式有些相似,甚至从类图上看几乎没什么差别
工厂模式是在实体类和主函数中多加了一层工厂,而策略模式是在主函数和策略中多加一层控制策略的东西,无需在主函数中声明

工厂模式在主函数中没有new,在工厂的内部创建了对象,我们需要调用函数需要在主函数里显式调用
策略模式则是需要在中间那一层中修改代码,并不在主函数中直接调用

像代码中的Queen重写的attack方法,就是重复执行了两次攻击,这就是策略,或者说算法,而不是在主函数中重复两次,这也是策略模式的一个体现

如有还有疑问,可以看看这个:
https://blog.csdn.net/lmx125254/article/details/86625960
大佬写的我觉得挺易懂的
优点和缺点那里是参考其他大佬的,但是网址我一不小心找不到了,抱歉

以上为本人个人见解,或许理解较浅,还请大佬不吝指点