黑马程序员——Objective-C语言知识点总结之内存管理、Block、Protocol

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！——

内存管理

基本原理

进行内存管理原因

本质原因：因为其它局部变量主要存放于栈中，而对象存储于堆中，当代码块结束时这个代码块中涉及的所有局部变量会被回收，指向对象的指针也被回收，此时对象已经没有指针指向，但依然存在于内存中，造成内存泄露。

管理范围：任何继承NSObject的对象，对其他的基本数据类型无效。

对象的基本结构

每个OC对象都有自己的引用计数器，是一个整数表示对象被引用的次数，即现在有多少东西在使用这个对象。

对象刚被创建时，默认计数器值为1，当计数器的值变为0时，则对象销毁。

在每个OC对象内部，都专门有4个字节的存储空间来存储引用计数器。

引用计数器的作用

判断对象要不要回收的唯一依据就是计数器是否为0，若不为0则存在。

方法的基本使用

给对象发送消息，进行相应的计数器操作。

1> Retain消息：使计数器+1，改方法返回对象本身
2> Release消息：使计数器-1（并不代表释放对象）
3> retainCount消息：获得对象当前的引用计数器值
4> dealloc
* 当一个对象要被回收的时候，就会调用
* 一定要调用[super dealloc]，这句调用要放在最后面

对象的销毁

1> 当一个对象的引用计数器为0时，那么它将被销毁，其占用的内存被系统回收

2> 当对象被销毁时，系统会自动向对象发送一条dealloc消息，一般会重写dealloc方法，在这里释放相关的资源，dealloc就像是对象的“临终遗言”。一旦重写了dealloc方法就必须调用[super dealloc]，并且放在代码块的最后调用（不能直接调用dealloc方法）

// 当一个Person对象被回收的时候，就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");

    // super的dealloc一定要调用，而且放在最后面
    [super dealloc];
}
@end

3> 一旦对象被回收了，那么他所占据的存储空间就不再可用，坚持使用会导致程序崩溃（野指针错误）

概念

1> 僵尸对象 ：所占用内存已经被回收的对象，僵尸对象不能再使用

2> 野指针 ：指向僵尸对象（不可用内存）的指针，给野指针发送消息会报错（EXC_BAD_ACCESS）

3> 空指针 ：没有指向任何东西的指针（存储的东西是nil、NULL、0），给空指针发送消息不会报错

例：

1、对象刚被创建时，计数器为1，发送retainCount消息：获得对象当前的引用计数器值

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

    NSUInteger c = [p retainCount];

    NSLog(@"计数器：%ld", c);

运行结果：
2015-04-28 07:04:50.968 01-引用计数器的基本操作[560:16419] 计数器：1

2、

    Person *p = [[Person alloc] init];
    NSUInteger c = [p retainCount];
    NSLog(@"计数器：%ld", c);

    // retain方法返回的是对象本身，计数器加1
    [p retain];
    NSUInteger c1 = [p retainCount];
    NSLog(@"计数器：%ld", c1); // 2

    // release方法，计数器减1
    [p release];
    NSUInteger c2 = [p retainCount];
    NSLog(@"计数器：%ld", c2); // 1

    [p release]; // 计数器为0，野指针，指向僵尸对象
    // 变为僵尸对象，此时p指针仍存在（野指针），仍存有地址，所以仍有指向，只不过指向僵尸对象
    [p retain]; // 因为已经是野指针，没有指向的对象，retain操作无效

    //p.age = 10;

    // 给已经释放的对象发送了一条-setAge:消息：
    // 报错信息：-[Person setAge:]: message sent to deallocated instance 0x100109a10

注意：

不能使用[p retaion]让僵尸对象起死复生。

内存管理原则

原则

1、只要还有人在使用某个对象，那么这个对象就不会被回收

只要你想使用这个对象，那么就应该让这个对象的引用计数器+1；
当你不想使用这个对象时，应该让对象的引用计数器-1；

2、谁创建，谁release

1> 如果你通过alloc,new,copy来创建了一个对象，那么你就必须调用release或者autorelease方法
2> 不是你创建的就不用你去负责

3、谁retain，谁release

只要你调用了retain，无论这个对象时如何生成的，你都要调用release

例：

#import "Person.h"

@implementation Person
- (void)setBook:(Book *)book
{
    // 想使用Book这个对象，调用一次retain
    _book = [book retain];
}

- (Book *)book
{
    return _book;
}

