程式師世界 >> 編程語言 >> C語言 >> C++ >> C++入門知識 >> Head First_設計模式_學習筆記_第01章_策略模式

Head First_設計模式_學習筆記_第01章_策略模式

編輯：C++入門知識

第一次用這書來學習設計模式，還真是超正點，無意中學會了第一個設計模式——策略模式。本次學習，我決定用最笨的方法，上機實踐，逐個代碼敲，用C++，C#，java三種語言來將它書上的UML圖用代碼實現。具體也不多說啦。這次的筆記就以筆記的形式記錄吧，也不用過多的說明啦，書本上寫得太好啦。

首先呢，是從簡單的模擬鴨子應用做起：

P002_C++代碼實現：
[cpp]
/**
* 項目名稱：P002Duck.cpp
* 文件說明: 實現《Head Frist 設計模式》P2書本UML圖的代碼。
* 　　　　　完成簡單的模擬Duck應用。
* 程序說明：本程序共含三個類：
* 　　　　　Duck作為基類，定義quack(), swim(), display() 基本方法。
* 　　　　　MallardDuck派生Duck,重寫display()方法。
* 　　　　　RedheadDuck派生Duck,重寫display()方法。
* 開發環境：Microsoft Visual Studio 2010
* 開發語言：C++
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
**/

#include <iostream>
using std::cout;

#include "Duck.h"
#include "MallardDuck.h"
#include "RedheadDuck.h"

/************************** 主函數 ****************************/
int main()
{
    // Duck, MallardDuck, RedheadDuck

// construct
    Duck * duck[3] = {0, 0, 0};
    duck[0] = new Duck();
    duck[1] = new MallardDuck();
    duck[2] = new RedheadDuck();

// show
    for(int i = 0; i < 3; ++i){
        if(0 == i){ cout << "Hello, I'm class Duck:\n"; }
        else if(1 == i){ cout << "\nHello, I'm class MallardDuck:\n";}
        else if(2 == i){ cout << "\nHello, I'm class RedHeadDuck:\n";}
        duck[i] -> quack();
        duck[i] -> swim();
        duck[i] -> display();
    }

// destroy
    for(int i = 0; i < 3; ++i){
        delete duck[i];
    }

    cout << "\n測試已完成，"; system("pause");
    return 0;
}

/************** 運行結果 *************

Hello, I'm class Duck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
Duck: 我是一只普通樣子的鴨

Hello, I'm class MallardDuck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
MallardDuck: 我是一只綠色頭的鴨

Hello, I'm class RedHeadDuck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨

測試已完成，請按任意鍵繼續. . .

************** 　以上　 *************/

[cpp]
// Duck.h

/************************* Duck類 ******************************/
#ifndef __DUCK__
#define __DUCK__

class Duck
{
public:
    Duck(){}
    virtual ~Duck(){}

    void quack(){           // 呱呱叫
        cout << "Duck: 我是一只會呱呱叫的鴨\n";
    }
    void swim(){            // 游泳
        cout << "Duck: 我是一只會游泳的鴨\n";
    }
    virtual void display(){ // 鴨子的樣子
        cout << "Duck: 我是一只普通樣子的鴨\n";
    }
};

#endif // __DUCK__

[cpp]
// MallardDuck.h

/******************** MallardDuck類 ****************************/
#ifndef __MALLARDDUCK__
#define __MALLARDDUCK__

class Duck;

class MallardDuck: public Duck
{
public:
    MallardDuck():Duck(){}          // 外觀是綠頭的一種鴨
    virtual ~MallardDuck(){}

    virtual void display(){
        cout << "MallardDuck: 我是一只綠色頭的鴨\n";
    }
};

#endif // __MALLARDDUCK__

[cpp]
// RedheadDuck.h

/******************** RedheadDuck類 ****************************/
#ifndef __REDHEADDUCK__
#define __REDHEADDUCK__

class Duck;

class RedheadDuck: public Duck
{
public:
    RedheadDuck():Duck(){}      // 外觀是紅頭的一種鴨
    virtual ~RedheadDuck(){}

    virtual void display(){
        cout << "RedheadDuck: 我是一只紅頭鴨\n";
    }
};

#endif // __REDHEADDUCK__

P002_C#代碼實現：
[csharp] v
/**
* 項目名稱：P002Duck
* 文件說明: 實現《Head Frist 設計模式》P2書本UML圖的代碼。
* 　　　　　完成簡單的模擬Duck應用。
* 程序說明：本程序共含三個類：
* 　　　　　Duck作為基類，定義quack(), swim(), display() 基本方法。
* 　　　　　MallardDuck派生Duck,重寫display()方法。
* 　　　　　RedheadDuck派生Duck,重寫display()方法。
* 開發環境：Microsoft Visual Studio 2010
* 開發語言：C#
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
**/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P002Duck
{
    class Program
    {
        static void Main(string[] args)
        {
        // Duck, MallardDuck, RedheadDuck

        // construct
            Duck [] duck = {new Duck(), new MallardDuck(), new RedheadDuck()};

        // show
            for(int i = 0; i < 3; ++i){
                if(0 == i){ Console.WriteLine("Hello, I'm class Duck:"); }
                else if(1 == i){ Console.WriteLine("\nHello, I'm class MallardDuck:");}
                else if(2 == i){ Console.WriteLine("\nHello, I'm class RedHeadDuck:");}
                duck[i].quack();
                duck[i].swim();
                duck[i].display();
            }

        Console.WriteLine("\n測試已完成，請按任意鍵繼續");
        Console.ReadKey();
        }
    }
}

/************** 運行結果 *************

Hello, I'm class Duck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
Duck: 我是一只普通樣子的鴨

Hello, I'm class MallardDuck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
MallardDuck: 我是一只綠色頭的鴨

Hello, I'm class RedHeadDuck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨

測試已完成，請按任意鍵繼續. . .

************** 　以上　 *************/

