黑马程序员- IOS学习笔记-OC ARC、BLOCK、protocol

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

ARC

ARC是编译器特性 编译的时候会检测对象是否需要释放

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

指针分为2种：

1> 强指针： 默认情况下，所有指针都是强指针。__strong;

2> 弱指针： __weak

当两端循环引用的时候，解决方案：

1> ARC

一端用strong，一端用weak

2> 非ARC

一端用retain、，一端用assign

例子：

//
// main.m
// ARC循环引用
//
// Created by yanglei on 14-9-4.
// Copyright (c) 2014年 itcast. All rights reserved.
//

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

/*
    ARC循环引用：
        人有一条狗，狗有一个主人。
    思路：
    一端用strong，一端用weak. 强指针和弱指针
 
    对比：
    非ARC循环引用：
    一端用retain,一端用assign.
 */
int main(int argc, const char * argv[])
{

    @autoreleasepool {
        // 创建一个人和一条狗
        Person *p = [[Person alloc] init];
        Dog *habagou = [[Dog alloc] init];
        // 人有一只哈巴狗
        p.dog = habagou;
        // 哈巴狗狗的主人是p
        habagou.p = p;
       
    }
    return 0;
}

//
// Person.h
// ARC循环引用

#import <Foundation/Foundation.h>
@class Dog;

@interface Person : NSObject
// 创建成员变量_dog，并声明实现setter和getter
@property (nonatomic,strong) Dog *dog;

@end

// Person.m
// ARC循环引用

#import "Person.h"

@implementation Person

- (void)dealloc
{
    NSLog(@"dog被销毁");
}
@end

//
// Dog.h
// ARC循环引用

#import <Foundation/Foundation.h>
@class Person;

@interface Dog : NSObject

// 创建成员变量_p，实现成员变量的setter和getter
@property (nonatomic,weak) Person *p;

@end

//
// Dog.m
// ARC循环引用

#import "Dog.h"

@implementation Dog

- (void)dealloc
{
    NSLog(@"person被释放");
}

@end

Block

1、作用 ： 封装一段代码，可以在任何时候执行。

2、语法：

1> 不带参数：

void (^myBlock)();

2> 带参数：

int (^sumBlock)(int ,int);

@protocol MyProtocol

    // @required 要求实现，不实现就会发出警告

    // @optional 不要求实现

    // 用于程序员之间的交流

@end

3、 block封装代码

^(int a, int b) {

    return a + b;

};  // 注意此处要用分号结尾

^() {

    NSLog(@"这是一段block代码");

};

^ {

    NSLog(@"这是一段block代码");

};

4、 block访问外面变量

* block内部可以访问外面的变量

* 默认情况下，block内部不能修改外面的局部变量

* 给局部变量加上__block关键字，这个局部变量就可以在block内部进行修改

5、 利用typedef定义block类型

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

之后就可以通过MyBlock这种类型来定义block变量

例如：

MyBlock test;  // 单独定义

MyBlock b1,b2; // 多个变量一起定义

b1 = ^(int a, int b) {

    return a - b;

};

MyBlock b3 = ^(int a, int b) { // 定义并实现block

    return a - b;

};

当协议只用在某个类中时，则把协议和类写在一起

如果协议需要多个类来遵守，则需要把协议单独一个文件

练习：

//
// main.m
// Block学习
//
// Created by yanglei on 14-9-4.
// Copyright (c) 2014年 itcast. All rights reserved.
//

#import <Foundation/Foundation.h>
// 函数实现加法运算
int test(int a, int b)
{
    return a + b;
};

// 定义Block为MyBlock类型，简化操作
typedef int (^MyBlock)(int,int);

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        // 利用函数计算两个数的和
        int c = test(10, 13);
        NSLog(@"c is %d",c);
       
        // 定义指向函数的指针和block类似
        int (*p)(int,int) = test;
        p(12,32); // 调用
       
        // 利用block封装代码实现加法运算
        int (^sumBlock)(int,int) = ^(int a, int b){
            return a + b;
        };
        // 调用方法和函数一样
        int d = sumBlock(10,13);
        NSLog(@"d is %d",d);
       
        // 创建一个MyBlock类型的变量
        MyBlock testBlock ;
        // EXC_BAD_ACCESS访问了一块不可用内存,必须要实现block
        //int e = testBlock(10, 17);
       
        testBlock = ^(int a, int b){
            return a + b;
        };
        int e = testBlock(10,17);
        NSLog(@"e is %d",e);
       
    }
    return 0;
}

protocol

     协议： 只能声明方法，并且需要遵守基类协议 。

    定义：

    @protocol 协议名称 <NSObject>

         // 方法声明列表

    @end

    基协议： NSObject是一个基类,基本上其他类都要继承基类。同样系统中也有一个基协议，名字也叫NSObject,有一对<>即<NSObject>，是最基础的协议，建议自定义协议都继承基协议。

   协议属性：

        @required 表示需要声明的方法

        @optional 表示不需要声明的方法

     协议作用：主要用作和程序员之间的交流

    父类遵守了某个协议则子类拥有此协议的所有方法

    如何遵守协议：

   1> 类遵守协议

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

    

    @end

    2> 协议遵守协议

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

    @end

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

        * @required 默认

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

        * @optional

            不要求实现，不会有警告

    

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

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

        id<协议名称> 变量名;

        例如：

        NSObject<MyProtocol> *obj;

        id<MyProtocol> obj2;

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

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

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

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

        例子：

        @property (nonatomic, strong) Person<MyProtocol> *person;

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

//
// main.m
// protocol学习

#import <Foundation/Foundation.h>
#import "Person.h"
#import "MyProtocol.h"
#import "Myprotocol2.h"
/*
 
 
 */
int main(int argc, const char * argv[])
{

    @autoreleasepool {
        // 要求obj遵守Myprotocol2这个协议，Myprotocol遵守了此协议所以Person类也遵守此协议
        NSObject *obj = [[Person alloc] init];
        obj = nil;

        // 没有遵守MyProtocol协议报黄色警告
// NSObject<MyProtocol> *obj2 = [[NSObject alloc] init];
// obj2 = nil;
        //创建Person类的实例并初始化成员变量
        Person *p = [[Person alloc] init];
        [p setAge:22];
       
        // 调用测试方法并输出年龄
        [p test];
       
        // 调用求和方法
        int s = [p sumWithNum1:10 andNum2:p.age];
        NSLog(@"s is %d",s);
    }
    return 0;
}

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