- (void)dealloc
{
    // 不想使用这个对象时，应该让对象的引用计数器-1；
    // 谁return谁release
    [_book release];
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Book.h"

int main()
{
    // b-1
    Book *b = [[Book alloc] init];
    // p-1
    Person *p1 = [[Person alloc] init];

    //p1想占用b这本书
    // b-2
    [p1 setBook:b];

    // 谁创建谁release
    // p-0
    // b-1
    [p1 release];
    p1 = nil;

    // b-0
    // 谁创建谁release
    [b release];
    b = nil;
    return 0;
}

4、总结

有始有终，有加就应该有减。曾经让某个对象计数器加1，就应该让其在最后-1.

内存管理代码规范

1、只要调用了alloc，就必须有release(autorelease)

2、Set方法的代码规范

1）基本数据类型：直接复制

-（void）setAge:(int)age
{
_age=age;

}
2）OC对象类型

-（void）setCar:(Car *)car
{
    //1.先判断是不是新传进来的对象
    If(car!=_car)
    {
        //2 对旧对象做一次release
        [_car release];//若没有旧对象，则没有影响
        //3.对新对象做一次retain
        _car=[car retain];
    }
}

（三）dealloc方法的代码规范

// 1 一定要[super dealloc]，而且要放到最后
// 2 对self（当前）所拥有的的其他对象做一次release操作
-（void）dealloc
{
    [_car release];
    [super dealloc];
}

@property的参数

set方法内存管理相关参数

1> Retain:对对象release旧值，retain新值（适用于OC对象类型）
2> Assign:直接赋值（默认，适用于非oc对象类型）
3> Copy:release旧值，copy新值

是否要生成set方法（若为只读属性，则不生成）

1> Readonly:只读，只会生成getter的声明和实现
2> Readwrite:默认的，同时生成setter和getter的声明和实现

多线程管理（苹果在一定程度上屏蔽了多线程操作）

1> Nonatomic:高性能，一般使用这个
2> Atomic:低性能

set和get方法的名称

修改set和get方法的名称，主要用于BOOL类型。因为返回BOOL类型的方法名一般以is开头，修改名称一般用在BOOL类型中的getter 方法名

@propery(setter=setAbc,getter=isRich) BOOL rich;
BOOL b=p.isRich;// 调用

例：

// 高性能,非oc对象，直接赋值,同时生成setter和getter的声明和实现
@property (nonatomic, assign, readwrite) int weight;
// 同时生成setter和getter的声明和实现，非oc对象，直接赋值
@property (readwrite, assign) int height; 
// 高性能,非oc对象，直接赋值
@property (nonatomic, assign) int age;
// 对对象release旧值，retain新值
@property (retain) NSString *name;
@end

内存管理中的循环引用问题以及解决

案例：每个人有一张身份证，每张身份证对应一个人，不能使用#import的方式相互包含，这就形成了循环引用。
新的关键字：@class 类名；——解决循环引用问题，提高性能

@class关键字

@class仅仅告诉编译器，在进行编译的时候把后面的名字作为一个类来处理。
1、@class的作用

声明一个类，告诉编译器某个名称是一个类
例：

@class Person; //仅仅告诉编译器，Person是一个类

2、开发中引用一个类的规范

1> 在.h文件中使用@class来声明类
2> 在.m文件中真正要使用到的时候，使用#import来包含类中的所有东西

Person.h

#import <Foundation/Foundation.h>

// @class仅仅是告诉编译器，Card是一个类／在.m文件中用到此类时，需要在 .m文件引入#import "Card.h"
@class Card;

@interface Person : NSObject

@property (nonatomic, retain) Card *card;

@end

Person.m

#import "Person.h"
#import "Card.h" // 使用#import来包含类中的所有东西

@implementation Person

- (void)dealloc  //当p-0 时调用此方法
{
    NSLog(@"Person被销毁了");
    [_card release];

    [super dealloc];
}

@end

3> 两端循环引用的解决方法
一端使用retain,一端使用assign（使用assign的在dealloc中也不用再release）
例：
Person.h

@property (nonatomic, retain) Card *card;

Card.h

@property (nonatomic, assign) Person *person; 
//使用assign是为了解决两端循环引用，对应的.m文件中不需要[_person release]

3、@class和＃import的区别

两种方式的区别:

1> #import方式会包含被引用类的所有信息，包括被引用类的变量和方法；@class方式只是告诉编译器在A.h文件中 B *b 只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中信息

2>使用@class方式由于只需要知道被引用类（B类）的名称就可以了，而在实现类由于要用到被引用类中的实体变量和方法，所以在.m文件中需要使用#import来包含被引用类的头文件

3> 如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来 讲，使用@class方式就不会出现这种问题了

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

由上可知，@class是放在.h中的，只是在引用一个类，将这个被引用类作为一个类型，在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。

Autorelease

基本用法

1> 会将对象放到一个自动释放池中

2> 当自动释放池被销毁时，会对池子里的所有对象做一次release

3> 会返回对象本身

4> 调用完autorelease方法后，对象的计数器不受影响（销毁时影响）

好处

1> 不需要再关心对象释放的时间

2> 不需要再关心什么时候调用release

使用注意

1> 占用内存较大的对象，不要随便使用autorelease，应该使用release来精确控制
2> 占用内存较小的对象使用autorelease，没有太大的影响

错误写法

1> 连续调用多次autorelease，释放池销毁时执行两次release(-1吗？)

@autoreleasepool
 {
    Person *p = [[[[Person alloc] init] autorelease] autorelease];
 }

2> Alloc之后调用了autorelease，之后又调用了release

@autoreleasepool
 {
    // 1
    Person *p = [[[Person alloc] init] autorelease];

    // 0
    [p release];
 }

自动释放池

1> 在ios程序运行过程中，会创建无数个池子，这些池子都是以栈结构（先进后出）存在的

2> 当一个对象调用autorelease时，会将这个对象放到位于栈顶的释放池中

自动释放池的创建方式

1> ios 5.0以前的创建方式

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

[pool  release];//[pool drain];用于mac 

2> Ios5.0以后

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

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

例：

#import <Foundation/Foundation.h>
#import Person.h
int main()
{
    @autoreleasepool
    {
        // { 开始代表创建了释放池
        Person *p = [[[Person alloc] init] autorelease];
        p.age = 1;

        @autoreleasepool//可以创建无数多个释放池，释放池中可以嵌套
        {
            // 1
            Person *p2 = [[[Person alloc] init] autorelease];
            //调用autoreleasepool后只是把p2放池中，计数器不变；
            p2.age = 2;
        }

        Person *p3 = [[[Person alloc] init] autorelease];
        p3.age = 3;

    } //  结束代表销毁释放池，此行过后person销毁
}

运行结果：
2015-04-28 18:20:54.952 08-autorelease[1128:63137] Person—dealloc2
2015-04-28 18:20:54.953 08-autorelease[1128:63137] Person—dealloc3
2015-04-28 18:20:54.953 08-autorelease[1128:63137] Person—dealloc1

Autorelease注意

1> 系统自带的方法中，如果不包含alloc 、new、 copy等，则这些方法返回的对象都是autorelease的，如[NSDate date]；

NSString *str = @"123123";
//不需要release  

NSString *str2 = [NSString stringWithFormat:@"age is %d", 10];
//不需要release 

NSNumber *num = [[NSNumber alloc] initWithInt:10];
//需要release
[num release];

NSNumber *num2 = [NSNumber numberWithInt:100];
//不需要release

2> 开发中经常会写一些类方法来快速创建一个autorelease对象，创建对象时不要直接使用类名，而是使用self

+ (id)person
{
    return [[[self alloc] init] autorelease];//尽量使用self，满足满足子类调用父类方法时返回子类对象

        p2.money = 100;
}

所以

GoodPerson *p2 = [GoodPerson personWithAge:10];

p2.money = 100;

// 满足子类调用父类方法时返回子类对象

ARC内存管理机制

ARC的判断准则

只要没有强指针指向对象，对象就会被释放

指针分类

1> 强指针：默认的情况下，所有的指针都是强指针，关键字__strong

2> 弱指针：__weak关键字修饰的指针

声明一个弱指针如下：

 __weak Person *p;

ARC中，只要弱指针指向的对象不在了，就直接把弱指针做清空操作

_ _weak Person *p=[[Person alloc]  init];

不合理，对象一创建出来就被释放掉，对象释放掉后，ARC把指针自动清零

例：

Person *p = [[Person alloc] init];
__weak Person *p2 = p;
p = nil;//对象在此时销毁，因为ARC判断标准为没有强指针指向对象
p2 = nil;//弱指针指向的对象销毁后，弱指针自动清空（清空所存储的地址，代表没有指向，不是销毁）

注：

1、ARC中在property处不再使用retain,而是使用strong，在dealloc中不需要再[super dealloc]

@property（nonatomic,strong）Dog *dog;
// 意味着生成的成员变量_dog是一个强指针，相当于以前的retain

如果换成是弱指针，则换成weak，不需要加__

ARC的特点总结：

1> 不允许调用release，retain，retainCount

2>不允许重写dealloc,但是不允许调用[super dealloc]

3>@property的参数：
Strong:相当于原来的retain（适用于OC对象类型），成员变量是强指针
Weak:相当于原来的assign,(适用于oc对象类型)，成员变量是弱指针
Assign：适用于非OC对象类型（基础类型）

4>补充

1) 让程序兼容ARC和非ARC部分
转变为非ARC -fno-objc-arc;
转变为ARC的， -f-objc-arc ;

