【设计模式】学习笔记（三）——结构型设计模式

鸡先生

发布于 2022-10-29 17:28:40

7020

发布于 2022-10-29 17:28:40

文章被收录于专栏：鸡先生

一、结构型设计模式简介

简介：结构型模式描述如何将类或对象按某种布局组成更大的结构。

它分为类结构型模式和对象结构型模式：

类结构型模式：采用继承机制来组织接口和类。
对象结构型模式：采用组合或聚合来组合对象。

由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。

结构型模式分为以下 7 种：

代理模式
适配器模式
装饰者模式
桥接模式
外观模式
组合模式
享元模式

二、代理模式

2.1 代理模式介绍

概述： 为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象，代理对象充当目标对象和客户之间的一个中介角色

分类：

静态代理
动态代理
Cgilb代理

结构： 代理（Proxy）模式分为三种角色：

抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
真实主题（Peal Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
代理（Proxy）类：提供了于真实主题相同的接口，其内部含有对真实主题的引用，他可以访问、控制或扩展真实主题的功能。

优点：代理模式在客户端与目标对象之间起到了一个中介作用和保护目标对象的作用；代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；代理对象可以扩展目标对象功能；

缺点：增加了系统的复杂度

使用场景：

远程（Remote）代理：本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。

防火墙（Firewall）代理：当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。

保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。

2.2 静态代理

概述：静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现相同的接口或者是继承相同的父类。

代码示例

【需求】在以前大家去火车站买票，需要经过很多步骤，要先打车到火车站，任何排队才能去买到票，而火车站在很多地方都代收点，我们可以在代售点就可以买到票。实现步骤： ① 创建抽象主题类，卖火车票的接口 ② 创建真实主题类，火车类。并实现买火车票的接口 ③ 创建代理类，代售点类。 ④ 声明火车类对象，并实现卖火车票的接口 ⑤ 强化sell方法后调用火车类对象的卖火车票方法

/**
 * 卖火车票的接口（抽象主题类）
 */
public interface SellTickets {

    //卖票方法
    void sell();
}

/**
 * 火车站类（具体主题类）
 */
public class TrainStation implements SellTickets{

    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

/**
 * 代售点类（代理类）
 */
public class ProxyPoint implements SellTickets{

    //声明火车站类对象
    private TrainStation trainStation = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代理点收取点服务费");
        trainStation.sell();
    }
}

//然后我们模拟一下用户买票
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建代售点类对象
        ProxyPoint proxyPoint = new ProxyPoint();
        proxyPoint.sell();
        //打印结果
        //代理点收取点服务费
        //火车站卖票
    }
}

从代码中我们可以看到，我们并没有之间去火车站买票，而是通过代售点买的票，同时也对sell方法进行了增强（代理点收取了一些服务费）。

2.3 JDK代理

概述：代理对象，不需要实现接口，但是目标对象要实现接口，否则不能用动态代理。代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象，动态代理也叫：JDK代理、接口代理

代码示例

还是上面的需求，我们现在使用动态代理来完成实现步骤： ① 创建抽象主题类：卖火车票的接口 ② 创建真实主题类：火车类。并实现买火车票的接口 ③ 创建代理工厂类：声明目标对象，声明获取代理对象的方法 ④ 通过反射机制，返回一个代理类对象

/**
 * 卖火车票的接口（抽象主题类）
 */
public interface SellTickets {

    //卖票方法
    void sell();
}
/**
 * 火车站类（具体主题类）
 */
public class TrainStation implements SellTickets{

    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}
import java.lang.reflect.*;

/**
 * 代理工厂类
 */
public class ProxyFactory {

    //声明目标对象
    private TrainStation station = new TrainStation();

    //获取代理对象的方法
    public Object getProxyInstance(){

        /**说明
         //public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
         // 1.ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法固定
         // 2.Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方法确认类型
         // 3.InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件加载处理方法，会把当前执行的目标对象方法作为参数传入          */
        return Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 说明
                     * @param proxy：代理对象。和proxyObject对象是同一个对象，在Invoke方法中基本不用
                     * @param method：对接口中的方法进行封装的method对象
                     * @param args：调用方法的实际参数
                     * @return 方法的返回值。
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("代售点收取一定的服务费用（JDK动态代理）");
                        //通过反射机制调用目标对象的方法
                        Object returnVal = method.invoke(station,args);
                        return returnVal;
                    }
                });
    }
}
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //使用factory对象的方法获取代理对象
        SellTickets proxyObject = (SellTickets) factory.getProxyInstance();
        //调用卖火车票的方法
        proxyObject.sell();
        /**打印结果
         * 代售点收取一定的服务费用（JDK动态代理）
         * 火车站卖票
         */
    }
}

