1,设计原则
2,创建型模式
创建型模式就是用来创建对象的模式,抽象了实例化的过程。所有的创建型模式都有两个共同点:第一,它们都将系统使用哪些具体类的信息封装起来;第二,它们隐藏了这些类的实例是如何被创建和组织的。创建型模式包括:单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。
private Form2
{
InitializeComponent();
}
private static Form2 SingleForm = null;
public static Form2 InitialForm()
{
if (SingleForm == null)
{
SingleForm = new Form2();
}
return SingleForm;
}
///
/// 自己做饭的情况
/// 没有简单工厂之前,客户想吃什么菜只能自己炒的
///
public class Customer
{
///
/// 烧菜方法
///
///
///
public static Food Cook(string type)
{
Food food = null;
// 客户A说:我想吃西红柿炒蛋怎么办?
// 客户B说:那你就自己烧啊
// 客户A说:好吧,那就自己做吧
if (type.Equals("西红柿炒蛋"))
{
food = new TomatoScrambledEggs();
}
// 我又想吃土豆肉丝, 这个还是得自己做
// 我觉得自己做好累哦,如果能有人帮我做就好了?
else if (type.Equals("土豆肉丝"))
{
food = new ShreddedPorkWithPotatoes();
}
return food;
}
static void Main(string[] args)
{
// 做西红柿炒蛋
Food food1 = Cook("西红柿炒蛋");
food1.Print();
Food food2 = Cook("土豆肉丝");
food2.Print();
Console.Read();
}
}
///
/// 菜抽象类
///
public abstract class Food
{
// 输出点了什么、菜
public abstract void Print();
}
///
/// 西红柿炒鸡蛋这道菜
///
public class TomatoScrambledEggs : Food
{
public override void Print()
{
Console.WriteLine("一份西红柿炒蛋!");
}
}
自己做饭,如果我们想吃别的菜时,此时就需要去买这种菜和洗菜这些繁琐的操作,有了餐馆(也就是简单工厂)之后,我们就可以把这些操作交给餐馆去做,此时消费者(也就是我们)对菜(也就是具体对象)的依赖关系从直接变成的间接的,这样就是实现了面向对象的另一个原则——降低对象之间的耦合度,下面就具体看看有了餐馆之后的实现代码(即简单工厂的实现):
///
/// 顾客充当客户端,负责调用简单工厂来生产对象
/// 即客户点菜,厨师(相当于简单工厂)负责烧菜(生产的对象)
///
class Customer
{
static void Main(string[] args)
{
// 客户想点一个西红柿炒蛋
Food food1 = FoodSimpleFactory.CreateFood("西红柿炒蛋");
food1.Print();
// 客户想点一个土豆肉丝
Food food2 = FoodSimpleFactory.CreateFood("土豆肉丝");
food2.Print();
Console.Read();
}
}
///
/// 菜抽象类
///
public abstract class Food
{
// 输出点了什么菜
public abstract void Print();
}
///
/// 西红柿炒鸡蛋这道菜
///
public class TomatoScrambledEggs : Food
{
public override void Print()
{
Console.WriteLine("一份西红柿炒蛋!");
}
}
///
/// 简单工厂类, 负责 炒菜
///
public class FoodSimpleFactory
{
public static Food CreateFood(string type)
{
Food food = null;
if (type.Equals("土豆肉丝"))
{
food= new ShreddedPorkWithPotatoes();
}
else if (type.Equals("西红柿炒蛋"))
{
food= new TomatoScrambledEggs();
}
return food;
}
}
//总工厂负责提供所有的产品对象
interface IInLettFactory
{
Coder CreateInLettCoder();
}
实现工厂中的方法
//分工厂1提供c#程序员
class CSharpFactory : IInLettFactory
{
public Coder CreateInLettCoder()
{
return new CSharp();
}
}
程序员对象都要有自己的介绍方式
public interface Coder
{
void Information();
}
每种程序员都实现自己的介绍方式
class CSharp : Coder
{
public void Information()
{
Console.WriteLine("我是C#程序员");
}
}
class Python : Coder
{
public void Information()
{
Console.WriteLine(" I am a Python coder");
}
}
客户最终只需要向工厂负责要人就行
static void Main(string[] args)
{
while (true)
{
Console.WriteLine("请选择你需要的程序员类型:1.C#,2.Python");
string str1 = Console.ReadLine();
IInLettFactory factory = null;
if (str1 == "1")
{
factory = new CSharpFactory();
}
else if (str1 == "2")
{
factory = new PythonFactory();
}
Coder coder = factory.CreateInLettCoder();
coder.Information();
}
}
}
while (true)
{
Console.WriteLine("请你选择你需要的地点程序员:1.西安,2.北京");
string str1 = Console.ReadLine();
Console.WriteLine("请你选择你需要的技术:1.Web,2.C#");
string str2 = Console.ReadLine();
InLettFactory factory = null;
if (str1 == "1")
{
factory = new XiAnInLett();
}
else if (str1 == "2")
{
factory = new BeiJingInLett();
}
Web web = null;
CSharp csharp = null;
if (str2 == "1")
{
web = factory.CreateWeb();
}
else if (str2 == "2")
{
csharp = factory.CreateCSharp();
}
if (web != null)
{
web.WebPerson();
}
if (csharp != null)
{
csharp.CSharpPerson();
}
}
抽象工厂
///
/// 总集团公司
///
public abstract class InLettFactory
{
public abstract CSharp CreateCSharp();
public abstract Web CreateWeb();
}
实现工厂
//西安的子公司
class XiAnInLett : InLettFactory
{
public override CSharp CreateCSharp()
{
return new XiAnCSharp();
}
public override Web CreateWeb()
{
return new XiAnWeb();
}
}
//北京的子公司
class BeiJingInLett : InLettFactory
{
public override CSharp CreateCSharp()
{
return new BeiJingCSharp();
}
public override Web CreateWeb()
{
return new BeiJingWeb();
}
}
C#抽象对象
//提供一个CSharp程序员
public abstract class CSharp
{
public abstract void CSharpPerson();
}
实现C#抽象对象
//提供一个西安的CSharp程序员
class XiAnCSharp : CSharp
{
public override void CSharpPerson()
{
Console.WriteLine("我是西安的C#程序员");
}
}
//提供一个北京的CSharp程序员
class BeiJingCSharp : CSharp
{
public override void CSharpPerson()
{
Console.WriteLine("我是北京的C#程序员");
}
}
Web抽象对象
//提供一个Web程序员
public abstract class Web
{
public abstract void WebPerson();
}
实现Web抽象对象
//提供一个西安的Web程序员
class XiAnWeb : Web
{
public override void WebPerson()
{
Console.WriteLine("我是西安的WEB工程师");
}
}
//提供一个北京的Web程序员
class BeiJingWeb : Web
{
public override void WebPerson()
{
Console.WriteLine("我是北京的WEB程序员");
}
}
抽象工厂的分析
抽象工厂模式将具体产品的创建延迟到具体工厂的子类中,这样将对象的创建封装起来,可以减少客户端与具体产品类之间的依赖,从而使系统耦合度低,这样更有利于后期的维护和扩展,这真是抽象工厂模式的优点所在,然后抽象模式同时也存在不足的地方。下面就具体看下抽象工厂的缺点(缺点其实在前面的介绍中以已经涉及了):
抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了“开发——封闭”原则。
知道了抽象工厂的优缺点之后,也就能很好地把握什么情况下考虑使用抽象工厂模式了,下面就具体看看使用抽象工厂模式的系统应该符合那几个前提:
a, 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达,这点也是所有工厂模式应用的前提。
b,这个系统有多个系列产品,而系统中只消费其中某一系列产品
c, 系统要求提供一个产品类的库,所有产品以同样的接口出现,客户端不需要依赖具体实现。
行为型模式包括11种模式:模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、状态模式、策略模式、责任链模式、访问者模式、解释器模式和备忘录模式。