黑马程序员——OC—block和protocol协议

OC—block和protocol协议

 

 

 一、block：

      1. 作用：用来保存一段代码

      2. block的标志：^

      3. 定义的格式：

返回值 (^ 变量名) (形参列表)  =  ^{.........};

      5. block和函数相同点：

           1). 都可以保存一段代码

           2).都有返回值

           3). 都有形参

           4). 调用方式都一样

      6. block封装代码：

^(int a, int b) {

    return a - b;

};

^() {

    NSLog(@"i love oc");

};   

  

       7. block特点：

          1). 没有形参可以省略 ()

          2). block内部可以访问外部局部变量

          3). block内部不可以修改外部局部变量

          4).在局部变量前加上__block关键字，这个局部变量就可以在block内部中修改

 

代码示例：

 

#import <Foundation/Foundation.h>

 

typedef int (*SumP)(int, int);

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

int sum(int a, int b)
{
    return a + b;
}

int main()
{ 
    
    /*
    int (^sumBlock)(int, int);
   
    sumBlock = ^(int a, int b) {
        return a + b;
    };
   
    int (^minusBlock)(int, int) = ^(int a, int b) {
        return a - b;
    };*/
   
    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;
    };
   
   
    NSLog(@"%d - %d - %d", multiplyBlock(2, 4),  sumBlock(10 , 9), minusBlock(10, 8));
    
    return 0;
}

void test3()
{
    int a = 10;
    __block int b = 20;
   
    void (^block)();
   
    block = ^{
        // block内部可以访问外面的变量
        //NSLog(@"a = %d", a);
       
        // 默认情况下，block内部不能修改外面的局部变量
        // a = 20;
       
        // 给局部变量加上__block关键字，这个局部变量就可以在block内部修改
        b = 25;
    };
   
   
    block();
}

// 有返回值、有形参的block
void test2()
{ 
    int (^sumblock)(int, int) = ^(int a, int b){
        return a + b;
    };
   
    int c = sumblock(10, 11);
   
   
    // 用一个block输出n条横线
   
   
    void (^lineBlock)(int) =  ^(int n)
    {
        for (int i = 0; i<n; i++) {
            NSLog(@"----------------");
        }
    };
    lineBlock(5);

}

// 没有返回值、没有形参的block
void test()
{
    // 定义block变量
    /*
    void (^myblock)() = ^(){
        NSLog(@"----------------");
        NSLog(@"----------------");
    };*/
   
    // 如果block没有形参，可以省略后面的()
    void (^myblock)() = ^{
        NSLog(@"----------------");
        NSLog(@"----------------");
    };
   
    // 利用block变量调用block内部的代码
    myblock();
   
    myblock();
}

 

     8. 利用typedef 定义block类型：

        typedef  数据类型(^  类型名)  (参数);

 

        typedef  int  (^ myBlcok)  (int , int);

 

 二、protocol协议：

     

        1. 用途：

             1). 可以用来声明一大堆方法（不能声明成员变量）

             2). 只要某个类遵守了这个协议，就相当于拥有了这个协议的所有方法

             3). 只要遵守了某个协议，那么子类也就遵守了

 

        2. 定义protocol格式：

           定义：

                 @protocol  协议名称 ：NSObject

                      ……方法……

                  @end

         遵守协议：

                @interface  类名 ：NSObject   <协议名> 

 

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

            1). @required ：用@required修饰的方法，在遵守协议后必须实现

            2). @optional ：用@optional修饰的方法，在遵守协议后可以实现也可以不实现

 

        4. 遵守协议的方法：

           1). 类遵守协议：

              @interface  类名  ： 父类名 <协议1，协议2>

              @end

           2). 协议遵守协议：

              @portocol  协议名  <其它协议1，其它协议2>

              @end

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

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

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

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

 

代码示例：

Dog 类：

#import <Foundation/Foundation.h>

@protocol MyProtocol2;

@interface Dog : NSObject <MyProtocol2>

@end

#import "Dog.h"
#import "MyProtocol2.h"

@implementation Dog
- (void)haha2
{
   
}
@end

 

Hashiqi 类：

#import "Dog.h"

@protocol MyDogProtocol <NSObject>
- (void)dogTest;
@end

@interface Hashiqi : Dog<MyDogProtocol>
- (void)addTest;
@end

@interface Hashiqi (Add)
- (void)addTest;
@end

 

#import "Hashiqi.h"

@implementation Hashiqi

- (void)dogTest
{

}

@end

@implementation Hashiqi (Add)
- (void)addTest
{

}
@end

Person 类：

#import <Foundation/Foundation.h>

//#import "MyProtocol3.h"
//#import "MyProtocol2.h"

@class Hashiqi;

@protocol MyProtocol2;

@protocol MyProtocol3;

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

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

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

@property (nonatomic, strong) Hashiqi *dog;

@end

#import "Person.h"
#import "MyProtocol2.h"
#import "MyProtocol3.h"

@implementation Person

- (void)test
{
   
}

@end

MyProtocol 协议：

#import <Foundation/Foundation.h>

// 定义了一个名叫MyProtocol的协议
@protocol MyProtocol <NSObject>
// @required 要求实现，不实现就会发出警告
// @optional 不要求实现

- (void)test4;

@required
- (void)test;
- (void)test2;

@optional
- (void)test3;

@end

MProtocol 协议2：

#import <Foundation/Foundation.h>

@protocol MyProtocol2  <NSObject>

- (void)haha2;

@optional
- (void)haha3;

@end

MyProtocol 协议3：

#import <Foundation/Foundation.h>
#import "MyProtocol.h"

// 一个协议遵守了另外一个协议，就可以拥有另一个协议的所有方法声明

@protocol MyProtocol3 <MyProtocol>

- (void)hehe;
@end

MyProtocol 协议4：

#import <Foundation/Foundation.h>

@protocol MyProtocol4 <NSObject>

@end

main 函数：

 

#import <Foundation/Foundation.h>
#import "MyProtocol.h"
#import "MyProtocol3.h"
#import "Person.h"
#import "Dog.h"
#import "Hashiqi.h"

int main()
{
    Person *p = [[Person alloc] init];
    p.obj = [[Hashiqi alloc] init];
   
    return 0;
}

void test()
{
    //NSObject *obj = [[NSObject alloc] init];
   
   
    //NSObject *obj2 = @"4324324";
   
   
    // 要求obj3保存的对象必须是遵守是MyProtocol这个协议
   
    //NSObject<MyProtocol> *obj3 = [[NSObject alloc] init];
   
    NSObject<MyProtocol> *obj3 = [[Person alloc] init];
   
    obj3 = nil;
   
   
    id<MyProtocol> obj4 = [[Person alloc] init];
   
    obj4 = nil;
   
    // 要求obj5，保存的对象必须遵守MyProtocol3、并且继承了Person
    Person<MyProtocol3> *obj5 = [[Person alloc] init];
   
    obj5 = nil;
}

 

   5. 如何区分协议是否单独写在一个文件中：

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

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