设计模式学习之简单工厂模式

      简单工厂模式，SimpleFactory，是专门定义一个类来决定要实例化哪一个类，而待实例化的类都必须有共同的基类或者继承自同一个接口。

      先看下面得代码:

      定义一个用户接口，该接口包含一个用户登录和打印用户信息的方法

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPatterns.SimpleFactory
 6 {
 7      public   interface  IUser
 8      {
 9          /**/ ///   <summary>
10          /// 用户登录方法
11          ///   </summary>
12          ///   <param name="userName"></param>
13          ///   <param name="userPwd"></param>
14          ///   <returns> 0表示登录成功，1表示用户名错误，2表示密码错误 </returns>
15          int  UserLogin( string  userName, string  userPwd);
16
17          /**/ ///   <summary>
18          ///  打印用户信息
19          ///   </summary>
20          void  PrintUserInfo();
21     }
22 }

     创建一个用户类，该类为一个抽象类,作为所有用户子类的基类.该类继承了IUser接口，但是只实现了用户登录方法，而将用户信息打印方法定义为抽象方法，这样就可以推迟到用户类的子类中去实现.

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPatterns.SimpleFactory
 6 {
 7      public   abstract   class  User : IUser
 8      {
 9          private   string  userName;
10
11          private   string  userPwd;
12
13          public   string  UserName
14          {
15              get   {  return  userName; }
16              set   { userName  =  value; }
17         }
18
19          public   string  UserPwd
20          {
21              get   {  return  userPwd; }
22              set   { userPwd  =  value; }
23         }
24
25          public   int  UserLogin( string  userName, string  userPwd)
26          {
27              if  (userName  ==  UserName)
28              {
29                  if  (userPwd  ==  UserPwd)
30                  {
31                      return   0 ;
32                 }
33                  else
34                  {
35                      return   2 ;
36                 }
37             }
38              else
39              {
40                  return   1 ;
41             }
42         }
43
44          public   abstract   void  PrintUserInfo();
45     }
46 }

创建两个用户类的子类，Teacher和Student,在这两个子类中实现用户信息打印方法.

Teacher:

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPatterns.SimpleFactory
 6 {
 7      public   class  Teacher :User
 8      {
 9          public  Teacher()
10          {
11              this .UserName  =   " teacher " ;
12              this .UserPwd  =   " teacher " ;
13         }
14          public   override   void  PrintUserInfo()
15          {
16             Console.Write( " input your name:/n " );
17              string  userName;
18             userName  =  Console.ReadLine();
19             Console.Write( " /ninput your password:/n " );
20              string  userPwd;
21             userPwd  =  Console.ReadLine();
22             Console.Write( " /n " );
23              switch  (UserLogin(userName, userPwd))
24              {
25                  case   0 :
26                     Console.WriteLine( " I'm a Teacher " );
27                      break ;
28                  case   1 :
29                     Console.WriteLine( " you name isn't exists " );
30                      break ;
31                  case   2 :
32                     Console.WriteLine( " you password is wrong " );
33                      break ;
34             }
35         }
36     }
37 }

Student:

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPatterns.SimpleFactory
 6 {
 7      public   class  Student:User
 8      {
 9          public  Student()
10          {
11              this .UserName  =   " student " ;
12              this .UserPwd  =   " studen " ;
13         }
14
15          public   override   void  PrintUserInfo()
16          {
17             Console.Write( " input your name:/n " );
18              string  userName;
19             userName  =  Console.ReadLine();
20             Console.Write( " /ninput your password:/n " );
21              string  userPwd;
22             userPwd  =  Console.ReadLine();
23             Console.Write( " /n " );
24              switch  (UserLogin(userName, userPwd))
25              {
26                  case   0 :
27                     Console.WriteLine( " I'm a Student " );
28                      break ;
29                  case   1 :
30                     Console.WriteLine( " you name isn't exists " );
31                      break ;
32                  case   2 :
33                     Console.WriteLine( " you password is wrong " );
34                      break ;
35             }
36         }
37     }
38 }

最后即是工厂类，通过传入的userType的值来决定要获取哪一个子类的实例：

 1 using  System;
 2 using  System.Collections.Generic;
 3 using  System.Text;
 4
 5 namespace  DesignPatterns.SimpleFactory
 6 {
 7      public   class  UserFactory
 8      {
 9          public   static  IUser User( string  userType)
10          {
11              switch  (userType)
12              {
13                  case   " Teacher " :
14                      return   new  Teacher();
15                  case   " Student " :
16                      return   new  Student();
17                  default :
18                      return   null ;
19             }
20         }
21     }
22 }

 

最后可以稍微总结一下：

      当出现多个类是派生自同一个基类的时候，我们就可以通过这种设计方式来获取这些类的实例，这样也便于程序的统一管理和维护。

      当出现新的派生类的时候，只需要在工厂类中添加其相对应的实例条件以及代码就行了。

 

这里顺便总结一下接口和抽象类。

接口中不能出现字段，同时只能出现方法签名，不能出现方法体。

抽象类中可以定义抽象方法，当然抽象方法只能定义在抽象类中，抽象类中可以存在其他的方法。

当一个类继承了接口时，就必须要实现接口中的方法，如果出现了类中暂时不能实现接口的方法的情况时，可以将这个类定义成抽象类，然后在抽象类中将该方法定义为抽象方法。当然还有其他的实现方式，这里就不多说了。