内存管理简介

引用计数器

1.什么是引用计数器

• 系统是如何判断什么时候需要回收一个对象所占用的内存?
  • 根据对象的引用计数器
• 什么是引用计数器
  • 每个OC对象都有自己的引用计数器
  • 它是一个整数
  • 从字面上, 可以理解为”对象被引用的次数”
  • 也可以理解为: 它表示有多少人正在用这个对象

yyjsq.png

2.引用计数器的作用

• 简单来说, 可以理解为:
  • 引用计数器表示有多少人正在使用这个对象
• 当没有任何人使用这个对象时, 系统才会回收这个对象, 也就是说
  • 当对象的引用计数器为0时,对象占用的内存就会被系统回收
  • 如果对象的计数器不为0，那么在整个程序运行过程，它占用的内存就不可能被回收(除非整个程序已经退出 )
• 任何一个对象, 刚生下来的时候, 引用计数器都为1
  • 当使用alloc、new或者copy创建一个对象时，对象的引用计数器默认就是1

3.引用计数器的操作

• 要想管理对象占用的内存, 就得学会操作对象的引用计数器
• 引用计数器的常见操作
  • 给对象发送一条retain消息,可以使引用计数器值+1（retain方法返回对象本身）
  • 给对象发送一条release消息, 可以使引用计数器值-1
  • 给对象发送retainCount消息, 可以获得当前的引用计数器值
• 需要注意的是: release并不代表销毁\回收对象, 仅仅是计数器-1

dealloc方法

1.dealloc方法基本概念

• 当一个对象的引用计数器值为0时,这个对象即将被销毁，其占用的内存被系统回收
• 对象即将被销毁时系统会自动给对象发送一条dealloc消息 (因此, 从dealloc方法有没有被调用,就可以判断出对象是否被销毁)
• dealloc方法的重写
  • 一般会重写dealloc方法,在这里释放相关资源,dealloc就是对象的遗言
  • 一旦重写了dealloc方法, 就必须调用[super dealloc],并且放在最后面调用
• 注意
  • 不能直接调用dealloc方法
  • 一旦对象被回收了, 它占用的内存就不再可用,坚持使用会导致程序崩溃（野指针错误）

野指针\空指针

1.僵尸对象

• 已经被销毁的对象(不能再使用的对象)
• 显示僵尸对象,修改edit scheme

zombie.png

2.野指针

• 指向僵尸对象(不可用内存)的指针
• 给野指针发消息会报EXC_BAD_ACCESS错误

3.空指针

• 没有指向存储空间的指针(里面存的是nil, 也就是0)
• 给空指针发消息是没有任何反应的
• 为了避免野指针错误的常见办法
  • 在对象被销毁之后, 将指向对象的指针变为空指针(self.obj = nil)

4.如何关闭ARC功能

• 要想手动调用retain、release等方法 , 就必须关闭ARC功能

arc.png

内存管理原则

1.内存管理原则

• 苹果官方规定的内存管理原则
  • 谁创建谁release :
    • 如果你通过alloc、new、copy或mutableCopy来创建一个对象，那么你必须调用release或autorelease
  • 谁retain谁release:
    • 只要你调用了retain，就必须调用一次release
• 总结一下就是
  • 有加就有减
  • 曾经让对象的计数器+1，就必须在最后让对象计数器-1

2.多对象内存管理

• 只要还有人在用某个对象，那么这个对象就不会被回收
• 只要你想用这个对象，就让对象的计数器+1
• 当你不再使用这个对象时，就让对象的计数器-1

3.set方法内存管理

• (1)retain需要使用的对象
• (2)release之前的对象
• (3)只有传入的对象和之前的不同才需要release和retain

- (void)setRoom:(Room *)room
{
    // 避免过度释放
    if (room != _room)
    {
        // 对当前正在使用的房间（旧房间）做一次release
        [_room release];

        // 对新房间做一次retain操作
         _room = [room retain];
    }
}

