自学iOS开发系列----OC（协议和委托代理）

协议
1.协议是OC的一种语法。OC的协议，类似于JAVA中接口，用来规范函数声明，实现多继承或对象间通信的一种语法。

2.协议的两种写法

①command+N新建协议类（HTProtocol）

②为协议命名

③HTProtocol.h

//第一种写法
#import <Foundation/Foundation.h>

@protocol HTProtocol <NSObject>

- (void)sayHello;

@end

④新建Person类

1）Person.h

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

//第二种写法，最常用的
@protocol PersonDelegate <NSObject>

- (void)run;

@end
//遵守多个协议
@interface Person : NSObject <
HTProtocol,
PersonDelegate
>

@end

2）Person.m

#import "Person.h"

@implementation Person

- (void)sayHello {
    NSLog(@"世界，你好");
}

- (void)run {
    NSLog(@"所有的人都在跑步");
}

@end

⑤main.m

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

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

        Person * person = [[Person alloc] init];
        [person sayHello];
        [person run];

    }
    return 0;
}

3.协议中的关键字
@required:当某个类遵守了此协议，必须要实现的方法，默认属性;
@optional:当某个类遵守了此协议，可以不实现，日常工作中最常用;
默认声明的协议为@required关键字,必须实现的协议未实现，则程序运行报错。

实战应用：
①新建协议类WorkProtocol
WorkProtocol.h

#import <Foundation/Foundation.h>

@protocol WorkProtocol <NSObject>

//默认为@required
- (void)read;

//当某个类遵守了此协议，必须要实现的方法，默认属性
@required
- (void)writeCode;

//当某个类遵守了此协议，可以不实现，日常工作中最常用
@optional
- (void)writeDocuments;

@end

②新建Worker类
1）Worker.h

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

@interface Worker : NSObject<
WorkProtocol>

@end

2）Worker.m

#import "Worker.h"

@implementation Worker

- (void)read {
    NSLog(@"Worker read");
}

- (void)writeCode {
    NSLog(@"Worker writeCode");
}

- (void)writeDocuments {
    NSLog(@"Worker writeDocuments");
}

@end

③main.m

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

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

        Worker * worker = [[Worker alloc] init];
        [worker read];
        [worker writeCode];
        [worker writeDocuments];

    }
    return 0;
}

4.OC中只有单继承，没有多继承，但是可以通过协议的方式实现多继承
①新建ClassA类
1）ClassA.h

#import <Foundation/Foundation.h>

@protocol ClassAProtocol <NSObject>

- (void)classAMethod;

@end

@interface ClassA : NSObject <ClassAProtocol>

@end

2）ClassA.m

#import "ClassA.h"

@implementation ClassA

- (void)classAMethod {
    NSLog(@"class A Method");
}

@end

②新建协议类ClassBProtocol
ClassBProtocol.h

#import <Foundation/Foundation.h>

@protocol ClassBProtocol <NSObject>

- (void)classBMethod;

@end

③新建ClassC类,模拟多继承
1）ClassC.h

#import <Foundation/Foundation.h>
#import "ClassA.h"
#import "ClassBProtocol.h"

@interface ClassC : NSObject <
ClassAProtocol,
ClassBProtocol>

@end

2）ClassC.m

#import "ClassC.h"

@implementation ClassC

- (void)classAMethod {
    NSLog(@"ClassA");
}

- (void)classBMethod {
    NSLog(@"ClassB");
}

@end

④main.m

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

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

        ClassC * clsC = [[ClassC alloc] init];

        [clsC classAMethod];
        [clsC classBMethod];

    }
    return 0;
}

委托代理
1.委托代理就好比现实生活中，我们如果想做成一件事，有的时候仅靠我们自己是无法达到目的的，需要通过他人的帮助才能完成。

2.通过类的复合理解委托代理的含义
如下情景：小明去找房子，通过中介，中介找到房子后，把信息会告诉你，你看看房子是否满意，如果满意租下来，如果不满意，让中介继续找。
①新建Agent类
1）Agent.h

#import <Foundation/Foundation.h>

typedef enum : NSInteger{
    HighHouseType,    //高档房
    MiddleHouseType,  //普通房
    LowHouseType      //廉价房
}HouseType;

@interface Agent : NSObject

