【QQ界面展示-通知的发布和监听 Objective-C语言】

一、来，看看，我们先给大家介绍一下通知

1.那么，这个通知，我们就是要给大家介绍三个东西

1）一个是通知的发布：如何发布通知

2）一个是通知的监听：发布以后，如何监听通知

3）一个是通知的移除：注意，通知一定要怎么样，最后，移除，

2.当你监听了一个通知以后，当你这个对象没有的时候，一定要把它移出一下，这个通知，否则就会有，野指针错误了，

类似于野指针错误了，空对象错误，

所以说，我们，要学习就是通知的发布、通知的监听、通知的移除、

就这么三点，

当我介绍完以后，如果这三点你都不会，我就白介绍了，

如果都会了，那就够了，

3.通知的发布

好，那么，在介绍之前，告诉大家，

我们这个通知里面，有这么两个对象，需要注意的，一个叫做

1）NSNotificationCenter

2）NSNotification

那么，这两个对象，是干什么的，

无论你是发布通知，还是监听通知，都必须通过谁来实现，

NSNotificationCenter

无论你是发布通知，还是监听通知，都必须通过NSNotificationCenter，来实现，

每次你发布的一条儿通知，就是一个什么对象呢，

就是一个NSNotification，这么一个对象，

每次发布的一条儿通知，就是一个NSNotification，这么一个对象，

所以说，现在有两个对象，

有两个类，你得搞明白，

1）当你要发布通知的时候，或者说，当你要监听通知的时候，你得首先拿到哪个类的对象，

NSNotificationCenter，这个对象啊，

2）注意，你每次发布的一个通知，这个通知里面，会包含好多信息，

包括通知的名称，

包括通知的内容，

等等，

会包含这些信息，这些信息，都会封装到一个什么对象里面来保存呢，

都会封装到一个NSNotification，对象，所以说，一个NSNotification，对象，就表示一个通知的一些信息啊，

那么，每一个通知，就是一个NSNotification，

十个通知，就得有几个，十个NSNotification，

所以说，上面这个对象，是用来发布和监听通知的，

下边这个对象，是用来封装一个通知的，

OK，就是这么两个东西，

好，这是我们关于这两个类，要搞明白，

等会儿，我们主要就是学习，这两个对象，怎么来去用它，

二、通知中心

先给大家来看一下这幅图，

好，注意，现在呢，这里有一幅图，这幅图里面呢，

有这么几个部分，

1）第一个，是红色框框，框住的这个

这个里面是发布通知的对象，

这个对象A，是用来发布通知的，这里有一个NSNotification，

两个NSNotification，

三个NSNotification，

表示这个A对象，发布了几个通知啊，三个通知吧，

1）第一个通知的名字，是不是在这个name里面，第一个通知的名字叫@“通知1”

2）第二个通知的名字，叫@“通知2”

3）第三个通知的名字，叫@“通知3”

这是A对象，发布了三个通知，

2）然后，这个绿色框框，框住的这个对象，

对象B，它是用来监听通知的，

它是用来监听通知的，

注意，这个对象B里面的，M1方法，监听了A对象发布的第一个通知，@“通知1”，

同时，是不是也监听了A对象发布的第二个通知，@“通知2”，啊，

就是说，对象B里面，的M1方法，监听了A对象发布的通知1、和通知2

3）然后，对象B里面的M2方法，监听了对象A里面的通知1、和通知3

4）对象B里面的M3方法，它只是监听了A对象里面的第3个通知、通知3，啊，

也就是说，现在，我们A，某个对象，可以发布很多个通知，

另外一个对象，是不是也可以监听很多个通知吧，

同时，一个方法，可以监听一个通知，

一个方法，是不是也可以监听多个通知吧，

一个通知，可以被一个方法监听，

一个通知，也可以被多个方法监听，

明白我的意思吧，就像广播一样，

当然，在我们国家，因为有法律规定，不是说人人都能开一个广播电台的吧，但是实际上，技术上，每个人是不是都可以发布自己的一个广播电台，

