设计模式 重点版(常用10个)

创建型(创建对象): 2 个 (工厂模式, 单例模式)

结构型: 6 个 (适配器模式, 组合模式, 装饰者模式, 代理模式, 外观模式, 桥梁模式)

行为型: 8 个 (中介者模式, 策略模式, 模板模式, 观察者模式, 迭代器模式, 责任链模式, 命令模式, 状态模式)

1. 工厂模式

提供一个创建类的统一接口.

目的: 每次创建类时, 只需要调用这个接口就可以了, 不用每次都需要写一次创建代码

 

上面是简单的工厂模式, 正常的工厂方法模式, 就是针对每个类, 都要创建一个工厂类. 但是他们可以实现共同的接口. (这种模式映射了之前我看的object c 的那本书), 一般用简单的工厂模式就可以了.

2. 单例模式

保证在内存中一个类只有一个实例存在, 并且提供一个访问该实例的全局访问点.

目的: 例如一个系统中可能存在多个打印任务, 但是只能一个正在工作的打印任务在内存中.

 

饿汉式: 类加载时, 就创建好了这个单例( 很饿, 所以要立刻吃, 立刻加载)

懒加载(懒汉式):  可以用的时候再加载 (吃的时候再说, 不是一开始就把饭做好)

如果 getInstance() 使用频率很高, 那肯定是饿汉式好.

 

 

利用 反射 破解单例模式

实际上, 在构造器函数内, 加一句话就可以防止反射破解单例

if (instance != null) {

　　throw new RuntimeException();    // 也就是多次多用构造器时, 抛出异常

} 

通过反序列化的方式 构造多个对象, 破解单例

首先，通过序列化把对象写到硬盘上， 然后在把这个对象反序列化读回到程序中, 这时就不是之前的对象了.

如何防止序列化, 通过定义一个 readResolve() 方法 , 这个方法的作用是，在反序列化时, 如果这个类已经定义了实例, 直接返回这个实例就可以了, 不需要new一个新的了.

3. 适配器模式

将一个类的接口转换成客户希望的另一个接口.

目的: 比如我们去别的地方, 我们的插座的方向头是不一样的, 比如(中国, 德国 我出差去德国), 适配器需要满足以下要求:

(1) 必须符合德国标准的接口，否则的话还是没办法插到德国插座中

(2) 在调用上面实现的德标接口进行充电时，提供一种机制，将这个调用转到对国标接口的调用

这就要求:

(1) 适配器必须实现原有的旧的接口

(2) 适配器对象中持有对新接口的引用，当调用旧接口时，将这个调用委托给实现新接口的对象来处理，也就是在适配器对象中组合一个新接口

4. 组合模式

将对象组合成树型结构以表示“部分---整体”的层次结构

组合模式类似 “树”

component: 组合中对象的接口声明

composite: 树枝结点(有子节点)

leaf: 树叶结点(无子节点)

目的: 就是你想要这种层次关系的类时, 就可以使用.

例如: 各部门之间的层级关系

抽象接口类：
 
package com.zyh.designpattern.composite;
 
public abstract class Company {
 
private String name;
 
public Company(String name) {
 
super();
 
this.name = name;
 
}
 
public Company(){}
 
public String getName() {
 
return name;
 
}
 
public void setName(String name) {
 
this.name = name;
 
}
 
protected abstract void add(Company company);
 
protected abstract void romove(Company company);
 
protected abstract void display(int depth);
 
}
 
枝结点类：
 
package com.zyh.designpattern.composite;
 
import java.util.ArrayList;
 
import java.util.List;
 
public class ConcreteCompany extends Company {
 
private List cList;　public ConcreteCompany() {　cList = new ArrayList();　}　public ConcreteCompany(String name) {　super(name);　cList = new ArrayList();　}　@Override
 
protected void add(Company company) {
 
// TODO Auto-generated method stub
 
cList.add(company);
 
}
 
@Override
 
protected void display(int depth) {
 
// TODO Auto-generated method stub
 
StringBuilder sb = new StringBuilder("");
 
for (int i = 0; i < depth; i++) {
 
sb.append("-");
 
}
 
System.out.println(new String(sb) + this.getName());
 
for (Company c : cList) {
 
c.display(depth + 2);
 
}
 
}
 
@Override
 
protected void romove(Company company) {
 
// TODO Auto-generated method stub
 
cList.remove(company);
 
}
 
}
 
