java设计模式

Facade

外观模式：将多个子系统封装起来，提供一个更加简洁的接口对供外部调用；

​

举个例子，比如我们每天打开电脑时，都需要做三件事：

• 打开浏览器
• 打开 IDEA
• 打开钉钉

每天下班时，关机前需要做三件事：

• 关闭浏览器
• 关闭 IDE
• 关闭钉钉

定义浏览器类、钉钉类、IDEA类：

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : 浏览器类
 */
public class Browser {
    public static void open() {
        System.out.println("打开浏览器");
    }

    public static void close() {
        System.out.println("关闭浏览器");
    }
}

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : IDEA类
 */
public class IDEA {
    public static void open() {
        System.out.println("打开 IDE");
    }

    public static void close() {
        System.out.println("关闭 IDE");
    }
}

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : 钉钉类
 */
public class Dingding {
    public static void open() {
        System.out.println("打开钉钉");
    }

    public static void close() {
        System.out.println("关闭钉钉");
    }
}

因为每天都会做这几件事，所有我们将这多个子系统封装起来，提供一个对外开放、更简洁的接口供外部使用：

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:37
 * @Description : 每日工作外观类
 */
public class EverydayFacade {
    public void open() {
        Browser.open();
        IDEA.open();
        Dingding.open();
    }

    public void close() {
        Browser.close();
        IDEA.close();
        Dingding.close();
    }
}

测试:

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:16
 * @Description : Facade1测试类
 */
public class Client {
    //不使用外观类
    public static void test1() {
        System.out.println("===========上班:==============");
        Browser.open();
        IDEA.open();
        Dingding.open();

        System.out.println("===========下班:==============");
        Browser.close();
        IDEA.close();
        Dingding.close();
    }

    //使用外观类
    public static void test2(){
        EverydayFacade everydayFacade = new EverydayFacade();
        System.out.println("===========上班:==============");
        everydayFacade.open();
        System.out.println("===========下班:==============");
        everydayFacade.close();
    }
    public static void main(String[] args) {
//        test1();
        test2();
    }
}

Bridge

桥接模式：将抽象部分与它的实现部分分离，使用它们都可以独立的变化；

考虑这样一个需求：绘制矩形、圆形、三角形这三种图案。

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : 形状接口
 */
public interface IShape {
    void draw();
}
//三种形状类
public class Rectangle implements IShape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
public class Round implements IShape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
public class Triangle implements IShape {
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}

这时咱有了新的需求，为每种形状都添加4种不同的颜色：红、黄、蓝、绿；

很容易后想到两种方案：

1. 考虑复用形状类，将每种形状定义为父类，每种不同颜色的图形继承自其形状父类。
2. 考虑复用颜色类，将每种颜色定义为父类，每天不同颜色的图形继承自其颜色父类。

2种方案的缺陷：

1. 使用了面向对象的继承特性；（Java只能继承一个类）
2. 每次添加一种颜色，就得增加3个类；若增加一种形状，又得添加5种不同颜色的类；

其实这个需求，图形的形状和颜色都是图形的两个属性，抛弃掉继承关系，将形状和颜色分离开，根据需求对形状和颜色进行组合，最后就能组合成不同的图形，这就是桥接模式的思想；

定义颜色接口：

public interface IColor{
    String getColor();
}

每种颜色都实现相同的接口：

public class Red implements IColor {
    @Override
    public String getColor() {
        return "Red";
    }
}


public class Blue implements IColor {
    @Override
    public String getColor() {
        return "Blue";
    }
}


public class Yellow implements IColor {
    @Override
    public String getColor() {
        return "Yellow";
    }
}


public class Green implements IColor {
    @Override
    public String getColor() {
        return "Green";
    }
}

在每种形状中，组合颜色接口：

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : 矩形
 */
public class Rectangle implements IShape {
    private IColor color;//组合颜色，

    // 自定义搭配不同颜色
    public void setColor(IColor color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("绘制了一个 " + color.getColor() + " 矩形");
    }
}

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : 圆形
 */
public class Round implements IShape {
    private IColor color;//组合颜色

    // 自定义搭配不同颜色
    public void setColor(IColor color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("绘制了一个 " + color.getColor() + " 圆形");
    }
}

/**
 * @Company 
 * @Author : 
 * @Create : 2021/07/18 22:13
 * @Description : 三角形
 */
public class Triangle implements IShape {
    private IColor color;//组合颜色

    // 自定义搭配不同颜色
    public void setColor(IColor color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("绘制了一个 " + color.getColor() + " 三角形");
    }
}

测试：

/**
 * @Company
 * @Author : 
 * @Create : 2021/07/19 1:43
 * @Description : Bridge1测试类
 */
public class Client {
    public static void main(String[] args) {
        //初始化矩形实例
        Rectangle rectangle = new Rectangle();
        //绘制红颜色的正方形
        rectangle.setColor(new Red());
        rectangle.draw();

        //绘制一个黄颜色的矩形
        rectangle.setColor(new Yellow());
        rectangle.draw();

        //初始话圆形实例
        Round round = new Round();
        //绘制一个绿色的圆形
        round.setColor(new Green());
        round.draw();

        //初始话三角形实例
        Triangle triangle = new Triangle();
        //绘制一个蓝色的三角形
        triangle.setColor(new Blue());
        triangle.draw();
    }
}

这时，如果我们需求添加一种或多种不同的形状或颜色，只需求添加形状或颜色的一个实现类即可；

​