注意：ProxyFactory 不是代理模式中所说的代理类，而代理类是程序在运行过程中动态的在内存中生成的类。通过阿里巴巴开源诊断工具（Arthas【阿尔萨斯】）查看代理类的结构：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.lnjecit.proxy.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void doSomething() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.lnjecit.proxy.Subject").getMethod("doSomething");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

代理类($Proxy)实现了SellTickets。这也就印证了我们之前说的真实类和代理类实现同样的接口。将我们提供的匿名内部类对象传递给父类。

2.4 CGLIB代理

如果没有定义SellTickets，只定义了TrainStation（火车类），显然JDK代理是无法实现的，因为JDK动态代理要求必须定义接口，对接口进行代理。那么我们就可以使用CGLIB代理来实现。

概述：CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很多的补充。

代码示例

因为CGLIB是第三方提供的包，所以需要引用jar包的坐标：

<dependencies>
    <dependency>
       <groupId>cglib</groupId>
       <artifactId>cglib</artifactId>
       <version>2.2.2</version>
    </dependency>
</dependencies>

然后就可以开始写代码了

/**
 * 火车站（具体主题类）
 */
public class TrainStation {
    public void sell(){
        System.out.println("火车站卖票");
    }
}
import net.sf.cglib.proxy.*;
import java.lang.reflect.Method;

/**
 * 代理对象工厂，用来获取代理对象
 */
public class ProxyFactory implements MethodInterceptor {

    private TrainStation station = new TrainStation();

    public TrainStation getProxyFactory(){
        //创建Enhancer对象，类似于JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        return (TrainStation)enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代售点收取一点服务费用（CGLIT代理）");
        //要调用目标对象的方法
        return method.invoke(station,objects);
    }
}
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建代理工厂
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = factory.getProxyFactory();
        //调用代理对象中的sell方法卖票
        proxyObject.sell();
        /**运行结构
         * 代售点收取一点服务费用（CGLIT代理）
         * 火车站卖票
         */
    }
}

2.5 三种代理的对比

2.5.1 JDK代理和CGLIB代理

使用CGLIB实现动态代理，CGLIB底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要搞。唯一需要注意的是，CGLIB不能对声明为final的类或者方法进行代理，因为CGLIB原理是动态生成被代理类的子类

在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLIB代理效率低一点，但是到了JDK1.8的时候，JDK代理效率高于CGLIB代理。

所以如果接口使用JDK动态代理，如果没有接口使用CGLIB代理

2.5.2 动态代理和静态代理

动态代理与静态代理相比较，最大的好处是接口声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

如果接口增加一个方法，静态代理模式除了所有是实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护复杂度。而动态代理不会出现该问题

三、适配器模式

3.1 适配器模式介绍

概述：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的哪些类能一起工作。

分类：

类适配器模式
对象适配器模式
接口适配器模式

结构：

目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口
适配者（Adaptee）类：它是被访问和配置的现存组件库中的组件接口。
适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者

适用场景：

以前开发系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致
使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同

3.2 类适配器模式

实现方式：定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件

代码示例

【例】读卡器现有一台电脑只能读取SD卡，而要读取TF卡中的内容就需要使用到适配器模式。创建一个读卡器，将TF卡中的内容读取出来。接下来我们模拟一下场景

/**
 * 目标接口
 */
public interface SDCard {

    //从SDK卡中读取数据
    String readSD();
    //从SD卡中写数据
    void writeSD(String msg);
}
/**
 * 具体的SD卡类
 */
public class SDCardImpl implements SDCard {

    @Override
    public String readSD() {
        return "SDCard read msg : hello word SD";
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg : " + msg);
    }
}
/**
 * 适配者类的接口
 */
public interface TFCard {