[csharp]
// Duck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P002Duck
{
    /************************* Duck類 ******************************/
    public class Duck
    {
        public Duck() { }

        public void quack()
        {           // 呱呱叫
            Console.WriteLine("Duck: 我是一只會呱呱叫的鴨");
        }
        public void swim()
        {           // 游泳
            Console.WriteLine("Duck: 我是一只會游泳的鴨");
        }
        public virtual void display()
        {   // 鴨子的樣子
            Console.WriteLine("Duck: 我是一只普通樣子的鴨");
        }
    };
}

[csharp]
// MallardDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P002Duck
{
    /******************** MallardDuck類 ****************************/
    public class MallardDuck : Duck
    {
        public MallardDuck() : base() { }           // 外觀是綠頭的一種鴨

        public override void display()
        {
            Console.WriteLine("MallardDuck: 我是一只綠色頭的鴨");
        }
    };
}

[csharp]
// RedheadDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P002Duck
{
    /******************** RedheadDuck類 ****************************/
    public class RedheadDuck : Duck
    {
        public RedheadDuck() : base() { }       // 外觀是紅頭的一種鴨

        public override void display()
        {
            Console.WriteLine("RedheadDuck: 我是一只紅頭鴨");
        }
    };
}

P002_Java代碼實現
[java]
/**
* 文件名稱：P2Duck.java
* 文件說明: 實現《Head Frist 設計模式》P2書本UML圖的代碼。
* 　　　　　完成簡單的模擬Duck應用。
* 程序說明：本程序共含三個類：
* 　　　　　Duck作為基類，定義quack(), swim(), display() 基本方法。
* 　　　　　MallardDuck派生Duck,重寫display()方法。
* 　　　　　RedheadDuck派生Duck,重寫display()方法。
* 開發環境：Eclipse-SDK-3.4.2-win32
* 開發語言：Java
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
**/

import Duck.*;

public class Main
{
    public static void main(String[] args)
    {
        // Duck, MallardDuck, RedheadDuck

        // construct
        Duck[] duck = { new Duck(), new MallardDuck(), new RedheadDuck() };

        // show
        for (int i = 0; i < 3; ++i)
        {
            if (0 == i) { System.out.println("Hello, I'm class Duck:"); }
            else if (1 == i) { System.out.println("\nHello, I'm class MallardDuck:"); }
            else if (2 == i) { System.out.println("\nHello, I'm class RedHeadDuck:"); }
            duck[i].quack();
            duck[i].swim();
            duck[i].display();
        }

        System.out.println("\n測試已完成。");
    }

}

/************** 運行結果 *************

Hello, I'm class Duck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
Duck: 我是一只普通樣子的鴨

Hello, I'm class MallardDuck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
MallardDuck: 我是一只綠色頭的鴨

Hello, I'm class RedHeadDuck:
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨

測試已完成。

************** 　以上　 *************/

[java]

/************************* Duck類 ******************************/
public class Duck
{
    public Duck() { }

    public void quack()
    {           // 呱呱叫
        System.out.println("Duck: 我是一只會呱呱叫的鴨");
    }
    public void swim()
    {           // 游泳
        System.out.println("Duck: 我是一只會游泳的鴨");
    }
    public void display()
    {   // 鴨子的樣子
        System.out.println("Duck: 我是一只普通樣子的鴨");
    }
}

[java]
package Duck;

/******************** MallardDuck類 ****************************/
public class MallardDuck extends Duck
{
    public MallardDuck() { super(); }           // 外觀是綠頭的一種鴨

    public void display()
    {
        System.out.println("MallardDuck: 我是一只綠色頭的鴨");
    }
}

[java]
package Duck;

/******************** RedheadDuck類 ****************************/
public class RedheadDuck extends Duck
{
    public RedheadDuck() { super(); }       // 外觀是紅頭的一種鴨

    public void display()
    {
        System.out.println("RedheadDuck: 我是一只紅頭鴨");
    }
}

之後，需要增加一個特殊的不會飛也不會叫的RubberDuck類，項目代碼變得有點冗余

P005_C++代碼實現：
[cpp]
/**
* 項目名稱：P005RubberDuck
* 文件說明: 實現《Head Frist 設計模式》P5書本UML圖的代碼。
* 　　　　　完成簡單的模擬Duck應用。
* 　　　　　在P02的基礎上另外再給Duck加上會飛的方法，再加一個RubberDuck類。
* 程序說明：本程序共含四個類：
* 　　　　　Duck作為基類，定義quack(), swim(), display() 基本方法。
* 　　　　　MallardDuck派生Duck,重寫display()方法。
* 　　　　　RedheadDuck派生Duck,重寫display()方法。
* 　　　　　RubberDuck派生Duck，重寫display()方法，fly()方法，quack()方法。
* 開發環境：Microsoft Visual Studio 2010
* 開發語言：C++
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
**/

#include <iostream>
using std::cout;

#include "Duck.h"
#include "MallardDuck.h"
#include "RedheadDuck.h"
#include "RubberDuck.h"

/************************** 主函數 ****************************/
int main()
{

// construct
    Duck * duck[4] = {0, 0, 0, 0};
    duck[0] = new Duck();
    duck[1] = new MallardDuck();
    duck[2] = new RedheadDuck();
    duck[3] = new RubberDuck();

// show
    for(int i = 0; i < 4; ++i){
        if(0 == i){ cout << "Hello, I'm class Duck:\n"; }
        else if(1 == i){ cout << "\nHello, I'm class MallardDuck:\n";}
        else if(2 == i){ cout << "\nHello, I'm class RedHeadDuck:\n";}
        else if(3 == i){ cout << "\nHello, I'm class RubberDuck:\n";}
        duck[i] -> swim();
        duck[i] -> display();
        duck[i] -> quack();
        duck[i] -> fly();
    }

// destroy
    for(int i = 0; i < 4; ++i){
        delete duck[i];
    }

    cout << "\n測試已完成，"; system("pause");
    return 0;
}

