设计模式,简单工厂模式,工厂方法,单例模式,中介者模式

设计模式

设计模式是在特定环境下人们解决某类重复出现问题的一套成功或有效的解决方案
(在一定环境下，用固定套路解决问题)

设计模式思维导图
设计模式基础
设计模式分类

创建型(Creational)模式： 如何创建对象；
结构型(Structural )模式： 如何实现类或对象的组合；
行为型(Behavioral)模式： 类或对象怎样交互以及怎样分配职责。




设计模式目前种类： GoF 的 23 种 + “简单工厂模式” = 24 种。

设计模式的基础是多态

设计原则目的:高内聚,低耦合

1. 单一职责原则: 类的职责单一,对外只提供一种功能,而引起类变化的原因都应该只有一个.
2. 开闭原则: 类的改动是通过增加代码进行的,而不是修改源代码.
3. 里氏代换原则: 任何抽象类出现的地方都可以用他的实现类进行替换,实际就是虚拟机制,语言级别实现面向对象功能,(多态)
4. 依赖倒转原则: 依赖于抽象(接口),不要依赖具体的实现(类),也就是针对接口编程.
5. 迪米特法则:多组合,少继承.
6. 合成复用: 多组合

设计模式的核心是: 高内聚 低耦合 代码编写多 但是方便维护
1. 单例模式: 懒汉和饿汉(直接就new 线程相对安全) 但是在unity不涉及多线程, 所以都行 一般人们写的懒汉多一点
1. 普通class
2. 里面一个私有的 静态属性 对象
3. 私有构造函数
4. 共有 静态 对象返回值类型的 方法(GetInstance/GetInit)
5. GetInstance 进行new
2. 简单工厂:
1. 抽象父类
2. 子类继承并重写父类
3. 工厂接受参数 并new对应的子类 返回类型是抽象父类
4. 工厂方法里面就是switch结构
6. 违背了开闭原则
3. 工厂方法:
1. 定义抽象工厂(返回值是抽象父类)和抽象父类
2. 一个物体就佩戴一个工厂
4. 中介者模式
1. MVC 卖家 买家 淘宝

简单工厂模式

优点:
实现了对象创建和使用的分离。
不需要记住具体类名，记住参数即可，减少使用者记忆量。
缺点:
对工厂类职责过重，一旦不能工作，系统受到影响。
增加系统中类的个数，复杂度和理解度增加。
违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。

简单工厂: 一个抽象父类 N个实现类 还有一个工厂 生产手机
参数不同 结果不同 父类返回 switch 简单工厂(变形)
抽象类的用途是提供一个可供多个派生类共享的通用基类定义。

以生产手机为例

定义一个抽象类抽象方法

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

namespace 简单工厂模式
{
     public abstract class GetPhotoName//抽象类
    {
        public string PhotoName;
        public abstract void show();//抽象方法
    }
}

定义工厂

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

namespace 简单工厂模式
{
    public class FSK
    {
        //静态方法,返回类型GetPhotoName
        public static GetPhotoName CreatPhoneByName(string PhoneName)
        {
            GetPhotoName retunValue;
            switch (PhoneName)//判断
            {
                case "mi":
                    retunValue = new Apple();//调用子类
                    retunValue.PhotoName = "MIMIX3";//调用父类属性并赋值
                    return retunValue;
                case "apple":
                    retunValue = new MiMix3();
                    retunValue.PhotoName = "AppleXS";
                    return retunValue;



            }
            return null;
        }
    }
}

定义实现类

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

namespace 简单工厂模式
{
    class Apple:GetPhotoName//实现类

    {
        public override void show()
        {
            Console.WriteLine("我是图片{0}",PhotoName);
        }
    }
}

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

namespace 简单工厂模式
{
    class MiMix3:GetPhotoName//继承自抽象类
    {
        public override void show()//实现类
        {
            Console.WriteLine("我是图片{0}",PhotoName);
        }
    }
}

定义主类

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

namespace 简单工厂模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //实例化creatPhone=FSK.CreatPhoneByName方法的返回值.
            GetPhotoName creatPhone = FSK.CreatPhoneByName("apple");
            creatPhone.show();//调用show方法
            Console.ReadLine();
        }
    }
}

工厂方法

工厂方法是一个物品对应一个工厂! 实现自给自足
主类