两个叶结点类：
 
-------------------------1---------------------------.
 
package com.zyh.designpattern.composite;
 
public class HRDepartment extends Company {
 
public HRDepartment(String name) {
 
super(name);
 
}
 
@Override
 
protected void add(Company company) {
 
}
 
@Override
 
protected void display(int depth) {
 
// TODO Auto-generated method stub
 
StringBuilder sb = new StringBuilder("");
 
for (int i = 0; i < depth; i++) {
 
sb.append("-");
 
}
 
System.out.println(new String(sb) + this.getName());
 
}
 
@Override
 
protected void romove(Company company) {
 
}
 
}
 
----------------2-------------------
 
package com.zyh.designpattern.composite;
 
public class FinanceDepartment extends Company {
 
public FinanceDepartment(String name) {
 
super(name);
 
}
 
@Override
 
protected void add(Company company) {
 
}
 
@Override
 
protected void display(int depth) {
 
// TODO Auto-generated method stub
 
StringBuilder sb = new StringBuilder("");
 
for (int i = 0; i < depth; i++) {
 
sb.append("-");
 
}
 
System.out.println(new String(sb) + this.getName());
 
}
 
@Override
 
protected void romove(Company company) {
 
}
 
}
 
客户端：
 
package com.zyh.designpattern.composite;
 
public class Client {
 
public static void main(String[] args) {
 
// TODO Auto-generated method stub
 
Company root = new ConcreteCompany();
 
root.setName("北京总公司");
 
root.add(new HRDepartment("总公司人力资源部"));
 
root.add(new FinanceDepartment("总公司财务部"));
 
Company shandongCom = new ConcreteCompany("山东分公司");
 
shandongCom.add(new HRDepartment("山东分公司人力资源部"));
 
shandongCom.add(new FinanceDepartment("山东分公司账务部"));
 
Company zaozhuangCom = new ConcreteCompany("枣庄办事处");
 
zaozhuangCom.add(new FinanceDepartment("枣庄办事处财务部"));
 
zaozhuangCom.add(new HRDepartment("枣庄办事处人力资源部"));
 
Company jinanCom = new ConcreteCompany("济南办事处");
 
jinanCom.add(new FinanceDepartment("济南办事处财务部"));
 
jinanCom.add(new HRDepartment("济南办事处人力资源部"));
 
shandongCom.add(jinanCom);
 
shandongCom.add(zaozhuangCom);
 
Company huadongCom = new ConcreteCompany("上海华东分公司");
 
huadongCom.add(new HRDepartment("上海华东分公司人力资源部"));
 
huadongCom.add(new FinanceDepartment("上海华东分公司账务部"));
 
Company hangzhouCom = new ConcreteCompany("杭州办事处");
 
hangzhouCom.add(new FinanceDepartment("杭州办事处财务部"));
 
hangzhouCom.add(new HRDepartment("杭州办事处人力资源部"));
 
Company nanjingCom = new ConcreteCompany("南京办事处");
 
nanjingCom.add(new FinanceDepartment("南京办事处财务部"));
 
nanjingCom.add(new HRDepartment("南京办事处人力资源部"));
 
huadongCom.add(hangzhouCom);
 
huadongCom.add(nanjingCom);
 
root.add(shandongCom);
 
root.add(huadongCom);
 
root.display(0);
 
}
 
}

5. 装饰者模式

动态的给一个对象添加一些额外的职责

目的: 需要扩展一个类的功能, 或给一个类增加额外的功能, 例如: 比如生日蛋糕, 有一些级别的蛋糕的情况, 比如, 巧克力蛋糕, 草莓蛋糕等, 但是, 要想在蛋糕上单独加一些东西, 比如加一些花, 等等, 这样, 就可以将基本的蛋糕采用继承关系, 而装饰者有个抽象类, 那些加的花啊什么的, 都是继承这个装饰者类, 参考下边类图

