什么网站可以免费做视频,网站有哪些类型,什么人需要网站建设,深圳网站建设交易一、设计模式定义 设计模式#xff08;Design Pattern#xff09;是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。使用设计模式的目的#xff1a;为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化#xff1b;… 一、设计模式定义 设计模式Design Pattern是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。 使用设计模式的目的为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化设计模式是软件工程的基石脉络如同大厦的结构一样。 二、设计模式的四个基本要素 模式名称、针对的问题解决方案、效果评价 三、面向对象设计的原则 针对接口编程而不是针对实现编程。 优先使用对象组合而不是类继承。对象组合如委托参数化类型不同于对象组合和类继承如c的模板Template 设计应支持变化。 面向对象设计有五大原则 1、单一职责原则SRP 阐述简述一个类应该只有一个发生变化的原因。如有多个职责应该分离 如果没有变化的征兆那么应用SRP原则或者其它原则都是不明智的。 2、开放-封闭原则OCP 阐述一个软件实体如类、模块和函数应该对扩展开放对修改关闭。 开闭原则的重要性 开闭原则对测试的影响 开闭原则可是保持原有的测试代码仍然能够正常运行我们只需要对扩展的代码进行测试就可以了。 开闭原则可以提高复用性 在面向对象的设计中所有的逻辑都是从原子逻辑组合而来的而不是在一个类中独立实现一个业务逻辑。只有这样代码才可以复用粒度越小被复用的可能性就越大。 开闭原则可以提高可维护性面向对象开发的要求 如何使用开闭原则 抽象约束 第一通过接口或者抽象类约束扩展对扩展进行边界限定不允许出现在接口或抽象类中不存在的public方法 第二参数类型、引用对象尽量使用接口或者抽象类而不是实现类 第三抽象层尽量保持稳定一旦确定即不允许修改。 元数据metadata控制模块行为 元数据就是用来描述环境和数据的数据通俗地说就是配置参数参数可以从文件中获得也可以从数据库中获得。 Spring容器就是一个典型的元数据控制模块行为的例子其中达到极致的就是控制反转Inversion of Control 制定项目章程 在一个团队中建立项目章程是非常重要的因为章程中指定了所有人员都必须遵守的约定对项目来说约定优于配置。 封装变化 对变化的封装包含两层含义 第一将相同的变化封装到一个接口或者抽象类中 第二将不同的变化封装到不同的接口或抽象类中不应该有两个不同的变化出现在同一个接口或抽象类中。 3、里氏替换原则LSP 阐述子类型subtype必须能够替换掉它们的基类型basetype 如要既要遵守契约又要遵守LSP 从CRectangle类和CSquare类提取出公共部分做为一个基类。比如CShape类。 CRectangle和CSquare都继承自CShape类。 4、依赖倒置原则DIP 阐述面向接口编程 表现 高层模块不应该依赖底层模块两者都应该依赖其抽象抽象不应该依赖细节细节应该依赖抽象。 如何做到抽象依赖 构造函数传递依赖对象——构造函数注入Setter方法传递依赖对象——Setter依赖注入接口声明依赖对象——接口注入5、接口隔离原则ISP 阐述不同应用场景的接口要分开定义 表现 客户端不应该依赖它不需要的接口类间的依赖关系应该建立在最小的接口上6、迪米特原则LKP 阐述一个对象应该对其他对象有最少的了解。迪米特法则Law of DemeterLoD也称为最少知识原则Least Knowledge PrincipleLKP。 通俗地讲一个类应该对自己需要耦合或调用的类知道得最少你被耦合或调用的类的内部是如何复杂都和我没关系那是你的事情我就知道你提供的public方法我就调用这么多其他的一概不关心。 含义只和朋友交流 四、模式和框架 设计模式比框架更抽象、设计模式是比框架更小的体系结构元素、框架比设计模式更特例化、 设计模式可以分为创建模式、结构模式、行为模式三个大类。根据范围可以分为类的模式、对象模式。 创建模式是关注对象的创建。 结构模式是关注类与类之间的关系。 行为模式是关注对象与行为之间的关系。 五、创建模式 1、abstract factory(抽象工厂) 意图提供一个创建一系列相关或相互依赖的对象的接口而无需指定他们具体的类。 别名kit 适用一个系统要独立于它的产品的创建、组合、表示 一个系统要由多个产品系列中的一个来配置时。 利弊分离具体的类易于交换产品系列有利于产品一致但难以支持新产品。 例子 int main()
{
//创建工厂
IFactory * pFactory NULL;
IUser * pUser NULL;
IDepartment * pDepartment NULL;
int choise;
cout选择数据库: ;
cinchoise;
switch(choise)
{
case 1:
pFactory new SqlServerFactory(); //创建SqlServer访问的工厂
break;
case 2:
pFactory new AccessFactory(); //创建Access访问的工厂
break;
}
//一致的操作
pUser pFactory-CreateUser();
pDepartment pFactory-CreateDepartment();
pUser-Insert();
pUser-GetUser();
pDepartment-Insert();
pDepartment-GetDepartment();
return 0;
}2、bulider生成器 意图将一个复杂对象的构建和它的标识分离使同样的创建过程创建不同的表示。 适用性 在以下情况使用Build模式 1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。 2 当构造过程必须允许被构造的对象有不同的表示时。 3 Builder模式要解决的也正是这样的问题 当我们要创建的对象很复杂的时候通常是由很多其他的对象组合而成 我们要复杂对象的创建过程和这个对象的表示展示分离开来 这样做的好处就是通过一步步的进行复杂对象的构建 由于在每一步的构造过程中可以引入参数使得经过相同的步骤创建最后得到的对象的展示不一样。 在书中第一个例子RTF文档阅读器的实现中可以看到文档RTFReader支持。 将一个“复杂对象的构建算法”与它的“部件及组装方式”分离使得构件算法和组装方式可以独立应对变化复用同样的构建算法可以创建不同的表示不同的构建过程可以复用相同的部件组装方式。 例子C#中 StringBuild就是一个很好的简单的例子 1: //Client同时充当了Director的角色2: StringBuilder builder new StringBuilder();3: builder.Append(happyhippy);4: builder.Append(.cnblogs);5: builder.Append(.com);6: //返回string对象happyhippy.cnblogs.com7: builder.ToString(); 3、factory method工厂方法 意图定义一个用于创建对象的接口让子类决定实例化哪一个类。即使一个类的实例化延迟到子类中 别名虚拟构造器Virtual Constructor 适用 在以下情况下可以使用工厂方法模式 一个类不知道它所需要的对象的类在工厂方法模式中客户端不需要知道具体产品类的类名只需要知道所对应的工厂即可具体的产品对象由具体工厂类创建客户端需要知道创建具体产品的工厂类。 一个类通过其子类来指定创建哪个对象在工厂方法模式中对于抽象工厂类只需要提供一个创建产品的接口而由其子类来确定具体要创建的对象利用面向对象的多态性和里氏代换原则在程序运行时子类对象将覆盖父类对象从而使得系统更容易 扩展。 将创建对象的任务委托给多个工厂子类中的某一个客户端在使用时可以无须关心是哪一个工厂子类创建产品子类需要时再动态指定可将具体工厂类的类名存储在配置文件或数据库中。 例子 namespace FactoryMethod
{/// summary/// 抽象产品类/// /summarypublic interface ICoat{void ShowCoat();}
}IFactory.csnamespace FactoryMethod
{/// summary/// 抽象工厂类定义产品的接口/// /summarypublic interface IFactory{ICoat CreateCoat();}
}FashionCoat.csusing System;
namespace FactoryMethod
{/// summary/// 具体产品类时尚上衣类/// /summarypublic class FashionCoat :ICoat{public void ShowCoat(){Console.WriteLine(这件是时尚上衣);}}
}BusinessCoat.csusing System;
namespace FactoryMethod
{/// summary/// 具体产品类商务上衣类/// /summarypublic class BusinessCoat :ICoat{public void ShowCoat(){Console.WriteLine(这件是商务上衣);}}
}FashionFactory.csnamespace FactoryMethod
{/// summary/// 具体工厂类用于创建时尚上衣/// /summarypublic class FashionFactory :IFactory{public ICoat CreateCoat(){return new FashionCoat();}}
}BusinessFactory.csnamespace FactoryMethod
{/// summary/// 具体工厂类:用于创建商务上衣类/// /summarypublic class BusinessFactory : IFactory{public ICoat CreateCoat(){return new BusinessCoat();}}
}
App.config?xml version1.0 encodingutf-8 ?
configurationappSettingsadd keyFactoryName valueFashionFactory//appSettings
/configuration
Program.csusing System;
using System.Configuration;
using System.Reflection;namespace FactoryMethod
{class Client{static void Main(string[] args){//BusinessFactory factory new BusinessFactory();//为了方便以后修改,将工厂类的类名写在应用程序配置文件中string factoryName ConfigurationManager.AppSettings[FactoryName];IFactory factory (IFactory)Assembly.Load(FactoryMethod).CreateInstance(FactoryMethod. factoryName);ICoat coat factory.CreateCoat();//显示你要的上衣coat.ShowCoat();Console.ReadLine();}}
} 4、prototype原型 意图用原型实例指定创建对象的种类并且通过拷贝这些原型创建新的对象 结构 适用当一个系统应该独立于他的产品的创建、构成和表示 例子 我定义了一个场景一个人开这一辆车在一条公路上。现在这件事是确定的但不确定的有几点1、人姓名性别年龄2车什么牌子的3公路公路名字长度类型柏油还是土路。现在我们一个个实现。先来实现人定义一个抽象类AbstractDriver具体实现男性Man和女性Women
public abstract class AbstractDriver{public AbstractDriver(){//// TODO: 在此处添加构造函数逻辑//}public string name;public string sex;public int age;public abstract string drive();public abstract AbstractDriver Clone();}public class Man:AbstractDriver{public Man(string strName,int intAge){sex Male;name strName;age intAge;}public override string drive(){return name is drive;}public override AbstractDriver Clone(){return (AbstractDriver)this.MemberwiseClone();}}public class Women:AbstractDriver{public Women(string strName,int intAge){sex Female;name strName;age intAge;}public override string drive(){return name is drive;}public override AbstractDriver Clone(){return (AbstractDriver)this.MemberwiseClone();}}注意抽象代码中有一个Clone的方法个人认为这个方法是原型模式的一个基础因为前面讲了原型模式是通过拷贝自身来创建新的对象。下面我们再来实现公路和汽车公路
public abstract class AbstractRoad{public AbstractRoad(){//// TODO: 在此处添加构造函数逻辑//}public string Type;public string RoadName;public int RoadLong;public abstract AbstractRoad Clone();}public class Bituminous:AbstractRoad //柏油路{public Bituminous(string strName,int intLong){RoadName strName;RoadLong intLong;Type Bituminous;}public override AbstractRoad Clone(){return (AbstractRoad)this.MemberwiseClone();}}public class Cement:AbstractRoad //水泥路{public Cement(string strName,int intLong){RoadName strName;RoadLong intLong;Type Cement;}public override AbstractRoad Clone(){return (AbstractRoad)this.MemberwiseClone();}}汽车public abstract class AbstractCar{public AbstractCar(){//// TODO: 在此处添加构造函数逻辑//}public string OilBox;public string Wheel;public string Body;public abstract string Run();public abstract string Stop();public abstract AbstractCar Clone();}public class BMWCar:AbstractCar{public BMWCar(){OilBox BMWs OilBox;Wheel BMWs Wheel;Body BMWs body;}public override string Run(){return BMW is running;}public override string Stop(){return BMW is stoped;}public override AbstractCar Clone(){return (AbstractCar)this.MemberwiseClone();}}public class BORACar:AbstractCar{public BORACar(){OilBox BORAs OilBox;Wheel BORAs Wheel;Body BORAs Body;}public override string Run(){return BORA is running;}public override string Stop(){return BORA is stoped;}public override AbstractCar Clone(){return (AbstractCar)this.MemberwiseClone();}}public class VolvoCar:AbstractCar{public VolvoCar(){OilBox Volvos OilBox;Wheel Volvos Wheel;Body Volvos Body;}public override string Run(){return Volvo is running;}public override string Stop(){return Volvo is stoped;}public override AbstractCar Clone(){return (AbstractCar)this.MemberwiseClone();}}然后我们再来看看场景我们定义一个Manage类在这个场景中有一个人一辆车和一条公路代码实现如下
class Manage{public AbstractCar Car;public AbstractDriver Driver;public AbstractRoad Road;public void Run(AbstractCar car,AbstractDriver driver,AbstractRoad road){Car car.Clone();Driver driver.Clone();Road road.Clone();}}可以看到在这个代码中场景只是依赖于那几个抽象的类来实现的。最后我们再来实现一下客户代码比如我现在要一辆Volvo车一个叫“Anli”的女司机在一条叫“Road1”、长1000的柏油路上。static void Main(string[] args){Manage game new Manage();game.Run(new VolvoCar(),new Women(Anli,18),new Bituminous(Road1,1000));Console.Write(CarRun: game.Car.Run() \n);Console.Write(DriverName: game.Driver.name \n);Console.Write(DriverSex: game.Driver.sex \n);Console.Write(RoadName: game.Road.RoadName \n);Console.Write(RoadType: game.Road.Type \n);Console.Write(CarStop: game.Car.Stop() \n);Console.Read();}运行的结果是CarRun:Volvo is runningDriverName:AnliDriverSex:FemaleRoadName:Road1RoadType:BituminousCarStop:Volvo is stoped现在我们再来看看原型模式的几个要点 1、Prototype模式同样用于隔离类对象的使用者和具体类型易变类之间的耦合关系它同样要求这些“易变类”拥有“稳定的接口”。 2、Prototype模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来实现它使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象——所需工作仅仅是注册一个新类的对象即原型然后在任何需要的地方不断地Clone。 3、Prototype模式中的Clone方法可以利用Object类的MemberwiseClone或者序列化来实现深拷贝。 5、singleton单件 意图保证类有且仅有一个实例并提供一个访问它的全局访问点 此处没有过多的解释程序只运行一个实例的例子很多如工具管理的类主程序等 单例模式的实现 #的独特语言特性决定了C#拥有实现Singleton模式的独特方法。这里不再赘述原因给出几个结果方法一下面是利用.NET Framework平台优势实现Singleton模式的代码sealed class Singleton
{private Singleton();public static readonly Singleton Instancenew Singleton();
}
这使得代码减少了许多同时也解决了线程问题带来的性能上损失。那么它又是怎样工作的呢注意到Singleton类被声明为sealed以此保证它自己不会被继承其次没有了Instance的方法将原来_instance成员变量变成public readonly并在声明时被初始化。通过这些改变我们确实得到了Singleton的模式原因是在JIT的处理过程中如果类中的static属性被任何方法使用时.NET Framework将对这个属性进行初始化于是在初始化Instance属性的同时Singleton类实例得以创建和装载。而私有的构造函数和readonly(只读)保证了Singleton不会被再次实例化这正是Singleton设计模式的意图。
摘自http://www.cnblogs.com/huqingyu/archive/2004/07/09/22721.aspx 不过这也带来了一些问题比如无法继承实例在程序一运行就被初始化无法实现延迟初始化等。方法二既然方法一存在问题我们还有其它办法。public sealed class Singleton
{Singleton(){}public static Singleton GetInstance(){return Nested.instance;}class Nested{// Explicit static constructor to tell C# compiler// not to mark type as beforefieldinitstatic Nested(){}internal static readonly Singleton instance new Singleton();}
} 六、结构型模式 结构型模式涉及到如何组合类和对象以或者更大的结构 1、adapter模式 意图把一个类的接口变换成客户端所期待的另一种接口 Adapter模式使原本因接口不匹配或者不兼容而无法在一起工作的两个类能够在一起工作 比如多种手机每一种机型都自带有从电器有一天自带充电器坏了而且市场没有这类型充电器可买了。怎么办万能充电器就可以解决。这个万能充电器就是适配器。 分类 共有两类适配器模式1.类的适配器模式采用继承实现2.对象适配器采用对象组合方式实现 1)类适配器模式 ——适配器继承自已实现的类一般多重继承。 Adapter与Adaptee是继承关系 1、用一个具体的Adapter类和Target进行匹配。结果是当我们想要一个匹配一个类以及所有它的子类时类Adapter将不能胜任工作 2、使得Adapter可以重定义Adaptee的部分行为因为Adapter是Adaptee的一个子集 3、仅仅引入一个对象并不需要额外的指针以间接取得adaptee 2)对象适配器模式—— 适配器容纳一个它包裹的类的实例。在这种情况下适配器调用被包裹对象的物理实体。 Adapter与Adaptee是委托关系 1、允许一个Adapter与多个Adaptee同时工作。Adapter也可以一次给所有的Adaptee添加功能 2、使用重定义Adaptee的行为比较困难 无论哪种适配器它的宗旨都是保留现有类所提供的服务向客户提供接口以满足客户的期望。 即在不改变原有系统的基础上提供新的接口服务。 适用 1 • 你想使用一个已经存在的类而它的接口不符合你的需求。 2 • 你想创建一个可以复用的类该类可以与其他不相关的类或不可预见的类即那些接口可能不一定兼容的类协同工作。 3 •仅适用于对象Adapter你想使用一些已经存在的子类但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。即仅仅引入一个对象并不需要额外的指针以间接取得adaptee。 举例 /// summary/// 定义客户端期待的接口/// /summarypublic class Target{/// summary/// 使用virtual修饰以便子类可以重写/// /summarypublic virtual void Request(){Console.WriteLine(This is a common request);}}/// summary/// 定义需要适配的类/// /summarypublic class Adaptee{public void SpecificRequest(){Console.WriteLine(This is a special request.);}}/// summary/// 定义适配器/// /summarypublic class Adapter:Target{// 建立一个私有的Adeptee对象private Adaptee adaptee new Adaptee();/// summary/// 通过重写表面上调用Request()方法变成了实际调用SpecificRequest()/// /summarypublic override void Request(){adaptee.SpecificRequest();}}
客户端
class Program{static void Main(string[] args){// 对客户端来说调用的就是Target的Request()Target target new Adapter();target.Request();Console.Read();}}举例 类适配器 using System;/// 这里以插座和插头的例子来诠释适配器模式
/// 现在我们买的电器插头是2个孔但是我们买的插座只有3个孔的
/// 这是我们想把电器插在插座上的话就需要一个电适配器
namespace 设计模式之适配器模式
{/// summary/// 客户端客户想要把2个孔的插头 转变成三个孔的插头这个转变交给适配器就好/// 既然适配器需要完成这个功能所以它必须同时具体2个孔插头和三个孔插头的特征/// /summaryclass Client{static void Main(string[] args){// 现在客户端可以通过电适配要使用2个孔的插头了IThreeHole threehole new PowerAdapter();threehole.Request();Console.ReadLine();}}/// summary/// 三个孔的插头也就是适配器模式中的目标角色/// /summarypublic interface IThreeHole{void Request();}/// summary/// 两个孔的插头源角色——需要适配的类/// /summarypublic abstract class TwoHole{public void SpecificRequest(){Console.WriteLine(我是两个孔的插头);}}/// summary/// 适配器类接口要放在类的后面/// 适配器类提供了三个孔插头的行为但其本质是调用两个孔插头的方法/// /summarypublic class PowerAdapter:TwoHole,IThreeHole{/// summary/// 实现三个孔插头接口方法/// /summarypublic void Request(){// 调用两个孔插头方法this.SpecificRequest();}}
}对象适配器 namespace 对象的适配器模式
{class Client{static void Main(string[] args){// 现在客户端可以通过电适配要使用2个孔的插头了ThreeHole threehole new PowerAdapter();threehole.Request();Console.ReadLine();}}/// summary/// 三个孔的插头也就是适配器模式中的目标(Target)角色/// /summarypublic class ThreeHole{// 客户端需要的方法public virtual void Request(){// 可以把一般实现放在这里}}/// summary/// 两个孔的插头源角色——需要适配的类/// /summarypublic class TwoHole{public void SpecificRequest(){Console.WriteLine(我是两个孔的插头);}}/// summary/// 适配器类这里适配器类没有TwoHole类/// 而是引用了TwoHole对象所以是对象的适配器模式的实现/// /summarypublic class PowerAdapter : ThreeHole{// 引用两个孔插头的实例,从而将客户端与TwoHole联系起来public TwoHole twoholeAdaptee new TwoHole();/// summary/// 实现三个孔插头接口方法/// /summarypublic override void Request(){twoholeAdaptee.SpecificRequest();}}
}桥梁模式(bridge模式)桥梁模式与对象适配器类似但是桥梁模式的出发点不同桥梁模式目的是将接口部分和实现部分分离从而对它们可以较为容易也相对独立的加以改变。而对象适配器模式则意味着改变一个已有对象的接口 装饰器模式(decorator模式)装饰模式增强了其他对象的功能而同时又不改变它的接口。因此装饰模式对应用的透明性比适配器更好。结果是decorator模式支持递归组合而纯粹使用适配器是不可能实现这一点的。 Facade外观模式适配器模式的重点是改变一个单独类的API。Facade的目的是给由许多对象构成的整个子系统提供更为简洁的接口。而适配器模式就是封装一个单独类适配器模式经常用在需要第三方API协同工作的场合设法把你的代码与第三方库隔离开来。 适配器模式与外观模式都是对现相存系统的封装。但这两种模式的意图完全不同前者使现存系统与正在设计的系统协同工作而后者则为现存系统提供一个更为方便的访问接口。简单地说适配器模式为事后设计而外观模式则必须事前设计因为系统依靠于外观。总之适配器模式没有引入新的接口而外观模式则定义了一个全新的接口。 代理模式Proxy 在不改变它的接口的条件下为另一个对象定义了一个代理。 装饰者模式适配器模式外观模式三者之间的区别 装饰者模式的话它并不会改变接口而是将一个一个的接口进行装饰也就是添加新的功能。 适配器模式是将一个接口通过适配来间接转换为另一个接口。 外观模式的话其主要是提供一个整洁的一致的接口给客户端。 转载于:https://www.cnblogs.com/xietianjiao/p/7285011.html
