设计模式学习笔记(2)

原创 2004年08月27日 15:49:00

目录

6.Prototype

7.Builder

8.Astract factory

9.factory method

6.Prototype
说明:实现对象的深拷贝(也可以是浅拷贝)。深拷贝是指生成对象的实体拷贝,而浅拷贝只返回对象的引用。
在C#中提供了ICloneable接口,它只有一个Clone()方法(这和JAVA类似),我们利用它来实现Prototype模式。
浅拷贝的实现:system namespace下提供了MemberwiseClone()方法实现浅拷贝,在Clone()中调用它即可。
深拷贝的实现:手动实现,看下面的实例。
实例:
//----浅拷贝--------
using System; 
namespace Prototype_Shallow{ 
   //因为我们在FCL里面已经有这样的接口所以我们就不定义新的Prototype了 
   public class ConcretePrototype1 : ICloneable{ 
   private int m_ID; 
   public int ID{ 
   get{ 
   return this.m_ID; 
   } 
   }
  
   public ConcretePrototype1(int id){ 
   this.m_ID = id; 
   } 
   
   public object Clone(){ 
   return this.MemberwiseClone(); 
   } 
  } 
   

   public class ConcretePrototype2 : ICloneable{ 
   private int m_ID; 
   public int ID 
   { 
   get 
   { 
   return this.m_ID; 
   } 
  }
  
   public ConcretePrototype2(int id){ 
   this.m_ID = id; 
  }
  
   public object Clone(){ 
   return this.MemberwiseClone(); 
   } 
   }
}
//下面是调用部分
ConcretePrototype1 p1 = new ConcretePrototype1(1);
ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();

 

//----深拷贝-----------
namespace Prototype_Deep{
  
   using System.Collections;
  
   public class ConcretePrototype : ICloneable
  
   {
  
   private int m_ID;
  
   public int ID
  
   {
  
   get
  
   {
  
   return this.m_ID;
  
   }
  
   }
  
  
  
   private ArrayList m_arrayList = new ArrayList();
  
  
  
   public ConcretePrototype(int id)
  
   {
  
   this.m_ID = id;
  
   this.m_arrayList.Add("FirstObject");
  
   this.m_arrayList.Add("SecondObject");
  
   // ...
  
   }
  
  
  
   public object Clone()
  
   {
  
   ConcretePrototype c = new ConcretePrototype(this.ID);
  
   c.m_arrayList = new ArrayList();
  
   c.m_arrayList.Add("FirstObject");
  
   c.m_arrayList.Add("SecondObject");
  
   return c;
  
   }
  
  
  
   public ConcretePrototype DeepClone(){
  
   return (ConcretePrototype)this.Clone();
  
   }
  
   }
  
  }

  //下面是调用部分
 
   ConcretePrototype p = new ConcretePrototype(1);
  
   ConcretePrototype c = p.DeepClone();
  
   this.richTextBox1.AppendText(p.ToString()+":"+p.ID.ToString()+"/n");
  
   this.richTextBox1.AppendText(c.ToString()+":"+c.ID.ToString()+"/n");
  
   c.m_arrayList[0] = "Changed";
  
   for(int i = 0;i<=1;i++){
  
   this.richTextBox1.AppendText(c.m_arrayList[i].ToString());
  
   }
  
   this.richTextBox1.AppendText("/n");
  
   for(int i = 0;i<=1;i++){
  
   this.richTextBox1.AppendText(p.m_arrayList[i].ToString());
  
   }