/************** 運行結果 *************

Hello, I'm class Duck:
Duck: 我是一只會游泳的鴨
Duck: 我是一只普通樣子的鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class MallardDuck:
Duck: 我是一只會游泳的鴨
MallardDuck: 我是一只綠色頭的鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class RedHeadDuck:
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class RubberDuck:
Duck: 我是一只會游泳的鴨
RubberDuck: 我是一只橡皮鴨
RubberDuck: 我這鴨不會叫
RubberDuck: 我這鴨不會飛

測試已完成，請按任意鍵繼續. . .

************** 　以上　 *************/

[cpp]
// Duck.h

/************************* Duck類 ******************************/
#ifndef __DUCK__
#define __DUCK__

class Duck
{
public:
    Duck(){}
    virtual ~Duck(){}

    virtual void quack(){           // 呱呱叫
        cout << "Duck: 我是一只會呱呱叫的鴨\n";
    }
    void swim(){            // 游泳
        cout << "Duck: 我是一只會游泳的鴨\n";
    }
    virtual void display(){ // 鴨子的樣子
        cout << "Duck: 我是一只普通樣子的鴨\n";
    }
    virtual void fly(){ // 還會飛
        cout << "Duck: 我是一只會飛的鴨\n";
    }
};

#endif // __DUCK__
[cpp]
// MallardDuck.h

/******************** MallardDuck類 ****************************/
#ifndef __MALLARDDUCK__
#define __MALLARDDUCK__

class Duck;

class MallardDuck: public Duck
{
public:
    MallardDuck():Duck(){}          // 外觀是綠頭的一種鴨
    virtual ~MallardDuck(){}

    virtual void display(){
        cout << "MallardDuck: 我是一只綠色頭的鴨\n";
    }
};

#endif // __MALLARDDUCK__

[cpp]
// RubberDuck.h

/******************** RubberdDuck類 ****************************/
#ifndef __RUBBERDUCK__
#define __RUBBERDUCK__

class Duck;

class RubberDuck: public Duck
{
public:
    RubberDuck():Duck(){}       // 不會飛也不會叫的橡皮鴨，實質是一只誘餌鴨
    virtual ~RubberDuck(){}

    virtual void display(){
        cout << "RubberDuck: 我是一只橡皮鴨\n";
    }
    virtual void fly(){
        cout << "RubberDuck: 我這鴨不會飛\n";
    }
    virtual void quack(){
        cout << "RubberDuck: 我這鴨不會叫\n";
    }
};

#endif // __RUBBERDUCK__

P005_C#代碼實現：
[csharp]
/**
* 項目名稱：P005RubberDuck
* 文件說明: 實現《Head Frist 設計模式》P5書本UML圖的代碼。
* 　　　　　完成簡單的模擬Duck應用。
* 　　　　　在P02的基礎上另外再給Duck加上會飛的方法，再加一個RubberDuck類。
* 程序說明：本程序共含四個類：
* 　　　　　Duck作為基類，定義quack(), swim(), display() 基本方法。
* 　　　　　MallardDuck派生Duck,重寫display()方法。
* 　　　　　RedheadDuck派生Duck,重寫display()方法。
* 　　　　　RubberDuck派生Duck，重寫display()方法，fly()方法，quack()方法。
* 開發環境：Microsoft Visual Studio 2010
* 開發語言：C#
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
**/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P005RubberDuck
{
    class Program
    {
        static void Main(string[] args)
        {

        // construct
            Duck [] duck = {
                               new Duck(),
                               new MallardDuck(),
                               new RedheadDuck(),
                               new RubberDuck()
                           };

        // show
            for(int i = 0; i < 4; ++i){
                if(0 == i){ Console.WriteLine("Hello, I'm class Duck:"); }
                else if(1 == i){ Console.WriteLine("\nHello, I'm class MallardDuck:");}
                else if(2 == i){ Console.WriteLine("\nHello, I'm class RedHeadDuck:");}
                else if (3 == i) { Console.WriteLine("\nHello, I'm class RubberDuck:"); }
                duck[i].swim();
                duck[i].display();
                duck[i].quack();
                duck[i].fly();
            }

        Console.WriteLine("\n測試已完成，請按任意鍵繼續");
        Console.ReadKey();
        }
    }
}

/************** 運行結果 *************

Hello, I'm class Duck:
Duck: 我是一只會游泳的鴨
Duck: 我是一只普通樣子的鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class MallardDuck:
Duck: 我是一只會游泳的鴨
MallardDuck: 我是一只綠色頭的鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class RedHeadDuck:
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class RubberDuck:
Duck: 我是一只會游泳的鴨
RubberDuck: 我是一只橡皮鴨
RubberDuck: 我是不會叫的
RubberDuck：我也不會飛

測試已完成，請按任意鍵繼續

************** 　以上　 *************/

[csharp]
// Duck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P005RubberDuck
{
    /************************* Duck類 ******************************/
    public class Duck
    {
        public Duck() { }

        public virtual void quack()
        {           // 呱呱叫
            Console.WriteLine("Duck: 我是一只會呱呱叫的鴨");
        }
        public void swim()
        {           // 游泳
            Console.WriteLine("Duck: 我是一只會游泳的鴨");
        }
        public virtual void display()
        {   // 鴨子的樣子
            Console.WriteLine("Duck: 我是一只普通樣子的鴨");
        }
        public virtual void fly()
        {           // 飛
            Console.WriteLine("Duck: 我是一只會飛的鴨");
        }
    };
}

[csharp]
// MallardDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P005RubberDuck
{
    /******************** MallardDuck類 ****************************/
    public class MallardDuck : Duck
    {
        public MallardDuck() : base() { }           // 外觀是綠頭的一種鴨

        public override void display()
        {
            Console.WriteLine("MallardDuck: 我是一只綠色頭的鴨");
        }
    };
}