6. 代理模式

为其他对象提供一种代理以控制对这个对象的访问

目的: 对对象访问进行控制, 比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时是这样的体现的

代码如下:

package com.yangguangfu.proxy;
/**
 * 
 * @author 阿福(trygf521@126.com)<br>
 *定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
 */
public interface KindWoman {
    
    //这种女人能做什么事情呢？
    public void makeEyesWithMan();//抛媚眼
    
    public void happyWithMan();//和男人那个....

}

一种类型嘛，那肯定是接口，定义个潘金莲

package com.yangguangfu.proxy;
/**
 * 
 * @author 阿福(trygf521@126.com)<br>
 *定义一个潘金莲是什么样的人
 */
public class PanJinLian  implements KindWoman{

    @Override
    public void happyWithMan() {
        System.out.println("潘金莲和男人在做那个...");
        
    }

    @Override
    public void makeEyesWithMan() {
        System.out.println("潘金莲抛媚眼...");
        
    }

}

再定义个丑陋的王婆

package com.yangguangfu.proxy;
/**
 * 
 * @author 阿福(trygf521@126.com)<br>
 *王婆这个人老聪明了，她太老了，是个男人都看不上她，
 *但是她有智慧经验呀，他作为一类女人的代理！
 */
public class WangPo implements KindWoman {
    
    private KindWoman kindWoman;
    
    public WangPo(){
        //默认的话是潘金莲的代理
        this.kindWoman = new PanJinLian();
    }
    //她可以是KindWomam的任何一个女人的代理，只要你是这一类型
    public WangPo(KindWoman kindWoman){
        this.kindWoman = kindWoman;
    }

    @Override
    public void happyWithMan() {
        //自己老了，干不了了，但可以叫年轻的代替。
        this.kindWoman.happyWithMan();
        
    }

    @Override
    public void makeEyesWithMan() {
        //王婆年纪大了，谁看她抛媚眼啊
        this.kindWoman.makeEyesWithMan();
        
    }

}

两个女主角都上场了，该男主角了，定义个西门庆

package com.yangguangfu.proxy;
/**
 * 
 * @author 阿福(trygf521@126.com)<br>
 *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下：
 *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！
 */
public class XiMenQiang {

    /**
     * @param args
     */
    public static void main(String[] args) {
        WangPo wangPo;
        //把王婆叫出来
         wangPo = new WangPo();
        //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：
        wangPo.makeEyesWithMan();
        //看到没有表面是王婆在做，其实爽的是潘金莲
        wangPo.happyWithMan();
        
        

    }

}

7. 外观模式

为子系统中的一组接口提供一个一致的界面

比如: 不知道大家有没有比较过自己泡茶和去茶馆喝茶的区别，如果是自己泡茶需要自行准备茶叶、茶具和开水，如图1(A)所示，而去茶馆喝茶，最简单的方式就是跟茶馆服务员说想要一杯什么样的茶，是铁观音、碧螺春还是西湖龙井？正因为茶馆有服务员，顾客无须直接和茶叶、茶具、开水等交互，整个泡茶过程由服务员来完成，顾客只需与服务员交互即可，整个过程非常简单省事，如图1(B)所示

在软件开发中，有时候为了完成一项较为复杂的功能，一个客户类需要和多个业务类交互，而这些需要交互的业务类经常会作为一个整体出现，由于涉及到的类比较多，导致使用时代码较为复杂，此时，特别需要一个类似服务员一样的角色，由它来负责和多个业务类进行交互，而客户类只需与该类交互。外观模式通过引入一个新的外观类(Facade)来实现该功能，外观类充当了软件系统中的“服务员”，它为多个业务类的调用提供了一个统一的入口，简化了类与类之间的交互。在外观模式中，那些需要交互的业务类被称为子系统(Subsystem)。如果没有外观类，那么每个客户类需要和多个子系统之间进行复杂的交互，系统的耦合度将很大，如图2(A)所示；而引入外观类之后，客户类只需要直接与外观类交互，客户类与子系统之间原有的复杂引用关系由外观类来实现，从而降低了系统的耦合度，如图2(B)所示。

