创建型模式

Posted 2020-06-29 超超boy

创建型模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。

1.抽象工厂模式(ABSTRACT FACTORY)

意图

提供一个创建一系列相关或相互依赖对象的接口，而不需指定他们具体的类。

（　 抽象工厂模式可以向客户端（Client指代码模式的使用者，后文类同）提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族（Product Family指位于不同产品等级中，功能相关联的产品的集合）中的产品对象。）

结构

 

using System;

namespace DesignPatterns.Creational
{

　　　 // 测试程序

　　　 class MainApp
　　　 {
　　　　　　　 public static void Main()
　　　　　　　 {
　　　　　　　　　　　 // 抽象工厂1 
　　　　　　　　　　　 AbstractFactory factory1 = new ConcreteFactory1();
　　　　　　　　　　　 Client c1 = new Client(factory1);
　　　　　　　　　　　 c1.Run();

　　　　　　　　　　　 // 抽象工厂2 
　　　　　　　　　　　 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;

　　　　　　　 // 构造，注意通过构造传入抽象工厂
　　　　　　　 public Client(AbstractFactory factory)
　　　　　　　 {
　　　　　　　　　　　 AbstractProductB = factory.CreateProductB();
　　　　　　　　　　　 AbstractProductA = factory.CreateProductA();
　　　　　　　 }

　　　　　　　 public void Run()
　　　　　　　 {
　　　　　　　　　　　 AbstractProductB.Interact(AbstractProductA);
　　　　　　　 }
　　　 }
}

输出结果为：

ProductB1 interacts with ProductA1
ProductB2 interacts with ProductA2

2.工厂方法模式(FACTORY METHOD)

意图

定义一个用于创建对象的接口，让子类决定实例化哪个类。Factory Method 使一个类的实例化延迟到其子类。

结构

 

适用性

在下列情况下可以使用Factory Method 模式：

1. 当一个类不知道它所必须创建的对象的类的时候；
2. 当一个类希望由它的子类来指定它所创建的对象的时候；
3. 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

3.单件模式(Singleton Pattern)    我最喜欢用的一个，简单好用

意图

保证一个类有且只有一个实例,并提供一个访问它的全局访问点。

 

public class Product{

private Product p;

private Product(){

}
public Product getProduct{
  if(p == null)
    p = new Product();
 
 return p;
}

}