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

news/2024/11/27 2:14:59/

文章目录

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

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

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;}@Overridepublic 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.ppmy.cn/news/1550211.html

相关文章

SpringBoot（9）-Dubbo+Zookeeper

SpringBoot（9）-Dubbo+Zookeeper

目录 一、了解分布式系统 二、RPC 三、Dubbo 四、SpringBootDubboZookeeper 4.1 框架搭建 4.2 实现RPC 一、了解分布式系统 分布式系统&#xff1a;由一组通过网络进行通信&#xff0c;为了完成共同的任务而协调工作的计算机节点组成的系统 二、RPC RPC&#xff1a;远程…
阅读更多...
如果在docker 容器中安装ros遇到的问题

如果在docker 容器中安装ros遇到的问题

1.在容器内部无法修改时间&#xff0c;需要在宿主机外边修改时钟。修改时钟&#xff1a; hwclock --systohc或者执行 date -s "2024-11-24 19:25:10"2.容器内部内置有opencv4.5版本&#xff0c;需要卸载&#xff0c;重新安装4.2.0版本。记录折腾好久的卸载过程。 …
阅读更多...
websocket是什么？

websocket是什么？

一、定义 Websocket是一种在单个TCP连接上进行全双工通信的协议&#xff0c;它允许服务器主动向客户端推送数据&#xff0c;而不需要客户端不断的轮询服务器来获取数据 与http协议不同&#xff0c;http是一种无状态的&#xff0c;请求&#xff0c;响应模式的协议(单向通信)&a…
阅读更多...
CSS回顾-CSS样式优先级规则详解

CSS回顾-CSS样式优先级规则详解

一、引言 在之前梳理 CSS 选择器的文章&#xff08;CSS 回顾 - CSS 选择器详解&#xff09;中&#xff0c;我们对 CSS 选择器有了全面的认识。此刻&#xff0c;不妨思考这样一个问题&#xff1a;倘若众多不同类型的选择器均针对 h1 标签设定样式&#xff0c;究竟会呈现何种结果…
阅读更多...
蓝网科技临床浏览系统存在SQL注入漏洞

蓝网科技临床浏览系统存在SQL注入漏洞

漏洞描述 蓝网科技临床浏览系统是一个专门用于医疗行业的软件系统&#xff0c;主要用于医生、护士和其他医疗专业人员在临床工作中进行信息浏览、查询和管理。在deleteStudy.php中的接口处存在SQL注入漏洞&#xff0c;未经身份验证的恶意攻击者利用 SQL 注入漏洞获取数据库中的…
阅读更多...
Jtti：如何知晓服务器的压力上限?具体的步骤和方法

Jtti：如何知晓服务器的压力上限?具体的步骤和方法

了解服务器的压力上限(也称为性能极限或容量)是确保系统在高负载下仍能稳定运行的重要步骤。这通常通过压力测试(也称为负载测试或性能测试)来实现。以下是详细的步骤和方法来确定服务器的压力上限&#xff1a; 1. 定义测试目标和指标 在进行压力测试前&#xff0c;明确测试目标…
阅读更多...
【Mybatis】@Param注解 resultMap手动映射

【Mybatis】@Param注解 resultMap手动映射

文章目录 一、映射文件参数二、查询映射2-1 一对一2-2 一对多2-3 总结 一、映射文件参数 Param 注解官方文档解释 1、单个参数&#xff08;对象&#xff09;不使用注解 public int save(User user);<!-- 添加用户 --> <insert id"save" parameterType&quo…
阅读更多...
tcp/ip异常断开调试笔记——lwip

tcp/ip异常断开调试笔记——lwip

问题一&#xff1a;异常掉线 异常断开模拟 1、单片机端做服务端&#xff08;只监听一个客户端&#xff09;&#xff0c;电脑做客户端连接 2、尝试连接确定通信正常&#xff0c;断开网线。电脑客户端点击断开 3、经过一段时间&#xff08;超过tcp/ip 3次握手时间&#xff09…
阅读更多...
最新文章

Copyright @ 2022~2023