GoF设计模式——结构型设计模式分析与应用

news2024/11/25 9:50:31

文章目录

    • UML图的结构主要表现为：继承（抽象）、关联 、组合或聚合 的三种关系。
      • 1. 继承（抽象，泛化关系）
      • 2. 关联
      • 3. 组合/聚合
      • 各种可能的配合：
        • 1. 关联后抽象
        • 2. 关联的集合
        • 3. 组合接口
        • 4. 递归聚合接口
      • Adapter
      • Bridge
      • Composite
      • Decorator
      • Facade
      • Flyweight
      • Proxy

GoF(Gang of Four)设计模式的三大类：

  • 创建型设计模式（Creational Patterns）
  • 结构型设计模式（Structural Patterns）
  • 行为设计模式（Behavioral Patterns）

Object Scope 可用于运行时

Class Scope 只能用于编译时

在这里插入图片描述

UML图的结构主要表现为：继承（抽象）、关联 、组合或聚合 的三种关系。

车是交通工具，车是我的，车里有发动机

1. 继承（抽象，泛化关系）

class Vehicle {
    String name;
    void move() {}
}

class Car extends Vehicle {
    void drive() {}
}

2. 关联

class Person {
    Car car; // 关联关系
}

class Car {
    String model;
}

3. 组合/聚合

class Car {
    Engine engine; // 组合关系
    GPS gps;       // 聚合关系
}

class Engine {}
class GPS {}

各种可能的配合：

圈住部分即为原因。

1. 关联后抽象

在这里插入图片描述

2. 关联的集合

在这里插入图片描述

3. 组合接口

在这里插入图片描述

4. 递归聚合接口

在这里插入图片描述
这里递归怎么理解？

其实是虽然我的装饰器实现了这个接口，但是我的装饰器类内部成员可能还有有这个接口类。

Adapter

适配器模式能够将不兼容的接口转换成兼容的接口，从而使得原本无法直接交互的类能够合作。
可以在不修改现有代码的情况下，重用第三方的功能或代码。
可以在不同的系统间进行灵活的接口转换，尤其适用于系统集成和迁移。

Adapter（适配器）设计模式

继承+关联 （“关联后抽象”）

“ 加一层，新接口。”
在这里插入图片描述

（“R”标记：可运行时改变；实心箭头指实现，空心指泛化）

设计逻辑的层次：

  • 先从具体类（ConcreteAdapter）的实现入手，明确其与其他类的关联（如 Adaptee）。
  • 然后在其上进一步抽象出一个统一的接口（Adapter），以适应多种实现需求。
// 老版本的播放器接口
class OldMediaPlayer {
    void playAudio() {
        System.out.println("Playing audio...");
    }
}

// 新播放器接口
interface ModernPlayer {
    void play();
}

// 适配器类
class PlayerAdapter implements ModernPlayer {
    private OldMediaPlayer oldMediaPlayer;

    public PlayerAdapter(OldMediaPlayer oldMediaPlayer) {
        this.oldMediaPlayer = oldMediaPlayer;
    }

    @Override
    public void play() {
        oldMediaPlayer.playAudio(); // 使用旧方法适配新接口
    }
}

// 客户端代码
public class AdapterExample {
    public static void main(String[] args) {
        OldMediaPlayer oldPlayer = new OldMediaPlayer();
        ModernPlayer modernPlayer = new PlayerAdapter(oldPlayer);

        modernPlayer.play(); // 使用新接口播放
    }
}

Bridge

解耦抽象和实现：桥接模式将抽象部分与实现部分分离，可以独立地扩展两者。
新增抽象层或者实现层时，不会影响到对方，增强了系统的可扩展性。
避免重复代码，增加代码复用性。

Bridge（桥）设计模式

组合接口

“ 比如形状类里加个颜色类。 而该形状可以在各种地方使用”
在这里插入图片描述

// 实现接口
interface Color {
    String fill();
}

class Red implements Color {
    public String fill() {
        return "Color is Red";
    }
}

class Blue implements Color {
    public String fill() {
        return "Color is Blue";
    }
}

// 抽象类
abstract class Shape {
    protected Color color;

    public Shape(Color color) {
        this.color = color;
    }