2) ARC也需要考虑循环引用问题：一端使用strong，另一端使用weak。

Person.h

#import <Foundation/Foundation.h>

@class Dog;

@interface Person : NSObject

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

@end

Dog.h

#import <Foundation/Foundation.h>

@class Person;

@interface Dog : NSObject

@property (nonatomic, weak) Person *person;// 用weak

@end

非ARC：1端用retain，另1端用assign

3) 提示：字符串是特殊的对象，但不需要使用release手动释放，这种字符串对象默认就是autorelease的，不用额外的去管内存。

block

1> Block封装了一段代码,可以在任何时候执行

2> Block可以作为函数参数或者函数的返回值，而其本身又可以带输入参数或返回值

苹果官方建议尽量多用block。在多线程、异步任务、集合遍历、集合排序、动画转场用的很多
block要掌握的东西

定义block变量

int (^MySum)(int, int) = ^(int a, int b) {
    return a+b;
};
// 定义了一个叫MySum的blocks对象，它带有两个int参数，返回int。等式右边就是blocks的具体实现

封装代码

 ^(int a, int b) {
    return a - b;
 };

 ^() {
    NSLog(@"----------");
 };

 ^ {
    NSLog(@"----------");
 };

访问外面变量

1> block内部可以访问外面的变量
2> 默认情况下，block内部不能修改外面的局部变量
3> 给局部变量加上__block关键字，这个局部变量就可以在block内部修改