namespace 工厂方法
{
    internal class Program
    {
        // 一个物体对应一个工厂
        // apple --> app工厂
        //mi ---> 小米工厂
        public static void Main(string[] args)
        {
            HuaWeiFac huaWeiFac = new HuaWeiFac();//实例化工厂
            AbsPhone absPhone= huaWeiFac.CreatePhone();//获得实现类
            absPhone.Show();//调用实现类方法
            System.Console.ReadKey();


        }
    }
}

namespace 工厂方法
{
    public abstract class AbsFac//定义抽象工厂
    {

        public abstract AbsPhone CreatePhone();//抽象方法
    }
}

namespace 工厂方法
{
    public abstract class AbsPhone//抽象手机类
    {
        public  abstract void Show();//抽象方法
    }
}

namespace 工厂方法
{
    public class HuaWeiFac: AbsFac//实现类,继承自抽象工厂
    
    {
        public override AbsPhone CreatePhone()
        {
            
            return  new HuaWei();
        }
        
        
    }
}

using  System;

namespace 工厂方法
{
    public class HuaWei: AbsPhone
    
    {
        public override void Show()
        {
            Console.WriteLine("我是华为手机");
        }
    }
}

单例模式

单例模式之懒汉恶汉
引:单例模式的八种写法
单例模式:
单唯一 单个
例 实例 对象

只有一份!

单例模式有看懒汉和恶汉

要求: 懒汉线程不安全 最好使用恶汉
能够熟练写出来 单例模式的懒汉和恶汉
指导unity里面的单利模式的写法
有区别 但是在unity里面都行 因为不涉及多线程!!!

using System;

namespace 单例模式
{

//13245
    class Singleton
    {
        private static Singleton _singleton;

        private Singleton()
        {
            //初始化
        }
//5
        public static Singleton GetInstance()
        {
            if (null == _singleton)
            {
                _singleton = new Singleton();
                Console.WriteLine("呵呵");
            }

            return _singleton;
        }

    }
    
    // 定义静态私有对象
    // 构造函数私有化
    //定义一个静态的 返回值为该类型的方法 一般以Getinstance/getInit为方法名称
    
    internal class Program
    {
        public static void Main(string[] args)
        {
            for (int i = 0; i < 100; i++)
            {
                Singleton.GetInstance();
            }
        }
    }
}

中介者模式

中介者模式

单例模式二

单例模式分为两种一种是继承mono的一种是不继承mono的
不继承mono的 常用于数据的管理
不继承mono:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


namespace Sington
{
    public class SingleTonTest /*: MonoBehaviour */
    {
        //不继承mono的单利  常用于数据的管理类

        public string name = "VR-1";

        //存储  当前类唯一实例的对象
        private static SingleTonTest instance;

        //需要一个位置对当前对象进行实例化 而且是唯一的实例化
        //public static SingleTonTest GetInstance()
        //{
        //    if (instance == null)
        //    {
        //        //当前类没有实例化
        //        instance = new SingleTonTest();
        //    }

        //    return instance;
        //}

        //属性访问器形式
        public static SingleTonTest Instance
        {
            get {
                if (instance == null)
                {
                    instance = new SingleTonTest();
                }
                return instance;
            }
        }

        public void Print()
        {
            System.Console.WriteLine("打印方法");
        }
        /// <summary>
        /// 当前需要单例的类的构造私有化
        /// </summary>
        private SingleTonTest()
        {

        }
    }
    public class Test
    {
        public void Main()
        {
            //1.方法形式获取单例
            //SingleTonTest.GetInstance();
            //2.属性访问器形式获取单例
            SingleTonTest a = SingleTonTest.Instance;
            string name =  a.name;
            a.Print();

        }

        
    }
}

继承mono的

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SingleTonMono : MonoBehaviour {
    //继承mono的单利
    //在游戏中  负责统筹管理的类  需要调到mono中的方法  Load<Sprite>
    public int playerGold=100;
    private static SingleTonMono instance;   //静态的可以用类去调用
    //比如在别脚本中用 singleton.ins  来调用下面写的方法Instance

    public static SingleTonMono Instance
    {
        get {
            return instance;
        }
    }

    void Awake()
    {
        instance = this;
    }

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
		
	}
}