设计模式-结构型模式讲解上（适配器、桥接、组合、享元）

一、结构型设计模式

上篇，我们呢讲解了创建型设计模式，包括 单例、原型、工厂方法，抽象工厂、构建者模式。

文章地址：https://blog.csdn.net/qq_43692950/article/details/120165779

这篇文章我们来讲解下结构型设计模式，结构型设计模式，主要处理类或对象的组合关系，为如何设计类以形成更大的结构提供指南。

结构型设计模式包括：适配器模式（Adapter Pattern）、桥接模式（Bridge Pattern）、组合模式（Composite Pattern）、装饰器模式（Decorator Pattern）、外观模式（Facade Pattern）、享元模式（Flyweight Pattern）、代理模式（Proxy Pattern）

在本文中主要介绍 适配器、桥接、组合、享元四种设计模式，下篇文章为讲解 外观、代理、 装饰器 。

二、适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。它结合了两个独立接口的功能。
优点：1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，在视频播放器中，假设视频播放器只能播放MP4格式的视频，那现在又个VLC格式的视频，那就不能播放了，那要怎么办呢？如果我们做个装换器，将VLC格式的视频转换为MP4格式的视频不就可以播放了吗，那这个转换器我们就可以采用适配器设计模式来设计。

下面使用程序演示下上面的例子：

1. 定义视频接口

public interface VideoInterFace {
    String getVideoPath();
}

2. 定时Mp4格式视频实例

public class Mp4Video implements VideoInterFace {
    @Override
    public String getVideoPath() {
        return "Mp4视频的路径";
    }
}

3. 定义Vlc格式视频实例

public class VlcVideo implements VideoInterFace{
    @Override
    public String getVideoPath() {
        return "Vlc视频的路径";
    }
}

4. 定义播放器，只接口Mp4格式的视频

public class Player {
    private Mp4Video video;

    public Player(Mp4Video video) {
        this.video = video;
    }

    public void play() {
        System.out.println(StringFormatter.concat("播放视频视频地址：", video.getVideoPath()).getValue());
    }
}

5. 我们需要播放Vlc格式的视频，定义Mp4的适配器，并接收Vlv格式视频，进行转码。

public class Mp4Adapter extends Mp4Video {

    private VlcVideo vlcVideo;

    public Mp4Adapter(VlcVideo vlcVideo) {
        this.vlcVideo = vlcVideo;
    }

    @Override
    public String getVideoPath() {
        System.out.println(StringFormatter.concat("开始格式转换，vlc地址：", vlcVideo.getVideoPath()).getValue());
        return "转换后的Mp4路径！";
    }
}

6. 测试

public class demo {
    public static void main(String[] args) {
        Player player = new Player(new Mp4Video());
        player.play();

        VlcVideo vlcVideo = new VlcVideo();
        Player player1 = new Player(new Mp4Adapter(vlcVideo));
        player1.play();
    }
}

从上面的例子可以看出，需要播放Vlc格式，我们就需要写一个目标适配器，这里是Mp4适配器，并继承Mp4，使之有Mp4的特性，并在内部做相应的转换即可，提高了系统的可扩展性。

三、桥接模式

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。
这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。
优点： 1、抽象和实现的分离。 2、优秀的扩展能力。 3、实现细节对客户透明。

举个例子：绘画不同颜色的各种图像，画不同的形状和涂颜色，便是两个不同的功能，但两者又相互联系，在画完形状后需要涂颜色，但颜色和形状有使多种多样的，此时就可以采用桥接设计模式，将两者的抽象化与实现化解耦，形状和颜色可以独立变化。

下面使用程序演示下上面的例子：

1. 定义颜色的接口

public interface ColorApi {
   public void drawCircle();
}

2. 定义不同颜色的实现，这里采用红色和绿色

public class ReqColor implements ColorApi {
    @Override
    public void drawCircle() {
        System.out.println("开始涂红色！");
    }
}

public class GreenColor implements ColorApi {
   @Override
   public void drawCircle() {
      System.out.println("开始涂绿色！");
   }
}

3. 定义形状的接口

public interface ShapeApi {
    //画形状
    void draw();
    //画形状并涂颜色
    void drawShapeAndsColor();
}

4. 定义形状的抽象模板，将共性的操作定义到抽象中

public abstract class ShapeAbstract implements ShapeApi {

    public ColorApi colorApi;

