大纲

• 26.Protocol-协议
• 27.delegate-代理
• 28.Foundation框架介绍
• 29.NSString和NSMutableString
• 30.NSArray和NSMutableArray
• 31.NSDictionary和NSMutableDictionary
• 32.copy
• 33.常见的结构体
• 1. NSFileManager
• 35.其他

书接上篇，继续来说说这个古老而又现代的开发语言。在Objectve-C语法总结<1> 那篇中OC大部分的语法基本上已经总结完毕。本篇在上一篇的基础上对语法进行少量的补充，其次主要对OC中的常用类API的介绍。

26.Protocol-协议

26.1.protocol 概念

• Protocol翻译过来叫做”协议”
  • 在写java的时候都会有接口interface这个概念,接口就是一堆方法的声明没有实现,而在OC里面Interface是一个类的头文件的声明,并不是真正意义上的接口的意思,在OC中接口是由一个叫做协议的protocol来实现的
  • protocol它可以声明一些必须实现的方法和选择实现 的方法。这个和java是完全不同的
• Protocol的作用
  • 用来声明一些方法
  • 也就说, 一个Protocol是由一系列的方法声明组成的

26.2.protocol 语法格式

• Protocol的定义
  1. @protocol 协议名称
  2. // 方法声明列表
  3. @end

• 类遵守协议
  • 一个类可以遵守1个或多个协议
  • 任何类只要遵守了Protocol,就相当于拥有了Protocol的所有方法声明
    1. @interface 类名 : 父类 <协议名称1, 协议名称2,…>
    2. @end

• 示例

1. @protocol SportProtocol <NSObject>
2. – (void)playFootball;
3. – (void)playBasketball;
4. @end
6. #import “SportProtocol.h” // 导入协议
7. @interface Studnet : NSObject<SportProtocol> // 遵守协议
8. @end
10. @implementation Student
11. // 实现协议方法
12. – (void)playBasketball
13. {
14. NSLog(@”%s”, __func__);
15. }
16. // 实现协议方法
17. – (void)playFootball
18. {
19. NSLog(@”%s”, __func__);
20. }
21. @end

26.3.protocol和继承区别

• 继承之后默认就有实现, 而protocol只有声明没有实现
• 相同类型的类可以使用继承, 但是不同类型的类只能使用protocol
• protocol可以用于存储方法的声明, 可以将多个类中共同的方法抽取出来, 以后让这些类遵守协议即可

26.4.protocol 的使用注意

• 1)Protocol:就一个用途,用来声明一大堆的方法(不能声明成员变量),不能写实现。

1. @protocol SportProtocol <NSObject>
2. {
3. int _age; // 错误写法
4. }
5. – (void)playFootball;
6. – (void)playBasketball;
7. @end

• 2)只要父类遵守了某个协议,那么子类也遵守。

1. @protocol SportProtocol <NSObject>
3. – (void)playFootball;
4. – (void)playBasketball;
5. @end

1. #import “SportProtocol.h”
2. @interface Student : NSObject <SportProtocol>
3. @end
5. @interface GoodStudent : Student
6. @end
8. @implementation GoodStudent
9. – (void)playFootball
10. {
11. NSLog(@”%s”, __func__);
12. }
13. – (void)playBasketball
14. {
15. NSLog(@”%s”, __func__);
16. }
17. @end

• 3)OC不能继承多个类(单继承)但是能够遵守多个协议。继承(:),遵守多个协议使用“< >”（尖括号）协议和协议直接用“，”（逗号）隔开。

1. #import “SportProtocol.h”
2. #import “StudyProtocol.h”
4. @interface Student : NSObject <SportProtocol, StudyProtocol>
6. @end

• 4)协议可以遵守协议,一个协议遵守了另一个协议,就可以拥有另一份协议中的方法声明

1. @protocol A
2. -(void)methodA;
3. @end
5. @protocol B <A>
6. -(void)methodB;
7. @end

1. @interface Student : NSObject <B>
2. -(void)methodA; // 同时拥有A/B协议中的方法声明
3. -(void)methodB;
4. @end

26.5.基协议

• NSObject是一个基类，*根本*基本的类，任何其他类*终都要继承它
• 还有也叫NSObject的协议，它是一个基协议，*根本*基本的协议
• NSObject协议中声明很多*基本的方法
  • description
  • retain
  • release
• 建议每个新的协议都要遵守NSObject协议

1. @protocol SportProtocol <NSObject> // 基协议
3. – (void)playFootball;
4. – (void)playBasketball;
5. @end

26.6.@required和@optional关键字

• 协议中有2个关键字可以控制方法是否要实现(默认是@required，在大多数情况下，用途在于程序员之间的交流)
  • @required：这个方法必须要实现（若不实现，编译器会发出警告）
  • @optional：可选的，这个方法不一定要实现。

1. @protocol SportProtocol <NSObject>
3. @required // 如果遵守协议的类不实现会报警告
4. – (void)playFootball;
5. @optional // 如果遵守协议的类不实现不会报警告
6. – (void)playBasketball;
7. @end

27.delegate-代理

27.1.代理设计模式

• 生活中大家一定遇到这样的情况了：比如说我要买一包纸，不妨就是心相印的吧，那一般人的话我应该不是去心相印的工厂里面直接去买吧，而是我们在心相印专卖店或者什么超市啊，这些地方购买，这些地方实际上就是洁丽雅毛巾的代理。这其实和我们OO中的代理模式是很相似的。在OC中到处都在使用代理，可以说代理设计模式是OC中*重要*常用的设计模式之一。

• 代理设计模式的场合:
  • 当对象A发生了一些行为,想告知对象B(让对象B成为对象A的代理对象)
  • 对象B想监听对象A的一些行为(让对象B成为对象A的代理对象)
  • 当对象A无法处理某些行为的时候,想让对象B帮忙处理(让对象B成为对象A的代理对象)

2.代理设计模式示例

• 婴儿吃饭睡觉

1. #import <Foundation/Foundation.h>
2. @class Baby;
3. // 协议
4. @protocol BabyProtocol <NSObject>
5. – (void)feedWithBaby:(Baby *)baby;
6. – (void)hypnosisWithBaby:(Baby *)baby;
7. @end

给baby定义了一个协议BabyProtocol，里面有两个方法，分别是吃饭和睡觉。该协议继承了基协议<NSObject>

1. #import “BabyProtocol.h”
2. @interface Baby : NSObject
3. // 食量
4. @property (nonatomic, assign) int food;
5. // 睡意
6. @property (nonatomic, assign) int drowsiness;
7. // 饿
8. – (void)hungry;
9. // 睡意
10. – (void)sleepy;
11. @property (nonatomic, strong) id<BabyProtocol> nanny;
12. @end
14. @implementation Baby
16. – (void)hungry
17. {
18. self.food -= 5;
19. NSLog(@”婴儿饿了”);
20. // 通知保姆，respondsToSelector：判断保姆类中是否实现了feedWithBaby:方法，如果没有实现该方法就不会执行。
21. if ([self.nanny respondsToSelector:@selector(feedWithBaby:)]) {
22. [self.nanny feedWithBaby:self];
23. }
24. }
26. – (void)sleepy
27. {
28. self.drowsiness += 5;
29. NSLog(@”婴儿困了”);
30. // 通知保姆
31. if ([self.nanny respondsToSelector:@selector(hypnosisWithBaby:)]) {
32. [self.nanny hypnosisWithBaby:self];
33. }
34. }
35. @end

baby类的匿名分类中定义了，食量，睡意两个int类型属性，定义了id类型的nanny属性，协议属性使用id类型的原因是代表任何类都可以遵守BabyProtocol协议，扩展性强。同时定义了两个hungry，sleepy（睡觉）两个方法。

1. // 保姆
2. @interface Nanny : NSObject <BabyProtocol>
3. @end
5. @implementation Nanny
7. – (void)feedWithBaby:(Baby *)baby
8. {
9. baby.food += 10;
10. NSLog(@”给婴儿喂奶, 现在的食量是%i”, baby.food);
11. }
13. – (void)hypnosisWithBaby:(Baby *)baby
14. {
15. baby.drowsiness += 10;
16. NSLog(@”哄婴儿睡觉, 现在的睡意是%i”, baby.drowsiness);
17. }
18. @end