只要你买个收音机，是不是别人就可以监听它那个、接收它的广播信号吧，

然后你发广播的时候，你需要关心将来有多少人收听吗，

你发广播的时候，你只是发出去了，你知道有多少人收听吗，

根本不知道，你只要把它发出去，那么，别人收听的时候，它收听的时候，清楚不清楚、能不能收到，是不是你不管啊，

你要做的只是，把这个广播发出去，然后呢，谁想听，自己拿收音机收我的台就OK了吧，

通知和这个有点儿像，

通知，就是A对象，只管发通知，你想发几个通知就发几个通知，

发完以后，别人到底监听不监听你这个通知，A对象需要管吗，

A对象根本不关心，

也就是说，很多通知，A对象发了以后，是没有人监听的，

这样是没有错的，

明白吧，你谁想监听你就监听，不想监听你就别监听，

反正我发通知的人，我一定会发，明白，我一定会发，就是这个意思，

好，接下来，就是需要：

1）用一个对象来发通知

2）用一个对象来监听通知

那么注意，发通知，得用哪个对象，NSNotificationCenter吧，

得用NSNotificationCenter来发布通知，

那么这个通知，是谁发布的呢，是这个A对象发布的，

注意，我们是用，NSNotificationCenter这个对象来发通知，

那么，用它来发通知，但是，这个通知是哪个对象要发布的呢，是不是上面这个A对象要发布的啊，

这个A对象，要发布一个通知，用谁来发布，得用下面这个NSNotificationCenter，得用这个Center对象来发布，

监听的时候，也是B对象要监听，通过什么来监听呢，通过NSNotificationCenter，这个对象来实现监听吧，

是这么一个意思，

二、接下来，我们就给大家模拟一下，这个发通知、和监听通知，

1.新建一个项目，

点击File-New-Project，

选择OS X系统-Application-Command Line Tool-点击Next，

起个名字：003通知的发布与监听，

新建这么一个只有一个main文件的这么一个项目，

好，这里我新建两个类，

右键-NewFile-新建两个类，

1）第一个类呢，

叫什么类啊，

第一个类呢，叫我们的：NotificationSender，类，

通知的发布者，通知发送者，

复制一下这句话，拷贝到.m文件里，

//通知的发布者，

2）再来一个通知的监听者，

来一个什么名字呢：NSNotificationListener，监听的意思，

好，这是我们这儿说的这么一个东西，

2.然后呢，通知的发布者，在这里面，给它加一个属性吧，

这个属性，就是name，表示这个通知的发布者，它叫啥，

然后呢，这个通知的监听者，也给它来个name吧，这个表示通知监听者的名称，

好，现在是不是有一个监听的通知者、和一个发布者了，

好，接下来，我们就打开这个主函数，

尝试来写一个通知发布、和监听，

是不是肯定要用到那两个类，

#import “No……，哎，怎么只有一个呢，

靠，我前边为什么要加个NS呢，是不是我前边在这个类型加了个NS吧，

但是不应该加吧，但是加上，是不是也没啥错吧，

但是最好别加，因为NS，是不是人家系统的类型啊，

行，删了，删了就删了吧，

哎，不删了，就这样吧，

OK，现在是不是这两个就都有了，

3.我们首先创建一个什么，

//创建一个通知的发布者

//创建一个通知的监听者

1）//怎么写，发布者，

NotificationSender *sender1 = [[NotificationSender alloc] init];

//好，是不是有一个通知的一个发布者了，

2）好，再来一个监听者，

NSNotificationListener *listener1 = [[NSNotificationListener alloc] init];

//然后，接下来，我们干什么，先来

3）让sender1对象发布一个通知

注意听，我要让这个对象发布一个通知，

既然发布通知，无论是发、还是接，都得拿到哪个对象，才能发布、还是接，

NSNotificationCenter，吧，

得拿到这个Center对象，才能进行发、接，

所以说，你这里要发一个通知，就得先获取干什么，先干什么，

