java设计模式（1） 适配器模式、装饰器模式

适配器模式

适配器就是一种适配中间件，它存在于不匹配的了两者之间，用于连接两者，使不匹配变得匹配。

手机充电需要将220V的交流电转化为手机锂电池需要的5V直流电

知识补充：手机充电器输入的电流是交流，通过变压整流输出电流是直流的。。

---

类适配器

️2️⃣Adaptee 源角色   ：220V的交流电（家用电一般是220V）  

//家用电压
public class HomeElectri {
    //输出220v交流电,AC指的是交流电
    public int outputAC220V() {
        int output = 220;
        return output;
    }
}

1️⃣Target 目标角色 ：  手机锂电池需要的5V直流电

目标类只需要定义方法，由适配器来转化：

//手机充电接口
public interface MobileCharge {
    //需要5v的直流电
    //DC指的是直流电
    int outputDC5V();
}

3️⃣Adapter 适配器角色  ：手机充电器

我为什么这么写，又去继承又去实现的？

          作为适配器，需要拿到俩边的资源。通过继承拿到源角色的能力（输出220V）通过实现接口，知道自己的目的角色。

//手机的适配器（手机充电器）
public class PhoneAdapter extends HomeElectri implements MobileCharge {

    @Override
    public int outputDC5V() {
        int output = outputAC220V();
        return (output / 44);
    }
}

---

对象适配器

不继承HomeElectri 类，而是持有HomeElectri 类的实例。

提供一个包装类Adapter，这个包装类包装了一个Adaptee的实例，从而此包装类能够把Adaptee的API与Target类的API链接起来。

//手机的适配器（手机充电器）
public class PhoneAdapter implements MobileCharge {

    HomeElectri homeElectri;

    public PhoneAdapter(HomeElectri homeElectri) {
        this.homeElectri = homeElectri;
    }

    @Override
    public int outputDC5V() {
        int output = homeElectri.outputAC220V();
        return (output / 44);
    }
}

PhoneAdapter adapter=new PhoneAdapter(new HomeElectri());
System.out.println("输出电压: "+adapter.outputDC5V());

---

接口适配器

接口的适配器是这样的：接口中往往有多个抽象方法，但是我们写该接口的实现类的时候，必须实现所有这些方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，

如：MouseListener是一个接口，里面有鼠标的各种事件

public interface MouseListener extends EventListener {

    public void mouseClicked(MouseEvent e);

    public void mousePressed(MouseEvent e);

    public void mouseReleased(MouseEvent e);

    public void mouseEntered(MouseEvent e);

    public void mouseExited(MouseEvent e);
}

此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法

MouseAdapter有2个特点

第一：它是抽象类。

第二：每个方法MouseAdapter都做了空实现

public abstract class MouseAdapter implements MouseListener, MouseWheelListener, MouseMotionListener {

    public void mouseClicked(MouseEvent e) {}

    public void mousePressed(MouseEvent e) {}

    public void mouseReleased(MouseEvent e) {}

    public void mouseEntered(MouseEvent e) {}

    public void mouseExited(MouseEvent e) {}

    public void mouseWheelMoved(MouseWheelEvent e){}

    public void mouseDragged(MouseEvent e){}

    public void mouseMoved(MouseEvent e){}
}

而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

addMouseListener（）这个方法需要MouseListener的一个参数

JButton jButton = new JButton("点我有惊喜");
jButton.addMouseListener(new MouseAdapter() {
     @Override
     public void mouseClicked(MouseEvent e) {
         System.out.println("惊不惊喜，意不意外");
     }
});

---

装饰器模式

装饰器模式核心思想

在不改变原有类的基础上给类新增额外的功能，符合开闭原则： 对扩展开放，对修改关闭

1.装饰模式是继承的一个替代模式，通过组合的方式完成继承的功能，但却避免了继承的侵入性

2.装饰类和被装饰类可以独立发展，不会相互耦合

原有的：

//制作蛋糕
public interface MakCake {
    //cake -蛋糕
    void createCake();
}

它的实现类