Nanny保姆类遵守了BabyProtocol协议，在baby发生饿了的行为时，会通知保姆，调用对应的方法。

1. int main(int argc, const char * argv[]) {
2. // 1.创建婴儿
3. Baby *b = [Baby new];
4. // 2.创建保姆
5. Nanny *n = [Nanny new];
6. // 3.保姆作为婴儿的代理
7. b.nanny = n;
9. // 4.换保姆
10. // Studnet *stu = [Studnet new];
11. //保姆属性id类型的，任何类都可以作为代理
12. // b.nanny = stu;
14. //5.婴儿发飙，执行food方法，food方法会执行保姆类的对应方法。
15. [b food];
16. [b sleepy];
18. return 0;
19. }

28.Foundation框架介绍

28.1.Foundation框架介绍

iOS提供了很多你可以在应用程序里调用的框架。要使用一个框架，需要将它添加到你的项目中，你的项目才可以使用它。许多应用程序都使用了如 Foundation、UIKit、和Core Graphics这些框架。根据你为应用程序选择的模版，相关的框架就已经被自动引入了。如果默认加入的框架不能满足你的应用程序的需求，你也可以加入需要的框架。
iOS应用程序基于Foundation和UIKit框架，在开发iOS程序时，主要使用框架就是Foundation和UIKit，因为它们包含了你需要的大部分东西。
每个框架对应IOS系统里的一层，每层建立在它下面层的上面。应该尽量使用上层的框架来代替下面的框架。更高层次的框架是对底层框架基于对象的抽象。
这两个框架在系统中的位置如下图：

1. + core os 核心操作系统
2. + core services 核心服务层
3. + core os 多媒体层
4. + core os 核心触摸层（基础的UI类库，开发中经常使用到）
5. + application 应用程序层

• UIKit类层级结构
  
• Foundation框架的作用
  • Foundation框架为所有的应用程序提供基本系统服务，也就是说Foundation框架是Mac\iOS中其他框架的基础
  • Foundation框架包含了很多开发中常用的数据类型:
    • 结构体
    • 枚举
    • 类
• 如何使用Foundation框架
  • Foundation框架中大约有125个可用的头文件,作为一个简单的形式,可以简单地使用以下语句导入#import<Foundation/Foundation.h>因为Foundation.h文件实际上导入其他所有Foundation框架中的头文件
• Foundation框架中的类
  • Foundation框架允许使用一些基本对象,如数字和字符串,以及一些对象集合,如数组,字典和集合,其他功能包括处理日期和时间、内存管理、处理文件系统、存储(或归档)对象、处理几何数据结构(如点和长方形)
  • Foundation框架提供了非常多好用的类, 比如
    1. NSString : 字符串
    2. NSArray : 数组
    3. NSDictionary : 字典
    4. NSDate : 日期
    5. NSData : 数据
    6. NSNumber : 数字

• Foundation框架中的类都是以NS为前缀(Next Step的缩写)
  • 乔布斯于1976年创立苹果公司
  • 乔布斯于1985年离开苹果公司, 创立NeXT公司, 开发了Next Step操作系统
  • 在开发Next Step操作系统过程中产生了Foundation框架
  • 1997年, 苹果公司收购NeXT公司, 乔布斯重返苹果公司(Mac系统就是基于Next Step系统)
  • 2007年, 苹果公司发布了iOS系统(iOS系统基于Mac系统)

• Foundation框架常见错误
  • 有时候会在不经意之间修改了系统自带的头文件, 比如NSString.h, 这时会出现以下错误:
    
  • 解决方案, 只需要删除Xcode的缓存即可
    • 缓存路径是/Users/用户名/Library/Developer/Xcode/DerivedData(默认情况下, 这是一个隐藏文件夹)
  • 要想看到上述文件夹, 必须在终端敲指令显示隐藏文件夹, 指令如下
    

    • 显示隐藏文件 : defaults write com.apple.finder AppleShowAllFiles –bool true
    • 隐藏隐藏文件 : defaults write com.apple.finder AppleShowAllFiles –bool false
    • (输入指令后, 一定要重新启动Finder)

29.NSString和NSMutableString

• NSString其实是一个对象类型。NSString是NSObject（Cocoa Foundation的基础对象）的子类，不可改变字符串，NSMutableString为可变的字符串。
  NSString 与 char *大的区别就是 NSString是一个objective对象,而char 是一个字节数组。@+” 字符串 ” 这个符号为objective-c NSString 字符串常量的标准用法，char* 创建的时候 无需添加@。每一个字符串其实是由若干个char字符组成，字符串的遍历实际上就是将字符串中的每一个字符提取出来。
  NSString 提供2个消息，length和characterAtIndex
  NSString 核心基础接口为CFStringRef

29.1.直接读写文件中的字符

• 从文件中读取

1. // 用来保存错误信息
2. NSError *error = nil;
4. // 读取文件内容
5. NSString *str = [NSString stringWithContentsOfFile:@”/Users/XXX/Desktop/abc.txt” encoding:NSUTF8StringEncoding error:&error];
7. // 如果有错误信息
8. if (error) {
9. NSLog(@”读取失败, 错误原因是:%@”, [error localizedDescription]);
10. } else { // 如果没有错误信息
11. NSLog(@”读取成功, 文件内容是:\n%@”, str);
12. }

• 写入文件中

1. NSString *str = @”江哥”;
2. BOOL flag = [str writeToFile:@”/Users/XXX/Desktop/abc.txt” atomically:YES encoding:NSUTF8StringEncoding error:nil];
3. if (flag == 1)
4. {
5. NSLog(@”写入成功”);
6. }

• 重复写入同一文件会覆盖掉上一次的内容

1. NSString *str1 = @”支付宝”;
2. BOOL flag = [str1 writeToFile:@”/Users/XXX/Desktop/abc.txt” atomically:YES encoding:NSUTF8StringEncoding error:nil];
4. NSString *str2 = @”暖宝宝”;
5. [str2 writeToFile:@”/Users/XXX/Desktop/abc.txt” atomically:YES encoding:NSUTF8StringEncoding error:nil];
7. NSString *str = [NSString stringWithContentsOfFile:@”/Users/XXX/Desktop/abc.txt” encoding:NSUTF8StringEncoding error:&error];
8. NSLog(@”str = %@”, str);
10. 输出结果:暖宝宝

29.2.NSString大小写处理

• 全部字符转为大写字母
  • – (NSString *)uppercaseString;
• 全部字符转为小写字母
  • – (NSString *)lowercaseString
• 首字母变大写，其他字母都变小写
  • – (NSString *)capitalizedString

29.3.NSString比较

• – (BOOL)isEqualToString:(NSString *)aString;
  • 两个字符串的内容相同就返回YES, 否则返回NO

1. NSString *str1 = @”gzs”;
2. NSString *str2 = [NSString stringWithFormat:@”gzs”];
3. if ([str1 isEqualToString:str2]) {
4. NSLog(@”字符串内容一样”);
5. }
7. if (str1 == str2) {
8. NSLog(@”字符串地址一样”);
9. }

• – (NSComparisonResult)compare:(NSString *)string;
  • 这个方法可以用来比较两个字符串内容的大小
  • 比较方法: 逐个字符地进行比较ASCII值，返回NSComparisonResult作为比较结果
  • NSComparisonResult是一个枚举，有3个值:
    • 如果左侧 > 右侧,返回NSOrderedDescending,
    • 如果左侧 < 右侧,返回NSOrderedAscending,
    • 如果左侧 == 右侧返回NSOrderedSame

1. NSString *str1 = @”abc”;
2. NSString *str2 = @”abd”;
3. switch ([str1 compare:str2]) {
4. case NSOrderedAscending:
5. NSLog(@”后面一个字符串大于前面一个”);
6. break;
7. case NSOrderedDescending:
8. NSLog(@”后面一个字符串小于前面一个”);
9. break;
10. case NSOrderedSame:
11. NSLog(@”两个字符串一样”);
12. break;
13. }
14. 输出结果: 后面一个字符串大于前面一个

• – (NSComparisonResult) caseInsensitiveCompare:(NSString *)string;
  • 忽略大小写进行比较，返回值与compare:一致

