[C++ 学习] 内聚 和 耦合 的几种样式

于 2023-12-05 23:20:32 发布
阅读量874 收藏 25
点赞数 23
文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52082041/article/details/134818396
版权

作者：HuangYuXuan
内容：内聚 和 耦合 的样式和示例
时间：2023/12/5

文章目录

耦合的样式和示例

"耦合"是软件工程中描述两个模块之间关系的术语，它表示模块间的相互依赖程度。不同的耦合程度可以影响系统的可维护性、可扩展性和可重用性。以下是一些常见的耦合模式及其示例：

  1. 非直接耦合（No Coupling）

    • 描述： 模块之间没有直接的依赖关系，彼此独立。

    • 示例： 两个完全独立的库，彼此无关。

    • 代码示例：

      #include <iostream>
#include <string>

//中介者模式 实现非直接耦合
class Colleague;

class Mediator {
public:
    virtual void sendMessage(const std::string& message, Colleague* colleague) const = 0;
};

class ConcreteMediator : public Mediator {
public:
    void setColleague1(Colleague* colleague) {
        colleague1 = colleague;
    }

    void setColleague2(Colleague* colleague) {
        colleague2 = colleague;
    }

    void sendMessage(const std::string& message, Colleague* colleague) const override {
        if (colleague == colleague1) {
            colleague2->receiveMessage(message);
        } else if (colleague == colleague2) {
            colleague1->receiveMessage(message);
        }
    }

private:
    Colleague* colleague1;
    Colleague* colleague2;
};

class Colleague {
public:
    Colleague(Mediator* mediator, const std::string& name)
        : mediator(mediator), name(name) {
    }

    virtual void sendMessage(const std::string& message) const {
        mediator->sendMessage(message, this);
    }

    virtual void receiveMessage(const std::string& message) const = 0;

protected:
    Mediator* mediator;
    std::string name;
};

class ConcreteColleague : public Colleague {
public:
    ConcreteColleague(Mediator* mediator, const std::string& name)
        : Colleague(mediator, name) {
    }

    void receiveMessage(const std::string& message) const override {
        std::cout << "Colleague " << name << " received message: " << message << std::endl;
    }
};

int main() {
    ConcreteMediator mediator;

    ConcreteColleague colleague1(&mediator, "Colleague1");
    ConcreteColleague colleague2(&mediator, "Colleague2");

    mediator.setColleague1(&colleague1);
    mediator.setColleague2(&colleague2);

    colleague1.sendMessage("Hello, colleagues!");

    return 0;
}

  2. 数据耦合（Data Coupling）

    • 描述： 模块之间通过参数传递简单的数据结构进行通信。

    • 示例： 一个函数接受参数，并使用这些参数进行计算，没有直接调用其他函数或模块。

    • 代码示例：

      #include <iostream>
#include <string>

// 模块A
class ModuleA {
public:

    void performOperation(ModuleB& moduleB, const std::string& data) {
        std::cout << "ModuleA is performing an operation with data: " << data << std::endl;
        moduleB.receiveData(data);
    }
};

// 模块B
class ModuleB {
public:

    void receiveData(const std::string& data) {
        std::cout << "ModuleB received data: " << data << std::endl;
    }
};

int main() {

    ModuleA moduleA;
    ModuleB moduleB;

    // 模块A执行操作，并通过参数传递数据给模块B
    moduleA.performOperation(moduleB, "Hello, ModuleB!");

    return 0;
}

  3. 标记耦合（Stamp Coupling）

    • 描述： 模块之间通过传递复杂的数据结构，其中只有一部分被使用。

    • 示例： 一个函数接受一个结构体，但只使用其中的一部分数据。

    • 代码示例：

      #include <iostream>
#include <string>


struct DataStructure {
    int tag; 
    std::string data;  

   
    DataStructure(int t, const std::string& d) : tag(t), data(d) {}
};

// 模块A
class ModuleA {
public:
    
