單例模式和工廠模式的簡單理解

//什么是單例模式？
//單例模式就是在核心就夠中只包含一個被稱作單例的特殊的類，通過單例模式可以保證系統中一個類只有一個實例，也就是說一個類只有一個對象實例
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();
        }
    }


}

 

抽象化工廠其實和抽象化電腦的思路是一樣的，代碼也是很簡單的，很容易看明白

 

 

 

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