[csharp]
// RedheadDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P005RubberDuck
{
    /******************** RedheadDuck類 ****************************/
    public class RedheadDuck : Duck
    {
        public RedheadDuck() : base() { }       // 外觀是紅頭的一種鴨

        public override void display()
        {
            Console.WriteLine("RedheadDuck: 我是一只紅頭鴨");
        }
    };
}

[csharp]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P005RubberDuck
{
    /******************** RubberDuck類 ****************************/
    public class RubberDuck: Duck
    {
        public RubberDuck() : base() { }        // 橡皮鴨，用作誘餌

        public override void display()
        {
            Console.WriteLine("RubberDuck: 我是一只橡皮鴨");
        }
        public override void quack()
        {           // 呱呱叫
            Console.WriteLine("RubberDuck: 我是不會叫的");
        }
        public override void fly()
        {           // 飛
            Console.WriteLine("RubberDuck：我也不會飛");
        }
    }
}

P005_Java代碼實現：
[java]
/**
* 項目名稱：P005RubberDuck
* 文件說明: 實現《Head Frist 設計模式》P5書本UML圖的代碼。
* 　　　　　完成簡單的模擬Duck應用。
* 　　　　　在P02的基礎上另外再給Duck加上會飛的方法，再加一個RubberDuck類。
* 程序說明：本程序共含四個類：
* 　　　　　Duck作為基類，定義quack(), swim(), display() 基本方法。
* 　　　　　MallardDuck派生Duck,重寫display()方法。
* 　　　　　RedheadDuck派生Duck,重寫display()方法。
* 　　　　　RubberDuck派生Duck，重寫display()方法，fly()方法，quack()方法。
* 開發環境：Eclipse-SDK-3.4.2-win32
* 開發語言：Java
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
**/

import Duck.*;

public class Main
{
    public static void main(String[] args)
    {
        // Duck, MallardDuck, RedheadDuck

        // construct
        Duck[] duck = { new Duck(), new MallardDuck(), new RedheadDuck(), new RubberDuck()};

        // show
        for (int i = 0; i < 4; ++i)
        {
            if (0 == i) { System.out.println("Hello, I'm class Duck:"); }
            else if (1 == i) { System.out.println("\nHello, I'm class MallardDuck:"); }
            else if (2 == i) { System.out.println("\nHello, I'm class RedHeadDuck:"); }
            duck[i].swim();
            duck[i].display();
            duck[i].quack();
            duck[i].fly();
        }

        System.out.println("\n測試已完成。");
    }
}

/************** 運行結果 *************

Hello, I'm class Duck:
Duck: 我是一只會游泳的鴨
Duck: 我是一只普通樣子的鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class MallardDuck:
Duck: 我是一只會游泳的鴨
MallardDuck: 我是一只綠色頭的鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨

Hello, I'm class RedHeadDuck:
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨
Duck: 我是一只會呱呱叫的鴨
Duck: 我是一只會飛的鴨
Duck: 我是一只會游泳的鴨
RedheadDuck: 我是一只紅頭鴨
RubberDuck: 我這鴨不會叫

RubberDuck: 我這鴨不會飛

測試已完成。

************** 　以上　 *************/

[java]
package Duck;

/************************* Duck類 ******************************/
public class Duck
{
    public Duck() { }

    public void quack()
    {           // 呱呱叫
        System.out.println("Duck: 我是一只會呱呱叫的鴨");
    }
    public void swim()
    {           // 游泳
        System.out.println("Duck: 我是一只會游泳的鴨");
    }
    public void display()
    {   // 鴨子的樣子
        System.out.println("Duck: 我是一只普通樣子的鴨");
    }
    public void fly()
    {   // 會飛的鴨
        System.out.println("Duck: 我是一只會飛的鴨");
    }
}

[java]
package Duck;

/******************** RedheadDuck類 ****************************/
public class RubberDuck extends Duck
{
    public RubberDuck() { super(); }    // 不會飛也不會叫的橡皮鴨，實質是一只誘餌鴨

    public void display()
    {
        System.out.println("RedheadDuck: 我是一只紅頭鴨");
    }
    public void fly(){
        System.out.println("RubberDuck: 我這鴨不會飛\n");
    }
    public void quack(){
        System.out.println("RubberDuck: 我這鴨不會叫\n");
    }
}

最後，使用策略者模式(Strategy Pattern)解決這個問題：

P022_C++代碼實現：
[cpp]
/**
* 項目名稱：P022StrategyPerfectDuck
* 文件說明: 實現《Head Frist 設計模式》P22書本UML圖的代碼。
* 　　　　　以書上的UML圖為例，以策略模式(Strategy)設計本程序。
* 程序說明：本程序共含三個包：
* 　　　　　Duck包，含一個Duck抽象基類，基類中包含兩個接口數據成員，
* 　　　　　　　　　其它派生類通過定義這兩數據成員實現動作委托。
*           Fly包，含一個FlyBehavior接口，其它類為實現該接口，定義出含該接口的類的特征。
* 　　　　　Quack包，含一個QuackBehavior接口，其它類為實現該接口，定義出含該接口的類的特征。
* 開發環境：Microsoft Visual Studio 2010
* 開發語言：C++
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.18
* 附：策略模式——定義了算法族，分別封裝起來，讓它們之間可以互相替換，
* 　　　此模式讓算法的變化獨立於使用算法的客戶。
**/

#include <iostream>

#include "FlyBehavior.h"
#include "FlyNoWay.h"
#include "FlyRocketPowered.h"
#include "FlyWithWings.h"

#include "QuackBehavior.h"
#include "Squeak.h"
#include "Quack.h"
#include "MuteQuack.h"

#include "Duck.h"
#include "DecoyDuck.h"
#include "MallardDuck.h"
#include "MiniDuckSimulator.h"
#include "RedheadDuck.h"
#include "RubberDuck.h"