4.dealloc方法的内存管理

- (void)dealloc
{
    // 当人不在了，代表不用房间了
    // 对房间做一次release操作
    [_room release];
    [super dealloc];
}

@property参数

1.控制set方法的内存管理

• retain ： release旧值，retain新值（用于OC对象）
• assign ： 直接赋值，不做任何内存管理(默认，用于非OC对象类型)
• copy ： release旧值，copy新值（一般用于NSString *）

2.控制需不需要生成set方法

• readwrite ：同时生成set方法和get方法（默认）
• readonly ：只会生成get方法

3.多线程管理

• atomic ：性能低（默认单线程）
• nonatomic ：性能高

4.控制set方法和get方法的名称

• setter ： 设置set方法的名称，一定有个冒号:
• getter ： 设置get方法的名称
• 注意: 不同类型的参数可以组合在一起使用

@class

1.@class基本概念

• 作用
  • 可以简单地引用一个类
• 简单使用
  • @class Dog;
  • 仅仅是告诉编译器:Dog是一个类;并不会包含Dog这个类的所有内容
• 具体使用
  • 在.h文件中使用@class引用一个类
  • 在.m文件中使用#import包含这个类的.h文件

2.@class其它应用场景

• 对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类
• 这种嵌套包含的代码编译会报错

#import "B.h"
@interface A : NSObject
{
    B *_b;
}
@end

#import “A.h"
@interface B : NSObject
{
    A *_a;
}
@end

• 当使用@class在两个类相互声明，就不会出现编译报错

@class B;
@interface A : NSObject
{
    B *_b;
}
@end

@class A;
@interface B : NSObject
{
    A *_a;
}
@end

3.@class和#import

• 作用上的区别

  • #import会包含引用类的所有信息(内容),包括引用类的变量和方法
  • @class仅仅是告诉编译器有这么一个类, 具体这个类里有什么信息, 完全不知

• 效率上的区别

  • 如果有上百个头文件都#import了同一个文件，或者这些文件依次被#import,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍 , 编译效率非常低

  • 相对来讲，使用@class方式就不会出现这种问题了

循环retian

1.循环retian基本概念

• 循环retain的场景
  • 比如A对象retain了B对象，B对象retain了A对象
• 循环retain的弊端
  • 这样会导致A对象和B对象永远无法释放
• 循环retain的解决方案
  • 当两端互相引用时，应该一端用retain、一端用assign

autorelease基本使用

1.autorelease基本概念

• autorelease是一种支持引用计数的内存管理方式,只要给对象发送一条autorelease消息,会将对象放到一个自动释放池中,当自动释放池被销毁时，会对池子里面的所有对象做一次release操作

  • 注意,这里只是发送release消息,如果当时的引用计数(reference-counted)依然不为0,则该对象依然不会被释放。

• autorelease方法会返回对象本身

Person *p = [Person new];
p = [p autorelease];

• 调用完autorelease方法后，对象的计数器不变

Person *p = [Person new];
p = [p autorelease];
NSLog(@"count = %lu", [p retainCount]); // 1

• autorelease的好处
  • 不用再关心对象释放的时间
  • 不用再关心什么时候调用release
• autorelease的原理
  • autorelease实际上只是把对release的调用延迟了,对于每一个autorelease,系统只是把该 Object放入了当前的autorelease pool中,当该pool被释放时,该pool中的所有Object会被调用Release。

2.自动释放池

@autoreleasepool
{ //开始代表创建自动释放池

} //结束代表销毁自动释放池

• 在iOS程序运行过程中，会创建无数个池子。这些池子都是以栈结构存在（先进后出）
• 当一个对象调用autorelease方法时，会将这个对象放到栈顶的释放池

3.autorelease基本使用

NSAutoreleasePool *autoreleasePool = [[NSAutoreleasePool alloc] init];

