[1. 适配器（Adapter）]
[2. 桥接（Bridge）]
[3. 组合（Composite）]
[4. 装饰（Decorator）]
[5. 外观（Facade）]
[6. 享元（Flyweight）]
[7. 代理（Proxy）]

1. 适配器（Adapter）

适配器模式:
定义：将一个类的接口转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以相互合作。
这个定义还好，说适配器的功能就是把一个接口转成另一个接口。
如题目，手机充电器一般都是5V左右吧，咱天朝的家用交流电压220V，所以手机充电需要一个适配器（降压器）

1. 角色类。

/**
 * Created by zhxh on 2019/4/9
 * 源角色
 */
public class Adaptee {
    public void doSomething() {
        System.out.println("i am adaptee,let us do it ");
    }
}

/**
 * Created by zhxh on 2019/4/9
 * 目标角色
 */
public interface Target {
    public void request();
}

/**
 * Created by zhxh on 2019/4/9
 * 目标角色的实现类
 */
public class ConcreteTarget implements Target {
    @Override
    public void request() {
        System.out.println("hahaha");
    }
}

2. 桥接（Bridge）

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。
这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

这种模式涉及到一个作为桥接的接口[DrawAPI]，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。

1. 角色类。

/**
 * Created by zhxh on 2019/4/14
 */
public abstract class Abstraction {
    private Implementor imp;

    public Abstraction(Implementor imp) {
        this.imp = imp;
    }

    public void request() {
        this.imp.doSomething();
    }

    public Implementor getImp() {
        return imp;
    }
}

/**
 * Created by zhxh on 2019/4/14
 */
public interface Implementor {
    public void doSomething();

    public void doAnything();
}

/**
 * Created by zhxh on 2019/4/14
 */
public class RefinedAbstraction extends Abstraction {

    public RefinedAbstraction(Implementor imp) {
        super(imp);
    }

    @Override
    public void request() {
        //todo do something else
        System.out.println("refine something else");

        super.request();
        super.getImp().doAnything();
    }
}

/**
 * Created by zhxh on 2019/4/14
 */
public class ConcreteImplementor1 implements Implementor {
    @Override
    public void doSomething() {
        System.out.println("ConcreteImplementor1-->doSomething");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteImplementor1-->doAnything");
    }
}

2. 场景类。

/**
 * Created by zhxh on 2019/4/14
 */
public class Client {
    public static void main(String[] args) {
        Implementor imp = new ConcreteImplementor1();
        Abstraction abs = new RefinedAbstraction(imp);
        abs.request();
    }
}

3. 组合（Composite）

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。
组合模式依据树形结构来组合对象，用来表示部分以及整体层次。
这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
<p>
主要解决：
它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，
客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

1. 角色类。

/**
 * Created by zhxh on 2020-02-02.
 * 1. 创建 Employee 类，该类带有 Employee 对象的列表。
 */
public class Employee {

    private String name;
    // 部门
    private String dept;
    // 工资
    private int salary;
    // 员工 list
    private List<Employee> subordinates;

    public Employee(String name, String dept, int salary) {
        this.name = name;
        this.dept = dept;
        this.salary = salary;
        this.subordinates = new ArrayList<Employee>();
    }

    public void add(Employee e) {
        subordinates.add(e);
    }

    public void remove(Employee e) {
        subordinates.remove(e);
    }

    public List<Employee> getSubordinates() {
        return subordinates;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", dept='" + dept + '\'' +
                ", salary=" + salary +
                ", subordinates=" + subordinates +
                '}';
    }
}

2. 场景类。

public class App {
    public static void main(String[] args) {

        // 2. 使用 Employee 类来创建和打印员工的层次结构。
        final Employee ceo = new Employee("John", "CEO", 30000);

        Employee headSales = new Employee("Robert", "Head sales", 20000);

        Employee headMarketing = new Employee("Michel", "Head Marketing", 20000);

        Employee clerk1 = new Employee("Laura", "Marketing", 10000);
        Employee clerk2 = new Employee("Bob", "Marketing", 10000);

        Employee salesExecutive1 = new Employee("Richard", "Sales", 10000);
        Employee salesExecutive2 = new Employee("Rob", "Sales", 10000);

        ceo.add(headSales);
        ceo.add(headMarketing);

        headSales.add(salesExecutive1);
        headSales.add(salesExecutive2);

        headMarketing.add(clerk1);
        headMarketing.add(clerk2);

        Log.e("---", ceo.toString());
    }
}

4. 装饰（Decorator）

装饰者模式:
装饰者模式：若要扩展功能，装饰者提供了比集成更有弹性的替代方案，动态地将责任附加到对象上。
先简单描述下装饰者模式发挥作用的地方，当我们设计好了一个类，我们需要给这个类添加一些辅助的功能，
并且不希望改变这个类的代码，这时候就是装饰者模式大展雄威的时候了。
这里还体现了一个原则：类应该对扩展开放，对修改关闭。

1. 角色类。

/**
 * Created by zhxh on 2019/4/13
 */