int main()
{
     Duck * duck[] = {
                            new DecoyDuck(),
                            new MallardDuck(),
                            new RedheadDuck(),
                            new RubberDuck(),
                            new MiniDuckSimulator()
    };

    for(int i = 0; i < sizeof(duck)/sizeof(duck[0]); ++i){
        switch(i){
            case 0: std::cout << "\nNow,DocoyDuck Testing Start...\n";break;
            case 1: std::cout << "\nNow,MallardDuck Testing Start...\n";break;
            case 2: std::cout << "\nNow,RedheadDuck Testing Start...\n";break;
            case 3: std::cout << "\nNow,RubberDuck Testing Start...\n";break;
            case 4: std::cout << "\nNow,MiniDuckSimulator Testing Start...\n";break;
        }
        duck[i] -> swim();
        duck[i] -> display();
        duck[i] -> performFly();
        duck[i] -> performQuack();
    }

    std::cout << "\nNow, Trying to change MiniDuckSimulator\n";
    duck[4] -> setFlyBehavior(new FlyRocketPowered());
    duck[4] -> setQuackBehavior(new Quack());
    duck[4] -> display();
    duck[4] -> performFly();
    duck[4] -> performQuack();

    std::cout << "\n";
    system("pause");

    for (int i = 0; i < 5; ++i){
        delete duck[i];
    }
    return 0;
}

/**************** 運算結果 ******************

Now,DocoyDuck Testing Start...
All ducks can Swim.
I'm a duck Decoy
I can fly in no way
I am MuteQuack, I can't Quack.

Now,MallardDuck Testing Start...
All ducks can Swim.
I'm Mallard duck!
I can Fly With Wings
I can Quack, gua gua ...

Now,RedheadDuck Testing Start...
All ducks can Swim.
I'm Red Headed duck
I can Fly With Wings
I can Quack, gua gua ...

Now,RubberDuck Testing Start...
All ducks can Swim.
I'm Red Headed duck
I can fly in no way
I am MuteQuack, I can't Quack.

Now,MiniDuckSimulator Testing Start...
All ducks can Swim.
I'm MiniDuckSimulator!
I can fly in no way
I am MuteQuack, I can't Quack.

Now, Trying to change MiniDuckSimulator
I'm MiniDuckSimulator!
I'm flying with a rocket
I can Quack, gua gua ...

請按任意鍵繼續. . .

************************************************/

[cpp]
// FlyBehavior.h

#ifndef __FLYBEHAVIOR__
#define __FLYBEHAVIOR__

class FlyBehavior
{
public:
virtual void fly(){}
};

#endif // __FLYBEHAVIOR__

[cpp]
// FlyNoWay.h

#ifndef __FLYNOWAY__
#define __FLYNOWAY__

#include <iostream>
class FlyBehavior;

class FlyNoWay: public FlyBehavior
{
public:
    virtual void fly(){
         std::cout << "I can fly in no way\n";
    }
};

#endif // __FLYNOWAY__

[cpp]
// FlyRocketPowered.h

#ifndef __FLYROCKETPOWERED__
#define __FLYROCKETPOWERED__

#include <iostream>
class FlyBehavior;

class FlyRocketPowered: public FlyBehavior
{
public:
    virtual void fly(){
         std::cout << "I'm flying with a rocket\n";
    }
};

#endif // __FLYROCKETPOWERED__

[cpp]
// FlyWithWings.h

#ifndef __FLYWITHWINGS__
#define __FLYWITHWINGS__

#include <iostream>
class FlyBehavior;

class FlyWithWings: public FlyBehavior
{
public:
    virtual void fly(){
         std::cout << "I can Fly With Wings\n";
    }
};

#endif // __FLYWITHWINGS__

[cpp]
// QuackBehavior.h

#ifndef __QUACKBEHAVIOR__
#define __QUACKBEHAVIOR__

class QuackBehavior
{
public:
virtual void quack(){}
};

#endif // __QUACKBEHAVIOR__

[cpp]
// Quack.h

#ifndef __QUACK__
#define __QUACK__

#include <iostream>

class QuackBehavior;

class Quack: public QuackBehavior
{
public:
    virtual void quack(){
        std::cout << "I can Quack, gua gua ...\n";
    }
};

#endif // __QUACK__

[cpp]
// MuteQuack.h

#ifndef __MUTEQUACK__
#define __MUTEQUACK__

#include <iostream>

class QuackBehavior;

class MuteQuack: public QuackBehavior
{
public:
    virtual void quack(){
        std::cout << "I am MuteQuack, I can't Quack.\n";
    }
};

#endif // __MUTEQUACK__

[cpp]
// Squeak.h

#ifndef __SQUEAK__
#define __SQUEAK__

#include <iostream>

class QuackBehavior;

class Squeak: public QuackBehavior
{
public:
    virtual void quack(){
        std::cout << "I am Squeak, I can Quack, zi zi ...\n";
    }
};

#endif // __SQUEAK__

[cpp]
// Duck.h

#ifndef __DUCK__
#define __DUCK__

#include "FlyBehavior.h"
#include "QuackBehavior.h"

#include <iostream>

class Duck
{
protected:
    FlyBehavior * flyBehavior;
    QuackBehavior * quackBehavior;

public:
    Duck(){
        flyBehavior = 0;
        quackBehavior = 0;
    }

    virtual ~Duck(){
        if(NULL != flyBehavior){
            delete flyBehavior;
            flyBehavior = 0;
        }
        if(NULL != quackBehavior){
            delete quackBehavior;
            quackBehavior = 0;
        }
    }

    void setFlyBehavior(FlyBehavior * fb) {
        if(NULL != flyBehavior){
            delete flyBehavior;
        }
        flyBehavior = fb;
    }

    void setQuackBehavior(QuackBehavior * qb){
        if(NULL != quackBehavior){
            delete quackBehavior;
        }
        quackBehavior = qb;
    }

    void performFly(){
         flyBehavior -> fly();
    }

    void performQuack() {
         quackBehavior -> quack();
    }

    void swim() {
        std::cout << "All ducks can Swim.\n";
    }

    virtual void display(){
        std::cout << "I'm Base Duck";
    }
};