例：

int a = 10;
    __block int b = 20;

    void (^block)();

    block = ^{
        // block内部可以访问外面的变量
        //NSLog(@"a = %d", a);

        // 默认情况下，block内部不能修改外面的局部变量
        // a = 20;

        // 给局部变量加上__block关键字，这个局部变量就可以在block内部修改
        b = 25;
    };

利用typedef定义block类型

typedef int (^MyBlock)(int, int);

 // 利用MyBlock这种类型来定义block变量
 MyBlock block;
 MyBlock b1, b2;

Protocol

简单来说就是一系列方法的列表，其中声明的方法可以被任何类实现。这种模式一般称为代理(delegation)模式

在iOS和OS X开发中，Apple采用了大量的代理模式来实现MVC中View(UI控件)和Controller(控制器)的解耦

定义协议

格式：@protocol 名称 <协议名>
例：@protocol MyProtocol

关键字

1> @required要求实现，不实现就会发出警告，默认
2> @optional 不要求实现

#import <Foundation/Foundation.h>

// 定义了一个名叫MyProtocol的协议
@protocol MyProtocol <NSObject>

//默认为required
- (void)test4;

// 必须实现
@required
- (void)test;
- (void)test2;

// 不要求实现
@optional
- (void)test3;

@end

注意：

1> 只要一个类遵守了某一份协议，就能拥有这份协议中的所有方法声明

// : 继承父类
// <> 遵守协议
@interface Person : NSObject <MyProtocol3, MyProtocol2> // 遵守多个协议，加,

2>
创建一个普通OC类，在h文件中引入包含Protocol的h文件(或者用@protocol声明这个协议,作用跟@class类似, 建议用这种方式)

// #import "MyBtnDelegate.h"
@protocol MyBtnDelegate;
@interface MyController : NSObject<MyBtnDelegate>
@end

3> 创建对象

    // 要求obj1保存的对象必须是遵守是MyProtocol这个协议,并且继承了Person
    NSObject<MyProtocol> *obj1 = [[Person alloc] init];

   // 要求obj2，保存的对象必须遵守MyProtocol1、并且继承了Person
    Person<MyProtocol1> *obj2 = [[Person alloc] init];

使用场景

1> OC的Protocol和Java的接口很类似,如果一些类之间没有继承关系,但是又具备某些相同的行为,可使用Protocol来描述它们的关系,不同的类，可以实现同一个Protocol

2>最常用的就是委托代理模式，Cocoa框架中大量采用了这种模式实现数据和UI的分离。例如UIView产生的所有事件的处理，都是通过委托的方式交给UIViewController完成。根据约定，框架中后缀为Delegate的都是Protocol，如UIApplicationDelegate，UITableViewDelegate等