OC——协议与托管

协议的概念

  协议

    是一个方法列表

    它声明了一系列的方法而不进行实现

    作用类似于接口

  非正式协议

    为特定目的而设定

    包含可选的方法

    列表中的方法是可以选择性实现的

    用于将方法归类，更好地组织代码

  正式协议

    所有实现正式协议的类，都必须实现该正式协议中的所有方法

一个类可以实现任意多个协议

正式协议

  正式协议

    Cocoa中协议，通常指的是正式协议

  作用

    使一个类可以正式地声明一个方法列表

    作为向外提供服务的接口

  协议的术语

    提供者

  声明正式的协议

    客户类

    采纳正式协议，即同意实现协议中所有的方法

  使用协议步骤

声明协议——>采用协议——>实现协议——>使用协议

  声明协议格式(

    在.h文件中，声明协议：

      @protocol  协议名称

        函数成员声明；

      @end

  )：

      @protocol

      协议名称

      函数成员声明

         新添加的方法

  采用协议格式

    @ interface与@end

    ClassName

      现有类的类名

    协议名称

  注意

    一个类可以采纳多个协议

    不同的协议之间用逗号分隔

正式协议中的泛型

    可以指向任何类型的对象。id 再加上正式协议，能够达到形似JAVA中泛型的效果(注：只是形似，并非神似)

委托设计模式

  代理设计模式的基本概念

      代理是指一个对象提供机会对另一个对象中的行为发生变化时做出的反应。

      代理设计模式的基本思想——两个对象协同解决问题，通常用于对象之间的通信。

  代理设计模式的基本特点
      简化了对象的行为，最小化了对象之间的耦合度.使用代理，一般来说无需子类化

      简化了我们应用程序开发，既容易实现，又灵活

@optional和@required关键字

  @optional关键字

      该指令后的方法都是可选的，即不一定要实现

  @required关键字

      该指令后面的方法，必须要实现

第一个项目：
协议
main.m

#import <Foundation/Foundation.h>
#import "MyClient.h"
#import "MyServer.h"
#import "MyServer2.h"

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

    @autoreleasepool {
        
        MyClient *myClient = [MyClient new];
        [myClient setSendData:1111];
        [myClient setReceiverData:0];
        [myClient print_client];
        
        //实例化MyServer类
        MyServer *server = [MyServer new];
        id obj;
        obj = server;
        [myClient show:obj];
        
        //实例化实现了xieyi的类的对象
        MyServer2 *server2 = [MyServer2 new];
        obj = server2;
        [myClient showPort:obj];//id<xieyi>  表示需要一个实现了xieyi的类的对象              List<Student>
        
    }
    return 0;
}

MyClient.m

#import "MyClient.h"
#import "MyServer.h"

@implementation MyClient
@synthesize sendData,receiverData;

-(void)sendData:(int) _data{
    
    sendData = _data;

}
-(void)receiverData:(int) _data{
    receiverData = _data;

}

-(void)print_client{

    NSLog(@"client : send = %d,receiver = %d",sendData,receiverData);

}

//传递的使普通干的对象
-(void)show:(id) _obj{

    MyServer *server = [MyServer new];
    server = _obj;

    [server receiverData:45];
}


//传递的是实现了xieyi的类的对象
-(void)showPort:(id<xieyi>)_obj{

    [_obj setNetworkPort:8080];
    
}
@end
 MyClient.h

#import <Foundation/Foundation.h>
#import "NetworkPotocol.h"
#import "xieyi.h"

@interface MyClient : NSObject<NetworkPotocol>
{

    //定义变量存储接收和发送的内容
    int sendData;
    int receiverData;

}
// 合成存取器，
@property int sendData,receiverData;

-(void)print_client;
-(void)show:(id) _obj; //_obj 传递的使myServer
-(void)showPort:(id<xieyi>) _obj; //实现了xieyi 的对象
@end



MyServer.m

#import "MyServer.h"

@implementation MyServer
-(void)sendData:(int) _data{
    
    NSLog(@"Server: 发送数据%d",_data);
    
}
-(void)receiverData:(int) _data{
    NSLog(@"Server: 接受数据%d",_data);
    
}
@end


MyServer.h

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

@interface MyServer : NSObject<NetworkPotocol>

@end

MyServer2.m

#import "MyServer2.h"

@implementation MyServer2
-(void)setNetworkPort:(int) _port{

    NSLog(@"myServer2 port:%d",_port);

}
@end

MyServer2.h

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

@interface MyServer2 : NSObject<xieyi>

@end


NetworkPotocol.h

#import <Foundation/Foundation.h>

@protocol NetworkPotocol <NSObject>

//等待被实现的方法
-(void)sendData:(int) _data;
-(void)receiverData:(int) _data;
//-(void)networkPort:(int) _port;