#endif // __DUCK__

[cpp]
// DecoyDuck.h

#ifndef __DECOYDUCK__
#define __DECOYDUCK__

#include <iostream>

class Duck;

class DecoyDuck: public Duck
{
public:
    DecoyDuck() :Duck(){
        flyBehavior = new FlyNoWay();
        quackBehavior = new MuteQuack();
    }
    virtual ~DecoyDuck(){}

    virtual void display(){
        std::cout << "I'm a duck Decoy\n";
    }
};

#endif // __DECOYDUCK__

[cpp]
// MallardDuck.h

#ifndef __MALLARDDUCK__
#define __MALLARDDUCK__

#include <iostream>

class Duck;

class MallardDuck: public Duck
{
public:
    MallardDuck() {
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    virtual ~MallardDuck(){}

    virtual void display(){
        std::cout << "I'm Mallard duck!\n";
    }
};

#endif // __MALLARDDUCK__

[cpp] view plaincopyprint?
// MiniDuckSimulator.h

#ifndef __MINIDUCKSIMULATOR__
#define __MINIDUCKSIMULATOR__

#include <iostream>

class Duck;

class MiniDuckSimulator: public Duck
{
public:
    MiniDuckSimulator():Duck() {
        flyBehavior = new FlyNoWay();
        quackBehavior = new MuteQuack();
    }

    virtual ~MiniDuckSimulator(){}

    virtual void display(){
        std::cout << "I'm MiniDuckSimulator!\n";
    }
};

#endif // __MINIDUCKSIMULATOR__

[cpp]
// RedheadDuck.h

#ifndef __REDHEADDUCK__
#define __REDHEADDUCK__

#include <iostream>

class Duck;

class RedheadDuck: public Duck
{
public:
    RedheadDuck():Duck() {
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

    virtual ~RedheadDuck(){}

    virtual void display(){
        std::cout << "I'm Red Headed duck\n";
    }
};

#endif // __REDHEADDUCK__

[cpp]
// RubberDuck.h

#ifndef __RUBBERDUCK__
#define __RUBBERDUCK__

#include <iostream>

class Duck;

class RubberDuck: public Duck
{
public:
    RubberDuck():Duck() {
        flyBehavior = new FlyNoWay();
        quackBehavior = new MuteQuack();
    }

    virtual ~RubberDuck(){}

    virtual void display(){
        std::cout << "I'm Red Headed duck\n";
    }
};

#endif // __RUBBERDUCK__

P022_C#代碼實現：
[csharp]
/**
* 項目名稱：P022StrategyPerfectDuck
* 文件說明: 實現《Head Frist 設計模式》P22書本UML圖的代碼。
* 　　　　　以書上的UML圖為例，以策略模式(Strategy)設計本程序。
* 程序說明：本程序共含三個包：
* 　　　　　Duck包，含一個Duck抽象基類，基類中包含兩個接口數據成員，
* 　　　　　　　　　其它派生類通過定義這兩數據成員實現動作委托。
*          Fly包，含一個FlyBehavior接口，其它類為實現該接口，定義出含該接口的類的特征。
* 　　　　　Quack包，含一個QuackBehavior接口，其它類為實現該接口，定義出含該接口的類的特征。
* 開發環境：Microsoft Visual Studio 2010
* 開發語言：C#
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
* 附：策略模式——定義了算法族，分別封裝起來，讓它們之間可以互相替換，
* 　　　此模式讓算法的變化獨立於使用算法的客戶。
**/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck
{
    using Quack;
    using Fly;
    using Duck;

    class Program
    {
        static void Main(string[] args)
        {
                    Duck.Duck [] duck = {
                            new DecoyDuck(),
                            new MallardDuck(),
                            new RedheadDuck(),
                            new RubberDuck(),
                            new MiniDuckSimulator()
                        };

        for(int i = 0; i < duck.Length; ++i){
            switch(i){
            case 0: Console.WriteLine("\nNow,DocoyDuck Testing Start...");break;
            case 1: Console.WriteLine("\nNow,MallardDuck Testing Start...");break;
            case 2: Console.WriteLine("\nNow,RedheadDuck Testing Start...");break;
            case 3: Console.WriteLine("\nNow,RubberDuck Testing Start...");break;
            case 4: Console.WriteLine("\nNow,MiniDuckSimulator Testing Start...");break;
            }
            duck[i].swim();
            duck[i].display();
            duck[i].performFly();
            duck[i].performQuack();
        }

        Console.WriteLine("\nNow, Trying to change MiniDuckSimulator");
        duck[4].setFlyBehavior(new FlyRocketPowered());
        duck[4].setQuackBehavior(new Quack.Quack());
        duck[4].display();
        duck[4].performFly();
        duck[4].performQuack();

        }
    }
}

/***********    運行結果   ***************

Now,DocoyDuck Testing Start...
All ducks can Swim.
I'm a duck Decoy
I can fly in no way
I am MuteQuack, I can't Quack.

Now,MallardDuck Testing Start...
All ducks can Swim.
I'm Mallard duck
I can Fly With Wings
I can Quack, gua gua ...

Now,RedheadDuck Testing Start...
All ducks can Swim.
I'm Red Headed duck
I can Fly With Wings
I can Quack, gua gua ...

Now,RubberDuck Testing Start...
All ducks can Swim.
I'm RubberDuck.
I can fly in no way
I am MuteQuack, I can't Quack.

Now,MiniDuckSimulator Testing Start...
All ducks can Swim.
I'm MiniDuckSimulator
I can fly in no way
I am MuteQuack, I can't Quack.

Now, Trying to change MiniDuckSimulator
I'm MiniDuckSimulator
I'm flying with a rocket
I can Quack, gua gua ...
請按任意鍵繼續. . .

***********************************************/

[csharp]
// FlyBehavior.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Fly
{
    public interface FlyBehavior
    {
        void fly();
    }
}

[java]
// FlyNoWay.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Fly
{
    public class FlyNoWay: FlyBehavior
    {
        public void fly(){
            Console.WriteLine("I can fly in no way");
        }
    }
}

[java]
// FlyRocketPowered.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Fly
{
    public class FlyRocketPowered: FlyBehavior
    {
        public void fly(){
            Console.WriteLine("I'm flying with a rocket");
        }
    }
}

[java]
// FlyWithWings.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Fly
{
    public class FlyWithWings: FlyBehavior
    {
        public void fly(){
            Console.WriteLine("I can Fly With Wings");
        }
    }
}

[csharp]
// QuackBehavior.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Quack
{
    public interface QuackBehavior
    {
        void quack();
    }
}

[csharp]
// Quack.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Quack
{
    public class Quack:QuackBehavior
    {
        public void quack(){
            Console.WriteLine("I can Quack, gua gua ...");
        }
    }
}

[csharp]
// MuteQuack.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Quack
{
    public class MuteQuack: QuackBehavior
    {
        public void quack(){
            Console.WriteLine("I am MuteQuack, I can't Quack.");
        }
    }
}

[csharp]
// Squeak.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace P022StrategyPerfectDuck.Quack
{
    public class Squeak: QuackBehavior
    {
        public void quack(){
            Console.WriteLine("I am Squeak, I can Quack, zi zi ...");
        }

    }
}

[csharp]
// Duck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using P022StrategyPerfectDuck.Fly;
using P022StrategyPerfectDuck.Quack;

namespace P022StrategyPerfectDuck.Duck
{
    public abstract class Duck
    {
        protected FlyBehavior flyBehavior;
        protected QuackBehavior quackBehavior;