7.builder
说明:builder是非常好理解的,就是把复杂的对象分成若干个简单对象来实现,就好像生产汽车一样,是由各个零件组装成的。我觉得如果每个子对象不会彼此依赖,用这种模式会非常好,可以灵活的拼装出新的复杂类。
实例:
  using System; 
  namespace Builder_Me{ 
   using System.Collections; 
   // specifies an abstract interface for creating parts of a Product object. 
   //为创建对象的一个部分指定一个接口 
   public interface Builder{ 
   void BuildPartA(); 
   void BuildPartB(); 
   Product GetResult(); 
   } 
   
   // constructs and assembles parts of the product by impementing the Builder interface. 
   // defines and keeps track of the representation it creates. 
   // provides an interface for retrieving the product. 
   public class ConcreteBuilder1 : Builder{ 
   private Product m_Product; 
   public void BuildPartA(){ 
   this.m_Product = new Product(); 
   this.m_Product.AddParts("1","PartA"); 
   }
  
   public void BuildPartB(){ 
   this.m_Product.AddParts("2","PartB"); 
   }
  
  
   public Product GetResult(){ 
   return this.m_Product; 
   } 
   }
  
  
   public class ConcreteBuilder2 : Builder{ 
   private Product m_Product; 
   public void BuildPartA(){ 
   //必须先调用该方法否则不能实例化对象 
   this.m_Product = new Product(); 
   this.m_Product.AddParts("3","Part1"); 
  } 

   public void BuildPartB(){ 
   this.m_Product.AddParts("4","Part2"); 
  } 
   
   public Product GetResult(){ 
   return this.m_Product; 
   } 
   } 
   
   // construct an object using the Builder interface. 
   public class Director{ 
   public void Construct(Builder builder){ 
   //顺序不能变 
   builder.BuildPartA(); 
   builder.BuildPartB(); 
   } 
   } 

   
   // represents the complex object under construction.ConcreteBuilder builds 
   // the product's internal representation and defines the process by which it's 
   // assembled. 
   // includes classes that define the constituent parts,including interfaces for 
   // assembling the parts into the final result. 
   //要创建复杂的对象该对象我们用Hashtable组合表示。 
   public class Product{ 
   Hashtable m_Parts = new Hashtable(); 
   public void AddParts(string partKey,string partValue){ 
   this.m_Parts.Add(partKey,partValue); 
   } 

   public string ShowSelfParts(){ 
   string strResult = string.Empty; 
   int i = 1; 
   foreach(string strTmp in this.m_Parts.Values){ 
   strResult +="Part"+i.ToString()+":/t"+strTmp+"/n"; 
   i++; 
  } 
  return strResult; 
   } 
   } 
  }
  
  客户端的代码片断如下: 
  Director director = new Director(); 
   Builder builder1 = new ConcreteBuilder1(); 
   Builder builder2 = new ConcreteBuilder2(); 
   director.Construct( builder1 ); 
   Product p1 = builder1.GetResult(); 
   this.richTextBox1.AppendText(p1.ShowSelfParts()); 
   
   director.Construct( builder2 ); 
   Product p2 = builder2.GetResult(); 
   this.richTextBox1.AppendText(p2.ShowSelfParts());

  
  
  8.Astract factory
  说明:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们的具体类。
  实例:
  using System;
   namespace AbstractFactory_Maze{
   using Maze;
   public interface AbstractFactory{ 
   MazeClass MakeMaze(); 
   Wall MakeWall(); 
   Room MakeRoom(int n); 
   Door MakeDoor(Room oneRoom,Room otherRoom); 
   } 
   
   public class MazeFactory : AbstractFactory{ 
   public MazeClass MakeMaze(){ 
   return new MazeClass(); 
   }
  
   public Wall MakeWall(){ 
   return new Wall(); 
   }
  
   public Room MakeRoom(int n){ 
   return new Room(n); 
   }
  
   public Door MakeDoor(Room oneRoom,Room otherRoom){ 
   return new Door(oneRoom,otherRoom); 
   } 
   } 
   
   // this is a client 
   public class MazeGame{ 
   public MazeClass MazeCreate(AbstractFactory factory){ 
   MazeClass aMaze = factory.MakeMaze(); 
   Room r1 = factory.MakeRoom(1); 
   Room r2 = factory.MakeRoom(2); 
   Door aDoor = factory.MakeDoor(r1,r2); 
   
   aMaze.AddRoom(r1); 
   aMaze.AddRoom(r2); 

   r1.SetSide(Direction.North,factory.MakeWall()); 
   r1.SetSide(Direction.East,aDoor); 
   r1.SetSide(Direction.South,factory.MakeWall()); 
   r1.SetSide(Direction.West,factory.MakeWall()); 
   
   r2.SetSide(Direction.North,factory.MakeWall()); 
   r2.SetSide(Direction.East,factory.MakeWall()); 
   r2.SetSide(Direction.South,factory.MakeWall()); 
   r2.SetSide(Direction.West,aDoor);

   return aMaze; 
   } 
   } 
  } 
   
namespace Maze{ 
   using System.Collections;

   public class MapSite{ 
   public virtual void Enter(){} 
   }
  

   public enum Direction {North,South,East,West}


