设计模式学习笔记(1)

原创 2004年08月27日 12:42:00

前言
以前粗略的看过设计模式,有的看懂了,有的没看懂,有的看懂了又忘了,有的在写程序时已不知不觉在用了.
总之,现在从头学习一遍,并且开始做笔记,这样记的牢。
以后写程序也要有意识的向设计模式靠拢。
那本经典的《设计模式》准备去买一本,一共有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!

*/

C++不足之处讨论系列(四)--函数重载

以下文章翻译自Ian Joyner所著的《C++?? A Critique of C++ and Programming and Language Trends of the 1990s》 3/E【I...
  • cber
  • cber
  • 2001-05-21 23:26:00
  • 1228

java学习笔记1(java io/nio)

  • 2011年08月30日 19:01
  • 561KB
  • 下载

设计模式(c++)笔记 总结

一、设计模式分类:       按照目的来分,设计模式可以分为创建型模式、结构型模式和行为型模式。(分类如下表)       创建型模式用来处理对象的创建过程;      结构型模式用来...
  • my183100521
  • my183100521
  • 2013-10-25 15:55:49
  • 2055

设计模式学习笔记--Flyweight享元模式.docx

  • 2010年03月30日 13:19
  • 64KB
  • 下载

设计模式学习笔记--备忘录模式

一.简介 今天来学习一下设计模式中的备忘录模式。说到这个模式,也许不太熟悉,不过相信写代码的时候,写错了之后,Ctrl+Z的功能用得还是比较多的,比如Word,Photoshop等编辑软件中,撤销...
  • puppet_master
  • puppet_master
  • 2016-05-06 14:46:32
  • 900

《javascript设计模式与开发实践》阅读笔记(三)

this,call和apply2.1 thisthis指针的用法,相信在很多场合都看到过,这里也总结了几点: 作为对象的方法调用 作为普通函数调用 构造器调用 Function.prototype.c...
  • sinat_25127047
  • sinat_25127047
  • 2016-11-03 11:41:40
  • 472

Head First 设计模式读书笔记

第一章 设计模式入门 Duck设计原则:把可能变化之处找出来,并独立。                           针对接口编程,实现多态。 把Duck的可能变化的行为独立出来,委托给行为类实...
  • fengyun703
  • fengyun703
  • 2016-05-12 12:07:41
  • 481

大话设计模式 读书笔记

大话设计模式 读书笔记 着重从c#代码角度分析 学习心得: 学设计模式,不需要是否能立刻理解和记忆,无需着力首先是UML图 再从设计模式到UML图 从UML图到代码 其次知道各种模式的应用场景即可...
  • jiangdmdr
  • jiangdmdr
  • 2017-03-01 18:50:25
  • 592

设计模式 -- 状态模式(State)

理解 状态模式一般运用在一个对象在某些条件下能触发一些不同的行为的情形。其实系统开发中到处都充斥着这些情形,初学者往往都是习惯性的用面向过程的思维方式解决问题,往往看到模块中if .. else .....
  • u010223072
  • u010223072
  • 2016-06-26 15:39:45
  • 2536

设计模式---可复用面向对象软件的基础 阅读笔记(一)

设计模式---可复用面向对象软件的基础 阅读笔记(一)            扯些淡:为什么会读这本书,有什么样的意义。目的是为了站在更高层次上去看编码,而且在做的也是产品,对于不想只做个简单的、无...
  • u013793732
  • u013793732
  • 2016-09-03 16:03:51
  • 573
收藏助手
不良信息举报
您举报文章:设计模式学习笔记(1)
举报原因:
原因补充:

(最多只允许输入30个字)