@property (nonatomic, assign) HouseType type; //记录房子的信息

- (HouseType)findHouse;

@end

2）Agent.m

#import "Agent.h"

@implementation Agent

- (HouseType)findHouse {
    self.type = arc4random() % 3;

    switch (self.type) {
        case HighHouseType:{
            NSLog(@"找到了一个高档房子");
            break;
        }
            case MiddleHouseType:{
            NSLog(@"找到一个价格合适的普通房子");
            break;
        }
            case LowHouseType:{
            NSLog(@"找个一个廉价的房子");
            break;
        }
        default:
            break;
    }

    return self.type;
}

@end

②新建Person类
1）Person.h

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

@interface Person : NSObject

- (BOOL)wantToFindHouseWithAgent:(Agent *)agent;

@end

2）Person.m

#import "Person.h"

@implementation Person

- (BOOL)wantToFindHouseWithAgent:(Agent *)agent {
    HouseType type = [agent findHouse];

    switch (type) {
        case HighHouseType:{
            NSLog(@"房子不错，就是太贵了");
            break;
        }

        case MiddleHouseType:{
            NSLog(@"这个房子最好了，就是我喜欢的类型，价格也能接受");
            break;
        }

        case LowHouseType:{
            NSLog(@"房子太破了");
            break;
        }
        default:
            break;
    }

    if (type == MiddleHouseType) {
        return YES;
    }
    return NO;
}

@end

③main.m

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

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

        Person * xiaoming = [[Person alloc] init];
        Agent * xiaoli = [[Agent alloc] init];

        while (1) {
            sleep(1);
            BOOL success = [xiaoming wantToFindHouseWithAgent:xiaoli];
            if (success) {
                break;
            }
        }

        NSLog(@"终于找到最合适的房子了，好开森！");
    }
    return 0;
}

3.通过委托代理实现上面的情景
①新建Agent类
1）Agent.h

#import <Foundation/Foundation.h>

typedef enum : NSInteger{
    HighHouseType,
    MiddleHouseType,
    LowHouseType
}HouseType;

//声明协议
@protocol FindHouseProtocol <NSObject>

- (void)looklookOK:(int)type location:(NSString *)location;

@end


@interface Agent : NSObject

//声明代理
@property (nonatomic, assign) id<FindHouseProtocol>delegate;

@property (nonatomic, assign) HouseType type;

- (void)startFindHouse;

@end

2）Agent.m

#import "Agent.h"

@implementation Agent

- (void)startFindHouse {
    self.type = arc4random() % 3;

    switch (self.type) {
        case HighHouseType:{
            NSLog(@"找到了一个高档房子");
            break;
        }
            case MiddleHouseType:{
            NSLog(@"找到一个价格合适的普通房子");
            break;
        }
            case LowHouseType:{
            NSLog(@"找个一个廉价的房子");
            break;
        }
        default:
            break;
    }

    NSArray * array = @[@"昌平",@"海淀",@"朝阳"];

    //谁刚才让我去找房子 我找到之后就让谁来看房子
    [self.delegate looklookOK:self.type location:array[arc4random()%3]];
}

@end

②新建Person类
1）Person.h

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

@interface Person : NSObject<FindHouseProtocol> {
    BOOL _OK;
}

- (void)findHouse;

@end

2）Person.m

#import "Person.h"

@implementation Person

- (void)findHouse {
    Agent * agent = [[Agent alloc] init];

    agent.delegate = self;

    _OK = NO;

    while (1) {
        sleep(1);
        [agent startFindHouse];
        if (_OK) {
            break;
        }
    }
}

- (void)looklookOK:(int)type location:(NSString *)location {
    switch (type) {
        case HighHouseType:{
            NSLog(@"房子不错，就是太贵了");
            break;
        }

        case MiddleHouseType:{
            NSLog(@"这个房子最好了，就是我喜欢的类型，价格也能接受");
            break;
        }

        case LowHouseType:{
            NSLog(@"房子太破了");
            break;
        }
        default:
            break;
    }

    if (type == MiddleHouseType && [location isEqualToString:@"昌平"]) {
        _OK = YES;
    }
}

@end

③main.m

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

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

        Person * xiaoming = [[Person alloc] init];
        [xiaoming findHouse];

    }
    return 0;
}