   public class Room : MapSite{ 
   public string Print(){ 
   string result = ""; 
   for(int i = 0 ;i<=3;i++){ 
   switch(i){ 
   case (int)Direction.East:{ 
   result += "East is:"+this.GetSide(Direction.East)+"/t"; 
   break; 
   }
  
   case (int)Direction.North:{ 
   result += "North is:"+this.GetSide(Direction.North)+"/t"; 
   break; 
   }
  
   case (int)Direction.South:{ 
   result += "South is:"+this.GetSide(Direction.South)+"/t"; 
   break; 
   }
  
   case (int)Direction.West:{ 
   result += "West is:"+this.GetSide(Direction.West)+"/t"; 
   break; 
   } 
   } 
   } 
   return result; 
   }
  
 
   public Room(int n){ 
   this.m_roomNumber = n; 
   }
  
 
   public MapSite GetSide(Direction dir){ 
   return this.m_sides[(int)dir]; 
   }
  

   public void SetSide(Direction dir,MapSite mapSite){ 
   this.m_sides[(int)dir] = mapSite; 
   }
  
 
   public override void Enter(){} 
   private MapSite[] m_sides = new MapSite[4]; 
   int m_roomNumber; 
  }
  
 
   public class Wall : MapSite{ 
   public Wall(){} 
   public override void Enter(){} 
   }
  
 
   public class Door : MapSite{ 
   public Door(Room oneRoom,Room otherRoom){} 
   public override void Enter(){} 
   public Room oneRoom{ 
   get{return this.m_oneRoom;} 
   set{this.m_oneRoom = value;} 
   }
  
   private Room m_oneRoom; 
   public Room otherRoom{ 
   get{return this.m_otherRoom;} 
   set{this.m_otherRoom = value;} 
   }
  
   private Room m_otherRoom;
  
   private bool m_isOpen;
  
   public bool IsOpen{
  
   get{return this.m_isOpen;}
  
   set{this.m_isOpen = value;}
  
   }
  
   }
  
 
   public class MazeClass{
  
   public MazeClass(){}
  

   public string Print(){
  
   string result = "";
  
   for(int i = 0; i<=this.m_Maze.Count-1;i++){
  
   result +=this.RoomNumber(i).Print()+"/n";
  
   }
  
   return result;
  
   }
  
 
   public void AddRoom(Room room){
  
   m_Maze.Add(room);
  
   }
  