1. NSString *str1 = @”abc”;
2. NSString *str2 = @”ABC”;
3. switch ([str1 caseInsensitiveCompare:str2]) {
4. case NSOrderedAscending:
5. NSLog(@”后面一个字符串大于前面一个”);
6. break;
7. case NSOrderedDescending:
8. NSLog(@”后面一个字符串小于前面一个”);
9. break;
10. case NSOrderedSame:
11. NSLog(@”两个字符串一样”);
12. break;
13. }
14. 输出结果:两个字符串一样

29.4.字符串搜索

• – (BOOL)hasPrefix:(NSString *)aString;
  • 是否以aString开头
• – (BOOL)hasSuffix:(NSString *)aString;
  • 是否以aString结尾
• – (NSRange)rangeOfString:(NSString *)aString;
  • 用来检查字符串内容中是否包含了aString
  • 如果包含, 就返回aString的范围
  • 如果不包含, NSRange的location为NSNotFound, length为0

29.5.NSRange基本概念

• NSRange是Foundation框架中比较常用的结构体, 它的定义如下:

1. typedef struct _NSRange {
2. NSUInteger location;
3. NSUInteger length;
4. } NSRange;
5. // NSUInteger的定义
6. typedef unsigned int NSUInteger;

• NSRange用来表示事物的一个范围,通常是字符串里的字符范围或者数组里的元素范围
• NSRange有2个成员
  • NSUInteger location : 表示该范围的起始位置
  • NSUInteger length : 表示该范围内的长度
• 比如@“I love GZS”中的@“ GZS”可以用location为7，length为3的范围来表示

29.6.NSRange的创建

• 有3种方式创建一个NSRange变量
• 方式1

1. NSRange range;
2. range.location = 7;
3. range.length = 3;

• 方式2

1. NSRange range = {7, 3};
2. 或者
3. NSRange range = {.location = 7,.length = 3};

• 方式3 : 使用NSMakeRange函数

NSRange range = NSMakeRange(7, 3);

29.7.字符串的截取

• – (NSString *)substringFromIndex:(NSUInteger)from;
  • 从指定位置from开始(包括指定位置的字符)到尾部
    1. NSString *str = @”<head>暖宝宝</head>“;
    2. str = [str substringFromIndex:7];
    3. NSLog(@”str = %@”, str);
    5. 输出结果: 暖宝宝</head>

• – (NSString *)substringToIndex:(NSUInteger)to;
  • 从字符串的开头一直截取到指定的位置to，但不包括该位置的字符
    1. NSString *str = @”<head>暖宝宝</head>”;
    2. str = [str substringToIndex:10];
    3. NSLog(@”str = %@”, str);
    5. 输出结果: <head>暖宝宝

• – (NSString *)substringWithRange:(NSRange)range;
  • 按照所给出的NSRange从字符串中截取子串
    1. NSString *str = @”<head>暖宝宝</head>”;
    2. NSRange range;
    3. /*
    4. range.location = 6;
    5. range.length = 3;
    6. */
    7. range.location = [str rangeOfString:@”>”].location + 1;
    8. range.length = [str rangeOfString:@”</”].location – range.location;
    9. NSString *res = [str substringWithRange:range];
    10. NSLog(@”res = %@”, res);
    11. 输出结果: 暖宝宝

29.8.字符串的替换函数

• – (NSString )stringByReplacingOccurrencesOfString:(NSString )target withString:(NSString *)replacement;
  • 用replacement替换target

1. NSString *str = @”http:**baidu.com*img*ljn.gif”;
2. NSString *newStr = [str stringByReplacingOccurrencesOfString:@”*” withString:@”/”];
3. NSLog(@”newStr = %@”, newStr);
5. 输出结果: http://www.baidu.com/img/ljn.gif

• – (NSString )stringByTrimmingCharactersInSet:(NSCharacterSet )set;
  • 去除首尾

1. NSString *str = @” http://baidu.com/img/ljn.gif “;
2. NSString *newStr = [str stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
3. NSLog(@”str =|%@|”, str);
4. NSLog(@”newStr =|%@|”, newStr);
6. 输出结果:
7. str =| http://baidu.com/img/ljn.gif |
8. newStr =|http://baidu.com/img/ljn.gif|

1. NSString *str = @”***http://baidu.com/img/ljn.gif***”;
2. NSString *newStr = [str stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@”*”]];
4. NSLog(@”str =|%@|”, str);
5. NSLog(@”newStr =|%@|”, newStr);
7. 输出结果:
8. str =|***http://baidu.com/img/ljn.gif***|
9. newStr =|http://baidu.com/img/ljn.gif|

---

29.9.NSString与路径

• – (BOOL)isAbsolutePath;
  • 是否为*对路径
    1. // 其实就是判断是否以/开头
    2. // NSString *str = @”/Users/My-Lee/Desktop/bai.txt”;
    3. NSString *str = @”Users/My-Lee/Desktop/bai.txt”;
    4. if ([str isAbsolutePath]) {
    5. NSLog(@”是*对路径”);
    6. }else
    7. {
    8. NSLog(@”不是*对路径”);
    9. }

• – (NSString *)lastPathComponent;
  • 获得*后一个目录
    1. // 截取*后一个/后面的内容
    2. NSString *str = @”/Users/My-Lee/Desktop/bai.txt”;
    3. NSString *component = [str lastPathComponent];
    4. NSLog(@”component = %@”, component);

• – (NSString *)stringByDeletingLastPathComponent;
  • 删除*后一个目录
    1. // 其实就是上次*后一个/和之后的内容
    2. NSString *str = @”/Users/My-Lee/Desktop/bai.txt”;
    3. NSString *newStr = [str stringByDeletingLastPathComponent];
    4. NSLog(@”newStr = %@”, newStr);

• – (NSString )stringByAppendingPathComponent:(NSString )str;
  • 在路径的后面拼接一个目录
    (也可以使用stringByAppendingString:或者stringByAppendingFormat:拼接字符串内容)
    1. // 其实就是在*后面加上/和要拼接得内容
    2. // 注意会判断后面有没有/有就不添加了, 没有就添加, 并且如果有多个会替换为1个
    3. // NSString *str = @”/Users/My-Lee/Desktop”;
    4. NSString *str = @”/Users/My-Lee/Desktop/”;
    5. NSString *newStr = [str stringByAppendingPathComponent:@”bai”];
    6. NSLog(@”newStr = %@”, newStr);

29.10.NSString与文件拓展名

• – (NSString *)pathExtension;
  • 获得拓展名
    1. // 其实就是从*后面开始截取.之后的内容
    2. // NSString *str = @”abc.txt”;
    3. NSString *str = @”abc.txt”;
    4. NSString *extension = [str pathExtension];
    5. NSLog(@”extension = %@”, extension);

• – (NSString *)stringByDeletingPathExtension;
  • 删除尾部的拓展名
    1. // 其实就是上次从*后面开始.之后的内容
    2. // NSString *str = @”abc.txt”;
    3. NSString *str = @”abc.txt”;
    4. NSString *newStr = [str stringByDeletingPathExtension];
    5. NSLog(@”newStr = %@”, newStr);

• – (NSString )stringByAppendingPathExtension:(NSString )str;
  • 在尾部添加一个拓展名
    1. // 其实就是在*后面拼接上.和指定的内容
    2. NSString *str = @”abc”;
    3. NSString *newStr = [str stringByAppendingPathExtension:@”gif”];
    4. NSLog(@”newStr = %@”, newStr);

29.11.字符串和其他数据类型转换

• 转为基本数据类型
  • – (double)doubleValue;
  • – (float)floatValue;
  • – (int)intValue;
    1. NSString *str1 = @”110″;
    2. NSString *str2 = @”10″;
    3. int res = str1.intValue + str2.intValue;
    4. NSLog(@”res = %i”, res);
    1. NSString *str1 = @”110″;
    2. NSString *str2 = @”10.1″;
    3. double res = str1.doubleValue + str2.doubleValue;
    4. NSLog(@”res = %f”, res);

• 转为C语言中的字符串
  • – (char *)UTF8String;
    1. NSString *str = @”abc”;
    2. const char *cStr = [str UTF8String];
    3. NSLog(@”cStr = %s”, cStr);
    1. char *cStr = “abc”;
    2. NSString *str = [NSString stringWithUTF8String:cStr];
    3. NSLog(@”str = %@”, str);