    void performOperation(ModuleB& moduleB, const DataStructure& dataStructure) {
        std::cout << "ModuleA is performing an operation with data: " << dataStructure.data << std::endl;
        moduleB.receiveData(dataStructure);
    }
};

// 模块B
class ModuleB {
public:
    
    void receiveData(const DataStructure& dataStructure) {
        std::cout << "ModuleB received data with tag: " << dataStructure.tag << std::endl;
    }
};

int main() {
    // 创建模块A和模块B的实例
    ModuleA moduleA;
    ModuleB moduleB;

   
    DataStructure dataStructure(42, "Hello, ModuleB!");
    moduleA.performOperation(moduleB, dataStructure);

    return 0;
}

  4. 控制耦合（Control Coupling）

    • 描述： 模块之间通过传递控制信息（如标志位）进行通信。

    • 示例： 一个函数接受一个布尔值，根据该值的真假执行不同的操作。

    • 代码示例：

      #include <iostream>

// 模块A
class ModuleA {
public:
   
    void performOperation(ModuleB& moduleB, bool controlFlag) {
        std::cout << "ModuleA is performing an operation with control flag: " << controlFlag << std::endl;
        moduleB.receiveControlFlag(controlFlag);
    }
};

// 模块B
class ModuleB {
public:
    
    void receiveControlFlag(bool controlFlag) {
        if (controlFlag) {
            std::cout << "ModuleB received control flag: true - Performing specific action." << std::endl;
        } else {
            std::cout << "ModuleB received control flag: false - Performing default action." << std::endl;
        }
    }
};

int main() {
    // 创建模块A和模块B的实例
    ModuleA moduleA;
    ModuleB moduleB;

    moduleA.performOperation(moduleB, true);
    moduleA.performOperation(moduleB, false);

    return 0;
}

  5. 外部耦合（External Coupling）

    • 描述： 两个模块之间通过共享的全局数据进行通信。

    • 示例： 多个模块共享一个全局变量，通过该变量进行数据传递。

    • 代码示例：

      #include <iostream>
#include <string>

// 共享的全局数据
class SharedData {
public:
    static std::string sharedMessage;

    static void setSharedMessage(const std::string& message) {
        sharedMessage = message;
    }

    static std::string getSharedMessage() {
        return sharedMessage;
    }
};

// 模块A
class ModuleA {
public:
   
    void performOperation() {
        std::cout << "ModuleA is performing an operation with shared data: " << SharedData::getSharedMessage() << std::endl;
    }
};

// 模块B
class ModuleB {
public:
   
    void performOperation() {
        std::cout << "ModuleB is performing an operation with shared data: " << SharedData::getSharedMessage() << std::endl;
    }
};


std::string SharedData::sharedMessage = "";

int main() {
    // 创建模块A和模块B的实例
    ModuleA moduleA;
    ModuleB moduleB;

    SharedData::setSharedMessage("Hello, Modules!");

    moduleA.performOperation();
    moduleB.performOperation();

    return 0;
}

  6. 内容耦合（Content Coupling）

    • 描述： 一个模块直接访问另一个模块的内部实现。

    • 示例： 一个模块直接访问另一个模块的私有成员变量或函数。

    • 代码示例：

      #include <iostream>
#include <string>

// 模块A
class ModuleA {
public:
   
    void performOperation() {
        ModuleB moduleB;
        std::cout << "ModuleA is performing an operation using ModuleB's internal implementation." << std::endl;
        moduleB.internalImplementation();
    }
};

// 模块B
class ModuleB {
public:
  
    void internalImplementation() {
        std::cout << "ModuleB's internal implementation." << std::endl;
    }
};

int main() {
    // 创建模块A的实例
    ModuleA moduleA;

    moduleA.performOperation();

    return 0;
}

在设计软件时，通常会尽量减少耦合，特别是高度耦合，以提高系统的灵活性、可维护性和可扩展性。使用合适的设计模式和良好的软件架构可以帮助降低耦合度。

内聚的样式和示例

