022-block与@protocol-OC笔记

/ 1评 / 0赞

学习目标

1.【掌握】延展Extension

2.【掌握】block类型

3.【掌握】block修改外部变量

4.【理解】block的应用场景

5.【掌握】协议protocol

6.【掌握】@protocol类型限制

7.【理解】代理模式Delegation

一、延展Extension

延展(Extension)是一个特殊的分类，延展没有名字(匿名分类)，而且只能有方法的声明，不能有单独的方法实现，与本类共享一个方法实现。我们可以使用@property生成私有属性和对应的getter、setter方法。所以我们常常将延展写在类的实现文件中，用于私有化类的成员(属性和方法)，仅限本类访问。

//用于类的实现文件中
#import "Person.h"

//定义延展
@interface Person ()

//延展里声明属性和方法
@end

@implementation Person

//实现方法
@end

二、block类型

block是OC中新增的一个数据类型，可以声明block变量来存储一段代码，这段代码可以有参数，也可以有返回值，也可以都没有。并且可以通过这个block变量来执行存储在变量中的代码，同时block变量也可以作为一个参数进行传递。在使用时，我们常常会使用typedef来声明一个block类型的别名，这样就可以把符合特定要求的代码块保存在block变量里作为方法的参数进行传递，还能简写代码。

语法：

返回值类型 (^block变量名)(参数列表) = ^代码段返回值类型(参数列表) {

    代码段;

};

block类型的简单使用

#import <Foundation/Foundation.h>

int main(){
    @autoreleasepool {
        
        //声明无参无返回值的block变量myBlock1
        void (^myBlock1)();
        
        //声明有两个int类型参数int类型返回值的block变量myBlock2
        int (^myBlock2)(int num1, int num2);
        //block变量的参数可以只写参数类型省略参数名
//        int (^myBlock2)(int, int);
        
        //无参数无返回值的代码段赋值给myBlock1
        myBlock1 = ^void() {
            NSLog(@"代码段内容1");
        };
        
        //有两个int类型参数int类型返回值的代码段赋值给myBlock2
        myBlock2 = ^int(int num1, int num2) {
            return num1 +num2;
        };
        
        int (^myBlock3)(int num1,int num2);
        //代码段的返回值类型可以省略，但是最终还是要返回符合要求的数据
        myBlock3 = ^(int num1, int num2) {
            return num1 +num2;
        };
        
        //代码段的返回值类型可以省略，但是最终还是要返回符合要求的数据
        void (^myBlock4)() = ^{
            NSLog(@"代码段内容4");
        };
        
        //使用block变量
        myBlock1();
        int result1 = myBlock2(1,2);
        int result2 = myBlock3(1,2);
        myBlock4();
        
        NSLog(@"result1 = %d",result1);
        NSLog(@"result2 = %d",result2);
    }
    /* 输出
     代码段内容1
     代码段内容4
     result1 = 3
     result2 = 3
     */
    return 0;
}

使用typedef将复杂的block定义简化

#import <Foundation/Foundation.h>

//只能存储符合要求的代码段
typedef void (^MyBlock1)();
typedef int (^MyBlock2)(int num1, int num2);

int main(){
    @autoreleasepool {
        
        MyBlock1 block2 = ^ {
            NSLog(@"无参数无返回值");
        };
        
        MyBlock2 block1 = ^(int num1, int num2) {
            return num1 + num2;
        };
        
        block2();
        int result = block1(1,2);
        NSLog(@"result = %d",result);
        /*
         无参数无返回值
         result = 3
         */
    }
    return 0;
}

三、block访问外部变量

block可以访问外部变量(block外部)，但无法改变外部变量的值。如果想要被修改，需要用__block修饰。

#import <Foundation/Foundation.h>

//只能存储符合要求的代码段
typedef void (^MyBlock)();