29.12.NSMutableString 基本概念

• NSMutableString 类 继承NSString类,那么NSString

大纲

---

• 0.OC数据类型
• 1.声明一个类
• 2.实现一个类
• 3.创建一个对象
• 4.对象的注意点
• 5.对象方法
• 6.类方法
• 7.getter/setter方法
• 8.点语法
• 9.self关键字
• 10.OC中的继承
• 11.super关键字
• 12.OC中的多态
• 13.实例变量访问修饰符
• 14.私有变量和私有方法
• 15.@property概念
• 16.@property修饰符
• 17.id类型
• 18.new方法实现原理
• 19.构造方法
• 20.instancetype与id
• 21.类的启动过程
• 22.SEL介绍
• 23.@class使用
• 24.注释和指令
• 25.分类
• 26.Block

---

0.OC中的数据类型

• OC是增强了C的特性，所以在变量和基本数据类型上基本与C一致。
• 在OC中变量命名有如下规则：
  • 由字母、数字、下划线、$符号组成
  • 必须以字母、下划线、$符号开头
  • 大小写敏感
• OC中有如下基本数据类型：

• 数据类型格式化字符：

• 举例

1. #import <Foundation/Foundation.h>
3. int main(int argc, const char * argv[])
4. {
6. @autoreleasepool {
8. //保留字是不能定义为变量名的，例如下面的int、float等就不能作为变量名
9. int i = 2;
10. float f = 2.3f;
11. double d = 2.3e12;
12. char c = ‘a’;
14. //输出数据
15. NSLog(@”i : %d”,i);
16. NSLog(@”f : %f 截取后 : %.2f”,f,f);
17. NSLog(@”d : %e 截取后 : %.2e”,d,d);
18. NSLog(@”c : %c , %d”,c ,c );
20. //数据转换
21. //数据类型容量大的转成小的可能会丢失精度
22. int i2 = (int)f;
23. float f2 = (float)i ;
25. NSLog(@”数据转换”);
26. NSLog(@”i2 : %d”,i2);
27. NSLog(@”f2 : %f”,f2);
29. NSLog(@”变量的作用域”);
30. if(YES){
31. int i3 = 2;
32. NSLog(@”i3 : %d”,i3);
33. }
34. //在if的{}外面是无法访问到内部的i3变量的，因为i3变量的作用域就只是那对{}内部
35. //NSLog(@”i3 : %d”,i3);
36. /*
37. 运行结果
38. [859:303] i : 2
39. [859:303] f : 2.300000 截取后 : 2.30
40. [859:303] d : 2.300000e+12 截取后 : 2.30e+12
41. [859:303] c : a , 97
42. [859:303] 数据转换
43. [859:303] i2 : 2
44. [859:303] f2 : 2.000000
45. */
46. }
47. return 0;
48. }

1.声明一个类

• 格式
  
• 注意：
  • 1.必须以@interface开头，@end结尾
  • 2.成员变量的声明，必须写在@interface与@end之间的大括号中
  • 3.方法的声明必须在{}下面，不能写在{}中

---

2.实现一个类

• 格式

1. @implementation MyClass
3. // 对象方法
4. – (id)initWithString:(NSString *)aName
5. {
6. //TODO
7. }
9. // 类方法
10. + (MyClass *)myClassWithString:(NSString *)aName
11. {
12. //TODO
13. }
15. @end

• 注意：
  • 1.必须以@implementation开头，@end结尾
  • 2.类名必须和声明的一致

3.创建一个对象

• 用类的方式告诉计算机，我们需要一个什么样的对象，之后我们要在程序中使用这个对象，就必须先创建一个对象

• 注意[Car new];做了三件事
  • 1.在堆内存中开辟了一块新的存储空间
  • 2.初始化成员变量(写在类声明大括号中的属性就叫成员变量,也叫实例变量)
  • 3.返回指针地址
• 消息机制
  • 使用对象调用方法就是OC中的消息机制
  • OC中调用方法的格式：[类名或者对象名 方法名];
    

4.对象的注意点

• 可以通过 对象->对象成员(注意声明属性为:@public) 的方式访问对象中的成员,
• 每一个对象中都有一份属于自己的属性。
• 对其中一个对象的成员进行了修改。和另一个对象没有关系

5.对象方法

5.1.对象方法的声明

• 格式
  
• 特征
  • 对象方法以-开头如 -(void)xx;
  • 对象方法只能由对象来调用
  • 对象方法中可以访问当前对象的成员变量
  • 调用格式 [对象名 对象方法名];
• 示例
  • 在MyClass.h文件中声明

1. @interface MyClass : NSObject
3. //声明没有返回值的方法
4. – (void)method;
5. //声明有返回值的方法
6. – (int)newMethod;
7. //声明有返回值有参数的方法
8. – (int)method: (int)var;
9. //声明有返回值有多个参数的方法
10. – (int)method: (int)var1 andVar2: (int)var2;
12. @end

5.2.对象方法实现

• 在MyClass.m文件中实现

1. @implementation MyClass
3. //声明没有返回值的方法
4. – (void)method{
5. // TODO
6. }
7. //声明有返回值的方法
8. – (int)newMethod{
9. // TODO
10. return 10;
11. }
12. //声明有返回值有参数的方法
13. – (int)method: (int)var{
14. // TODO
15. return 20;
16. }
17. //声明有返回值有多个参数的方法
18. – (int)method: (int)var1 andVar2: (int)var2{
19. // TODO
20. return 30;
21. }
23. @end

• 必须以@implementation开头，@end之间
• 在声明的后面加上{}即表示实现
• 需要实现的代码写在{}中

6.类方法

6.1.类方法声明

• 格式
  • 将对象方法-号变为+号
• 特征（很像java中静态方法）
  • 类方法以+开头 如+(void)put;
  • 类方法只能由类来调用
  • 类方法中不能访问实例(成员)变量,因为类方法由类来调用,并没有创建存储空间 来存储类中的成员变量。
• 类方法的好处:
  • 节省内存空间
  • 不依赖于对象,执行效率更高;
  • 能用类方法解决的问题,尽量使用类方法;
• 类方法的场合:
  • 当方法内部不需要使用到成员变量时,可以改为类方法
  • 类方法一般用于编写工具方法
• 示例

1. //声明没有返回值的方法
2. + (void)method;
3. //声明有返回值的方法
4. + (int) newMethod;
5. //声明有返回值有参数的方法
6. + (int)method: (int)var;
7. //声明有返回值有多个参数的方法
8. + (int)method: (int)var1 andVar2: (int)var2;

6.2.类方法实现

1. //声明没有返回值的方法
2. + (void)method{
3. // TODO
4. }
5. //声明有返回值的方法
6. + (int)newMethod{
7. // TODO
8. return 10;
9. }
10. //声明有返回值有参数的方法
11. + (int)method: (int)var{
12. // TODO
13. return 20;
14. }
15. //声明有返回值有多个参数的方法
16. + (int)method: (int)var1 andVar2: (int)var2{
17. // TODO
18. return 30;
19. }

• 必须卸载以@implementation开头，@end之间
• 在声明的后面加上{}即表示实现
• 将需要实现的代码写在{}中

6.3.对象方法和类方法区别

• 对象方法
  • 对象方法是属于对象的
  • 以减号-开头
  • 只能让对象调用，没有对象，这个方法根本不可能被执行
  • 对象方法能访问实例变量（成员变量）
  • 对象方法中可以调用当前对象的对象方法
  • 对象方法中可以调用其他对象的对象方法
  • 对象方法中不可以调用类方法
• 类方法
  • 类方法是属于类的
  • 以加号+开头
  • 只能用类名调用，对象不能调用
  • 类方法中不能直接访问实例变量（成员变量）
  • 类方法中不能直接调用对象方法，要想调用对象方法，必须创建或传入对象。
• 使用场合：
  • 当不需要访问成员变量的时候，尽量用类方法
• 类方法和对象方法可以同名

7.getter/setter方法

• 代码实现和java基本一样

1. @interface MyClass()
2. {
3. // 定义一个NSString（字符串）类型的属性Name
4. NSString *Name;
5. }
6. @end
8. @implementation MyClass
10. // setter方法
11. – (void)setName:(NSString *)name{
12. Name = name;
13. }
15. // getter方法
16. – (NSString *)name{
17. return name;
18. }
19. @end

