设计模式：单例和简单工厂

单例设计模式：只实例化一个类的对象！

 1 public class Person
 2     {
 3        //1：首先定义一个静态变量
 4        //2：将该类的构造函数私有化
 5        //3：定义一个静态方法，将该类对象赋给这个静态变量
 6        //4：在其他类中使用类.方法名来调用该对象
 7        public static Person p1;
 8        private Person()
 9        {
10        }
11        public static Person Get()
12        {
13            if (p1 == null)
14            {
15                p1 = new Person();
16            }
17            return p1;
18        }
19     }
20 class Program
21     {
22         static void Main(string[] args)
23         {
24             Person p1 = Person.Get();
25         }
26     }

设计模式之二：简单工厂

定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。

1：定义一个父类

 public abstract class Person
    {

       public abstract void Say();
       public Person()
       {
       }
    }

2：定义两个子类

 1     class Father:Person
 2     {
 3         public override void Say()
 4         {
 5             Console.WriteLine("我是爸爸");
 6         }
 7     }
 8  class Son:Person
 9     {
10         public override void Say()
11         {
12             Console.WriteLine("我是儿子");
13         }
14     }

3：定义简单工厂类

 1  public abstract class Tool
 2     {
 3        public static Person st(string type)
 4        {
 5           Person p1=null;
 6            switch (type)
 7            {
 8                case"爸爸":
 9                    p1=new Father();
10                    break;
11                case "儿子":
12                    p1 = new Son();
13                    break;
14
15
16
17            }
18            return p1;
19
20        }
21     }