一:创建型设计模式整体总结图
二:具体设计模式
1,工厂方法模型
1)定义:
定义一个用于创建对象的接口,让子类去决定实例化哪个类
2)优点:
克服了简单工厂违背开放封闭原则的缺点,又保持了对象创建过程的优点
3)类图
2,抽象工厂
1)定义:
提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类
2)优点:
让具体的创建实例过程与客户端分离,客户端是通过他们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户端代码中
3)类图
3,单例模式
1)定义:
保证一个类仅有一个实例,并提供一个访问它的全局访问点
4,原型模式
1)定义:
用原型实例指定创建对象的种类,并且通过拷贝这些原型实例创建新的对象
2)类图
5,建造者模式
1)定义:
将一个复杂对象的构建与他的表示分离,使得同样的构建过程可以创建不同的表示
2)类图
三:代码实现
快要过年啦,很多同学都在网上购买火车票回家,有时候还是买不上票。现在就以火车票为例,运用设计模式的思想,去练习巩固设计模式。
1,简单工厂
假如,规定好乘车区间,学生票票价是100,成人票价为200,要求简单显示购买火车票类型极其票价
类图:
代码实现:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 火车票
{
class Program
{
static void Main(string[] args)
{
Ticket ticket = FactoryTicket.CreateTicket("学生票"); //传入参数“学生票”,让火车票工厂去实例化对象的学生票类
ticket.GetTicket();
Ticket ticket2 = FactoryTicket.CreateTicket("成人票");
ticket2.GetTicket();
Console.Read();
}
}
//火车票工厂
class FactoryTicket
{
public static Ticket CreateTicket(string type)//根据提供的类型,去实例化具体的火车票对象
{
Ticket ticket = null;
switch (type)
{
case"学生票":
ticket = new StudentTicket(); //如果是学生票,则返回学生票子类
break;
case"成人票":
ticket = new GeneralTicket(); //如果是成人票,则返回成人票子类
break;
}
return ticket;
}
}
//火车票基类
class Ticket
{
private string money;
public string Money
{
get { return money; }
set { money = value; }
}
public virtual void GetTicket() //打印获得火车票的类型和价钱
{ }
}
//学生票
class StudentTicket:Ticket
{
private string money = "100";
public override void GetTicket()
{
Console .WriteLine ("您选择的是 学生票,票价为:{0}元",money );
}
}
//成人票
class GeneralTicket:Ticket
{
private string money = "200";
public override void GetTicket()
{
Console.WriteLine("您选择的是 成人票,票价为:{0}元",money );
}
}
}
运行结果:
2,抽象工厂
假设购买火车票的人只有姓名一个属性,要求,显示购买火车票或成人票。
类图
类图:
代码实现:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 火车票
{
class Program
{
static void Main(string[] args)
{
People li = new People("李");//实例化购买火车票的人li
IFactoryTicket factory = new StuTicketFactory();
ITicket iticket = factory.CreateTicket();
iticket.GetTicket();
Console.Read();
}
}
//火车票工厂接口,定义一个创建火车票的抽象工厂接口
interface IFactoryTicket
{
ITicket CreateTicket();
}
//实现IFactoryTicket接口,实例化StudentTicket
class StuTicketFactory:IFactoryTicket
{
public ITicket CreateTicket()
{
return new StudentTicket();
}
}
//实现IFactoryTicket接口,实例化GeneralTicket
class GenTicketFactory : IFactoryTicket
{
public ITicket CreateTicket()
{
return new GeneralTicket();
}
}
//火车票基类
interface ITicket
{
void GetTicket(); //打印获得火车票的类型和价钱
}
//学生票
class StudentTicket:ITicket
{
public void GetTicket()
{
Console .WriteLine ("您选择的是 学生票 ");
}
}
//成人票
class GeneralTicket:ITicket
{
public void GetTicket()
{
Console.WriteLine("您选择的是 成人票 ");
}
}
//定义购买火车票的人类
class People
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public People() { }
public People(string name)
{
this.name = name;
}
}
}
运行结果:
3,原型模式
假设,车票只显示购票者的姓名,票的类型(学生票,成人票),分别打印学生票和成人票,这里仅一张学生票,一张成人票(打印的票数多了,原型模式就方便啦)。
采用原型模式,通过拷贝原型创建不同的火车票。
类图:
代码实现:
namespace 火车票
{
class Program
{
static void Main(string[] args)
{
Ticket ticket1 = new Ticket("li");
ticket1.Type("学生票");
ticket1.GetTicket();
Ticket ticket2 = new Ticket("lisz");
ticket2.Type("成人票");
ticket2.GetTicket();
Console.Read();
}
}
class Ticket : ICloneable
{
private string username;
private string type;
public Ticket(string username)
{
this.username = username;
}
public void Type(string type)
{
this.type = type;
}
public void GetTicket()
{
Console.WriteLine("{0}:您购买的是{1}", username, type);
}
public object Clone()
{
return (object)this.MemberwiseClone();
}
}
}
运行结果:
4,单例模式
一个用户只能购买一张车次的票,假如时间段确定,车次确定。
双重锁定,代码实现:
namespace 火车票
{
class Program
{
static void Main(string[] args)
{
Ticket ticket = Ticket.GetTicket();
Ticket ticket1 = Ticket.GetTicket();
if (ticket == ticket1)
{
Console.WriteLine("两个对象是相同的实例");
}
Console.Read();
}
}
class Ticket
{
private static Ticket instance;
private static readonly object syncRoot = new object();//程序运行时,创建一个静态只读的进程辅助对象
private string username;
public Ticket() { }
public static Ticket GetTicket()
{
if (instance == null)//先判断实例是否存在,不存在再进行加锁处理
{
lock (syncRoot)
{
if (instance == null)
{
instance = new Ticket();
}
}
}
return instance;
}
}
}
四:总结适用性
1,工厂方法模型
工厂模式用来生产同一等级结构中的固定产品
当类不知道他所创建的对象的类
2,抽象工厂模型
抽象工厂模式用来生产不同产品族的全部产品
当要强调一系列相关的产品对象设计,以便进行联合使用
当提供一个产品类库,而只是想显示他们的接口而不是实现时
3,单例模式
当类只能由一个实例,而且客户可以从一个众所周知的访问点访问他
当唯一的实例是通过子类实例化的,而且无需更改代码就能实现扩展
4,原型模式
当要实例化的类是在运行时指定
当一个类的实例只能由几个不同状态组合中的一种
5,建造者模式
当创建复杂对象的算法独立于该对象的组成部分