public abstract class Decorator extends Component {
    private Component component = null;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operate() {
        this.component.operate();
    }
}

/**
 * Created by zhxh on 2019/4/13
 */
public class ConcreteDecorator1 extends Decorator {
    public ConcreteDecorator1(Component component) {
        super(component);
    }

    //special method
    private void method1() {
        System.out.println("ConcreteDecorator1-->method1()");
    }

    @Override
    public void operate() {
        this.method1();
        super.operate();
    }
}

/**
 * Created by zhxh on 2019/4/13
 */
public abstract class Component {
    public abstract void operate();
}

/**
 * Created by zhxh on 2019/4/13
 */
public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        System.out.println("ConcreteComponent-->operate()");
    }
}

2. 场景类。

/**
 * Created by zhxh on 2019/4/13
 */
public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        //第一次装饰
        component = new ConcreteDecorator1(component);
        //第二次装饰
        component = new ConcreteDecorator2(component);
        component.operate();
    }
}

5. 外观（Facade）

外观模式:
定义：提供一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层的接口，让子系统更容易使用。
其实就是为了方便客户的使用，把一群操作，封装成一个方法。

1. 角色类。

/**
 * Created by zhxh on 2019/4/14
 */
public class ClassA {
    public void doSomethingA() {
        System.out.println("ClassA-->doSomethingA()");
    }
}

/**
 * Created by zhxh on 2019/4/14
 */
public class ClassB {
    public void doSomethingB() {
        System.out.println("ClassB-->doSomethingB()");
    }
}

/**
 * Created by zhxh on 2019/4/14
 */
public class Facade {
    private ClassA classA = new ClassA();
    private ClassB classB = new ClassB();

    public void methdoA() {
        this.classA.doSomethingA();
    }

    public void methodB() {
        this.classB.doSomethingB();
    }
}

2. 场景类。

public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.methdoA();
        facade.methodB();
    }
}

6. 享元（Flyweight）

享元模式（Flyweight Pattern）
主要用于减少创建对象的数量，以减少内存占用和提高性能。
这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

1. 角色类。

/**
 * Created by zhxh on 2020-02-01.
 * 1. 创建一个接口。
 */
public interface Shape {
    void draw();
}

/**
 * Created by zhxh on 2020-02-01.
 * 2. 创建实现接口的实体类。
 */
public class Circle implements Shape {
    private String color;
    private int x;
    private int y;
    private int radius;

    public Circle(String color) {
        this.color = color;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        Log.e("---", "Circle: Draw() [Color : " + color
                + ", x : " + x + ", y :" + y + ", radius :" + radius);
    }
}

/**
 * Created by zhxh on 2020-02-01.
 * 3. 创建一个工厂，生成基于给定信息的实体类的对象。
 */
public class ShapeFactory {

    private static final HashMap<String, Shape> circleMap = new HashMap<String, Shape>();

    public static Shape getShape(String color) {
        Shape shape = circleMap.get(color);
        if (shape == null) {
            shape = new Circle(color);
            circleMap.put(color, shape);
            Log.e("getShape", "Creating circle of color : " + color);
        }
        return shape;
    }
}

2. 场景类。

public class App {
    private static final String color[] = {"Red", "Blue", "Yellow", "White", "Black"};

    public static void main(String[] args) {
        // 4. 使用该工厂，通过传递颜色信息来获取实体类的对象。
        for (int i = 0; i < 20; i++) {
            Circle circle = (Circle) ShapeFactory.getShape(getRandomColor());
            circle.setX(getRandomX());
            circle.setY(getRandomY());
            circle.setRadius(100);
            circle.draw();
        }
    }


    /**
     * 0.0-1.0  * [1-6]
     */
    private static String getRandomColor() {
        return color[(int) (Math.random() * color.length)];
    }

    private static int getRandomX() {
        return (int) (Math.random() * 100);
    }

    private static int getRandomY() {
        return (int) (Math.random() * 100);
    }
}

7. 代理（Proxy）

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，
比如说：要访问的对象在远程的机器上。
在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），
直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

1. 角色类。

/**
 * Created by zhxh on 2019/4/9
 */
public interface Subject {
    //define a method
    public void request();
}

/**
 * Created by zhxh on 2019/4/9
 */
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject-->request()");
    }
}

/**
 * Created by zhxh on 2019/4/9
 */
public class Proxy implements Subject {
    //proxy for some class
    private Subject subject = null;

    //default proxy
    public Proxy() {
        this.subject = new Proxy();
    }

    public Proxy(Subject... objects) {
        this.subject = objects[0];
    }

    @Override
    public void request() {
        this.before();
        this.subject.request();
        this.after();
    }

    private void before() {
        System.out.println("Proxy-->before()");
    }

    private void after() {
        System.out.println("Proxy-->after()");
    }
}

2. 场景类。

public class Client {
    public static void main(String[] args) {
        RealSubject subject = new RealSubject();
        Proxy proxy = new Proxy(subject);
        proxy.request();
    }
}