    public ShapeAbstract(ColorApi colorApi) {
        this.colorApi = colorApi;
    }

    @Override
    public void drawShapeAndsColor() {
        draw();
        colorApi.drawCircle();
    }
}

5. 定义圆形的实例

public class Circle extends ShapeAbstract {

   public Circle(ColorApi colorApi) {
      super(colorApi);
   }
 
   @Override
   public void draw() {
      System.out.println("开始画圆形！");
   }
}

6. 定义矩形的实例

public class Rectangle extends ShapeAbstract {

    public Rectangle(ColorApi colorApi) {
        super(colorApi);
    }

    @Override
    public void draw() {
        System.out.println("开始画矩形");
    }
}

7. 演示

public class demo {
   public static void main(String[] args) {
      ShapeApi shapeReq = new Circle(new ReqColor());
      shapeReq.drawShapeAndsColor();

      ShapeApi shapeGreen = new Circle(new GreenColor());
      shapeGreen.drawShapeAndsColor();

      ShapeApi rectangle = new Rectangle(new GreenColor());
      rectangle.drawShapeAndsColor();
   }
}

上面可以看出，可以灵活的定义形状和颜色的组合，并且他们两个都可以独立变化，添加新的形状只需，建立新的类并实现形状接口，添加颜色也是如此，极大的提高的系统的可扩展性和可维护型。

四、组合模式

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。
组合模式依据树形结构来组合对象，用来表示部分以及整体层次。它创建了对象组的树形结构。
优点： 1、高层模块调用简单。 2、节点自由增加。
缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

举个例子：一个公司，从上到下分为，公司、部门、小组等，他们整个在一起才能称为一个完整的公司，要表示做个公司的结构，就可以采用组合设计模式。

下面使用程序演示下上面的例子：

1. 定义属性类，用来表示不同层级的对象

@Data
public class Property {
   private String name;
   //下一层的子集
   private List<Property> next;

   public Property(String name) {
      this.name = name;
      next = new ArrayList<Property>();
   }
 
   public void add(Property e) {
      next.add(e);
   }
 
   public void remove(Property e) {
      next.remove(e);
   }
 
   public List<Property> getSubordinates(){
     return next;
   }
}

2. 使用演示

public class demo {
   public static void main(String[] args) {
      Property company = new Property("公司");
      Property department = new Property("部门");
      Property group = new Property("小组");

      company.add(department);
      department.add(group);

      System.out.println(company);
   }
}

上面就演示了一个公司的组合，通过company对象就可以获得整个公司的各个部分的对象。组合设计模式主要适合于整体部分的场景。

五、享元模式

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。它提供了减少对象数量从而改善应用所需的对象结构的方式。
享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。他的优点是大大减少对象的创建，降低系统的内存，使效率提高，但也有可能造成内存的浪费。比如Spring的采用容器的方式存储bean，使用时从容器中获取。

还是拿上面的画不同颜色形状的例子演示下享元设计模式的使用：

1. 定义形状的接口

public interface Shape {
   void draw();
}

2. 定义圆形的实现，并接收一个颜色值：

public class Circle implements Shape {

    private String color;

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

    @Override
    public void draw() {
        System.out.println(StringFormatter.concat("开始画 ", color, " 色的圆 ").getValue());
    }
}

3. 定义形状对象获取工厂，根据颜色值将对象存储到HashMap中，后再根据颜色值取对象，达到复用的效果。

public class ShapeFactory {

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

    public static Shape getCircle(String color) {
        if (!circleMap.containsKey(color)) {
            System.out.println(StringFormatter.concat(">> 创建", color, "颜色的圆 ").getValue());
            circleMap.put(color, new Circle(color));
        }
        return circleMap.get(color);
    }
}

4. 使用

public class demo {
    private static final String colors[] =
            {"Red", "Green", "Blue", "White", "Black"};

    public static void main(String[] args) {

        for (int i = 0; i < 20; ++i) {
            Shape circle = ShapeFactory.getCircle(getRandomColor());
            circle.draw();
        }
    }

    private static String getRandomColor() {
        return colors[(int) (Math.random() * colors.length)];
    }
}

上面可以看出，享元设计模式可以大大减少对象的创建，但也有可以造成内存的浪费，比如某个对象的使用频率非常低，如果一直存在内存中就有点浪费空间了。

文章来源: blog.csdn.net，作者：小毕超，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/qq_43692950/article/details/120248267