Objective-C 学习第七天

一、

自动释放池的原理
存入到自动释放池中的对象，在自动释放池销毁的时候，会自动调用储存在该自动释放池中的所有对象的release方法.
可以解决的问题:
将创建的对象，存入到自动释放池之中，就不再需要手动的release这个对象了，因为池子销毁的时候，就会自动的调用池中所有的对象release.
如何创建自动释放池
@autoreleasepool{

}
这对大括号代表这个自动释放池的范围
如何将对象存储到这个自动释放池中
在自动释放池之中调用对象的autoreleasepool方法，就会将这个对象存入到当前自动释放池之中，这个autorelease方法返回的是对象本身,所以可以这么写
@autoreleasepool{
Person *p1 = [[[Person alloc] init] autorelease];
}
这个时候，当这个自动释放池执行完毕之后，就会立即为这个自动释放池中的对象发送一条release消息.

autorelease好处:
创建对象，调用对象的autorelease方法，将这个对象存入当前的自动释放池之中，我们不需要再去release，因为自动释放池销毁的时候，就会自动的调用池中所有对象的release.
使用注意
1). 只有在自动释放池中调用了对象的autorelease方法，这个对象才会被存储到这个自动释放池中,如果只是将创建对象的代码写在自动释放池中，而没有调用对象的autorelease方法，是不会将这个对象存储到这个自动释放池之中的.
2). 对象的创建可以在自动释放池的外面，在自动释放池中，调用对象的autorelease方法，就可以将这个对象存储到这个自动释放池中.
3). 如果对象的autorelease方法的调用放在自动释放池的外面，是无法将其存储到这个自动释放池之中的，autorelease的调用只有放在自动释放池之中，才可以将其存储到自动释放池之中，对象的创建可以在外面.
4). 当自动释放池结束的时候，仅仅是对存储在自动释放池中的对象发送一条release消息，而不是销毁对象.
5). 如果在自动释放池中，调用同一个对象的autorelease方法多次，就会将这个对象存储多次到这个自动释放池中，在自动释放池结束的时候，就会为对象发送多次release消息. 所以，一个自动释放池中，只autorelease一次，只讲这个对象放一次，否则就会出现野指针错误.
6). 如果在自动释放池中，调用了存储到自动释放池中的对象的release方法，在自动释放池结束的时候，还会再调用对象的release方法，这个时候也有可能会造成野指针操作.
7). 将对象存储到自动释放池，并不会使对象的引用计数器+1,其好处就是创建对象存储早自动释放池，就不要再写release方法了.
8). 自动释放池可以嵌套.调用对象的autorelease方法，只会讲对象加入到自动释放池中，只有在当前自动释放池结束的时候才会向对象发送release消息.
autorelease规范
1). 创建对象，将对象存储到自动释放池中，就不需要再去手动的release
2). 类方法的第一个规范:
一般情况下，要求提供与自定义构造方法相同功能的类方法，这样可以快速的创建一个对象.
3). 类方法的第二个规范:
一般情况下，会为我们的类写一个类方法，用来让外界调用类方法类快速的得到一个对象.
规范: 使用类方法创建的对象，要求这个对象已经被autorelease过了.

提供一个类方法来快速的得到一个对象.
规范:
a. 这个类方法已类名开头，如果没有参数就直接是类名，如果有参数就是withXX:
b. 使用类方法得到的对象，要求这个对象已经被autorelease过了
```
     + (instancetype)person{
         return [[[selft alloc] init] autorelease];
     }
 
 这样我们直接调用类方法，就可以得到一个已经被autorelease过的对象.
 
     @autoreleasepoop{
         Person *p1 = [Person person];
         // 这个p1对象已经被autorelease过了，不需要再调用autorelease方法
         // 这个对象被存储到当前的自动释放池中
     }// 当自动释放池结束，就会为存储在其中的p1对象发送release消息.
```

二、ARC

什么是ARC
Automatic Reference Counting 自动引用计数，即ARC
顾名思义: 系统自动的帮助我们去计算对象的应用计数器的值.

在程序中使用ARC非常简单，只需要像往常一样编写代码.
只不过永远不要写retain、release、autorelease这三个关键字就好，这个ARC最基本的原则.
当ARC开启时，编译器会自动的在合适的地方插入retain、release、autorelease代码，编译器自动为对象做引用计数，而作为开发者，完全不需要担心编译器会做错.

需要特别注意: ARC是编译器机制，在编译器编译代码的时候，会在适当的位置加入retain、release、autorelease代码.
在ARC机制下，对象何时被释放: 只要没有强指针指向这个对象，这个对象就会立即回收.
强指针与弱指针
强指针: 默认情况下，我们声明一个指针，这个指针就是强指针，我们也可以使用__strong来显示的声明这是一个强指针.
```
Person *p1; 这是一个强指针，指针默认情况下都是一个强指针.
__strong Person *p2; 这也是一个强指针，使用__strong来显示声明的强指针.
```
弱指针: 使用__weak标识的指针就叫做弱指针.

无论强指针还是弱指针，都是指针，都可以用来存储地址，都可以通过这个指针访问对象的成员，唯一的区别就是在ARC模式下，他们用来作为回收对象的基准.
确认程序是否开启ARC机制
1). 默认情况下，Xcode开启ARC机制
2). ARC机制下，不允许调用retain/release/retainCount/autorelease方法
3). 在dealloc中不允许[super dealloc]

演示第一个ARC案例

    int main(int argc, const char *argv[]){
        @autoreleasepool{
            Person *p1 = [Person new];
        }// 当执行到这里，p1指针被回收
        return 0;
    }