    //从TF卡中读取数据
    String readTF();
    //从TF卡中写入数据
    void writeTF(String msg);
}
/**
 * 适配者类
 */
public class TFCarImpl implements TFCard {
    @Override
    public String readTF() {
        return "TFCard read msg : hello word TFCard";
    }

    @Override
    public void writeTF(String msg) {
        System.out.println("TFCard write ：" + msg);
    }
}
/**
 * 计算机类
 */
public class Computer {

    //从SD卡中读取数据
    public String readSD(SDCard sdCard){
        if (sdCard == null){
            throw new NullPointerException("sd card is not null");
        }
        return sdCard.readSD();
    }
}
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {

        //创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中的数据
        String msg = computer.readSD(new SDCardImpl());
        System.out.println(msg);//打印结果：SDCard read msg : hello word SD

        System.out.println("==================================");
        //使用该电脑读取TF卡中的数据
    }
}

到这里我们我们已经模拟出了大部分场景，但是现在我们想要使用电脑来读取TF卡中的数据，显然是做不到的。于是我们需要定义适配器类

/**
 * 适配器类
 */
public class SDAdapterTF extends TFCarImpl implements SDCard{
    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        writeTF(msg);
    }
}

创建好适配器类后，我们回到测试类，测试一下

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {

        //创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中的数据
        String msg = computer.readSD(new SDCardImpl());
        System.out.println(msg);//打印结果：SDCard read msg : hello word SD

        System.out.println("==================================");

        String msg1 = computer.readSD(new SDAdapterTF());
        System.out.println(msg1);
        /**打印结果
         * SDCard read msg : hello word SD
         * ==================================
         * adapter read tf card
         * TFCard read msg : hello word TFCard
         */
    }
}

类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用，反之不可以

3.3 对象适配器模式

实现方式：对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口

代码示例

【例】读卡器我们使用对象适配器模式，对适配器模式进行修改现在适配器类我们不继承适配者类，而是选择聚合适配者类

/**
 * 适配器类
 */
public class SDAdapterTF implements SDCard {

    //声明适配者类
    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return tfCard.readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        tfCard.writeTF(msg);
    }
}
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {

        //创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中的数据
        String msg = computer.readSD(new SDCardImpl());
        System.out.println(msg);//打印结果：SDCard read msg : hello word SD

        System.out.println("==================================");
        //使用该电脑读取TF卡中的数据
        //创建适配器类对象
        SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCarImpl());
        System.out.println(computer.readSD(sdAdapterTF));
        /**打印结果
         * SDCard read msg : hello word SD
         * ==================================
         * adapter read tf card
         * TFCard read msg : hello word TFCard
         */
    }
}

对象适配器与类适配器算是同一种思想，只不过实现方式不同，根据合成复用原则，对象适配器使用聚合代替继承，解决了类适配器的一定需要继承的局限性。使用成本更低，更灵活

3.4 接口适配器模式

概述：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Adapter，实现所有方法，而此时我们只需要继承该抽象类即可

代码示例

package interfaceAdapter;

public interface Interface4 {
    public void m1();
    public void m2();
    public void m3();
    public void m4();

}
package interfaceAdapter;
//在AbsAdapter我们将Interface4的方法进行默认实现
public abstract class AbsAdapter implements Interface4{
    public void m1() {

    }
    public void m2() {

    }
    public void m3() {

    }
    public void m4() {

    }
}

package interfaceAdapter;

public class Client {

public static void main(String[] args) {
    AbsAdapter absAdapter=new AbsAdapter() {
        //只需要覆盖我们需要使用的接口方法
        public void m1() {
            System.out.println("使用了m1的方法");
        }
    };
    absAdapter.m1();
}

}

四、装饰者模式

4.1 装饰者模式介绍

概述：在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外的功能）的模式

结构： 装饰（Decorator）模式中的角色：

抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加职责的对象。
具体构建（Concrete Component）角色：实现抽象构件，通过装饰者角色为其增加一些职责。
抽象装饰（Decorator）角色：继承或实现抽象构件，并包含具体构件的示例，可以通过其子类扩展具体构件的功能
具体装饰（ConcreateDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任

优点：