@end

xieyi.h

#import <Foundation/Foundation.h>

@protocol xieyi <NSObject>
-(void)setNetworkPort:(int) _port;
@end









第二个项目：
Protocol

main.m

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

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

    @autoreleasepool {
        
        //实例化ClassA 对象
        ClassA *classA = [ClassA new];
        classA.num=0;
        
        [classA jiafa:4];
        [classA jianfa:1];
        [classA chengfa:12];
        [classA chufa:3];
        
        //实例化采用了 myPotocol协议类的对象
        ClassObj *cobj = [ClassObj new];
        [classA test:cobj];
        
        ClassC *classC = [ClassC new];
        
        //[classA test:classC];
    }
    return 0;
}


ClassA.m

#import "ClassA.h"

@implementation ClassA
@synthesize num;
-(void)jiafa:(int) _n{
    
    num +=_n;
    NSLog(@"jiafa:num=%d",num);
}
-(void)jianfa:(int) _n{

    num -=_n;
    NSLog(@"jianfa:num=%d",num);
}
-(void)chengfa:(int) _n{

    num *=_n;
    NSLog(@"chengfa:num=%d",num);
}
-(void)chufa:(int) _n{

    num /=_n;
    NSLog(@"chufa:num=%d",num);

}

//使用泛型
-(void)test:(id<myPotocol>) _obj{

    [_obj show];

}
@end


ClassA.h

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

//采用某个协议              采用operatioin协议
@interface ClassA : NSObject<operation>
{
    int num;
}
@property int num;
@end



ClassObj.m

#import "ClassObj.h"

@implementation ClassObj
-(void)show{
    
    NSLog(@"CLassObj!!!");
    
}
@end


ClassObj.h

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

@interface ClassObj : NSObject<myPotocol>

@end


ClassC.m

#import "ClassC.h"

@implementation ClassC

@end



ClassC.h

#import <Foundation/Foundation.h>

@interface ClassC : NSObject

@end
myPotocol.h

#import <Foundation/Foundation.h>

@protocol myPotocol <NSObject>
-(void)show;
@end


operation.h

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

//        协议的名称     
@protocol operation <NSObject>
-(void)jiafa:(int) _n;
-(void)jianfa:(int) _n;
-(void)chengfa:(int) _n;
-(void)chufa:(int) _n;
-(void)test:(id<myPotocol>) _obj;
@end




第三个项目：
委托

main.m

#import <Foundation/Foundation.h>
#import "People.h"
#import "Bus.h"
#import "Bike.h"
#import "Taxi.h"

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

    @autoreleasepool {
        
        //实例化People类
        People *people = [People new];
        Bus *bus = [Bus new];
        Bike *bike = [Bike new];
        Taxi *taxi = [Taxi new];
        
        //因为Bike已经实现了 xieyi 所以他的对象可以被赋值为weituoObj
        //设置委托对象
        people.weituoObj = taxi;
        
        //调用people的goTo方法，该方法使用委托对象进一步调用了委托对象对应的goTo方法；
        
        [people goTo];
        
        
    }
    return 0;
}



People.m

#import "People.h"

@implementation People
@synthesize weituoObj;


-(void)goTo{

    NSLog(@"人要行走！");
    //SEL action = @selector(goTo);
                                    //action
    if([weituoObj respondsToSelector:@selector(goTo)]){
    
        //调用的使协议里的goTo
        [weituoObj goTo];
        //[weituoObj performSelector:action];
    
    }
}
@end


People.h

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

@interface People : NSObject{

    //定义委托对象
    id<xieyi> weituoObj; //该对象特点是赋值时必须使已经采纳了xieyi协议的累的的对象

}
//生成getter和setter方法
@property id<xieyi> weituoObj;
//定义的一个普通方法
-(void)goTo;
@end



Bus.m

#import "Bus.h"

@implementation Bus
-(void)goTo{

    NSLog(@"坐公交车前往目的地");

}
@end

Bus.h

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

@interface Bus : NSObject<xieyi>

@end


Bike.m

#import "Bike.h"

@implementation Bike
-(void)goTo{

    NSLog(@"骑自行车前往目的地！");

}
@end


Bike.h

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

@interface Bike : NSObject<xieyi>

@end

Taxi.m

#import "Taxi.h"

@implementation Taxi
-(void)goTo{

    NSLog(@"乘出租车前往！！！");

}
@end


Taxi.h

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

@interface Taxi : NSObject<xieyi>

@end



xieyi.h

#import <Foundation/Foundation.h>

@protocol xieyi <NSObject>
@required  //表示该方法必须实现
-(void)goTo;
//-(void)method3;
//.....

@optional//可以声明方法可以选择实现
-(void)method1;
-(void)method2;
@end