        public Duck() { }

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

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

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

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

        public void swim() {
            Console.WriteLine("All ducks can Swim.");
        }

        public abstract void display();

    }
}

[csharp]
// DecoyDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using P022StrategyPerfectDuck.Fly;
using P022StrategyPerfectDuck.Quack;

namespace P022StrategyPerfectDuck.Duck
{
    public class DecoyDuck: Duck
    {
        public DecoyDuck() {
            flyBehavior = new FlyNoWay();
            quackBehavior = new MuteQuack();
        }

        public override void display()
        {
            Console.WriteLine("I'm a duck Decoy");
        }
    }

}

[csharp]
// MallardDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using P022StrategyPerfectDuck.Fly;
using P022StrategyPerfectDuck.Quack;

namespace P022StrategyPerfectDuck.Duck
{
    class MallardDuck:Duck
    {
        public MallardDuck()
        {
            quackBehavior = new Quack.Quack();
            flyBehavior = new FlyWithWings();
        }

        public override void display()
        {
            Console.WriteLine("I'm Mallard duck");
        }
    }
}

[csharp]
// MiniDuckSimulator.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using P022StrategyPerfectDuck.Fly;
using P022StrategyPerfectDuck.Quack;

namespace P022StrategyPerfectDuck.Duck
{
    public class MiniDuckSimulator: Duck
    {
        public MiniDuckSimulator():base(){
            setFlyBehavior(new FlyNoWay());
            setQuackBehavior(new MuteQuack());
        }

        public override void display()
        {
            Console.WriteLine("I'm MiniDuckSimulator");
        }
    }
}

[csharp]
// RedheadDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using P022StrategyPerfectDuck.Fly;
using P022StrategyPerfectDuck.Quack;

namespace P022StrategyPerfectDuck.Duck
{
    public class RedheadDuck: Duck
    {
        public RedheadDuck() {
            flyBehavior = new FlyWithWings();
            quackBehavior = new Quack.Quack();
        }

        public override void display()
        {
            Console.WriteLine("I'm Red Headed duck");
        }
    }
}

[csharp]
// RubberDuck.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using P022StrategyPerfectDuck.Fly;
using P022StrategyPerfectDuck.Quack;

namespace P022StrategyPerfectDuck.Duck
{
    public class RubberDuck:Duck
    {
        public RubberDuck():base(){
            setFlyBehavior(new FlyNoWay());
            setQuackBehavior(new MuteQuack());
        }

