• 史上最全 结构型模式之 桥接 外观 组合 享元模式

    史上最全 结构型模式之 代理 适配器 装饰者 模式-CSDN博客

    5.4 桥接模式

    5.4.1 概述

    现在有一个需求，需要创建不同的图形，并且每个图形都有可能会有不同的颜色。我们可以利用继承的方式来设计类的关系：

    我们可以发现有很多的类，假如我们再增加一个形状或再增加一种颜色，就需要创建更多的类。

    试想，在一个有多种可能会变化的维度 系统中，用继承方式会造成类爆炸，扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类。为了更加灵活的设计系统，我们此时可以考虑使用桥接模式。

    定义：

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

    5.4.2 结构

    桥接（Bridge）模式包含以下主要角色：

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

    5.4.3 案例

    【例】视频播放器

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

    类图如下：

    代码如下：

    1. //视频文件
    2. public interface VideoFile {
    3.     void decode(String fileName);
    4. }
    5.  
    6. //avi文件
    7. public class AVIFile implements VideoFile {
    8.     public void decode(String fileName) {
    9.         System.out.println("avi视频文件："+ fileName);
    10.     }
    11. }
    12.  
    13. //rmvb文件
    14. public class REVBBFile implements VideoFile {
    15.  
    16.     public void decode(String fileName) {
    17.         System.out.println("rmvb文件：" + fileName);
    18.     }
    19. }
    20.  
    21. //操作系统版本
    22. public abstract class OperatingSystemVersion {
    23.  
    24.     protected VideoFile videoFile;
    25.  
    26.     public OperatingSystemVersion(VideoFile videoFile) {
    27.         this.videoFile = videoFile;
    28.     }
    29.  
    30.     public abstract void play(String fileName);
    31. }
    32.  
    33. //Windows版本
    34. public class Windows extends OperatingSystem {
    35.  
    36.     public Windows(VideoFile videoFile) {
    37.         super(videoFile);
    38.     }
    39.  
    40.     public void play(String fileName) {
    41.         videoFile.decode(fileName);
    42.     }
    43. }
    44.  
    45. //mac版本
    46. public class Mac extends OperatingSystemVersion {
    47.  
    48.     public Mac(VideoFile videoFile) {
    49.         super(videoFile);
    50.     }
    51.  
    52.     public void play(String fileName) {
    53. 		videoFile.decode(fileName);
    54.     }
    55. }
    56.  
    57. //测试类
    58. public class Client {
    59.     public static void main(String[] args) {
    60.         OperatingSystem os = new Windows(new AVIFile());
    61.         os.play("战狼3");
    62.     }
    63. }

    好处：

    • 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。

    如：如果现在还有一种视频文件类型wmv，我们只需要再定义一个类实现VideoFile接口即可，其他类不需要发生变化。

    • 实现细节对客户透明

    坏处：

    适配器模式容易类爆炸 , 每个维度都要创建多个类

    5.4.4 使用场景

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

    装饰是小的包裹大的，桥接是大的包裹小的

    5.5 外观模式

    5.5.1 概述

    有些人可能炒过股票，但其实大部分人都不太懂，这种没有足够了解证券知识的情况下做股票是很容易亏钱的，刚开始炒股肯定都会想，如果有个懂行的帮帮手就好，其实基金就是个好帮手，支付宝里就有许多的基金，它将投资者分散的资金集中起来，交由专业的经理人进行管理，投资于股票、债券、外汇等领域，而基金投资的收益归持有者所有，管理机构收取一定比例的托管管理费用。

    定义：

    又名门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口（基金），外部应用程序不用关心内部子系统的具体的细节（投资哪些），这样会大大降低应用程序的复杂度，提高了程序的可维护性。

    外观（Facade）模式是“迪米特法则”的典型应用

    5.5.2 结构

    外观（Facade）模式包含以下主要角色：

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

    5.5.3 案例

    【例】智能家电控制

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

    代码如下：

    1. //灯类
    2. public class Light {
    3.     public void on() {
    4.         System.out.println("打开了灯....");
    5.     }
    6.  
    7.     public void off() {
    8.         System.out.println("关闭了灯....");
    9.     }
    10. }
    11.  
    12. //电视类
    13. public class TV {
    14.     public void on() {
    15.         System.out.println("打开了电视....");
    16.     }
    17.  
    18.     public void off() {
    19.         System.out.println("关闭了电视....");
    20.     }
    21. }
    22.  
    23. //控制类
    24. public class AirCondition {
    25.     public void on() {
    26.         System.out.println("打开了空调....");
    27.     }
    28.  
    29.     public void off() {
    30.         System.out.println("关闭了空调....");
    31.     }
    32. }
    33.  
    34. //智能音箱 外观类 和用户交互
    35. public class SmartAppliancesFacade {
    36.     //聚合三个电器
    37.     private Light light;
    38.     private TV tv;
    39.     private AirCondition airCondition;
    40.  
    41.     public SmartAppliancesFacade() {
    42.         light = new Light();
    43.         tv = new TV();
    44.         airCondition = new AirCondition();
    45.     }
    46.  
    47.     public void say(String message) {
    48.         if(message.contains("打开")) {
    49.             on();
    50.         } else if(message.contains("关闭")) {
    51.             off();
    52.         } else {
    53.             System.out.println("我还听不懂你说的！！！");
    54.         }
    55.     }
    56.  
    57.     //起床后一键开电器
    58.     private void on() {
    59.         System.out.println("起床了");
    60.         light.on();
    61.         tv.on();
    62.         airCondition.on();
    63.     }
    64.  
    65.     //睡觉一键关电器
    66.     private void off() {
    67.         System.out.println("睡觉了");
    68.         light.off();
    69.         tv.off();
    70.         airCondition.off();
    71.     }
    72. }
    73.  
    74. //测试类
    75. public class Client {
    76.     public static void main(String[] args) {
    77.         //创建外观对象
    78.         SmartAppliancesFacade facade = new SmartAppliancesFacade();
    79.         //客户端直接与外观对象进行交互
    80.         facade.say("打开家电");
    81.         facade.say("关闭家电");
    82.     }
    83. }

    好处：

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

    缺点：

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

    5.5.4 使用场景

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

    5.5.5 源码解析（tomcat）

    使用tomcat作为web容器时，接收浏览器发送过来的请求，tomcat会将请求信息封装成Servlet Request对象，如下图①处对象。

    但是大家想想ServletRequest是一个接口，它还有一个子接口HttpServletRequest，而我们知道该request对象肯定是一个HttpServletRequest对象和ServletRequest共同的子实现类对象，到底是哪个类的对象呢？可以通过输出request对象，我们就会发现是一个名为RequestFacade的类的对象。

    RequestFacade类就使用了外观模式。先看结构图：

    为什么在此处使用外观模式呢？

    定义 RequestFacade 类，分别实现 ServletRequest ，同时定义私有成员变量 Request ，并且方法的实现调用 Request 的实现。然后，将 RequestFacade上转为 ServletRequest 传给 servlet 的 service 方法，这样即使在 servlet 中被下转为 RequestFacade ，也不能访问私有成员变量对象中的方法。既用了 Request ，又能防止其中方法被不合理的访问。

    5.6 组合模式 day04

    5.6.1 概述

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

    定义：

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

    5.6.2 结构

    组合模式主要包含三种角色：

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

    5.6.3 案例实现

    【例】软件菜单

    如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单。

    一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，我们的需求是针对一个菜单，打印出其包含的所有菜单以及菜单项的名称。

    要实现该案例，我们先画出类图：

    代码实现：

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

    1. //菜单组件  不管是菜单还是菜单项，都应该继承该类
    2. public abstract class MenuComponent {
    3.  
    4.     protected String name;
    5.     protected int level;
    6.  
    7.     //添加菜单
    8.     public void add(MenuComponent menuComponent){
    9.         throw new UnsupportedOperationException();
    10.     }
    11.  
    12.     //移除菜单
    13.     public void remove(MenuComponent menuComponent){
    14.         throw new UnsupportedOperationException();
    15.     }
    16.  
    17.     //获取指定的子菜单
    18.     public MenuComponent getChild(int i){
    19.         throw new UnsupportedOperationException();
    20.     }
    21.  
    22.     //获取菜单名称
    23.     public String getName(){
    24.         return name;
    25.     }
    26.  
    27.     public void print(){
    28.         throw new UnsupportedOperationException();
    29.     }
    30. }

    这里的MenuComponent定义为抽象类，因为有一些共有的属性和行为要在该类中实现，Menu和MenuItem类就可以只覆盖自己感兴趣的方法，而不用搭理不需要或者不感兴趣的方法，举例来说，Menu类可以包含子菜单，因此需要覆盖add()、remove()、getChild()方法，但是MenuItem就不应该有这些方法。这里给出的默认实现是抛出异常，你也可以根据自己的需要改写默认实现。

    1. public class Menu extends MenuComponent {
    2.     //菜单可以有 多个子菜单 或者 子菜单项
    3.     private List menuComponentList;
    4.  
    5.     public Menu(String name,int level){
    6.         this.level = level;
    7.         this.name = name;
    8.         menuComponentList = new ArrayList();
    9.     }
    10.  
    11.     @Override
    12.     public void add(MenuComponent menuComponent) {
    13.         menuComponentList.add(menuComponent);
    14.     }
    15.  
    16.     @Override
    17.     public void remove(MenuComponent menuComponent) {
    18.         menuComponentList.remove(menuComponent);
    19.     }
    20.  
    21.     @Override
    22.     public MenuComponent getChild(int i) {
    23.         return menuComponentList.get(i);
    24.     }
    25.  
    26.     @Override
    27.     public void print() {
    28.  
    29.         for (int i = 1; i < level; i++) {
    30.             System.out.print("--");
    31.         }
    32.         System.out.println(name);
    33.         for (MenuComponent menuComponent : menuComponentList) {
    34.             menuComponent.print();
    35.         }
    36.     }
    37. }

    Menu类已经实现了除了getName方法的其他所有方法，因为Menu类具有添加菜单，移除菜单和获取子菜单的功能。

    1. public class MenuItem extends MenuComponent {
    2.  
    3.     public MenuItem(String name,int level) {
    4.         this.name = name;
    5.         this.level = level;
    6.     }
    7.  
    8.     @Override
    9.     public void print() {
    10.         for (int i = 1; i < level; i++) {
    11.             System.out.print("--");
    12.         }
    13.         System.out.println(name);
    14.     }
    15. }

    MenuItem是菜单项，不能再有子菜单，所以添加菜单，移除菜单和获取子菜单的功能并不能实现。

    5.6.4 组合模式的分类

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

    • 透明组合模式

    透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法，比如在示例中 MenuComponent 声明了 add、remove 、getChild 方法，这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。

    透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供 add()、remove() 等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错（如果没有提供相应的错误处理代码）

    • 安全组合模式

    在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点 Menu 类中声明并实现这些方法。

    安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。

    5.6.5 优点

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

    5.6.6 使用场景

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

    5.7 享元模式（无）

    5.7.1 概述

    定义：

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

    5.7.2 结构

    享元（Flyweight ）模式中存在以下两种状态：

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

    享元模式的主要有以下角色：

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

    5.7.3 案例实现

    【例】俄罗斯方块

    下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。

    先来看类图：

    代码如下：

    俄罗斯方块有不同的形状，我们可以对这些形状向上抽取出AbstractBox，用来定义共性的属性和行为。

    1. public abstract class AbstractBox {
    2.     public abstract String getShape();
    3.  
    4.     public void display(String color) {
    5.         System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
    6.     }
    7. }

    接下来就是定义不同的形状了，IBox类、LBox类、OBox类等。

    1. public class IBox extends AbstractBox {
    2.  
    3.     @Override
    4.     public String getShape() {
    5.         return "I";
    6.     }
    7. }
    8.  
    9. public class LBox extends AbstractBox {
    10.  
    11.     @Override
    12.     public String getShape() {
    13.         return "L";
    14.     }
    15. }
    16.  
    17. public class OBox extends AbstractBox {
    18.  
    19.     @Override
    20.     public String getShape() {
    21.         return "O";
    22.     }
    23. }

    提供了一个工厂类（BoxFactory），用来管理享元对象（也就是AbstractBox子类对象），该工厂类对象只需要一个，所以可以使用单例模式。并给工厂类提供一个获取形状的方法。

    1. public class BoxFactory {
    2.  
    3.     private static HashMap map;
    4.  
    5.     private BoxFactory() {
    6.         map = new HashMap();
    7.         AbstractBox iBox = new IBox();
    8.         AbstractBox lBox = new LBox();
    9.         AbstractBox oBox = new OBox();
    10.         map.put("I", iBox);
    11.         map.put("L", lBox);
    12.         map.put("O", oBox);
    13.     }
    14.  
    15.     public static final BoxFactory getInstance() {
    16.         return SingletonHolder.INSTANCE;
    17.     }
    18.  
    19.     private static class SingletonHolder {
    20.         private static final BoxFactory INSTANCE = new BoxFactory();
    21.     }
    22.  
    23.     public AbstractBox getBox(String key) {
    24.         return map.get(key);
    25.     }
    26. }

    5.7.5 优缺点和使用场景

    1，优点

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

    2，缺点：

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

    3，使用场景：

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

    5.7.6 JDK源码解析

    Integer类使用了享元模式。我们先看下面的例子：

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Integer i1 = 127;
    4.         Integer i2 = 127;
    5.  
    6.         System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));
    7.  
    8.         Integer i3 = 128;
    9.         Integer i4 = 128;
    10.  
    11.         System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));
    12.     }
    13. }

    运行上面代码，结果如下：

    为什么第一个输出语句输出的是true，第二个输出语句输出的是false？通过反编译软件进行反编译，代码如下：

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Integer i1 = Integer.valueOf((int)127);
    4.         Integer i2 Integer.valueOf((int)127);
    5.         System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
    6.         Integer i3 = Integer.valueOf((int)128);
    7.         Integer i4 = Integer.valueOf((int)128);
    8.         System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
    9.     }
    10. }

    上面代码可以看到，直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 valueOf() ，所以只需要看该方法即可

    1. public final class Integer extends Number implements Comparable<Integer> {
    2.     
    3. 	public static Integer valueOf(int i) {
    4.         if (i >= IntegerCache.low && i <= IntegerCache.high)
    5.             return IntegerCache.cache[i + (-IntegerCache.low)];
    6.         return new Integer(i);
    7.     }
    8.     
    9.     private static class IntegerCache {
    10.         static final int low = -128;
    11.         static final int high;
    12.         static final Integer cache[];
    13.  
    14.         static {
    15.             int h = 127;
    16.             String integerCacheHighPropValue =
    17.                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    18.             if (integerCacheHighPropValue != null) {
    19.                 try {
    20.                     int i = parseInt(integerCacheHighPropValue);
    21.                     i = Math.max(i, 127);
    22.                     // Maximum array size is Integer.MAX_VALUE
    23.                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
    24.                 } catch( NumberFormatException nfe) {
    25.                 }
    26.             }
    27.             high = h;
    28.             cache = new Integer[(high - low) + 1];
    29.             int j = low;
    30.             for(int k = 0; k < cache.length; k++)
    31.                 cache[k] = new Integer(j++);
    32.             // range [-128, 127] must be interned (JLS7 5.1.7)
    33.             assert IntegerCache.high >= 127;
    34.         }
    35.  
    36.         private IntegerCache() {}
    37.     }
    38. }

    可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。

    非常感谢您阅读到这里，创作不易！如果这篇文章对您有帮助，希望能留下您的点赞👍 关注💖 收藏 💕评论💬感谢支持！！！

    听说 三连能够给人 带来好运！更有可能年入百w，进入大厂，上岸

  • 相关阅读:
    Linux——命令（基本操作命令）（day14）
    解决 Can‘t connect to MySQL server on ‘x‘ (10048) 问题
    CSS基础入门02
    Rust编程基础之引用与借用
    ROS机械臂 Movelt 学习笔记2 | Move Group 接口 C++
    ROS实验笔记之——FAST-LIVO
    elasticsearch集群
    阿里云服务器不能访问网络之安装mysql 提示连接超时
    Flink K8s Operator 如何提交flink SQL
    C++ Reference: Standard C++ Library reference: C Library: cfenv: fegetround
  • 原文地址：https://blog.csdn.net/m0_67184231/article/details/133767239