8.点语法

8.1点语法的本质

• 其实点语法的本质还是方法调用
• 当使用点语法时，编译器会自动展开成相应的方法

• 当点语法使用在 “=“赋值符号左侧的时候，点语法会被展开为setter方法的调用，其他情况（等号右侧、直接使用）为点语法展开为getter方法的调用

8.2点语法注意点

• 点语法的本质是方法的调用,而不是访问成员变量,当使用点语法时,编译器会自动展开成相应的方法调用。
• 点语法的本质是转换成相应的对setter和getter方法调用,如果没有set和get方法,则不能使用点语法。
• 不在要再getter 与 setter方法中使用本属性的点语法

1. – (void) setAge:(int)age {
2. // 下面的代码会引发死循环
3. self.age = age;
4. //编译器展开后 [self setAge:age]
5. }
8. – (int) age {
9. // 下面的代码会引发死循环
10. return self.age;
11. // 编译器展开后 [self age]
12. }

9.self关键字

• oc语言中的self，相当于java中的this关键字。
• 在类方法中的self，代表的是类对象，可以通过self调用该类对象的其他类方法。
• 在对象方法中self，代表的是该类的对象，可以通过self 关键字调用该对象的其他对象方法，同时也可以访问成员变量。

总结

• 谁调用self所在的方法，那么self就是谁
• self在类方法中就是这个类的类对象，全局只有一个，可通过self本类中的其他类方法，但是不能通过self来调用对象方法或访问成员变量
• self在对象方法中，就是调用这个方法的那个对象， 可以通过self调用其他本类中其他的对象方法，访问成员变量，但不能通过self调用本类的类方法。
  • 通过self调用方法的格式：[self 方法名];
  • 通过self访问成员变量格式：self->成员变量名

10.OC中的继承

10.1继承语法

• 在声明子类的时候，在子类名称后面通过：父类名称方式来实现继承。
  和java一样，OC也不能多继承。

1. @interface 子类名称 : 父类名称
3. @end

10.2方法重写

• 在子类中实现与父类中同名的方法，称之为方法重写；
• 重写以后当给子类发送这个消息的时候，执行的时在子类中重写的那个方法，而不是父类中的方法。
• 如果在想在子类中调用被子类重写的父类的方法，可以通过super关键字
• 使用场景：当从父类继承的某个方法不适合子类,可以在子类中重写父类的这个方法。

1. – (void)viewDidLoad {
2. // 调用父类的viewDidLoad方法。
3. [super viewDidLoad];
4. // 在重写方法中做一些操作
5. NSLog(@”%@”,@”my first iOS project”);
7. }

11.super关键字

• 直接调用父类中的某个方法
• super在对象方法中，那么就会调用父类的对象方法
  super在类方法中，那么就会调用父类的类方法

12.OC中的多态

• Animal是父类,子类有Cat 和 Dog,子类分别重写了父类中的eat方法;实例化对象的时候可以用下面的方法:

1. Animal *animal = nil;
3. //实例化猫的对象
4. animal = [Cat new];
5. [animal eat];
7. //实例化狗的对象
8. animal = [Dog new];
9. [animal eat];

13.实例变量访问修饰符

13.1.实例变量的作用域

@public

• 可以在其它类中访问被public修饰的成员变量
• 也可以在本类中访问被public修饰的成员变量
• 可以在子类中访问父类中被public修饰的成员变量

  @private

• 不可以在其它类中访问被private修饰的成员变量
• 可以在本类中访问被private修饰的成员变量
• 不可以在子类中访问父类中被private修饰的成员变量

  @protected

• 不可以在其它类中访问被protected修饰的成员变量
• 可以在本类中访问被protected修饰的成员变量
• 可以在子类中访问父类中被protected修饰的成员变量

  注意: 默认情况下所有的实例变量都是protected

  @package

• 介于public和private之间的
• 如果是在其它包中访问那么就是private的
• 如果是在当前代码所在的包种访问就是public的

1. @interface Person : NSObject
2. {
3. @public
4. int _age;
6. @private
7. double _height;
9. @protected// 默认就是protected
10. double _weight;
12. @package// 相当于public
13. NSString *_name;
14. NSString *_tel;
15. NSString *_email;
16. }
17. @end

14.私有变量和私有方法

• 在类的实现即.m文件中也可以声明成员变量,但是因为在其他文件中通常都只是包含头文件而不会包含实现文件,所以在.m文件中声明的成员变量是@private的。在.m中定义的成员变量不能和它的头文件.h中的成员变量同名。

1. @interface MyClass()
2. {
3. NSString *Name;
4. }
5. @end
7. @implementation MyClass
8. //在.h文件中没有声明，只在.m文件中实现就是私有方法
9. – (void)method{
11. // TODO
12. }
13. @end

15.@property概念

• @property是一个编译器指令。我*喜欢的一个功能之一。在java中类的每一个属性都有对应getter/setter方法。Eclipse等之类的IDE开发工具也集成了自动生成属性的getter/setter方法功能，但是还是需要程序员自己选中需要生成代码的属性然后生成。在oc中你只需要像这样一句话。So easy！
  1. @interface Person : NSObject
  3. @property int age;
  5. @end

• 在使用@property定义属性之后，编译器都帮我们干了什么？
  • Xcode4.4之前
    编译器只要看到@property, 就知道我们要生产某一个属性的getter/setter方法的声明，相当于实现了如下的两个方法声明。
    1. – (void)setAge:(int)age;
    2. – (int)age;

  • Xcode4.4之后有爱的Apple对@property进行了一个增强。
    1.利用@property可以同时自动生成setter/getter方法的声明和实现。
    2.利用@property来生成getter/setter方法, 那么我们可以不写成员变量, 系统会自动给我们生成一个_开头的成员变量（@property自动帮我们生成的成员变量是一个私有的成员变量, 也就是说是在.m文件中生成的, 而不是在.h文件中生成的）
    1. //Person.h文件
    2. @interface Person : NSObject
    4. @property int age;
    5. /*
    6. // 相当于生成了如下的getter/setter方法的声明
    7. – (void)setAge:(int)age;
    8. – (int)age
    9. */
    10. @end
    12. //Person.m文件
    13. #import “Person.h”
    14. @@implementation Person
    16. @property int age;
    17. /*
    18. // 相当于生成了如下的getter/setter方法的实现
    19. – (void)setAge:(int)age
    20. {
    21. //_age编译器自动帮我们生成的私有成员变量
    22. _age = age;
    23. }
    24. – (int)age
    25. {
    26. return _age;
    27. }
    28. */
    29. @end

    3.@property只会生成*简单的getter/setter方法,而不会进行数据判断。如果想对传入的数据进行过滤, 那么我们就必须重写getter/setter方法。如果不想对传入的数据进行过滤, 仅仅是提供一个方法给外界操作成员变量, 那么就可以使用@property。

    • 如果重写了setter方法, 那么@property就只会生成getter方法
      1. - (void)setAge:(int)age
      2. {
      3. //对传递过来的age进行过滤
      4. if (age < 0) {
      5. age = 0;
      6. }
      7. _age = age;
      8. }

    • 如果重写了getter方法, 那么@property就只会生成setter方法
      1. – (int)age
      2. {
      3. return _age;
      4. }
      • 如果同时重写了getter/setter方法, 那么@property就不会自动帮我们生成私有的成员变量。
        

16. @property修饰符

• 修饰是否生成getter方法的
  • readonly 只生成setter方法，不生成getter方法
  • readwrite 既生成getter 又生成setter方法（默认）

    @property (readonly) int age;

