精华内容
下载资源
问答
  • 单例设计模式的优缺点 设计思想 举例表示
  • singleton设计模式by Navdeep ... 让我们研究一下Singleton设计模式的优缺点 (Let’s examine the pros and cons of the Singleton design pattern) Design patterns are conceptual tools for solving complex soft...

    singleton设计模式

    by Navdeep Singh

    通过Navdeep Singh

    让我们研究一下Singleton设计模式的优缺点 (Let’s examine the pros and cons of the Singleton design pattern)

    Design patterns are conceptual tools for solving complex software problems. These patterns are simple and elegant solutions that have evolved over time and may have become generally accepted as the best way to address certain design challenges. — Me, in my ebook Reactive Programming with Swift 4

    设计模式是解决复杂软件问题的概念工具。 这些模式是简单而优雅的解决方案,并且随着时间的推移而发展,并且可能已被广泛接受为解决某些设计挑战的最佳方法。 — 我在我的电子书《使用Swift 4进行React式编程》中

    单例设计模式 (Singleton Design Pattern)

    The Singleton pattern encapsulates a shared resource within a single unique class instance. This instance arbitrates access to the resource and storage-related state information. A class method provides the reference to this instance, so there is no need to pass the reference around. Any object that has access to the Singleton’s class header can use the Singleton.

    Singleton模式将共享资源封装在一个唯一的类实例中。 该实例仲裁对资源和与存储相关的状态信息的访问。 类方法提供对此实例的引用,因此不需要传递该引用。 任何有权访问Singleton类标题的对象都可以使用Singleton。

    This design pattern defines the structure of a class that can have only one instance. A Singleton encapsulates a unique resource and makes it readily available throughout the application. The resource might be hardware, a network service, a persistent store, or anything else that can be modeled as a unique object or service.

    这种设计模式定义了只能具有一个实例的类的结构。 Singleton封装了独特的资源,并使其易于在整个应用程序中使用 。 该资源可以是硬件,网络服务,持久性存储,或可以建模为唯一对象或服务的其他任何资源。

    One example from Cocoa touch is a physical device running an iOS application. For an executing app, there is only one iPhone or iPad with a single battery and a screen. UIDevice is a Singleton class here since it provides one channel to interact with the underlying features. In case the unique resource has a writable configuration, this sort of discrepancy can lead to problems such as race condition and deadlock. Since they are unique, Singletons act as a control, ensuring orderly access to the shared resource.

    来自Cocoa touch的一个示例是运行iOS应用程序的物理设备。 对于执行中的应用程序,只有一部iPhone或iPad带有一个电池和一个屏幕。 UIDevice在这里是Singleton类,因为它提供了一个与基础功能进行交互的渠道。 如果唯一资源具有可写配置,则这种差异会导致诸如争用条件和死锁之类的问题。 由于它们是唯一的,因此Singletons充当控件,确保对共享资源的有序访问。

    Singletons may often be modeled as a server within the application that accepts requests to send, store, or retrieve data and configure the resource state.
    单例通常可以建模为应用程序中的服务器,该服务器接受发送,存储或检索数据并配置资源状态的请求。

    实作 (Implementation)

    Implementation of the Singleton pattern often typically creates a single object using the factory method, and this instance/object is called a shared instance in most cases. Since the access to the instance is passed on through a class method, the need to create an object is eliminated. Let’s look at the Singleton implementation in code.

    Singleton模式的实现通常通常使用factory方法创建单个对象,并且在大多数情况下,此实例/对象称为共享实例。 由于对实例的访问是通过类方法传递的,因此无需创建对象。 让我们看一下代码中的Singleton实现。

    For this example, we have used the command line tool Xcode template to create a project and name it Singleton. Our Singleton class is called SingletonObject, which we created as a normal Cocoa class, and it is a subclass of NSObject. The project setup looks like this so far:

    在此示例中,我们使用了命令行工具 Xcode模板来创建一个项目并将其命名为Singleton。 我们的Singleton类称为SingletonObject ,它是我们作为普通Cocoa类创建的,它是NSObject的子类。 到目前为止,项目设置如下:

    Then we added a class method called sharedInstance as discussed earlier since this is how the class will make the Singleton available. Its return value is of the SingleObject type, as follows:

    然后, 如前所述 ,我们添加了一个名为sharedInstance的类方法,因为这是该类使Singleton可用的方式。 它的返回值是SingleObject类型,如下所示:

    func sharedInstance() -> SingletonObject {         }

    The function stores the instance in a static local reference called localSharedInstance. Static locals are much like global objects — they retain their value for the lifetime of the application, yet they are limited in scope. These qualities make them ideal to be a Singleton, since they are permanent and yet ensure that our Singleton is only available through sharedInstance.

    该函数将实例存储在称为localSharedInstance的静态本地引用中。 静态局部变量很像全局对象,它们在应用程序的生命周期中保留其价值,但范围有限。 这些品质使它们非常适合成为Singleton,因为它们是永久性的,而且可以确保我们的Singleton仅可通过sharedInstance获得

    This is one of the ways in which our Singleton implementation ensures that the Singleton stays singular. The basic structure of shared instance consists of a conditional block that tests whether a Singleton instance has been allocated. But surprisingly, that’s the older way of doing things (or may be the way to go in other languages). In Swift, however, the implementation has changed to merely one line, and we don’t require a method. The implementation looks like this:

    这是我们的Singleton实现可确保Singleton保持单数的方式之一。 共享实例的基本结构由一个条件块组成,该条件块测试是否已分配Singleton实例。 但是令人惊讶的是,这是较旧的处理方式(或者可能是其他语言的处理方式)。 但是,在Swift中,实现只更改为一行,我们不需要方法。 实现看起来像这样:

    class SingletonObject: NSObject {    static let sharedInstance = SingletonObject()}

    Simple, isn’t it?

    很简单,不是吗?

    单例设计模式—优点和缺点 (Singleton design pattern — Pros and cons)

    Singletons are not the answer to every problem. Like any tool, they can be short in supply or can be overused.
    单例并不能解决所有问题。 像任何工具一样,它们可能供应不足或过度使用。

    Some developers are critical of Singletons for various reasons. We will examine this critique and discuss ways to address them briefly. The criticisms, for the most part, fall into two categories:

    一些开发人员出于各种原因对Singletons持批评态度。 我们将研究这种批评并讨论解决这些问题的方法。 批评大部分分为两类:

    • Singletons hinder unit testing: A Singleton might cause issues for writing testable code if the object and the methods associated with it are so tightly coupled that it becomes impossible to test without writing a fully-functional class dedicated to the Singleton.

      Singleton会阻碍单元测试:如果对象和与之关联的方法紧密耦合,以至于如果不编写专用于Singleton的功能齐全的类就无法进行测试,则Singleton可能会导致编写可测试代码的问题。

    • Singletons create hidden dependencies: As the Singleton is readily available throughout the code base, it can be overused. Moreover, since its reference is not completely transparent while passing to different methods, it becomes difficult to track.

      单例创建隐藏的依赖项:由于单例在整个代码库中都很容易获得,因此可能会被过度使用。 此外,由于在传递给不同方法时其引用不是完全透明的,因此变得难以跟踪。

    To avoid these complications, when considering the Singleton pattern, you should make certain that the class is a Singleton. Also, while thinking of designing the Singleton design pattern, keep testing in mind and use dependency injection whenever possible — that is, try to pass the Singleton as a parameter to the initializer whenever possible.

    为了避免这些复杂性,在考虑Singleton模式时,应确保该类是Singleton。 另外,在考虑设计Singleton设计模式时,请牢记测试并在可能的情况下使用依赖注入-也就是说,尝试在可能的情况下将Singleton作为参数传递给初始化程序。

    For other updates, you can follow me on Twitter on my twitter handle @NavRudraSambyal

    对于其他更新,您可以在Twitter上的@NavRudraSambyal上关注我。

    To read more about various other Design patterns and practice examples, you can follow the link to my book Reactive programming in Swift 4

    要阅读有关其他各种设计模式和实践示例的更多信息,可以单击我的书《 Swift 4中的React式编程》中的链接。

    Thanks for reading, please share it if you found it useful :)

    感谢您的阅读,如果您觉得有用,请分享:)

    翻译自: https://www.freecodecamp.org/news/singleton-design-pattern-pros-and-cons-e10f98e23d63/

    singleton设计模式

    展开全文
  • 缺点:一是如果需要生产产品过多,此模式会导致工厂类过于庞大,承担过多职责,变成超级类; ​ 二是当生成新产品时,必须在工厂类中添加新分支。这违背了开闭原则 工厂方法模式 工厂方法模式就是将简单工厂...

    简单工厂模式

    简单工厂模式就是让一个工厂类承担构建所有对象的职责。调用者需要什么产品,让工厂生产出来即可。

    优点:将构建过程封装的好处不仅可以降低耦合,如果某个产品构造方法相当复杂,使用工厂模式可以大大减少代码重复。

    缺点:一是如果需要生产的产品过多,此模式会导致工厂类过于庞大,承担过多的职责,变成超级类;

    ​ 二是当生成新产品时,必须在工厂类中添加新的分支。这违背了开闭原则

    工厂方法模式

    工厂方法模式就是将简单工厂的各个职责拆分成专业职责的工厂类

    优点:工厂方法模式就是为了解决简单共厂模式的弊端诞生的。当生产的产品种类越来越多时,工厂类不会变成超级类(各个工厂的运行过程都可单独修改);当需要生产新的产品时,无需更改既有的工厂,只需要添加新的工厂即可。保持了面向对象的可扩展性,符合开闭原则。

    缺点:相比起简单工厂来说,工厂方法用户的操作类便多了,增加了用户端的代码量,但相比起其改进程度来说,这点问题还是能接受的

    抽象工厂模式

    抽象工厂模式时工厂方法模式的进一步改进,提取出其工厂接口

    优点:由于客户只调用抽象工厂中的方法(每个具体工厂都实现其方法,但在客户端的调用代码是一样的),这就使得替换工厂变得非常容易。也很好的继承了工厂方法模式的优点,很好的发挥了开闭原则、依赖倒置原则。

    缺点:抽象工厂模式太重了,如果抽象接口需要添加新功能,则会影响到所有的具体工厂类。所有工厂模式适合同类工厂这样的横向扩展需求,不适合增添新功能这样的纵向扩展。

    单例模式

    单例模式是在创建类时使该类能自行创建它的实例(在类中提供初始化功能)。

    单例模式有两种,分为懒汉模式和饿汉模式,懒汉模式是在类中提供一个初始化的函数(类如果没被初始化将其初始化,如果类被初始化了就结束调用),在需要的地方调用这个初始化函数;饿汉模式是在创建类的变量时就声明,然后给出一个声明函数返回该变量。其具体过程及各种优缺点参照我博客()。

    建造者模式

    建造者模式又叫生成器模式,将一个复杂对象的构建与他的表示分离,使得同样的构建过程可以创建不同的表示

    具体实现

    指挥者(Director)直接和客户(Client)进行需求沟通;

    沟通后指挥者将客户创建产品的需求划分为各个部件的建造请求(Builder);

    将各个部件的建造请求委派到具体的建造者(ConcreteBuilder);

    各个具体建造者负责进行产品部件的构建;

    最终构建成具体产品(Product)。

    优点

    1.使用建造者模式可以使客户端不必知道产品内部组成的细节。

    2.具体的建造者类之间是相互独立的,这有利于系统的扩展。

    3.具体的建造者相互独立,因此可以对建造的过程逐步细化,而不会对其他模块产生任何影响。

    缺点

    1.建造者模式所创建的产品一般具有较多的共同点,其组成部分相似;如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。

    2.如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大。

    原型模式

    原型模式,用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。其实就是从一个对象再创建另外一个可定制的对象,而且不需要知道任何创建细节。

    优点:

    使用原型模式创建对象比直接new一个对象在性能上要好的多,因为Object类的clone方法是一个本地方法, 它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。

    使用原型模式的另一个好处是简化对象的创建,使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

    适配器模式

    将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不相容而不能工作的那些类可以一起工作。

    优点:

    复用了现存的类,解决了现存类和复用环境要求不一致的问题。

    一个对象适配器可以把多个不同的适配者类适配到同一个目标,也就是说,同一个适配器可以把适配者类和它的子类都适配到目标接口。

    缺点:

    对于对象适配器来说,更换适配器的实现过程比较复杂。

    桥接模式

    将抽象部分与它的现实部分分离,使它们都可以独立地变化(实现系统可能有多角度分类,每一种分类都有可能变化,那么就把这种多角度分离出来让它们独立变化,减少它们之间的耦合)

    桥接模式的使用场景:
    1、当一个对象有多个变化因素的时候,通过抽象这些变化因素,将依赖具体实现,修改为依赖抽象。
    2、当某个变化因素在多个对象中共享时。我们可以抽象出这个变化因素,然后实现这些不同的变化因素。
    3、当我们期望一个对象的多个变化因素可以动态的变化,而且不影响客户的程序的使用时。

    组合模式

    将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式对单个用户对象和组合对象具有使用一致性。

    缺点:客户端需要花更多时间理清类之间的层次关系

    优点:无需关系处理的单个对象,还是组合的对象容器,实现容器之间的解耦合。当有新部件时容易添加进来。

    何时用组合模式:

    需求中体现部分与整体层次的结构时,以及你希望用户可以忽略组合对象与单个对象的不同,统一的使用组合结构中的所有对象时。

    中介者模式

    用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其松耦合,而且可以独立地改变它们之间的交互。

    优点:

    将多对多的通信转化成多对一的通信,降低了系统的复杂性;Mediator还活得系统解耦的特性;将控制集中

    缺点:

    由于控制的集中化,于是把交互复杂性变为了中介者的复杂性,这就使得中介者会变得比任何一个ConcreteColleague都复杂

    备忘录模式

    在不破坏封装的前提下捕获一个对象的内部状态,并在该对象之外保持这个状态。这样一会就可以将该对象恢复到原先保存的状态。

    使用备忘录模式的好处:
    1)有时一些发起人对象的内部信息必须保存在发起人对象以外的地方,但是必须要由发起人对象自己读取,这时使用备忘录模式可以把复杂的发起人内部信息对其他的对象屏蔽起来,从而可以恰当地保持封装的边界。
    2)本模式简化了发起人类。发起人不再需要管理和保存其内部状态的一个个版本,客户端可以自行管理他们所需要的这些状态的版本。
    3)当发起人角色的状态改变的时候,有可能这个状态无效,这时候就可以使用暂时存储起来的备忘录将状态复原。

    使用备忘录模式的缺点:
    1)如果发起人角色的状态需要完整地存储到备忘录对象中,那么在资源消耗上面备忘录对象会很昂贵。
    2)当负责人角色将一个备忘录存储起来的时候,负责人可能并不知道这个状态会占用多大的存储空间,从而无法提醒用户一个操作是否很昂贵。

    状态模式

    当一个对象的内在状态改变时允许其改变其行为,这个对象看起来像是改变了其类。

    优点:

    将特定的状态相关的行为都放入一个对象中,由于所有与状态相关的代码都存在某个ConcreteState中,所以通过定义新的子类很容易增加新的状态和转换

    策略模式

    它定义了算法家族,分别封装起来,让他们之间可以相互替换,次模式让算法的变化不会影响到使用算法的客户

    优点:

    策略模式非常完美的符合了“开闭原则”,用户可以在不修改原有系统的基础上选择算法或行为,也可以灵活地增加新的算法或行为。

    缺点:

    虽然策略模式定义了算法,但是它并不提供算法的选择,即什么算法对于什么问题最合适这是策略模式所不关心的,所以对于策略的选择还是要客户端来做。客户必须要清楚的知道每个算法之间的区别和在什么时候什么地方使用什么策略是最合适的,这样就增加客户端的负担。

    模板方法

    定义一个算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤。

    优点:

    通过把不变行为搬移到超类,去除子类中的重复代码来体现它的优势,提供了一个很好的代码复用的平台

    访问者模式

    作用于某对象结构中的各元素的操作,它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

    优点:

    把数据结构和作用于结构上的操作脱耦合,使得操作集合可以相对自由的演化

    缺点:

    使得增加新的数据结构比较困难

    (适用于数据结构相对稳定的系统)

    展开全文
  • MVC设计模式的优缺点

    2019-09-28 12:58:26
    1)优点: 各司其职、互不干涉; 有利于开发中分工;...2)缺点: 系统结构和实现复杂; 视图与控制器过于紧密; 不适用于小型甚至中型应用程序; 转载于:https://www.cnblogs.com/yuzc/p/8798376.html...

     

    1)优点:

    各司其职、互不干涉;

    有利于开发中的分工;

    有利于组建的重用;

    2)缺点:

    系统结构和实现复杂;

    视图与控制器过于紧密;

    不适用于小型甚至中型应用程序;

    转载于:https://www.cnblogs.com/yuzc/p/8798376.html

    展开全文
  • 1、单例(Singleton)模式:某个类只能生成一个实例,该类提供...4、抽象工厂(AbstractFactory)模式:提供一个创建产品族接口,其每个子类可以生产一系列相关产品。 5、建造者(Builder)模式:将一个复杂对象..

    1、单例(Singleton)模式:某个类只能生成一个实例,该类提供了一个全局访问点供外部获取该实例,其拓展是有限多例模式。

    2、原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。

    3、工厂方法(Factory Method)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。

    4、抽象工厂(AbstractFactory)模式:提供一个创建产品族的接口,其每个子类可以生产一系列相关的产品。

    5、建造者(Builder)模式:将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建成该复杂对象。

    6、代理(Proxy)模式:为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象,从而限制、增强或修改该对象的一些特性。

    7、适配器(Adapter)模式:将一个类的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

    8、桥接(Bridge)模式:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合。

    9、装饰(Decorator)模式:动态的给对象增加一些职责,即增加其额外的功能。

    10、外观(Facade)模式:为多个复杂的子系统提供一个一致的接口,使这些子系统更加容易被访问。

    11、享元(Flyweight)模式:运用共享技术来有效地支持大量细粒度对象的复用。

    12、组合(Composite)模式:将对象组合成树状层次结构,使用户单个对象和组合对象具有一致的访问性。

    13、模板方法(TemplateMethod)模式:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下定义该算法的某些特定步骤。

    14、策略(Strategy)模式:定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的改变不会影响使用算法的客户。

    15、命令(Command)模式:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分隔开。

    16、职责链(Chain of Responsibility)模式:把请求从链中的一个对象传到下一个对象,直到请求被响应为止。通过这种方式去除对象之间的耦合。

    17、状态(State)模式:允许一个对象在其内部状态改变时改变其行为能力。

    18、观察者(Observer)模式:多个对象间一对多关系,当一个对象发生改变时,把这种改变通知给其他多个对象,从而影响其他对象的行为。

    19、中介者(Mediator)模式:定义一个中介对象来简化原有对象之间的交互关系,降低系统中对象间的耦合度,使原有对象之间不必相互了解。

    20、迭代器(Iterator)模式:提供一种方法来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。

    21、访问者(Visitor)模式:在不改变集合元素的前提下,为一个集合中的每个元素提供多种访问方式,即每个元素有多个访问者对象访问。

    22、备忘录(Memento)模式:在不破坏封装性的前提下,获取并保存一个对象的内部状态,以便以后恢复它。

    23、解释器(Interpreter)模式:提供如何定义语言的文法,以及对语言句子的解释方法,即解释器。

     

    一、开闭原则

    定义:一个软件实体,如类,模块和函数应该对拓展开放,对修改关闭。用抽象构建框架,用实现拓展细节。

    优点:提高软件系统的可复用性及可维护性。

    二、依赖倒置原则

    定义:高层模块不应该依赖低层模块,两者都应该依赖其抽象。抽象不应该依赖细节;细节应该依赖抽象。针对接口编程,不要针对实现编程

    优点:可以减少类之间的耦合性、提高系统稳定性、提高代码可读性和可维护性,可降低修改程序所造成的风险。

    三、单一职责原则

    定义:不要存在多于一个导致类变更的原因。一个类\接口\方法只负责一项职责。

    优点:降低类的复杂度、提高类的可读性,提高系统的可维护性、降低变更引起的风险。

    四、接口隔离原则

    定义:用多个专门的接口,而不使用单一的总接口,客户端不应该依赖它不需要的接口。一个类对一个类的依赖应该建立在最小的接口上。建立单一接口,不要建立庞大臃肿的接口。尽量细化接口,接口中的方法尽量少。

    优点:符合我们常说的高内聚低耦合的设计思想,从而使得类具有良好的可读性、可拓展性和可维护性。

    五、迪米特原则

    定义:一个对象应该对其他对象保持最少的了解。又叫最少知道原则。尽量降低类与类之间的耦合。强调只和朋友交流,不和陌生人说话。朋友--出现在成员变量、方法的输入、输出参数中的类称为成员朋友类,而出现在方法体内部的类不属于朋友类。

    优点:降低类之间的耦合。

    六、里式替换原则

    定义:如果对每一个类型为T1的对象O1,都有类型为T2的对象O2,使得以T1定义的所有程序P在所有的对象O1都替换成O2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。

    定义拓展:一个软件实体如果适用一个父类的话,那一定适用于其子类,所有引用父类的地方必须能透明地使用其子类的对象,子类对象能够替换父类对象,而程序逻辑不变。

    引申意义:子类可以拓展父类的功能,但不能改变父类原有的功能。

    含义1:子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。

    含义2:子类中可以增加自己特有的方法。

    含义3:当子类的方法重载父类的方法时,方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更宽松。

    含义4:当子类的方法实现父类的方法时(重写\重载或实现抽象方法),方法的后置条件(即方法的输出\返回值)要比父类更严格或相等。

    优点1:约束继承泛滥,开闭原则的一种体现。

    优点2:加强程序的健壮性,同时变更时也可以做到非常好的兼容性,提高程序的维护性、拓展性。降低需求变更时引入的风险。

    七、合成(组合)/聚合复用原则

    定义:尽量使用对象组合/聚合,而不是继承关系达到软件复用的目的。

    优点:可以使系统更加灵活,降低类与类之间的耦合度,一个类的变化对其他类造成的影响相对较少。

    八、简单工厂

    定义:由一个工厂对象决定创建出哪一种产品类的实例。

    类型:创建型,但不属于GOF23种设计模式。

    使用场景:工厂类负责创建的对象比较少。客户端(应用层)只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心。

    优点:只需要传入一个正确的参数,就可以获取你所需要的对象,而无需知道其创建的细节。

    缺点:工厂类的职责相对过重,增加新的产品,需要修改工厂类的判断逻辑,违背开闭原则。

    九、工厂方法

    定义:定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,工厂方法让类的实例化推迟到子类中进行。

    适用场景:创建对象需要大量重复的代码。客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。一个类通过其子类来指定创建哪个对象。

    优点:用户只需要关心所需的产品对应的工厂,无需关心创建细节。加入新产品符合开闭原则,提高可拓展性。

    缺点:类的个数容易过多,增加复杂度。增加了系统的抽象性和理解难度。

    十、抽象工厂

    定义:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口。无需指定它们具体的类。

    使用场景:客户端(应用层)不依赖于产品实例如何被创建、实现等细节。强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。

    优点:具体产品在应用层代码隔离,无需关心创建细节。将一个系列的产品族统一到一起创建。

    缺点:规定了所有可能被创建的产品集合,产品族中扩展新的产品困难,需要修改抽象工厂的接口。增加了系统的抽象性和理解难度。

     

    十一、建造者模式

    定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。用户只需指定所要建造的类型就可以得到它们,建造过程及细节不需要知道。

    适用场景:如果一个对象有非常复杂的内部结构(很多属性)。想把复杂对象的创建和使用分离。

    优点:封装性好,创建和使用分离。扩展性好、建造类之间独立、一定程度上解耦。

    缺点:产生多余的Builder对象。产品内部发生变化,建造者都要修改,成本较大。

    十二、单例设计模式

    定义:保证一个类仅有一个实例,并提供一个全局的访问点。

    适用场景:想确保任何情况下都绝对只有一个实例。

    优点:在内存里只有一个实例,减少了内存的开销。可以避免对资源的多重占用。设置全局访问点,严格控制访问。

    缺点:没有接口,扩展困难。

    重点:私有构造器。线程安全。延迟加载。序列化和反序列化安全。反射。

    十三、原型模式

    定义:指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。不需要知道任何创建的细节,不调用构造函数

    适用场景:类初始化消耗较多资源。new产生的一个对象需要非常繁琐的过程(数据准备、访问权限等)。构造函数比较复杂。循环体中产生大量对象时。

    优点:原型模式性能比直接new一个对象性能高。简化创建过程。

    缺点:必须配备克隆方法。对克隆复杂对象或对克隆出的对象进行复杂改造时,容易引入风险。深拷贝、浅拷贝要运用得当。

    十四、外观模式

    定义:又叫门面模式,提供了一个统一的接口,用来访问子系统中的一群接口。外观模式定义了一个高层接口,让子系统更容易使用。

    使用场景:子系统越来越复杂,增加外观模式提供简单调用接口。构建多层系统结构,利用外观对象作为每层的入口,简化层间调用。

    优点:简化了调用过程,无需了解深入子系统,防止带来风险。减少系统依赖、松散耦合。更好的划分访问层次。符合迪米特法则,即最少知道原则。

    缺点:增加子系统、扩展子系统行为容易引入风险。不符合开闭原则。

    十五、装饰者模式

    定义:在不改变原有对象的基础上,将功能附加到对象上。提供了比继承更有弹性的替代方案(扩展原有对象功能)。

    优点:继承的有力补充,比继承灵活,不改变原有对象的情况下给一个对象扩展功能。通过使用不同装饰类以及这些装饰类的排列组合,可以实现不同的效果。符合开闭原则。

    缺点:会出现更多的代码,更多的类,增加程序复杂性。动态装饰时,多层装饰时会更复杂。

    十六、适配器模式

    定义:将一个类的接口转换成客户期望的另一个接口。使原本接口不兼容的类可以一起工作。

    适用场景:已经存在的类,它的方法和需求不匹配时(方法结果相同或相似)。不是软件设计阶段考虑的设计模式,是随着软件维护,由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。

    优点:能提高类的透明性和复用,现有的类复用但不需要改变。目标类和适配器类解耦,提高程序扩展性。符合开闭原则。

    缺点:适配器编写过程需要全面考虑,可能会增加系统的复杂性。增加系统代码可读的难度。

    十七、享元模式

    定义:提供了减少对象数量从而改善应用所需的对象结构的方式。运用共享技术有效地支持大量细粒度的对象

    适用场景:常常应用于系统底层的开发,以便解决系统的性能问题。系统有大量相似对象、需要缓冲池的场景。

    优点:减少对象的创建,降低内存中对象的数量,降低系统的内存,提高效率。减少内存之外的其他资源占用。

    缺点:关注内/外部状态、关注线程安全问题。使系统、程序的逻辑复杂化。

    十八、组合模式

    定义:将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式是客户端对单个对象和组合对象保持一致的方式处理。

    适用场景:希望客户端可以忽略组合对象与单个对象的差异时。处理一个树形结构时。

    优点:清楚地定义分层次的复杂对象,表示对象的全部或部分层次。让客户端忽略了层次的差异,方便对整个层次结构进行控制。简化客户端代码。符合开闭原则。

    缺点:限制类型时会较为复杂。使设计变得更加抽象。

    十九、桥接模式

    定义:将抽象部分与它的具体实现部分分离,使它们都可以独立地变化。通过组合的方式建立两个类之间关系,而不是继承。

    适用场景:抽象和具体实现之间增加更多的灵活性。一个类存在两个(或多个)独立变化的维度,且这两个(或多个)维度都需要独立进行拓展。不希望使用继承,或因为多层继承导致系统类的个数剧增。

    优点:分离抽象部分及其具体实现部分。提高了系统的可扩展性。符合开闭原则。符合合成复用原则。

    缺点:增加了系统的理解与设计难度。需要正确地识别出系统中两个独立变化的维度。

    二十、代理模式

    定义:为其他对象提供一种代理,以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。

    适用场景:保护目标对象。增强目标对象。

    优点:代理模式能将代理对象与真实被调用的目标对象分离。一定程度上降低了系统的耦合度,扩展性好。保护目标对象。增强目标对象。

    缺点:代理模式会造成系统设计中类的数目增加。在客户端和目标对象增加一个代理对象,会造成请求处理速度变慢。增加系统的复杂度。

    二十一、模板模式

    定义:定义了一个算法的骨架,并允许子类为一个或多个步骤提供实现。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法的某些步骤。

    适用场景:一次性实现一个算法的不变的部分,并将可变的行为留给子类来实现。各子类中公共的行为被提取出来并集中到一个公共父类中,从而避免代码重复。

    优点:提高复用性,提高扩展性,符合开闭原则。

    缺点:类数目增加。增加了系统实现的复杂度。继承关系自身缺点,如果父类添加新的抽象方法,所有子类都要改一遍。

    二十二、迭代器模式

    定义:提供一种方法,顺序访问一个集合对象中的各个元素,而又不暴露该对象的内部表示。

    适用场景:访问一个集合对象的内容而无需暴露它的内部表示。为遍历不同的集合结构提供一个统一的接口。

    优点:分离了集合对象的遍历行为。

    缺点:类的个数成对增加。

    二十三、策略模式

    定义:定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化不会影响到使用算法的用户。

    适用场景:系统有很多类,而它们的区别仅仅在于它们的行为不同。一个系统需要动态地在几种算法中选择一种。

    优点:符合开闭原则。避免使用多重条件转移语句。提高算法的保密性和安全性。

    缺点:客户端必须知道所有的策略类,并自行决定使用哪一个策略类。产生很多策略类。

    二十四、解释器模式

    定义:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。为了解释一种语言,而为语言创建的解释器。

    适用场景:某个特定类型问题发生频率足够高。

    优点:语法由很多类表示,容易改变及扩展此"语言"。

    缺点:当语法规则数目太多时,增加了系统复杂度。

    二十五、观察者模式

    定义:定义了对象之间的一对多依赖,让多个观察者对象同时监听某一个主题对象,当主题对象发生变化时,它的所有依赖者(观察者)都会收到通知并更新。

    适用场景:关联行为场景,建立一套触发机制。

    优点:观察者和被观察者之间建立一个抽象的耦合。观察者模式支持广播通信。

    缺点:观察者之间有过多的细节依赖、提高时间消耗及程序复杂度。使用要得当,要避免循环调用。

    二十六、备忘录模式

    定义:保存一个对象的某个状态,以便在适当的时候恢复对象。“没有后悔药”。“存档”。

    适用场景:保存及恢复数据相关业务场景。后悔的时候,即想恢复到之前的状态。

    优点:为用户提供一种可恢复机制。存档信息的封装。

    缺点:资源占用。

    二十七、命令模式

    定义:将"请求"封装成对象,以便使用不同的请求。命令模式解决了应用程序中对象的职责以及它们之间的通信方式。

    适用场景:请求调用者和请求接收者需要解耦,使得调用者和接受者不直接交互。需要抽象出等待执行的行为。

    优点:降低耦合。容易扩展新命令或一组命令。

    缺点:命令的无限扩展会增加类的数量,提高系统实现复杂度。

    二十八、中介者模式

    定义:定义一个封装一组对象如何交互的对象。通过使对象明确地相互引用来促进松散耦合,并允许独立的改变它们的交互。

    适用场景:系统中对象之间存在复杂的引用关系,产生的相互依赖关系结构混乱且难以理解。交互的公共行为,如果需要改变行为则可以增加新的中介类。

    优点:将一对多转换成了一对一,降低程序复杂度。类之间解耦。

    缺点:中介者过多,导致系统复杂。

    二十九、责任链模式

    定义:为请求创建一个接受此次请求对象的链。

    适用场景:一个请求的处理需要多个对象当中的一个或几个协作处理。

    优点:请求的发送者和接受者(请求的处理)解耦。责任链可以动态组合。

    缺点:责任链太长或者处理时间过长,影响性能。责任链有可能过多。

    三十、访问者模式

    定义:封装作用于某数据结构(如List/Set/Map等)中的各元素的操作。可以在不改变各元素的类的前提下,定义作用于这些元素的操作。

    适用场景:一个数据结构如(List/Set/Map等)包含很多类型对象。数据结构与数据操作相分离。

    优点:增加新的操作很容易,即增加一个新的访问者。

    缺点:增加新的数据结构困难。具体元素变更比较麻烦。

    三十一、状态模式

    定义:允许一个对象在其内部状态改变时,改变它的行为。

    适用场景:一个对象存在多个状态(不同状态下行为不同),且状态可相互转换。

    优点:将不同的状态隔离。把各个状态的转换逻辑,分布到State的子类中,减少相互间依赖。增加新的状态很简单。

    缺点:状态多的业务场景导致类数目增加,系统变复杂。

     

    展开全文
  • 各个设计模式的优缺点

    千次阅读 2015-11-02 14:04:47
    设计原则 1、找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化代码混在一起。 2、针对接口编程(实际上是针对超类编程),而不是针对实现编程。 策略模式(Strategy Pattern) 优点: 缺点:1....
  • 转载请注明出处:http://blog.csdn.net/woshizisezise/article/details/50358924单例模式是运用频率很高的模式,但是,由于在客户端通常没有...1.Double Check Lock(DCL)实现单例DCL方式实现单例模式的优点是既能够在需
  • 原始模式: var Car = new Object; Car.color = "blue"; Car.door = 4; Car.showColor = function() { alert(this.color); } Car.showColor(); //"blue"; 原理:声明对象,后续给对象加属性和方法 优点:可以...
  • 编程以来就一直被灌输MVC设计模式,具体MVC使用到底好在哪里 又有那些不足之处,可以通过下面文章得以了解。 一、mvc原理  mvc是一种程序开发设计模式,它实现了显示模块与功能模块分离。提高了程序可维护...
  • 转自:http://www.cnblogs.com/WebYan/p/6066191.html#commentform 原始模式: 1 var Car = new Object; 2 3 Car.color = "blue"; 4 Car.door = 4; 5 Car.showColor = function() { 6 ale...
  • 主要介绍了C++设计模式编程中策略模式的优缺点及实现,文中讨论了策略模式中设计抽象接口的继承和组合之间的区别,需要的朋友可以参考下
  • 2013-03-21整理出来的23个设计模式的优缺点,部分地方的理解可能不是很到位。 简单的介绍了23个设计模式的优点和缺点,以及使用场景,同时举了该设计模式的经典例子。
  • 设计模式及其优缺点

    千次阅读 2018-06-29 16:31:10
    设计模式 1.单例模式: 实现方式: a) 将被实现构造方法设计成private。 b) 添加此类引用静态成员变量,并为其实例化。 c) 在被实现类中提供公共CreateInstance函数,返回实例化此类,就是b...
  • 单例模式(Singleton),也叫单子模式,是一种常用软件设计模式。在应用这个模式时,单例对象类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象,这样有利于我们协调系统整体行为。 比如在...
  • 设计模式优缺点(二)

    热门讨论 2018-02-06 09:37:01
    前言上篇博客描述的是创建型模式和结构型模式中的模式的优缺点及适用场景,接下来就再学习一下行为型模式中模式的优缺点和适用场景吧。正文1. 观察者模式优点:松耦合,使各自的变化不会影响另一边的变化 缺点:不...
  • 八种架构设计模式及其优缺点概述

    千次阅读 2017-04-11 09:15:31
    八种架构设计模式及其优缺点概述, 单库单应用模式:最简单的,可能大家都见过 内容分发模式:目前用的比较多 查询分离模式:对于大并发的查询、业务 微服务模式:适用于复杂的业务模式的拆解 多级缓存...
  • 单例模式的实现 什么是单例设计模式? 单例模式,是一种常用的软件设计模式。它的核心思想是指,一个类只允许产生一个实例化对象。 单例设计模式实现要求: 1、构造方法私有化,保证在类的外部不能通过使用new关键字...
  • 这个问题我问过面试者不下于数十次,回答五花八门,在我看来,模式就是经验,设计模式就是设计经验,有了这些经验,我们就能在特定情况下使用特定设计、组合设计,这样可以大大节省我们设计时间,提..
  • 原型模式多用于创建复杂或者构造耗时实例,因为这种情况下,复制一个已经存在实例可使程序运行更高效。原型模式是用于创建重复对象,同时又能保证性能。,原型模式提供了一种创建对象最佳方式。这种模式是...
  • 设计模式优缺点(一)

    千次阅读 热门讨论 2018-02-05 17:26:08
    前言什么东西,什么事物都是有正反两面设计模式也不例外,也是既有优点,又有缺点,当然也有该用它场合。正文1. 工厂方法模式优点:使用工厂方法模式,创建客户所需产品,用户只需关心产品对应工厂,其他都...
  • 单例模式的优缺点

    千次阅读 2018-05-15 20:40:00
    http://www.tools138.com/create/article/20150929/020009847.html单利模式的优缺点和使用场景 首先介绍一下单例模式: 单例模式(Singleton),也叫单子模式,是一种常用的软件设计模式。在应用这个模式时,单例...
  • 1 简单工厂模式(Static Factory Method) ...工厂类是整个模式的关键。包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。 通过使用工厂类,外界可以从直接创建具体产品对象的尴...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,299
精华内容 1,719
关键字:

设计模式的优缺点