设计模式学习笔记（1）

前言
以前粗略的看过设计模式，有的看懂了，有的没看懂，有的看懂了又忘了，有的在写程序时已不知不觉在用了.
总之，现在从头学习一遍，并且开始做笔记，这样记的牢。
以后写程序也要有意识的向设计模式靠拢。
那本经典的《设计模式》准备去买一本，一共有23种设计模式，这里我先研究了5种，后面争取都研究完，例子是C#的，不过对于C++、java、delphi应该都是适用的。
欢迎大家和我讨论！

目录
1.singleton
2.strategy
3.Decorator
4.composite
5.state

1.Singleton
说明：保证类只有一个实例。
实例：
using System;
class Singleton
{
private static Singleton singleton = null;
public static Singleton Instance()
{
if (null == singleton)
singleton = new Singleton();
return singleton;
}

private Singleton()
{
}
}

class Application
{
public static void Main()
{
Singleton s1 = Singleton.Instance();
//Singleton s2 = new Singleton(); //错误：构造器不可访问
Singleton s2 = Singleton.Instance();
if (s1.Equals(s2)) // 引用相等
Console.WriteLine("Instances are identical");
}
}

/*以下是程序输出结果：
Instances are identical
*/

2.strategy
说明：利用接口实现方法无关化，客户程序同特定算法实现细节毫无耦合关系。
实例：
using System;

namespace strategy1
{
/// <summary>
/// Summary description for Class.
/// </summary>
interface Strategy
{
bool IsPrime(int n);
}

class Miller : Strategy
{
public bool IsPrime(int n){
bool result = false;
//使用Miller法测试n是否为素数，果真，则更新result值
Console.WriteLine("Using Miller's algorithm");
return result;
}
}

class Fermat : Strategy
{
public bool IsPrime(int n){
bool result = false;
//使用Fermat法测试n是否为素数，果真，则更新result值
Console.WriteLine("Using Fermat's algorithm");
return result;
}
}

class Mersenne : Strategy
{
public bool IsPrime(int n)
{
bool result = false;
//使用Mersenne法测试n是否为素数，果真，则更新result值
Console.WriteLine("Using Mersenne's algorithm");
return result;
}
}

class Primality
{
private Strategy strategy;

public Primality(Strategy s)
{
strategy = s;
}
public bool Test(int n)
{
return strategy.IsPrime(n);
}
}

class Class
{
[STAThread]
static void Main(string[] args)
{
Console.Write("Number to be tested: ");
string input = Console.ReadLine();
int n = Int32.Parse(input);
Console.Write("Desired algorithm performance: lo, medium, hi? ");
input = Console.ReadLine();
char ch = char.Parse(input);
Primality prime = null;
switch (ch)
{
case 'l':
case 'L':
prime = new Primality(new Miller());
break;

case 'm':
case 'M':
prime = new Primality(new Fermat());
break;

case 'h':
case 'H':
prime = new Primality(new Mersenne());
break;
}

if (prime != null)
{
bool result = prime.Test(n);
}
else
Console.WriteLine("Bad Choice!");

Console.ReadLine();
}

}

}

/*以下是某次测试输出结果：
Number to be tested:1
Desired algorithm performance: lo, medium, hi? M
Using Fermat's algorithm
*/

3.Decorator
说明：通过子类实现功能的灵活扩展。
实例：
using System;

