以Head First設計模式中第一章給出的鴨子例子來講，此例子中有個鴨子的類，一共有普通鴨、模型鴨和玩具鴨三種。區別是普通鴨可以飛行併發出嘎嘎的叫聲；模型鴨不能飛行且不能發聲；玩具鴨不能飛行，但可以依靠火箭推進飛行（^..^就是這麼吊）且發出吱吱的聲音。面對這些有類似的屬性但不同的行為的類來說，使用策略模式便有利於類的拓展，其原則是：多用組合，少用繼承。簡單的思路是：定義演算法族，分別封裝起來，讓它們相互之間可以替換，使演算法的變化獨立於使用演算法的客戶。以下就從例項來說明：
首先是鴨子類，那就建立一個鴨子的超類（Duck），鴨子有飛行和鳴叫的行為，所以其下有兩個方法用於執行其飛行行為（performFly）和鳴叫行為（performQuack），當然可以新增一些其他方法（display）。
Duck類

/**
 * 鴨子的超類
 */
public abstract class Duck {

    public Duck() {
        // 執行鴨子的特徵
        display();
    }

    //鴨子的外觀，所有的鴨子外觀都不一樣，需要例項化的時候自定這隻鴨子是長什麼樣的
    public abstract void display();

    //執行鴨子的飛行行為
    public void performFly(){

    }

    //執行鴨子的鳴叫行為
    public void performFly(){

    }
}

可能此處會想到直接建立三種鴨子子類來繼承Duck超類，然後重寫performFly()和performFly()方法。如果這麼做的話要是再出現一種鴨子可以飛行但是發出吱吱的叫聲那就會和普通鴨子的飛行行為一樣，這樣就需要重寫寫一遍飛行的程式碼而沒有起到最初的程式碼複用的情況。所以此處考慮到一個設計原則，就是找出應用中可能需要變化的地方把它獨立出來，因此採用介面的方式設計飛行行為介面（FlyBehavior）和鳴叫介面（QuackBehavior）

/**
 * 鴨子的飛行行為介面，所有的飛行行為類需實現這個介面
 */
public interface FlyBehavior {
    //實現並賦予飛行行為
    public void fly();
}

/**
 *  同樣鴨子具有叫的行為
 */
public interface QuackBehavior {
    //實現並賦予鳴叫行為
    public void quack();
}

既然有了飛行和鳴叫的介面，那就需要實現其具體的行為，因此再建立所有的行為類實現它們，當然可以新增其他的飛行行為和鳴叫行為

可飛行的行為類：

/**
 *  可飛行
 */
public
 
 class Flyable implements FlyBehavior{

    @Override
    public void fly() {
        // 實現飛行行為
        System.out.println("我飛起來了！");
    }
}

不可飛行行為類：

/**
 *  無法飛行的行為
 */
public class FlyNoWay implements FlyBehavior{

    @Override
    public void fly() {
        // 這隻鴨子不能飛行，可能是模型鴨
        System.out.println("我飛不起來。");
    }
}

靠火箭飛行行為類：

/**
 *  依靠火箭飛行
 */
public class FlyRocket implements FlyBehavior{

    @Override
    public void fly() {
        // 依靠火箭推進飛行的鴨子
        System.out.println("我可以靠火箭飛行了");
    }
}

當然還有叫聲的行為
發出嘎嘎叫聲：

/**
 *  鴨子嘎嘎的鳴叫聲
 */
public class Gaga implements QuackBehavior{

    @Override
    public void quack() {
        // 鴨子的叫聲是嘎嘎的叫
        System.out.println("我會嘎嘎地叫！！");
    }
}

發出吱吱叫聲

/**
 *  鴨子吱吱地叫
 */
public class Zhizhi implements QuackBehavior{

    @Override
    public void quack() {
        // 鴨子鳴叫聲為吱吱地叫
        System.out.println("我會吱吱地叫！！");
    }
}

叫不出聲

/**
 *  叫不出聲的鴨子（木頭鴨）
 */
public class Silence implements QuackBehavior{

    @Override
    public void quack() {
        // 有些鴨子叫不出聲
        System.out.println("我叫不出聲！");
    }
}

既然飛行行為和鳴叫的行為都有了，現在可以整合鴨子的超類（Duck）了。最初的Duck只有方法而沒有具體實現，現在可以其方法了。到此處還只是宣告鴨子的飛行行為和鳴叫行為，具體是什麼得需要看子類是什麼型別的鴨子了。

/**
 * 鴨子的超類
 */
public abstract class Duck {

    public Duck() {
        // 執行鴨子的特徵
        display();
    }

    //鴨子具有的飛行行為
    FlyBehavior flyBehavior;