Person *p = [[[Person alloc] init] autorelease];

[autoreleasePool drain];
@autoreleasepool
{ // 创建一个自动释放池
        Person *p = [[Person new] autorelease];
} // 销毁自动释放池(会给池子中所有对象发送一条release消息)

4.autorelease使用注意

• 并不是放到自动释放池代码中,都会自动加入到自动释放池

 @autoreleasepool {
    // 因为没有调用 autorelease 方法,所以对象没有加入到自动释放池
    Person *p = [[Person alloc] init];
    [p run];
}

• 在自动释放池的外部发送autorelease 不会被加入到自动释放池中
  • autorelease是一个方法,只有在自动释 放池中调用才有效。

 @autoreleasepool {
 }
 // 没有与之对应的自动释放池, 只有在自动释放池中调用autorelease才会放到释放池
 Person *p = [[[Person alloc] init] autorelease];
 [p run];

 // 正确写法
  @autoreleasepool {
    Person *p = [[[Person alloc] init] autorelease];
 }

 // 正确写法
 Person *p = [[Person alloc] init];
  @autoreleasepool {
    [p autorelease];
 }

• 自动释放池的嵌套使用

  • 自动释放池是以栈的形式存在

  • 由于栈只有一个入口, 所以调用autorelease会将对象放到栈顶的自动释放池

  • 栈顶就是离调用autorelease方法最近的自动释放池

    @autoreleasepool { // 栈底自动释放池
    @autoreleasepool {
       @autoreleasepool { // 栈顶自动释放池
           Person *p = [[[Person alloc] init] autorelease];
       }
       Person *p = [[[Person alloc] init] autorelease];
    }
    }
    

• 自动释放池中不适宜放占用内存比较大的对象

  • 尽量避免对大内存使用该方法,对于这种延迟释放机制,还是尽量少用
  • 不要把大量循环操作放到同一个 @autoreleasepool 之间,这样会造成内存峰值的上升

// 内存暴涨
    @autoreleasepool {
        for (int i = 0; i < 99999; ++i) {
            Person *p = [[[Person alloc] init] autorelease];
        }
    }
// 内存不会暴涨
 for (int i = 0; i < 99999; ++i) {
        @autoreleasepool {
            Person *p = [[[Person alloc] init] autorelease];
        }
    }

5.autorelease错误用法

• 不要连续调用autorelease

 @autoreleasepool {
        // 错误写法, 过度释放
    Person *p = [[[[Person alloc] init] autorelease] autorelease];
 }

• 调用autorelease后又调用release

 @autoreleasepool {
    Person *p = [[[Person alloc] init] autorelease];
    [p release]; // 错误写法, 过度释放
 }

ARC基本概念

1.什么是ARC

• Automatic Reference Counting,自动引用计数,即ARC,可以说是WWDC2011和iOS5所引入 的最大的变革和最激动人心的变化。ARC是新的LLVM 3.0编译器的一项特性,使用ARC,可以说一 举解决了广大iOS开发者所憎恨的手动内存管理的麻烦。

  • 手动管理内存, 可以简称MRC (Manual Reference Counting)

• 在工程中使用ARC非常简单:只需要像往常那样编写代码,只不过永远不写retain,release和autorelease三个关键字就好~这是ARC的基本原则。

• 当ARC开启时,编译器将自动在代码合适的地方插入retain, release和autorelease,而作为程序猿,完全不需要担心编译器会做错(除非开发者自己错用ARC了)。

2.ARC的注意点和优点

• ARC的注意点
  • ARC是编译器特性，而不是运行时特性
  • ARC不是其它语言中的垃圾回收, 有着本质区别
• ARC的优点
  • 完全消除了手动管理内存的烦琐, 让程序猿更加专注于app的业务
  • 基本上能够避免内存泄露
  • 有时还能更加快速，因为编译器还可以执行某些优化

3.ARC的判断原则

