策略模式介绍以及headfirst上的两个实例

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。

分析下定义，策略模式定义和封装了一系列的算法，它们是可以相互替换的，也就是说它们具有共性，而它们的共性就体现在策略接口的行为上，另外为了达到目的，也就是说让算法独立于使用它的客户而独立变化，我们需要让客户端依赖于策略接口。

策略模式的优缺点:
优点：
1、结构清晰，把策略分离成一个个单独的类「替换了传统的 if else」
2、代码耦合度降低，安全性提高「各个策略的细节被屏蔽」
缺点：
1、客户端必须要知道所有的策略类，否则你不知道该使用那个策略，所以策略模式适用于提前知道所有策略的情况下
2、增加了类的编写，本来只需要 if else 即可「但是这是所有模式和架构的通病」

策略模式类图:

下面来看两个经典的案例:
1.headfirst设计模式一书中的鸭子实例
Duck.java

package StrategyPattern;

/**
 * 鸭子超类
 */

public abstract class Duck {
    protected FlyBehavior flyBehavior;
    protected QuackBehavior quackBehavior;

    public Duck() {
    }

    public abstract void display();

    public void performFly() {
        flyBehavior.fly();
    }

    public void perormQuack() {
        quackBehavior.quack();
    }

    public void swim() {
        System.out.println("All ducks float,even decoys!");
    }

    public void setFlyBehavior(FlyBehavior fb) {
        flyBehavior = fb;
    }

    public void setQuackBehavior(QuackBehavior qb) {
        quackBehavior = qb;
    }
}

FlyBehavior.java

package StrategyPattern;

/**
 * 实现飞行接口的类
 */
public interface FlyBehavior {
    void fly();
}

FlyNoWay.java

package StrategyPattern;

/**
 * 不能飞
 */
public class FlyNoWay implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println("I can't fly!");
    }

}

FlyRocketPowered.java

package StrategyPattern;

/**
 * 用火箭飞
 */
public class FlyRocketPowered implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println("I'm flying with a rocket!");
    }
}

FlyWithWings.java

package StrategyPattern;

/**
 * 用翅膀飞
 */
public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("I'm flying!");
    }

}

MallardDuck.java

package StrategyPattern;

/**
 * 绿头鸭
 */
public class MallardDuck extends Duck {
    public MallardDuck(){
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }
    @Override
    public void display() {
        System.out.println("I'm a real Mallard duck!");
    }
}

ModelDuck.java

package StrategyPattern;

/**
 * 模型鸭
 */
public class ModelDuck extends Duck {

    public ModelDuck() {
        flyBehavior = new FlyNoWay();
        quackBehavior = new Quack();
    }

    @Override
    public void display() {
        System.out.println("I'm a model duck!");
    }
}

MuteQuack.java

package StrategyPattern;

/**
 * 不会叫
 */
public class MuteQuack implements QuackBehavior{
     @Override
     public void quack()
    {
        System.out.println("<< Silence >>");
    }
}

Quack.java

package StrategyPattern;

/**
 * 呱呱叫
 */
public class Quack implements QuackBehavior{
    @Override
    public void quack()
    {
        System.out.println("Quack");
    }
}

QuackBehavior.java

package StrategyPattern;

/**
 * 实现发声接口的类
 */
public interface QuackBehavior {
    void quack();
}

Squeak.java

package StrategyPattern;

/**
 * 吱吱叫
 */
public class Squeak implements QuackBehavior{
    @Override
    public void quack()
    {
        System.out.println("Squeak");
    }
}

Test.java

package StrategyPattern;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {

        //绿头鸭
        Duck mallard = new MallardDuck();
        mallard.perormQuack();
        mallard.performFly();

        //模型鸭
        Duck model = new ModelDuck();
        model.performFly();
        model.setFlyBehavior(new FlyRocketPowered());
        model.performFly();
    }
}

2.headfirst设计模式一书中策略模式课后练习之冒险游戏
类图设计:

AxeBehavior.java

package AdventureGame;

public class AxeBehavior implements WeaponBehavior {
    @Override
    public void useWeaPon() {
        System.out.println("使用斧头");
    }
}

BowAndArrowBehavior.java

package AdventureGame;

public class BowAndArrowBehavior implements WeaponBehavior{
    @Override
    public void useWeaPon() {
        System.out.println("使用弓箭");
    }

}

King.java

package AdventureGame;

public class King extends Role {
    public King(){
        weapon=new AxeBehavior();
    }
    @Override
    void display() {
        System.out.println("这是国王");
    }
}

KnifeBehavior.java

package AdventureGame;

public class KnifeBehavior implements WeaponBehavior{
    @Override
    public void useWeaPon() {
        System.out.println("使用宝剑");
    }
}

knight.java

package AdventureGame;

public class knight extends Role {
    public knight(){
        weapon=new SwordBehavior();
    }
    @Override
    void display() {
        System.out.println("这是骑士");
    }
}

Queen.java

package AdventureGame;

public class Queen extends Role{
    public Queen(){
        weapon=new KnifeBehavior();
    }
    @Override
    void display() {
        System.out.println("这是皇后");
    }
}

Role.java

package AdventureGame;

public abstract class Role {
    WeaponBehavior weapon;
    public Role(){
    }
    public void setWeapon(WeaponBehavior weapon) {
        this.weapon = weapon;
    }
    abstract void display();
    public void weaponWay(){
        weapon.useWeaPon();
    }
}

SwordBehavior.java

package AdventureGame;

public class SwordBehavior implements WeaponBehavior{
    @Override
    public void useWeaPon() {
        System.out.println("使用匕首");
    }
}

Troll.java

package AdventureGame;

public class Troll extends Role{
    public Troll(){
        weapon=new SwordBehavior();
    }
    @Override
    void display() {
        System.out.println("这是妖怪");
    }
}

WeaponBehavior.java

package AdventureGame;

public interface WeaponBehavior {
    void useWeaPon();
}

Test.java

package AdventureGame;

public class Test {
public static void main(String[] args) {
        King king = new King();
        king.display();
        king.weaponWay();
        System.out.println("更换武器以后");
        king.setWeapon(new SwordBehavior());
        king.weaponWay();
        }
}

运行效果图:

策略模式就先介绍到这,以后有更深的理解时再继续补充相关内容!