策略模式

策略模式

案例导入

需求：设计一款植物大战僵尸的游戏

现有两款僵尸，他们的属性如下

属性	外观	移动方式	攻击
普通僵尸	普通	朝着一个方向移动	咬
旗手僵尸	普通+手持旗子	朝着一个方向移动	咬

设计出这两个僵尸类

这种属性简单的类很好实现，只需要定义一个抽象类，把不同的属性抽离出来，相同的属性实现，子类来继承实现不同的属性

//抽象类
abstract class AbstractZombie{
    //抽象方法
    public abstract void display();
    public void attack(){
        System.out.println("咬");
    }
    public void move(){
        System.out.println("一步一步移动");
    }
}
//普通僵尸
class NormalZombie extends AbstractZombie{
    @Override
    public void display() {
        System.out.println("普通僵尸");
    }
}
//棋手僵尸
class FlagZombie extends AbstractZombie{
    @Override
    public void display() {
        System.out.println("我是棋手僵尸");
    }
}

思考：要是有成千上万的属性这种方式还依然适用吗？

模式定义

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

实现

//移动
interface Moveable{
    void move();
}
//攻击
interface Attackable{
    void attrack();
}
//抽象僵尸类
abstract class Zombie{
//    外观抽象方法
    abstract public void display();
    Moveable moveable;
    Attackable attackable;
    abstract void move();
    abstract void attrack();

    public Zombie(Moveable moveable, Attackable attackable) {
        this.moveable = moveable;
        this.attackable = attackable;
    }

    public Attackable getAttackable() {
        return attackable;
    }

    public void setAttackable(Attackable attackable) {
        this.attackable = attackable;
    }

    public Moveable getMoveable() {
        return moveable;
    }

    public void setMoveable(Moveable moveable) {
        this.moveable = moveable;
    }
}
//移动方式：一步一步移动
class StepByStepMove implements Moveable{

    @Override
    public void move() {
        System.out.println("一步一步移动");
    }
}
//攻击方式：咬
class BiteAttack implements Attackable{
    @Override
    public void attrack() {
        System.out.println("咬");
    }
}
//攻击方式：打
class HitAttack implements Attackable{
    @Override
    public void attrack() {
        System.out.println("打");
    }
}

//普通僵尸
class NormalZombie1 extends Zombie{

    public NormalZombie1() {
        super(new StepByStepMove(), new BiteAttack());
    }

    public NormalZombie1(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }

    @Override
    public void display() {
        System.out.println("普通僵尸");
    }

    @Override
    void move() {
        moveable.move();
    }

    @Override
    void attrack() {
        attackable.attrack();
    }
}
//旗手僵尸
class FlogZombie1 extends Zombie{
    public FlogZombie1(){
        super(new StepByStepMove(), new BiteAttack());
    }
    public FlogZombie1(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }

    @Override
    public void display() {
        System.out.println("旗手僵尸");
    }

    @Override
    void move() {
        moveable.move();
    }

    @Override
    void attrack() {
        attackable.attrack();
    }
}

标签：策略,void,模式,attackable,moveable,Override,public,僵尸
来源： https://blog.csdn.net/xu2414506319/article/details/111879586