    abstract void draw();
}

class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }

    public void draw() {
        System.out.println("Drawing Circle. " + color.fill());
    }
}

// 客户端代码
public class BridgeExample {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new Red());
        Shape blueCircle = new Circle(new Blue());

        redCircle.draw();
        blueCircle.draw();
    }
}

Composite

树形结构：组合模式允许你以树形结构来组合对象，简化了对象的管理和处理。
统一操作：可以统一对单个对象和组合对象的处理，客户端不需要知道是单一对象还是组合对象。
递归结构：支持递归组合，使得层次结构更易于表示和管理，特别适用于有层次结构的对象模型。

Composite（组合）设计模式

递归聚合接口

“可以都放进一个容器，装满书的书包”

书包里可能还有一个书包，所以书包的“聚合”里，还有component抽象类——递归。
在这里插入图片描述

// 组件接口
interface Component {
    void operation();
}

// 叶子节点
class Leaf implements Component {
    private String name;

    public Leaf(String name) {
        this.name = name;
    }

    public void operation() {
        System.out.println("Leaf: " + name);
    }
}

// 容器节点
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component component) {
        children.add(component);
    }

    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }
}

// 客户端代码
public class CompositeExample {
    public static void main(String[] args) {
        Composite root = new Composite();

        Leaf leaf1 = new Leaf("Leaf 1");
        Leaf leaf2 = new Leaf("Leaf 2");

        Composite subTree = new Composite();
        subTree.add(new Leaf("SubTree Leaf 1"));

        root.add(leaf1);
        root.add(leaf2);
        root.add(subTree);

        root.operation(); // 遍历树形结构
    }
}

Decorator

动态扩展功能：装饰器模式可以在运行时动态地给对象添加新的功能，而不改变原有类的代码。
增加灵活性：通过装饰器，可以为对象添加多种功能，客户端可以根据需求进行组合，增加了系统的灵活性。
符合开放/关闭原则：装饰器通过扩展功能，而不是修改类本身，符合开放/关闭原则。

Decorator（装饰器）设计模式

递归聚合接口

“对不同物品可以进行不同装饰”

“两组抽象和实现。
装饰器里有【具体部件】和新的方法”
在这里插入图片描述

// 抽象组件（饮料）
interface Beverage {
    String getDescription();
    double cost();
}

// 具体组件
class Coffee implements Beverage {
    public String getDescription() {
        return "Coffee";
    }

    public double cost() {
        return 5.0;
    }
}

// 装饰器
abstract class AddOnDecorator implements Beverage {
    protected Beverage beverage;

    public AddOnDecorator(Beverage beverage) {
        this.beverage = beverage;
    }
}

class Milk extends AddOnDecorator {
    public Milk(Beverage beverage) {
        super(beverage);
    }

    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }

    public double cost() {
        return beverage.cost() + 1.0;
    }
}

class Sugar extends AddOnDecorator {
    public Sugar(Beverage beverage) {
        super(beverage);
    }

    public String getDescription() {
        return beverage.getDescription() + ", Sugar";
    }

    public double cost() {
        return beverage.cost() + 0.5;
    }
}

// 客户端代码
public class DecoratorExample {
    public static void main(String[] args) {
        Beverage beverage = new Coffee();
        beverage = new Milk(beverage);
        beverage = new Sugar(beverage);

        System.out.println(beverage.getDescription() + " costs " + beverage.cost());
    }
}

Facade

简化接口：外观模式为复杂子系统提供了一个统一的、高层的接口，简化了客户端的调用方式。
降低耦合：客户端不需要了解各个子系统的实现细节，只需要与外观类交互，从而降低了系统的耦合度。
便于扩展：如果需要修改子系统的实现，可以在外观类中进行修改，而不影响客户端代码。

Façade（门面）设计模式

关联的集合

“将各个组件集成在一起”
在这里插入图片描述

class CPU {
    public void start() {
        System.out.println("CPU started.");
    }
}

class Memory {
    public void load() {
        System.out.println("Memory loaded.");
    }
}

class HardDrive {
    public void readData() {
        System.out.println("HardDrive read data.");
    }
}