        public override void display()
        {
            Console.WriteLine("I'm RubberDuck.");
        }
    }

}

P022_Java代碼實現：
[java]
/**
* 項目名稱：P022StrategyPerfectDuck
* 文件說明: 實現《Head Frist 設計模式》P22書本UML圖的代碼。
* 　　　　　以書上的UML圖為例，以策略模式(Strategy)設計本程序。
* 程序說明：本程序共含三個包：
* 　　　　　Duck包，含一個Duck抽象基類，基類中包含兩個接口數據成員，
* 　　　　　　　　　其它派生類通過定義這兩數據成員實現動作委托。
*          Fly包，含一個FlyBehavior接口，其它類為實現該接口，定義出含該接口的類的特征。
* 　　　　　Quack包，含一個QuackBehavior接口，其它類為實現該接口，定義出含該接口的類的特征。
* 開發環境：Eclipse-SDK-3.4.2-win32
* 開發語言：Java
* 文件作者：Neicole
* 聯系方式：http://blog.csdn.net/neicole
* 聯系方式：http://neicole.blog.51cto.com/
* 制作日期：2012.09.17
* 附：策略模式——定義了算法族，分別封裝起來，讓它們之間可以互相替換，
* 　　　此模式讓算法的變化獨立於使用算法的客戶。
**/

import Duck.*;
import Fly.*;
import Quack.*;

public class Main
{
    public static void main(String[] args)
    {
        Duck [] duck = {
                            new DecoyDuck(),
                            new MallardDuck(),
                            new RedheadDuck(),
                            new RubberDuck(),
                            new MiniDuckSimulator()
                        };

        for(int i = 0; i < duck.length; ++i){
            switch(i){
            case 0: System.out.println("\nNow,DocoyDuck Testing Start...");break;
            case 1: System.out.println("\nNow,MallardDuck Testing Start...");break;
            case 2: System.out.println("\nNow,RedheadDuck Testing Start...");break;
            case 3: System.out.println("\nNow,RubberDuck Testing Start...");break;
            case 4: System.out.println("\nNow,MiniDuckSimulator Testing Start...");break;
            }
            duck[i].swim();
            duck[i].display();
            duck[i].performFly();
            duck[i].performQuack();
        }

        System.out.println("\nNow, Trying to change MiniDuckSimulator");
        duck[4].setFlyBehavior(new FlyRocketPowered());
        duck[4].setQuackBehavior(new Quack());
        duck[4].display();
        duck[4].performFly();
        duck[4].performQuack();
    }
}

/****************** 運行結果   *******************

Now,DocoyDuck Testing Start...
All ducks can Swim.
I'm a duck Decoy
I can fly in no way
I am MuteQuack, I can't Quack.

Now,MallardDuck Testing Start...
All ducks can Swim.
I'm Mallard duck
I can Fly With Wings
I can Quack, gua gua ...

Now,RedheadDuck Testing Start...
All ducks can Swim.
I'm Red Headed duck
I can Fly With Wings
I can Quack, gua gua ...

Now,RubberDuck Testing Start...
All ducks can Swim.
I'm RubberDuck.
I can fly in no way
I am MuteQuack, I can't Quack.

Now,MiniDuckSimulator Testing Start...
All ducks can Swim.
I'm MiniDuckSimulator
I can fly in no way
I am MuteQuack, I can't Quack.

Now, Trying to change MiniDuckSimulator
I'm MiniDuckSimulator
I'm flying with a rocket
I can Quack, gua gua ...

************************************************/

[java]
// FlyBehavior.java

package Fly;

public interface FlyBehavior
{
public void fly();
}

[java]
// FlyNoWay.java

package Fly;

public class FlyNoWay implements FlyBehavior
{
    public void fly() {
        System.out.println("I can fly in no way");
    }
}

[java]
// FlyRocketPowered.java

package Fly;

public class FlyRocketPowered implements FlyBehavior
{
    public void fly(){
        System.out.println("I'm flying with a rocket");
    }
}

[java]
// FlyWithWings.java

package Fly;

public class FlyWithWings implements FlyBehavior
{
    public void fly(){
        System.out.println("I can Fly With Wings");
    }
}

[java]
// QuackBehavior.java

package Quack;

public interface QuackBehavior
{
public void quack();
}

[java]
// Quack.java

package Quack;

public class Quack implements QuackBehavior
{
    public void quack(){
        System.out.println("I can Quack, gua gua ...");
    }
}

[java]
// MuteQuack.java

package Quack;

public class MuteQuack implements QuackBehavior
{
    public void quack(){
        System.out.println("I am MuteQuack, I can't Quack.");
    }
}

[java]
// Squeak.java

package Quack;

public class Squeak implements QuackBehavior
{
    public void quack(){
        System.out.println("I am Squeak, I can Quack, zi zi ...");
    }

}

[java]
// Duck.java

package Duck;

import Fly.*;
import Quack.*;

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

    public Duck() { }

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

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

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

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


    public void swim() {
        System.out.println("All ducks can Swim.");
    }

    public abstract void display();

}

[java]
// DecoyDuck.java

package Duck;
import Fly.*;
import Quack.*;

public class DecoyDuck extends Duck
{
    public DecoyDuck() {
        flyBehavior = new FlyNoWay();
        quackBehavior = new MuteQuack();
    }

    public void display() {
        System.out.println("I'm a duck Decoy");
    }
}

[java]
// MallardDuck.java

package Duck;
import Fly.*;
import Quack.*;

public class MallardDuck extends Duck
{
    public MallardDuck() {
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    public void display() {
        System.out.println("I'm Mallard duck");
    }
}

[java]
// MiniDuckSimulator.java

package Duck;
import Fly.*;
import Quack.*;

public class MiniDuckSimulator extends Duck
{
    public MiniDuckSimulator(){
        super();
        super.setFlyBehavior(new FlyNoWay());
        super.setQuackBehavior(new MuteQuack());
    }

    public void display(){
        System.out.println("I'm MiniDuckSimulator");
    }

}

[java]
// RedheadDuck.java

package Duck;
import Fly.*;
import Quack.*;

public class RedheadDuck extends Duck
{
    public RedheadDuck() {
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

    public void display() {
        System.out.println("I'm Red Headed duck");
    }
}

[java]
// RubberDuck.java

package Duck;

import Fly.FlyNoWay;
import Quack.MuteQuack;

public class RubberDuck extends Duck
{
    public RubberDuck(){
        super();
        setFlyBehavior(new FlyNoWay());
        setQuackBehavior(new MuteQuack());
    }

    public void display(){
        System.out.println("I'm RubberDuck.");
    }

}

末尾，我還是將《Head First 設計模式》的一章重要知識摘錄下來吧：

00基礎：
01 抽象，
02 封裝，
03 多態，
04 繼承。
00原則：
01 封裝變化，
02 多用組合，少用繼承，
03 針對接品編程，不針對實現編程。
00模式：
01 （Strategy Pattern）策略模式――定義算法族，分別封裝起來，讓它們之間可以互相替換，此模式讓算法的變化獨立於使用算法的客戶。
00要點
01 知道OO基礎，並不足以讓你設計出良好的OO系統。
02 良好的OO設計必須具備可復用、可擴充、可維護三個特性。
03 模式可以讓我們建造出具有良好的OO設計質量的系統。
04 模式被認為是歷經驗證的OO設計經驗。
05 模式不是代碼，而是針對設計問題的通用解決方案。你可把它們應用到特定的應用中。
06 模式不是被發明，而是被發現。
07 大多數的模式和原則，都著眼於軟件變化的主題。
08 大多數的模式都允許系統局部改變獨立於其他部分。
09 我們常把系統中會變化的部分抽出來封裝。
10 模式讓開發人員之間有共享的語言，能夠最大化溝通的價值。