• 指定所生成的方法的方法名称
  • getter=你定制的getter方法名称
  • setter=你定义的setter方法名称(注意setter方法必须要有 🙂
    1. @property (getter=isMarried) BOOL married;
    2. 说明，通常BOOL类型的属性的getter方法要以is开头

• 多线程管理
  • atomic  :性能低(默认) 
  • nonatomic  :性能高(iOS开发中都用这个属性)

    @property (nonatomic)  NSString  *name;

• 控制set方法的内存管理
  MRC（手动引用计数）
  • retain  :  release旧值,retain新值(用于OC对象) 
  • assign  :  直接赋值,不做任何内存管理(默认,用于非OC对象类型) 
  • copy  :  release旧值,copy新值(一般用于NSString  *)

    ARC（自动引用计数）

  • strong  :  强引用，相当于MRC下的retain。用于OC对象。
  • weak  :  弱引用，相当于MRC下的assign。一般用来防止循环引用。
  • copy  :  release旧值,copy新值(一般用于NSString  *)
    1. // MRC
    2. @property (nonatomic, retain) User *user;
    3. @property (nonatomic, assign) int age;
    4. @property (nonatomic, copy) NSString *name;
    6. // ARC
    7. @property (nonatomic, strong) User *user;
    8. @property (nonatomic, assign) int age;
    9. @property (nonatomic, weak) UIView *view;
    10. @property (nonatomic, copy) NSString *name;
    12. 说明，此处大概了解下内存管理，后面会详细的说明。

• 总结
  

17.id类型

17.1.静态类型和动态类型

• 静态类型
  • 在编译的时候就知道这个指针变量所属的类,这个这个变量总是存储特定类的对象。

    Person *p = [Person new];

• 动态类型
  • 这一特性是程序直到执行时才确定对象所属的类

    id obj = [Person new];

17.2.为什么要有动态类型?

• 我们知道NSObject是OC中的基类（相当于java中object）
• 那么任何对象的NSObject类型的指针可以指向任意对象，都没有问题
• 但是NSObject是静态类型，如果通过它直接调用NSObject上面不存在的方法，编译器会报错。
• 你如果想通过NSObject的指针调用特定对象的上面，就必须把NSObject * 这种类型强转成特定类型。然后调用。如下

1. //定义NSObject * 类型
2. NSObject* obj = [Cat new];
3. //需要强制类型转换
4. Cat *c = (Cat*)obj
5. [c eat];

• id 是一种通用的对象类型,它可以指向属于任何类的对象,也可以理解为万能指针 ,相当于C语言的 void *
• 因为id是动态类型,所以可以通过id类型直接调用指向对象中的方法, 编译器不会报错

1. /// Represents an instance of a class.
2. struct objc_object {
3. Class isa OBJC_ISA_AVAILABILITY;
4. };
6. /// A pointer to an instance of a class.
7. typedef struct objc_object *id;

1. id obj = [C at new];
2. [obj eat]; // 不用强制类型转换
4. [obj test]; //可以调用私有方法

• 注意：
  • 在id的定义中,已经包好了*号。Id指针只能指向OC中的对象
  • 为了尽可能的减少编程中出错，Xcode做了一个检查，当使用id 类型的调用本项目中所有类上都没有的方法，编译器会报错
  • id类型不能使用.语法, 因为.语法是编译时特性, 而id是运行时特性

17.3.id数据类型与静态类型

• 虽然说id数据类型可以存储任何类型的对象，但是不要养成滥用这种通用类型
  • 如没有使用到多态尽量使用静态类型
  • 静态类型可以更早的发现错误(在编译阶段而不是运行阶段)
  • 静态类型能够提高程序的可读性
  • 使用动态类型前*好其真实类型
• 动态类型判断类型
  • – (BOOL)isKindOfClass:classObj 判断实例对象是否是这个类或者这个类的子类的实例

1. Person *p = [Person new];
2. Student *stu = [Student new];
4. BOOL res = [p isKindOfClass:[Person class]];
5. NSLog(@“res = %i”, res); // YES
6. res = [stu isKindOfClass:[Person class]];
7. NSLog(@“res = %i”, res); // YES

• – (BOOL) isMemberOfClass: classObj 判断是否是这个类的实例

1. Person *p = [Person new];
2. Student *stu = [Student new];
4. BOOL res = [p isMemberOfClass:[Person class]];
5. NSLog(@“res = %i”, res); // YES
6. res = [stu isMemberOfClass:[Person class]];
7. NSLog(@“res = %i”, res); // NO

• + (BOOL) isSubclassOfClass:classObj 判断类是否是指定类的子类)

1. BOOL res = [Person isSubclassOfClass:[Student class]];
2. NSLog(@“res = %i”, res); // NO
4. res = [Student isSubclassOfClass:[Person class]];
5. NSLog(@“res = %i”, res); // YES

18.new方法实现原理

• java中创建一个对象:Person person = new Person();
  在OC中创建一个可用的对象:Person *p=[Person new];
  new方法的内部会分别调用两个方法来完成3件事情:
  • (1)使用alloc方法来分配存储空间(返回分配的对象);
  • (2)使用init方法来对对象进行初始化。
  • (3)返回对象的首地址

This method is a combination of alloc and init. Like alloc, it initializes the isa instance variable of the new object so it points to the class data structure. It then invokes the init method to complete the initialization process.

• 可以把new方法拆开如下:
  • (1).调用类方法+alloc分配存储空间,返回未经初始化的对象Person *p1=[person alloc];
  • (2).调用对象方法-init进行初始化,返回对象本身
    Person *p2=[p1 init];
  • (3).以上两个过程整合为一句:Person *p=[[Person alloc] init];
• 说明：
  • alloc 与 init合起来称为构造方法，表示构造一个对象
  • alloc 方法为对象分配存储空间，并将所分配这一块区域全部清0.

    The isa instance variable of the new instance is initialized to a data structure that describes the class; memory for all other instance variables is set to 0.

  • init方法是初始化方法（构造方法），用来对象成员变量进行初始化，默认实现是一个空方法。

    An object isn’t ready to be used until it has been initialized. The init method defined in the NSObject class does no initialization; it simply returns self.

• 所以下面两句的作用是等价的
  1. Person *p1 = [Person new];
  2. Person *p = [[Person alloc] init];// 一般使用该方式创建对象

• iOS 程序通常使用[[类名 alloc] init] 的方式创建对象，因为这个可以与其他initWithXX:…的初始化方法统一起来，代码风格保持一致。

19.构造方法

19.1.默认构造方法

• OC的构造方法是以init开头，会java的同学要哭死了，然并卵。

1. – (id)init {
2. self = [super init];
3. if (self) {
4. // Initialize self.
5. }
6. return self;
7. }
9. //或者也可以这样
10. //- (id)init {
11. – (instancetype)init {
12. if (self = [super init]) {
13. // Initialize self.
14. }
15. return self;
16. }

• [super init]的作用:
  先利用父类的init方法为子类实例的父类部分属性初始化。稍微会点java的都知道什么意思，就不过多解释了。
• self 为什么要赋值为[super init]:
  简单来说是为了防止父类的初始化方法release掉了self指向的空间并重新alloc了一块空间。还有[super init]可能alloc失败,这时就不再执行if中的语句。

19.2自定义构造方法

• 自定义构造方法的规范
  • (1)一定是对象方法,以减号开头
  • (2)返回值一般是instancetype类型
  • (3)方法名必须以initWith开头
• 自定义构造方法的声明

1. @interface Person : NSObject
3. @property int age;
5. @property NSString *name;
7. // 当想让对象一创建就拥有一些指定的值,就可以使用自定义构造方法
8. – (instancetype)initWithAge:(int)age;
10. – (instancetype)initWithName:(NSString *)name;
12. – (instancetype)initWithAge:(int)age andName:(NSString *)name;
14. @end

• 自定义构造方法的实现

1. #import “Person.h”
3. @implementation Person
5. – (instancetype)init
6. {
7. if (self = [super init]) {
8. _age = 10;
9. }
10. return self;
11. }
13. – (NSString *)description
14. {
15. return [NSString stringWithFormat:@”age = %i, name = %@”, _age, _name];
16. }
18. – (instancetype)initWithAge:(int)age
19. {
20. if (self = [super init]) {
21. _age = age;
22. }
23. return self;
24. }
26. – (instancetype)initWithName:(NSString *)name
27. {
28. if (self =[super init]) {
29. _name = name;
30. }
31. return self;
32. }
34. – (instancetype)initWithAge:(int)age andName:(NSString *)name
35. {
36. if (self = [super init]) {
37. _age = age;
38. _name = name;
39. }
40. return self;
41. }

19.3.自定义类工厂方法

• 类工厂方法
  • 用于快速创建对象的类方法, 我们称之为类工厂方法
  • 类工厂方法中主要用于 给对象分配存储空间和初始化这块存储空间