• ARC的判断原则
  • 只要还有一个强指针变量指向对象，对象就会保持在内存中
• 强指针
  • 默认所有指针变量都是强指针
  • 被__strong修饰的指针

 Person *p1 = [[Person alloc] init];
 __strong  Person *p2 = [[Person alloc] init];

• 弱指针
  • 被__weak修饰的指针

__weak  Person *p = [[Person alloc] init];

• 注意:当使用ARC的时候,暂时忘记“引用计数器”,因为判断标准变了。

4.ARC机制判断

• OS5以后,创建项目默认的都是ARC

  
  Snip20150625_2.png

• ARC机制下有几个明显的标志:

  • 不允许调用对象的 release方法
  • 不允许调用 autorelease方法
  • 再重写父类的dealloc方法时,不能再调用 [super dealloc];

ARC下的内存管理

1.ARC下单对象内存管理

• 局部变量释放对象随之被释放

int main(int argc, const char * argv[]) {
   @autoreleasepool {
        Person *p = [[Person alloc] init];
    } // 执行到这一行局部变量p释放
    // 由于没有强指针指向对象, 所以对象也释放
    return 0;
}

• 清空指针对象随之被释放

int main(int argc, const char * argv[]) {
   @autoreleasepool {
        Person *p = [[Person alloc] init];
        p = nil; // 执行到这一行, 由于没有强指针指向对象, 所以对象被释放
    }
    return 0;
}

• 默认清空所有指针都是强指针

int main(int argc, const char * argv[]) {
   @autoreleasepool {
        // p1和p2都是强指针
        Person *p1 = [[Person alloc] init];
        __strong Person *p2 = [[Person alloc] init];
    }
    return 0;
}

• 弱指针需要明确说明
  • 注意: 千万不要使用弱指针保存新创建的对象

int main(int argc, const char * argv[]) {
   @autoreleasepool {
        // p是弱指针, 创建的对象会被立即释放
        __weak Person *p1 = [[Person alloc] init];
    }
    return 0;
}

---

2.ARC下多对象内存管理

• ARC和MRC一样, 想拥有某个对象必须用强指针保存对象, 但是不需要在dealloc方法中release

@interface Person : NSObject

// MRC写法
//@property (nonatomic, retain) Dog *dog;

// ARC写法
@property (nonatomic, strong) Dog *dog;

@end

---

3.ARC下循环引用问题

• ARC和MRC一样, 如果A拥有B, B也拥有A, 那么必须一方使用弱指针

@interface Person : NSObject

//@property (nonatomic, retain) Dog *dog;
@property (nonatomic, strong) Dog *dog;

@end

@interface Dog : NSObject

// 错误写法, 循环引用会导致内存泄露
//@property (nonatomic, strong) Person *owner;

// 正确写法, 当如果保存对象建议使用weak
//@property (nonatomic, assign) Person *owner;
@property (nonatomic, weak) Person *owner;
@end

---

4.ARC下@property参数

• strong : 用于OC对象, 相当于MRC中的retain
• weak : 用于OC对象, 相当于MRC中的assign
• assign : 用于基本数据类型, 跟MRC中的assign一样

Category基本概念

1.什么是Category

• Category有很多种翻译: 分类 \ 类别 \ 类目 (一般叫分类)
• Category是OC特有的语法, 其他语言没有的语法
• Category的作用
  • 可以在不修改原来类的基础上, 为这个类扩充一些方法
  • 一个庞大的类可以分模块开发
  • 一个庞大的类可以由多个人来编写,更有利于团队合作

---

2.Category的格式

• 在.h文件中声明类别

  • 1)新添加的方法必须写在 @interface 与 @end之间

  • 2)ClassName 现有类的类名(要为哪个类扩展方法) + 3)CategoryName 待声明的类别名称

  • 4)NewMethod 新添加的方法

    @interface ClassName (CategoryName)
    NewMethod; //在类别中添加方法
    //不允许在类别中添加变量
    @end
    

  • 注意: 1)不允许在声明类别的时候定义变量