    //鴨子的鳴叫行為
    QuackBehavior quackBehavior;

    //鴨子的外觀，所有的鴨子外觀都不一樣，需要例項化的時候自定這隻鴨子是長什麼樣的
    public abstract void display();

    //執行鴨子的飛行行為
    public void performFly(){
        flyBehavior.fly();
    }

    //執行鴨子的鳴叫行為
    public void performQuack(){
        quackBehavior.quack();
    }
}

現在是時候建立三種鴨子了，建立之時初始化其行為便可。
正常鴨（NormalDuck）

/**
 *  建立正常的鴨子，繼承超類，執行飛行和鳴叫的行為，此類鴨子可以飛，並且發出嘎嘎的叫聲
 */
public class NormalDuck extends Duck{

    public NormalDuck() {
        // 普通鴨建構函式
        flyBehavior = new Flyable();
        quackBehavior = new Gaga();
    }

    @Override
    public void display() {
        // 此類鴨子外觀都一致
        System.out.println("這是一隻小黃鴨！！");
    }
}

玩具鴨（ToyDuck）

/**
 *  玩具鴨，不會飛行，但會吱吱地叫
 */
public class ToyDuck extends Duck{

    public ToyDuck() {
        // 玩具鴨建構函式
        flyBehavior = new FlyNoWay();
        quackBehavior = new Zhizhi();
    }

    @Override
    public void display() {
        // 玩具鴨子
        System.out.println("這是一隻玩具鴨！！");
    }
}

模型鴨（ModelDuck）

/**
 *  模型鴨，不會飛也不會叫
 */
public class ModelDuck extends Duck{

    public ModelDuck() {
        // 模型鴨建構函式
        flyBehavior = new FlyNoWay();
        quackBehavior = new Silence();
    }

    @Override
    public void display() {
        // 模型鴨
        System.out.println("這是一隻模型鴨！！");
    }
}

上面說過玩具鴨是可以飛行的，那為什麼不直接將其飛行行為設為靠火箭推進飛行呢？這裡就可以再次整合一下Duck類，使其可以動態設定行為，通過setFlyBehavior(new FlyRocket())動態設定其飛行行為，此方法也可用於設定鳴叫行為。

/**
 * 鴨子的超類
 */
public abstract class Duck {

    public Duck() {
        // 執行鴨子的特徵
        display();
    }

    //鴨子具有的飛行行為
    FlyBehavior flyBehavior;

    //鴨子的鳴叫行為
    QuackBehavior quackBehavior;

    //鴨子的外觀，所有的鴨子外觀都不一樣，需要例項化的時候自定這隻鴨子是長什麼樣的
    public abstract void display();

    //執行鴨子的飛行行為
    public void performFly(){
        flyBehavior.fly();
    }

    //執行鴨子的鳴叫行為
    public void performQuack(){
        quackBehavior.quack();
    }

    //設定鴨子飛行的屬性
    public void setFlyBehavior(FlyBehavior fb){
        flyBehavior = fb;
    }

    //設定鴨子的鳴叫屬性
    public void setQuackBehavior(QuackBehavior qb){
        quackBehavior = qb;
    }
}

至此所有的工作都已經做完，現在開始測試

/**
 *  建立鴨子
 *  先建立鴨子的超類和具有的各種行為，然後建立不同型別的鴨子，最後例項化這些鴨子 
 */
public class CreateDuck {
    public static void main(String[] args) {
        //建立普通鴨子，此類鴨子可以飛行，併發出嘎嘎的叫聲
        Duck normalDuck = new NormalDuck();
        normalDuck.performFly();
        normalDuck.performQuack();

        //建立模型鴨，此類鴨子不能飛行，並且不能發出聲音
        Duck modelDuck = new ModelDuck();
        modelDuck.performFly();
        modelDuck.performQuack();

        //建立玩具鴨，此類鴨子不能飛行，但依靠火箭推進飛行，並且會發出吱吱的聲音
        Duck toyDuck = new ToyDuck();
        toyDuck.performFly();                   //執行玩具鴨的基本屬性（不會飛行）
        toyDuck.setFlyBehavior(new FlyRocket());//賦予玩具鴨行的飛行屬性（火箭推進）,至此覆蓋了之前的
        toyDuck.performFly();                   //再次執行時玩具鴨已經擁有火箭推進了，可以飛行了。
        toyDuck.performQuack();
    }
}

執行結果:

在這裡看到實現鴨子的各種行為可以使用策略模式將鴨子的行為封裝到一組類中，這樣可以很容易拓展和改變，並且在需要之時還能在執行時改變其行為，如將不會飛行的玩具設定成靠火箭推進飛行。