"内聚"是软件工程中描述模块内部组织和结构的术语，它表示模块内部各个元素之间相互关联的紧密程度。高内聚性意味着模块内部的元素紧密相关，执行相似的任务，而低内聚性则表示模块内部的元素关联性较弱。以下是一些常见的内聚类型及其示例：

  1. 功能内聚（Functional Cohesion）

    • 描述： 模块内的元素执行相似的功能，完成一个具体的任务。

    • 示例： 一个计算平均值的模块，其中包含计算总和、计数和平均值的功能。

    • 代码示例：

      #include <iostream>
#include <vector>


class DataProcessor {
public:
    DataProcessor() {}

    // 计算总和的功能
    int calculateSum(const std::vector<int>& data) const {
        int sum = 0;
        for (int value : data) {
            sum += value;
        }
        return sum;
    }

    // 计算平均值的功能
    double calculateAverage(const std::vector<int>& data) const {
        if (data.empty()) {
            return 0.0;
        }

        int sum = calculateSum(data);
        return static_cast<double>(sum) / data.size();
    }

    void processData(const std::vector<int>& data) const {
        int sum = calculateSum(data);
        double average = calculateAverage(data);

        std::cout << "Sum: " << sum << std::endl;
        std::cout << "Average: " << average << std::endl;
    }
};

int main() {
    DataProcessor dataProcessor;

    std::vector<int> data = {1, 2, 3, 4, 5};

    dataProcessor.processData(data);

    return 0;
}

  2. 顺序内聚（Procedural Cohesion）

    • 描述： 模块内的元素按照一定的顺序执行，但不一定要求输出作为下一个元素的输入。

    • 示例： 一个数据处理模块，其中包含数据采集、数据清理、数据分析等步骤。

    • 代码示例：

      #include <iostream>
#include <vector>

class DataProcessor {
public:
    void processData(const std::vector<int>& data) const {
        int sum = calculateSum(data);
        
        displayResults(sum);
    }

private:
    // 计算总和的功能
    int calculateSum(const std::vector<int>& data) const {
        int sum = 0;
        for (int value : data) {
            sum += value;
        }
        return sum;
    }

    // 显示结果的功能
    void displayResults(int sum,) const {
        std::cout << "Sum: " << sum << std::endl;
    }
};

int main() {

    std::vector<int> data = {1, 2, 3, 4, 5};

    DataProcessor dataProcessor;

    dataProcessor.processData(data);

    return 0;
}

  3. 通信内聚（Communicational Cohesion）

    • 描述： 模块内的元素共享相同的数据，彼此之间通过数据进行通信。

    • 示例： 一个模块，包含对共享数据结构进行读写的函数。

    • 代码示例：

      #include <iostream>
#include <vector>

struct SharedData {
    std::vector<int> data;
    int flag;

    SharedData(const std::vector<int>& d, int f) : data(d), flag(f) {}
};

class DataProcessor {
public:
    DataProcessor(const SharedData& sharedData) : sharedData(sharedData) {}

    void processData() const {
        int sum = calculateSum();
        double average = calculateAverage();

        std::cout << "Sum: " << sum << std::endl;
        std::cout << "Average: " << average << std::endl;
    }

private:
    // 计算总和的功能
    int calculateSum() const {
        int sum = 0;
        for (int value : sharedData.data) {
            sum += value;
        }
        return sum;
    }

    // 计算平均值的功能
    double calculateAverage() const {
        if (sharedData.data.empty()) {
            return 0.0;
        }

        int sum = calculateSum();
        return static_cast<double>(sum) / sharedData.data.size();
    }

    const SharedData& sharedData;
};

int main() {

    std::vector<int> data = {1, 2, 3, 4, 5};
    int flag = 42;

    SharedData sharedData(data, flag);

    DataProcessor dataProcessor(sharedData);

    dataProcessor.processData();

    return 0;
}

  4. 过程内聚（Procedural Cohesion）

    • 描述： 如果一个模块内的处理元素是相关的，而且必须以特定的次序执行。

    • 示例： 一个图形处理模块，其中包含不同的函数用于绘制图形、填充颜色等，它们可以以任意顺序调用。

    • 代码示例：

      #include <iostream>