8. 桥梁模式

桥梁模式将抽象部分与它的实现部分分离

目的: 比如我们有一个画图程序 有2个图形（Circle Rectangle ）和2种画图方法（Drawing1 Drawing2）图形可能会使用Drawing1来画图 也可能使用Drawing2来画图在这个画图程序中有两个可变因素 一个是图形的种类 有可能会增加新的图形 另一个是画图方法 可能会有Drawing3出现.

9. 中介者模式

中介者模式用一个中介对象封装一系列的对象交互

目的: 比如 在生活中，当电脑缺少了一块主板，那会怎么样？如果有人这样问我的话，我就会马上跳出来说“这电脑肯定报废了”，当然这不是重点。假如少了主板电脑还可以用的话，想想，里面的CPU、显卡、声卡、光驱、硬盘等等，不是就要我们自己用线把它们连起来。想想就觉得头疼，那么现在你觉得主板在电脑里扮演着什么角色呢？

例2:

Mediator：中介者接口。在里面定义了各个同事之间相互交互所需要的方法，可以是公共的方法，如Change方法，也可以是小范围的交互方法

ConcreteMediator：具体的中介者实现对象。它需要了解并为维护每个同事对象，并负责具体的协调各个同事对象的交互关系。

Colleague：同事类的定义，通常实现成为抽象类，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象,也就是每个同事对象都会持有中介者对象的引用，这个功能可定义在这个类中。

ConcreteColleague：具体的同事类，实现自己的业务，需要与其他同事对象交互时，就通知中介对象，中介对象会负责后续的交互。

10. 策略模式

策略模式定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换

比如:

刘备要到江东娶老婆了，走之前诸葛亮给赵云（伴郎）三个锦囊妙计，说是按天机拆开能解决棘手问题，嘿，还别说，真解决了大问题，搞到最后是周瑜陪了夫人又折兵，那咱们先看看这个场景是什么样子的。

先说说这个场景中的要素：三个妙计，一个锦囊，一个赵云，妙计是亮哥给的，妙计放在锦囊里，俗称就是锦囊妙计嘛，那赵云就是一个干活的人，从锦囊取出妙计，执行，然后获胜。用java程序怎么表现这些呢？

那我们先来看看图

三个妙计是同一类型的东西，那咱就写个接口：

package com.yangguangfu.strategy;
/**
 * 
 * @author trygf521@126.com:阿福
 * 首先定义一个策略接口，这是诸葛亮老人家给赵云的三个锦囊妙计的接口。
 */
public interface IStrategy {
    //每个锦囊妙计都是一个可执行的算法。
    public void operate();

}

然后再写三个实现类，有三个妙计嘛：

妙计一：初到吴国：

package com.yangguangfu.strategy;
/**
 * 
 * @author trygf521@126.com:阿福
 * 找乔国老帮忙，使孙权不能杀刘备。
 */
public class BackDoor implements IStrategy {

    @Override
    public void operate() {
        System.out.println("找乔国老帮忙，让吴国太给孙权施加压力，使孙权不能杀刘备...");
    }

}

妙计二：求吴国太开个绿灯，放行：

package com.yangguangfu.strategy;
/**
 * 
 * @author trygf521@126.com:阿福
 * 求吴国太开个绿灯。
 */
public class GivenGreenLight implements IStrategy {

    @Override
    public void operate() {
        System.out.println("求吴国太开个绿灯，放行！");
        
    }

}

妙计三：孙夫人断后，挡住追兵：

package com.yangguangfu.strategy;
/**
 * 
 * @author trygf521@126.com:阿福
 * 孙夫人断后，挡住追兵。
 */
public class BlackEnemy implements IStrategy {