//先获取NSNotificationCenter对象

//是不是拿到这个对象，才能进行发通知、或者监听通知吧，

//怎么获取这个对象

NSNotificationCenter *center

NSNotificationCenter *notificationCenter =

//等于什么呢，等于NSNotificationCenter，

//里面有一个方法，叫做default……

//叫做defaultCenter

//默认有一个叫defaultCenter，

//这就是一个类方法，

//也就是说，这个发通知、和接通知，这个对象，这个对象一直就、这个对象是不是一直存在于我们的应用程序里面，

//我们要做的只是，拿到这个对象，就可以了，明白吧，不需要我们创建，

//拿到这个对象，就OK了，

//拿到它以后，要通过这个对象进行发通知、或者说是监听通知，

//我们要用它、要通过它发布一个通知

//通过NSNotificationCenter发布一个通知

//注意，通过这个Center对象，发布一个通知，需要调一个方法，来，注意看，我们的PPT里面，我给大家把这几个方法，列出来了，

是这里，来，注意看，

当你需要通过这个对象，发布一个通知的时候，非常简单，只要调它的这个postNotification，

调这个PostNotification方法，

或者是PostNotificationName方法

或者是postNotificationName：userInfo：方法

调这三个方法，都可以，

这三个方法，其实意思是一样的，来，注意看，给大家就是，看一下，

这个可能文字比较挤，看不清楚，我在这里看，

注意，我们是不是首先知道，它肯定是要调、要发送通知、肯定是要调一个post什么什么方法啊，

来，看看，

notificationCenter post……

来个postNotification，注意，这里有这三个方法，

这三个方法，其实可以理解为是一个方法，

1）当你发布一个通知的时候，你可以通过传一个封装好的NSNotification对象，可以事先先封装好一个NSNotification对象，然后把这个对象直接传进来，这样的话，就会把你这个通知对象，给你发出去，

2）或者说，你可以调第二个方法，当调这个postNotification方法的时候，它根据你现场传过来的这两个参数，内部给你构建一个NSNotification对象

3）第三个也是，你在调这个方法的时候，给它传一个：

1— 通知的名称

2— 传一个是哪个对象发的通知

3— 传一个通知的具体数据

然后在这个方法内部，它会根据这三个值，创建一个NSNotification对象，

也就是说，这三个方法，都是用来发布通知的，

只不过，

1）第一个方法是，你得事先先封装好一个通知对象，

然后传过来，我帮你发，

2）第三个方法是，你不需要事先封装，只要把通知对象里面的数据，给我传给这三个参数，我在这个postNotification方法内部，是不是帮你封装这个通知对象啊，

那么这个时候，我请问大家，如果是你的话，你会调第一个、第二个、还是第三个，

如果是我的话，我会调第三个，为什么，

第一个是不是还得手动封装，多费劲啊，

第三个是不是写完以后，内部自动封装了啊，

但是，有时候，你现在就有一个现成的通知对象，

这个时候，调第一个是不是很方便，

所以说，在不同的情况下，有不同的方法，

我们现在，今天主要用第三个，

1）参数一：表示通知的名称

2）参数二：第二个这个对象，表示的是，这个NSNotificationCenter，这个对象，要帮你发一个通知，但是这个通知是哪个对象发的呢，我们是不是要用这个sender1这个对象发，所以，第二个参数，就传一个sender1，

3）参数三：第三个参数，是这个通知的一个具体的内容，

这是一个键值对儿吧，NSDictionary，这儿既然是个键值对儿，所以说，这个通知的内容，你想怎么写，就怎么写，想怎么写，就怎么写，

想怎么写，

最近有什么重大的新闻，

两会是吧，

这是值吧，

我们是不是先得给它来个键，

键，随便起吧，

随便起，

title，是不是这个，

[notificationCenter postNotificationName:@“tzname1” object:sender1 userInfo:@{@“title”：@“两会Duang开始了”}];

2）再来个内容，

@“content”：内容是什么，