• 在.m文件中实现类别:

  • 1)新方法的实现必须写在@ implementation与@end之间
  • 2)ClassName 现有类的类名
  • 3)CategoryName 待声明的类别名称
  • 4)NewMethod 新添加的方法的实现

@implementation ClassName(CategoryName)

NewMethod
... ...
@end

• 使用Xcode创建分类

category1.png
category2.png

Category注意事项

1.分类的使用注意事项

• 分类只能增加方法, 不能增加成员变量

@interface Person (NJ)
{
//    错误写法
//    int _age;
}
- (void)eat;
@end

• 分类中写property只会生成方法声明

@interface Person (NJ)
// 只会生成getter/setter方法的声明, 不会生成实现和私有成员变量
@property (nonatomic, assign) int age;
@end

• 分类可以访问原来类中的成员变量

@interface Person : NSObject
{
    int _no;
}
@end

@implementation Person (NJ)
- (void)say
{
    NSLog(@"%s", __func__);
    // 可以访问原有类中得成员变量
    NSLog(@"no = %i", _no);
}
@end

• 如果分类和原来类出现同名的方法, 优先调用分类中的方法, 原来类中的方法会被忽略

@implementation Person

- (void)sleep
{
    NSLog(@"%s", __func__);
}
@end

@implementation Person (NJ)
- (void)sleep
{
    NSLog(@"%s", __func__);
}
@end

int main(int argc, const char * argv[]) {
    Person *p = [[Person alloc] init];
    [p sleep];
    return 0;
}

输出结果:
-[Person(NJ) sleep]

---

2.分类的编译的顺序

• 多个分类中有同名方法,则执行最后编译的文件方法(注意开发中千万不要这么干)

@implementation Person

- (void)sleep
{
    NSLog(@"%s", __func__);
}
@end

@implementation Person (NJ)
- (void)sleep
{
    NSLog(@"%s", __func__);
}
@end

@implementation Person (MJ)
- (void)sleep
{
    NSLog(@"%s", __func__);
}
@end

int main(int argc, const char * argv[]) {
    Person *p = [[Person alloc] init];
    [p sleep];
    return 0;
}

输出结果:
-[Person(MJ) sleep]

category3.png

• 方法调用的优先级(从高到低)
  • 分类(最后参与编译的分类优先)
  • 原来类
  • 父类

• 练习

#import "NSString+GX.h"

@implementation NSString (GX)
+ (int)countWithStr:(NSString *)str
{
    int count = 0;
    for (int i = 0; i < str.length; i++) {
        unichar c = [str characterAtIndex:i];
        if (c >= '0' && c <= '9'){
            count++;
        }
    }
    return count;
}
- (int) count
{
    int num = 0;
    for (int i = 0; i < self.length; i++) {
        unichar c = [self characterAtIndex:i];
        if (c >= '0' && c <= '9'){
            num++;
        }
    }
    return num;
}
@end

---

类扩展(Class Extension)

1.什么是类扩展

• 延展类别又称为扩展(Extendsion),Extension是Category的一个特例
• 可以为某个类扩充一些私有的成员变量和方法
  • 写在.m文件中
  • 英文名是Class Extension

---

2.类扩展书写格式

@interface 类名 ()
@end

• 对比分类, 就少了一个分类名称,因此也有人称它为”匿名分类”

Block基本概念

1.block的格式

• Block的定义格式

返回值类型 (^block变量名)(形参列表) = ^(形参列表) {

};

Snip20150625_11.png

• block最简单形式

void (^block名)() = ^{代码块;}

例如:
void (^myBlock)() = ^{ NSLog(@"GX"); };

• block带有参数的block的定义和使用

void (^block名称)(参数列表)
= ^ (参数列表) {  代码实现; };

