黑马程序员——OC语言学习——ARC机制、block代码块、protocol协议、protocol协议的应用

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

一、 ARC机制

ARC机制是自动管理内存的方法，让系统自动帮我们管理内存。也就是系统帮我们写那些内存管理代码,如autorelease和自动释放池。苹果真的很体贴。相应的也涉及到一些内存管理的参数。

ARC的判断准则：只要没有强指针指向对象，就会释放对象。

那什么是强指正，弱指针呢？

默认情况下，我们定义的指针都是强指针，参数为：__strong

弱指针，参数为：__weak

如：

强指针：

          int *num   或者把参数加上 __strong

弱指针：

         __weak int *num;

为了与手动管理内存区分开，ARC做了一些限制，不给我们在使用ARC的时候，再使用手动管理内存的方法和参数。

如：

 1> 不允许调用release、retain、retainCount
 2> 允许重写dealloc，但是不允许调用[super dealloc]
 3> @property的参数
  * strong ：成员变量是强指针（适用于OC对象类型）
  * weak ：成员变量是弱指针（适用于OC对象类型）
  * assign : 适用于非OC对象类型
 4> 以前的retain改为用strong

我们将昨天的代码用ARC机制重写一下。

//-----------------------------车类
@class Person;
@interface Car : NSObject
@property (nonatomic, assign)Person *owner;
@end
@implementation Car
// 当一个Car对象被回收的时候，自动调用这个方法
- (void)dealloc
{
    NSLog(@"Car对象被回收");
    
    // super的dealloc放在最后面
    [super dealloc];
}
@end

//-------------------------------人类
@interface Person : NSObject
@property (nonatomic, strong)Car *car;
@end
@implementation Person
// 当一个Person对象被回收的时候，自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");
    // super的dealloc放在最后面
    [super dealloc];
}
@end

int main()
{
        Car *c = [[Car alloc]init];
        Person *p = [[Person alloc]init];
        p.car = c;
    
    return 0;
}

很简单，一句话：一方不用内存管理，就是将一方的retain换成weak，由weak来替换手动管理下的assign。

二、 OC代码块——block

block就是封装一段代码，随时供我们调用，相较于函数，优点是：不需要在程序运行前确定，可以保存程序运行时的代码，供我们使用。

苹果官方建议我们尽量使用block

block在很大程度上和函数很像，比如：

     1.可以保存代码
     2.有返回值
     3.有形参
     4.调用方式一样

block的标志：^

例如我们用函数来实现打印一条横线是：

void line()

{ 

          NSLog(@"-------------------")

}

              用block来实现打印一条横线：

void (^myblock)() = ^(){
        NSLog(@"----------------");
    };

这是没有参数的block

有参数的block

int (^sumblock)(int, int) = ^(int a, int b){
        return a + b;
    };

我们可以直接调用sumblock(2,3) 来实现2+3求和的方法。

int (^sumblock)(int, int) ：是定义一个block变量，接收参数为两个int型数据

int ：返回值类型

sumblock：是block变量名，用来调用block

^：是block类型的标志

^(int a, int b){
        return a + b;
    }; 这就要用block封装的代码块。 a, b 是代码块中所要传入的数据类型。

block内部可以访问外面的变量  如： NSLog(@"a = %d", a);
        
但是默认情况下，block内部不能修改外面的局部变量        如这样就是错误的： a = 20;
        
 如果要在block中修改局部变量的值，需要在局部变量前加上__block关键字，这个局部变量就可以在block内部修改 如：__block a = 20;

每次使用block都要定义，这样会显得很繁琐，我们可以利用预处理指令 typedef 来预先定义。

如：上面定义求和的代码块，所需传入两个int型变量。

我们可以定义： typedef int (^MyBlock)(int, int);

这样就可以利用MyBlock 来存储代码块，前提都是传入两个int型数据的代码块

如： MyBlock sumBlock;
    sumBlock = ^(int a, int b) {
        return a + b;
    };
    
    MyBlock minusBlock = ^(int a, int b) {
        return a - b;
    };
    
    
    MyBlock multiplyBlock = ^(int a, int b) {
        return a * b;
    };

三、 协议——protocol

1.协议的定义

 @protocol 协议名称 <NSObject>

  // 方法声明列表....

 @end

 2.如何遵守协议

 1> 类遵守协议

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

 @end

 2> 协议遵守协议

 @protocol 协议名称 <其他协议名称1, 其他协议名称2>

 @end

 3.协议中方法声明的关键字

 1> @required (默认)

   要求实现，如果没有实现，会发出警告

 2> @optional

   不要求实现，怎样不会有警告

 4.定义一个变量的时候，限制这个变量保存的对象遵守某个协议

 类名<协议名称> *变量名;

 id<协议名称> 变量名;

 NSObject<MyProtocol> *obj;

 id<MyProtocol> obj2;

 如果没有遵守对应的协议，编译器会警告

 5.@property中声明的属性也可用做一个遵守协议的限制

 @property (nonatomic, strong) 类名<协议名称> *属性名;

 @property (nonatomic, strong) id<协议名称> 属性名;

 @property (nonatomic, strong) Dog<MyProtocol> *dog;

 @property (nonatomic, strong) id<MyProtocol> dog2;

 6.协议可用定义在单独.h文件中，也可用定义在某个类中

 1> 如果这个协议只用在某个类中，应该把协议定义在该类中

 2> 如果这个协议用在很多类中，就应该定义在单独文件中

 7.分类可用定义在单独.h和.m文件中，也可用定义在原来类中

 1> 一般情况下，都是定义在单独文件

 2> 定义在原来类中的分类，只要求能看懂语法

四、 协议的应用——代理模式

比如我想去电影院询问电影票价格和剩余票数

我自己不去，想通过另一个人或者物帮我办，这个东西就叫做代理。

协议在代理中的应用

给代理规定方法，按照我的要求办事。只要是遵守这个协议的都可以充当我的代理。一不要为了更换代理而使代理方法重写。

用代码实现就是:

#import <Foundation/Foundation.h>

//-----------------------------------代理买票的协议
// 声明一些代理方法 -- 票数，票价
@protocol TicketDelegate <NSObject>

// 返回票价
- (double) ticketPrice;

// 还剩多少张票
- (int) leftTicketsNumber;
@end

//------------------------------------人，需要代理买票询问的人
@interface Person : NSObject

- (void) buyTicket; // 人的买票方法

// 拥有一个代理属性，但定义的对象属性必须遵守TicketDelegate协议
// 代理的类名随便，类型为id ,可以接受任何类型的对象。
@property (nonatomic, strong) id<TicketDelegate> delegate; // 定义的这样变量，说明遵守协议
@end

@implementation Person

// 买电影票
- (void)buyTicket
{
    // 叫代理去帮自己买票（询问一下票价、询问一下票的剩余张数）
    double price = [_delegate ticketPrice];
    int number =  [_delegate leftTicketsNumber];
    
    NSLog(@"通过代理得知，票价=%.2f，还剩%d张票", price, number);
}
@end

//-------------------------------------代理
@interface Agent : NSObject <TicketDelegate> // 遵守了代理买票协议
@end
@implementation Agent  // 实现协议中的代理方法

// 剩余的票数
- (int)leftTicketsNumber
{
    return 10;
}

// 每一张票多少钱
- (double)ticketPrice
{
    return 100;
}
@end

int main()
{
    
    // 买票人
    Person *p = [[Person alloc] init];
    // 代理
    Agent *a = [[Agent alloc] init];
    
    // 设置人的代理
    p.delegate = a;
    
    // 人打算看电影
    [p buyTicket];

    return 0;
}