   public Room RoomNumber(int roomNumber){
  
   return (Room)this.m_Maze[roomNumber];
  
   }
  
  
   private ArrayList m_Maze = new ArrayList();
  
   }
  
  }
  
 
   private void Form1_Load(object sender, System.EventArgs e) {
  
   AbstractFactory factory = new MazeFactory();
  
   MazeGame game = new MazeGame();
  
   MazeClass aMaze = game.MazeCreate(factory);
  
   this.richTextBox1.AppendText(aMaze.Print());
 
   }
  
 
  以下为输出结果:
  
  North is:Maze.Wall South is:Maze.Wall East is:Maze.Door West is:Maze.Wall
  
  North is:Maze.Wall South is:Maze.Wall East is:Maze.Wall West is:Maze.Door


 9.factory method
 说明:工厂方法的目的很明确就是定义一个用来创建对象的接口,但是他不直接创建对象,而由他的子类来创建,这样一来就将创建对象的责任推迟到了该接口的子类中,创建什么类型的对象由子类来决定,而创建对象的时间由接口来定。
 实例:
  using System;
  
  using System.Collections;
  
  // 该命名空间中是一些运行实例德的环境包括Maze、Door等等
  
  namespace CommonObject{
  
  
  
   // 所有的迷宫构件的基类里面有一个方法用来显示当前构件的信息
  
   public class MapSite{
  
   public virtual string Enter(){
  
   return string.Empty;
  
   }
  
   }
  
  
  
   // 墙是组成迷宫的构件之一,这里是一个很一般的墙(没有炸弹)
  
   public class Wall : MapSite{
  
   public override string Enter(){
  
   return "This is a Wall.";
  
   }
  
   public Wall(){}
  
   }
  
  
  
   // 门也是迷宫的组成部分之一,这也是一个很普通的门(不能施魔法)
  
   public class Door : MapSite{
  
  
  
   public override string Enter(){
  
   return "This is a Door.";
  
   }
  
  
  
   // 门是在两个房子之间的构件所以构造函数包含两个房子
  
   // 说明是哪两个房子之间的门
  
   public Door(Room roomFrom,Room roomTo){
  
   this.m_Room1 = roomFrom;
  
   this.m_Room2 = roomTo;
  
   }
  
  
  
   // 让我们有机会可以从门进入另一个房子,将会得到
  
   // 另一个房子的引用
  
   public Room OtherSideFrom(Room roomFrom){
  
   if(this.m_Room1 == roomFrom)
  
   return this.m_Room2;
  
   else
  
   return this.m_Room1;
  
   }
  
  
  
   // 这是一些私有的变量
  
   private Room m_Room1;
  
   private Room m_Room2;
  
   // 描述门的状态默认所有的新门都是关的
  
   private bool m_IsOpen = false;
  
   // 提供一个公共访问的访问器
  
   public bool IsOpen{
  
   set{this.m_IsOpen = value;}
  
   get{return this.m_IsOpen;}
  
   }

   }
  
  
  
   // 房间是组成迷宫的基本单位
  
   public class Room : MapSite
  
   {
  
   // 枚举类型表示房子的面
  
   public enum Sides{
  
   North = 0,
  
   East,
  
   South,
  
   West
  
   }
  
  
  
   public override string Enter(){
  
   return "This is a Room.";
  
   }

   // 构造函数,为了可以区分房间我们给每一个房间加一个标示
  
   public Room(int roomNumber){
  
   this.m_roomNumber = roomNumber;
  
   }

  
   // 设置房子的面,房子有4个面组成,因为我们现在不知道每个面
  
   // 的具体类型(门?墙?)所以我们用MapSite类型。
  
   public void SetSide(Sides side,MapSite sideMap){
  
   this.m_side[(int)side] = sideMap;
  
   }

   // 得到指定的面,同样我们不知道得到的是哪一个面
  
   // 所以我们用MapSite返回结构
  
   public MapSite GetSide(Sides side){
  
   return this.m_side[(int)side];
  
   }

   // 一些私有成员 房号
  
   protected int m_roomNumber;
  
   // 房子有4个面
  
   protected const int m_Sides = 4;
  
   // 用一个1维的MapSite数组存储未知类型的面(墙或门)
  
   protected MapSite[] m_side = new MapSite[m_Sides];

   }

   // 带炸弹的房子
  
   public class BombedRoom : Room{
  
   public BombedRoom(int roomNumber) : base(roomNumber){}
  
   }

  
   // 带迷宫的房子
  
   public class EnchantedRoom : Room{
  
   public EnchantedRoom(int roomNumber,Spell spell) : base(roomNumber){}
  
   }

  
   // 这是一个特殊的墙--带炸弹的
  
   public class BombedWall : Wall{}
  
  
  
   // 这是一个可以施魔法的门
  
   public class EnchantedDoor : Door{
  
   public EnchantedDoor(Room roomFrom,Room roomTo) : base(roomFrom,roomTo){}
  
   }

   // 这就是我们的迷宫了
  
   public class Maze{
  
   private ArrayList m_Rooms = new ArrayList();
  
   public Room RoomNumber(int roomNumber){
  
   return (Room)this.m_Rooms[roomNumber];
  
   }
  
   public void AddRoom(Room room){
  
   this.m_Rooms.Add(room);
  
   }
  
   }

  
   // 魔法类
  
   public class Spell{}
  
  }
  
  接下来是工厂方法的实现:
  
  using System;
  
  using System.Collections;
  
  namespace FactoryMethod_Example
  
  {
  
  
  
   // 加入MazeContext
  
   using CommonObject;
  
  
  
   // 实现了一些工厂方法的Creator类
  
   public class MazeGame
  
   {
  
   // 要返回给Client的对象
  
   private Maze m_Maze = null;
  
  
  
   // 一个访问器用来得到maze
  
   public Maze Maze
  
   {
  
   get
  
   {
  
   if (this.m_Maze == null)
  
   this.m_Maze = CreateMaze();
  
   return this.m_Maze;
  
   }
  
   }
  
  
  
   // 构造器
  
   public MazeGame()
  
   {
  
   }
  
  
  
   // 以下就是一些工厂方法创建迷宫的每个个构件
  
   public virtual Maze MakeMaze()
  
   {
  
   return new Maze();
  
   }
  
  
  
   public virtual Room MakeRoom(int id)
  
   {
  
   return new Room(id);
  
   }
  
  
  
   public virtual Wall MakeWall()
  
   {
  
   return new Wall();
  
   }
  
  
  
   public virtual Door MakeDoor(Room room1, Room room2)
  
   {
  
   return new Door(room1, room2);
  
   }
  
  
  
   // 创建迷宫
  
   public Maze CreateMaze()
  
   {
  
   Maze maze = MakeMaze();
  
  
  
   // 创建门和房间
  
   Room room1 = MakeRoom(1);
  
   Room room2 = MakeRoom(2);
  
   Door theDoor = MakeDoor(room1, room2);
  
  
  
   // 将房间添加到迷宫里面
  
   maze.AddRoom(room1);
  
   maze.AddRoom(room2);
  
  
  
   // 设置room1的面
  
   room1.SetSide(Room.Sides.North, MakeWall());
  
   room1.SetSide(Room.Sides.East, theDoor);
  
   room1.SetSide(Room.Sides.South, MakeWall());
  
   room1.SetSide(Room.Sides.West, MakeWall());
  
  
  
   // 设置room2的面
  
   room2.SetSide(Room.Sides.North, MakeWall());
  
   room2.SetSide(Room.Sides.East, MakeWall());
  
   room2.SetSide(Room.Sides.South, MakeWall());
  
   room2.SetSide(Room.Sides.West, theDoor);

   return maze;
  
   }
  
   }

  
   // 创建带炸弹迷宫
  
   public class BombedMazeGame : MazeGame{
  
   public BombedMazeGame(){}
  
   public override Wall MakeWall(){
  
   return new BombedWall();
  
   }

   public override Room MakeRoom(int n){
  
   return new BombedRoom(n);
  
   }
  
   }

   // 创建带魔法的迷宫
  
   public class EnchantedMazeGame : MazeGame{

   private Spell m_spell;

   public EnchantedMazeGame(Spell spell){
  
   this.m_spell = spell;
  
   }
  
   public override Door MakeDoor(Room r1,Room r2){
  
   return new EnchantedDoor(r1,r2);
  
   }

   public override Room MakeRoom(int n){
  
   return new EnchantedRoom(n,this.m_spell);
  
   }

   }
  
  }
  