例如:
void (^myBlock)(int) = ^(int num){ NSLog(@"num = %i", num); };

• 带有参数和返回值的block

返回类型 (^block名称)(参数列表)
= ^ (参数列表) { // 代码实现; }

例如:
int (^myBlock)(int, int) = ^(int num1, int num2){ return num1 + num2; };

• 调用Block保存的代码

block变量名(实参);

typedef和Block

1.函数指针回顾

• 函数指针使用

int sum(int value1, int value2)
{
    return value1 + value2;
}

int minus(int value1, int value2)
{
    return value1 - value2;
}

int main(int argc, const char * argv[]) {
    int (*sumP) (int, int) = sum;
    int res = sumP(10, 20);
    NSLog(@"res = %i", res);

    int (*minusP) (int , int) = minus;
    res = minusP(10, 20);
    NSLog(@"res = %i", res);
    return 0;
}

• 函数指针别名

typedef int (*calculate) (int, int);
int main(int argc, const char * argv[]) {
    calculate sumP = sum;
    int res = sumP(10, 20);
    NSLog(@"res = %i", res);
    calculate minusP = minus;
    res = minusP(10, 20);
    NSLog(@"res = %i", res);
    return 0;
}

---

2.block和typedef

• block使用

int main(int argc, const char * argv[]) {
  int (^sumBlock) (int, int) = ^(int value1, int value2){
      return value1 + value2;
  };
  int res = sumBlock(10 , 20);
  NSLog(@"res = %i", res);

  int (^minusBlock) (int, int) = ^(int value1, int value2){
      return value1 - value2;
  };
  res = minusBlock(10 , 20);
  NSLog(@"res = %i", res);
  return 0;
}

• block别名

typedef int (^calculateBlock) (int, int);
int main(int argc, const char * argv[]) {
    calculateBlock sumBlock = ^(int value1, int value2){
        return value1 + value2;
    };
    int res = sumBlock(10, 20);
    NSLog(@"res = %i", res);
    calculateBlock minusBlock = ^(int value1, int value2){
        return value1 - value2;
    };
    res = minusBlock(10, 20);
    NSLog(@"res = %i", res);

    return 0;
}

Block注意事项

1.Block注意事项

• 在block内部可以访问block外部的变量

int  a = 10;
void (^myBlock)() = ^{
    NSLog(@"a = %i", a);
    }
myBlock();
输出结果: 10

• block内部也可以定义和block外部的同名的变量(局部变量),此时局部变量会暂时屏蔽外部

int  a = 10;
void (^myBlock)() = ^{
    int a = 50;
    NSLog(@"a = %i", a);
    }
myBlock();
输出结果: 50

• 默认情况下, Block内部不能修改外面的局部变量
  • block将外部变量拷贝copy一份到堆中.改变了block中的值,不会影响外部的值

int b = 5;
void (^myBlock)() = ^{
    b = 20; // 报错
    NSLog(@"b = %i", b);
    };
myBlock();

• Block内部可以修改使用__block修饰的局部变量
  • 传递的是变量地址

__block int b = 5;
void (^myBlock)() = ^{
  b = 20;
  NSLog(@"b = %i", b);
};
myBlock();
输出结果: 2

protocol 基本概念

• Protocol的作用
  • 用来声明一些方法
  • 也就说, 一个Protocol是由一系列的方法声明组成的

2.protocol 语法格式

• Protocol的定义

@protocol 协议名称
// 方法声明列表
@end

• 类遵守协议
  • 一个类可以遵守1个或多个协议
  • 任何类只要遵守了Protocol,就相当于拥有了Protocol的所有方法声明

@interface 类名 : 父类 <协议名称1, 协议名称2,…>
@end

• 示例

@protocol SportProtocol <NSObject>
- (void)playFootball;
- (void)playBasketball;
@end

#import "SportProtocol.h" // 导入协议
@interface Studnet : NSObject<SportProtocol> // 遵守协议
@end

@implementation Student
// 实现协议方法
- (void)playBasketball
{
    NSLog(@"%s", __func__);
}
// 实现协议方法
- (void)playFootball
{
    NSLog(@"%s", __func__);
}
@end

---

3.protocol和继承区别

• 继承之后默认就有实现, 而protocol只有声明没有实现
• 相同类型的类可以使用继承, 但是不同类型的类只能使用protocol
• protocol可以用于存储方法的声明, 可以将多个类中共同的方法抽取出来, 以后让这些类遵守协议即可

4.protocol 的使用注意

• 1)Protocol:就一个用途,用来声明一大堆的方法(不能声明成员变量),不能写实现。