• 规范:
  • 一定是类方法 +
  • 方法名称以类的名称开头, 首字母小写
  • 一定有返回值, 返回值是id/instancetype
• 自定义类工厂方法声明

1. #import <Foundation/Foundation.h>
3. @interface Person : NSObject
5. @property int age;
6. + (instancetype)person;
8. + (instancetype)personWithAge:(int)age;
9. @end

• 自定义类工厂方法实现

1. #import “Person.h”
3. @implementation Person
5. + (instancetype)person
6. {
7. return [[Person alloc] init];
8. }
10. + (instancetype)personWithAge:(int)age
11. {
12. Person *p = [[Person alloc] init];
13. p.age = age;
14. return p;
15. }
17. @end

20. instancetype与id

• instancetype == id == 万能指针 == 指向一个对象。
• id在编译的时候不能判断对象的真实类型
• instancetype在编译的时候可以判断对象的真实类型
• instancetype与id相似，不过instancetype只能作为方法返回值，它会进行类型检查，如果创建出来的对象，赋值了不相干的对象就会有一个警告信息，防止出错。id类型可以作为形参，也可以作为方法的返回值。

1. // init此时返回值是id
2. NSString *str = [[Person alloc] init];
3. // Person并没有length方法, 但是id是动态类型, 所以编译时不会报错
4. NSLog(@”length = %i”, str.length);
6. —————————-
8. // init此时返回值是instancetype
9. // 由于instancetype它会进行类型检查, 所以会报警告
10. NSString *str = [[Person alloc] init];
11. NSLog(@”length = %i”, str.length);
13. —————————-
14. instancetype *p = [[person alloc] init];
15. // 错误写法instancetype只能作为返回值

21.类的启动过程

21.1.+load方法

• 在程序启动的时候会加载所有的类和分类，并调用所有类和分类的+load方法(只会调用一次)
• load方法加载顺序，在运行时会加载到内存中，会先加载父类的load方法，子类的load方法会在所有的父类加载完之后被加载。*后会是子类的load方法。
• 不管程序运行过程有没有用到这个类，都会调用+load加载

1. @implementation Person
3. + (void)load
4. {
5. NSLog(@”%s”, __func__);
6. }
7. @end
9. @implementation Student : Person
11. + (void)load
12. {
13. NSLog(@”%s”, __func__);
14. }
15. @end
17. 输出结果:
18. +[Person load]
19. +[Student load]

21.2.+initialize

• 在*次使用某个类时（比如创建对象等），只会调用一次+initialize方法
• 一个类只会调用一次+initialize方法，先调用父类的，再调用子类的
• initlalize方法方法是在类或它的子类收到*条消息之前被调用的，这里所指的消息包括实例方法和类方法的调用。也就是说 +initialize 方法是以懒加载的方式被调用的，如果程序一直没有给某个类或它的子类发送消息，那么这个类的 +initialize 方法是永远不会被调用的。那这样设计有什么好处呢？好处是显而易见的，那就是节省系统资源，避免浪费。

1. @implementation Person
2. + (void)initialize
3. {
4. NSLog(@”%s”, __func__);
5. }
6. @end
8. @implementation Student : Person
9. + (void)initialize
10. {
11. NSLog(@”%s”, __func__);
12. }
13. @end
14. int main(int argc, const char * argv[]) {
15. Student *stu = [Student new];
16. return 0;
17. }
18. 输出结果:
19. +[Person initialize]
20. +[Student initialize]

• +load 和 +initialize 总结

22.SEL介绍

22.1.SEL类型

• SEL类型代表着方法的签名，在类对象的方法列表中存储着该签名与方法代码的对应关系
• 每个类的方法列表都存储在类对象中
• 每个方法都有一个与之对应的SEL类型的对象
• 根据一个SEL对象就可以找到方法的地址，进而调用方法
• SEL类型的定义
  • typedef struct objc_selector *SEL;
• 首先把test这个方法名包装成sel类型的数据
• 根据SEL数据到该类的类对象上去找，对应的方法的代码，如果找到了就执行该代码
• 如果没有找到根据类对象上的父类的类对象指针，去父类的类对象中查找，如果找到了，则执行父类的代码
• 如果没有找到，一直像上找，直到基类(NSObject)
• 如果都没有找到就报错。
• 注意：
  • 在这个操作过程中有缓存,*次找的时候是一个一个的找,非常耗性能,之后再用到的时候就直接使用。
  • 个人理解在*次查找的时候会速度比较慢，消耗性能，之后在使用的时候应该会先从缓存中进行查找，如果没有，在按照上边的步骤进行查找。找到之后会先缓存，在执行。

1. Dog *dog=[[Dog alloc] init];
2. [dog eat];

22.2.SEL使用

• 定义普通的变量
  • 如：SEL sel = @selector(show);
• 作为方法实参与NSObject配合使用
• 检验对象是否实现了某个方法
  • – (BOOL) respondsToSelector: (SEL)selector 判断实例是否实现这样方法
  • + (BOOL)instancesRespondToSelector:(SEL)aSelector;

1. BOOL flag;
2. // [类 respondsToSelector]用于判断是否包含某个类方法
3. flag = [Person respondsToSelector:@selector(objectFun)]; //NO
4. flag = [Person respondsToSelector:@selector(classFun)]; //YES
6. Person *obj = [[Person alloc] init];
8. // [对象 respondsToSelector]用于判断是否包含某个对象方法
9. flag = [obj respondsToSelector:@selector(objectFun)]; //YES
10. flag = [obj respondsToSelector:@selector(classFun)]; //NO
12. // [类名 instancesRespondToSelector]用于判断是否包含某个对象方法
13. // instancesRespondToSelectorr只能写在类名后面, 等价于 [对象 respondsToSelector]
14. flag = [Person instancesRespondToSelector:@selector(objectFun)]; //YES
15. flag = [Person instancesRespondToSelector:@selector(classFun)]; //NO