装饰者模式可以带来比继承更加灵活的扩展功能，使用更加方便
可以通过组合不同的装饰者对象来获取具有不同行为的状态多样化的结构
装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则
继承是静态的附加职责，装饰者是动态的附加职责
装饰类和被装饰类可以独立发展，不会互相耦合。
装饰模式是继承的一个替代模式，装饰者可以动态扩展一个实现类的功能

代码示例

【穿装备加战斗力】想必大家在玩RPG游戏的时候，都会有装备加战斗力这么一说，今天我们就用适配器模式来实现一下这个功能

//首先我们肯定是要有装备的对吧，有装备才能加战斗力嘛
//装备类中有我们的战斗力，和这个装备的描述
/**
 * 装备类（抽象构建角色）
 */
public abstract class Equip {
    private float strength;//战斗力
    private String desc;//描述

    public float getStrength() {
        return strength;
    }

    public void setStrength(float strength) {
        this.strength = strength;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Equip(float strength, String desc) {
        this.strength = strength;
        this.desc = desc;
    }

    public abstract float cost();
}
//其实在正常设计中，战士装备栏这类还有很多其他方法，比如一个战士不能装备两把主武器
//但这里我们就只简单的描述一下战斗力怎么增加，首先战士默认战斗力是35
/**
 * 战士装备栏类（具体构件类）
 */
public class Warrior extends Equip {

    public Warrior() {
        super(35, "战士");
    }

    public float cost() {
        return getStrength();
    }
}
/**
 * 法师装备栏类（具体构件类）
 */
public class Master extends Equip{

    public Master() {
        super(20, "法师");
    }

    public float cost() {
        return getStrength();
    }
}

//抽象装饰者类：这里描述的就是给构件装饰的角色。装备
/**
 * 抽象装饰者角色
 */
public abstract class Garnish extends Equip {
    //声明装备类的变量
    private Equip equip;

    public Garnish(Equip equip, float strength, String desc) {
        super(strength, desc);
        this.equip = equip;
    }

    public Equip getEquip() {
        return equip;
    }
}
/**
 * 屠龙刀类（具体装饰者角色）
 */
public class DragonSword extends Garnish{

    public DragonSword(Equip equip){
        super(equip,999,"屠龙刀");
    }

    public float cost() {
        //计算战力
        return getStrength() + getEquip().cost();
    }

    public String getDesc() {
        return getEquip().getDesc() + "+" + super.getDesc();
    }
}
/**
 * 幸运戒指（具体装饰者角色）
 */
public class LuckyRing extends Garnish{

    public LuckyRing(Equip equip){
        super(equip,50,"幸运戒指");
    }

    public float cost() {
        //计算战力
        return getStrength() + getEquip().cost();
    }

    public String getDesc() {
        return  getEquip().getDesc() + "+" + super.getDesc();
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建一个战士
        Equip warrior = new Warrior();

        System.out.println("角色：" + warrior.getDesc());
        System.out.println("战斗力：" + warrior.cost());

        System.out.println("===========================");

        //给战士装备屠龙刀
        warrior = new DragonSword(warrior);
        System.out.println("角色：" + warrior.getDesc());
        System.out.println("战斗力：" + warrior.cost());

        System.out.println("===========================");
        //给战士装备幸运戒指
        warrior = new LuckyRing(warrior);
        System.out.println("角色：" + warrior.getDesc());
        System.out.println("战斗力：" + warrior.cost());
        /**打印结果
         * 角色：战士
         * 战斗力：35.0
         * ===========================
         * 角色：战士+屠龙刀
         * 战斗力：1034.0
         * ===========================
         * 角色：战士+屠龙刀+幸运戒指
         * 战斗力：1084.0
         */
    }
}

4.2 静态代理和装饰者的区别

相同点：
- 都要是实现与目标类相同的业务接口
- 在两个类中都要声明目标对象
- 都可以在不修改目标类的前提下增强目标方法
不同点：
- 目的不同
  - 装饰者是为了增强目标对象
  - 静态代理是为了保护和隐藏目标对象
- 获取目标对象构建的方法不同
  - 装饰者是由外界转递进来，可以通过构造方法转递
  - 静态代理是在代理类内部场景，以此来隐藏目标对象

五、桥接模式

5.1 桥接模式介绍

概述：将抽象与实现分离，使它们可以独立变化，它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变的耦合度

结构：

抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。
扩展抽象化（Rofinod Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。
具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现。

优点：

提高了系统的可扩展性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
实现细节对客户透明

适用场景：

当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。
当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承练习，通过桥接模式可以使它们在抽象层建立一个关联关系。

代码示例

【例】视频播放器需求：开发一个跨平台播放器，可以在不同操作系统平台（如Windows、Mac、Linux等）上播放多种格式的视频文件，常见的视频格式包括RMVB、AVI、WMV等。该播放器包含了两个维度，适合使用桥接模式

/**
 * 视频文件（实现化角色）
 */
public interface VideoFile {
    //解码功能
    void decode(String fileName);
}

/**
 * avi视频文件（具体的实现化角色）
 */
public class AviFile implements VideoFile{