int main(){
    @autoreleasepool {
        //使用__block修饰一个变量
        __block int num = 20;
        
        MyBlock sumBlock = ^ {
            NSLog(@"num = %d",++num);//更改被__block修饰的外部变量的值
        };
        
        /*
         num = 21
         */
    }
    return 0;
}

四、block的应用场景

block作为方法的参数，可以将调用者的代码段传递到函数内部去使用

#import <Foundation/Foundation.h>

//只能存储符合要求的代码段
typedef void (^MyBlock)();
//程序员每天发生的事情
void days(void (^myBlock)());
//将每天上班发生的事情写到block
void workDay(int day);

int main(){
    @autoreleasepool {
        //循环传入天数调用函数
        for (int i = 1; i <= 5; i ++) {
            workDay(i);
        }
    }
    return 0;
}

void workDay(int day){
    MyBlock myBlock;
    switch (day) {
        case 1:
            myBlock = ^{
                NSLog(@"看美女......");
            };
            break;
        case 2:
            myBlock = ^{
                NSLog(@"看代码......");
            };
            break;
        case 3:
            myBlock = ^{
                NSLog(@"写代码......");
            };
            break;
        case 4:
            myBlock = ^{
                NSLog(@"测试代码......");
            };
            break;
        case 5:
            myBlock = ^{
                NSLog(@"因美女少离职......");
            };
            break;
        default:
            break;
    }
    //调用函数传入block
    days(myBlock);
}

//程序员每天发生的事情
void days(void (^myBlock)()){
    NSLog(@"起床");
    NSLog(@"吃饭");
    NSLog(@"坐车");
    myBlock();
    NSLog(@"下班");
    NSLog(@"坐车");
    NSLog(@"回家");
    NSLog(@"吃饭");
    NSLog(@"睡觉");
}

block作为方法或函数的返回值，方法执行完毕之后会有一段代码返回给调用者

#import <Foundation/Foundation.h>

typedef void (^ReturnBlock)();

//block作为函数返回值，一般开发中很少用到
ReturnBlock test(){
    return ^{
        NSLog(@"内容");
    };
}
int main(){
    @autoreleasepool {
        //调用函数
        ReturnBlock test1 = test();
    }
    return 0;
}

五、协议protocol

在OC中使用@protocol定义一个协议，遵守此协议的类就拥有了这个协议所有的方法声明。协议跟其他面向对象语言的接口有些类似，只是不一定会实现协议里的方法。

//youProtocol.h文件
#import <Foundation/Foundation.h>

@protocol youProtocol <NSObject>
//被@required修饰，必须实现的方法，不实现编译时也不报错，用于程序员直接的交流
@required
- (void)shout;

//被@optional修饰，可选实现的方法，不实现编译时也不报错，用于程序员直接的交流
@optional
- (void)drive;
@end


//myProtocol.h文件
#import <Foundation/Foundation.h>

@protocol myProtocol <NSObject>
@required
- (void)sayHi;
- (void)song;

@optional
- (void)paly;
- (void)eat;
@end


//Dog.h文件
#import <Foundation/Foundation.h>
#import "myProtocol.h"

@interface Dog : NSObject <myProtocol,youProtocol>

@end


//Dog.m文件
#import "Dog.h"

@implementation Dog
//继承了两个协议，6个方法只实现了3个必须实现的
- (void)sayHi {
    NSLog(@"狗汪汪。。");
}
- (void)song {
    NSLog(@"狗唱。。");
}
- (void)shout {
    NSLog(@"狗叫。。");
}
@end

总结：

1.协议通过<>进行实现，并且只能在类的声明上遵守协议，一个类可以同时遵守多个协议，中间通过逗号分隔。

2.一个协议可以遵守自另一个协议，例如上面myProtocol就遵守自NSObject(基协议)，如果需要遵守多个协议中间使用逗号分隔。

3.如果父类遵守了某个协议，子类继承了父类所有成员，相当于子类也遵守了这个协议，子类不实现也不会警告。