#include <string>

void validateOrder(int orderId) {

    std::cout << "Validating order: " << orderId << std::endl;
}

double calculateTotalPrice(int quantity, double pricePerUnit) {

    return quantity * pricePerUnit;
}

void updateInventory(int productId, int quantity) {

    std::cout << "Updating inventory for product " << productId << " with quantity " << quantity << std::endl;
}

void processOrder(int orderId, int productId, int quantity, double pricePerUnit) {

    validateOrder(orderId);

    double totalPrice = calculateTotalPrice(quantity, pricePerUnit);
    std::cout << "Total Price: " << totalPrice << std::endl;

    updateInventory(productId, quantity);
    
    std::cout << "Order processed successfully!" << std::endl;
}

int main() {

    processOrder(1, 1001, 5, 25.99);

    return 0;
}

  5. 时间内聚（Temporal Cohesion）

    • 描述： 模块内的元素在同一时间段内执行，完成一个相关的任务。

    • 示例： 一个初始化模块，包含系统启动时需要执行的一系列初始化操作。

    • 代码示例：

      #include <iostream>
#include <vector>
#include <string>

//数据A
class Data_A{
public:
	Data_A(int number,std::string str,std::vector<int> Array)
		:_number(number),
		 _str(str),
		 _Array(Array)
	{}
	Data_A(const Data_A&&) = default;
	Data_A& operator=(const Data_A&&) = default;
private:
	int _number;
	std::string _str;
	std::vector<int> _Array;	
};

//数据B
class Data_B{
public:
	Data_B(int number,std::string str)
		:_number(number),
		 _str(str),
	{}
	Data_B(const Data_B&&) = default;
	Data_B& operator=(const Data_B&&) = default;
private:
	int _number;
	std::string _str;	
};

static Data_A memory_A
static Data_A memory_B

void Data_init(Data_A temp_memory_A,Data_B temp_memory_b){
		memory_A = std::move(temp_memory_A);
		memory_B = std::move(temp_memory_B);
	
	//... to Do
}

int main(){

	Data_init({10,"Hello",{1,2}},{12,"world"});
}

  6. 逻辑内聚（Logical Cohesion）

    • 描述： 模块内的元素执行相似的逻辑操作，但没有具体的功能关联。

    • 示例： 一个包含一组杂乱功能的工具类，它们通过共享某种上下文或领域而放在同一个模块中。

    • 代码示例：

      #include <iostream>

void validateOrder(int orderId) {

    std::cout << "Validating order: " << orderId << std::endl;
}

double calculateTotalPrice(int quantity, double pricePerUnit) {

    return quantity * pricePerUnit;
}

void updateInventory(int productId, int quantity) {

    std::cout << "Updating inventory for product " << productId << " with quantity " << quantity << std::endl;
}

void printOrderInfo(int orderId, int productId, int quantity, double pricePerUnit) {

    std::cout << "Order Info - Order ID: " << orderId << ", Product ID: " << productId
              << ", Quantity: " << quantity << ", Price per Unit: " << pricePerUnit << std::endl;
}

void processOrder(int orderId, int productId, int quantity, double pricePerUnit) {

    validateOrder(orderId);

    double totalPrice = calculateTotalPrice(quantity, pricePerUnit);
    std::cout << "Total Price: " << totalPrice << std::endl;

    updateInventory(productId, quantity);

    printOrderInfo(orderId, productId, quantity, pricePerUnit);

    std::cout << "Order processed successfully!" << std::endl;
}

int main() {

    processOrder(1, 1001, 5, 25.99);

    return 0;
}

  7. 偶然内聚（Coincidental Cohesion）

    • 描述： 模块内的元素没有明显的相关性，它们被放在同一个模块中是偶然的。

    • 示例： 一个包含了无关联的各种杂乱功能的工具类，没有明显的组织结构。

    • 代码示例：

      #include <iostream>

void processData(int data) {

    std::cout << "Processing data: " << data << std::endl;
}