@“content”：@”成龙的头发少了“

假设这就是一个通知，这个通知里面，只有这两个内容，

OK，现在这是不是就是一个通知，

这，就是一个啥，

这是不是就是发布了一个通知啊，

注意，这就是发布了一个通知，

4.那么，是不是要监听这个通知啊，

来，注意听，

监听通知，必须放到发布通知之前，

监听，必须放到发布通知之前，

得先监听、再发布、然后才起作用，

如果它已经发布了，再监听，就晚了，

因为你先监听了以后，这个通知对象，就知道，哦，你要监听，我发的时候，我给你发一份儿啊，

就好比，定牛奶，你得先定，才会给你送家吧，那人家送过来了，你说我定一下，你做梦呢吧，

一定要先定，才会给你送到家，

这里也是，要先监听，然后再发布，你才能接收，

所以，下面是发布通知，上面是监听通知，

//监听一个通知，我们知道用这个listener1，这个对象来监听，

//但是，我们打开看一下这个listener1，里面，有任何方法吗，没有，我们给它写一个，

//监听通知的时候，必须是使用某个对象的方法来监听吧，

//监听通知的时候，必须使用某个对象的方法来监听，

//因为只有方法，当通知发送的时候，才会被执行，

//所以，一定要先写个方法，

//编写一个方法，这个方法用来监听通知，

//叫什么，随便写，m1，可不可以，m1方法，

- （void）m1；

在NSNotificationListener.m文件里，把这个方法实现以下，

//我们这里是不是，只要m1方法一被调用，是不是duang，就出来了，

//现在这个监听通知者，里面是不是有一个m1方法了，

//然后，我们在这个主函数中，

//用这个listener1的m1方法，监听一下这个通知，

//注意，怎么监听，是不是也要用这个Center对象啊，

//是不是也要用这个notificationCenter，来监听，

//所以说，我们可以先把这个对象，怎么样，挪到前面去吧，

//选中这句话，command + X，是不是写到最上面啊，

//因为无论发布通知，还是监听通知，都要用到它，所以，先把它写到上面，

//监听，怎么来监听，

//notificationCenter，里面有一个方法，叫做add

//我们说，你监听这个通知，相当于你一直观察这个通知，

//只要它一通知，是不是就立刻去做一件事儿啊，

//所以说，你监听的意思，其实就是增加一个观察者，

//我们在这里，就是用这个什么，就是我们这个addObserver：（id）

//注意，不是上面这个，

//这个是KVO什么东西，不用管它，用这个

notificationCenter addObserver：（id） selector：（SEL） name：（NSString *） object：（id）

//注意，这个里边有这么几个参数，

1）参数一：第一个参数是，哪个对象要监听这个通知，

哪个对象，listener1吧，

2）参数二：第二个参数，这个对象的哪个方法，要监听这个通知，是不是m1方法吧，

@selector（m1）

3）参数三：第三个参数，是什么东西呢，就是说，增加的这个监听，是让这个对象（listener1）的这个方法（m1）监听，这个第三个参数，是通知的名字，我们这儿是不是只发布了一个通知，通知的名字，是不是叫这个，@“tzname1”

第三个参数，是要监听的通知的名字，

4）参数四：第四个参数，是，这个通知名字，是哪个对象发布的这个通知啊，

是sender1，这个对象吧，对，是sender1，

拷过来，

这就是，监听一个通知，

来，把参数写一下，

1）参数1：要监听通知的对象

2）参数2：该对象的哪个方法用来监听这个通知

3）参数3：被监听的通知的名称

4）参数4：发布通知的对象

下面这个发布通知的参数，写一下，

1）参数1：通知名称

2）参数2：通知发布者（发布通知的对象）

有人说，发布通知的对象，不是这个吗，（notificationCenter）

不是这个，它只是一个工具而已，它只是一个工具而已，

是不是这个工具，为这个对象（sender1）来发布通知，

3）参数3：通知的具体内容

这就是我们的这个

1）首先，创建一个通知的发布者

