设计模式分类
- 创建者模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。
常用：单例模式、工厂方法模式、抽象工厂模式、建造者模式 。
不常用：原型模式 - 结构型模式：把类或对象结合在一起形成一个更大的结构。
常用：代理模式、桥接模式、装饰者模式、适配器模式。
不常用：组合模式、外观模式、享元模式。 - 行为型模式：类和对象如何交互、划分责任和算法。
常用：观察者模式、模板模式、策略模式、责任链模式、迭代器模式、状态模式。
不常用：访问者模式、备忘录模式、命令模式、解释器模式、中介模式。
各分类中模式的关键点
- 单例模式：某个类只能有一个实例，并且提供一个全局的访问点。
- 简单工厂：一个工厂类根据传入的参数决定创建出那一种产品类的实例。
- 工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。
- 抽象工厂：创建相关或依赖对象的家族，而无须明确指定具体类。
- 建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。
- 原型模式：通过复制现有的实例来创建新的实例。
- 适配器模式：将一个类的方法接口转换成客户希望的另一个接口。
- 组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。
- 装饰模式：动态的给对象添加新的功能。
- 代理模式：为其它对象提供一个代理以便控制这个对象的访问。
- 享元模式：通过共享技术来有效的支持大量细粒度的对象。
- 外观模式：对外提供一个同一的方法，来访问子系统中的一群接口。
- 桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。
- 模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。
- 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。
- 策略模式：定义一系列算法，把它们封装起来，并且使它们可以相互替换。
- 状态模式：允许一个对象在其对象内部状态改变时改变它的行为。
- 观察者模式：对象间的一对多的依赖关系。
- 备忘录模式：在不破坏封装的前提下，保持对象的内部状态。
- 中介者模式：用一个中介对象来封装一系列的对象交互。
- 命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。
- 访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。
- 责任链模式：将请求的发送者和接受者解耦，使得多个对象都有处理这个请求的机会。
- 迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。
设计模式详解
1、单例模式
单例模式，它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。
单例模式的特定：
1、只有一个实例。
2、自我实例化。
3、提供全局访问点。
单例模式的优点主要就是节约系统资源，提高系统效率，同时也能够严格控制客户对它的访问。
也许就是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，同时也没有抽象类，所以扩展起来有一定的困难。
单例模式实现方式
1、懒汉式单例：第一次被引用时，才会将自己实例化。
利用双重锁定解决多线程不安全的问题。
class Singleton
{
private static Singleton instance;
private static readonly object syncRoot = new object();
//构造函数必须是私有，防止在类的外部被实例化
private Singleton()
{
}
public static Singleton GetInstance()
{
//先判断实例是否存在，不存在再加锁处理
if (instance == null)
{
//再同一时刻加了锁的那部分程序只有一个线程可以进入
lock (syncRoot)
{
/*
如果当instance为null并且同时有两个线程调用GetInstance()方法时，
它们将都可以通过第一重instance==null的判断。然后由于lock机制，这两个线程则只有一个进入,
另一个在外排队等候，必须要其中的一个进入并出来后，另一个才能进入。而此时如果没有了第二重的
instance==null的判断，则第一个线程创建了实例，而第二线程还是可以继续在创建新的实例。
*/
if (instance == null)
{
instance = new Singleton();
}
}
}
return instance;
}
}
2、饿汉式单例：静态初始化的方式，是在自己被加载时就将自己实例化。
缺点：需要提前占用系统资源。
public sealed class Singleton
{
private static readonly Singleton instance = new Singleton();
private Singleton() { }
public static Singleton GetInstance()
{
return instance;
}
}
2、工厂方法模式
工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。
同时在工厂方法模式中用户只需要知道生成产品的具体工厂即可，无须关心产品的创建过程。
虽然它很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类。这样就会导致系统的复杂度增加。
结构图
class Program
{
static void Main(string[] args)
{
//工厂方法模式
IFactory factory = new HUAWEIFactory ();
Phone phone= factory.CreatePhone();
phone.Bells();
phone.Call();
phone.Send();
Console.Read();
}
}
//手机对象类
class Phone
{
public void Send()
{
Console.WriteLine("发短信");
}
public void Call()
{
Console.WriteLine("打电话");
}
public void Bells()
{
Console.WriteLine("闹铃");
}
}
//华为（具体产品类）
class HUAWEI: Phone
{ }
//小米（具体产品类）
class XiaoMi: Phone
{ }
//手机工厂（创建手机对象的接口）
interface IFactory
{
Phone CreatePhone();
}
//生产华为手机的工厂(具体产品工厂类)
class HUAWEIFactory : IFactory
{
public Phone CreatePhone()
{
return new HUAWEI();
}
}
//生产小米手机的工厂(具体产品工厂类)
class XiaoMiFactory : IFactory
{
public Phone CreatePhone()
{
return new XiaoMi();
}
}
3、抽象工厂模式
-
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
他允许客户端使用抽象的接口来创建一组相关的产品，而不需要关心实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了，而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更改接口及其下所有子类。
（新增一个产品，就会增加抽象产品、具体产品类以及修改抽象工厂、具体工厂类） -
组成角色
角色 关系 作用 抽象工厂（AbstractFactory） 具体工厂的父类 抽象工厂接口，它里面包含所有的产品创建的抽象方法 具体工厂（ConcreteFactory） 抽象工厂的子类；被外界调用 实现抽象工厂方法，创建产品的实例 抽象产品（AbstractProduct） 具体产品的父类 描述具体产品的公共接口 具体产品（ConcreteProduct） 抽象产品的子类；工厂类创建的目标类 对抽象产品的具体分类实现 -
结构图
-
实现代码
class Program
{
static void Main(string[] args)
{
AbstractFactory factory1 = new ConcreteFactory1();
Client c1 = new Client(factory1);
c1.Run();
AbstractFactory factory2 = new ConcreteFactory2();
Client c2 = new Client(factory2);
c2.Run();
Console.Read();
}
}
//抽象工厂类
abstract class AbstractFactory
{
public abstract AbstractProductA CreateProductA();
public abstract AbstractProductB CreateProductB();
}
//具体工厂类1；实现抽象工厂类方法
class ConcreteFactory1 : AbstractFactory
{
public override AbstractProductA CreateProductA()
{
return new ProductA1();
}
public override AbstractProductB CreateProductB()
{
return new ProductB1();
}
}
//具体工厂类2；实现抽象工厂类方法
class ConcreteFactory2 : AbstractFactory
{
public override AbstractProductA CreateProductA()
{
return new ProductA2();
}
public override AbstractProductB CreateProductB()
{
return new ProductB2();
}
}
//抽象产品A
abstract class AbstractProductA
{
}
//抽象产品B
abstract class AbstractProductB
{
public abstract void Interact(AbstractProductA a);
}
//具体产品A1
class ProductA1 : AbstractProductA
{
}
//具体产品B1
class ProductB1 : AbstractProductB
{
public override void Interact(AbstractProductA a)
{
Console.WriteLine(this.GetType().Name +
" interacts with " + a.GetType().Name);
}
}
//具体产品A2
class ProductA2 : AbstractProductA
{
}
//具体产品B2
class ProductB2 : AbstractProductB
{
public override void Interact(AbstractProductA a)
{
Console.WriteLine(this.GetType().Name +
" interacts with " + a.GetType().Name);
}
}
class Client
{
private AbstractProductA AbstractProductA;
private AbstractProductB AbstractProductB;
// Constructor
public Client(AbstractFactory factory)
{
AbstractProductB = factory.CreateProductB();
AbstractProductA = factory.CreateProductA();
}
public void Run()
{
AbstractProductB.Interact(AbstractProductA);
}
}
864
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
