适配器模式的概念

适配器模式就是为了解决两个不匹配的实现类之间的调用而建一个适配中间类来使两者匹配。
当我们要访问的接口A中没有我们想要的方法 ，却在另一个接口B中发现了合适的方法，我们又不能改变访问接口A，在这种情况下，我们可以定义一个适配器p来进行中转，这个适配器p要实现我们访问的接口A，这样我们就能继续访问当前接口A中的方法（虽然它目前不是我们的菜），然后再继承接口B的实现类B，这样我们可以在适配器P中访问接口B的方法了，这时我们在适配器P中的接口A方法中直接引用BB中的合适方法，这样就完成了一个简单的类适配器。

public interface Ps2 {
     void isPs2();
 }
 public interface Usb {
     void isUsb();
 }
public class Usber implements Usb {

    @Override
    public void isUsb() {
        System.out.println("USB口");
    }

}
public class Adapter extends Usber implements Ps2 {

    @Override
    public void isPs2() {
        isUsb();
    }

}
public class Clienter {

    public static void main(String[] args) {
        Ps2 p = new Adapter();
        p.isPs2();
    }

}

在上面例子中我们要调用ps2的方法，但是目前usb只提供了使用usb，于是使用了适配器adapter，在adapter里使用ps2的方法，里面可以调用到usb。
接口Ps2：描述ps2接口格式
接口Usb：描述USB接口格式
类Usber：是接口Usb的实现类，是具体的USB接口格式
Adapter：用于将ps2接口格式转换成为USB接口格式

在Java I/O中的适配器模式应用解析

这里以读取文件为例，使用字符读取：

public static void readFile(String fileName) throws Exception{
        File file = new File(fileName);
        Reader reader = null;
        try{
            InputStream in = new FileInputStream(file);
            reader = new InputStreamReader(in);
            int tempchar;
            while ((tempchar = reader.read()) != -1) {
                if (((char) tempchar) != '\r') {
                    System.out.print((char) tempchar);
                }
            }
            reader.close();
        }catch (Exception e){
            e.printStackTrace();
        }

    }

读取文件手机，创建一个输入流FileInputStream,但是读取的方法定义在抽象类Reader里，无法直接用Reader去读取输入流，这时使用了InputStreamReader来读取，但是实际上InputStreamReader并不是一个适配器。仔细查看一下InputStreamReader的源码：

public class InputStreamReader extends Reader {

    private final StreamDecoder sd;

    /**
     * Creates an InputStreamReader that uses the default charset.
     *
     * @param  in   An InputStream
     */
    public InputStreamReader(InputStream in) {
        super(in);
        try {
            sd = StreamDecoder.forInputStreamReader(in, this, (String)null); // ## check lock object
        } catch (UnsupportedEncodingException e) {
            // The default encoding should always be available
            throw new Error(e);
        }
    }
    public int read() throws IOException {
        return sd.read();
    }
}

InputStreamReader是引用了一个StreamDecoder来间接引用的InputStream,而且在StreamDecoder内可以定义字符编码类型，可以看StreamDecoder的源码，真正实现read方法的是它，而且也内部引用了inputStream，它扮演的才是适配器角色，而InputStreamReader更多的是扮演一个装饰器角色，给StreamDecoder加以装饰。

public class StreamDecoder extends Reader {
    ····
    private InputStream in;
    ···

    public int read() throws IOException {
        return this.read0();
    }

    private int read0() throws IOException {
        Object var1 = this.lock;
        synchronized(this.lock) {
            if(this.haveLeftoverChar) {
                this.haveLeftoverChar = false;
                return this.leftoverChar;
            } else {
                char[] var2 = new char[2];
                int var3 = this.read(var2, 0, 2);
                switch(var3) {
                case -1:
                    return -1;
                case 0:
                default:
                    assert false : var3;

                    return -1;
                case 2:
                    this.leftoverChar = var2[1];
                    this.haveLeftoverChar = true;
                case 1:
                    return var2[0];
                }
            }
        }
    }
}