2）创建一个通知的监听者

3）因为我们要发布通知、或者是监听通知，所以说，首先得创建一个NSNotificationCenter对象，

4）然后，一定要先监听通知

5）再，发布通知

6）然后，还有一个步骤，要移除这个通知，什么时候移除呢，我们等会儿再说，

来，先给大家，把这个运行一下，

来，来，咱们看一下，它管用不管用，这里，设个断点，

现在我们一步一步走，

1）走一步，是不是创建了一个通知发布者

2）是不是又创建了一个通知监听者

3）是不是创建了一个NSNotificationCenter，那个对象吧，

4）然后，是不是要增加一个监听，

让listener1的m1方法，监听这个通知，@“tzname1”，监听这个对象（sender1）发布的@“tzname1”通知吧，

所以说，这句话，完整的说，应该是，让listener1这个对象的m1方法，监听sender1，这个对象发布的@“tzname1”，这个通知，

5）再走一步，监听完毕之后，只要这个通知一发布，这里是不是立刻就应该监听的到，

这里一监听的到，意味着这个m1方法，立刻就被执行了，

咱们看看是吗，

通知一发布，监听通知的方法，立刻被执行，是不是，

这是不是就是通知的监听者啊，

也就是说，其实，大家想想，这是什么意思，其实是，只要这个通知一发布，那么这个时候，它就会调用通知监听者的m1方法，

是不是直接调这个对象（listener1）的这个方法（m1）啊，

既然是这样，那么假如说，有一天，listener1，这个对象作废了，这个对象废掉了，这个对象释放了，

一开始，listener1，这个对象，是不是监听我们这个通知，

然后呢，当这个listener1，这个对象被销毁以后，这个对象（listener1）就被销毁了，

这个对象被销毁以后，是不是通知还有可能被发布吧，

当这个对象被销毁以后，如果你一发这个通知，它依然会去调用listener1，对象的这个m1方法，

这个时候，listener1，这个对象被销毁了，调一个已经被销毁了的对象的m1方法，显然就，野指针错误了吧，

是不是僵尸对象了吧，

所以说，为了避免这个问题，

当这个listener1，监听了这个通知以后，一定要在listener1，被销毁的时候，再把这个通知给它移除掉，

明白为什么要移除通知了吗，

因为如果你不移除的话，这个时候，一旦这个监听通知的对象，被销毁了，通知一发布，依然会调它的那个方法，就会发生野指针错误，

所以说，就得移除，

既然我们知道为什么了，你能告诉我应该在什么地方，去移除这个通知吗，

是不是在listener1这个对象被销毁的时候，会在它即将被销毁的时候，移除这个通知啊，

哪个方法预示着这个对象即将被销毁了，

只要这个方法一被执行，对象就被销毁了，

哪个方法，

对，就是我们这个类的一个dealloc方法，

来，找到我们这个listener，

它里面是不是有一个dealloc方法吧，

它里面，是不是有一个叫做dealloc方法，

在这个方法当中，注意看，

- （void）dealloc{

//移除通知

//怎么移除，你监听通知、发布通知、移除通知，都得用谁，

[NSNotificationCenter defaultCenter];

是不是都得用这个Center啊，

然后，怎么移除，remove

removeObserver，

把谁移除掉，把self，

当前，这个监听对象，自己，它是不是，它要通过这个对象的m1方法，监听一个通知啊，

你移除的时候，就是把当前对象自己移除掉，我再也不监听你了，马上就挂了，

在挂之前，咱俩先解除关系啊，

就是这么个意思，这就是我们移除通知，

啥，super，能调吗，

[super dealloc];

command + B，

Build Failed，什么，

ARC forbids explicit message send of ‘dealloc’

ARC禁止显示的发布这个消息给父类，

ARC是不是不能调，

MRC是不是才能调啊，

删掉这句话，[super dealloc];

好，那么接下来，这就是我们这个通知的一个简单的一个

1）监听

2）发布

好，大家休息一下，