• 让对象执行某个方法
  • – (id)performSelector:(SEL)aSelector;
  • – (id)performSelector:(SEL)aSelector withObject:(id)object;
  • – (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;
    • respondsToSelector注意点: 如果是通过一个对象来调用该方法那么会判断该对象有没有实现-号开头的方法，如果是通过类来调用该方法, 那么会判断该类有没有实现+号开头的方法

1. Person *p = [Person new];
2. SEL s1 = @selector(objectFun);
3. [p performSelector:s1];
5. SEL s2 = @selector(objectFun:);
6. [p performSelector:s2 withObject:@“seltest”];
8. SEL s3 = @selector(objectFun:value2:);
9. [p performSelector:s3 withObject:@“gzs” withObject:@“seltest”];
11. SEL s4 = @selector(classFun);
12. [Person performSelector:s4];
14. SEL s5 = @selector(classFun:);
15. [Person performSelector:s5 withObject:@“seltest”];
17. SEL s6 = @selector(classFun:value2:);
18. [Person performSelector:s6 withObject:@“seltest” withObject:@“seltest2”];

• 作为方法形参

1. @implementation Person
3. - (void)makeObject:(id) obj performSelector:(SEL) selector
4. {
5. [obj performSelector:selector];
6. }
7. @end
9. int main(int argc, const char * argv[]) {
11. Person *p = [Person new];
12. SEL s1 = @selector(eat);
13. Dog *d = [Dog new];
14. [p makeObject:d performSelector:s1];
16. return 0;
17. }

---

22.3.OC方法查找顺序

• 1.给实例对象消息的过程(调用对象方法)
  • 根据对象的isA指针去该对象的类方法中查找，如果找到了就执行
  • 如果没有找到，就去该类的父类类对象中查找
  • 如果没有找到就一直往上找，直到根类（NSObject）
  • 如果都没有找到就报错（还有三次挽救的机会）
• 2.给类对象发送消息(调用类方法)
  • 根据类对象的isA指针去元对象中查找，如果找到了就执行
  • 如果没有找到就去父元对象中查找
  • 如果如果没有找到就一直往上查找，直到根类（NSOject）
  • 如果都没有找到就报错（还有三次挽救的机会）

23.@class使用

23.1.基本概念

• 作用
  • 可以简单地引用一个类
• 简单使用
  • @class Dog;
  • 仅仅是告诉编译器:Dog是一个类;并不会包含Dog这个类的所有内容
• 具体使用
  • 在.h文件中使用@class引用一个类
  • 在.m文件中使用#import包含这个类的.h文件
• 其它应用场景
  • 对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类
  • 这种嵌套包含的代码编译会报错

1. #import “B.h”
2. @interface A : NSObject
3. {
4. B *_b;
5. }
6. @end
8. #import “A.h”
9. @interface B : NSObject
10. {
11. A *_a;
12. }
13. @end

• 当使用@class在两个类相互声明，就不会出现编译报错

1. @class B;
2. @interface A : NSObject
3. {
4. B *_b;
5. }
6. @end
8. @class A;
9. @interface B : NSObject
10. {
11. A *_a;
12. }
13. @end

23.2.@class和#import

• 作用上的区别
  • #import会包含引用类的所有信息(内容),包括引用类的变量和方法
  • @class仅仅是告诉编译器有这么一个类, 具体这个类里有什么信息, 完全不知
• 效率上的区别
  • 如果有上百个头文件都#import了同一个文件，或者这些文件依次被#import,那么一旦*开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍 , 编译效率非常低
  • 相对来讲，使用@class方式就不会出现这种问题了

24.注释和指令

24.1.#pragma mark指令的使用

• 功能:简单来说就是对代码的分组,方便代码查找和导航用的 它们告诉Xcode编译器,要在编辑器窗格顶部的方法和函数弹出菜单中将代码分隔开。一些类(尤其是一些控制器类)可能很长,方法和函数弹出菜单可以便于代码导航。此时加入#pragma 指令(#pragma是一个编译指令)对代码进行逻辑组织很有效果。
• 一个类里我们总会有一些方法的功能与性质是相差不多的,你可能会有把方法们分组的想 法。Xcode已经有了类似的支持,它就是 #pragma mark。
  • 分组: #pragma mark 分组(标识)名称
    
  • 分隔线: #pragma mark –
    
  • 分割线加分组: #pragma mark – 分组(标识)名称
    

24.2.其他指令

• MARK:
• TODO:
• FIXME:
• !!!:
• ???:
  基本和#pragma mark指令没神马区别，有图有真相。

25.分类

25.1.什么是分类（Category）

• Category有很多种翻译: 分类 \ 类别 \ 类目 (一般叫分类)
• Category是OC特有的语法, 其他语言没有的语法
• Category的作用
  • 可以在不修改原来类的基础上, 为这个类扩充一些方法
  • 一个庞大的类可以分模块开发
  • 一个庞大的类可以由多个人来编写,更有利于团队合作

25.2.Category的格式

• 在.h文件中声明类别
  • 1)新添加的方法必须写在 @interface 与 @end之间
  • 2)ClassName 现有类的类名(要为哪个类扩展方法)
  • 3)CategoryName 待声明的类别名称
  • 4)NewMethod 新添加的方法

1. @interface ClassName (CategoryName)
2. NewMethod; //在类别中添加方法
3. //不允许在类别中添加变量
4. @end

• 在.m文件中实现类别:
  • 1)新方法的实现必须写在@ implementation与@end之间
  • 2)ClassName 现有类的类名
  • 3)CategoryName 待声明的类别名称
  • 4)NewMethod 新添加的方法的实现

1. @implementation ClassName(CategoryName)
3. NewMethod
4. … …
5. @end

• 使用Xcode创建分类
  • command + N创建文件，然后选择本地存储路径。
    
  • 填写分类名称，下一步，然后选择本地存储路径。
    

25.3.分类的使用注意事项

• 分类只能增加方法, 不能增加成员变量

1. @interface Person (gz)
2. {
3. // 错误写法
4. // int _age;
5. }
6. – (void)eat;
7. @end

• 分类中写property只会生成方法声明

1. @interface Person (gz)
2. // 只会生成getter/setter方法的声明, 不会生成实现和私有成员变量
3. @property (nonatomic, assign) int age;
4. @end

• 分类可以访问原来类中的成员变量

1. @interface Person : NSObject
2. {
3. int _no;
4. }
5. @end
7. @implementation Person (gz)
8. – (void)say
9. {
10. NSLog(@”%s”, __func__);
11. // 可以访问原有类中得成员变量
12. NSLog(@”no = %i”, _no);
13. }
14. @end

• 如果分类和原来类出现同名的方法, 优先调用分类中的方法, 原来类中的方法会被忽略

1. @implementation Person
3. – (void)sleep
4. {
5. NSLog(@”%s”, __func__);
6. }
7. @end
9. @implementation Person (gz)
10. – (void)sleep
11. {
12. NSLog(@”%s”, __func__);
13. }
14. @end
16. int main(int argc, const char * argv[]) {
17. Person *p = [[Person alloc] init];
18. [p sleep];
19. return 0;
20. }
22. 输出结果:
23. -[Person(gz) sleep]

25.4.分类的编译的顺序

• 多个分类中有同名方法,则执行*后编译的文件方法

1. @implementation Person
3. – (void)sleep
4. {
5. NSLog(@”%s”, __func__);
6. }
7. @end
9. @implementation Person (gz)
10. – (void)sleep
11. {
12. NSLog(@”%s”, __func__);
13. }
14. @end
16. @implementation Person (zz)
17. – (void)sleep
18. {
19. NSLog(@”%s”, __func__);
20. }
21. @end
23. int main(int argc, const char * argv[]) {
24. Person *p = [[Person alloc] init];
25. [p sleep];
26. return 0;
27. }
29. 输出结果:
30. -[Person(zz) sleep]

• 方法调用的优先级(从高到低)
  • 分类(*后参与编译的分类优先)
  • 原来类
  • 父类

25.5类扩展

• 延展类别又称为扩展(Extendsion),Extension是Category的一个特例
• 对比分类，类延展只少了个分类的名字，所有又称之为“匿名分类”
• 可以为某个类扩充一些私有的成员变量和方法
  • 写在.m文件中
  • 英文名是Class Extension
• 类扩展书写格式

1. @interface 类名 ()
2. @end

• 例子

1. #import “Person.h”
3. @interface Person()
5. // 没在.h文件中声明，属于私有属性
6. @property (nonatomic, strong) NSArray *array;
8. // 没在.h文件中声明，属于私有方法
9. – (void)say;
12. @end
14. @implementation Person
16. – (void)say{
17. // TODO
18. }
20. @end

 

26. Block

26.1.Block介绍

• Block是iOS中一种比较特殊的数据类型。在java中没有可以与之相对于的语法。如果你有c语言的基础，明白指针的原理，那就感觉容易多了。个人理解Block就是一个指向函数的指针。该指针指向了一块内存，该内存中存储了一段代码，当你需要执行这一段代码块的时候就根据这个指针找到对应的内存地址，然后就可以执行对应的代码。当然这只是简单说明了Block的作用，在实际开发中还是有很多地方需要好好的研究的。比如，block内部引用对象，如何防止循环引用，如何修改block外边的变量，block中内存如何管理等等，想想就崩溃，这是后话。废话不多说，直接看语法。
• Block是苹果官方特别推荐使用的数据类型, 应用场景比较广泛
  • 动画
  • 多线程
  • 集合遍历
  • 网络请求回调

26.2.block的格式

• Block的定义格式

1. 返回值类型 (^block变量名)(形参列表) = ^(形参列表) {
3. };

• block*简单形式

1. void (^block名)() = ^{代码块;}
3. 例如:
4. void (^myBlock)() = ^{ NSLog(@”block”); };

• block带有参数的block的定义和使用

1. void (^block名称)(参数列表)
2. = ^ (参数列表) { // 代码实现; }
4. 例如:
5. void (^myBlock)(int) = ^(int num){ NSLog(@”num = %i”, num); };

• 带有参数和返回值的block

1. 返回类型 (^block名称)(参数列表)
2. = ^ (参数列表) { // 代码实现; }
4. 例如:
5. int (^myBlock)(int, int) = ^(int num1, int num2){ return num1 + num2; };

• 调用Block保存的代码

1. block变量名(实参);
2. 例如：
3. // 调用了block的*简单形式
4. myBlock();
6. // 调用了带有参数的block
7. myBlock(10);
9. // 调用了带有参数和返回值的block
10. myBlock(10, 20);