单例模式和工厂模式的简单理解

//什么是单例模式？//单例模式就是在核心就够中只包含一个被称作单例的特殊的类，通过单例模式可以保证系统中一个类只有一个实例，也就是说一个类只有一个对象实例using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class danli
    {
        static void Main(string[] args)
        {
            sing Instance = sing.GetInstance();
            sing Instance2 = sing.GetInstance();
            if (Instance == Instance2)
                Console.WriteLine("xiangtong");//判断实例是否建立成功
            Console.ReadKey();
        }
    }
    //建立一个设置单例的类
    class sing
    {
        private static sing _Instance = null;//定义一个单例的实例
        public static sing GetInstance()//获取一个对象
        {
            if (_Instance == null)
                _Instance = new sing();
            return _Instance;
        }
    }

}

从图中可以看出实例化出来的Instance和Instance2实际上是一样的，也就是说在运行GetStance方法之后，因为先创建了Instance，所以在创建Instance2时不满足if条件依旧返回Instance；

我们可以在用一个简单的例子来说明一下单例模式的工作模式：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class danli
    {
        static void Main(string[] args)
        {
            sing Instance = sing.GetInstance();
            sing Instance2 = sing.GetInstance();

Person.Change();
            Console.WriteLine(Instance2.i);
            Console.ReadKey();
        }
    }

    public class Person
    {
        public static void Change()
        {
            sing Instance = sing.GetInstance();
            Instance.i = 10;
        }
    }

    //建立一个单例特殊类
    class sing
    {
        public int i = 1;
        //private sing() { }
        private static sing _Instance = null;//定义一个单例的实例
        public static sing GetInstance()//获取一个对象
        {
            if (_Instance == null)
                _Instance = new sing();
            return _Instance;
        }
    }

}

最初的时候调用特殊类并且设置i=1，对象实例化后Instance.i=1，经过Change方法之后设置Instance.i=10；

输出Instance2.i结果是10.

若非单例情况下，Instance.i的值应该是不确定的，从这也就可以说明，单例模式就是创建一个特殊的类，这个类只能有一个实例的对象，实际上Instance2=return Instance。

————————————————————————————————————————————————————————————————————————————我是快乐的分割线~~~~~~~

下面来说一下什么是工厂模式：

【偷个懒复制一下】：工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

老规矩用代码来显示：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    //电脑抽象类
    public abstract class Computer
    {
        public abstract void print();
    }

    public  class Lenovo:Computer
    {
        public override void print()
        {
            Console.WriteLine("This is a Lenovo Computer");
        }
    }

    public class AUSU:Computer
    {
        public override void print()
        {
            Console.WriteLine("This is a AUSU Computer");
        }
    }
    //选择实例化对象的类型
    public class Make
    {
        public static Computer Create(string Type)
        {
            Computer com = null;
            if(Type=="联想")
            {
                com = new Lenovo();
            }
            else if(Type=="华硕")
            {
                com = new AUSU();
            }
            return com;
        }
    }

    class danli
    {
        static void Main(string[] args)
        {
            //运用工厂模式实例化对象
            Computer com = Make.Create("联想");
            com.print();
            Console.ReadKey();
        }
    }

}

这个代码是先定义了一个电脑的抽象类，然后通过选择所要实例化出来的电脑的类型来制作方法Create；这个制作方法就相当与一个工厂，这个工厂只能加工联想和华硕的电脑，当然我们也可以“扩大”工厂的生产类型，从而生产其他类型的电脑，但是这种方法显然有一个弊端，就是当这个工厂坏掉之后，所有在这个工厂里加工的电脑都是不能在加工了，然后解决这个问题呢？

这就需要来抽象化工厂了

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    //电脑抽象类
    public abstract class Computer
    {
        public abstract void print();
    }

    public  class Lenovo:Computer
    {
        public override void print()
        {
            Console.WriteLine("This is a Lenovo Computer");
        }
    }

    public class AUSU:Computer
    {
        public override void print()
        {
            Console.WriteLine("This is a AUSU Computer");
        }
    }
    //工厂抽象
    public abstract class Creater
    {
        public abstract Computer CreateComputer();
    }
    //联想工厂抽象
    public class CreaterLenovo :Creater
    {
        public override Computer CreateComputer()
        {
            return new Lenovo();
        }
    }
    //华硕工厂抽象
    public class CreaterAUSU:Creater
    {
        public override Computer CreateComputer()
        {
            return new AUSU();
        }
    }

    //public class Make
    //{
    //    public static Computer Create(string Type)
    //    {
    //        Computer com = null;
    //        if(Type=="联想")
    //        {
    //            com = new Lenovo();
    //        }
    //        else if(Type=="华硕")
    //        {
    //            com = new AUSU();
    //        }
    //        return com;
    //    }
    //}

    class danli
    {
        static void Main(string[] args)
        {
            //利用工厂模式实例化对象
            Creater cr = new CreaterAUSU();//实例化华硕工厂
            Computer com = cr.CreateComputer();//在联想工厂里面实例化华硕电脑这个实例
            com.print();
            Console.ReadKey();
        }
    }

}

抽象化工厂其实和抽象化电脑的思路是一样的，代码也是很简单的，很容易看明白

我是一只小菜鸡啊小菜鸡    ~~~~~