    public void decode(String fileName) {
        System.out.println("avi视频文件：" + fileName);
    }
}

/**
 * Rmv视频文件类（具体的实现化角色）
 */
public class RmvbFile implements VideoFile {

    public void decode(String fileName) {
        System.out.println("rmvb视频文件：" + fileName);
    }
}

/**
 * 抽象的操作系统类（抽象化角色）
 */
public abstract class OpratingSystem {

    //声明videFile 变量
    protected VideoFile videoFile;

    public OpratingSystem(VideoFile videoFile) {
        this.videoFile = videoFile;
    }

    public abstract void play(String fileName);
}

/**
 * Windows操作系统（扩展抽象化角色）
 */
public class Windows extends OpratingSystem{
    public Windows(VideoFile videoFile){
        super(videoFile);
    }

    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

/**
 * Mac操作系统（扩展抽象化角色）
 */
public class Mac extends OpratingSystem{
    public Mac(VideoFile videoFile){
        super(videoFile);
    }

    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建mac 系统对象
        OpratingSystem system = new Mac(new AviFile());
        //使用操作系统播放视频文件
        system.play("战狼3");
        /**打印结果
         * avi视频文件：战狼3
         */
    }
}

六、外观模式(门面模式)

6.1 外观模式介绍

概述：是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一的接口，外部应用程序不关心内部子系统的具体的细节，这样会大大降低应用的复杂度，提高了程序的可维护性。外观模式是“迪米特法则”的典型应用

结构：

外观（Facade）角色：为多个子系统对外提供一个共同的接口、
子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。

优点：

降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。
对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。

缺点：

不符合开闭原则，修改很麻烦

适用场景：

对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系
当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。
当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。

代码示例

【例】智能家电控制小明的爷爷年纪大了，一个人在家生活：每次都需要打开灯、打开电视、打开空调；睡觉时关闭灯、关闭电视、关闭空调；操作起来比较麻烦。所以小明给爷爷买了个智能音箱，可以通过语言直接控制这些智能家电的开启和关闭。

/**
 * 空调类
 */
public class AirCondition {
    //开启空调
    public void on(){
        System.out.println("打开空调...");
    }

    //关闭空调
    public void off(){
        System.out.println("关闭空调...");
    }
}

/**
 * 电灯类
 */
public class Light {

    //开灯
    public void on(){
        System.out.println("打开电灯...");
    }

    //关灯
    public void off(){
        System.out.println("关闭电灯...");
    }
}

/**
 * 电视类
 */
public class TV {
    //开启电视机
    public void on(){
        System.out.println("开启电视机...");
    }

    //关闭电视机
    public void off(){
        System.out.println("关闭电视机...");
    }
}


/**
 * 外观类：用户主要和该类对象进行交互
 */
public class SmartAppliancesFacade {

    //聚合电灯对象，电视机对象，空调对象
    private Light light;
    private TV tv;
    private AirCondition airCondition;

    public SmartAppliancesFacade() {
        light = new Light();
        tv = new TV();
        airCondition = new AirCondition();
    }

    //通过语言控制
    public void say(String message){
        if(message.contains("打开")){
            on();
        }else if(message.contains("关闭")){
            off();
        }else {
            System.out.println("没听懂你说什么");
        }
    }

    //一键打开功能
    private void on(){
        light.on();
        tv.on();
        airCondition.on();
    }