ARC下的单个对象的内存管理
在ARC机制下: 当没有任何一个强指针指向它的时候，就会被立即回收.
1). 当指向对象的所有的强指针被回收的时候，对象就会被立即回收

    int main(int argc, const char *argv[]){
        @autoreleasepool{
            Person *p1 = [Person new];
            Person *p2 = p1;
        }// 当执行到这里，p1指针被回收,p2指针也被回收
        return 0;
    }

2). 将所有指向对象的强指针赋值为nil的时候，对象就会被立即回收

    int main(int argc, const char *argv[]){
        @autoreleasepool{
            Person *p1 = [Person new];
            p1 = nil;
        }// 当执行到这里，p1指针被回收,p2指针也被回收
        return 0;
    }

强指针与弱指针
1). 强指针与弱指针的声明
默认情况下，所有的指针都是强类型的.
Person *p1 = [[Person alloc] init];
p1指针是强类型的，因为默认情况下指针都是强类型的.
不过我们可以使用__strong来显示的标识指针是强类型指针.
__strong Person *p2 = [Person new];
这时候p2指针是强类型的，其实写不写__strong都是强类型指针.
指针类型也可以是弱指针类型.
使用__weak标识指针的类型是弱类型指针.
__weak Person *p3 = p2;
这时候，p3指针是1个弱类型的指针，p3弱指针也指向p2强指针指向的对象.
在操作对象的时候，通过强指针或者弱指针都可以操作，没有任何区别

2). ARC模式下的对象回收标准
ARC机制下释放对象的标准，没有任何强指针指向对象的时候，对象就会被释放.如果这个时候有弱指针指向，也会被释放。
```
    int main(int argc, const char *argv[]){
        @autoreleasepool{
            __strong Person *p1 = [[Person alloc] init];
            __weak Person *p2 = p1;
            p1 = nil;// 当执行到这里，p1指针被回收,p2指针也被回收
        }
        return 0;
    }
```
3). 最重要的一点:不能创建对象用1个弱指针存储这个对象的指针，这样的话，刚创建出来的对象，就没有任何强指针指向，创建处理就会被回收.
```
    int main(int argc, const char *argv[]){
        @autoreleasepool{
            // 创建一个对象，刚创建出来就会被回收
            __weak Person *p2 = [[Person alloc] init];      
        }
        return 0;
    }
```
4). 在ARC的机制下，原来指向这个对象的弱指针，会被自动设置为nil.
在ARC机制下，@property参数就不能使用retain，因为retain代表生成的setter方法是MRC的标准的内存管理代码，而我们在ARC机制下不需要那些代码.
所以在ARC机制下的setter方法，什么都不需要做.
ARC机制下，关注的重点,当一个类的属性是一个OC对象的时候，这个属性应该声明为强类型的.
1). 控制@property生成的私有属性，是一个强类型还是弱类型.
使用参数strong和weak
@property(nonatomic,strong)Car *car;
代表生成的_car是强类型
@property(nonatomic,weak)Car *car;
代表生成的_car是弱类型
如果不写，默认是strong
使用建议
1). 在ARC机制下，如果属性的类型是OC对象类型，使用strong
2). 在ARC机制下，如果属性的类型不是OC对象类型，使用assign
3). strong和weak都是应用在属性类型是OC对象的时候
4). 在ARC机制下，将MRC下的retain换为strong
循环引用
解决方案: 其中一方使用weak，另一方使用strong

三、

遇到的问题--MRC与ARC兼容
点击项目->Target->Build Phases->Compile Sources->选中要使用MRC编译的类，双击->填写
```
    -fno-objc-arc
```
使用命令-fno-objc-arc
MRC转换为ARC
Edit-> Convert->To Object-C ARC...->选中要转成ARC的程序选中，点击Check->Next->Save.
分类(类别/类目)--category
默认情况一个类独占一个模块，这个时候将所有的成员都写在这个模块中，很难管理。将功能相似的方法定义在同一个模块中，这样的好处，方便维护和管理。
1). 顾名思义: 把类分开，将一个类分为多个模块
2). 如何为一个类添加分类: Target->New File->Objective-C File->Next,
```
    File: itcast
    File Type: Category
    Class: Student(选择要分的类)
```
Next->Create.
3). 会生成一个.h和一个.m模块
a. 模块的文件名是本类名+分类名.h，本类名+分类名.m
4). 添加的分类分为声明和实现
@interface 本类名 (分类名)
@end
代表不是新创建一个类，而是对已有的类添加一个分类,小括弧中写上分类的名字,因为一个类可以添加多个分类，为了区分每个类
@implementation 本类名 (分类名)
@end
这是分类的实现
5). 分类的使用
a. 如果要访问分类中定义的成员，就要把分类的头文件引进来.

6). 分类的作用:就是将一个类分为多个模块

7). 注意
a. 分类中只能增加方法，不能增加属性
b. 在分类中可以写@property但是不会自动生成私有属性，也不会自动生成getter/setter的实现，只会生成getter/setter的声明
c. 在分类的方法实现中不可以直接访问本类的私有属性，但是可以调用本类的getter/setter来访问属性
d. 当分类中有和本类同名方法的时候，优先调用分类的方法，哪怕没有引入分类的头文件，如果多个分类中有多个相同的方法，优先调用最后编译的分类

8). 什么时候需要使用分类
当一个类的方法很多很杂的时候，比较臃肿的时候，这个时候就可以使用分类，将功能相似的方法写在同一个模块当中
分类的作用在于可以将我们写的类分为多个模块
为系统自带的类写分类，这就叫做非正式协议.
1). 分类的第一个作用: 分为多个模块，方便管理
2). 分类的第二个作用: 为一个已经存在的类添加方法

Objective-C 学习第七天

你可能感兴趣的:(Objective-C 学习第七天)