namespace decortation
{
/// <summary>
/// Summary description for Class.
/// </summary>

class FileTransfer
{
public virtual void Download(string url, byte[] data, int size)
{
// 下载文件
}
public virtual void Upload(string url, byte[] data, int size)
{
// 上传文件
}
}

class Decorator : FileTransfer
{
private FileTransfer ft = new FileTransfer();
private bool IsAccessAllowed(string url)
{
bool result = true;
// 决定是否对请求的URL访问授权
return result;
}

private void LogAccess(string url)
{
// 将URL、时间、用户身份等信息写入数据库
Console.WriteLine("Logging access to {0}", url);
}

public override void Download(string url, byte[] data, int size)
{
if (!IsAccessAllowed(url)) return;
ft.Download(url, data, size);
LogAccess(url);
}

public override void Upload(string url, byte[] data, int size)
{
if (!IsAccessAllowed(url)) return;
ft.Upload(url, data, size);
LogAccess(url);
}
}

class Class
{
public static void Main()
{
Console.Write("Enter URL to access: ");
string url = Console.ReadLine();
Console.Write("Enable logging and access check? ");
string input = Console.ReadLine();
char ch = char.Parse(input);
bool decoration = (ch == 'y' || ch == 'Y');
FileTransfer ft = null;
if (!decoration)
ft = new FileTransfer();
else
ft = new Decorator();
byte[] buf = new byte[1024];
ft.Download(url, buf, 1024);
}
}

}

4.composite
说明：利用接口达到用一致的方式来访问所有对象（这个很常用的）。
实例：
C#示例：
using System;
using System.Collections;
interface Shape
{
void Draw();
}
class Line : Shape
{
private double x1, y1, x2, y2;
public Line(double x1, double y1, double x2, double y2)
{
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
public void Draw()
{
//从(x1, y1) 到(x2, y2)画一条线
Console.WriteLine("Drawing a line");
}
}
class Circle : Shape
{
private double x, y, r;
public Circle(double x, double y, double radius)
{
this.x = x;
this.y = y;
this.r = r;
}
public void Draw()
{
//以(x, y)为圆心，r为半径画一个圆
Console.WriteLine("Drawing a circle");
}
}
class Drawing : Shape
{
private ArrayList shapes;
public Drawing()
{
shapes = new ArrayList();
}
public void Add(Shape s)
{
shapes.Add(s);
}
public void Draw()
{
IEnumerator enumerator = shapes.GetEnumerator();
while (enumerator.MoveNext())
((Shape) enumerator.Current).Draw();
}
}
class Application
{
public static void Main()
{
Shape[] array = new Shape[3];
array[0] = new Line(0, 0, 10, 12);
array[1] = new Circle(2, 3, 5.5);
Drawing dwg = new Drawing();
dwg.Add(new Line(3, 4, 3, 5));
dwg.Add(new Circle(5, 6, 7.7));
array[2] = dwg;
// 画出所有的图形，注意：用一致的方式来访问所有对象
for (int i = 0; i < 3; ++i)
array[i].Draw();
}
}
/*以下是程序输出结果：
Drawing a line
Drawing a circle
Drawing a line
Drawing a circle
*/

5.state
说明：当对象内部状态改变时自动改变它的行为。

实例：
这个实例比较长，我简单说明一下，这是一个自动售货机的例子，客户可以投掷面值5、10、25的硬币，货物价值25。每当客户投了硬币就打印投的钱数和，如果够了25，就提示货物售出。
state是个抽象类，它派生了5、10、15、20、25几种钱数和的类（也就是所有可能的钱数和），由于它们都是从STATE继承的，所以它们都有一个STATE类型的静态成员state作为状态的标识（你可以把它想象成全局变量），每个类都接收投入5、10、25面值的硬币，对应的方法是
public virtual void AddNickel(VendingMachine vm) { }
public virtual void AddDime(VendingMachine vm) { }
public virtual void AddQuarter(VendingMachine vm) { }
虽然方法一样，但是每个类内部实现的状态跃迁是不一样的，比如5元的类，接收10元后state就跃迁到了15元，以此类推。
仔细看看吧，这是一个非常有意思的实例。不过说实话，这样实现程序确实太累了，也许在别的应用中可以降低程序员的负担，不过我还没发现（有的话告诉我）。
另外如果有100种状态，有10种路径，难道每个状态都要继承（100×10）？那coding起来岂不是太累，而且代码不要太长啊，唉，当程序员真不容易啊...

using System;

abstract class State

{

public virtual void AddNickel(VendingMachine vm) { }

public virtual void AddDime(VendingMachine vm) { }

public virtual void AddQuarter(VendingMachine vm) { }

protected virtual void ChangeState(VendingMachine vm, State s)

{

vm.ChangeState(s);

}

}

class VendingMachine

{

private State state;

public VendingMachine()

{

Console.WriteLine("The Vending Machine is now online: product costs 25c");

state = Start.Instance();

}

public void ChangeState(State to)

{

state = to;

}

public void Vend()

{

// 发饮料

Console.WriteLine("Dispensing product...Thank you!");

}

public void AddNickel()

{

state.AddNickel(this);

}

public void AddDime()

{

state.AddDime(this);

}

public void AddQuarter()

{

state.AddQuarter(this);

}

}

class Start : State

{

private static State state = new Start();

private Start()

{

}

public static State Instance()

{

// singleton逻辑

Console.WriteLine("Credit: 0c");

return state;

}

public override void AddNickel(VendingMachine vm)

{

ChangeState(vm, Five.Instance());

}

public override void AddDime(VendingMachine vm)

{

ChangeState(vm, Ten.Instance());

}

public override void AddQuarter(VendingMachine vm)

{

vm.Vend();

}

}

class Five : State

{

private static State state = new Five();

private Five()

{

}

public static State Instance()

{

// singleton 逻辑

Console.WriteLine("Credit: 5c");

return state;

}

public override void AddNickel(VendingMachine vm)

{

ChangeState(vm, Ten.Instance());

}

public override void AddDime(VendingMachine vm)

{

ChangeState(vm, Fifteen.Instance());

}

public override void AddQuarter(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance()); // no change returned :-)

}

}