// 门面类
class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private HardDrive hardDrive;

    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.hardDrive = new HardDrive();
    }

    public void start() {
        cpu.start();
        memory.load();
        hardDrive.readData();
    }
}

// 客户端代码
public class FacadeExample {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.start(); // 一键启动
    }
}

Flyweight

内存优化：享元模式通过共享相同的对象实例，减少了内存的消耗，尤其适用于大量相似对象的场景。
提高性能：由于共享对象的使用，可以减少对象的创建和销毁，提高了系统的性能。

Flyweight（享元）设计模式

关联的集合

“共享的懒汉模式”
在这里插入图片描述

// 抽象享元
interface Shape {
    void draw();
}

// 具体享元
class Circle implements Shape {
    private String color;

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

    public void draw() {
        System.out.println("Drawing " + color + " Circle");
    }
}

// 享元工厂
class ShapeFactory {
    private static Map<String, Shape> shapeMap = new HashMap<>();

    public static Shape getCircle(String color) {
        if (!shapeMap.containsKey(color)) {
            shapeMap.put(color, new Circle(color));
            System.out.println("Created new " + color + " Circle");
        }
        return shapeMap.get(color);
    }
}

// 客户端代码
public class FlyweightExample {
    public static void main(String[] args) {
        Shape redCircle = ShapeFactory.getCircle("Red");
        Shape blueCircle = ShapeFactory.getCircle("Blue");
        Shape anotherRedCircle = ShapeFactory.getCircle("Red");

        redCircle.draw();
        blueCircle.draw();
        anotherRedCircle.draw(); // 复用红色圆
    }
}

Proxy

控制访问：代理模式可以控制对真实对象的访问，例如延迟加载、权限控制、缓存等。
增强功能：代理类可以为目标对象增加额外的功能，比如日志记录、安全控制等，而不需要修改目标对象的代码。
降低耦合：代理类和目标类相互独立，客户端通过代理类访问目标对象，减少了对目标类的直接依赖。

Proxy（代理）设计模式

关联后抽象

“懒汉模式”
在这里插入图片描述

// 抽象接口
interface Image {
    void display();
}

// 真实类
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading " + fileName);
    }

    public void display() {
        System.out.println("Displaying " + fileName);
    }
}

// 代理类
class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName); // 延迟加载
        }
        realImage.display();
    }
}