大话设计模式 读书笔记

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

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

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

Java设计模式之初学者笔记——设计模式基础讲解

设计模式基础讲解
  • u012817635
  • u012817635
  • 2016年04月06日 20:11
  • 3314

【设计模式】学习笔记10:外观模式(Facade)

上一次我们已经知道了适配器模式是如何将一个类的接口转换成另一个符合客户期望的接口了。Java中要做到这一点,必须将一个不兼容接口的对象包装起来,变成兼容的对象。 这次要学的是外观模式. 外观模式是将一...
  • shuangde800
  • shuangde800
  • 2013年08月13日 00:42
  • 2706

《Android源码设计模式解析与实战》读书笔记(十)

第十章、解释器模式 解释器模式是一种用的比较少的行为型模式,其提供了一种解释语言的语法或表达式的方式。但是它的使用场景确实很广泛,只是因为我们自己很少回去构造一个语言的文法,所以使用较少。...
  • qq_17766199
  • qq_17766199
  • 2015年12月23日 09:08
  • 2078

学习Java设计模式的10条建议

设计模式在整个Java的学习路线图中有着承上启下的作用。
  • printj
  • printj
  • 2014年07月28日 15:11
  • 1010

java设计模式学习汇总

1.什么是设计模式 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编制真正工程化,设...
  • tomcat_2014
  • tomcat_2014
  • 2017年03月07日 10:33
  • 556

如何学习设计模式

GoF的[设计模式]是经典著作,有人看了好多遍仍然说没有看懂,许多人看懂了一些模式但不知道如何应用……这里,yqj2065抛砖引玉,讨论一下如何学习设计模式。...
  • yqj2065
  • yqj2065
  • 2014年09月06日 21:20
  • 6028

CUDA学习笔记二

前言 线程的组织形式对程序的性能影响是至关重要的,本篇博文主要以下面一种情况来介绍线程组织形式: 2D grid 2D block 线程索引 一般,一个矩阵以线性存储在global memory中的...
  • langb2014
  • langb2014
  • 2016年05月08日 23:13
  • 1851

关于设计模式感想

学习模式是一个漫长的过程,应该明确的认识到设计模式的意义在哪里,我们学起来才会更加具有针对性,而不是为了设计模式而设计模式。最近看到一段话感觉挺有意思的: 计算机的强大在于它不知道疲倦,他的计算力持...
  • micro_hz
  • micro_hz
  • 2016年05月24日 17:01
  • 584
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:设计模式学习笔记(2)
举报原因:
原因补充:

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