4.协议中不能定义属性，只能声明方法，不要在协议中使用@property定义属性，协议的主要作用是集中声明方法。

5.我们可以通过关键字@required和@optional分别修饰必须实现的方法和可选实现的方法，如果不修饰则默认是@required。

六、@protocol类型限制

要求某个指针保存的是遵守了指定协议的对象，比如id<协议名> obj;，这个obj指针只能指向遵守了“<协议名>”这个协议的对象。之所以要求对象要遵守某个协议，是因为我们可能会在程序中调用协议中的方法，如果没有遵守并实现其对应方法调用时就会报错。一般调用时我们都会使用respondsToSelector:方法来判断遵守了指定协议的对象是否实现了其对应的方法。

//假如有Person类，如果Person没有同时遵守sportProtocol和playProtocol协议就报错
id<sportProtocol,playProtocol> obj = [[Person alloc] init];

//父类<协议名> *指针名;
//这里的指针只能指向遵守了指定协议的对象或子类对象，这里是多态。

七、代理模式Delegation

事实上在OC中协议的更多作用是用于约束一个类必须实现某些方法，而从面向对象的角度而言这个类跟其他面向对象语言的接口(interface)并不一定存在某种自然关系，可能是两个完全不同意义上的事物，这种模式我们称之为代理模式（Delegation）。在Cocoa框架中大量采用这种模式实现数据和UI的分离，而且基本上所有的协议都是以Delegate结尾。

现在假设需要设计一个按钮，在按钮中定义按钮的代理，同时使用协议约束这个代理（事件的触发者）必须实现协议中的某些方法，当按钮被点击就检查代理是否实现了这个方法，如果实现了则调用这个方法。

//JFButtonDelegate.h文件
#import <Foundation/Foundation.h>
@class JFButton;

@protocol JFButtonDelegate <NSObject>
@required
-(void)onClick:(JFButton *)button;

@end


//MyListener.h文件
#import <Foundation/Foundation.h>
#import "JFButtonDelegate.h"

@interface MyListener : NSObject <JFButtonDelegate>

@end


//MyListener.m文件
#import "MyListener.h"
#import "JFButton.h"

@implementation MyListener

//实现协议中声明的方法
-(void)onClick:(JFButton *)button{
    NSLog(@"调用代理的监听方法，被点击的按钮是:%@",button);
}
@end


//JFButton.h文件
#import <Foundation/Foundation.h>
#import "JFButtonDelegate.h"

@interface JFButton : NSObject

//代理属性，同时约定作为代理的对象必须实现JFButtonDelegate协议
//id可以表示任何一个OC对象类型，类型后面的 <协议名> 用于约束作为这个属性的对象必须实现该协议。
@property (nonatomic,strong) id<JFButtonDelegate> delegate;

//点击方法
-(void)click;

@end


//JFButton.m文件
#import "JFButton.h"

@implementation JFButton

-(void)click{
    NSLog(@"调用按钮对象的点击方法");
    
    //使用respondsToSelector方法可以判断self.delegate实例是否实现了onClick:方法
    if([self.delegate respondsToSelector:@selector(onClick:)]){
        //如果确认onClich:方法已经实现，则作为JFButton的监听
        [self.delegate onClick:self];
    }
}

@end


//main.m文件
#import <Foundation/Foundation.h>
#import "JFButton.h"
#import "MyListener.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //实例化按钮和监听对象
        JFButton *button = [[JFButton alloc]init];
        MyListener *listener = [[MyListener alloc]init];
        
        //降遵守了协议的监听对象作为按钮的代理
        button.delegate = listener;
        
        //按钮调用点击方法
        [button click];
        
        /*
         调用按钮对象的点击方法
         调用代理的监听方法，被点击的按钮是:<JFButton: 0x100114710>
         */
    }
    return 0;
}
  1. CrazyCoder说道：
    2015年11月12日 09:08

    建议博主把block循环引用的情况都写出来，把如何避免循环引用的几种方法也写写

    回复

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注