// 客户端代码
public class ProxyExample {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");
        image.display(); // 加载并显示
        image.display(); // 再次显示，无需加载
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2247211.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【论文复现】深度知识追踪

【论文复现】深度知识追踪

&#x1f4dd;个人主页&#x1f339;&#xff1a;Eternity._ &#x1f339;&#x1f339;期待您的关注 &#x1f339;&#x1f339; ❀ 深度知识追踪 1. 论文概述2. 论文方法3. 实验部分3.1 数据集3.2 实验步骤3.3 实验结果 4 关键代码 1. 论文概述 知识追踪的任务是对学生的知…
阅读更多...
Linux: 进程地址空间（理解虚拟地址和页表）

Linux: 进程地址空间（理解虚拟地址和页表）

目录 1. 虚拟地址 2. 进程地址空间分布 3. 描述进程地址空间 4. 内存管理——页表 5. 父子进程的虚拟地址关系 6. 页表标记位 6.1 读写权限 6.2 命中权限 7.为什么存在进程地址空间 1. 虚拟地址 #include <stdio.h> #include <unistd.h> #include <sy…
阅读更多...
C语言：深入理解指针

C语言：深入理解指针

一.内存和地址 我们知道计算机上CPU&#xff08;中央处理器&#xff09;在处理数据的时候&#xff0c;需要的数据是在内存中读取的&#xff0c;处理后的数据也会放回内存中&#xff0c;那我们买电脑的时候&#xff0c;电脑上内存是 8GB/16GB/32GB 等&#xff0c;那这些内存空间…
阅读更多...
transformer.js（一）：这个前端大模型运行框架的可运行环境、使用方式、代码示例以及适合与不适合的场景

transformer.js（一）：这个前端大模型运行框架的可运行环境、使用方式、代码示例以及适合与不适合的场景

随着大模型的广泛应用&#xff0c;越来越多的开发者希望在前端直接运行机器学习模型&#xff0c;从而减少对后端的依赖&#xff0c;并提升用户体验。Transformer.js 是一个专为前端环境设计的框架&#xff0c;它支持运行基于 Transformer 架构的深度学习模型&#xff0c;尤其是…
阅读更多...
uni-app 发布媒介功能（自由选择媒介类型的内容） 设计

uni-app 发布媒介功能（自由选择媒介类型的内容） 设计

1.首先明确需求 我想做一个可以选择媒介的内容&#xff0c;来进行发布媒介的功能 &#xff08;媒介包含&#xff1a;图片、文本、视频&#xff09; 2.原型设计 发布-编辑界面 通过点击下方的加号&#xff0c;可以自由选择添加的媒介类型 但是因为预览中无法看到视频的效果&…
阅读更多...
行业分析---2024年小鹏汽车AI Day及三季度财报

行业分析---2024年小鹏汽车AI Day及三季度财报

1 背景 在之前的博客中&#xff0c;笔者撰写了多篇行业类分析的文章&#xff08;科技新能源&#xff09;&#xff1a; 《行业分析---我眼中的Apple Inc.》 《行业分析---马斯克的Tesla》 《行业分析---造车新势力之蔚来汽车》 《行业分析---造车新势力之小鹏汽车》 《行业分析-…
阅读更多...
数据可视化复习1-Matplotlib简介属性和创建子图

数据可视化复习1-Matplotlib简介属性和创建子图

1.Matplotlib简介 Matplotlib是一个Python的2D绘图库&#xff0c;它可以在各种平台上以各种硬拷贝格式和交互环境生成具有出版品质的图形。通过Matplotlib&#xff0c;开发者可以仅需要几行代码&#xff0c;便可以生成绘图、直方图、功率谱、条形图、错误图、散点图等。 以下…
阅读更多...
WebStorm 2024.3/IntelliJ IDEA 2024.3出现elementUI提示未知 HTML 标记、组件引用爆红等问题处理

WebStorm 2024.3/IntelliJ IDEA 2024.3出现elementUI提示未知 HTML 标记、组件引用爆红等问题处理

WebStorm 2024.3/IntelliJ IDEA 2024.3出现elementUI提示未知 HTML 标记、组件引用爆红等问题处理 1. 标题识别elementUI组件爆红 这个原因是&#xff1a; 在官网说明里&#xff0c;才版本2024.1开始&#xff0c;默认启用的 Vue Language Server&#xff0c;但是在 Vue 2 项目…
阅读更多...
如何安全删除 Linux 用户帐户和主目录 ？

如何安全删除 Linux 用户帐户和主目录 ？

Linux 以其健壮性和灵活性而闻名&#xff0c;是全球服务器和桌面的首选。管理用户帐户是系统管理的一个基本方面&#xff0c;包括创建、修改和删除用户帐户及其相关数据。本指南全面概述了如何在 Linux 中安全地删除用户帐户及其主目录&#xff0c;以确保系统的安全性和完整性。…
阅读更多...
如何利用ros搭建虚拟场景通过仿真机器人完成一次简单的SLAM建图、导航规划（超简单）？——学习来源：机器人工匠阿杰

如何利用ros搭建虚拟场景通过仿真机器人完成一次简单的SLAM建图、导航规划（超简单）？——学习来源：机器人工匠阿杰

一&#xff1a;什么是SLAM&#xff0c;SLAM和导航规划又有什么关系&#xff1f; SLAM&#xff08;Simultaneous Localization and Mapping&#xff0c;即同时定位与建图&#xff09;是一种在未知或动态环境中自行驶的重要技术。主要通过设备上的传感器&#xff08;如激光雷达、…
阅读更多...
shell脚本（完结）

shell脚本（完结）

声明&#xff1a;学习视频来自b站up主 泷羽sec&#xff0c;如涉及侵权马上删除文章 感谢泷羽sec 团队的教学 视频地址&#xff1a;shell编程&#xff08;完结&#xff09;_哔哩哔哩_bilibili 本文主要讲解不同shell脚本中的相互调用以及输入输出重定向操作。 一、不同脚本之间…
阅读更多...
禁用达梦DEM的agent

禁用达梦DEM的agent

agent占用内存较多&#xff0c;实际没什么使用&#xff0c;考虑停止agent 应该切换到root执行停止 cd /dm/dmdbms/tool/dmagent/service/ ./DmAgentService stop禁用
阅读更多...
使用ChatGPT生成和优化电子商务用户需求规格说明书

使用ChatGPT生成和优化电子商务用户需求规格说明书

在电子商务项目开发中&#xff0c;用户需求规格说明书&#xff08;User Requirement Specification, URS&#xff09;是团队沟通与项目成功的基石。然而&#xff0c;面对复杂多变的需求&#xff0c;如何快速生成清晰、完整且具备说服力的文档&#xff1f;这正是AI工具的用武之地…
阅读更多...
产品研发管理和研发项目管理的区别是什么

产品研发管理和研发项目管理的区别是什么

产品研发管理与研发项目管理有显著的区别&#xff0c;主要体现在管理范围、目标导向和执行方法上。产品研发管理侧重于产品生命周期的规划与执行&#xff0c;强调产品的创新性和市场需求对接&#xff0c;而研发项目管理则更注重具体项目的执行过程&#xff0c;聚焦项目时间、成…
阅读更多...
摆烂仙君传——深度学习秘境奇缘

摆烂仙君传——深度学习秘境奇缘

第一章&#xff1a;深度学习秘境 在修仙界与科技交织的边缘&#xff0c;八荒六合九天无上摆烂仙君在其高科技修炼室中感应到一股神秘的召唤。这股力量似乎与他的灵魂产生了共鸣&#xff0c;引导他前往传说中的深度学习秘境。在那里&#xff0c;古老的仙法与前沿的算法交织&…
阅读更多...
【FPGA开发】Vivado自定义封装IP核，绑定总线

【FPGA开发】Vivado自定义封装IP核，绑定总线

支持单个文件的封装、整个工程的封装&#xff0c;这里用单个文件举例。 在文件工程目录下&#xff0c;自建一个文件夹&#xff0c;里面放上需要封装的verilog文件。 选择第三个&#xff0c;指定路径封装&#xff0c;找到文件所在目录 取个名&#xff0c;选择封装IP的路径 会…
阅读更多...
【CS61A 2024秋】Python入门课，全过程记录P2（Week3开始，更新中2024/11/24）

【CS61A 2024秋】Python入门课，全过程记录P2（Week3开始，更新中2024/11/24）

文章目录 关于基本介绍&#x1f44b;Week 3Mon Environments阅读材料Lab 02: Higher-Order Functions, Lambda ExpressionsQ1: WWPD: The Truth Will PrevailQ2: WWPD: Higher-Order FunctionsQ3: WWPD: Lambda 关于 个人博客&#xff0c;里面偶尔更新&#xff0c;最近比较忙。…
阅读更多...
在Linux下配置gitee与Github的远程仓库

在Linux下配置gitee与Github的远程仓库

目录 前言 云服务器下载git 检测是否下载成功git Linux下配置gitee远程仓库 代码提交演示 git三板斧 Linux下配置Github远程仓库 最后的提醒 前言 那么本篇文章将是在&#xff0c;你已经创建了本地仓库的基础上&#xff0c;在Linux下配置gitee的远程仓库的步骤&#xff…
阅读更多...
Mac配置maven环境及在IDEA中配置Maven

Mac配置maven环境及在IDEA中配置Maven

Mac配置maven环境及在IDEA中配置Maven 1. 介绍 Maven是一款广泛用于Java等JVM语言项目的工具&#xff0c;它以项目对象模型&#xff08;POM&#xff09;为基础进行项目管理&#xff0c;通过POM文件来定义项目信息和依赖关系。同时&#xff0c;它也是构建自动化工具&#xff0…
阅读更多...
硬中断关闭后的堆栈抓取方法

硬中断关闭后的堆栈抓取方法

一、背景 性能和稳定性是一个计算机工程里的一个永恒的主题。其中尤其稳定性这块的问题发现和问题分析及问题解决就依赖合适的对系统的观测的手段&#xff0c;帮助我们发现问题&#xff0c;识别问题原因最后才能解决问题。稳定性问题里尤其底层问题里&#xff0c;除了panic问题…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023