精华内容
下载资源
问答
  • 软件设计模式深入理解

    千次阅读 2020-09-16 13:42:43
    设计模式1、设计模式基本要素4个主要部分2、按照目的分类 1、设计模式基本要素4个主要部分 该模式名称使用什么解决方案去解决了什么问题会产生什么样的效果 2、按照目的分类

    1、设计模式基本要素4个主要部分

    模式名称使用什么解决方案去解决了什么问题会产生什么样的效果

    2、按照目的分类

    在这里插入图片描述

    展开全文
  • 软件设计模式(概念理解学习)

    千次阅读 2015-03-05 11:53:57
    使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的;设计模式使代码编制真正工程化;设计模式软件工程的基石脉络,如同大厦的结构一样。 ...

    概述

    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的;设计模式使代码编制真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。

    设计框架

    可复用面向对象软件系统一般划分为两大类:应用程序工具箱和框架(Framework),我们平时开发的具体软件都是应用程序,Java的API属于工具箱;而框架是构成一类特定软件可复用设计的一组相互协作的类,EJB(EnterpriseJavaBeans)是Java应用于企业计算的框架
    框架通常定义了应用体系的整体结构类和对象的关系等等设计参数,以便于具体应用实现者能集中精力于应用本身的特定细节。框架主要记录软件应用中共同的设计决策,框架强调设计复用,因此框架设计中必然要使用设计模式。
    另外,设计模式有助于对框架结构的理解,成熟的框架通常使用了多种设计模式,如果你熟悉这些设计模式,毫无疑问,你将迅速掌握框架的结构,我们一般开发者如果突然接触EJB、Spring等框架,会觉得特别难学、难掌握,那么转而先掌握设计模式,无疑是给了你剖析EJB或J2EE系统的一把利器。

    设计原则
    为什么要提倡“Design Pattern呢?根本原因是为了代码复用,增加可维护性。那么怎么才能实现代码复用呢?面向对象有几个原则:开闭原则(Open Closed Principle,OCP)、里氏代换原则(Liskov Substitution Principle,LSP)、依赖倒转原则(Dependency Inversion Principle,DIP)、接口隔离原则(Interface Segregation Principle,ISP)、合成/聚合复用原则(Composite/Aggregate Reuse Principle,CARP)、最小知识原则(Principle of Least Knowledge,PLK,也叫迪米特法则)。开闭原则具有理想主义的色彩,它是面向对象设计的终极目标。其他几条,则可以看做是开闭原则的实现方法。
    设计模式就是实现了这些原则,从而达到了代码复用、增加可维护性的目的。

    开闭原则
    此原则是由Bertrand Meyer提出的。原文是:“Software entities should be open for extension,but closed for modification”。就是说模块应对扩展开放,而对修改关闭。模块应尽量在不修改原(是“原”,指原来的代码)代码的情况下进行扩展。
    里氏代换原则
    里氏代换原则是由Barbara Liskov提出的。如果调用的是父类的话,那么换成子类也完全可以运行。
    可以说:里氏代换原则是继承复用的一个基础。
    依赖倒转原则
    抽象不应该依赖于细节,细节应当依赖于抽象。
    要针对接口编程,而不是针对实现编程。
    传递参数,或者在组合聚合关系中,尽量引用层次高的类。
    主要是在构造对象时可以动态的创建各种具体对象,当然如果一些具体类比较稳定,就不必在弄一个抽象类做它的父类,这样有画蛇添足的感觉
    合成/聚合复用原则
    合成/聚合复用原则(Composite/Aggregate Reuse Principle,CARP)经常又叫做合成复用原则。合成/聚合复用原则就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过向这些对象的委派达到复用已有功能的目的。它的设计原则是:要尽量使用合成/聚合,尽量不要使用继承。
    就是说要少用继承,多用合成关系来实现。我曾经这样写过程序:有几个类要与数据库打交道,就写了一个数据库操作的类,然后别的跟数据库打交道的类都继承这个。结果后来,我修改了数据库操作类的一个方法,各个类都需要改动。“牵一发而动全身”!面向对象是要把波动限制在尽量小的范围。
    接口隔离原则
    定制服务的例子,每一个接口应该是一种角色,不多不少,不干不该干的事,该干的事都要干。
    最少知识原则
    也叫迪米特法则。不要和陌生人说话,即一个对象应对其他对象有尽可能少的了解。


    设计模式分为三种类型,共23种
    创建型模式:单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
    结构型模式:适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
    行为型模式:模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。


    Abstract Factory(抽象工厂模式):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
    Adapter(适配器模式):将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
    Bridge(桥接模式):将抽象部分与它的实现部分分离,使它们都可以独立地变化。
    Builder(建造者模式):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
    Chain of Responsibility(职责链模式):为解除请求的发送者和接收者之间耦合,而使多个对象都有机会处理这个请求。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它。
    Command(命令模式):将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可取消的操作。
    Composite(组合模式):将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。
    Decorator(装饰模式):动态地给一个对象添加一些额外的职责。就扩展功能而言, 它比生成子类方式更为灵活。
    Facade(外观模式):为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
    Factory Method(工厂模式):定义一个用于创建对象的接口,让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。
    Flyweight(享元模式):运用共享技术有效地支持大量细粒度的对象。
    Interpreter(解析器模式):给定一个语言, 定义它的文法的一种表示,并定义一个解释器, 该解释器使用该表示来解释语言中的句子。
    Iterator(迭代器模式):提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示。
    Mediator(中介模式):用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
    Memento(备忘录模式):在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。
    Observer(观察者模式):定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。
    Prototype(原型模式):用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象。
    Proxy(代理模式):为其他对象提供一个代理以控制对这个对象的访问。
    Singleton(单例模式):保证一个类仅有一个实例,并提供一个访问它的全局访问点。 单例模式是最简单的设计模式之一,但是对于Java的开发者来说,它却有很多缺陷。在九月的专栏中,David Geary探讨了单例模式以及在面对多线程(multi-threading)、类装载器(class loaders)和序列化(serialization)时如何处理这些缺陷。
    State(状态模式):允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。
    Strategy(策略模式):定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。
    Template Method(模板方法模式):定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
    Visitor(访问者模式):表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。


    展开全文
  • 深入理解设计模式-单例模式

    万次阅读 多人点赞 2021-05-08 16:40:26
    单例模式是一种常用的软件设计模式,其定义是单例对象的类只能允许一个实例存在。 许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放...

    深入理解设计模式-双锁单例模式


    一、什么是单例模式

    单例模式是一种常用的软件设计模式,其定义是单例对象的类只能允许一个实例存在。
    许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

    在这里插入图片描述


    二、应用场景

    举一个例子,网站的计数器,一般也是采用单例模式实现,如果你存在多个计数器,每一个用户的访问都刷新计数器的值,这样的话你的实计数的值是难以同步的。但是如果采用单例模式实现就不会存在这样的问题,而且还可以避免线程安全问题。同样多线程的线程池的设计一般也是采用单例模式,这是由于线程池需要方便对池中的线程进行控制 同样,对于一些应用程序的日志应用,或者web开发中读取配置文件都适合使用单例模式,如HttpApplication 就是单例的典型应用。 从上述的例子中我们可以总结出适合使用单例模式的场景和优缺点: 适用场景: 1.需要生成唯一序列的环境 2.需要频繁实例化然后销毁的对象。 3.创建对象时耗时过多或者耗资源过多,但又经常用到的对象。 4.方便资源相互通信的环境

    三、优缺点

    优点:
    1.在内存中只有一个对象,节省内存空间;
    2.避免频繁的创建销毁对象,可以提高性能;
    3.避免对共享资源的多重占用,简化访问;
    4.为整个系统提供一个全局访问点。
    缺点:
    1.不适用于变化频繁的对象;
    2.滥用单例将带来一些负面问题,如为了节省资源将数据库连接池对象设计为的单例类,可能会导致共 享连接池对象的程序过多而出现连接池溢出;
    4.如果实例化的对象长时间不被利用,系统会认为该对象是垃圾而被回收,这可能会导致对象状态的丢失;


    四、代码实现

    饿汉单例模式

    public class Singleton1 {
        private static Singleton1 instance = new Singleton1();
    
        private Singleton1(){}
    
        public static Singleton1 getInstance(){
            return instance;
        }
    }
    

    类加载的方式是按需加载,且加载一次。。因此,在上述单例类被加载时,就会实例化一个对象并交给自己的引用,供系统使用;而且,由于这个类在整个生命周期中只会被加载一次,因此只会创建一个实例,即能够充分保证单例,这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。

    懒汉单例模式

    public class Singleton2 {
        private static Singleton2 instance;
    
        private Singleton2(){}
    
        public static Singleton2 getInstance(){
            if (instance == null) {
                instance = new Singleton2();
            }
            return instance;
        }
    }
    

    我们从懒汉式单例可以看到,单例实例被延迟加载,即只有在真正使用的时候才会实例化一个对象并交给自己的引用。
    这种写法起到了Lazy Loading的效果,但是只能在单线程下使用。如果在多线程下,一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

    双锁单例模式

    public class Singleton {
        private volatile static Singleton instance;
        private Singleton (){}
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
    

    双锁模式,进行了两次的判断,第一次是为了避免不要的实例,第二次是为了进行同步,避免多线程问题。由于singleton=new Singleton()对象的创建在JVM中可能会进行重排序,在多线程访问下存在风险,使用volatile修饰signleton实例变量有效,解决该问题。


    总结

    单例模式的实现方法还有很多。上述是比较经典的实现方式,也是我们应该掌握的几种实现方式。
    从这四种实现中,我们可以总结出,要想实现效率高的线程安全的单例,我们必须注意以下两点:
    1.尽量减少同步块的作用域;
    2.尽量使用细粒度的锁。

    展开全文
  • 软件设计模式详解

    万次阅读 多人点赞 2018-11-07 21:40:21
    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 ...

    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性

    简介

    设计模式(英语 design pattern)是对面向对象设计中反复出现的问题的解决方案。这个术语是在1990年代由Erich Gamma等人从建筑设计领域引入到计算机科学中来的。这个术语的含义还存有争议。算法不是设计模式,因为算法致力于解决问题而非设计问题。设计模式通常描述了一组相互紧密作用的类与对象。设计模式提供一种讨论软件设计的公共语言,使得熟练设计者的设计经验可以被初学者和其他设计者掌握。设计模式还为软件重构提供了目标。

    随着软件开发社群对设计模式的兴趣日益增长,已经出版了一些相关的专著,定期召开相应的研讨会,而且Ward Cunningham为此发明了WikiWiki用来交流设计模式的经验。

    历史

    肯特·贝克和沃德·坎宁安在1987年利用克里斯托佛·亚历山大在建筑设计领域里的思想开发了设计模式并把此思想应用在Smalltalk中的图形用户接口的生成中。一年后Erich Gamma在他的苏黎世大学博士毕业论文中开始尝试把这种思想改写为适用于软件开发。于此同时James Coplien 在1989年至1991 年也在利用相同的思想致力于C++的开发,而后于1991年发表了他的著作Advanced C++ Idioms。就在这一年Erich Gamma 得到了博士学位,然后去了美国,在那与Richard Helm, Ralph Johnson ,John Vlissides合作出版了Design Patterns - Elements of Reusable Object-Oriented Software 一书,在此书中共收录了23个设计模式。这四位作者在软件开发领域里也以他们的匿名著称Gang of Four(四人帮,简称GoF),并且是他们在此书中的协作导致了软件设计模式的突破。有时这个匿名GoF也会用于指代前面提到的那本书。

    模式格式

    尽管名称和顺序在不同的资料中各有不同,描述模式的格式大致分为以下四个主要部分:

    模式名称(Pattern Name):每一个模式都有自己的名字,模式的名字使得我们可以讨论我们的设计。

    问题(Problem):在面向对象的系统设计过程中反复出现的特定场合,它导致我们采用某个模式。

    解决方案(Solution):上述问题的解决方案,其内容给出了设计的各个组成部分,它们之间的关系、职责划分和协作方式

    效果(Consequence):采用该模式对软件系统其他部分的影响,比如对系统的扩充性、可移植性的影响。影响也包括负面的影响。

    别名(Also Known As):一个模式可以有超过一个以上的名称。这些名称应该要在这一节注明。

    动机(Motivation):该模式应该利用在哪种情况下是本节提供的方案(包括问题与来龙去脉)的责任。

    应用(Applicability)

    结构(Structure):这部分常用类图与互动图阐述此模式。

    参与者(Participants):这部分提供一份本模式用到的类与物件清单,与它们在设计下扮演的角色。

    合作(Collaboration):描述在此模式下,类与物件间的互动。

    结果(Consequences):这部分应描述使用本模式後的结果、副作用、与交换(trade-off)

    实现(Implementaion):这部分应描述实现该模式、该模式的部分方案、实现该模式的可能技术、或者建议实现模式的方法。

    例程(Sample Code):示范程式。

    已知应用(Known Uses):业界已知的实做范例。

    相关模式(Related Patterns):这部分包括其他相关模式,以及与其他类似模式的不同。

    模式列表

           设计模式分为三大类:创建型、结构型、行为型。创建型模式处理的是对象的创建过程(通过各种方式创建对象,使对象创建和管理变得简单),结构型模式处理的是对象/类的组合,行为型模式处理类和对象间的交互方式和任务分布(只有类可以创建对象,接口只能被实现)

    创建型

    抽象工厂模式(Abstract Factory)

           抽象工厂模式是提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。区别于工厂方法模式的地方,工厂方法模式是创建一个工厂,可以实现多种对象;而抽象工厂模式是提供一个抽象工厂接口,里面定义多种工厂,每个工厂可以生产多种对象前者的重点在于"怎么生产",后者的重点在于"生产哪些";前者是一个抽象产品类,可以派生出多个具体产品类,后者是多个抽象产品类,每个抽象产品类可以派生出多个具体产品类;前者的每个具体工厂类只能创建一个具体产品类的实例,后者的每个具体工厂类可以创建多个具体产品类的实例。

    工厂方法模式(Factory Method)

           工厂方法模式的创建是因为简单工厂模式有一个问题,在简单工厂模式中类的创建依赖工厂类,如果想要拓展程序,必须对工厂类进行修改,这违背了开闭原则,所以就出现了工厂方法模式,只需要创建一个工厂接口和多个工厂实现类,子类可以自己决定实例化哪一个工厂类,client类针对抽象接口进行编程,如果需要增加新的功能,继承工厂接口,直接增加新的工厂类就可以了,创建过程延迟到子类中进行,不需要修改之前的代码,满足了开闭原则,达到灵活地生产多种对象。。

    原型模式 (Prototype)

           原型模式是用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。其实就是将对象复制了一份并返还给调用者,对象需继承Cloneable并重写clone()方法。原型模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。分为浅复制和深复制,前者是将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的;后者是将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。

    单例模式(Singleton)

           单例模式能保证一个类仅有一个实例,并提供一个访问它的全局访问点,同时在类内部创造单一对象,通过设置权限,使类外部无法再创造对象。单例对象能保证在一个JVM中,该对象只有一个实例存在,这样做的好处就在于如果某些类创建比较频繁,特别是对于一些大型的对象,这是一笔很大的系统开销。在创建的时候,省去了new操作符,降低了系统内存的使用频率,减轻了系统的压力。同时单例模式保证在一个jvm中仅存在一个实例的好处就在于好比一个军队当中只会存在一个最高级别的军官来指挥整个军队,这样才能保证独立控制整个过程,否则如果出现多个,肯定会杂乱无序。

    建造者模式(Builder)

           建造者模式是将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示,就好比是每个饭店或者每家都会做西红柿炒鸡蛋,最后虽然都是西红柿炒鸡蛋的外观,但是由于当中的做饭过程存在差别,所以味道会不同。在程序当中就是将一些不会变的基本组件,通过builder来进行组合,构建复杂对象,实现分离。这样做的好处就在于客户端不必知道产品内部组成的细节;同时具体的建造者类之间是相互独立的,对系统的扩展非常有利,满足开闭原则;由于具体的建造者类是独立的,因此可以对建造过程逐步细化,而不对其他的模块产生任何影响。

    结构型

    适配器模式 (Adapter)

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

    桥接模式(Bridge)

           桥接模式是将抽象部分与实现部分分离,使它们都可以独立的变化。桥接模式就是把事物和其具体实现分开,使他们可以各自独立的变化(突然联想到了mvc模式)。将抽象化与实现化解耦,使得二者可以独立变化,就好比现在常说的mvc模式,view和model之间通过control来控制,达到高内聚低耦合来解耦的目的。

    组合模式(Composite)

           组合模式是将对象组合成树形结构以表示"部分-整体"的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。创建了一个包含自己对象组的类,并提供修改对象组的方法。在系统的文件和文件夹的问题上就使用了组合模式,文件下不可以有对象,而文件夹下可以有文件对象或者文件夹对象。

    修饰模式 (Decorator)

           装饰器模式是动态地给一个对象添加一些额外的职责,给一个对象增加一些新的功能,要求装饰对象和被装饰对象实现同一个接口,装饰对象持有被装饰对象的实例。除了动态的增加,也可以动态的撤销,要做到动态的形式,不可以用继承实现,因为继承是静态的。

    外观模式

           外观模式是为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。在客户端和复杂系统之间再加一层,提供一个容易使用的外观层。外观模式是为了解决类与类之间的依赖关系的,外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,比如搜狐门户网站,就利用了外观模式。

    享元模式

           享元模式是运用共享技术有效地支持大量细粒度的对象。享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,重用现有的同类对象,若未找到匹配的对象,则创建新对象,这样可以减少对象的创建,降低系统内存,提高效率。

    代理模式(Proxy)

            代理模式是为其他对象提供一种代理以控制对这个对象的访问,也就是创建类的代理类,间接访问被代理类的过程中,对其功能加以控制。它和装饰器模式的区别在于,装饰器模式为了增强功能,而代理模式是为了加以控制。代理模式就是多一个代理类出来,替原对象进行一些操作,例如买火车票不一定在火车站买,也可以去代售点。再比如打官司需要请律师,因为律师在法律方面有专长,可以替我们进行操作。

    行为模式

    责任链模式 (Chain of Responsibility)

           责任链模式是避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求。在生活中学生进行请假的过程中,会涉及到,学生请假会一级一级往上批,最终处理,具体由谁批准可能不清楚。在程序当中,现在使用的struts拦截器即用到了责任链模式

    命令模式 (Command)

           命令模式是将一个请求封装成一个对象,从而使发出者可以用不同的请求对客户进行参数化。模式当中存在调用者、接收者、命令三个对象,实现请求和执行分开;调用者选择命令发布,命令指定接收者。举个例子,司令员下令让士兵去干件事情,司令员的作用是发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。司令士兵命令三者相互解耦,任何一方都不用去依赖其他人。其实struts框架也涉及到命令模式的思想。

    解释器模式(Interpreter)

           解释器模式是给定一个语言,定义它的文法表示,并定义一个解释器,这个解释器使用该标识来解释语言中的句子,基本也就用在这个范围内,适用面较窄,例如:正则表达式的解释等。

    迭代器模式(Iterator)

           迭代器模式是提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。在Java当中,将聚合类中遍历各个元素的行为分离出来,封装成迭代器,让迭代器来处理遍历的任务;使简化聚合类,同时又不暴露聚合类的内部,在我们经常使用的JDK中各个类也都是这些基本的东西。

    中介者模式(Mediator)

           中介者模式是用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。例如,MVC模式中control就是model和view的中介者。与适配器区别在于,适配器是为了兼容不同的接口,而中介者是为了将显示和操作分离

    备忘录模式 (Memento)

           备忘录模式是在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。创建一个备忘录类,用来存储原始类的信息;同时创建备忘录仓库类,用来存储备忘录类,主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,也就是做个备份。在系统当中使用的撤销操作,即是使用了备忘录模式,系统可以保存有限次数的文件状态,用户可以进行上几个状态的恢复,也就是用到了备忘录模式。

    观察者模式(Observer)

           观察者模式是定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。也就是当被观察者状态变化时,通知所有观察者,这种依赖方式具有双向性,在QQ邮箱中的邮件订阅和RSS订阅,当我们浏览一些博客时,经常会看到RSS图标,意思就是,当你订阅了该文章,如果后续有更新,会及时通知你。这种现象即是典型的观察者模式。

    状态模式 (State)

           状态模式是允许对象在内部状态发生改变时改变它的行为。对象具有多种状态,且每种状态具有特定的行为。在网站的积分系统中,用户具有不同的积分,也就对应了不同的状态;还有QQ的用户状态有几种状态,在线、隐身、忙碌等,每个状态对应不同的操作,而且你的好友也能看到你的状态。

    策略模式 (Strategy)

           策略模式是定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换,且算法的变化不会影响到使用算法的客户。是为了统一接口下的一系列算法类(也就是多种策略),用一个类将其封装起来,使这些策略可动态切换。策略模式属于行为型模式,是为了使这些策略可以相互切换,是为了选择不同的行为。

    模板方法模式(Template Method)

           模板方法模式是定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。该模式就是在一个抽象类中,有一个主方法,再定义1...n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤,将一些固定步骤、固定逻辑的方法封装成模板方法。调用模板方法即可完成那些特定的步骤。

    访问者模式 (Visitor)

           访问者模式主要是将数据结构与数据操作分离。在被访问的类里面加一个对外提供接待访问者的接口,访问者封装了对被访问者结构的一些杂乱操作,解耦结构与算法,同时具有优秀的扩展性。通俗来讲就是一种分离对象数据结构与行为的方法,通过这种分离,可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。访问者模式的优点是增加操作很容易,因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中,其改变不影响系统数据结构。

    模式原则

    大家都开始注意设计模式。那么,到底我们为什么要用设计模式呢?这么多设计模式为什么要怎么设计呢?说实话,以前我还真没搞清楚。就是看大家一口一个"Design pattern",心就有点发虚。于是就买了本"四人帮"的设计模式,结果看得似懂非懂:看得时候好像是懂了,过一会就忘了。可能是本人比较"愚钝"吧:))最近,有了点感悟。"独乐不如众乐",与大家分享一下,还望指教! 为什么要提倡"Design Pattern"呢?根本原因是为了代码复用,增加可维护性。那么怎么才能实现代码复用呢?OO界有前辈的几个原则:"开-闭"原则(Open Closed Principal)、里氏代换原则、合成复用原则。设计模式就是实现了这些原则,从而达到了代码复用、增加可维护性的目的。

    开-闭原则

    此原则是由"Bertrand Meyer"提出的。原文是:"Software entities should be open for extension,but closed for modification"。就是说模块应对扩展开放,而对修改关闭。模块应尽量在不修改原(是"原",指原来的代码)代码的情况下进行扩展。那么怎么扩展呢?我们看工厂模式"factory pattern":假设中关村有一个卖盗版盘和毛片的小子,我们给他设计一"光盘销售管理软件"。我们应该先设计一"光盘"接口。而盗版盘和毛片是其子类。小子通过"DiscFactory"来管理这些光盘。代码为:

    public class DiscFactory{
        public static 光盘 getDisc(String name){
            return(光盘)Class.forName(name).getInstance();
        }
    }

    有人要买盗版盘,怎么实现呢?

    public class 小子{ 
        public static void main(String[] args){ 
            光盘 d=DiscFactory.getDisc("盗版盘"); 
            光盘.卖(); 
        } 
    }

    如果有一天,这小子良心发现了,开始卖正版软件。没关系,我们只要再创建一个"光盘"的子类"正版软件"就可以了。不需要修改原结构和代码。怎么样?对扩展开放,对修改关闭。"开-闭原则" 工厂模式是对具体产品进行扩展,有的项目可能需要更多的扩展性,要对这个"工厂"也进行扩展,那就成了"抽象工厂模式"。

    里氏代换原则

    里氏代换原则是由"Barbara Liskov"提出的。如果调用的是父类的话,那么换成子类也完全可以运行。比如: 光盘 d=new 盗版盘(); d.卖(); 要将"盗版盘"类改为"毛片"类,没问题,完全可以运行。Java编译程序会检查程序是否符合里氏代换原则。还记得java继承的一个原则吗?子类override方法的访问权限不能小于父类对应方法的访问权限。比如"光盘"中的方法"卖"访问权限是"public",那么"盗版盘"和"毛片"中的"卖"方法就不能是protected或private,编译不能通过。为什么要这样呢?你想啊:如果"盗版盘"的"卖"方法是private。那么下面这段代码就不能执行了: 光盘 d=new 盗版盘(); d.卖();可以说:里氏代换原则是继承复用的一个基础。

    合成复用原则

    就是说要少用继承,多用合成关系来实现。我曾经这样写过程序:有几个类要与数据库打交道,就写了一个数据库操作的类,然后别的跟数据库打交道的类都继承这个。结果后来,我修改了数据库操作类的一个方法,各个类都需要改动。"牵一发而动全身"!面向对象是要把波动限制在尽量小的范围

    在Java中,应尽量针对Interface编程,而非实现类。这样,更换子类不会影响调用它方法的代码。要让各个类尽可能少的跟别人联系,"不要与陌生人说话"。这样,城门失火,才不至于殃及池鱼。扩展性和维护性才能提高

    理解了这些原则,再看设计模式,只是在具体问题上怎么实现这些原则而已。张无忌太极拳,忘记了所有招式,打倒了"玄幂二老",所谓"心中无招"。设计模式可谓招数,如果先学通了各种模式,又忘掉了所有模式而随心所欲,可谓OO之最高境界。

    依赖倒转原则

    要针对接口编程,而不是针对实现编程。传递参数,或者在组合聚合关系中,尽量引用层次高的类。主要是在构造对象时可以动态的创建各种具体对象,当然如果一些具体类比较稳定,就不必在弄一个抽象类做它的父类,这样有画舌添足的感觉。

    接口隔离原则

    一种角色,不多不少,不干不该干的事,该干的事都要干

    抽象类

    抽象类抽象类不会有实例,类为子类继承,一般包含这个类的共同属性和方法。注意:好的继承关系中,只有叶节点是具体类,其他节点应该都是抽象类,也就是说具体类是不被继承的。将尽可能多的共同代码放到抽象类中。 

    展开全文
  • 常用设计模式总结

    万次阅读 多人点赞 2019-07-31 19:13:12
    使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式软件工程的基石,如同大厦的一块块砖石一样。...
  • 深入理解设计模式-设计模式七大原则

    千次阅读 多人点赞 2021-05-26 09:44:41
    深入理解设计模式-设计模式七大原则 文章目录前言一、单一职责原则1.基本介绍2.注意事项和细节二、接口隔离原则1.基本介绍三、依赖倒转原则1.基本介绍2.注意事项和细节四、里氏替换原则1.基本介绍五、开闭原则1....
  • 几种常见设计模式理解

    千次阅读 2015-08-31 10:58:49
    几种常见设计模式理解 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 最早提出“设计模式”概念的...
  • 什么是软件设计模式

    千次阅读 2016-04-17 15:38:31
    使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的;设计模式使代码编制真正工程化;设计模式软件工程的基石脉络,如同大厦的结构一样。一 ...
  • 设计模式理解

    千次阅读 2004-10-15 15:58:00
    设计模式理解 Adams Wang 面向对象指使用离散的对象来构建软件系统;设计模式利用了对象的继承、组合和代理(delegation),在较OOP高的层次上考虑问题。尤其是使用代理来任何不稳定或不确定的方面,如状态、...
  • 【Java设计模式软件设计七大原则

    万次阅读 多人点赞 2019-08-31 13:44:31
    文章目录软件设计原则的分类开闭原则依赖倒置原则单一职责原则接口隔离原则迪米特法则(最少知道原则...在设计模式中会有这7中软件设计原则的体现,但是值得注意的是这7钟设计原则在设计模式中的使用是有取舍的,有...
  • 一、软件设计模式的产生背景 “设计模式”这个术语最初并不是出现在软件设计中,而是被用于建筑领域的设计中。 1977 年,美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大...
  • 设计模式——设计模式概述

    万次阅读 多人点赞 2019-10-12 08:07:49
    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。设计模式主要是为了解决某类重复出现的问题而出现的一套成功或有效的解决方案。设计模式提供...
  • 23种设计模式汇总整理

    万次阅读 多人点赞 2015-04-09 10:57:11
    设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式 结构型模式,共七种:适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 ...
  • 学习软件设计模式的书籍

    千次阅读 2016-03-04 00:57:21
    著作权归作者所有。 商业转载请联系作者获得授权,非商业转载请注明出处...这四人都是Phd级别,就是他们最先提出了设计模式,理论水平高,虽然薄薄一本,但是文字相对晦涩,也缺乏容易理解的例子。等你到一定程度了,
  • 设计模式

    千次阅读 多人点赞 2019-07-22 09:33:22
    设计模式简介 设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式软件开发人员在软件...使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性...
  • 23种软件设计模式

    千次阅读 2018-03-07 15:25:26
    软件设计模式,是一套被反复使用、众所周知的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 1. 建造模式(Builder):将一个...
  • 快速理解设计模式六大原则

    千次阅读 2020-10-21 22:57:58
    设计模式的核心总结起来就一句话:用抽象构建框架,用实现扩展细节。目的就是代码修改的改动量最小 设计模式六大原则 单一职责原则 很好理解,一个类职责要单一,不要承载过多的职责,就比如说我们电脑上所有的...
  • 对软件架构设计的一些总结和理解

    万次阅读 多人点赞 2015-09-06 22:28:18
    软件架构是指在一定的设计原则基础上,从不同角度组成系统的各部分进行搭配和安排,形成系统的多个结构而组成架构,它包括该系统的各个组件,组件的外部可见属性及组件之间的相互关系。组件的外部可见属性是指其他...
  • 深入理解Java设计模式-工厂模式

    千次阅读 2020-03-15 18:13:12
    在工厂模式中,我们在创建对象时不会客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离,工厂模式分为简单工厂、工厂方法、抽象工厂模式 2.工厂模式好处 工厂模式...
  • 软件设计模式、目标、原则

    万次阅读 2016-05-27 19:10:52
    软件设计模式 一、设计目标: ⑴、软件设计目标:正确性、健壮性、灵活性、可重用性、高效性 1、正确性:也就是满足应用程序的需求。 2、健壮性:是指软件对于规范要求以外的输入情况的处理能力。也就是说,在...
  • 设计模式软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。可以针对某一系列问题提供一个实现的思想,框架,让设计条理清晰。...
  • 理解J2EE设计模式

    千次阅读 2003-06-06 07:54:00
    第二章 J2EE设计模式在我们形成了框架、模式的简单认知以后。作为背景知识,这一章中我们主要了解和理解J2EE设计模式,以期获得J2EE设计模式的全貌。由于在SUN公司的网站上[i]有整个J2EE模式的详细的介绍,重复...
  • 设计模式: 工厂模式(Java理解)

    千次阅读 2018-03-29 22:51:44
    ,还有一本Design Patterns,结合这两本书,总结一下设计模式的相关知识,提升自己的编程能力. 其实很多设计模式,在之前的项目中,都有所用到,现在算是做一个总结吧,打算写成一个系列,算是自己的备忘手册,也让大家学习...
  • C++ 设计模式

    万次阅读 多人点赞 2018-02-09 09:26:25
    设计模式代表了最佳的实践,在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处:可重用代码、保证代码可靠性、使代码更易被他人理解 ......
  • 软件设计模式的非软件例子

    万次阅读 2004-10-04 18:20:00
    http://www.lzhlj.com/articles/Article_Show.asp?ArticleID=14&ArticlePage=1摘要软件设计模式来源于Christopher Alexander的建筑学模式和对象运动。根据Alexander的观点,模式...基于这两个原因,软件设计模式对于真
  • 设计模式软件架构设计

    千次阅读 2012-02-20 18:06:21
    设计模式软件架构设计  .中国科学院软件所  2006 Software Engineering, 7th edition. Chapter 1 Slide 1 议题 .中国科学院软件所  2006 Software Engineering, 7th edition. Chapter 1  ...
  • 如何通俗理解设计模式及其思想

    万次阅读 多人点赞 2018-07-08 20:36:52
    本文由 玉刚说写作平台 提供写作赞助 原作者:却把清梅嗅 ... 版权声明:本文版权归微信公众号 玉刚...数据结构,算法,设计模式被认为是程序员必备技能的三叉戟,如果说编程语言的语法特性和业务编码能力是【术】,...
  • 设计模式理解的总结

    千次阅读 2012-12-08 17:45:12
    设计模式是编程抽象化的一个具体的应用,它让程序更好的阅读和理解,逻辑上更加合理,是通向更大规模软件的一个基础,换个说法,如果一个软件的模式很混乱那么它混乱到一定的程度就再也编写和维护不下去了,一直觉得...
  • 一什么是设计模式?  设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。...设计模式软件工程的基石脉络,如同大厦的结构一样。  二为什么要使用设计模式?  
  • 设计模式软件模式起源与诞生

    千次阅读 热门讨论 2015-12-28 12:07:04
    GoF将模式的概念引入软件工程领域,这标志着软件模式的诞生。软件模式并非仅限于设计模式,还包括架构模式、分析模式和过程模式等,实际上,在软件开发生命周期的每一个阶段都存在着一些被认同的模式。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 326,164
精华内容 130,465
关键字:

对软件设计模式的理解