    //一键打开功能
    private void off(){
        light.off();
        tv.off();
        airCondition.off();
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建智能音箱对象
        SmartAppliancesFacade facade = new SmartAppliancesFacade();
        //控制家电
        facade.say("打开家电");
        System.out.println("===============");
        facade.say("关闭家电");
    }
}

七、组合模式

7.1 组合模式介绍

树形结构：在树形结构中可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点后，就可以对叶子节点进行相关的操作。可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。但是由于容器对象和叶子对象在功能上面的区别，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦，作为客户而已，它始终希望能够一致的对待容器对象和叶子对象。

概述：用于把一组相似的对象当作一个单一的对象，组合模式依据树形结构来组合对象，用来表示部分以及整体层此。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

结构：

抽象跟节点（Component）：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性。
叶枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
叶子节点（Leat）：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

优点：

组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码、
在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改，符合开闭原则。
为树形结构的面向对象提供了一种灵活的解决方案，通过叶子节点和树枝系欸但的递归组合，可以形成复杂的树形结构，但对树形结构的控制非常简单。

适用场景：

组合模式正是应树形结构而生的，所以使用场景就是出现树形结构的地方。比如：文件目录显示，多级目录呈现等树形结构数据操作。

分类： 根据抽象构建类的定义形式，我们可将组合模式分为透明模式和安全组合模式两种形式。

透明组合模式： 抽象节点角色中声明了所有用于管理成员对象的方法，确保所有的构件类都有相同的接口。透明组合模式的缺点就是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一层的对象，即不可能包含成员变量，因此为其提供方法是没有意义的，这在编译阶段不会出错，但在运行阶段调用这些方法就可能出错（如果没有提供相应的错误处理代码）
安全组合模式： 在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点类中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。

代码示例

【例】软件菜单如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单。一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，我们的需求是针对一个菜单，打印出其包含的所有菜单以及菜单项的名称。

代码实现：不管是菜单还是菜单项，都应该继承自统一的接口，这里姑且将这个统一的接口称为菜单组件。

/**
 * 菜单组件（抽象跟节点）
 */
public abstract class MenuComponent {
    //菜单组件的名称
    protected String name;
    //菜单组件的层级
    protected int level;

    //添加子菜单
    public void add(MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }

    //移除子菜单
    public void remove(MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }

    //获取指定子菜单
    public MenuComponent getChild(int index){
        throw new UnsupportedOperationException();
    }

    //获取菜单或者菜单项的名称
    public String getName(){
        return name;
    }

    //打印菜单名称的方法（包括子菜单和子菜单项）
    public abstract void print();
}

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;

/**
 * 菜单类：属于树枝节点
 */
public class Menu extends MenuComponent {
    //菜单可以有多个子菜单或子菜单项
    private List<MenuComponent> menuComponentList = new ArrayList<MenuComponent>();

    public Menu(String name, int level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void add(MenuComponent menuComponent) {
        menuComponentList.add(menuComponent);
    }

    @Override
    public void remove(MenuComponent menuComponent) {
        menuComponentList.remove(menuComponent);
    }

    @Override
    public MenuComponent getChild(int index) {
        return menuComponentList.get(index);
    }

    public void print(){
        //打印菜单名称
        for (int i = 0;i<level;i++){
            System.out.print("--");
        }
        System.out.println(name);
        //打印子菜单或者子菜单项
        for (MenuComponent component : menuComponentList){
            component.print();
        }
    }
}

/**
 * 菜单项类：属于叶子节点
 */
public class MenuItem extends MenuComponent{

    public MenuItem(String name,int level){
        this.name=name;
        this.level=level;
    }

    @Override
    public void print() {
        //打印菜单项的名称
        for (int i = 0;i<level;i++){
            System.out.print("--");
        }
        System.out.println(name);
    }
}
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //创建菜单数
        MenuComponent menu1 = new Menu("菜单管理",2);
        menu1.add(new MenuItem("页面访问",3));
        menu1.add(new MenuItem("展开菜单",3));
        menu1.add(new MenuItem("编辑菜单",3));
        menu1.add(new MenuItem("删除菜单",3));
        menu1.add(new MenuItem("新增菜单",3));

        MenuComponent menu2 = new Menu("权限管理",2);
        menu2.add(new MenuItem("页面访问",3));
        menu2.add(new MenuItem("提交保存",3));