@protocol SportProtocol <NSObject>
{
    int _age; // 错误写法
}
- (void)playFootball;
- (void)playBasketball;
@end

• 2)只要父类遵守了某个协议,那么子类也遵守。

@protocol SportProtocol <NSObject>

- (void)playFootball;
- (void)playBasketball;
@end
#import "SportProtocol.h"
@interface Student : NSObject <SportProtocol>
@end

@interface GoodStudent : Student
@end

@implementation GoodStudent
- (void)playFootball
{
    NSLog(@"%s", __func__);
}
- (void)playBasketball
{
    NSLog(@"%s", __func__);
}
@end

• 3)OC不能继承多个类(单继承)但是能够遵守多个协议。继承(:),遵守协议(< >)

#import "SportProtocol.h"
#import "StudyProtocol.h"

@interface Student : NSObject <SportProtocol, StudyProtocol>

@end

• 4)协议可以遵守协议,一个协议遵守了另一个协议,就可以拥有另一份协议中的方法声明

@protocol A
-(void)methodA;
@end

@protocol B <A>
-(void)methodB;
@end
@interface Student : NSObject <B>
-(void)methodA; // 同时拥有A/B协议中的方法声明
-(void)methodB;
@end

---

5.基协议

• NSObject是一个基类，最根本最基本的类，任何其他类最终都要继承它
• 还有名字也叫NSObject的协议，它是一个基协议，最根本最基本的协议
• NSObject协议中声明很多最基本的方法
  • description
  • retain
  • release
• 建议每个新的协议都要遵守NSObject协议

@protocol SportProtocol <NSObject> // 基协议

- (void)playFootball;
- (void)playBasketball;
@end

---

6.@required和@optional关键字

• 协议中有2个关键字可以控制方法是否要实现(默认是@required，在大多数情况下，用途在于程序员之间的交流)
  • @required：这个方法必须要实现（若不实现，编译器会发出警告）
  • @optional：这个方法不一定要实现

@protocol SportProtocol <NSObject>

@required // 如果遵守协议的类不实现会报警告
- (void)playFootball;
@optional // 如果遵守协议的类不实现不会报警告
- (void)playBasketball;
@end

代理设计模式

• 代理设计模式的场合:
  • 1.当对象A发生了一些行为,想告知对象B(让对象B成为对象A的代理对象)
  • 2.对象B想监听对象A的一些行为(让对象B成为对象A的代理对象)
  • 3.当对象A无法处理某些行为的时候,想让对象B帮忙处理(让对象B成为对象A的代理对象)

协议的编写规范

• 一般情况下,当前协议属于谁,我们就定义到谁的头文件中
• 协议名称一般以它属于的类名开头,后面跟上Protocol或者Delegate
• 协议中的方法名称一般以协议的名称protocol之前的作为开头
• 一般情况下协议中的方法会将触发协议的对象传递出去
• 一般情况下一个类中的代理属于的名称叫做 delegate
• 当某一个类要成为另外一个类的代理时候,一般情况下再.h文件中用@protocl 协议名称,告诉编译器这是一个协议. 在.m文件中用#import导入头文件.