public class MakeCakeImpl implements MakCake {
    //制作蛋糕的通用基础逻辑
    @Override
    public void createCake() {
        System.out.println("使用面粉、鸡蛋、牛奶等...制作一个基础蛋糕");
    }
}

---

抽象装饰器

抽象装饰器: 通用的装饰的装饰器，其内部必然，有一个属性指向，其实现一般是一个抽象类

被装饰类和所有的装饰类必须实现同一个接口，而且必须持有被装饰的对象，可以无限装饰

//制作蛋糕的抽象装饰器
public abstract class CakeDecorator implements MakCake{
    private MakCake makCake;

    public CakeDecorator(MakCake makCake) {
        this.makCake = makCake;
    }

    @Override
    public void createCake() {
        makCake.createCake();
    }
}

具体装饰器角色：向“制作蛋糕”添加新的职责

给蛋糕添加水果

public class FruitAddDecorator extends AbsCakeDecorator{
    public FruitAddDecorator(MakCake makCake) {
        super(makCake);
    }

    @Override
    public void createCake() {
        super.createCake();
        decorateMethod();
    }

    // 定义自己的修饰逻辑
    private void decorateMethod() {
        System.out.println("加一份新鲜的水果，如草莓...");
    }
}

给蛋糕添加饼干

public class BiscuitAddDecorator extends AbsCakeDecorator {
    public BiscuitAddDecorator(MakCake makCake) {
        super(makCake);
    }

    @Override
    public void createCake() {
        super.createCake();
        decorateMethod();
    }

    // 定义自己的修饰逻辑
    private void decorateMethod() {
        System.out.println("加一份好吃的饼干，如奥利奥...");
    }
}

测试

public static void main(String[] args) {
    //制作最基础的蛋糕面饼
    MakCake cake = new MakeCakeImpl();
    //为蛋糕添加水果
    cake= new FruitAddDecorator(cake);
    cake.createCake();
}

控制台：

---

无限装饰？

什么是无限装饰？使用装饰器模式一层一层的对最底层被包装类进行功能扩展了。 

• 对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。

public static void main(String[] args) {
    //制作最基础的蛋糕面饼
    MakCake cake = new MakeCakeImpl();
    //为蛋糕添加水果
    cake= new FruitAddDecorator(cake);
    // 第二次修饰，蛋糕添加饼干
    cake = new BiscuitAddDecorator(cake);
    cake.createCake();
}

先看结果 

---

new 构造器分析

如上，再new装饰器的时候，构造器做啥了 

 //为蛋糕添加水果
 cake= new FruitAddDecorator(cake);

1 进入FruitAddDecorator 

2 AbsCakeDecorator中的makCake赋值为MakeCakeImpl的实例

-----------------------------------

 代码再走一行

 // 第二次修饰，蛋糕添加饼干
 cake = new BiscuitAddDecorator(cake);

3. 进入BiscuitAddDecorator

4.又进入父类AbsCakeDecorator，AbsCakeDecorator中的makCake赋值为FruitAddDecorator的实例

---

调用方法分析

public static void main(String[] args) {
    //制作最基础的蛋糕面饼
    MakCake cake = new MakeCakeImpl();
    //为蛋糕添加水果
    cake= new FruitAddDecorator(cake);
    // 第二次修饰，蛋糕添加饼干
    cake = new BiscuitAddDecorator(cake);
    cake.createCake();
}

分析完前面的new构造器之后，cake.createCake()做啥了？？？

此时cake是BiscuitAddDecorator的引用

1. 会先调用BiscuitAddDecorator的createCake方法，

2. 走super的createCake（），进入其父类AbsCakeDecorator的方法

3.1 从idea提示看的出此时makCake是FruitAddDecorator的实例，那么接着进入FruitAddDecorator的createCake（）

3.2.走super的createCake（）,再进入AbsCakeDecorator，此时makCake是MakeCakeImpl

的实例

 3.3.进入MakeCakeImpl，控制台打印输出

打印完成后回到3.1,再打印输出

 再回到第一步，BiscuitAddDecorator的createCake（），打印输出

---

在java哪里见过

这是我在学习安全的并发容器类时用到过的，比如

List