        MenuComponent menu3 = new Menu("角色管理",2);
        menu3.add(new MenuItem("页面访问",3));
        menu3.add(new MenuItem("新增角色",3));
        menu3.add(new MenuItem("修改角色",3));

        //创建一级菜单
        MenuComponent component = new Menu("系统管理",1);
        component.add(menu1);
        component.add(menu2);
        component.add(menu3);

        //打印菜单名称（如果有子菜单一块打印）
        component.print();
        /**打印结构
         * --系统管理
         * ----菜单管理
         * ------页面访问
         * ------展开菜单
         * ------编辑菜单
         * ------删除菜单
         * ------新增菜单
         * ----权限管理
         * ------页面访问
         * ------提交保存
         * ----角色管理
         * ------页面访问
         * ------新增角色
         * ------修改角色
         *
         * 进程已结束，退出代码为 0
         */
    }
}

八、享元模式

8.1 享元模式介绍

概述：运用共享技术来有效地支持大量细粒度对象的复用，它通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似对象的开销，从而提高系统资源的利用率。

结构： 享元（Fiyweight）模式中存在以下两种状态： 1.内部状态，即不会随着环境的改变而改变的可共享部分。 2.外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

享元模式的主要角色:

抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）
具体享元（Concrete Fiyweight）角色：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
非享元（Unsharable Flyweight）角色：并不是所有的抽象享元类的子类都需要被共享，不能被分享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色，当客户对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

优点：

极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
享元模式中的外部状态相对独立，且不影响内部状态

缺点：

为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

适用场景：

一个系统有大量相同或相似的对象（造成内存的大量耗费）
对象的大部分状态都可以外部化，可以将这些外部化状态传入对象中。
在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

代码示例

【例】俄罗斯方块下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间。（我们需要使用享元模式来解决这一问题）

/**
 * 抽象享元角色
 */
public abstract class AbstractBox {
    //获取图形的方法
    public abstract String getShape();

    //显示图形及颜色
    public void display(String color) {
        System.out.println("方块状态：" + getShape() + "，颜色：" + color);
    }
}
/**
 * I图形类（具体享元角色）
 */
public class IBox extends AbstractBox{

    public String getShape() {
        return "I";
    }
}

/**
 * L图形类（具体享元角色）
 */
public class LBox extends AbstractBox{

    public String getShape() {
        return "L";
    }
}

/**
 * O图形类（具体享元角色）
 */
public class OBox extends AbstractBox{

    public String getShape() {
        return "O";
    }
}

import java.util.HashMap;

/**
 * 工厂类，将该类设计为单例
 */
public class BoxFactory {

    private HashMap<String,AbstractBox> map;

    //在构造方法中进行初始化操作
    private BoxFactory(){
        map = new HashMap<String,AbstractBox>();
        map.put("I",new IBox());
        map.put("L",new LBox());
        map.put("O",new OBox());
    }

    private static BoxFactory factory = new BoxFactory();

    //提供一个方法获取该工厂类对象
    public static BoxFactory getInstance(){
        return factory;
    }

    //根据名称获取图形对象
    public AbstractBox getShape(String name){
        return map.get(name);
    }
}
/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        //获取I图形对象
        AbstractBox box1 =  BoxFactory.getInstance().getShape("I");
        box1.display("灰色");

        //获取L图形对象
        AbstractBox box2 =  BoxFactory.getInstance().getShape("L");
        box1.display("绿色");

        //获取O图形对象
        AbstractBox box3 =  BoxFactory.getInstance().getShape("O");
        box1.display("灰色");

        //获取O图形对象
        AbstractBox box4 =  BoxFactory.getInstance().getShape("O");
        box1.display("红色");

        System.out.println("两次获取到的O对象是否是同一个对象：" + (box3 == box4));
        /**打印结构
         * 方块状态：I，颜色：灰色
         * 方块状态：L，颜色：绿色
         * 方块状态：O，颜色：灰色
         * 方块状态：O，颜色：红色
         * 两次获取到的O对象是否是同一个对象：true
         */
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2022-04-29，如有侵权请联系 cloudcommunity@tencent.com 删除

jdk

面向对象编程

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

jdk

面向对象编程