------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------
一、block代码块
1.block类型是一个c级别的语法和运行机制，他与标准c函数类似，不同之处在于，它除了有可执行代码以外，还包含了与堆。栈 内存绑定的变量，因此block 对象包含着一组状态数据，这些数据在程序执行是用于对行为产生影响，block被设计为可同时兼容 三种语言 oc 、c++ 、c。
block 的基本使用
int（^myBlock ）（int）=（int num）{ return }
1) 无参 无返回值
定义一个没有参数\没有返回值的block变量，同时赋值。
void (^block变量名)()=^(){
代码块的语句
}
void (^myBlock1)(int)=^( ){
NSLog(@"xxxx");
}
//使用block变量
myBlock1(); //这样就打印xxxxx 没参数^小括号可以省略
2）有参数无返回值
void(^变量名)(参数类型及个数)=^(形参列表){
代码块语句
}
viod (^myBlock2)(int,int)=^(int a, int b){
NSLog(@"a+b =%d",a+b);
}
myBlock2(3,6);
//先定义变量，再赋值
myblock2=^(int x,inty){
NSLog(@"x*y =%d",x*y);
}
3）有参数有返回值
定义一个有从哪回溯有返回值的block
int(^myBlock3)(int,int)=^(intx,inty){
return x+y;
}
//使用block ,接受返回值
int sum =myBlock3 (23,45 );
//重新给变量赋值
myblock3=^(int x,inty){
return x*y;
}
2.block的typedef
利用typedef定义的block类型（和指向函数的只注重很像）
typedef void(^myBlock)() :
格式 ： typedef 返回值类型(^新别名)(参数类型列表)
typedf int (^myBlock1)(int ,int);
给没有返回值，没有参数的block起一个别名
myblock是一个类型不在是一个单纯的变量
typedef void (^myblock)();
myblock f1;
//block类型的变量
f1 =^{
NSLog(@“hellowworld");
}
//使用
f1();
定义有参数 \有返回值的block类型
int (^block1)(int,int)=^(inta,intb){
return a=b;
}
定义了一个block1的类型 返回值是int 有两个int类型参数
typedef int(^block1)(int,int);
block1 b1；
b1 =^(int x,int y){
return x-y;
}
int s= b1(2,3);
连续定义多个 block1类型的变量
block1 n,n2,n2;
3.block 访问外部变量
1）在block内部可以访问外部的变量
当定义block的时候会把外部变量以const 的方式复制一份，存放到block的所在内存中
2）block内部不可以修改外部的变量值
3)__block 修饰的变量 内部可以修改 应为这里不再以const的方式拷贝
4.注意：
1）静态变量和全局变量。在不加 __block 都会直接引用变量地址，也就意味着可以修改变量的值，在没有__block参数的情况下
2）全局变量block：定义在函数外部的block是global 另外如果函数内部的block，但是没有捕捉任何自动变量，那么他也是全局的
3）栈block 区别，是否引用了外部变量
4)堆block 则是对栈block copy得来，对全局block copy不会有任何作用，返回的依然是全局block。
5.block作为函数的返回值
步骤 1.使用typedef定义一个新类型
//给block起个别名
typedef int (^newType)(int num1,int num2);
2.使用新类型作为函数的返回值
//定义一个返回值是block类型的函数
newType test4（）{}
3.定义变量接受函数的返回值（block类型）
4.调用block
//block类型作为函数的返回值
newType test（）{
newType w1 =^{
NSLog(@"xxxx");
NSLog(@"helloword");
}
return w1;//返回值
}
//定义block类型的变量 接受函数返回的结果
newType n1 =test();
//执行block
n1（）;
//重新定义一个新的类型 newType2
typedef int (^newType2)(int,int);
newType2 test2 {
return^(int a,int b){
return a+b;
}
}
//n2 = ^(int a,int b){ return a+b ; };
newType2 n2 = test2();
//调用block
int s = (23,23);
7.block的掌握技巧
1）block 结构的快速提示： 输入inlineBlock
2）我们在定义block变量的时候，形参类型及个数 这个位置处可以加上形参名
test(^int(int,int)){}
实现程序员工作
#import <Foundation/Foundation.h>
//block类型的变量 workBlock 作为函数的参数
void work( void(^workBlock)() ){
NSLog(@"起床刷牙");
NSLog(@"去车站");
NSLog(@"坐车");
workBlock();//打印其它的
NSLog(@"去车站");
NSLog(@"坐车回家");
NSLog(@"吃饭");
NSLog(@"睡觉");
}
void workday(int n){
typedef void(^workBlock) ();
workBlock w;
switch (n) {
case 1:
w=(^{
NSLog(@"了解项目");
});
break;
case 2:
w=(^{
NSLog(@"了解项目");
});
break;
case 3:
w=(^{
NSLog(@"了解项目");
});
break;
case 4:
w=(^{
NSLog(@"了解项目");
});
break;
case 5:
w=(^{
NSLog(@"离职");
});
break;
default:
break;
}
//调用函数
work(w);
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
workday(5);
return 0;
}
}
二、protocol（协议）
1.protocol 概念及基本使用
什么是协议：一些方法的声明 ，一般写到一个.h头文件中
方法有两种：必须实现的 和选择实现的
协议的作用： 供其他的类区遵守
如果一个类遵守了一个协议，就应该实现这个协议宏定义的必须要实现的方法。
2. 如何定义一个协议
@protocol xxx <NSObject> 默认的情况下遵守的 NSObject 协议
@end
类遵守协议的格式
1）遵守协议
先导如入头文件
@interface Person :NSObject <xxx>;
@end
2）遵守多个协议
@interface 类名：NSObject <xxx,aaa ,bbb>;
@end
#import <Foundation/Foundation.h>
//定义一个协议
//定义协议的流程-->定义协议-->让类遵守这个协议-->实现协议中对应的方法（必须要实现的）
@protocol basepProtocol <NSObject>
//声明一些方法
-(void)eat;
-(void)run;
@end
//Person 遵守这个协议
@intrface Person :NSObjeect <baseProtocol>
@end
@implementation Person
-(void)eat{
NSLog(@"人在吃法饭");
}
-(void)run{
NSLog(@"人在跑步");
}
@end
当我们遵守了某个协议后，就有相当于这个类有了协议中所有的方法声明
3.protocol的其他用法
protocol的使用注意
1）protocol ：就一个用途，用来声明一大堆的方法(不能声明成员变量)，不能写实现
2)只要某个类遵守了这个协议，就拥有了这个协议中的所有方法
3）只要父类遵守了某个协议，那么子类也遵守 ，实现了协议方法，这些方法可以被子类继承
4）protocol声明的方法可以让任何类区实现 ，protocol就是协议
5）oc中不能继承多个类（单继承）但是能够遵守多个协议。继承（ ：）协议（ < > ）
6)基协议：<NSObject>是基协议，是最根本的协议，其中声明了很多方法。
7)协议可以遵守协议，一个协议遵守了另一个协议，就可以拥有另一个协议中的方法声明
4.protocol 中的@reuired 和@optional
@required和@optional 是协议方法声明中的两个关键字
他们主要控制方法是否要实现（默认的是@required） ，
用途 在于程序员之间的交流
@requried 表示必须要实现的方法
@optional 可以选择实现方法
5.protocol 类型限制
需要一女朋友的条件 定个协议
housHoldProtocl.h
@protocol houseHoldProtocol <NSObject>
- (void)zuoFan;
- (void)xiyifu;
@optional
-(void)job;
@end
1）使用id存储对象，对象的类型限制
格式 id<协议名称> 变量名
id <Myportocol> obj1;
//这样写后，表示是给人都满足条件
所以改为 id<houseHoldProtocol>girl ;
这样就行限制了 传进来的对象要遵守了协议才可以赋值
2）对象赋值类型限制
格式：类名<协议名>*变量名
Person<hoseHoldProtocol>*p
这样必须是人的类的对象才能赋值
3）对象的关联关系
要求人的狗会算数
@intterface Person:NSObject
//限制了这里传入的狗必须是遵守了dogProtocol的狗
@property(nonatomic,strong)Dog<dogProtocol>*dog;
@end
//狗遵守协议
@intreface Dog：NSObject <dogProtocol>
@end
id 和instancetype的区别
1）instancetyp只能作为函数或方法的返回值
2）id能作为方法或者函数的返回值、参数类型，也能用来定义一个变量
3)instancetype 对比id的好处: 能精确的的限制返回值的具体类型
6.protocol代理模式设计
实现 婴儿饿了要吃东西 ，困了要睡觉，
婴儿类 保姆类
#import <Foundation/Foundation.h>
@protocol baoMuProtocol <NSObject>
- (void)eatToBaby;
- (void)sleepToBaby;
@end
import <Foundation/Foundation.h>
#import "baoMuProtocol.h"
@class baby;
@interface baoMu : NSObject<baoMuProtocol>
@property (nonatomic,weak) baby *baby;
@end
#import "baoMu.h"
#import "baby.h"
@implementation baoMu
- (void)eatToBaby{
NSLog(@"保姆正在给baby喂奶");
}
- (void)sleepToBaby{
NSLog(@"保姆正在哄baby睡觉");
}
@end
#import <Foundation/Foundation.h>
@class baoMu;
#import "baoMuProtocol.h"
@interface baby : NSObject
@property (nonatomic,strong) baoMu<baoMuProtocol>*baomu;
- (void)babyWantEat;
- (void)babyWantsleep;
@end
#import "baby.h"
#import "baoMu.h"
@implementation baby
- (void)babyWantEat{
NSLog(@"baby在哭。。。。");
[self.baomu eatToBaby];
}
- (void)babyWantsleep{
NSLog(@"baby在哭。。。。");
[self.baomu sleepToBaby];
}
@end
#import <Foundation/Foundation.h>
#import "baby.h"
#import "baoMu.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
baoMu *baomu =[[baoMu alloc] init];
baby * ba =[[baby alloc] init];
ba.baomu = baomu;
[ba babyWantEat];
}
return 0;
}
protocol代理设计模式概念
传入对象，代替当前类完成某个功能，称为代理模式。
利用协议实现代理模式的主要思路：
1）定义一个协议，里面声明代理需需要实现的方法列表。
2）创建一个代理类，遵守上面的代理协议
3）在需要代理的类中，定义一个对象类型为id且遵守代理协议的成员变量
4)在类中调用成员变量_delegate（代理的方法），调用代理的类方法
5）main.m或其他类文件中，为类的成员变量赋值
理解应用通过中介找房子
#import <Foundation/Foundation.h>
@protocol findHouseProtocol <NSObject>
- (void)findHouse;
@end
#import <Foundation/Foundation.h>
#import "findHouseProtocol.h"
@interface LinkHome : NSObject<findHouseProtocol>
@end
#import "LinkHome.h"
#import "findHouseProtocol.h"
@implementation LinkHome
- (void)findHouse{
NSLog(@"链家地产正在给学生找房子");
}
@end
#import <Foundation/Foundation.h>
#import "findHouseProtocol.h"
@interface Student : NSObject
@property (nonatomic ,strong) id<findHouseProtocol>delegate;
-(void)needHouse;
@end
#import "Student.h"
#import "LinkHome.h"
@implementation Student
-(void)needHouse{
NSLog(@"学生需要一个温暖的家");
[self.delegate findHouse];
}
@end
#import <Foundation/Foundation.h>
#import "Student.h"
#import "LinkHome.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
//代理类
LinkHome *li = [[LinkHome alloc] init];
Student*stu =[[Student alloc] init];
stu.delegate=li;
[stu needHouse];
//代理类 LinKhome
//代理对象 delegate
//协议内容 findHouseProtocol
//协议内容 findHouse
}
return 0;
}