精华内容
下载资源
问答
  • 对象和对象之间通过什么进行通信
    千次阅读
    2013-05-25 19:14:58

    对象之间进行通信最基本的方式就是消息传递,在Cocoa中提供Notification Center机制来完成这一任务。其主要作用就是负责在任意两个对象之间进行通信。使用方法很简单,如下几个步骤即可:

      假设A与B之间进行通信,B来触发事件,A接受该事件,并作出响应。
      1) A编写自定义的消息响应函数update
      2) A向消息中心注册,[NSNotificationCenter defaultCenter] addObserver: self selector:@selector(update) name:@"updateKey" object:nil];
      3) B触发事件,[[NSNotificationCenter defaultCenter] postNotificationName:@"updateKey" object:nil];

      每一个进程都有一个默认的NSNotificationCenter,可以通过类方法defaultCenter获取该消息中心的实例。消息中心可以处理同一进程中不同对象之间的消息。如果要在同一台机器上进行进程间的通信,需要使用NSDistributedNotificationCenter。

      消息中心以同步的方式将消息分发到所有的观察者中,换言之,直到所有的观察者都收到消息并处理完毕以后,控制权才会回到调用者的手里。如果需要异步的处理消息,需要使用通知队列NSNotificationQueue。

      在多线程程序中,通知会被分发到每一个发起消息的线程中,这可能与观察者注册时所在的线程已经不是同一线程。

    1. 消息处理事件postNotificationName和addObserver的调用:
          1)定义消息创建的关联值,也就是找到方法的标识
    1
    2
    3
    NSString *myNotification = @ "myNotification" ;
    myNotification是变量,@“myNotification”这个值存于通知中心中,信息中心通过这个值来识别变量。
          2)调用信息
    1
    2
    3
    4
    NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
    [center postNotificationName:myNotification object:nil userInfo:[NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt:SMSRecommendNotification] , @ "actcode" ,nil]];
    [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt:SMSRecommendNotification],这个是传递给-( void )onToIphone:(NSNotification*)notify 的参数
    更多相关内容
  • C++对象之间通信的三种常见方式

    万次阅读 2017-11-03 18:53:19
    经过这一年多对C++的使用,总结出了下边的三种常见对象之间通信方式。这里就不上代码了。只作为一种设计思想,记录下来方便自已以后使用,大家一起学习,这只是自已在工作中的总结,如果谁有更好的经验,请回复...

    经过这一年多对C++的使用,总结出了下边的三种常见对象之间的通信方式。这里就不上代码了。只作为一种设计思想,记录下来方便自已以后使用,和大家一起学习,这只是自已在工作中的总结,如果谁有更好的经验,请回复我,我再加进去。

    1:使用一个全局单例对象作为交互对象的中介;

    在这种交互方式中,有三个对象参加进来。

    类1:ClassA;             //用来创建交互对象1:obj1

    类2:ClassB;             //用来创建交互对象2:obj2

    类3:ClassC;             //单例类,用来创建单例对象:objS

    如果obj1现在要给obj2发送一条消息,就要先从objS中取得obj2的对象指针地址。然后通过这个地址把消息发送给obj2。当然,用同样的方法,我们也可以让obj2给Obj1发送消息。

    这里使用时要注意的问题有两个。

          1) obj1给obj2发送消息时,objS中存的obj2对象地址不能为空

          2) 当创建obj2时,要马上把obj2的实例地址传送给单例objS,在销毁obj2时,要马上把obj2在单例objS中保存的对象地址清空为NULL

    C++对象之间通信的三种常见方法 - ♂苹果 - 眼睛想旅行

     

    2:为交互的对象创建一个虚接口代理类;

         这种方式,适合自已常常要给第三方发回调消息的对象,比如按钮或者控件什么的。因为自已包含于目标对象,所以比较方便设置代理,也可以使用目标对象对控件对象对外组合封装起来。

         这种交互方式中,有两个对象参加进来,创建类时,需要创建发消息对象的虚代理类。在而目标对象要继承这个虚代理类并实现这个代理类的虚方法。他和第三种方式相比,优点是可以创建多条消息通道。

    类1:ClassA;              //用来创建交互类ClassC,将作为obj1的一个父类

    类2:ClassB;              //用来创建发送消息的对象2:obj2

    虚接口类:ClassX;    //用来实现交互,在obj2中会包含一个ClassX的实例类型变量。以方便保存obj1的对象地址。

    类3: ClassC;               //继承自ClassA和ClassX,用来创建交互对象1:obj1

    C++对象之间通信的三种常见方法 - ♂苹果 - 眼睛想旅行

    3:创建交互对象的基类方法函数指针。

           这种方式和第二种其实是差不多的,只是这种方式,比较适合只有一条回调消息的情况。这里只有两个对象,和一个对象方法函数指针。这里只强调一下,对象函数指针的定义方式。

           类1:ClassA;                               //用来创建交互对象1:obj1

           类2:ClassB;                                //用来创建交互对象2:obj2

    这里说明一下obj1和obj2的方法函数指针都怎么创建:

          假如:

                   ClassA有一个对象方法,void func1(); 我们给这个方法定义一个指针类型如下

                   typedef  void  (ClassA::*FUNC1)();

            在对象obj2中就可以定义这么一个FUNC1类型的对象指针。定在创建obj1中创建obj2时把obj1的这个FUNC1的指针类型赋上obj1的回调方法指针。这样就可以在obj2中使用使用obj1的这个对象方法指针调用obj2的回调方法了。 请看图:

    C++对象之间通信的三种常见方法 - ♂苹果 - 眼睛想旅行

    第一种方法最常用容易理解,第二方法速度快,第一种与三种结合适合批量对象交互,可组成MVC或观察着模式。
    UML图画的并不标准,正在学习中。

    欢迎转载,转载注明出处: http://fengmm521.blog.163.com/blog/static/25091358201421292224959/
    另外我有一个QQ群,欢迎爱技术的来一起学习交流:213571088
    展开全文
  • C++对象之间通信的几种方式

    千次阅读 2020-12-30 17:51:12
    第一种:直接调用(强耦合、循环嵌套) #include <iostream> using namespace std; class CouplingB { public: void HandleMessage(int i) { cout << i << endl;... m_b.Handl

    第一种:直接调用(强耦合、循环嵌套)

    #include <iostream>
    
    using namespace std;
    
    class CouplingB
    {
    public:
        void HandleMessage(int i)
        {
            cout << i << endl;
        }
    };
    
    class CouplingA
    {
    public:
        void SendMessage(int i)
        {
            m_b.HandleMessage(i);
        }
    
    private:
        CouplingB m_b;
    };
    
    int main()
    {
        CouplingA coupleingA;
        coupleingA.SendMessage(100);
    	return 0;
    }
     
    

    第二种:中介者(解耦)

    class DecouplingClassA
    {
    public:
        void SendMessage(int i);
        void HandleMessage(int i)
        {
            cout << "DecouplingClassB::HandleMessage(): " << i << endl;
        }
    };
    
    class DecouplingClassB
    {
    public:
        void SendMessage(int i);
        void HandleMessage(int i)
        {
            cout << "DecouplingClassB::HandleMessage(): " << i << endl;
        }
    };
    
    class Mediation
    {
    private:
        Mediation() {}
    
    public:
        DecouplingClassA GetClassA()
        {
            return m_classA;
        }
    
        DecouplingClassB GetClassB()
        {
            return m_classB;
        }
    public:
        static Mediation* Instance()
        {
            if(nullptr == m_instance)
            {
                m_instance = new Mediation;
            }
            return m_instance;
        }
    
    private:
        DecouplingClassA m_classA;
        DecouplingClassB m_classB;
    
    private:
        static Mediation *m_instance;
    };
    
    Mediation *Mediation::m_instance = nullptr;
    
    void DecouplingClassA::SendMessage(int i)
    {
        cout << "DecouplingClassA::SendMessage -> ";s
    
        DecouplingClassB classB = Mediation::Instance()->GetClassB();
        classB.HandleMessage(i);
    }
    
    void DecouplingClassB::SendMessage(int i)
    {
        cout << "DecouplingClassB::SendMessage -> ";
    
        DecouplingClassA classA = Mediation::Instance()->GetClassA();
        classA.HandleMessage(i);
    }
    
    int main()
    {
        // 去耦合(中介器)
        DecouplingClassA classA = Mediation::Instance()->GetClassA();
        classA.SendMessage(200);
        DecouplingClassB classB = Mediation::Instance()->GetClassB();;
        classB.SendMessage(300);
        
        return 0;
    }
    
    

    第三种:回调接口(常用、可扩展成观察者模式)

    #ifndef CALLBACK_H
    #define CALLBACK_H
    
    #include <iostream>
    using namespace std;
    
    
    class Interface
    {
    public:
        virtual ~Interface() {}
        virtual void Test(int i) = 0;
    };
    
    class Invoker
    {
    public:
        Invoker() {}
    
        Invoker(Interface *interface)
        {
            m_interface = interface;
        }
    
        void SetHandler(Interface *interface)
        {
            m_interface = interface;
        }
    
        void Invoke()
        {
            if(nullptr != m_interface)
                m_interface->Test(500);
        }
    
    private:
        Interface *m_interface;
    };
    
    class Realizer : public Interface
    {
    public:
        Realizer() {}
    
        void Test(int i)
        {
            cout << "Realizer::test(): " << i << endl;
        }
    };
    
    #endif // CALLBACK_H
    
    
    int main()
    {
        // 回调接口
        Realizer *realizer = new Realizer;
        Invoker *invoker = new Invoker(realizer);
        invoker->Invoke();
    
        return 0;
    }
    
    

    第四种:绑定函数指针

    第五种:Qt的信号槽(很强大)

    展开全文
  • android 实例 Activity 之间通过 Handler 通信
  • QT中类对象之间通信尽量少使用信号槽

    千次阅读 多人点赞 2020-03-07 23:37:12
    大家都知道在QT中的信号槽是一种非常重要的方法,这种方法可以使不同的类对象之间进行高效的通信,而且这也是QT区别于其他框架的重要机制之一。这就像MFCWIN32的消息机制一样。 但是我希望大家以后在使用QT时还是...

    大家都知道在QT中的信号槽是一种非常重要的方法,这种方法可以使不同的类对象之间进行高效的通信,而且这也是QT区别于其他框架的重要机制之一。这就像MFC和WIN32的消息机制一样。

    但是我希望大家以后在使用QT时还是尽量少使用信号槽实现是对象之间的通信。除了一些必须的场合,比如按钮的点击事件、列表框的切换事件等。

    为什么这样说呢?

    一、在结构上来说,连接信号槽的地方、发射信号的地方、接受信号的地方往往不在一个地方或者离得很近的地方,有时不在一个模块中,这就给代码的阅读带来的很大的困难。当读到发射信号的地方,需要知道这个信号是发给谁的,同理阅读到槽函数时,也需要知道是哪个类对象发射出的哪个信号。当查看完信号槽连接的地方,弄明白发射和接受对象之后,继续在原来的地方阅读代码,往往会打断之前的思路,还有重新花时间来整理思路。就像线程之间的来回切换一下,每次切换都是需要资源成本的。

    二、信号槽机制有点像C/C++中的goto句。第一次学C语言的时候,老师就说过,不要使用goto语句,会破坏代码的模块化,但是不明白为什么。随着经验的增加,发现模块与模块之间的高内聚和低耦合是多么的重要!而信号槽这种设计又非常的灵活,可以在不通过类、不用的模块之间发射和接受信号,这也就大大的破坏了模块之间的高内聚性。当开发的模块增多,开发的人员增加后,这种问题就会更加的凸显出来。

    那么在QT中如果不使用信号槽在对象之间进行通信,该使用什么方法在不同的类对象之间进行通信呢?

    下面看一个例子,先使用信号槽进行通信。
    介绍:有两个界面:第一个界面和第二个界面,第一个界面有一个Label,第二个界面有一个编辑框。当点击第一个界面的按钮的时候,弹出第二个界面,当在第二个界面的编辑框编辑完成之后,点击按钮,编辑的内容就会在第一个界面的Label上显示出来。
    在这里插入图片描述
    代码如下:
    第一个界面:

    #pragma once
    
    #include <QtWidgets/QMainWindow>
    #include "ui_SignalSlot.h"
    
    class QtGuiSecond;
    
    class SignalSlot : public QMainWindow {
    	Q_OBJECT
    
    public:
    	SignalSlot(QWidget *parent = Q_NULLPTR);
    
    private:
    	void init();
    
    private slots:
    	void slotBtn();
    	void slotEditStr(QString str);
    private:
    	Ui::SignalSlotClass ui;
    
    	QtGuiSecond* _guiSecond = nullptr;
    };
    
    
    #include "SignalSlot.h"
    #include "QtGuiSecond.h"
    
    SignalSlot::SignalSlot(QWidget *parent)
    	: QMainWindow(parent) {
    	ui.setupUi(this);
    	init();
    }
    
    void SignalSlot::init() {
    	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotBtn()));
    
    	_guiSecond = new QtGuiSecond;
    
    	connect(_guiSecond, SIGNAL(sigEditStr(QString)), this, SLOT(slotEditStr(QString)));
    }
    
    void SignalSlot::slotBtn() {
    	_guiSecond->show();
    }
    
    void SignalSlot::slotEditStr(QString str) {
    	ui.label->setText(str);
    }
    
    

    第二个界面:

    #pragma once
    
    #include <QWidget>
    #include "ui_QtGuiSecond.h"
    
    class QtGuiSecond : public QWidget {
    	Q_OBJECT
    
    public:
    	QtGuiSecond(QWidget *parent = Q_NULLPTR);
    	~QtGuiSecond();
    
    private:
    	void init();
    
    private slots:
    	void slotOK();
    signals:
    	void sigEditStr(QString);
    
    private:
    	Ui::QtGuiSecond ui;
    
    
    };
    
    
    #include "QtGuiSecond.h"
    
    QtGuiSecond::QtGuiSecond(QWidget *parent)
    	: QWidget(parent) {
    	ui.setupUi(this);
    	init();
    }
    
    QtGuiSecond::~QtGuiSecond() {
    }
    
    void QtGuiSecond::init() {
    	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotOK()));
    }
    
    void QtGuiSecond::slotOK() {
    	QString str = ui.lineEdit->text();
    	emit sigEditStr(str);
    }
    
    

    可以看到第二个界面编辑的内容是通过信号槽的方式传过去了。

    如果不使用信号槽该怎么传递数据呢?

    这就需要我们添加第三个类,也就是接口类,这个类的目的就是为了传递参数的。

    #pragma once
    #include <QString>
    
    class IEditArg {
    public:
    	IEditArg();
    	~IEditArg();
    
    	virtual void editStr(QString str);
    };
    
    
    #include "IEditArg.h"
    
    IEditArg::IEditArg() {
    }
    
    IEditArg::~IEditArg() {
    }
    
    void IEditArg::editStr(QString str) {
    
    }
    
    

    然后让第一个界面类继承这个类,并且实现里面的虚函数:

    #pragma once
    
    #include <QtWidgets/QMainWindow>
    #include "ui_SignalSlot.h"
    #include "IEditArg.h"
    
    class QtGuiSecond;
    
    class SignalSlot : public QMainWindow, public IEditArg {
    	Q_OBJECT
    
    public:
    	SignalSlot(QWidget *parent = Q_NULLPTR);
    
    	void editStr(QString str)override;
    private:
    	void init();
    
    private slots:
    	void slotBtn();
    private:
    	Ui::SignalSlotClass ui;
    
    	QtGuiSecond* _guiSecond = nullptr;
    };
    
    
    #include "SignalSlot.h"
    #include "QtGuiSecond.h"
    
    SignalSlot::SignalSlot(QWidget *parent)
    	: QMainWindow(parent) {
    	ui.setupUi(this);
    	init();
    }
    
    void SignalSlot::editStr(QString str) {
    	ui.label->setText(str);
    }
    
    void SignalSlot::init() {
    	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotBtn()));
    
    	_guiSecond = new QtGuiSecond;
    
    	_guiSecond->setArgInterface(this);
    }
    
    void SignalSlot::slotBtn() {
    	_guiSecond->show();
    }
    
    

    第二个界面类保存这个接口:

    #pragma once
    
    #include <QWidget>
    #include "ui_QtGuiSecond.h"
    
    class IEditArg;
    
    class QtGuiSecond : public QWidget {
    	Q_OBJECT
    
    public:
    	QtGuiSecond(QWidget *parent = Q_NULLPTR);
    	~QtGuiSecond();
    
    	void setArgInterface(IEditArg* editArg);
    private:
    	void init();
    
    private slots:
    	void slotOK();
    
    private:
    	Ui::QtGuiSecond ui;
    
    	IEditArg* _editArg = nullptr;
    };
    
    
    #include "QtGuiSecond.h"
    #include "IEditArg.h"
    
    QtGuiSecond::QtGuiSecond(QWidget *parent)
    	: QWidget(parent) {
    	ui.setupUi(this);
    	init();
    }
    
    QtGuiSecond::~QtGuiSecond() {
    }
    
    void QtGuiSecond::setArgInterface(IEditArg* editArg) {
    	_editArg = editArg;
    }
    
    void QtGuiSecond::init() {
    	connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(slotOK()));
    }
    
    void QtGuiSecond::slotOK() {
    	QString str = ui.lineEdit->text();
    	if (_editArg!=nullptr){
    		_editArg->editStr(str);
    	}
    }
    
    

    这样就完成了,虽然代码多了一些但是结构更清晰了!同样也是实现相同的功能呢!有利用了C++的特性。

    aaa

    展开全文
  • 对象之间的调用机制 通信方式

    千次阅读 2015-10-18 16:51:26
    1.直接方法调用 2.Target-Action @selector() 3.Delegate 协议 ...1.判断通信对象是一对一的还是一对多的(一般一对一的是1,2,5,一对多是3,4,6)...2.对象之间的耦合度,是强耦合还是松耦合(尽量让所有模块解
  • 闲话少说正题如下:本人在开发过程中曾经碰过一个疑惑:面向对象开发时候在类之间通信如何做?1:如果把所有的需要参数都通过结构指针传过去那么需要调用类的一些功能函数如何处理?2:我就写个全局变量吧,爱什么数据就...
  • 1、结构化分析设计方法集中于将功能作为系统的构造块。 2、在信息建模方法中(实体关系模型)构造块是实体,但在该方法中用来满足系统需求的功能被完全忽略掉了。 两种方法都没有处理对动态行为的捕获,声明性语义...
  • C++对象之间通信

    千次阅读 2010-12-11 21:08:00
    项目,然而对C++类对象之间通信总有种不知所措就好像人吃了饭自然会消化那样只知其然,不知起所以然的感觉。人,活着,好多时候是在寻找真理,其 实说俗点就是在找一个自己能够容易接受的理由来说服自己。...
  • 一个窗口更新localStorage,另一个窗口监听window对象的”storage”事件,来实现通信。 注:两个页面要同源(URL的协议、域名端口相同) 2、cookie+setInterval() page1将要传递的信息存储在cookie中,page2使用...
  • 在iIOS 中 delegate 主要用于视图与使用对象之间通信交互,典型的特点就是它有返回值。 用途:常用于传\赋值(如tableView中的委托(dateSource)中常见)或者传递事件(例如在异步请求中,界面事件触发数据层改变...
  • 专栏 >实现游戏对象与对象之间通信

    千次阅读 2012-08-06 02:21:46
    游戏中,对象与对象之间需要交流,实现的方法多种,例如:可定义静态变量,其他脚本直接调用, 也可用到: SendMessage 今天主要学习SendMessage的用法。   1、创建两个脚本:“Cube0”“Cube1”; 2、将两个...
  • CAN笔记(18) 对象字典

    万次阅读 2019-09-11 10:00:44
    对象字典OD概述、通讯对象子协议区、制造商特定子协议区、标准化设备子协议区
  • 什么是UML? UML(统一建模语言)的出现是为了软件设计有更好的可读性和可理解性。 UML由由构造块、公共机制、规则三个部分 组成。 构造块,犹如建房子时的砖瓦。 规则,是支配基本构造块如何放在一起的规则(5个...
  • 〖Python语法进阶篇⑤〗 - 进程间的通信

    千次阅读 多人点赞 2022-04-10 22:33:56
    今天的章节我们来学习一下进程之间通信通过前面章节的学习我们都知道 `进程在创建之后是没有办法获取返回值的` 。但有的时候两个进程之间需要进行相互之间的配合才能完成工作,这就需要今天所要学习的主题:`...
  • 这里为什么说Lock对象哪?Lock其实是一个接口,在JDK1.5以后开始提供,其实现类常用的有ReentrantLock,这里所说的Lock对象即是只Lock接口的实现类,为了方便记忆或理解,都简称为Lock对象。 我们知道synchronized...
  • 在现实应用中,很多时候都需要让多个线程按照一定的次序来访问共享资源,例如,经典的生产者消费者问题。这类问题描述了这样一种情况,假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库...
  • 串行通信总结(实现两个单片机之间通信

    万次阅读 多人点赞 2017-01-06 11:47:59
    串行通信实现的是两个对象之间的数据传递,对象通常是单片机。通信实际上是在两个单片机上连上线,通过线路来传递信息。 如图,调制解调器非常重要,其作用是实现数字信号模拟信号的转换。但是注意,调制解
  • Java 线程间通信

    千次阅读 2022-04-16 15:16:02
    Java线程间通信
  • UML– 用例图用例图展现的是一组用例、参与者扩展关系、包含关系等。该图的作用是描述系统的行为,即该系统在它的上下文环境中所提供的外部可见服务。注:参与者不一定是人,可以是其它除系统以外的事物。 简述用...
  • Session对象和Application对象都是计算机的存储系统。 1、作用不同 session对象用于存储特定的用户DAO会话所需的信息 。 Session对象的引入是为了弥补HTTP协议的不足,HTTP协议是一种无状态的协议。 application是...
  • 第一章 类和对象的概念及应用

    千人学习 2017-07-23 14:41:49
    本课程主要讲解了C#中关于类的概念以及对象的概念,他们二者之间的关系。通过实际操作演示。并对类成员之间的访问修饰符进行了深度的讲解。
  • 也叫时序图,它按时间顺序显示对象之间的交互,描述了如何通过对象之间的交互实现用例。 对象表述为虚垂线顶端的矩形框,这些对象都排列在图的顶部。其中,发起用例活动的对象放在最左边,其它边界按边界对象、控制...
  • Android 四大组件之间通信

    千次阅读 2018-05-27 15:23:59
    下面主要介绍Activity之间通信,ActivityFragment之间通信,ActivityService之间通信,以及ContentProvider使用。组件之间利用广播,EventBus等第三方框架进行通信这里不做介绍。 一、Activity之间通信...
  • 开源对象存储MinIO技术白皮书

    万次阅读 多人点赞 2019-09-27 13:38:36
    通过这种方式,MinIO对象存储系统几乎可以无限的扩展总体性能容量。   2 统一域名访问  MinIO集群扩展加入新了集群或桶后,对象存储的客户端程序需要通过统一域名/url(如bucket1.domain.com)来访问...
  • Activity之间通信方式

    千次阅读 2018-08-23 16:09:46
    Intent是Android四大组件(Activity、Service、BroadcastReceiver、ContentProvider)之间通信的纽带,在Intent中携带数据也是四大组件之间数据通信最常用、最普通的方式。常规写法如下: //创建用于封装数据的...
  • 什么是面向对象编程

    万次阅读 多人点赞 2020-01-12 18:57:20
    本文关键字:面向对象、面向过程、面向过程编程语言、面向对象编程语言。说到编程,对于初学者来讲,可能第一想到的就是敲键盘,写代码,做游戏,甚至于会联想到软件破解、网络攻防。另一方面,在学了一些编程的相关...
  • Android进程间线程间通信方式

    千次阅读 2021-01-17 13:22:41
    进程:是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配调度的一个独立单位。线程:是进程的一个实体,是CPU调度分派的基本单位,它是比进程更小的能独立运行的基本单位。线程...
  • java对象的默认值

    千次阅读 2021-03-05 11:18:15
    其中,数据成员是一种对象(通过它的句柄与其通信),可以为任何类型。它也可以是主类型(并不是句柄)之一。如果是指向对象的一个句柄,则必须初始化那个句柄,用一种名为“构建器”(第4章会对此详述)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 507,104
精华内容 202,841
热门标签
关键字:

对象和对象之间通过什么进行通信