一.设计遵循法则
设计模式是在特定环境下人们解决某类重复出现问题的一套成功或有效的解决方案.
设计模式目前种类： GoF 的 23 种 + “简单工厂模式” = 24 种。
设计模式的作用:高内聚低耦合
软件开发的原则:
迪米特: 多组合 少继承
里式替换: 多态
合成复用: 多组合,少继承
依赖倒转:
单一:
开闭:
二.简单工厂
一个抽象父类 N个实现类 还有一个工厂
参数不同 结果不同 父类返回 switch 简单工厂(变形
代码实例:
1 using System;
2 namespace day24
3 {
4 public abstract class Phone//父类
5 {
6 public string PhoneName;
7 public abstract void Show();
8 }
9 public class FSK//工厂
10 {
11 public static Phone CreatePhoneByName(string phoneName)
12 {
13 Phone returnValue;
14 switch (phoneName)
15 {
16 case "Apple":
17 returnValue = new ApplexRS();
18 returnValue.PhoneName = "AppleXRS";
19 return returnValue;
20 case "Mi":
21 returnValue = new MIMix3();
22 returnValue.PhoneName = "MIMix3";
23 return returnValue;
24 case "HuaWei":
25 returnValue = new HuaWeics();
26 returnValue.PhoneName = "HuaWeics";
27 return returnValue;
28 case "MeiTu":
29 returnValue = new MeiTu();
30 returnValue.PhoneName = "MeiTu";
31 return returnValue;
32 }
33 return null;
34 }
35 }
36 public class HuaWeics : Phone//子类01
37 {
38 public override void Show()
39 {
40 Console.WriteLine("我是{0}手机 我在展示最新功能!", PhoneName);
41 }
42 }
43 public class MIMix3 : Phone//子类02
44 {
45 public override void Show()
46 {
47 Console.WriteLine("我是{0}手机 我在展示最新功能!", PhoneName);
48 }
49 }
50 public class MeiTu : Phone//子类03
51 {
52 public override void Show()
53 {
54 Console.WriteLine("我是{0}手机 我在展示最新功能!", PhoneName);
55 }
56 }
57 public class ApplexRS : Phone//子类04
58 {
59 public override void Show()
60 {
61 Console.WriteLine("我是{0}手机 我在展示最新功能!", PhoneName);
62 }
63 }
64 internal class Program//实现
65 {
66 public static void Main(string[] args)
67 {
68 //传递参数给富士康, 富士康接受参数返回结果
69 Phone createPhone = FSK.CreatePhoneByName("MeiTu");
70 createPhone.Show();
71 }
72 }
73 }
优缺点:
优点: 实现了对象创建和使用的分离。
不需要记住具体类名，记住参数即可，减少使用者记忆量。
缺点: 对工厂类职责过重，一旦不能工作，系统受到影响。
增加系统中类的个数，复杂度和理解度增加。
违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。
三.工厂方法
一个物品对应一个工厂! 实现自给自足
代码实例:
1 using System;
2 namespace 工厂方法
3 {
4 public abstract class AbsPhone//手机父类
5 {
6 public abstract void Show();
7 }
8 public abstract class AbsFac//工厂父类
9 {
10 public abstract AbsPhone CreatePhone();
11 }
12 public class HuaWei : AbsPhone//手机子类01
13 {
14 public override void Show()
15 {
16 Console.WriteLine("我是华为手机");
17 }
18 }
19 public class HuaWeiFac : AbsFac//工厂子类01
20 {
21 public override AbsPhone CreatePhone()
22 {
23 return new HuaWei();
24 }
25 }
26 internal class Program//主函数
27 {
28 // 一个物体对应一个工厂
29 public static void Main(string[] args)
30 {
31 Console.Read();
32 }
33 }
34 }
优缺点:
优点: 不需要记住具体类名，甚至连具体参数都不用记忆。
实现了对象创建和使用的分离。
系统的可扩展性也就变得非常好，无需修改接口和原类
缺点: 增加系统中类的个数，复杂度和理解度增加。
增加了系统的抽象性和理解难度。
四.单例模式
单---->唯一 单个
例----> 实例 对象
步骤:
1).定义静态私有对象
2).构造函数私有化
3).定义一个静态的 返回值为该类型的方法 一般以Getinstance/getInit为方法名称
单例模式有懒汉和恶汉,懒汉线程不安全 最好使用饿汉.
代码实例
懒汉模式:后实例化
1 using System;
2 namespace 单例模式
3 {
4 // 定义静态私有对象
5 // 构造函数私有化
6 //定义一个静态的 返回值为该类型的方法 一般以Getinstance/getInit为方法名称
7 class Singleton
8 {
9 private static Singleton _singleton;//第一步
10 private Singleton()//第二步
11 {
12 //初始化
13 }
14 public static Singleton GetInstance()//第三步
15 {
16 if (null == _singleton)
17 {
18 _singleton = new Singleton();
19 Console.WriteLine("呵呵");
20 }
21 return _singleton;
22 }
23 }
24 internal class Program
25 {
26 public static void Main(string[] args)
27 {
28 for (int i = 0; i < 100; i++)
29 {
30 Singleton.GetInstance();
31 }
32 }
33 }
34 }
饿汉模式:先实例化
1 public class HungrySingle
2 {
3
4 private static HungrySingle sInstance = new HungrySingle();//第一步
5
6 private HungrySingle() //第二步
7 {
8
9 }
10
11 public static HungrySingle getInstance() //第三步
12 {
13 return sInstance;
14 }
15
16 }
unity里面的单利模式的写法:
1 public sealed class SingletonMoBehaviour: MonoBehaviour
2 {
3 private static volatile SingletonBehaviour instance;
4 private static object syncRoot = new Object();
5 public static SingletonBehaviour Instance
6 {
7 get
8 {
9 if (instance == null)
10 {
11 lock (syncRoot)
12 {
13 if (instance == null) {
14 SingletonBehaviour[] instances = FindObjectsOfType<SingletonBehaviour>();
15 if (instances != null){
16 for (var i = 0; i < instances.Length; i++) {
17 Destroy(instances[i].gameObject);
18 }
19 }
20 GameObject go = new GameObject("_SingletonBehaviour");
21 instance = go.AddComponent<SingletonBehaviour>();
22 DontDestroyOnLoad(go);
23 }
24 }
25 }
26 return instance;
27 }
28 }
29 }
懒汉和恶汉有区别,但是在unity里面都行,因为不涉及多线程!!!
拓展知识:
线程: 是CPU直接切换的 并行
进程: 是分配资源的单位