    @Override
    public void operate() {
        System.out.println("孙夫人断后，挡住追兵...");

    }

}
好了，大家看看，三个妙计是有了，那需要有个地方放妙计啊，放锦囊里：

package com.yangguangfu.strategy;
/**
 * 
 * @author trygf521@126.com:阿福
 *
 */
public class Context {
    
    private IStrategy strategy;
    //构造函数，要你使用哪个妙计
    public Context(IStrategy strategy){
        this.strategy = strategy;
    }
    
    public void operate(){
        this.strategy.operate();
    }

}

然后就是赵云雄赳赳的揣着三个锦囊，拉着已步入老年行列，还想着娶纯情少女的，色咪咪的刘备老爷子去入赘了，嗨，还别说，亮哥的三个妙计还真不错，瞧瞧：

package com.yangguangfu.strategy;

public class ZhaoYun {

    /**
     * 赵云出场了，他根据诸葛亮给他的交代，依次拆开妙计
     */
    public static void main(String[] args) {
        Context context;
        
        //刚到吴国的时候拆开第一个
        System.out.println("----------刚刚到吴国的时候拆开第一个---------------");
        context = new Context(new BackDoor());
        context.operate();//拆开执行
        System.out.println("












");
        
        //当刘备乐不思蜀时，拆开第二个
        System.out.println("----------刘备乐不思蜀，拆第二个了---------------");
        context = new Context(new GivenGreenLight());
        context.operate();//拆开执行
        System.out.println("












");
        
        //孙权的小追兵了，咋办？拆开第三个锦囊
        System.out.println("----------孙权的小追兵了，咋办？拆开第三个锦囊---------------");
        context = new Context(new BlackEnemy());
        context.operate();//拆开执行
        System.out.println("












");
    }

}

11. 模板模式

定义一个操作中的算法骨架, 而将一些步骤延迟到子类中

个人感觉是定义一套流程”即算法骨架”, 置于骨架的内容, 要到实现时, 会有不同

比如: 我们使用冲泡咖啡和冲泡茶的例子

加工流程：

咖啡冲泡法：1.把水煮沸、2.用沸水冲泡咖啡、3.把咖啡倒进杯子、4.加糖和牛奶

茶冲泡法： 1.把水煮沸、2.用沸水冲泡茶叶、3.把 茶 倒进杯子、4.加蜂蜜

实践步骤：

1>创建一个模板(抽象)类：Beverage(饮料) 这里包含”骨架”

package com.kaishengit.beverage;

public abstract class Beverage {
    /**
     * 冲泡咖啡或茶...流程
     */
    public final void create(){
        boilWater();//把水煮沸
        brew();//用沸水冲泡...
        pourInCup();//把...倒进杯子
        addCoundiments();//加...
    }


    public abstract void addCoundiments();

    public abstract void brew();
    
    public void boilWater() {
        System.out.println("煮开水");
    }
    
    public void pourInCup() {
        System.out.println("倒进杯子");
    }
}

2>创建一个咖啡类(Coffee)和茶(Tea)类,都继承Beverage抽象类

1.咖啡(Coffee)

package com.kaishengit.beverage;

public class Coffee extends Beverage{

    @Override
    public void addCoundiments() {
        System.out.println("添加糖和牛奶");    }

    @Override
    public void brew() {
        System.out.println("用水冲咖啡");
    }
}

2. 茶(Tea)

package com.kaishengit.beverage;

public class Tea extends Beverage{

    @Override
    public void addCoundiments() {
        System.out.println("添加蜂蜜");
    }

    @Override
    public void brew() {
        System.out.println("用水冲茶");
    }

}

12. 观察者模式

定义了一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象

模式中的角色

　　抽象主题（Subject）：它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。

　　具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。

　　抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

　　具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调

想想自己blog的气象站的例子(headfirst 设计模式中的例子)

13. 迭代器模式

迭代器模式提供一种方法顺序访问一个聚合对象中各个元素

迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口

具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。

Aggregate （聚合）: 聚合定义创建相应迭代器对象的接口

ConcreteAggregate （具体聚合）: 具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例

比如: 早期电视机, 按电视上按钮换台那种, 当我们换频道时, 重要的不是几频道, 而是节目内容.

在面向对象的软件设计中, 我们经常会遇到一类集合对象, 这类集合对象的内部结构可能有着各种各样的实现, 但是归结起来, 无非有两点是我们关心的: 一是集合内部的数据存储结构, 二是遍历这个集合内部的数据. Iterator 模式就是分离了集合对象的遍历行为.

首先有一个抽象的聚集, 所谓聚集就是数据的集合, 可以循环去访问它, 它只有一个方法 GetIterator()让子类去实现, 用来获得一个迭代器对象.

抽象迭代器: Iterator, 它用来访问聚集的类, 封装了一些方法, 通常会有 MoveNext(), CurrentItem(), First(), Next()

具体聚集 ConcreteList: 它实现了抽象聚集中的唯一方法, 同时再里面保存了一组数据

具体迭代器 ConcreteIterator: 具体迭代器, 它实现了迭代器中的4个方法, 在它的构造函数中需要接受一个具体聚集类型的参数.

14. 责任链模式

责任链模式使多个对象都有机会处理请求

抽象处理者 Handler: 定义出一个处理请求的接口,如果需要，接口可以定义出一个方法，以设定和返回对下家的引用。这个角色通常由一个抽象类或接口实现。

具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

比如: 请假,审批的例子, 在公司里，如果你的请假时间小于0.5天，那么只需要向项目经理打声招呼就OK了, 如果超过了0.5天，但是还小于2天，那么就要去找人事部处理，当然，这就要扣工资了, 如果超过了2天，你就需要去找总经理了，工资当然也玩完了。那么，对于我们来说，这个流程就是这样的。

也就是这样一个过程，你需要和你的直接上级——项目经理去打交道，最终可能是项目经理给你回邮件，可能是人事部给你回邮件，也可能是总经理给你回邮件。内部的过程其实应该是个黑盒子，你并不知道内部的消息是如何处理的。你需要找到的，只是你想要第一个交付的对象而已.

下边是一个审批例子的具体代码.

抽象处理者角色

public abstract class Handler {
    /**
     * 持有下一个处理请求的对象
     */
    protected Handler successor = null;
    /**
     * 取值方法
     */
    public Handler getSuccessor() {
        return successor;
    }
    /**
     * 设置下一个处理请求的对象
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    /**
     * 处理聚餐费用的申请
     * @param user    申请人
     * @param fee    申请的钱数
     * @return        成功或失败的具体通知
     */
    public abstract String handleFeeRequest(String user , double fee);

具体处理者角色

项目经理

public class ProjectManager extends Handler {

    @Override
    public String handleFeeRequest(String user, double fee) {
        
        String str = "";
        //项目经理权限比较小，只能在500以内
        if(fee < 500)
        {
            //为了测试，简单点，只同意张三的请求
            if("张三".equals(user))
            {
                str = "成功：项目经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";    
            }else
            {
                //其他人一律不同意
                str = "失败：项目经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
            }
        }else
        {
            //超过500，继续传递给级别更高的人处理
            if(getSuccessor() != null)
            {
                return getSuccessor().handleFeeRequest(user, fee);
            }
        }
        return str;
    }

}

部门经理

public class DeptManager extends Handler {

    @Override
    public String handleFeeRequest(String user, double fee) {
        
        String str = "";
        //部门经理的权限只能在1000以内
        if(fee < 1000)
        {
            //为了测试，简单点，只同意张三的请求
            if("张三".equals(user))
            {
                str = "成功：部门经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";    
            }else
            {
                //其他人一律不同意
                str = "失败：部门经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
            }
        }else
        {
            //超过1000，继续传递给级别更高的人处理
            if(getSuccessor() != null)
            {
                return getSuccessor().handleFeeRequest(user, fee);
            }
        }
        return str;
    }

}

部长

public class GeneralManager extends Handler {

    @Override
    public String handleFeeRequest(String user, double fee) {
        
        String str = "";
        //总经理的权限很大，只要请求到了这里，他都可以处理
        if(fee >= 1000)
        {
            //为了测试，简单点，只同意张三的请求
            if("张三".equals(user))
            {
                str = "成功：总经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";    
            }else
            {
                //其他人一律不同意
                str = "失败：总经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
            }
        }else
        {
            //如果还有后继的处理对象，继续传递
            if(getSuccessor() != null)
            {
                return getSuccessor().handleFeeRequest(user, fee);
            }
        }
        return str;
    }

}

客户端类 (测试)

public class Client {

    public static void main(String[] args) {
        //先要组装责任链
        Handler h1 = new GeneralManager();
        Handler h2 = new DeptManager();
        Handler h3 = new ProjectManager();
        h3.setSuccessor(h2);
        h2.setSuccessor(h1);
        
        //开始测试
        String test1 = h3.handleFeeRequest("张三", 300);
        System.out.println("test1 = " + test1);
        String test2 = h3.handleFeeRequest("李四", 300);
        System.out.println("test2 = " + test2);
        System.out.println("---------------------------------------");
        
        String test3 = h3.handleFeeRequest("张三", 700);
        System.out.println("test3 = " + test3);
        String test4 = h3.handleFeeRequest("李四", 700);
        System.out.println("test4 = " + test4);
        System.out.println("---------------------------------------");
        
        String test5 = h3.handleFeeRequest("张三", 1500);
        System.out.println("test5 = " + test5);
        String test6 = h3.handleFeeRequest("李四", 1500);
        System.out.println("test6 = " + test6);
    }

}

输出结果:

15. 命令模式

将一个请求封装成为一个对象, 使可以用不同的请求对客户进行参数化

命令角色（Command）：声明执行操作的接口。有java接口或者抽象类来实现。

具体命令角色（Concrete Command）：将一个接收者对象绑定于一个动作；调用接收者相应的操作，以实现命令角色声明的执行操作的接口

客户角色（Client）：创建一个具体命令对象（并可以设定它的接收者

请求者角色（Invoker）：调用命令对象执行这个请求

接收者角色（Receiver）：知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者

比如: 电视机遥控器

电视机是请求的接收者Receiver，遥控器是请求的发送者Invoker, 遥控器上有一些按钮，不同的按钮对应电视机的不同操作Command. 抽象命令角色由一个命令接口来扮演, 有三个具体的命令类实现了抽象命令接口，这三个具体命令类分别代表三种操作：打开电视机、关闭电视机和切换频道

代码如下:

public interface Command {
    public void execute();
}


public class ConcreteCommand implements Command {

    private Receiver receiver = null;
    private String state;

    public ConcreteCommand(Receiver receiver){
       this.receiver = receiver;
    }  
    public void execute() {
       receiver.action();
    }
}


public class Receiver {
    public void action(){
       //真正执行命令操作的功能代码
    }
}


public class Invoker {
    private Command command = null;

    public void setCommand(Command command) {
       this.command = command;
    }

    public void runCommand() {
       command.execute();
    }
}

public class Client {
    public void assemble(){
       //创建接收者
       Receiver receiver = new Receiver();
       //创建命令对象，设定它的接收者
       Command command = new ConcreteCommand(receiver);
       //创建Invoker，把命令对象设置进去
       Invoker invoker = new Invoker();
       invoker.setCommand(command);
    }
}

模拟电视机换台的代码:

下面给个例子，是模拟对电视机的操作有开机、关机、换台命令。代码如下

//命令接收者
public class Tv {
　　public int currentChannel = 0;

　　public void turnOn() {
　　   System.out.println("The televisino is on.");
　　}

　　public void turnOff() {
　　   System.out.println("The television is off.");
　　}

　　public void changeChannel(int channel) {
　　   this.currentChannel = channel;
　　   System.out.println("Now TV channel is " + channel);
　　}
}

//执行命令的接口
public interface Command {
　　void execute();
}

//开机命令
public class CommandOn implements Command {
　　private Tv myTv;

　　public CommandOn(Tv tv) {
　　   myTv = tv;
　　}

　　public void execute() {
　　   myTv.turnOn();
　　}
}

//关机命令
public class CommandOff implements Command {
　　private Tv myTv;

　　public CommandOff(Tv tv) {
　　   myTv = tv;
　　}

　　public void execute() {
　　   myTv.turnOff();
　　}
}

//频道切换命令
public class CommandChange implements Command {
　　private Tv myTv;

　　private int channel;

　　public CommandChange(Tv tv, int channel) {
　　   myTv = tv;
 　　  this.channel = channel;
　　}

　　public void execute() {
　　   myTv.changeChannel(channel);
　　}
}

//可以看作是遥控器吧
public class Control {
　　private Command onCommand, offCommand, changeChannel;

　　public Control(Command on, Command off, Command channel) {
 　　  onCommand = on;
 　　  offCommand = off;
　　   changeChannel = channel;
　　}

　　public void turnOn() {
　　   onCommand.execute();
　　}

　　public void turnOff() {
　　   offCommand.execute();
　　}

　　public void changeChannel() {
 　　  changeChannel.execute();
　　}
}

//测试类
public class Client {
　　public static void main(String[] args) {
  　　 // 命令接收者
 　　  Tv myTv = new Tv();
 　　  // 开机命令
  　　 CommandOn on = new CommandOn(myTv);
  　　 // 关机命令
  　　 CommandOff off = new CommandOff(myTv);
  　　 // 频道切换命令
 　　  CommandChange channel = new CommandChange(myTv, 2);
 　　  // 命令控制对象
　　   Control control = new Control(on, off, channel);

  　　 // 开机
  　　 control.turnOn();
 　　  // 切换频道
 　　  control.changeChannel();
 　　  // 关机
 　　  control.turnOff();
　　}
}


执行结果为：
The televisino is on.
Now TV channel is 2
The television is off.

16. 状态模式

状态模式容许一个对象在其内部状态改变时改变它的行为

上下文环境（Context）：它定义了客户程序需要的接口并维护一个具体状态角色的实例，将与状态相关的操作委托给当前的Concrete State对象来处理.

抽象状态（State）：定义一个接口以封装使用上下文环境的的一个特定状态相关的行为 

具体状态（Concrete State）：实现抽象状态定义的接口

举例:

电灯有两个状态，开（亮）与关（不亮），下面就用状态模式来实现对电灯的控制

/// <summary>
    /// 电灯类，对应模式中的Context类
    /// </summary>
    public class Light
    {
        private LightState state;

        public Light(LightState state)
        {
            this.state = state;
        }

        /// <summary>
        /// 按下电灯开关
        /// </summary>
        public void PressSwich()
        {
            state.PressSwich(this);
        }

        public LightState State
        {
            get { return state; }
            set { state = value; }
        }    
    }

    /// <summary>
    /// 抽象的电灯状态类，相当于State类
    /// </summary>
    public abstract class LightState
    {
        public abstract void PressSwich(Light light);
    }

    /// <summary>
    /// 具体状态类, 开
    /// </summary>
    public class On : LightState
    {
        /// <summary>
        /// 在开状态下，按下开关则切换到关的状态。
        /// </summary>
        /// <param name="light"></param>
        public override void PressSwich(Light light)
        {
            Console.WriteLine("Turn off the light.");

            light.State = new Off();
        }
    }

    /// <summary>
    /// 具体状态类，关
    /// </summary>
    public class Off: LightState
    {
        /// <summary>
        /// 在关状态下，按下开关则打开电灯。
        /// </summary>
        /// <param name="light"></param>
        public override void PressSwich(Light light)
        {
            Console.WriteLine("Turn on the light.");

            light.State = new On();
        }
    }

客户端代码

class Program
    {
        static void Main(string[] args)
        {
            // 初始化电灯，原始状态为关
            Light light = new Light(new Off());

            // 第一次按下开关，打开电灯
            light.PressSwich();
            // 第二次按下开关，关闭电灯
            light.PressSwich();

            Console.Read();
        }
    }