void generateReport() {

    std::cout << "Generating report." << std::endl;
}

void sendNotification(const std::string& message) {

    std::cout << "Sending notification: " << message << std::endl;
}

int main() {

    int data = 42;
    processData(data);

    generateReport();

    std::string notificationMessage = "Important message!";
    sendNotification(notificationMessage);

    return 0;
}

高内聚性有助于提高代码的可维护性、可读性和重用性，因此在软件设计中通常被认为是一个重要的设计原则。

wake a mask
关注
  • 23
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
c++ 之内聚与耦合
xiaozhi
10-19 525
内聚：模块内各元素彼此结合的紧密程度； 耦合：不同模块间的依赖紧密程度。 模块化的组织方式：将整个系统分解为若干模块，模块之间通过接口传递信息，模块划分应尽可能高内聚，低耦合。 ...
通信内聚c语言例子,功能内聚、顺序内聚、数据耦合、控制耦合例子
weixin_31134719的博客
05-21 1975
功能内聚、顺序内聚、数据耦合、控制耦合例子(C语言描述)1.举出功能内聚、顺序内聚、数据耦合、控制耦合各一例(用C语言)。(1)功能内聚/**功能内聚性例子*根据出生年份得出年龄*/#include#includevoidGetAge(){intBirthYear=0;intAge=0;printf("%s","请输入出生年份：");scanf("%d",&BirthYear);time_...
耦合性 内聚加实例
weixin_34290631的博客
02-09 2854
基本信息 耦合性(或称"耦合度") 英文 : coupling 耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块之间越独立则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。 形象的说，就是要将代码写的和电脑一样，主类就是电脑的主机箱，当程序需要实现什么功能的时候只需要在其他...
在C语言中数据耦合例子,耦合性 内聚加实例 - osc_yip56055的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_36377344的博客
05-21 991
基本信息耦合性(或称"耦合度")英文 : coupling耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块之间越独立则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。形象的说，就是要将代码写的和电脑一样，主类就是电脑的主机箱，当程序需要实现什么功能的时候只需要在其他的类引入接口，就像电脑上的usb接口。非...
C++解耦合的一种方法
weixin_34242658的博客
09-05 872
以数据为中心，多模块之间使用全局变量来做消息通知，或者状态改变，这样模块之间没有直接的联系。各个模块都是直接使用全局变量而已。全局变量的问题这里不探讨。以我的实例讲解，游戏中的英雄（主角）在地图上自动奔跑到鼠标点击的地方，或者网络信令传过来的坐标位置上。主角的自动移动方法setAutoMovePos这里不细说原来的做法如下代码//Map.cpp文件 //鼠标按下事件 ...
大牛思想(高内聚低耦合).pdf
08-27
大牛思想(高内聚低耦合).pdf
学习C和C++的9点经验总结
09-02
结构化编程强调代码的模块化和功能分解，主张高内聚、低耦合。这不仅是现代软件开发的基本原则，也是编程实践中的最佳实践。通过理解结构化编程，能够帮助我们设计出更容易维护和扩展的代码。在学习C语言的过程中，...
C++学习课件
04-16
C++是一种广泛应用于系统软件、...这套C++学习课件将带你一步步踏入这个精彩的编程世界，让你在短时间内掌握C++的基础知识，为进一步深入学习打下坚实的基础。通过不断的练习和项目实践，你将成为一名熟练的C++程序员。
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
判断几种图片文件头的c++代码
11-02
C++是一种强大的编程语言，能够处理各种文件操作，包括二进制文件的读取。在这个场景下，我们需要关注的是如何通过读取图片文件的头部信息来判断它属于哪种格式，如GIF、BMP或JPEG（JPG）。这些图片格式都有其特定的...
为每种内聚和耦合举例
weixin_42822489的博客
01-12 2585
参考：https://www.cnblogs.com/xiaym896/p/5400677.html 学习中补上些自己的理解。 一、内聚 1、偶然内聚：模块的各成分之间没有关联，只是把分散的功能合并在一起。 //程序1 double d1,d2,d3; if(d1 > d2) d3 = d1; else d3 = d2; //程序2 int i1,i2,i3;...
软件工程-耦合与内聚简单实例
weixin_46694417的博客
12-01 6493
耦合与内聚简单实例
【架构】软件代码的耦合性和内聚性，以几个简单小例子说明
YoYo的桃子树
02-03 6819
1. 起因 这篇文章应该算作前两篇文章的后续思考。 在前两篇文章中，考虑到了分层的方法，参考了别人的代码架构。 工程代码结构(附带几个demo) 嵌入式软件架构设计 模块化 & 分层设计 其实我们说到最后，好的代码，我们分层，做模块，无非就是实现一个高内聚和低耦合。 举个简单的例子，将某个模块代码直接删除之后，将上层调用处注释，重新编译，是否还能编过？（不考虑功能的运行） 如果还能，说...
ansys 内聚力_内聚力 软件工程
cumt951045的博客
07-26 1103
ansys 内聚力 凝聚 (Cohesion) In general terms, the word cohesion means 'the action or act of forming a united whole'. According to the definition of Cambridge University, cohesion is defined as "the state ...
软工之耦合性
我只是心态好
11-20 1139
通俗来讲，耦合就是一种关系，指模块之间的关系。 耦合有很多种分类，一般模块之间是有七种，也就是说模块之间的连接方式大概有七种。 数据耦合是指两个模块之间有调用关系，模块间传递的是简单的数据值。 一、非直接耦合 非直接耦合：弱耦合，两模块之间没有直接关系 在这个图中，B和C就是非直接耦在系统中基本无法做到非直接耦合 二、数据耦合
马上看懂各种内聚类型（逻辑内聚、过程内聚、顺序内聚）
热门推荐
Biu_Destiny的博客
05-18 1万+
各种内聚模式 内聚概念 内聚其实是一个模块内部各成分之间相关联程度的度量。用来表示说，你这个模块里面各个元素之间关系好不好，是不是每天勾肩搭背，还是冷眼相对或者是偶尔打个招呼。 内聚类型 这里用【元素】来统一表达一个模块中各种操作、部分等说法。 内聚模式 概念 举个例子 偶然内聚 各个元素关系比较松散 不认识的几个人，偶然之下几个人被分到一个班了 逻辑内聚 各个元素逻辑上是有关系的，但实际功能来看是没有关系的 哥几个都擅长体育，逻辑上说应该有关系，然而并无 时间内聚 各个元素必须再同
耦合与耦合性区别（二）
u012999868的专栏
06-30 6982
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决与模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分摸块的一个准则就是高内聚低耦合。 耦合性（或称“耦合度”）
内聚和耦合的举例
weixin_34200628的博客
04-17 4454
内聚类型： 1.偶然内聚 模块的各成分之间没有关联，只是把分散的功能合并在一起。 例：A模块中有三条语句（一条赋值，一条求和，一条传参），表面上看不出任何联系，但是B、C模块中都用到了这三条语句，于是将这三条语句合并成了模块A。模块A中就是偶然内聚。 2.逻辑内聚 逻辑上相关的功能被放在同一模块中。 例：A模块实现的是将对应的人员信息发送给技术部，人事部和财政部...
一例看懂C语言程序中的内聚和耦合
迂者-贺利坚的专栏
02-28 1万+
（一）原理篇 　　（清楚相关原理的读者，请直接看第二部分示例篇） 　　在软件工程中，模块的内聚和耦合是度量模块化质量的标准之一。内聚是指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。耦合是程序中各模块之间相互联系紧密程度的一种度量。各模块之间联系越紧密，其耦合性就越强。模块间耦合高低取决于模块间...
C++学习：嵌套类与内层成员访问
"这篇文档是关于C++学习的笔记，主要讨论了如何访问内层类的成员以及C++的一些基础知识，包括C++的起源、特点、行业地位和应用领域。" 在C++编程中，访问内层类的成员是一个重要的概念。内层类，也被称为嵌套类，是...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值