常用设计模式（二）

一、适配器模式

1、定义

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

的那些类可以在一起工作。

2、解决的问题

　　

　即Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

3、模式中的角色

　3.1 目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。

　

　3.2 需要适配的类（Adaptee）：需要适配的类或适配者类。

　3.3 适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成目标接口。

4、模式视图




5、代码实现

[code]package Adpater;

/**
 * 三相插座接口
 * @author ruolan
 *
 */
public interface ThreePlugIF {

    //使用三相电流供电
    public abstract void powerWithThree();

}

[code]package Adpater;

/**
 * 二相转三相的插座适配器
 * 
 * @author ruolan
 *
 */
public class TwoPlugAdapter implements ThreePlugIF {

    private GBTwoPlug plug;

     public TwoPlugAdapter(GBTwoPlug plug) {
        this.plug = plug;
    }

    @Override
    public void powerWithThree() {
        System.out.println("通过转化");
        plug.powerWithTwo();
    }

}

[code]package Adpater;

public class GBTwoPlug {

    //使用二相电流供电
    public void powerWithTwo(){
        System.out.println("使用二相电流供电");
    }
}

[code]package Adpater;

public class NoteBook {

    private ThreePlugIF plug;

    public NoteBook(ThreePlugIF plug){
        this.plug = plug;
    }

    //使用插座充电
    public void charge(){
        plug.powerWithThree();
    }

    public static void main(String[] args) {
        GBTwoPlug two = new GBTwoPlug();
        ThreePlugIF plug = new TwoPlugAdapter(two);   //通过适配器二相插座转三相
        NoteBook nbBook = new NoteBook(plug);
        nbBook.charge();
    }
}

输出结果：

[code]通过转化
使用二相电流供电

6、使用适配器模式的作用

6.1 透明

通过适配器，客户端可以调用同意接口，因而对客户端来说是透明的，这样做更简单、更直接、更紧凑

6.2重用

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

6.3低耦合

将目标类和适配器类解耦，通过引入一个适配器类重用现有的适配者类，而无需修改原有的代码。（遵循开闭原则）

二、责任链模式

1、定义

将接受者对象连成一条链，并在该链条上传递请求，知道有一个接受者对象处理他，通过让更多的对象有机会处理请求，避免了请求发送者和接受者之间的耦合

2、责任链模式视图：




3、代码实现

Sales代码

[code]package com.cor.handler;

public class Sales extends PriceHandler {

    @Override
    public void processDiscount(float discount) {
        if (discount <= 0.05) {
            System.out.format("%s批准了折扣:%.2f%n", this.getClass().getName(),discount);
        } else {
            successor.processDiscount(discount);
        }
    }

}

Manager代码：

[code]package com.cor.handler;

public class Manager extends PriceHandler {

    @Override
    public void processDiscount(float discount) {
        if (discount <= 0.3) {
            System.out.format("%s批准了折扣:%.2f%n", this.getClass().getName(),discount);
        } else {
            successor.processDiscount(discount);
        }
    }

}

Director代码：

[code]package com.cor.handler;

public class Director extends PriceHandler{

    @Override
    public void processDiscount(float discount) {
        if (discount <= 0.4) {
            System.out.format("%s批准了折扣:%.2f%n", this.getClass().getName(),discount);
        } else {
            successor.processDiscount(discount);
        }
    }

}

VicePresident代码：

[code]package com.cor.handler;

public class VicePresident extends PriceHandler {

    @Override
    public void processDiscount(float discount) {
        if (discount <= 0.5) {
            System.out.format("%s批准了折扣:%.2f%n", this.getClass().getName(),discount);
        } else {
            successor.processDiscount(discount);
        }
    }
}

CEO代码

[code]package com.cor.handler;

public class CEO extends PriceHandler{

    @Override
    public void processDiscount(float discount) {
        if (discount <= 0.55) {
            System.out.format("%s批准了折扣:%.2f%n", this.getClass().getName(),discount);
        } else {
            System.out.format("%s拒绝了折扣:%.2f%n", this.getClass().getName(),discount);
        }
    }

}

PriceHandler代码

[code]package com.cor.handler;

/*
 *价格处理人，负责处理客户折扣申请
 */
public abstract class PriceHandler {

    // 直接后继，传递请求
    protected PriceHandler successor;

    public void setSuccessor(PriceHandler successor) {
        this.successor = successor;
    }

    public abstract void processDiscount(float discount);

}

PriceHandlerFactory代码：

[code]package com.cor.handler;

public class PriceHandlerFactory {

    //创建PriceHandler工厂方法
    public static PriceHandler createPriceHandler() {
        PriceHandler sales = new Sales(); // 向上转型
        PriceHandler manager = new Manager();
        PriceHandler dir = new Director();
        PriceHandler vp = new VicePresident();
        PriceHandler ceo = new CEO();

        //指定后继
        sales.setSuccessor(manager);
        manager.setSuccessor(dir);
        dir.setSuccessor(vp);
        vp.setSuccessor(ceo);

        return sales;
    }

}

Customer代码：

[code]package com.cor.handler;

import java.util.Random;

/**
 * 客户请求折扣
 * @author ruolan
 *
 */
public class Customer {

    private PriceHandler handler;

    public void setHandler(PriceHandler handler) {
        this.handler = handler;
    }

    public void requestDiscount(float discount){
        handler.processDiscount(discount);
    }

    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.setHandler(PriceHandlerFactory.createPriceHandler());
        Random rand = new Random();
        for (int i = 0; i <= 100; i++) {
            System.out.print(i+"");
            customer.requestDiscount(rand.nextFloat());
        }
    }

}

输出结果：

[code]0com.cor.handler.CEO拒绝了折扣:1.00
1com.cor.handler.Manager批准了折扣:0.29
2com.cor.handler.Manager批准了折扣:0.09
3com.cor.handler.CEO拒绝了折扣:0.63
4com.cor.handler.VicePresident批准了折扣:0.44
5com.cor.handler.CEO拒绝了折扣:0.79
6com.cor.handler.CEO拒绝了折扣:0.60
7com.cor.handler.CEO拒绝了折扣:0.76
8com.cor.handler.Manager批准了折扣:0.12
9com.cor.handler.CEO拒绝了折扣:0.86
10com.cor.handler.CEO批准了折扣:0.50
11com.cor.handler.CEO拒绝了折扣:0.73
12com.cor.handler.CEO批准了折扣:0.50
13com.cor.handler.Sales批准了折扣:0.01
14com.cor.handler.Sales批准了折扣:0.00
15com.cor.handler.VicePresident批准了折扣:0.44
16com.cor.handler.Manager批准了折扣:0.23
17com.cor.handler.Manager批准了折扣:0.25
18com.cor.handler.Manager批准了折扣:0.08
19com.cor.handler.Director批准了折扣:0.32
20com.cor.handler.Manager批准了折扣:0.25
21com.cor.handler.VicePresident批准了折扣:0.41
。。。。。后面还有的哈

4、代码图解：



这里我们看到了有一个Lead这个，当然了，代码中没有实现，其实也是很好实现的哈，在重新定义一个Lead类，然后在PriceHandlerFactory这个类中，创建Lead的实例，然后修改Sales的后继是Lead，修改Lead的后继是Manager就行了。是不是很方便啊。

5、责任链模式真的好么？

执行的性能没有优化，我们可以看到我们创建了很多类的实例（内存占用），但是真正用到的没有几个，还有就是，这几个是一条链，在执行的时候会遍历整条链。。。。效率低下，

这个没有具体的说法，这个就要取决于项目实际了哈。