class Ten : State

{

private static State state = new Ten();

private Ten()

{

}

public static State Instance()

{

// singleton 逻辑

Console.WriteLine("Credit: 10c");

return state;

}

public override void AddNickel(VendingMachine vm)

{

ChangeState(vm, Fifteen.Instance());

}

public override void AddDime(VendingMachine vm)

{

ChangeState(vm, Twenty.Instance());

}

public override void AddQuarter(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance()); // no change returned :-)

}

}

class Fifteen : State

{

private static State state = new Fifteen();

private Fifteen()

{

}

public static State Instance()

{

// singleton 逻辑

Console.WriteLine("Credit: 15c");

return state;

}

public override void AddNickel(VendingMachine vm)

{

ChangeState(vm, Twenty.Instance());

}

public override void AddDime(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance());

}

public override void AddQuarter(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance()); // no change returned :-)

}

}

class Twenty : State

{

private static State state = new Twenty();

private Twenty()

{

}

public static State Instance()

{

// singleton 逻辑

Console.WriteLine("Credit: 20c");

return state;

}

public override void AddNickel(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance());

}

public override void AddDime(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance());

}

public override void AddQuarter(VendingMachine vm)

{

vm.Vend();

ChangeState(vm, Start.Instance()); // no change returned :-)

}

}

class Application

{

public static void Main()

{

int coin = 0;

string input = null;

VendingMachine vm = new VendingMachine();

while (true)

{

Console.Write("Insert a coin (5, 10, 25): ");

input = Console.ReadLine();

coin = Int32.Parse(input);

switch (coin)

{

case 5:

vm.AddNickel();

break;

case 10:

vm.AddDime();

break;

case 25:

vm.AddQuarter();

break;

default:

break;

}

}

}

}

/*以下是某次运行时输出结果：

The Vending Machine is now online: product costs 25c

Credit: 0c

Insert a coin <5, 10, 25>: 5

Credit: 5c

Insert a coin <5, 10, 25>: 10

Credit: 15c

Insert a coin <5, 10, 25>: 5

Credit: 20c

Insert a coin <5, 10, 25>: 5

Dispensing product...Thank you!

*/