精华内容
下载资源
问答
  • Java常见设计模式总结

    万次阅读 多人点赞 2021-09-18 17:18:54
    设计模式是一套经过反复使用的代码设计经验,目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的,它使得代码编写真正工程化,它是软件工程的基石,如同大厦的一块块...

     一、设计模式总述:

    1、什么是设计模式:

            设计模式是一套经过反复使用的代码设计经验,目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 设计模式于己于人于系统都是多赢的,它使得代码编写真正工程化,它是软件工程的基石,如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现实中都有相应的原理来与之对应,每种模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是它能被广泛应用的原因。总体来说,设计模式分为三大类:

    • 创建型模式:共5种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
    • 结构型模式:共7种:适配器模式、装饰器模式、代理模式、桥接模式、外观模式、组合模式、享元模式
    • 行为型模式:共11种:策略模式、模板方法模式、观察者模式、责任链模式、访问者模式、中介者模式、迭代器模式、命令模式、状态模式、备忘录模式、解释器模式

    其实还有两类:并发型模式和线程池模式,用一个图片来整体描述一下:

    2、设计模式的六大原则:

    (1)开闭原则 (Open Close Principle) :

            开闭原则指的是对扩展开放,对修改关闭。在对程序进行扩展的时候,不能去修改原有的代码,想要达到这样的效果,我们就需要使用接口或者抽象类

    (2)依赖倒转原则 (Dependence Inversion Principle):

            依赖倒置原则是开闭原则的基础,指的是针对接口编程,依赖于抽象而不依赖于具体

    (3)里氏替换原则 (Liskov Substitution Principle) :

            里氏替换原则是继承与复用的基石,只有当子类可以替换掉基类,且系统的功能不受影响时,基类才能被复用,而子类也能够在基础类上增加新的行为。所以里氏替换原则指的是任何基类可以出现的地方,子类一定可以出现。

            里氏替换原则是对 “开闭原则” 的补充,实现 “开闭原则” 的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏替换原则是对实现抽象化的具体步骤的规范。

    (4)接口隔离原则 (Interface Segregation Principle):

            使用多个隔离的接口,比使用单个接口要好,降低接口之间的耦合度与依赖,方便升级和维护方便

    (5)迪米特原则 (Demeter Principle):

            迪米特原则,也叫最少知道原则,指的是一个类应当尽量减少与其他实体进行相互作用,使得系统功能模块相对独立,降低耦合关系。该原则的初衷是降低类的耦合,虽然可以避免与非直接的类通信,但是要通信,就必然会通过一个“中介”来发生关系,过分的使用迪米特原则,会产生大量的中介和传递类,导致系统复杂度变大,所以采用迪米特法则时要反复权衡,既要做到结构清晰,又要高内聚低耦合。

    (6)合成复用原则 (Composite Reuse Principle):

            尽量使用组合/聚合的方式,而不是使用继承。

    二、Java的23种设计模式:

            接下来我们详细介绍Java中23种设计模式的概念,应用场景等情况,并结合他们的特点及设计模式的原则进行分析

    1、创建型-工厂方法模式:

    工厂方法模式分为三种:

    (1)简单工厂模式:

    建立一个工厂类,并定义一个接口对实现了同一接口的产品类进行创建。首先看下关系图:

    (2)工厂方法模式:

    工厂方法模式是对简单工厂模式的改进,简单工厂的缺陷在于不符合“开闭原则”,每次添加新产品类就需要修改工厂类,不利于系统的扩展维护。而工厂方法将工厂抽象化,并定义一个创建对象的接口。每增加新产品,只需增加该产品以及对应的具体实现工厂类,由具体工厂类决定要实例化的产品是哪个,将对象的创建与实例化延迟到子类,这样工厂的设计就符合“开闭原则”了,扩展时不必去修改原来的代码。UML关系图如下:

     (3)静态工厂方法模式:

    静态工厂模式是将工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

    工厂方法模式详情文章:Java设计模式之创建型:工厂模式详解(简单工厂+工厂方法+抽象工厂)

    2、创建型-抽象工厂模式:

            抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时,通过抽象工厂模式,能够保证客户端始终只使用同一个产品族中的对象;并且通过隔离具体类的生成,使得客户端不需要明确指定具体生成类;所有的具体工厂都实现了抽象工厂中定义的公共接口,因此只需要改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

            但该模式的缺点在于添加新的行为时比较麻烦,如果需要添加一个新产品族对象时,需要更改接口及其下所有子类,这必然会带来很大的麻烦。

            UML结构图如下:

    抽象工厂模式详情:Java设计模式之创建型:工厂模式详解(简单工厂+工厂方法+抽象工厂)

    3、创建型-建造者模式:

             建造者模式将复杂产品的创建步骤分解在在不同的方法中,使得创建过程更加清晰,从而更精确控制复杂对象的产生过程;通过隔离复杂对象的构建与使用,也就是将产品的创建与产品本身分离开来,使得同样的构建过程可以创建不同的对象;并且每个具体建造者都相互独立,因此可以很方便地替换具体建造者或增加新的具体建造者,用户使用不同的具体建造者即可得到不同的产品对象。UML结构图如下:

     建造者模式详情:Java设计模式之创建型:建造者模式

    4、创建型-单例模式:

            单例模式可以确保系统中某个类只有一个实例,该类自行实例化并向整个系统提供这个实例的公共访问点,除了该公共访问点,不能通过其他途径访问该实例。单例模式的优点在于:

    • 系统中只存在一个共用的实例对象,无需频繁创建和销毁对象,节约了系统资源,提高系统的性能
    • 可以严格控制客户怎么样以及何时访问单例对象。

    单例模式的写法有好几种,主要有三种:懒汉式单例、饿汉式单例、登记式单例。

    单例模式详情:Java设计模式之创建型:单例模式

    5、创建型-原型模式:

            原型模式也是用于对象的创建,通过将一个对象作为原型,对其进行复制克隆,产生一个与源对象类似的新对象。UML类图如下:

     在 Java 中,原型模式的核心是就是原型类 Prototype,Prototype 类需要具备以下两个条件:

    • 实现 Cloneable 接口:
    • 重写 Object 类中的 clone() 方法,用于返回对象的拷贝;

    Object 类中的 clone() 方法默认是浅拷贝,如果想要深拷贝对象,则需要在 clone() 方法中自定义自己的复制逻辑。

    • 浅复制:将一个对象复制后,基本数据类型的变量会重新创建,而引用类型指向的还是原对象所指向的内存地址。
    • 深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。

            使用原型模式进行创建对象不仅简化对象的创建步骤,还比 new 方式创建对象的性能要好的多,因为 Object 类的 clone() 方法是一个本地方法,直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显;

    原型模式详情:Java设计模式之创建型:原型模式

            

            上面我们介绍了5种创建型模式,下面我们就开始介绍下7种结构型模式:适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源,如下图:

    6、结构型-适配器模式:

            适配器模式主要用于将一个类或者接口转化成客户端希望的格式,使得原本不兼容的类可以在一起工作,将目标类和适配者类解耦;同时也符合“开闭原则”,可以在不修改原代码的基础上增加新的适配器类;将具体的实现封装在适配者类中,对于客户端类来说是透明的,而且提高了适配者的复用性,但是缺点在于更换适配器的实现过程比较复杂。

            所以,适配器模式比较适合以下场景:

    • (1)系统需要使用现有的类,而这些类的接口不符合系统的接口。
    • (2)使用第三方组件,组件接口定义和自己定义的不同,不希望修改自己的接口,但是要使用第三方组件接口的功能。

    下面有个非常形象的例子很好地说明了什么是适配器模式:

    适配器模式的主要实现有三种:类的适配器模式、对象的适配器模式、接口的适配器模式。三者的使用场景如下:

    • 类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。
    • 对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。
    • 接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。

    适配器模式详情:Java设计模式之结构型:适配器模式

    7、结构型-装饰器模式:

            装饰器模式可以动态给对象添加一些额外的职责从而实现功能的拓展,在运行时选择不同的装饰器,从而实现不同的行为;比使用继承更加灵活,通过对不同的装饰类进行排列组合,创造出很多不同行为,得到功能更为强大的对象;符合“开闭原则”,被装饰类与装饰类独立变化,用户可以根据需要增加新的装饰类和被装饰类,在使用时再对其进行组合,原有代码无须改变。装饰器模式的UML结构图如下:

            但是装饰器模式也存在缺点,首先会产生很多的小对象,增加了系统的复杂性,第二是排错比较困难,对于多次装饰的对象,调试时寻找错误可能需要逐级排查,较为烦琐。

    装饰器模式详情:Java设计模式之结构型:装饰器模式

    8、结构型-代理模式:

            代理模式的设计动机是通过代理对象来访问真实对象,通过建立一个对象代理类,由代理对象控制原对象的引用,从而实现对真实对象的操作。在代理模式中,代理对象主要起到一个中介的作用,用于协调与连接调用者(即客户端)和被调用者(即目标对象),在一定程度上降低了系统的耦合度,同时也保护了目标对象。但缺点是在调用者与被调用者之间增加了代理对象,可能会造成请求的处理速度变慢。UML结构图如下:

    代理模式详情:Java设计模式之结构型:代理模式

    9、结构型-桥接模式:

            桥接模式将系统的抽象部分与实现部分分离解耦,使他们可以独立的变化。为了达到让抽象部分和实现部分独立变化的目的,桥接模式使用组合关系来代替继承关系,抽象部分拥有实现部分的接口对象,从而能够通过这个接口对象来调用具体实现部分的功能。也就是说,桥接模式中的桥接是一个单方向的关系,只能够抽象部分去使用实现部分的对象,而不能反过来。 

            桥接模式符合“开闭原则”,提高了系统的可拓展性,在两个变化维度中任意扩展一个维度,都不需要修改原来的系统;并且实现细节对客户不透明,可以隐藏实现细节。但是由于聚合关系建立在抽象层,要求开发者针对抽象进行编程,这增加系统的理解和设计难度。桥接模式的UML结构图如下:

            就像在Java中我们使用 JDBC 连接数据库时,在各个数据库之间进行切换,基本不需要动太多的代码,原因就是使用了桥接模式,JDBC 提供统一接口,每个数据库提供各自的实现,然后由桥接类创建一个连接数据库的驱动,使用某一个数据库的时候只需要切换一下就行。JDBC 的结构图如下:

             在 JDBC 中,桥接模式的实现化角色 (Implementor) 为的 Driver 接口,具体实现化 (Concrete Implementor) 角色对应 MysqlDriver、OracleDriver 和 MariadbDriver,扩展抽象化 (Refined Abstraction) 角色对应 DriverManager,不具有抽象化 (Abstraction) 角色作为扩展抽象化角色的父类。

    桥接模式详情:Java设计模式之结构型:桥接模式

    10、结构型-外观模式:

            外观模式通过对客户端提供一个统一的接口,用于访问子系统中的一群接口。使用外观模式有以下几点好处:

    (1)更加易用:使得子系统更加易用,客户端不再需要了解子系统内部的实现,也不需要跟众多子系统内部的模块进行交互,只需要跟外观类交互就可以了;

    (2)松散耦合:将客户端与子系统解耦,让子系统内部的模块能更容易扩展和维护。

    (3)更好的划分访问层次:通过合理使用 Facade,可以更好地划分访问的层次,有些方法是对系统外的,有些方法是系统内部使用的。把需要暴露给外部的功能集中到门面中,这样既方便客户端使用,也很好地隐藏了内部的细节。

            但是如果外观模式对子系统类做太多的限制则减少了可变性和灵活性,所以外观模式适用于为复杂子系统提供一个简单接口,提高系统的易用性场景 以及 引入外观模式将子系统与客户端进行解耦,提高子系统的独立性和可移植性。

            外观模式的UML结构图如下:

    外观模式详情: Java设计模式之结构型:外观模式

    11、结构型-组合模式:

            组合模式将叶子对象和容器对象进行递归组合,形成树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性,能够像处理叶子对象一样来处理组合对象,无需进行区分,从而使用户程序能够与复杂元素的内部结构进行解耦。

            组合模式最关键的地方是叶子对象和组合对象实现了相同的抽象构建类,它既可表示叶子对象,也可表示容器对象,客户仅仅需要针对这个抽象构建类进行编程,这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。组合模式的UML结构图如下:

    组合模式详情: Java设计模式之结构型:组合模式

    12、结构型-享元模式:

            享元模式通过共享技术有效地支持细粒度、状态变化小的对象复用,当系统中存在有多个相同的对象,那么只共享一份,不必每个都去实例化一个对象,极大地减少系统中对象的数量,从而节省资源。

            享元模式的核心是享元工厂类,享元工厂类维护了一个对象存储池,当客户端需要对象时,首先从享元池中获取,如果享元池中存在对象实例则直接返回,如果享元池中不存在,则创建一个新的享元对象实例返回给用户,并在享元池中保存该新增对象,这点有些单例的意思。

            工厂类通常会使用集合类型来保存对象,如 HashMap、Hashtable、Vector 等等,在 Java 中,数据库连接池、线程池等都是用享元模式的应用。

            享元模式的UML结构图如下:

             Java 中,String 类型就是使用享元模式,String 对象是 final 类型,对象一旦创建就不可改变。而 Java 的字符串常量都是存在字符串常量池中的,JVM 会确保一个字符串常量在常量池中只有一个拷贝。

            而且提到共享池,我们也很容易联想到 Java 里面的JDBC连接池,通过连接池的管理,实现了数据库连接的共享,不需要每一次都重新创建连接,节省了数据库重新创建的开销,提升了系统的性能!

    享元模式详情:Java设计模式之结构型:享元模式

            前面我们介绍了7种结构型设计模式,接下来我们介绍一下11种行为型设计模式:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。先来张图,看看这11中模式的关系:

     13、行为型-策略模式:

            将类中经常改变或者可能改变的部分提取为作为一个抽象策略接口类,然后在类中包含这个对象的实例,这样类实例在运行时就可以随意调用实现了这个接口的类的行为。

            比如定义一系列的算法,把每一个算法封装起来,并且使它们可相互替换,使得算法可独立于使用它的客户而变化,这就是策略模式。UML结构图如下:

            策略模式的优点在于可以动态改变对象的行为;但缺点是会产生很多策略类,并且策略模式的决定权在用户,系统只是提供不同算法的实现,所以客户端必须知道所有的策略类,并自行决定使用哪一个策略类; 

            策略模式适用用于以下几种场景:

    • (1)应用程序需要实现特定的功能服务,而该程序有多种实现方式使用,所以需要动态地在几种算法中选择一种
    • (2)一个类定义了多种行为算法,并且这些行为在类的操作中以多个条件语句的形式出现,就可以将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

    策略模式详情:Java设计模式之行为型:策略模式

    14、行为型-模板方法:

            模板方法是基于继承实现的,在抽象父类中声明一个模板方法,并在模板方法中定义算法的执行步骤(即算法骨架)。在模板方法模式中,可以将子类共性的部分放在父类中实现,而特性的部分延迟到子类中实现,只需将特性部分在父类中声明成抽象方法即可,使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤,不同的子类可以以不同的方式来实现这些逻辑。

            模板方法模式的优点在于符合“开闭原则”,也能够实现代码复用,将不变的行为转移到父类,去除子类中的重复代码。但是缺点是不同的实现都需要定义一个子类,导致类的个数的增加使得系统更加庞大,设计更加抽象。模板方法模式的UML图如下:

    模板方法详情:Java设计模式之行为型:模板方法模式

    15、行为型-责任链模式:

            职责链可以将请求的处理者组织成一条链,并将请求沿着链传递,如果某个处理者能够处理请求则处理,否则将该请求交由上级处理。客户端只需将请求发送到职责链上,无须关注请求的处理细节,通过职责链将请求的发送者和处理者解耦了,这也是职责链的设计动机。        

           职责链模式可以简化对象间的相互连接,因为客户端和处理者都没有对方明确的信息,同时处理者也不知道职责链中的结构,处理者只需保存一个指向后续者的引用,而不需要保存所有候选者的引用。

            另外职责链模式增加了系统的灵活性,我们可以任意增加或更改处理者,甚至更改处理者的顺序,不过有可能会导致一个请求无论如何也得不到处理,因为它可能被放置在链末端。

    所以责任链模式有以下几个优点:

    • (1)降低耦合度,将请求的发送者和接收者解耦。反映在代码上就是不需要在类中写很多丑陋的 if….else 语句,如果用了职责链,相当于我们面对一个黑箱,只需将请求递交给其中一个处理者,然后让黑箱内部去负责传递就可以了。
    • (2)简化了对象,使得对象不需要链的结构。
    • (3)增加系统的灵活性,通过改变链内的成员或者调动他们的次序,允许动态地新增或者删除处理者
    • (4)增加新的请求处理类很方便。

    但是责任链模式也存在一些缺点:

    • (1)不能保证请求一定被成功处理
    • (2)系统性能将受到一定影响,并且可能会造成循环调用。
    • (3)可能不容易观察运行时的特征,而且在进行代码调试时不太方便,有碍于除错。

            责任链模式的UML结构图如下:

    责任链模式详情:Java设计模式之行为型:责任链模式

    16、行为型-观察者模式:

            观察者模式又称为 发布-订阅模式,定义了对象之间一对多依赖关系,当目标对象(被观察者)的状态发生改变时,它的所有依赖者(观察者)都会收到通知。一个观察目标可以对应多个观察者,而这些观察者之间没有相互联系,所以能够根据需要增加和删除观察者,使得系统更易于扩展,符合开闭原则;并且观察者模式让目标对象和观察者松耦合,虽然彼此不清楚对方的细节,但依然可以交互,目标对象只知道一个具体的观察者列表,但并不认识任何一个具体的观察者,它只知道他们都有一个共同的接口。

            但观察者模式的缺点在于如果存在很多个被观察者的话,那么将需要花费一定时间通知所有的观察者,如果观察者与被观察者之间存在循环依赖的话,那么可能导致系统崩溃,并且观察者模式没有相应的机制让观察者知道被观察对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。观察者模式的UML结构图如下:

     观察者模式详情:Java设计模式之行为型:观察者模式

    17、行为型-访问者模式:

            访问者模式就是一种分离对象数据结构与行为 (基于数据结构的操作) 的方法,通过这种分离,达到为一个被访问者动态添加新的操作而无需做其它修改的效果,使得添加作用于这些数据结构的新操作变得简单,并且不需要改变各数据结构,为不同类型的数据结构提供多种访问操作方式,这样是访问者模式的设计动机。

            除了使新增访问操作变得更加简单,也能够在不修改现有类的层次结构下,定义该类层次结构的操作,并将有关元素对象的访问行为集中到一个访问者对象中,而不是分散搞一个个的元素类中。

           但访问者模式的缺点在于让增加新的元素类变得困难,每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作,并在每一个具体访问者类中增加相应的具体操作,违背了“开闭原则”的要求;

            所以访问者模式适用于对象结构中很少改变,但经常需要在此对象结构上定义新的操作的系统,使得算法操作的增加变得简单;或者需要对一个对象结构中进行很多不同并且不相关的操作,并且需要避免让这些操作污染这些对象,也不希望在增加新操作时修改这些类的场景。

            访问者模式的UML结构图如下:

            从上面的 UML 结构图中我们可以看出,访问者模式主要分为两个层次结构,一个是访问者层次结构,提供了抽象访问者和具体访问者,主要用于声明一些操作;一个是元素层次结构,提供了抽象元素和具体元素,主要用于声明 accept 操作;而对象结构 ObjectStructure 作为两者的桥梁,存储了不同类型的对象,以便不同的访问者来访问,相同访问者可以以不同的方式访问不同的元素,所以在访问者模式中增加新的访问者无需修改现有代码,可扩展行强。

            在访问者模式使用了双分派技术,所谓双分派技术就是在选择方法的时候,不仅仅要根据消息接收者的运行时区别,还要根据参数的运行时区别。在访问者模式中,客户端将具体状态当做参数传递给具体访问者,这里完成第一次分派,然后具体访问者作为参数的“具体状态”中的方法,同时也将自己this作为参数传递进去,这里就完成了第二次分派。双分派意味着得到的执行操作决定于请求的种类和接受者的类型。

     访问者模式详情:Java设计模式之行为型:访问者模式

    18、行为型-中介者模式:

             中介者模式通过中介者对象来封装一系列的对象交互,将对象间复杂的关系网状结构变成结构简单的以中介者为核心的星形结构,对象间一对多的关联转变为一对一的关联,简化对象间的关系,便于理解;各个对象之间的关系被解耦,每个对象不再和它关联的对象直接发生相互作用,而是通过中介者对象来与关联的对象进行通讯,使得对象可以相对独立地使用,提高了对象的可复用和系统的可扩展性。

            在中介者模式中,中介者类处于核心地位,它封装了系统中所有对象类之间的关系,除了简化对象间的关系,还可以对对象间的交互进行进一步的控制。中介者模式的UML结构图如下:

            但是,中介者对象封装了对象之间的关联关系,导致中介者对象变得比较庞大复杂,所承担的责任也比较多,维护起来也比较困难,它需要知道每个对象和他们之间的交互细节,如果它出问题,将会导致整个系统都会出问题。

    中介者模式详情:Java设计模式之行为型:中介者模式

    19、行为型-命令模式:

            命令模式的本质是将请求封装成对象,将发出命令与执行命令的责任分开,命令的发送者和接收者完全解耦,发送者只需知道如何发送命令,不需要关心命令是如何实现的,甚至是否执行成功都不需要理会。命令模式的关键在于引入了抽象命令接口,发送者针对抽象命令接口编程,只有实现了抽象命令接口的具体命令才能与接收者相关联。

            使用命令模式的优势在于降低了系统的耦合度,而且新命令可以很方便添加到系统中,也容易设计一个组合命令。但缺点在于会导致某些系统有过多的具体命令类,因为针对每一个命令都需要设计一个具体命令类。

            命令模式的UML结构图如下:

    命令模式详情: Java设计模式之行为型:命令模式

    20、行为型-状态模式:

            状态模式,就是允许对象在内部状态发生改变时改变它的行为,对象看起来就好像修改了它的类,也就是说以状态为原子来改变它的行为,而不是通过行为来改变状态。

            当对象的行为取决于它的属性时,我们称这些属性为状态,那该对象就称为状态对象。对于状态对象而言,它的行为依赖于它的状态,比如要预订房间,只有当该房间空闲时才能预订,想入住该房间也只有当你预订了该房间或者该房间为空闲时。对于这样的一个对象,当它的外部事件产生互动的时候,其内部状态就会发生变化,从而使得他的行为也随之发生变化。

            状态模式的UML结构图如下:

     从上面的UML结构图我们可以看出状态模式的优点在于:

    (1)封装了转换规则,允许状态转换逻辑与状态对象合成一体,而不是某一个巨大的条件语句块

    (2)将所有与状态有关的行为放到一个类中,可以方便地增加新的状态,只需要改变对象状态即可改变对象的行为。 

    但是状态模式的缺点在于:

    (1)需要在枚举状态之前需要确定状态种类

    (2)会导致增加系统类和对象的个数。

    (3)对 “开闭原则” 的支持并不友好,新增状态类需要修改那些负责状态转换的源代码,否则无法切换到新增状态;而且修改某个状态类的行为也需修改对应类的源代码。

    所以状态模式适用于:代码中包含大量与对象状态有关的条件语句,以及对象的行为依赖于它的状态,并且可以根据它的状态改变而改变它的相关行为。

    状态模式详情:Java设计模式之行为型:状态模式

    21、行为型-备忘录模式:

            备忘录模式提供了一种恢复状态的机制,在不破坏封装的前提下,捕获对象的某个时刻内部状态,并保存在该对象之外,保证该对象能够恢复到某个历史状态;备忘录模式将保存的细节封装在备忘录中,除了创建它的创建者之外其他对象都不能访问它,并且实现了即使要改变保存的细节也不影响客户端。但是备忘录模式都是多状态和多备份的,会早用较多的内存,消耗资源。备忘录模式的额UML结构图如下:

             备忘录模式的核心就是备忘录 Memento,在备忘录中存储的就是原发器 Originator 的部分或者所有的状态信息,而这些状态信息是不能够被其他对象所访问的,也就是说我们是不能使用备忘录之外的对象来存储这些状态信息,如果暴漏了内部状态信息就违反了封装的原则,故备忘录除了原发器外其他对象都不可以访问。所以为了实现备忘录模式的封装,我们需要对备忘录的访问做些控制:

    (1)对原发器:可以访问备忘录里的所有信息。

    (2)对负责人 caretaker:不可以访问备忘录里面的数据,但是他可以保存备忘录并且可以将备忘录传递给其他对象。

    (3)其他对象:不可访问也不可以保存,它只负责接收从负责人那里传递过来的备忘录同时恢复原发器的状态。

    备忘录模式详情:Java设计模式之行为型:备忘录模式

    22、行为型-迭代器模式:

            迭代器模式提供一种访问集合中的各个元素,而不暴露其内部表示的方法。将在元素之间游走的职责交给迭代器,而不是集合对象,从而简化集合容器的实现,让集合容器专注于在它所应该专注的事情上,更加符合单一职责原则,避免在集合容器的抽象接口层中充斥着各种不同的遍历操作。迭代器模式的UML结构图如下:

    迭代器模式详情:Java设计模式之行为型:迭代器模式

    23、行为型-解释器模式:

            解释器模式,就是定义语言的文法,并建立一个解释器来解释该语言中的句子,通过构建解释器,解决某一频繁发生的特定类型问题实例。

            解释器模式描述了如何构成一个简单的语言解释器,主要应用在使用面向对象语言开发的编译器中,它描述了如何为简单的语言定义一个文法,如何在该语言中表示一个句子,以及如何解释这些句子。    

            解释器模式中除了能够使用文法规则来定义一个语言,还能通过使用抽象语法树来更加直观表示、更好地地表示一个语言的构成,每一颗抽象语法树对应一个语言实例。抽象语法树描述了如何构成一个复杂的句子,通过对抽象语法树的分析,可以识别出语言中的终结符和非终结符类。 在解释器模式中由于每一种终结符表达式、非终结符表达式都会有一个具体的实例与之相对应,所以系统的扩展性比较好。

            解释器模式的UML如下:

     解释器模式详情:Java设计模式之行为型:解释器模式


    相关推荐阅读:

    Spring常见面试题总结

    SpringMVC常见面试题总结

    Mybatis常见面试题总结

    MySQL常见面试题总结

    Redis常见面试题总结

    RabbitMQ消息队列常见面试题总结

    ElasticSearch搜索引擎常见面试题总结

    计算机网络常见面试题总结

    操作系统常见面试题总结

    Java基础、集合、多线程常见面试题总结

    Java虚拟机常见面试题总结

    Java常见设计模式总结

    海量数据处理的方法总结


    参考文章:

    Java之美[从菜鸟到高手演变]之设计模式

    Java之美[从菜鸟到高手演变]之设计模式二

    Java之美[从菜鸟到高手演变]之设计模式三

    Java之美[从菜鸟到高手演变]之设计模式四

    展开全文
  • Java中IO设计模式

    千次阅读 2016-07-18 08:32:53
    IO中的装饰者设计模式 缓冲装饰者模式 package com.cloud.day4; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.io...

    IO流中的装饰者设计模式

    缓冲流装饰者模式

    package com.cloud.day4;

    import java.io.BufferedReader;

    import java.io.File;

    import java.io.FileReader;

    import java.io.IOException;

    import java.io.Reader;

    /*

    装饰者设计模式:增强一个类的功能,而且还可以让这些装饰类互相装饰。

    BufferedReader拓展了FileReader的功能。

    BuferedWriter 拓展了FileWriter的功能。


    需求1编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有行号。

    需求2:编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有分号。

    需求3编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有双引号。

    需求4编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有行号+ 分号。

    需求5编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有分号+ 双引号。

    需求6编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有双引号+ 行号。

    需求7编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有行号+ 分号+双引号。


    ----| Reader

    -----------| BufferedReader

    ---------------| BufferedLineNum  带行号

    ---------------| BufferedSemi    带分号

    ---------------| BufferedQuto   带双引

    ---------------| 子类..

    ---------------|

    增强一个类的功能时候我们可以选择使用继承:

       通过继承实现增强一个类的功能优点:   代码结构清晰,通俗易懂。

       缺点:使用不灵活,会导致继承的体系过于庞大。

    */

    class BufferedLineNum extends BufferedReader{

       int count = 1;

       public BufferedLineNum(Reader in){

          super(in);

       }

       @Override

       public String readLine() throws IOException {

          String line = super.readLine();

          if(line==null){

            return null;

          }

          line = count+" "+line;

          count++;

          return line;

       }

    }

    //带分号的缓冲输入字符流

    class BufferedSemi extends BufferedReader{

       public BufferedSemi(Reader in) {

          super(in);

       }

       @Override

       public String readLine() throws IOException {

          String line = super.readLine();

          if(line==null){

            return null;

          }

          line = line+";";

          return line;

       }

    }

    //带双引号的缓冲输入字符流

    class BufferedQuto extends BufferedReader{

       public BufferedQuto(Reader in) {

          super(in);

       }

       @Override

       public String readLine() throws IOException {

          String line = super.readLine();

          if(line == null){

            return null;

          }

          line = "\""+line+"\"";

          return line;

       }

    }

    public class Demo1 {

       public static void main(String[] args) throws IOException {

          File file = new File("F:\\a.txt");

          FileReader fileReader = new FileReader(file);

          //建立带行号的缓冲输入字符流

          BufferedLineNum bufferedLineNum = new BufferedLineNum(fileReader);

          //建立带分号的缓冲输入字符流

          BufferedSemi bufferedSemi = new BufferedSemi(fileReader);

          //建立带引号的缓冲输入字符流

          BufferedQuto bufferedQuto = new BufferedQuto(fileReader);

          String line = null;

          while((line = bufferedQuto.readLine())!=null){

            System.out.println(line);

          }

       }

    }

    字符流装饰者模式

    package com.cloud.day4;

    /*

    装饰者设计模式:增强一个类的功能,而且还可以让这些装饰类互相装饰。

    装饰者设计模式的步骤:

       1. 在装饰类的内部维护一个被装饰类的引用。

       2. 让装饰类有一个共同的父类或者是父接口。


    需求1编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有行号。

     需求2:编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有分号。

     需求3编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有双引号。

     需求4编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有行号+ 分号。

     需求5编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有分号+ 双引号。

     需求6编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有双引号+ 行号。

     需求7编写一个类拓展BufferedReader的功能,增强readLine方法返回的字符串带有行号+ 分号+双引号。


    继承实现的增强类和修饰模式实现的增强类有何区别?

       继承实现的增强类:

          优点:代码结构清晰,而且实现简单.

          缺点:对于每一个的需要增强的类都要创建具体的子类来帮助其增强,这样会导致继承体系过于庞大。

    修饰模式实现的增强类:

          优点:内部可以通过多态技术对多个需要增强的类进行增强,可以是这些装饰类达到互相装饰的效果。使用比较灵活。     

          缺点:需要内部通过多态技术维护需要被增强的类的实例。进而使得代码稍微复杂。

    */

    import java.io.BufferedReader;

    import java.io.File;

    import java.io.FileReader;

    import java.io.IOException;

    //带行号的缓冲输入字符流

    class BufferedLineNum2 extends BufferedReader{

       //内部维护一个被装饰类的引用

       BufferedReader bufferedReader ;

       int count = 1;

       public BufferedLineNum2(BufferedReader bufferedReader) {

          super(bufferedReader);

          this.bufferedReader = bufferedReader;

       }

       public String readLine() throws IOException{

          String line = bufferedReader.readLine();

          if(line == null){

            return null;

          }

          line = count+" "+line;

          return line;

       }

    }

    //带分号缓冲输入字符流

    class BufferedLineSemi2 extends BufferedReader{

       //内部维护一个被装饰类的引用

       BufferedReader bufferedReader ;

       int count = 1;

       public BufferedLineSemi2(BufferedReader bufferedReader) {

          super(bufferedReader);

          this.bufferedReader = bufferedReader;

       }

       public String readLine() throws IOException{

          String line = bufferedReader.readLine();

          if(line == null){

            return null;

          }

          line = line+";";

          return line;

       }

    }

    //缓冲类带双引号

    class BufferedQuto2 extends BufferedReader{

      

       //在内部维护一个被装饰的类

       BufferedReader bufferedReader;

      

       public BufferedQuto2(BufferedReader bufferedReader){  //new  BufferedSemi2();

          super(bufferedReader) ; //只是为了让代码不报错..

          this.bufferedReader = bufferedReader;

       }

      

       public String readLine() throws IOException{

          String line = bufferedReader.readLine();

          if(line==null){

            return null;

          }

          line = "\""+line +"\"";

          return line;

       }

    }

    public class Demo2 {

       public static void main(String[] args) throws IOException {

          File file = new File("F:\\a.txt");

          FileReader fileReader = new FileReader(file);

          BufferedReader bufferedReader = new BufferedReader(fileReader);

          BufferedLineNum2 bufferedLineNum2 = new BufferedLineNum2(bufferedReader);

          bufferedLineNum2.readLine();

          String line = null;

          while((line = bufferedLineNum2.readLine())!=null){

            System.out.println(line);

          }

       }

    }

     

    案例

    package com.cloud.day4;

    /*练习:

    一家三口每个人都会工作,儿子的工作就是画画,母亲的工作就是在儿子的基础上做一个增强,不单止可以画画,还可以上涂料。

    爸爸的工作就是在妈妈基础上做了增强,就是上画框。

    */

     

    interface Work{

       public void work();

    }

    class Son implements Work{

       @Override

       public void work() {

          System.out.println("画画...");

       }

    }

    class Mother implements Work{

       Work worker;

       public Mother(Work worker){

          worker.work();

          this.worker = worker;

       }

       @Override

       public void work() {

          System.out.println("填色...");

       }

    }

    class Father implements Work{

       Work worker;

       public Father(Work worker){

          worker.work();

          this.worker = worker;

       }

       @Override

       public void work() {

          System.out.println("打包封装...");

       }

    }

    public class Demo3 {

       public static void main(String[] args) {

          Son son = new Son();

          Mother m = new Mother(son);

          Father f = new Father(m);

          f.work();

       }

    }

    展开全文
  • java io 设计模式

    万次阅读 2010-01-27 16:05:00
    三 装饰模式的应用 学过装饰模式后,大家会发现,它在Java语言中最著名的应用莫过于Java I/O标准为库的设计了。这一节将以处理Byte为例,看看装饰模式是怎样得到应用的。 为什么不用继承而用装饰模式 我们知道...

    三 装饰模式的应用

     学过装饰模式后,大家会发现,它在Java语言中最著名的应用莫过于Java I/O标准为库的设计了。这一节将以处理Byte流为例,看看装饰模式是怎样得到应用的。

     为什么不用继承而用装饰模式

     我们知道Java I/O库需要很多性能的各种组合,如果说这些性能的组合是通过继承方式来实现的话,那么每一种组合都需要一个类,这样就会出现大量重复性问题的出现,从而使类数目“爆炸”。而如果采用装饰模式,那么不仅类的数目大减少了,性能的重复也可以减至到最少。所以装饰模式是Java I/O库的基本模式。在这里我想再用<<Head First Design Pattern>>中讲到装饰模式时候的一个例子,看看装饰模式是怎么达到不仅类的数目大减少了,性能的重复也可以减至到最少:

     它这个例子大概是说:Beverage是一个抽象类,它被所有在一个咖啡店里卖的饮料继承。Beverage有个抽象方法cost,所有的子类都要实现这个抽象方法,计算它们的价格。现在有四个最基本的咖啡:HouseBlend,DarkRoast,Decaf,Espresso他们都继承自Beverage,现在的需求是说在四个最基本的咖啡里,每个都可以随便地添加调味品,像steamed milk,soy,还有mocha最后是加上whipped milk。如果是说按继承来实现这种几个调味品跟原来咖啡的组合的话,我们会很自然地设计来下面的类图来:

    看到了上面的类图了吗,我们不禁会说这就是“类爆炸”。如果是按装饰模式的设计思路我们可以得出下面的设计类图:

    我们再来看看Gof里面的标准的装饰模式的类图表示:

    仔细看看上面的几个图后我们肯定就会理解这句话了:装饰模式是怎么达到不仅类的数目大减少了,性能的重复也可以减至到最少。

     再回到Java I/O库,由于装饰模式的引用,造成了灵活性和复杂都大大增加了,我们在使用Java I/O库时,必须理解Java I/O库是由一些基本的原始流处理器和围绕它们的装饰流处理器所组成的,这样可以在学习和使用Java I/O库时达到事半功倍的效果。

     下面我用<<Java与模式>>,<<Head First Design Pattern>>或者是网上看到的一些类图来分析:

     首先是InputStream类型中的装饰模式:

     InputStream有七个直接的具体子类,有四个属于FilterInputStream的具体子类,如下图所示:

     

      上图中所有的类都叫做流处理器,这个图就叫做(InputStream类型的)流处理器图。

      书中提到根据输入流的源的类型,可以将这些流类分成两种,即原始流类(Original Stream)和链接流处理器(Wrapper Stream)。

      原始流处理器

      原始流处理器接收一个Byte数组对象,String对象,FileDiscriptor对象或者不同类型的流源对象,根据上面的图,原始流处理器包括以下四种:

      ByteArrayInputStream:为多线程的通信提供缓冲区操作功能,接收一个Byte数组作为流的源。

      FileInputStream:建立一个与文件有关的输入流。接收一个File对象作为流的源。

      PipedInputStream:可以与PipedOutputStream配合使用,用于读入一个数据管道的数据,接收一个PipedOutputStream作为源。

      StringBufferInputStream:将一个字符串缓冲区转换为一个输入流。接收一个String对象作为流的源。(JDK帮助文档上说明:已过时。此类未能正确地将字符转换为字节。从JDK1.1开始,从字符串创建流的首选方法是通过StringReader类进行创建。只有字符串中每个字符的低八位可以由此类使用。)

      链接流处理器

      所谓链接流处理器,就是可以接收另一个流对象作为源,并对之进行功能扩展的类。InputStream类型的链接处理器包括以下几种,它们都接收另一个InputStream对象作为流源。

      (1)FilterInputStream称为过滤输入流,它将另一个输入流作为流源。这个类的子类包括以下几种:

      BufferedInputStream:用来从硬盘将数据读入到一个内存缓冲区中,并从缓冲区提供数据。

      DataInputStream:提供基于多字节的读取方法,可以读取原始类型的数据。

      LineNumberInputStream:提供带有行计数功能的过滤输入流。

      PushbackInputStream:提供特殊的功能,可以将已经读取的字节“推回”到输入流中。

      (2)ObjectInputStream可以将使用ObjectInputStream串行化的原始数据类型和对象重新并行化。

      (3)SeqcueneInputStream可以将两个已有的输入流连接起来,形成一个输入流,从而将多个输入流排列构成一个输入流序列。

      抽象结构图

      按照上面的这种原始流处理器和链接流处理器的划分,可以用下面的结构图来描述它们之间的关系。

      

     

     上面的流处理器图跟装饰模式的结构图有着显而易见的相同之处。实际上InputStream类型的流处理器结构确实符合装饰模式。 

     装饰模式结构图

     

      对于上图FilterInputStream查看JDK1.4源代码,部分代码如下:

    Public class FilterInputStream extends InputStream {
        /**
         * The input stream to be filtered.
         */
        protected InputStream in;
        protected FilterInputStream(InputStream in) {
            this.in = in;
        }
        //其它代码
    }
    FilterInputStream继承了InputStream,也引用了InputStream,而它有四个子类,这就是所谓的Decorator模式

      上面这个图向我们传达了这个信息:链接流链接流对象接收一个原始流对象或者另外一个链接流对象作为流源;另一方面他们对流源的内部工作方法做了相应的改变,这种改变是装饰模式所要达到的目的。比如:

      BufferedInputStream“装饰”了InputStream的内部工作方式,使得流的读入操作使用了缓冲机制。在使用了缓冲机制后,不会对每一次的流读入操作都产生一个物理的读盘动作,从而提高了程序的效率,在汲及到物理流的读入时,都应当使用这个装饰流类。

      LineNumberInputStream和PushbackInputStream也同样“装饰”了InputStream的内部工作方式,前者使得程序能够按照行号读入数据;后者能够使程序读入的过程中,退后一个字符。

      DataInputStream子类读入各种不同的原始数据类型以及String类型的数据,这一点可以从它提供的各种read方法看出来,如:readByte(),readInt(),readFloat()等。

      Java语言的I/O库提供了四大等级结构:InputStream,OutputStream,Reader,Writer四个系列的类。InputStream和OutputStream处理8位字节流数据, Reader和Writer处理16位的字符流数据。InputStream和Reader处理输入, OutputStream和Writer处理输出,所以OutputStream,Reader,Writer这三类的装饰模式跟前面详细介绍的InputStream装饰模式大同小异,大家可以看书中其它部分对这三类的详细描述或者从网上也能找到有关资料。为了方便比较这几种类型,顺便附上Java语言的I/O层次结构图:

     下面的图表示:以InputStream和OutputStream形成的层次关系

     下面的图表示:以Reader和Writer形成的层次关系

    展开全文
  • Java中常用的设计模式

    万次阅读 多人点赞 2019-03-15 17:25:14
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统...

    文章转载借鉴:http://blog.csdn.net/zhangerqing

    一、什么是设计模式

    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的核心解决方案,这也是它能被广泛应用的原因

    二、设计模式的六大原则

    1、开闭原则(Open Close Principle)

    开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

    2、里氏代换原则(Liskov Substitution Principle)

    里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

    3、依赖倒转原则(Dependence Inversion Principle)

    这个是开闭原则的基础,具体内容:针对接口编程,依赖于抽象而不依赖于具体。

    4、接口隔离原则(Interface Segregation Principle)

    这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。所以上文中多次出现:降低依赖,降低耦合。

    5、迪米特法则(最少知道原则)(Demeter Principle)

    为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。

    6、合成复用原则(Composite Reuse Principle)

    原则是尽量使用合成/聚合的方式,而不是使用继承。

    设计模式原则详细描述请见:http://www.cnblogs.com/pony1223/p/7594803.html

    三、设计模式的三大类

    总体来说设计模式分为三大类:

    创建型模式(5种):工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    结构型模式(7种):适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式(11种):策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

     其实还有两类:并发型模式和线程池模式。用一个图片来整体描述一下:

    根据作用范围来分

    根据模式是主要用于类上还是主要用于对象上来分,这种方式可分为类模式和对象模式两种。

    1. 类模式:用于处理类与子类之间的关系,这些关系通过继承来建立,是静态的,在编译时刻便确定下来了。工厂方法、(类)适配器、模板方法、解释器属于该模式。
    2. 对象模式:用于处理对象之间的关系,这些关系可以通过组合或聚合来实现,在运行时刻是可以变化的,更具动态性。
    范围\目的创建型模式结构型模式行为型模式
    类模式工厂方法(类)适配器模板方法、解释器
    对象模式单例
    原型
    抽象工厂
    建造者
    代理
    (对象)适配器
    桥接
    装饰
    外观
    享元
    组合
    策略
    命令
    职责链
    状态
    观察者
    中介者
    迭代器
    访问者
    备忘录

    四、Java的二十三种设计模式

    从这一块开始,我们详细介绍Java中23种设计模式的概念,应用场景等情况,并结合他们的特点及设计模式的原则进行分析。

    创建型模式(5种):用于描述“怎样创建对象”,它的主要特点是“将对象的创建与使用分离”。

    A、单例模式(Singleton)

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

    这样的模式有几个好处:

    1. 某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
    2. 省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
    3. 有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。

    优点:只有一个实例,节约了内存资源,提高了系统性能

    缺点:
        没有抽象层,不能扩展
        职责过重,违背了单一性原则

    首先我们写一个简单的单例类:

    public class Singleton {
     
    	/* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */
    	private static Singleton instance = null;
     
    	/* 私有构造方法,防止被实例化 */
    	private Singleton() {
    	}
     
    	/* 静态工程方法,创建实例 */
    	public static Singleton getInstance() {
    		if (instance == null) {
    			instance = new Singleton();
    		}
    		return instance;
    	}
     
    	/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
    	public Object readResolve() {
    		return instance;
    	}
    }

    这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,如何解决?我们首先会想到对getInstance方法加synchronized关键字,如下:

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

    但是,synchronized关键字锁住的是这个对象,这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了,所以,这个地方需要改进。我们改成下面这个:

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

    似乎解决了之前提到的问题,将synchronized关键字加在了内部,也就是说当调用的时候是不需要加锁的,只有在instance为null,并创建对象的时候才需要加锁,性能有一定的提升。但是,这样的情况,还是有可能有问题的,看下面的情况:在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了,我们以A、B两个线程为例:

    ①:A、B线程同时进入了第一个if判断

    ②:A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();

    ③:由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员(注意此时JVM没有开始初始化这个实例),然后A离开了synchronized块。

    ④:B进入synchronized块,由于instance此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

    ⑥:此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。

    所以程序还是有可能发生错误,其实程序在运行过程是很复杂的,从这点我们就可以看出,尤其是在写多线程环境下的程序更有难度,有挑战性。我们对该程序做进一步优化:

    private static class SingletonFactory{         
            private static Singleton instance = new Singleton();         
        }         
    public static Singleton getInstance(){         
            return SingletonFactory.instance;         
        } 

     实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:

    public class Singleton {
     
    	/* 私有构造方法,防止被实例化 */
    	private Singleton() {
    	}
     
    	/* 此处使用一个内部类来维护单例 */
    	private static class SingletonFactory {
    		private static Singleton instance = new Singleton();
    	}
     
    	/* 获取实例 */
    	public static Singleton getInstance() {
    		return SingletonFactory.instance;
    	}
     
    	/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */
    	public Object readResolve() {
    		return getInstance();
    	}
    }

    其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建加synchronized关键字,也是可以的:

    public class SingletonTest {
     
    	private static SingletonTest instance = null;
     
    	private SingletonTest() {
    	}
     
    	private static synchronized void syncInit() {
    		if (instance == null) {
    			instance = new SingletonTest();
    		}
    	}
     
    	public static SingletonTest getInstance() {
    		if (instance == null) {
    			syncInit();
    		}
    		return instance;
    	}
    }

    考虑性能的话,整个程序只需创建一次实例,所以性能也不会有什么影响。

    public class SingletonTest {
     
    	private static SingletonTest instance = null;
    	private Vector properties = null;
     
    	public Vector getProperties() {
    		return properties;
    	}
     
    	private SingletonTest() {
    	}
     
    	private static synchronized void syncInit() {
    		if (instance == null) {
    			instance = new SingletonTest();
    		}
    	}
     
    	public static SingletonTest getInstance() {
    		if (instance == null) {
    			syncInit();
    		}
    		return instance;
    	}
     
    	public void updateProperties() {
    		SingletonTest shadow = new SingletonTest();
    		properties = shadow.getProperties();
    	}
    }

     通过单例模式的学习告诉我们:

    1. 单例模式理解起来简单,但是具体实现起来还是有一定的难度。
    2. synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。

    到这儿,单例模式基本已经讲完了,结尾处,笔者突然想到另一个问题,就是采用类的静态方法,实现单例模式的效果,也是可行的,此处二者有什么不同?

    首先,静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)

    其次,单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。

    再次,单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。

    最后一点,单例类比较灵活,毕竟从实现上只是一个普通的Java类,只要满足单例的基本需求,你可以在里面随心所欲的实现一些其它功能,但是静态类不行。从上面这些概括中,基本可以看出二者的区别,但是,从另一方面讲,我们上面最后实现的那个单例模式,内部就是用一个静态类来实现的,所以,二者有很大的关联,只是我们考虑问题的层面不同罢了。两种思想的结合,才能造就出完美的解决方案,就像HashMap采用数组+链表来实现一样,其实生活中很多事情都是这样,单用不同的方法来处理问题,总是有优点也有缺点,最完美的方法是,结合各个方法的优点,才能最好的解决问题!

    拓展:多例设计模式

    单例设计模式只留下一个类的一个实例化对象,而多例设计模式,会定义出多个对象。例如:定义一个表示星期的操作类,这个类的对象只能有7个实例化对象(星期一 ~ 星期日);定义一个表示性别的类,只能有2个实例化对象(男、女);定义一个表示颜色的操作类,只能有3个实例化对象(红、绿、蓝)。这种情况下,这样的类就不应该由用户无限制地去创造实例化对象,应该只使用有限的几个,这个就属于多例设计模式。不管是单例设计模式还是多例设计模式,有一个核心不可动摇,即构造器方法私有化。

    class Sex{
        private String title;
        private static final Sex MALE = new Sex("男");
        private static final Sex FEMALE = new Sex("女");
    
        private Sex(String title){        //构造器私有化
            this.title = title;
        }
    
        public String toString(){
            return this.title;
        }
        
        public static Sex getInstance(int ch){
            switch(ch){
                case 1:
                    return MALE;
                case 2:
                    return FEMALE;
                default:
                    return null;
            }
        }
    }
    
    public class TestDemo{
        public static void main(String args[]){
            Sex sex = Sex.getInstance(2);
            System.out.println(sex);
        }
    }
    
    
    ==========程序执行结果=========
    女

    B、工厂方法模式(Factory Method)

    工厂方法模式分为三种:

    1、普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。首先看下关系图:

    举例如下:(我们举一个发送邮件和短信的例子)

    首先,创建二者的共同接口:

    public interface Sender {
    	public void Send();
    }

    其次,创建实现类:

    public class MailSender implements Sender {
    	@Override
    	public void Send() {
    		System.out.println("this is mailsender!");
    	}
    }
    public class SmsSender implements Sender {
        @Override
        public void Send() {
            System.out.println("this is sms sender!");
        }
    }

    最后,建工厂类:

    public class SendFactory {
     
    	public Sender produce(String type) {
    		if ("mail".equals(type)) {
    			return new MailSender();
    		} else if ("sms".equals(type)) {
    			return new SmsSender();
    		} else {
    			System.out.println("请输入正确的类型!");
    			return null;
    		}
    	}
    }

    我们来测试下:

    public class FactoryTest {
     
    	public static void main(String[] args) {
    		SendFactory factory = new SendFactory();
    		Sender sender = factory.produce("sms");
    		sender.Send();
    	}
    }

    输出:this is sms sender!

    2、多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。关系图:

    将上面的代码做下修改,改动下SendFactory类就行,如下:

    public class SendFactory {
    	
    	public Sender produceMail(){
    		return new MailSender();
    	}
    	
    	public Sender produceSms(){
    		return new SmsSender();
    	}
    }

    测试类如下:

    public class FactoryTest {
     
    	public static void main(String[] args) {
    		SendFactory factory = new SendFactory();
    		Sender sender = factory.produceMail();
    		sender.Send();
    	}
    }

    输出:this is mailsender!

    3、静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

    public class SendFactory {
    	
    	public static Sender produceMail(){
    		return new MailSender();
    	}
    	
    	public static Sender produceSms(){
    		return new SmsSender();
    	}
    }
    public class FactoryTest {
     
    	public static void main(String[] args) {	
    		Sender sender = SendFactory.produceMail();
    		sender.Send();
    	}
    }

    输出:this is mailsender!

    总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传入的字符串有误,不能正确创建对象,第三种相对于第二种,不需要实例化工厂类,所以,大多数情况下,我们会选用第三种——静态工厂方法模式。

    好处:客户端不需要创建对象,明确了各个类的职责
    缺点:该工厂类负责创建所有实例,如果有新的类加入,需要不断的修改工厂类,不利于后期的维护

    C、抽象工厂模式

    工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。因为抽象工厂不太好理解,我们先看看图,然后就和代码,就比较容易理解。

    请看例子:

    public interface Sender {
    	public void Send();
    }

    两个实现类:

    public class MailSender implements Sender {
    	@Override
    	public void Send() {
    		System.out.println("this is mailsender!");
    	}
    }
    public class MailSender implements Sender {
    	@Override
    	public void Send() {
    		System.out.println("this is mailsender!");
    	}
    }

    在提供一个接口:

    public interface Provider {
    	public Sender produce();
    }

    两个工厂类:

        public class SendMailFactory implements Provider {
        	
        	@Override
        	public Sender produce(){
        		return new MailSender();
        	}
        }
    public class SendSmsFactory implements Provider{
     
    	@Override
    	public Sender produce() {
    		return new SmsSender();
    	}
    }

    测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		Provider provider = new SendMailFactory();
    		Sender sender = provider.produce();
    		sender.Send();
    	}
    }

    其实这个模式的好处就是,如果你现在想增加一个功能:发及时信息,则只需做一个实现类,实现Sender接口,同时做一个工厂类,实现Provider接口,就OK了,无需去改动现成的代码。这样做,拓展性较好!

    好处:如果有新的类进来,只需要添加一个对应的具体工厂类,不影响现有代码,增加了程序的扩展性
    缺点:增加了代码量

    D、建造者模式(Builder)

    工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码:

    还和前面一样,一个Sender接口,两个实现类MailSender和SmsSender。最后,建造者类如下:

    public class Builder {
    	
    	private List<Sender> list = new ArrayList<Sender>();
    	
    	public void produceMailSender(int count){
    		for(int i=0; i<count; i++){
    			list.add(new MailSender());
    		}
    	}
    	
    	public void produceSmsSender(int count){
    		for(int i=0; i<count; i++){
    			list.add(new SmsSender());
    		}
    	}
    }

     测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		Builder builder = new Builder();
    		builder.produceMailSender(10);
    	}
    }

    从这点看出,建造者模式将很多功能集成到一个类里,这个类可以创造出比较复杂的东西。所以与工程模式的区别就是:工厂模式关注的是创建单个产品,而建造者模式则关注创建符合对象,多个部分。因此,是选择工厂模式还是建造者模式,依实际情况而定。

    E、原型模式(Prototype)

    原型模式虽然是创建型的模式,但是与工程模式没有关系,从名字即可看出,该模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。本小结会通过对象的复制,进行讲解。在Java中,复制对象是通过clone()实现的,先创建一个原型类:

    public class Prototype implements Cloneable {
     
    	public Object clone() throws CloneNotSupportedException {
    		Prototype proto = (Prototype) super.clone();
    		return proto;
    	}
    }

    很简单,一个原型类,只需要实现Cloneable接口,覆写clone方法,此处clone方法可以改成任意的名称,因为Cloneable接口是个空接口,你可以任意定义实现类的方法名,如cloneA或者cloneB,因为此处的重点是super.clone()这句话,super.clone()调用的是Object的clone()方法,而在Object类中,clone()是native的,具体怎么实现,我会在另一篇文章中,关于解读Java中本地方法的调用,此处不再深究。在这儿,我将结合对象的浅复制和深复制来说一下,首先需要了解对象深、浅复制的概念:

    浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。

    深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。

    此处,写一个深浅复制的例子:

    public class Prototype implements Cloneable, Serializable {
     
    	private static final long serialVersionUID = 1L;
    	private String string;
     
    	private SerializableObject obj;
     
    	/* 浅复制 */
    	public Object clone() throws CloneNotSupportedException {
    		Prototype proto = (Prototype) super.clone();
    		return proto;
    	}
     
    	/* 深复制 */
    	public Object deepClone() throws IOException, ClassNotFoundException {
     
    		/* 写入当前对象的二进制流 */
    		ByteArrayOutputStream bos = new ByteArrayOutputStream();
    		ObjectOutputStream oos = new ObjectOutputStream(bos);
    		oos.writeObject(this);
     
    		/* 读出二进制流产生的新对象 */
    		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    		ObjectInputStream ois = new ObjectInputStream(bis);
    		return ois.readObject();
    	}
     
    	public String getString() {
    		return string;
    	}
     
    	public void setString(String string) {
    		this.string = string;
    	}
     
    	public SerializableObject getObj() {
    		return obj;
    	}
     
    	public void setObj(SerializableObject obj) {
    		this.obj = obj;
    	}
     
    }
     
    class SerializableObject implements Serializable {
    	private static final long serialVersionUID = 1L;
    }

    要实现深复制,需要采用流的形式读入当前对象的二进制输入,再写出二进制数据对应的对象。

    结构型模式(7种):用于描述如何将类或对象按某种布局组成更多的结构。

    F、适配器模式(Adapter)

    适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。首先,我们来看看类的适配器模式,先看类图:

    核心思想就是:有一个Source类,拥有一个方法,待适配,目标接口时Targetable,通过Adapter类,将Source的功能扩展到Targetable里,看代码:

    public class Source {
     
    	public void method1() {
    		System.out.println("this is original method!");
    	}
    }
    public interface Targetable {
     
    	/* 与原类中的方法相同 */
    	public void method1();
     
    	/* 新类的方法 */
    	public void method2();
    }
    public class Adapter extends Source implements Targetable {
     
    	@Override
    	public void method2() {
    		System.out.println("this is the targetable method!");
    	}
    }
    public class Adapter extends Source implements Targetable {
     
    	@Override
    	public void method2() {
    		System.out.println("this is the targetable method!");
    	}
    }

    Adapter类继承Source类,实现Targetable接口,下面是测试类:

    public class AdapterTest {
     
    	public static void main(String[] args) {
    		Targetable target = new Adapter();
    		target.method1();
    		target.method2();
    	}
    }

    输出:

    this is original method!
    this is the targetable method!

    这样Targetable接口的实现类就具有了Source类的功能。

    对象的适配器模式

    基本思路和类的适配器模式相同,只是将Adapter类作修改,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。看图:

    只需要修改Adapter类的源码即可:

    public class Wrapper implements Targetable {
     
    	private Source source;
    	
    	public Wrapper(Source source){
    		super();
    		this.source = source;
    	}
    	@Override
    	public void method2() {
    		System.out.println("this is the targetable method!");
    	}
     
    	@Override
    	public void method1() {
    		source.method1();
    	}
    }

    测试类:

    public class AdapterTest {
     
    	public static void main(String[] args) {
    		Source source = new Source();
    		Targetable target = new Wrapper(source);
    		target.method1();
    		target.method2();
    	}
    }

    输出与第一种一样,只是适配的方法不同而已。

    第三种适配器模式是接口的适配器模式,接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行。看一下类图:
     

    这个很好理解,在实际开发中,我们也常会遇到这种接口中定义了太多的方法,以致于有时我们在一些实现类中并不是都需要。看代码:

    public interface Sourceable {
    	
    	public void method1();
    	public void method2();
    }

    抽象类Wrapper2:

    public abstract class Wrapper2 implements Sourceable{
    	
    	public void method1(){}
    	public void method2(){}
    }
    public class SourceSub1 extends Wrapper2 {
    	public void method1(){
    		System.out.println("the sourceable interface's first Sub1!");
    	}
    }
    public class SourceSub2 extends Wrapper2 {
    	public void method2(){
    		System.out.println("the sourceable interface's second Sub2!");
    	}
    }
    public class WrapperTest {
     
    	public static void main(String[] args) {
    		Sourceable source1 = new SourceSub1();
    		Sourceable source2 = new SourceSub2();
    		
    		source1.method1();
    		source1.method2();
    		source2.method1();
    		source2.method2();
    	}
    }

    测试输出:

    the sourceable interface's first Sub1!
    the sourceable interface's second Sub2!

    达到了我们的效果!

     讲了这么多,总结一下三种适配器模式的应用场景:

    类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。

    对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。

    接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。

    G、装饰模式

    顾名思义,装饰模式就是给一个对象增加一些新的功能,而且是动态的,要求装饰对象和被装饰对象实现同一个接口。装饰对象持有被装饰对象的实例,关系图如下:

    Source类是被装饰类,Decorator类是一个装饰类,可以为Source类动态的添加一些功能,代码如下:

    public interface Sourceable {
    	public void method();
    }
    public class Source implements Sourceable {
     
    	@Override
    	public void method() {
    		System.out.println("the original method!");
    	}
    }
    public class Decorator implements Sourceable {
     
    	private Sourceable source;
    	
    	public Decorator(Sourceable source){
    		super();
    		this.source = source;
    	}
    	@Override
    	public void method() {
    		System.out.println("before decorator!");
    		source.method();
    		System.out.println("after decorator!");
    	}
    }

    测试类:

    public class DecoratorTest {
     
    	public static void main(String[] args) {
    		Sourceable source = new Source();
    		Sourceable obj = new Decorator(source);
    		obj.method();
    	}
    }

    输出:

    before decorator!
    the original method!
    after decorator!

    装饰器模式的应用场景:

    1. 需要扩展一个类的功能。
    2. 动态的为一个对象增加功能,而且还能动态撤销。(继承不能做到这一点,继承的功能是静态的,不能动态增删。)

    缺点:产生过多相似的对象,不易排错!

    H、代理者模式(Proxy)

    代理(Proxy)模式:为某对象提供一种代理以

    控制对该对象的访问。即客户端通过代理间接地访问该对象,从而限制、增强或修改该对象的一些特性。比如我们在租房子的时候会去找中介,为什么呢?因为你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因为律师在法律方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图:

    根据上文的阐述,代理模式就比较容易的理解了,我们看下代码:

    public interface Sourceable {
    	public void method();
    }
    public class Source implements Sourceable {
     
    	@Override
    	public void method() {
    		System.out.println("the original method!");
    	}
    }
    public class Proxy implements Sourceable {
     
    	private Source source;
    	public Proxy(){
    		super();
    		this.source = new Source();
    	}
    	@Override
    	public void method() {
    		before();
    		source.method();
    		atfer();
    	}
    	private void atfer() {
    		System.out.println("after proxy!");
    	}
    	private void before() {
    		System.out.println("before proxy!");
    	}
    }

    测试类:

    public class ProxyTest {
     
    	public static void main(String[] args) {
    		Sourceable source = new Proxy();
    		source.method();
    	}
     
    }

    输出:

    before proxy!
    the original method!
    after proxy!

    代理模式的应用场景:

    如果已有的方法在使用的时候需要对原有的方法进行改进,此时有两种办法:

    1. 修改原有的方法来适应。这样违反了“对扩展开放,对修改关闭”的原则。
    2. 就是采用一个代理类调用原有的方法,且对产生的结果进行控制。这种方法就是代理模式。

    使用代理模式,可以将功能划分的更加清晰,有助于后期维护!

    I、外观模式(Facade)

    外观模式是为了解决类与类之家的依赖关系的,像spring一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,该模式中没有涉及到接口,看下类图:(我们以一个计算机的启动过程为例)

    我们先看下实现类:

    public class CPU {
    	
    	public void startup(){
    		System.out.println("cpu startup!");
    	}
    	
    	public void shutdown(){
    		System.out.println("cpu shutdown!");
    	}
    }
    public class Memory {
    	
    	public void startup(){
    		System.out.println("memory startup!");
    	}
    	
    	public void shutdown(){
    		System.out.println("memory shutdown!");
    	}
    }
    public class Disk {
    	
    	public void startup(){
    		System.out.println("disk startup!");
    	}
    	
    	public void shutdown(){
    		System.out.println("disk shutdown!");
    	}
    }
    public class Computer {
    	private CPU cpu;
    	private Memory memory;
    	private Disk disk;
    	
    	public Computer(){
    		cpu = new CPU();
    		memory = new Memory();
    		disk = new Disk();
    	}
    	
    	public void startup(){
    		System.out.println("start the computer!");
    		cpu.startup();
    		memory.startup();
    		disk.startup();
    		System.out.println("start computer finished!");
    	}
    	
    	public void shutdown(){
    		System.out.println("begin to close the computer!");
    		cpu.shutdown();
    		memory.shutdown();
    		disk.shutdown();
    		System.out.println("computer closed!");
    	}
    }

    User类如下:

    public class User {
     
    	public static void main(String[] args) {
    		Computer computer = new Computer();
    		computer.startup();
    		computer.shutdown();
    	}
    }

    输出:

    start the computer!
    cpu startup!
    memory startup!
    disk startup!
    start computer finished!
    begin to close the computer!
    cpu shutdown!
    memory shutdown!
    disk shutdown!
    computer closed!

    如果我们没有Computer类,那么,CPU、Memory、Disk他们之间将会相互持有实例,产生关系,这样会造成严重的依赖,修改一个类,可能会带来其他类的修改,这不是我们想要看到的,有了Computer类,他们之间的关系被放在了Computer类里,这样就起到了解耦的作用,这就是外观模式!

    J、桥接模式

    桥接模式就是把事物和其具体实现分开,使他们可以各自独立的变化。桥接的用意是:将抽象化与实现化解耦,使得二者可以独立变化,它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度。像我们常用的JDBC桥DriverManager一样,JDBC进行连接数据库的时候,在各个数据库之间进行切换,基本不需要动太多的代码,甚至丝毫不用动,原因就是JDBC提供统一接口,每个数据库提供各自的实现,用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图:

    实现代码:

    先定义接口:

    public interface Sourceable {
    	public void method();
    }

    分别定义两个实现类:

    public class SourceSub1 implements Sourceable {
     
    	@Override
    	public void method() {
    		System.out.println("this is the first sub!");
    	}
    }
    public class SourceSub2 implements Sourceable {
     
    	@Override
    	public void method() {
    		System.out.println("this is the second sub!");
    	}
    }

     定义一个桥,持有Sourceable的一个实例:

    public abstract class Bridge {
    	private Sourceable source;
     
    	public void method(){
    		source.method();
    	}
    	
    	public Sourceable getSource() {
    		return source;
    	}
     
    	public void setSource(Sourceable source) {
    		this.source = source;
    	}
    }
    public class MyBridge extends Bridge {
    	public void method(){
    		getSource().method();
    	}
    }

     测试类:

    public class BridgeTest {
    	
    	public static void main(String[] args) {
    		
    		Bridge bridge = new MyBridge();
    		
    		/*调用第一个对象*/
    		Sourceable source1 = new SourceSub1();
    		bridge.setSource(source1);
    		bridge.method();
    		
    		/*调用第二个对象*/
    		Sourceable source2 = new SourceSub2();
    		bridge.setSource(source2);
    		bridge.method();
    	}
    }

    output:

    this is the first sub!
    this is the second sub!

    这样,就通过对Bridge类的调用,实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用。接下来我再画个图,大家就应该明白了,因为这个图是我们JDBC连接的原理,有数据库学习基础的,一结合就都懂了。
     

    K、组合模式(Composite)

    组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便,看看关系图:

     直接来看代码:

    public class TreeNode {
    	
    	private String name;
    	private TreeNode parent;
    	private Vector<TreeNode> children = new Vector<TreeNode>();
    	
    	public TreeNode(String name){
    		this.name = name;
    	}
     
    	public String getName() {
    		return name;
    	}
     
    	public void setName(String name) {
    		this.name = name;
    	}
     
    	public TreeNode getParent() {
    		return parent;
    	}
     
    	public void setParent(TreeNode parent) {
    		this.parent = parent;
    	}
    	
    	//添加孩子节点
    	public void add(TreeNode node){
    		children.add(node);
    	}
    	
    	//删除孩子节点
    	public void remove(TreeNode node){
    		children.remove(node);
    	}
    	
    	//取得孩子节点
    	public Enumeration<TreeNode> getChildren(){
    		return children.elements();
    	}
    }
    public class Tree {
     
    	TreeNode root = null;
     
    	public Tree(String name) {
    		root = new TreeNode(name);
    	}
     
    	public static void main(String[] args) {
    		Tree tree = new Tree("A");
    		TreeNode nodeB = new TreeNode("B");
    		TreeNode nodeC = new TreeNode("C");
    		
    		nodeB.add(nodeC);
    		tree.root.add(nodeB);
    		System.out.println("build the tree finished!");
    	}
    }

    使用场景:将多个对象组合在一起进行操作,常用于表示树形结构中,例如二叉树,数等。

    L、享元模式(Flyweight)

    享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。

    FlyWeightFactory负责创建和管理享元单元,当一个客户端请求时,工厂需要检查当前对象池中是否有符合条件的对象,如果有,就返回已经存在的对象,如果没有,则创建一个新对象,FlyWeight是超类。一提到共享池,我们很容易联想到Java里面的JDBC连接池,想想每个连接的特点,我们不难总结出:适用于作共享的一些个对象,他们有一些共有的属性,就拿数据库连接池来说,url、driverClassName、username、password及dbname,这些属性对于每个连接来说都是一样的,所以就适合用享元模式来处理,建一个工厂类,将上述类似属性作为内部数据,其它的作为外部数据,在方法调用时,当做参数传进来,这样就节省了空间,减少了实例的数量。

    看个例子:

    看下数据库连接池的代码:

    public class ConnectionPool {
    	
    	private Vector<Connection> pool;
    	
    	/*公有属性*/
    	private String url = "jdbc:mysql://localhost:3306/test";
    	private String username = "root";
    	private String password = "root";
    	private String driverClassName = "com.mysql.jdbc.Driver";
     
    	private int poolSize = 100;
    	private static ConnectionPool instance = null;
    	Connection conn = null;
     
    	/*构造方法,做一些初始化工作*/
    	private ConnectionPool() {
    		pool = new Vector<Connection>(poolSize);
     
    		for (int i = 0; i < poolSize; i++) {
    			try {
    				Class.forName(driverClassName);
    				conn = DriverManager.getConnection(url, username, password);
    				pool.add(conn);
    			} catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
     
    	/* 返回连接到连接池 */
    	public synchronized void release() {
    		pool.add(conn);
    	}
     
    	/* 返回连接池中的一个数据库连接 */
    	public synchronized Connection getConnection() {
    		if (pool.size() > 0) {
    			Connection conn = pool.get(0);
    			pool.remove(conn);
    			return conn;
    		} else {
    			return null;
    		}
    	}
    }

    通过连接池的管理,实现了数据库连接的共享,不需要每一次都重新创建连接,节省了数据库重新创建的开销,提升了系统的性能! 

    行为型模式(11种):用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,以及怎样分配职责。

    M、策略模式(strategy)

    策略(Strategy)模式:定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的改变不会影响使用算法的客户。需要设计一个接口,为一系列实现类提供统一的方法,多个实现类实现该接口,设计一个抽象类(可有可无,属于辅助类),提供辅助函数,关系图如下:

     图中ICalculator提供统一的方法,AbstractCalculator是辅助类,提供辅助方法,接下来,依次实现下每个类:

    首先统一接口:

    public interface ICalculator {
    	public int calculate(String exp);
    }

     辅助类:

    public abstract class AbstractCalculator {
    	
    	public int[] split(String exp,String opt){
    		String array[] = exp.split(opt);
    		int arrayInt[] = new int[2];
    		arrayInt[0] = Integer.parseInt(array[0]);
    		arrayInt[1] = Integer.parseInt(array[1]);
    		return arrayInt;
    	}
    }

     三个实现类:

    public class Plus extends AbstractCalculator implements ICalculator {
     
    	@Override
    	public int calculate(String exp) {
    		int arrayInt[] = split(exp,"\\+");
    		return arrayInt[0]+arrayInt[1];
    	}
    }
    public class Minus extends AbstractCalculator implements ICalculator {
     
    	@Override
    	public int calculate(String exp) {
    		int arrayInt[] = split(exp,"-");
    		return arrayInt[0]-arrayInt[1];
    	}
     
    }
    public class Multiply extends AbstractCalculator implements ICalculator {
     
    	@Override
    	public int calculate(String exp) {
    		int arrayInt[] = split(exp,"\\*");
    		return arrayInt[0]*arrayInt[1];
    	}
    }

    简单的测试类: 

    public class StrategyTest {
     
    	public static void main(String[] args) {
    		String exp = "2+8";
    		ICalculator cal = new Plus();
    		int result = cal.calculate(exp);
    		System.out.println(result);
    	}
    }

    输出:10

    策略模式的决定权在用户,系统本身提供不同算法的实现,新增或者删除算法,对各种算法做封装。因此,策略模式多用在算法决策系统中,外部用户只需要决定用哪个算法即可。

    N、模板方法模式(Template Method)

    模板方法(TemplateMethod)模式:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。即:一个抽象类中,有一个主方法,再定义1...n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用,先看个关系图:

     就是在AbstractCalculator类中定义一个主方法calculate,calculate()调用spilt()等,Plus和Minus分别继承AbstractCalculator类,通过对AbstractCalculator的调用实现对子类的调用,看下面的例子:

    public abstract class AbstractCalculator {
    	
    	/*主方法,实现对本类其它方法的调用*/
    	public final int calculate(String exp,String opt){
    		int array[] = split(exp,opt);
    		return calculate(array[0],array[1]);
    	}
    	
    	/*被子类重写的方法*/
    	abstract public int calculate(int num1,int num2);
    	
    	public int[] split(String exp,String opt){
    		String array[] = exp.split(opt);
    		int arrayInt[] = new int[2];
    		arrayInt[0] = Integer.parseInt(array[0]);
    		arrayInt[1] = Integer.parseInt(array[1]);
    		return arrayInt;
    	}
    }
    public class Plus extends AbstractCalculator {
     
    	@Override
    	public int calculate(int num1,int num2) {
    		return num1 + num2;
    	}
    }

     测试类:

    public class StrategyTest {
     
    	public static void main(String[] args) {
    		String exp = "8+8";
    		AbstractCalculator cal = new Plus();
    		int result = cal.calculate(exp, "\\+");
    		System.out.println(result);
    	}
    }

    我跟踪下这个小程序的执行过程:首先将exp和"\\+"做参数,调用AbstractCalculator类里的calculate(String,String)方法,在calculate(String,String)里调用同类的split(),之后再调用calculate(int ,int)方法,从这个方法进入到子类中,执行完return num1 + num2后,将值返回到AbstractCalculator类,赋给result,打印出来。正好验证了我们开头的思路。

    O、观察者模式(Observer)

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

    我解释下这些类的作用:MySubject类就是我们的主对象,Observer1和Observer2是依赖于MySubject的对象,当MySubject变化时,Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表,可以对其进行修改:增加或删除被监控对象,且当MySubject变化时,负责通知在列表内存在的对象。我们看实现代码:

    一个Observer接口:

    public interface Observer {
    	public void update();
    }

     两个实现类:

    public class Observer1 implements Observer {
     
    	@Override
    	public void update() {
    		System.out.println("observer1 has received!");
    	}
    }
    public class Observer2 implements Observer {
     
    	@Override
    	public void update() {
    		System.out.println("observer2 has received!");
    	}
    }

     Subject接口及实现类:

    public interface Subject {
    	
    	/*增加观察者*/
    	public void add(Observer observer);
    	
    	/*删除观察者*/
    	public void del(Observer observer);
    	
    	/*通知所有的观察者*/
    	public void notifyObservers();
    	
    	/*自身的操作*/
    	public void operation();
    }
    public abstract class AbstractSubject implements Subject {
     
    	private Vector<Observer> vector = new Vector<Observer>();
    	@Override
    	public void add(Observer observer) {
    		vector.add(observer);
    	}
     
    	@Override
    	public void del(Observer observer) {
    		vector.remove(observer);
    	}
     
    	@Override
    	public void notifyObservers() {
    		Enumeration<Observer> enumo = vector.elements();
    		while(enumo.hasMoreElements()){
    			enumo.nextElement().update();
    		}
    	}
    }
    public class MySubject extends AbstractSubject {
     
    	@Override
    	public void operation() {
    		System.out.println("update self!");
    		notifyObservers();
    	}
     
    }
    public class MySubject extends AbstractSubject {
     
    	@Override
    	public void operation() {
    		System.out.println("update self!");
    		notifyObservers();
    	}
     
    }

     测试类:

    public class ObserverTest {
     
    	public static void main(String[] args) {
    		Subject sub = new MySubject();
    		sub.add(new Observer1());
    		sub.add(new Observer2());
    		
    		sub.operation();
    	}
     
    }

    输出:

    update self!
    observer1 has received!
    observer2 has received!

    P、迭代子模式(Iterator)

    迭代器(Iterator)模式:提供一种方法来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。这句话包含两层意思:一是需要遍历的对象,即聚集对象,二是迭代器对象,用于对聚集对象进行遍历访问。我们看下关系图:

    这个思路和我们常用的一模一样,MyCollection中定义了集合的一些操作,MyIterator中定义了一系列迭代操作,且持有Collection实例,我们来看看实现代码:

    两个接口:

    public interface Collection {
    	
    	public Iterator iterator();
    	
    	/*取得集合元素*/
    	public Object get(int i);
    	
    	/*取得集合大小*/
    	public int size();
    }
    public interface Iterator {
    	//前移
    	public Object previous();
    	
    	//后移
    	public Object next();
    	public boolean hasNext();
    	
    	//取得第一个元素
    	public Object first();
    }

     两个实现:

    public class MyIterator implements Iterator {
     
    	private Collection collection;
    	private int pos = -1;
    	
    	public MyIterator(Collection collection){
    		this.collection = collection;
    	}
    	
    	@Override
    	public Object previous() {
    		if(pos > 0){
    			pos--;
    		}
    		return collection.get(pos);
    	}
     
    	@Override
    	public Object next() {
    		if(pos<collection.size()-1){
    			pos++;
    		}
    		return collection.get(pos);
    	}
     
    	@Override
    	public boolean hasNext() {
    		if(pos<collection.size()-1){
    			return true;
    		}else{
    			return false;
    		}
    	}
     
    	@Override
    	public Object first() {
    		pos = 0;
    		return collection.get(pos);
    	}
     
    }
    public class MyCollection implements Collection {
     
    	public String string[] = {"A","B","C","D","E"};
    	@Override
    	public Iterator iterator() {
    		return new MyIterator(this);
    	}
     
    	@Override
    	public Object get(int i) {
    		return string[i];
    	}
     
    	@Override
    	public int size() {
    		return string.length;
    	}
    }

     测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		Collection collection = new MyCollection();
    		Iterator it = collection.iterator();
    		
    		while(it.hasNext()){
    			System.out.println(it.next());
    		}
    	}
    }

    输出:A B C D E

    此处我们貌似模拟了一个集合类的过程,感觉是不是很爽?其实JDK中各个类也都是这些基本的东西,加一些设计模式,再加一些优化放到一起的,只要我们把这些东西学会了,掌握好了,我们也可以写出自己的集合类,甚至框架!

    Q、责任链模式(Chain of Responsibility)

    职责链(Chain of Responsibility)模式:把请求从链中的一个对象传到下一个对象,直到请求被响应为止。通过这种方式去除对象之间的耦合。发出者并不清楚到底最终那个对象会处理该请求,所以,责任链模式可以实现,在隐瞒客户端的情况下,对系统进行动态的调整。先看看关系图:

    Abstracthandler类提供了get和set方法,方便MyHandle类设置和修改引用对象,MyHandle类是核心,实例化后生成一系列相互持有的对象,构成一条链。

    public interface Handler {
    	public void operator();
    }
    public abstract class AbstractHandler {
    	
    	private Handler handler;
     
    	public Handler getHandler() {
    		return handler;
    	}
     
    	public void setHandler(Handler handler) {
    		this.handler = handler;
    	}
    	
    }
    public class MyHandler extends AbstractHandler implements Handler {
     
    	private String name;
     
    	public MyHandler(String name) {
    		this.name = name;
    	}
     
    	@Override
    	public void operator() {
    		System.out.println(name+"deal!");
    		if(getHandler()!=null){
    			getHandler().operator();
    		}
    	}
    }
    public class Test {
     
    	public static void main(String[] args) {
    		MyHandler h1 = new MyHandler("h1");
    		MyHandler h2 = new MyHandler("h2");
    		MyHandler h3 = new MyHandler("h3");
     
    		h1.setHandler(h2);
    		h2.setHandler(h3);
     
    		h1.operator();
    	}
    }

    输出:

    h1deal!
    h2deal!
    h3deal!

    此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。

    R、命令模式(Command)

    命令(Command)模式:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分割开。命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。这个过程好在,三者相互解耦,任何一方都不用去依赖其他人,只需要做好自己的事儿就行,司令员要的是结果,不会去关注到底士兵是怎么实现的。我们看看关系图:
     

    Invoker是调用者(司令员),Receiver是被调用者(士兵),MyCommand是命令,实现了Command接口,持有接收对象,看实现代码:

    public interface Command {
    	public void exe();
    }
    public class MyCommand implements Command {
     
    	private Receiver receiver;
    	
    	public MyCommand(Receiver receiver) {
    		this.receiver = receiver;
    	}
     
    	@Override
    	public void exe() {
    		receiver.action();
    	}
    }
    public class Receiver {
    	public void action(){
    		System.out.println("command received!");
    	}
    }
    public class Invoker {
    	
    	private Command command;
    	
    	public Invoker(Command command) {
    		this.command = command;
    	}
     
    	public void action(){
    		command.exe();
    	}
    }
    public class Test {
     
    	public static void main(String[] args) {
    		Receiver receiver = new Receiver();
    		Command cmd = new MyCommand(receiver);
    		Invoker invoker = new Invoker(cmd);
    		invoker.action();
    	}
    }

    输出:command received!

    这个很哈理解,命令模式的目的就是将命令的发出者和执行者之间解耦,实现请求和执行分开,熟悉Struts的同学应该知道,Struts其实就是一种将请求和呈现分离的技术,其中必然涉及命令模式的思想!

    S、备忘录模式(Memento)

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

    Original类是原始类,里面有需要保存的属性value及创建一个备忘录类,用来保存value值。Memento类是备忘录类,Storage类是存储备忘录的类,持有Memento类的实例,该模式很好理解。直接看源码

    public class Original {
    	
    	private String value;
    	
    	public String getValue() {
    		return value;
    	}
     
    	public void setValue(String value) {
    		this.value = value;
    	}
     
    	public Original(String value) {
    		this.value = value;
    	}
     
    	public Memento createMemento(){
    		return new Memento(value);
    	}
    	
    	public void restoreMemento(Memento memento){
    		this.value = memento.getValue();
    	}
    }
    public class Memento {
    	
    	private String value;
     
    	public Memento(String value) {
    		this.value = value;
    	}
     
    	public String getValue() {
    		return value;
    	}
     
    	public void setValue(String value) {
    		this.value = value;
    	}
    }
    public class Storage {
    	
    	private Memento memento;
    	
    	public Storage(Memento memento) {
    		this.memento = memento;
    	}
     
    	public Memento getMemento() {
    		return memento;
    	}
     
    	public void setMemento(Memento memento) {
    		this.memento = memento;
    	}
    }

     测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		
    		// 创建原始类
    		Original origi = new Original("egg");
     
    		// 创建备忘录
    		Storage storage = new Storage(origi.createMemento());
     
    		// 修改原始类的状态
    		System.out.println("初始化状态为:" + origi.getValue());
    		origi.setValue("niu");
    		System.out.println("修改后的状态为:" + origi.getValue());
     
    		// 回复原始类的状态
    		origi.restoreMemento(storage.getMemento());
    		System.out.println("恢复后的状态为:" + origi.getValue());
    	}
    }

    输出:

    初始化状态为:egg
    修改后的状态为:niu
    恢复后的状态为:egg

    简单描述下:新建原始类时,value被初始化为egg,后经过修改,将value的值置为niu,最后倒数第二行进行恢复状态,结果成功恢复了。其实我觉得这个模式叫“备份-恢复”模式最形象。

    T、状态模式(State)

    状态(State)模式:允许一个对象在其内部状态发生改变时改变其行为能力。比如QQ来说,有几种状态,在线、隐身、忙碌等,每个状态对应不同的操作,而且你的好友也能看到你的状态,所以,状态模式就两点:1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。看图:

    State类是个状态类,Context类可以实现切换,我们来看看代码:

    /**
     * 状态类的核心类
     */
    public class State {
    	
    	private String value;
    	
    	public String getValue() {
    		return value;
    	}
     
    	public void setValue(String value) {
    		this.value = value;
    	}
     
    	public void method1(){
    		System.out.println("execute the first opt!");
    	}
    	
    	public void method2(){
    		System.out.println("execute the second opt!");
    	}
    }
    /**
     * 状态模式的切换类
     */
    public class Context {
     
    	private State state;
     
    	public Context(State state) {
    		this.state = state;
    	}
     
    	public State getState() {
    		return state;
    	}
     
    	public void setState(State state) {
    		this.state = state;
    	}
     
    	public void method() {
    		if (state.getValue().equals("state1")) {
    			state.method1();
    		} else if (state.getValue().equals("state2")) {
    			state.method2();
    		}
    	}
    }

     测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		
    		State state = new State();
    		Context context = new Context(state);
    		
    		//设置第一种状态
    		state.setValue("state1");
    		context.method();
    		
    		//设置第二种状态
    		state.setValue("state2");
    		context.method();
    	}
    }

    输出:

    execute the first opt!
    execute the second opt!

    根据这个特性,状态模式在日常开发中用的挺多的,尤其是做网站的时候,我们有时希望根据对象的某一属性,区别开他们的一些功能,比如说简单的权限控制等。

    U、访问者模式(Visitor)

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

    访问者模式把数据结构和作用于结构上的操作解耦合,使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化,经常有新的数据对象增加进来,则不适合使用访问者模式。访问者模式的优点是增加操作很容易,因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中,其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。—— From 百科

    简单来说,访问者模式就是一种分离对象数据结构与行为的方法,通过这种分离,可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。简单关系图:

    来看看原码:一个Visitor类,存放要访问的对象,

    public interface Visitor {
    	public void visit(Subject sub);
    }
    public class MyVisitor implements Visitor {
     
    	@Override
    	public void visit(Subject sub) {
    		System.out.println("visit the subject:"+sub.getSubject());
    	}
    }

    Subject类,accept方法,接受将要访问它的对象,getSubject()获取将要被访问的属性,

    public interface Subject {
    	public void accept(Visitor visitor);
    	public String getSubject();
    }
    public class MySubject implements Subject {
     
    	@Override
    	public void accept(Visitor visitor) {
    		visitor.visit(this);
    	}
     
    	@Override
    	public String getSubject() {
    		return "love";
    	}
    }

    测试:

    public class Test {
     
    	public static void main(String[] args) {
    		
    		Visitor visitor = new MyVisitor();
    		Subject sub = new MySubject();
    		sub.accept(visitor);	
    	}
    }

     输出:visit the subject:love

    该模式适用场景:如果我们想为一个现有的类增加新功能,不得不考虑几个事情:

    1. 新功能会不会与现有功能出现兼容性问题?
    2. 以后会不会再需要添加?
    3. 如果类不允许修改代码怎么办?

    面对这些问题,最好的解决方法就是使用访问者模式,访问者模式适用于数据结构相对稳定的系统,把数据结构和算法解耦。

    V、中介者模式(Mediator)

    中介者(Mediator)模式:定义一个中介对象来简化原有对象之间的交互关系,降低系统中对象间的耦合度,使原有对象之间不必相互了解。中介者模式也是用来降低类类之间的耦合的,因为如果类类之间有依赖关系的话,不利于功能的拓展和维护,因为只要修改一个对象,其它关联的对象都得进行修改。如果使用中介者模式,只需关心和Mediator类的关系,具体类类之间的关系及调度交给Mediator就行,这有点像spring容器的作用。先看看图:

     User类统一接口,User1和User2分别是不同的对象,二者之间有关联,如果不采用中介者模式,则需要二者相互持有引用,这样二者的耦合度很高,为了解耦,引入了Mediator类,提供统一接口,MyMediator为其实现类,里面持有User1和User2的实例,用来实现对User1和User2的控制。这样User1和User2两个对象相互独立,他们只需要保持好和Mediator之间的关系就行,剩下的全由MyMediator类来维护!基本实现:

    public interface Mediator {
    	public void createMediator();
    	public void workAll();
    }
    public class MyMediator implements Mediator {
     
    	private User user1;
    	private User user2;
    	
    	public User getUser1() {
    		return user1;
    	}
     
    	public User getUser2() {
    		return user2;
    	}
     
    	@Override
    	public void createMediator() {
    		user1 = new User1(this);
    		user2 = new User2(this);
    	}
     
    	@Override
    	public void workAll() {
    		user1.work();
    		user2.work();
    	}
    }
    public abstract class User {
    	
    	private Mediator mediator;
    	
    	public Mediator getMediator(){
    		return mediator;
    	}
    	
    	public User(Mediator mediator) {
    		this.mediator = mediator;
    	}
     
    	public abstract void work();
    }
    public class User1 extends User {
     
    	public User1(Mediator mediator){
    		super(mediator);
    	}
    	
    	@Override
    	public void work() {
    		System.out.println("user1 exe!");
    	}
    }
    public class User2 extends User {
     
    	public User2(Mediator mediator){
    		super(mediator);
    	}
    	
    	@Override
    	public void work() {
    		System.out.println("user2 exe!");
    	}
    }

    测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		Mediator mediator = new MyMediator();
    		mediator.createMediator();
    		mediator.workAll();
    	}
    }

    输出:

    user1 exe!
    user2 exe!

    W、解释器模式(Interpreter)

    解释器(Interpreter)模式:提供如何定义语言的文法,以及对语言句子的解释方法,即解释器。一般主要应用在OOP开发中的编译器的开发中,所以适用面比较窄。

    Context类是一个上下文环境类,Plus和Minus分别是用来计算的实现,代码如下:

    public interface Expression {
    	public int interpret(Context context);
    }
    public class Plus implements Expression {
     
    	@Override
    	public int interpret(Context context) {
    		return context.getNum1()+context.getNum2();
    	}
    }
    public class Minus implements Expression {
     
    	@Override
    	public int interpret(Context context) {
    		return context.getNum1()-context.getNum2();
    	}
    }
    public class Context {
    	
    	private int num1;
    	private int num2;
    	
    	public Context(int num1, int num2) {
    		this.num1 = num1;
    		this.num2 = num2;
    	}
    	
    	public int getNum1() {
    		return num1;
    	}
    	public void setNum1(int num1) {
    		this.num1 = num1;
    	}
    	public int getNum2() {
    		return num2;
    	}
    	public void setNum2(int num2) {
    		this.num2 = num2;
    	}
    	
    	
    }
    public class Test {
     
    	public static void main(String[] args) {
     
    		// 计算9+2-8的值
    		int result = new Minus().interpret((new Context(new Plus()
    				.interpret(new Context(9, 2)), 8)));
    		System.out.println(result);
    	}
    }

    最后输出正确的结果:3。

    基本就这样,解释器模式用来做各种各样的解释器,如正则表达式等的解释器等等!

    展开全文
  • java io中涉及的设计模式

    千次阅读 2016-06-28 21:49:04
    java io中涉及的设计模式介绍先看一段代码,查看其中涉及的模式public void testInputStreamReader() throws Exception { private static final String SEPARATOR = File.separator; File file = new File("e:...
  • Java笔试面试-设计模式

    万次阅读 多人点赞 2019-10-24 09:57:49
    1.说一下设计模式?你都知道哪些? 答:设计模式总共有 23 种,总体来说可以分为三大类:创建型模式( Creational Patterns )、结构型模式( Structural Patterns )和行为型模式( Behavioral Patterns )。   ...
  • Java之美[从菜鸟高手演变]之设计模式

    万次阅读 多人点赞 2012-11-29 02:26:22
    设计模式(Design Patterns) ——可复用面向对象软件的基础设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人...
  • Java中23种设计模式的详细介绍

    万次阅读 多人点赞 2019-12-17 10:50:52
    Java开发中23种设计模式详细介绍设计模式介绍设计模式分类设计模式六大原则开闭原则(Open Close Principle)里氏代换原则 设计模式介绍 设计模式(Design Patterns): 一套被反复使用,多数人知晓,经过分类编目,代码...
  • Java设计模式之状态模式

    万次阅读 多人点赞 2015-04-14 07:54:13
    本文属于"23种设计模式"系列,介绍状态模式。
  • Java设计模式——开放设计模式

    千次阅读 2018-04-13 16:22:17
    我们聊过的这些设计模式都会遵循一个原则,就是面向对象的原则,高内聚低耦合使我们开发的核心思想,降低代码之间的耦合度使我们程序员的终极追求,今天和大家聊的是开放封闭设计模式。开放封闭设计模式:软件实体...
  • java IO体系之设计模式详解——01

    千次阅读 2013-11-08 23:46:38
    java IO体系之设计模式详解——01  一。引子(概括地介绍Java的IO)  无论是哪种编程语言,输入跟输出都是重要的一部分,Java也不例外,而且Java将输入/输出的功能和使用范畴做了很大的扩充。它采用了...
  • java设计模式

    千次阅读 2012-04-04 16:09:50
    Java设计模式 分类: java学习 2011-09-04 20:48 883人阅读 评论(6) 收藏 举报 设计模式公司荣誉出品 您的设计模式 我们的设计模式 CBF4LIFE 2009 年5 月 我希望这本书的阅读者具备最基本的代码编写能力,...
  • JAVA设计模式之原型模式

    万次阅读 多人点赞 2014-04-08 08:22:45
    定义:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。...在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在ja
  • Java设计模式常见使用场景

    万次阅读 多人点赞 2018-05-09 16:07:16
    一、Java I/O中的设计模式1、适配器模式适配器模式就是把一个类的接口变换成客户端所能接受的另一种接口,从而使两个接口不匹配而无法在一起工作的两个类能够在一起工作。通常被用在一个项目需要引用一些开源框架来...
  • Java设计模式—原型模式

    千次阅读 2016-09-03 11:39:24
    (尊重劳动成果,转载请注明出处:... 目录 个人理解: 定义: 通用类图如下所示: ...原型模式使用场景 ● 资源优化场景 ● 性能和安全要求的场景 ● 一个对象多个修改者的场景 原型模式的...
  • 希望你也加入人工智能的队伍中来!请点击http://www.captainbed.net Definition Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subcla...
  • java设计模式汇总

    千次阅读 2017-09-28 16:16:30
    翻译与github 上 java design 项目,旨在提供java设计模式的速查。 引用 [3]java 设计模式目录前言 目录 抽象文档 意图 适用范围 权威信息 例子实现分析 抽象工厂 意图 解释 适用范围 用例 结论 现实世界的例子 ...
  • JAVA设计模式--原型模式

    万次阅读 2016-05-23 19:48:46
    目录 一、什么是原型模式 二、原型模式实现 简单形式 登记形式 三、Java中的深拷贝与浅拷贝(或深度克隆与浅度克隆) ...四、原型模式应用场景 ...所以,使用原型模式创建的实例,具有与原型实例一样的数据。 ...
  • Java设计模式-原型模式

    千次阅读 2019-04-30 10:30:53
    原型模式
  • java 23种设计模式详解

    万次阅读 多人点赞 2016-07-01 14:45:14
    设计模式的分类总体来说设计模式分为三大类:创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合...
  • Java设计模式】责任链模式

    千次阅读 2019-07-12 09:37:00
    文章目录概述适用场景优点缺点责任链模式-相关设计模式演示 概述 ◆ 为请求创建一个接收此次请求对象的链 ◆ 类型:行为型 适用场景 ◆ 一个请求的处理需要多个对象当中的一个或几个协作处理 优点 ◆ 请求的发送者和...
  • java设计模式例题

    千次阅读 2019-01-06 00:01:32
    java设计模式例题 问题1:某软件公司要基于面向对象开发一套图表库,该图表库可以为应用系统提供多种不同外观的图表,例如柱状图(HistogramChart)、饼状图(PieChart)、折线图(LineChart)等。该软件公司图表库设计...
  • Java IO中涉及哪些设计模式
  • 装饰者模式动态地将责任附加对象上。若要扩展功能,装饰者提供了比继承更有弹性 的替代方案。 装饰者模式设计类之间的关系: 其中Component是一个超类,ConcreteComponen是被装饰者,Decorator是装饰者,装饰...
  • Java设计模式博客全目录

    千次阅读 2014-10-13 02:04:52
    今天来对这23种设计模式做个总结。...咱不能为了使用设计模式使用,而是在分析问题的过程中,想到使用某种设计模式能达到咱需要的效果,而且比不使用设计模式更有优势,那么咱该考虑使用设计模式了。
  • Java设计模式之起始

    千次阅读 2014-03-11 10:42:52
    摘要:本系列笔记记录了学习设计模式的一些学习过程和所获、不会记录全部四人组的23种设计模式、应用驱动学习、主要记录了常用的一些设计模式设计模式没有对与错、大胆设计、细心求证、切勿设计过头!
  • Java IO 中的设计模式

    千次阅读 2008-07-15 14:07:00
    Java IO 中的设计模式作者:终南 li.zhongnan@hotmail.com> 设计模式是一个很理论的,也是一个很经验的东西...其实,在JDK中就使用了很多设计模式,为类库的可重用性、可扩展性和灵活性提供了强有力的支持。JDK的I/O包
  • java 类库和框架中用设计模式

    千次阅读 2017-09-15 14:12:39
    有一些处理器可以对另一些处理器起装饰作用,形成新的、具有改善了的功能的处理器。 适配器模式: 有一些处理器是数组适配器对流处理器的适配。   Java 集合框架 装饰器模式: 通过阅读源码发现TreeSet和...
  • [Java设计模式之单例模式]

    万次阅读 2018-05-15 20:28:40
    Java程序中,要说用到的设计模式中,单例(Singleton)模式可能是使用最多的一种设计模式了。一些管理器和控制器常被设计成单例模式,在Spring中, 一个Component就只有一个实例在Java-Web中, 一个Servlet类只有一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 248,807
精华内容 99,522
关键字:

java流使用到的设计模式

java 订阅