自己的一些理解,方便以后回顾。。。
五、建造者模式
建造者模式:将一个复杂对象的创建与它的表示分离,使得同样的构建过程可以创建不同的表示
想到一个很有意思的例子,山寨公司根据客户需求定制手机
class Program
{
static void Main(string[] args)
{
//老大说了要开发两部新款手机,一款具有苹果的外观,小米的内涵,另一款具有苹果、vivo、华为的特点综合
//创建指挥者
CheapCopyDirector director = new CheapCopyDirector();
//创建一个负责生产第一个产品的创建者b1
RealBudilder1 b1 = new RealBudilder1();
//创建一个负责生产第二个产品的创建者b2
RealBudilder2 b2 = new RealBudilder2();
//指挥者指挥工作
director.DirectorJob(b1);
director.DirectorJob(b2);
director.GetPhone(b1);
director.GetPhone(b2);
Console.ReadKey();
}
}
public class CheapCopyDirector
{
public void DirectorJob(Builder builder)
{
builder.SetCPU();
builder.SetDisplayer();
builder.SetKernel();
}
public void GetPhone(Builder builder)
{
builder.GetPhone().Show();
}
}
public abstract class Builder
{
public abstract void SetCPU();
public abstract void SetKernel();
public abstract void SetDisplayer();
public abstract Pruduct GetPhone();
}
public class RealBudilder1:Builder
{
private Pruduct phone = new Pruduct();
public override void SetCPU()
{
phone.Add("小米cpu");
}
public override void SetKernel()
{
phone.Add("小米内核");
}
public override void SetDisplayer()
{
phone.Add("苹果显示器");
}
public override Pruduct GetPhone()
{
return phone;
}
}
public class RealBudilder2 : Builder
{
private Pruduct phone = new Pruduct();
public override void SetCPU()
{
phone.Add("小米cpu");
}
public override void SetKernel()
{
phone.Add("华为内核");
}
public override void SetDisplayer()
{
phone.Add("苹果显示器");
}
public override Pruduct GetPhone()
{
return phone;
}
}
public class Pruduct
{
List<string> compents = new List<string>();
public void Add(string str)
{
compents.Add(str);
}
public void Show()
{
for (int i = 0; i < compents.Count; i++)
{
Console.WriteLine(compents[i] + "已经组装完毕");
}
Console.WriteLine("此手机已经组装完毕");
}
}
每一次生产新的特定的产品 都要创建一个新的RealBuilder 类。。。
六、原型模式
当我们需要多个相同类实例的时候,通过new运算符创建相同的类实例需要消耗大量的
内存空间于是在特定情况下就通过浅拷贝来替换new操作
new运算符相关见
浅拷贝和深拷贝见
class Program
{
static void Main(string[] args)
{
Prototype1 P1 = new Prototype1("1");
Prototype1 P2 = P1.Clone()as Prototype1;
}
}
public abstract class Prototype
{
private string id;
public Prototype(string id)
{
this.id = id;
}
public abstract Prototype Clone();
}
public class Prototype1:Prototype
{
private string id;
public Prototype1(string id):base(id)
{
}
public override Prototype Clone()
{
return this.MemberwiseClone() as Prototype;
}
}
七、适配器模式
现在已经需要用到的接口和已经设计好的功能接口不一致,适配器模式提供一种接口的适配机制。
接口和抽象类的区别见
适配器模式又分为类的适配器模式和对象的适配器模式
类适配器:继承一个类和一个接口,在接口中通过this.方法名来调用类的方法。
class Program
{
static void Main(string[] args)
{
ShouldUse S = new Adapter();
S.INPut();
Console.ReadKey();
}
}
//现在需要使用的接口,比如手机充电的电压接口220v
public interface ShouldUse
{
void INPut();
}
//现在已经有的接口,比如手机需要的充电电压为5v
public class Have
{
public void Charger()
{
Console.WriteLine("充电电压为5v可以正常充电");
}
}
//我们充电的时候就需要电源适配器,来吧220v的电压转换为5v的电压
//类适配器
public class Adapter : Have, ShouldUse
{
public void INPut()
{
Console.WriteLine("电源适配器 将电压降低到5v");
//用220v的电压接口,转化为5v的电压
this.Charger();
}
}
对象适配器
继承一个接口,在接口中实例化一个类的对象,调用该对象的方法
class Program
{
static void Main(string[] args)
{
ShouldUse S = new Adapter();
S.INPut();
Console.ReadKey();
}
}
//现在需要使用的接口,比如手机充电的电压接口220v
public interface ShouldUse
{
void INPut();
}
//现在已经有的接口,比如手机需要的充电电压为5v
public class Have
{
public void Charger()
{
Console.WriteLine("充电电压为5v可以正常充电");
}
}
//我们充电的时候就需要电源适配器,来吧220v的电压转换为5v的电压
//类适配器
public class Adapter : ShouldUse
{
Have h = new Have();
public void INPut()
{
Console.WriteLine("电源适配器 将电压降低到5v");
//用220v的电压接口,转化为5v的电压
h.Charger();
}
}
八、桥接模式
当一个抽象有多个实现时我们通常通过继承来重写多个实现,继承机制将它的抽象部分和实现部分固定在一起,使得难以对抽象部分和实现部分进行独立的修改、扩充和重用。
桥接模式是为了让抽象化和实现化脱藕,使两者可以独立的变化
想不出来好例子了 借鉴一下。。。。。
class Program
{
static void Main(string[] args)
{
// 创建一个遥控器
RemoteControl remoteControl = new ConcreteRemote();
// 长虹电视机
remoteControl.Implementor = new ChangHong();
remoteControl.On();
remoteControl.SetChannel();
remoteControl.Off();
Console.WriteLine();
// 三星牌电视机
remoteControl.Implementor = new Samsung();
remoteControl.On();
remoteControl.SetChannel();
remoteControl.Off();
Console.Read();
}
}
/// <summary>
/// 抽象概念中的遥控器,扮演抽象化角色
/// </summary>
public class RemoteControl
{
// 字段
private TV implementor;
// 属性
public TV Implementor
{
get { return implementor; }
set { implementor = value; }
}
/// <summary>
/// 开电视机,这里抽象类中不再提供实现了,而是调用实现类中的实现
/// </summary>
public virtual void On()
{
implementor.On();
}
/// <summary>
/// 关电视机
/// </summary>
public virtual void Off()
{
implementor.Off();
}
/// <summary>
/// 换频道
/// </summary>
public virtual void SetChannel()
{
implementor.tuneChannel();
}
}
/// <summary>
/// 具体遥控器
/// </summary>
public class ConcreteRemote : RemoteControl
{
public override void SetChannel()
{
Console.WriteLine("---------------------");
base.SetChannel();
Console.WriteLine("---------------------");
}
}
/// <summary>
/// 电视机,提供抽象方法
/// </summary>
public abstract class TV
{
public abstract void On();
public abstract void Off();
public abstract void tuneChannel();
}
/// <summary>
/// 长虹牌电视机,重写基类的抽象方法
/// 提供具体的实现
/// </summary>
public class ChangHong : TV
{
public override void On()
{
Console.WriteLine("长虹牌电视机已经打开了");
}
public override void Off()
{
Console.WriteLine("长虹牌电视机已经关掉了");
}
public override void tuneChannel()
{
Console.WriteLine("长虹牌电视机换频道");
}
}
/// <summary>
/// 三星牌电视机,重写基类的抽象方法
/// </summary>
public class Samsung : TV
{
public override void On()
{
Console.WriteLine("三星牌电视机已经打开了");
}
public override void Off()
{
Console.WriteLine("三星牌电视机已经关掉了");
}
public override void tuneChannel()
{
Console.WriteLine("三星牌电视机换频道");
}
}