设计模式之一：简单工厂模式

 

 

 

首先定义一个父类BaseClass：

BaseClass代码 
 1 public class BaseClass
 2     {
 3         /// <summary>
 4         /// 将公用字段设置成属性
 5         /// </summary>
 6          private string _A = "";
 7         public string A
 8         {
 9             get { return _A; }
10             set { _A = value; }
11         }
12 
13         /// <summary>
14         /// 基类构造函数
15         /// </summary>
16          public BaseClass()
17         {
18 
19         }
20 
21         /// <summary>
22         /// 虚方法，由子类重写。
23         /// </summary>
24         /// <returns></returns>
25          public virtual string Function()
26         {
27             return "虚方法，由子类重写。";
28         }
29     }

然后写两个子类SubClass和SubClassT：

SubClass代码 
 1        /// <summary>
 2     /// 子类1
 3     /// </summary>
 4      public class SubClass : BaseClass
 5     {
 6         /// <summary>
 7         /// 重写基类的虚方法
 8         /// </summary>
 9         /// <returns></returns>
10          public override string Function()
11         {
12             base.A = "SubClass设置公共字段的值。";
13 
14             //添加处理逻辑
15  
16             return base.A;
17         }
18 
19         /// <summary>
20         /// 子类自己的方法
21         /// </summary>
22         /// <returns></returns>
23          public int SubFunction()
24         {
25             //自己的处理逻辑
26              return 1;
27         }
28     }

 

SubClassT代码 
 1        /// <summary>
 2     /// 子类2
 3     /// </summary>
 4      public class SubClassT : BaseClass
 5     {
 6         /// <summary>
 7         /// 重写基类的虚方法
 8         /// </summary>
 9         /// <returns></returns>
10          public override string Function()
11         {
12             base.A = "SubClassT设置公共字段的值。";
13 
14             //添加处理逻辑
15  
16             return base.A;
17         }
18 
19         /// <summary>
20         /// 子类自己的方法
21         /// </summary>
22         /// <returns></returns>
23          public int SubFunctionT()
24         {
25             //自己的处理逻辑
26              return 2;
27         }
28     }

 注意父类中有一个虚方法：

1 /// <summary>
2         /// 虚方法，由子类重写。
3         /// </summary>
4         /// <returns></returns>
5         public virtual string Function()
6         {
7             return "虚方法，由子类重写。";
8         }

 子类中对其进行了重写：

重写基类的虚方法代码 
 1         /// <summary>
 2         /// 重写基类的虚方法
 3      /// </summary>
 4         /// <returns></returns>
 5         public override string Function()
 6         {
 7             base.A = "SubClassT设置公共字段的值。";
 8 
 9             //添加处理逻辑
10 
11             return base.A;
12         }

然后写一个工厂类Factory：

Factory代码 
 1 public class Factory
 2     {
 3         public static BaseClass CreateBaseClass(int i)
 4         {
 5             BaseClass bc = null;
 6             switch (i)
 7             {
 8                 case 1:
 9                     bc = new SubClass();
10                     break;
11                 case 2:
12                     bc = new SubClassT();
13                     break;
14             }
15             return bc;
16         }

这里注意，用父类声明，但是用子类实例化，然后返回一个父类，这个就是多态。

工厂模式其实就是多态的一个应用。

 Program如下：

Program代码 
 1 class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             BaseClass bc = new BaseClass();
 6             bc = Factory.CreateBaseClass(1);
 7             Console.WriteLine(bc.Function());
 8             Console.ReadLine();
 9             BaseClass bcT = new BaseClass();
10             bcT = Factory.CreateBaseClass(2);
11             Console.WriteLine(bcT.Function());
12             Console.ReadLine();
13 
14         }
15     }

 

posted on 2010-03-15 13:57  狐狸的尾巴  阅读(206)  评论(0)    收藏  举报

导航