一个安卓开发者的 Objective-C 学习笔记。1
Objective-C 主要用于开发 macOS/iOS/iPadOS 等平台上的应用，看它的名字就可以猜到，这是一门基于 C 的面向对象的编程语言。
与大多数编程语言类似，OC 的程序运行入口也是 main 方法：
// 导入依赖，因为使用了 NSLog
#import <Foundation/Foundation.h>
// main 方法的返回值通常是 int
// main 方法参数分别是参数个数和参数数组，如果不需要也可以不写
// int main() {
int main(int argc, const char * argv[]) {
// 为了和 C 的字符串区分，声明 NSString 时，需要在字符串前加 @
// 另外，在创建一些字面量 literals 时，也需要使用 @
NSLog(@"Hello World!");
}clang main.m file1.m file2.m -w -framework Foundation -o main运行编译后生成的二进制文件（-t 表示命令行参数）：
./main -t arg1 arg2Objective-C 是一门基于 C 的语言，所以为了兼容 C，它做了很多改进。我们可以像 C 中一样声明原始数据类型，也可以声明 Objective-C 中独有的支持作为对象使用的数据类型。
int primitiveInt = 1;
long primitiveLong = 1;
float primitiveFloat = 1.0f;
double primitiveDouble = 1.0;
char charA = 'A';Objective 中布尔类型字面量为数字 0 和 1：
BOOL noBool = NO;
BOOL yesBool = YES;
NSLog(@"%d %d", noBool, yesBool);另外，与 C 中一样，所有的整形数字分为 signed 与 unsigned 类型，unsigned 类型数据只能代表非负数。以 unsigned int 为例，同样 16 位的情况下，它的取值范围是 0 ~ 65535，而普通 int 的取值范围则是 -32767 ~ 32767。
除了基本数据类型之外，其它所有的数据类型都是作为对象被创建的。
MyClass *myObject1 = nil; // Strong typing
id myObject2 = nil; // Weak typing上面的例子中，MyClass 是我们定义的一个类，创建它时在对象名称前加 * 表示这是一个强类型对象。我们也可以使用 id 声明一个对象，它表示这是一个弱类型的对象，它可以代表任何类的对象。
id var = nil;
if (var) {
NSLog(@"This is %p", var);
} else {
NSLog(@"var is empty");
}上面的例子中，我们声明一个 var 变量，并且初始化值为 nil，表示空值，此时使用 if 判断将会为 false，我们可以尝试将它修改成 1 或者 YES 再运行看看。
Objective-C 中的字符串用 NSString 表示，由于它是对象，所以创建时也需要使用指针。
NSString *str = @"Objective-C";
NSLog(str);
// 可变字符串
NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
[mutableString appendString:@" World!"];
NSLog(mutableString);我们可以使用 NSNumber 创建数字类型的对象，与创建字符串类似，同样需要使用 @ 符号。
// 创建一个长整型数字类型的对象
NSNumber *fortyTwoLongNumber = @42L;
// 转换成 long
long fortyTwoLong = [fortyTwoLongNumber longValue];
// 打印
NSLog(@"%li", fortyTwoLong);数组可以包含不同类型的数据，但是必须是对象。
NSArray *anArray = @[@1, @2L, @3.0F, @4U, @"5"];
NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
[mutableArray addObject:@"Hello"];
[mutableArray addObject:@"World"];
[mutableArray removeObjectAtIndex:0];
NSLog(@"%@", [mutableArray objectAtIndex:0]);字典，类似于其它编程语言中的 Map 的数据类型。
NSDictionary<NSString *, NSObject *> *dictionary =
@{ @"name" : @"Objective-C", @"birth" : @1992 };
NSObject *dName = dictionary[@"name"];
NSLog(@"dictionary = %@", [dictionary description]);集合对象。
// 创建一个可变集合对象
NSMutableSet<NSString *> *set = [NSMutableSet setWithObjects:@"Hi", nil];
[set addObject:@"there"];
// 空值不会被加入
NSLog(@"set = %@", set);Objective-C 虽然也是面向对象的语言，但是如果你像我一样之前没有接触过 C，那么第一点感到不适应的地方可能会是：为什么所有的类都要分别创建一个 .h 和一个 .m 文件呢？为什么要在 .h 文件中定义所有的属性和方法，然后再在 .m 文件中去实现呢？
其实这主要是因为过去的编程范式遗留下来的习惯，为了最大程度地复用代码，同时也保证了代码的清晰度，而且编译器也能根据 .h 文件来决定哪些属性和方法会被编译到最终生成的可执行文件中。2
如下所示，我们创建了一个 person.h 和 person.m 文件，其中定义和实现了 Person 类：
// 所有类都继承自 NSObject
@interface Person : NSObject
// 属性
@property (assign) NSString *name;
// 方法，+ 表示类方法（类似静态方法），- 表示实例方法
- (void)sayHi:(NSString *)greeting;
@end定义完 .h 文件之后再在 person.m 中实现：
// 首先需要导入头文件
#import "person.h"
@implementation Person {
// 实例变量
NSString *_nickName;
// 私有实例变量
@private int _age;
}
- (void)sayHi:(NSString *)greeting {
// 方法体
}
@end类的属性，也就是可以被外界直接访问类中的变量，和实例变量最大的区别是，实例变量只能在当前类中的构造器或实例方法中才能被访问。
// 编译器会为属性生成一个 setter 方法，这里的话就是 setName 方法
@property NSString *name;
// 我们也可以自定义 getter 和 setter
@property (getter = ageGet, setter = ageSet: ) int age;我们还可以为类的属性设置其它修饰符 (attribute)，上面例子中的自定义 setter 和 getter 其实也是属性的修饰符，其它这样的修饰符还有：
readonly: 表示只读，不会生成 setter 方法，默认为readwrite。copy: 复制属性的值，也就是使用强引用，即使引用值发生了修改也不会影响属性本身的值。nonatomic: 非原子性（线程不安全）。默认所有的属性都是原子性的，也就是支持跨进程赋值。unsafe_unretained: 等同于weak，也就是弱引用，当没有强引用的时候即释放它。主要用于防止多个对象之间的循环引用。
除了 readonly 之外，默认的 attribute 还有：
assign: 赋值，告诉编译期生成 setter 方法。retain: 等同于strong，也就是强引用，保持引用直到所有对象都释放了它，旧值被释放新值被赋值。atomic: 保持原子性，只有单个线程能访问它，线程安全但是效率更低。
属性背后其实也依赖于实例属性，它会自动生成为我们生产一个 _perpertyName 的幕后属性 (backing field)，假如我们想要在实现类中使用不一样的名字，可以使用 @synthesize 自定义：
@implementation Person
@synthesize name = instanceVariableName;
@end定义完属性之后，在实现类中有下面几种方式去访问它：
- (void)changeName {
NSString *var = @"Objective-C";
// 通过幕后属性访问
// _name = var;
// 使用 @synthesize 替代幕后属性
// instanceVariableName = var;
// 通过 setter
[self setName:var];
// 还可以使用 self. 语法
self.name = var;
}我们可以把实例变量看作其他语言中类的私有属性，而且通常我们只会在实现类中定义实例变量。
@implementation MyClass {
NSString *_nickName;
}之后，我们可以在构造器方法中去初始化它。
前面提到过，Objective-C 中的方法有两种，一种是类方法，一种是实例方法，分别使用方法前面的 + 和 - 表示。除此之外，实现类中的方法通常由这几个部分组成：方法类型+返回值+方法名+可选的方法参数+方法体。
- (void)myMethod:(int)arg1, name:(NSString *)arg2 {
// do something
}可以看到，和其它编程语言不同的地方在于，方法的参数名和参数值是分开表示的，而且参数名也是方法的一部分。因此，整个方法的方法名是：
myMethod:name:当我们调用一个方法的时候，需要用中括号将对象引用和方法括起来，如果方法有多个参数，还需要将参数名称一一列出，中间使用空格分割，并在冒号后表示实际参数：
[myClass myMethod:42 name:@"arg2"];需要注意的是，Objective-C 中还有一个 Message 的概念，当我们用以上的形式调用一个方法时，本质上是发送了一个消息给对象实例，编译器会将所有的方法都编译成下面这个形式：
id objc_msgSend(id self, SEL op, ...);上面的 objc_msgSend 是用于发送消息的方法。也就是说，当我们调用 myMethod 的时候，本质上是调用的是：
objc_msgSend(myClass, @selector(myMethod:name:), 42, @"arg2");关于 selector 的用法下面会再具体介绍。
构造器是一类特殊的方法，返回值通常是 id，我们可以在其中做一些类的初始化工作。
默认的构造器是 init：
- (id)init {
self = [super init];
// 判断父类是否初始化成功，如果初始化失败将会返回 nil
if (self) {
_nickName = @"default";
}
return self;
}自定义构造器：
- (id)initWithNickname:(NSString *)nickName {
self = [super init];
if (self) {
_nickName = nickName;
}
return self;
}Selector 是在对象上执行的方法的名称，编译器会将所有的方法都编译成 selector 来执行。当我们使用 selector 的时候，通常是为了实现动态分配执行方法。
Selector 用 SEL 表示，一般有两种方式创建：
SEL sel = @selector(methodName);当我们不知道方法名时，可以通过运行时方法 NSSelectorFromString 创建 selector：
SEL sel = NSSelectorFromString(dynamicMethodsString);在使用 selector 之前，通常需要先进行判断，确保方法可以执行：
if ([myClass respondsToSelector:sel]) {
// 调用方法
[myClass performSelector:selectorVar];
}除了以上这种调用方法之外，我们还可以使用 block 动态调用方法：
if ([myClass respondsToSelector:sel]) {
// 获取实现的方法
IMP imp = [myClass methodForSelector:sel];
// 将 IMP 对象转换为 block 对象
void (*func)(id, SEL, NSString*) = (void *)imp;
// 调用方法
func(myClass, sel, @"newArg");
}上面的例子中，我们使用了 methodForSelector 定位到方法，然后将其转换为 block 并执行。不过，由于 performSelector 方法的限制，方法的参数最多只能有两个。
Objective-C 中的类也有生命周期，而且还需要我们去管理内存的释放，这点会在内存管理部分详细介绍。
// 任何类在实例化之前都会先调用该方法
+ (void)initialize {
}
// 对应于 initialize 方法，用于清空对象，当引用计数为 0 时被调用
- (void)dealloc {
// 如果未启用 ARC，则需要手动释放引用计数
[nickName release];
// 调用父类方法
[super dealloc];
}Extensions 用于扩展类的属性和方法。
// Extension 通常和实现类放在一起
@interface Person () // 声明扩展类的语法是：在类名后 + ()
// 添加一个扩展属性
@property NSString *firstName;
// 添加一个扩展方法
+ (instancetype)createWithName:(NSString *)name;
@end从 Xcode 7 开始支持声明泛型类，使用关键字 __covariant：
@interface Result<__covariant A> : NSObject
// 使用 block 作为方法参数
- (void)handleSuccess:(void (^)(A))success
failure:(void (^)(NSError *))failure;
@end由于编译期不支持在实现类中使用泛型，所以实现类中需要使用 id：
@implementation Result
- (void)handleSuccess:(void (^)(id))success
failure:(void (^)(NSError *))failure {
// 假设调用成功，返回值是 42
success(@42);
}使用：
Result<NSNumber *> *r = [[Result alloc] init];
[r handleSuccess:^void (NSNumber * result) { NSLog(@"result: %i", [result intValue]); }
failure:^void (NSError *) { NSLog(@"error"); } ];当我们将返回值修改为字符串时：
success(@"ok");对应的处理结果是：
Result<NSString *> *r = [[Result alloc] init];
[r handleSuccess:^void (NSString * result) { NSLog(@"result: %@", result); }
failure:^void (NSError *) { NSLog(@"error"); } ];协议类似于接口 (Interface) 的概念，我们可以在 @protocol 中定义方法和属性，然后交由其它类去实现。
@protocol Worker <NSObject>
@property BOOL retired;
- (void)performWork;
@end通常，我们在声明类时将协议作为泛型类型使用：
@interface Person : NSObject<Worker>在实现类中实现协议中的方法：
// 下面这行注释会在文件和导航栏中添加一条分割线
#pragma mark -
// pragma mark 是一种特殊的管理代码的注释，方便我们在 XCode 导航栏中跳转到页面的各个区域
#pragma mark Career protocol
// 如果需要在实现类中使用 protocol 中的属性，必须使用 synthesize 暴露出该属性
@synthesize retired = _retired;
// 实现 protocol 中的方法
- (void)performWork {
NSLog(@"do some work.");
}Categories 同样用于扩展一个类，它和 extensions 的最大的区别是，extensions 中扩展的方法一般只能用于某一个特定的实现类，但是 categories 为某个类添加的扩展方法可以用于所有的类，包括子类。
定义 category 和定义类的方式相同，需要先声明头文件，然后再在实现类中实现方法。通常情况下，文件名是实现的基类名+category 名，比如下面的这个例子中，为 Person 类添加了阅读相关的方法，那么，文件名就是 person+read.h。
#import "person.h"
// 类后括号内就是这个 category 的名字
@interface Person (Read)
// 添加的方法
- (void)read:(NSString *)material;
@end实现类：
#import "person+read.h"
@implementation Person (Read)
- (void)read:(NSString *)material {
NSLog(@"I'm reading %@", material);
}
@end当需要调用 category 中的方法时，只需要导入 category 即可：
#import "person+read.h"
#import "person.h"
...
- (void)someMethod {
Person *p = [[Person alloc] init];
[p read:@"a book"];
}Blocks 是 Objective-C 中一种特殊的对象，它可以直接执行一段代码，类似其它语言中的 lambda 表达式。
我们可以使用 ^ 符创建一个 block 字面量：
^{
NSLog(@"This is a block");
}类似与 C 中的方法指针，我们可以使用下面的语法去引用一个 block：
void (^simpleBlock)(void);以上可以理解为我们创建了一个 simpleBlock 变量来表示一个参数为 void，返回值也为 void 的方法。
之后，我们可以创建方法体：
simpleBlock = ^ {
NSLog(@"This is a block");
}当然，我们也可以将上面两个步骤合二为一：
void (^simpleBlock)(void) = ^ {
NSLog(@"This is a block");
}另外，block 也可以包含参数和返回值：
double (^addBlock)(double, double) =
^(double firstValue, double secondValue) {
return firstValue * secondValue;
};更多 block 的语法可以参考这个回答。
Objective-C 中并没有 Java 中的垃圾回收机制，我们必须自行管理内存。Objective-C 中使用引用计数的方式管理内存，当我们创建一个对象时，对应的内存也会被创建并分配给该对象，我们即拥有了 (own) 该对象，此时引用计数 +1。只要我们还持有该引用，该对象就会持续存在，不会被释放 (deallocate)。而当我们释放 (release) 了该对象，引用计数 -1，若引用计数减到 0 时，该对象才会从内存中被移出。
// 创建对象
MyClass *classVar = [[MyClass alloc] init];
// 使用对象
[classVar doSomething];
// 释放对象
[classVar release];由于手动管理内存麻烦且容易出错，从 Xcode 4.2 和 iOS 4 开始，引入了 Automatic Reference Counting 来帮助我们管理内存。
// 默认值，变量会被保存在内存中直到离开作用域
__strong NSString *strongString;
// 弱引用，假如引用的对象被释放，那么弱引用会被设为 nil
__weak NSSet *weakSet;
// 与弱引用类似，但是如果引用的对象被释放，引用也不会被设为 nil
__unsafe_unretained NSArray *unsafeArray;对于类的属性而言，默认会是 strong 的，也就是会在内存中被保存直到对象被释放；而如果属性是 weak 的，则当引用计数减到零后，属性接收到的值会变成 nil。
// 默认值
@property (strong) MyClass *strongVar;
// 改为弱引用
@property (weak) MyClass *weakVar;当我们使用指针时，我们其实是在引用一个对象的地址，而不是直接使用堆 (heap) 中创建的对象，这样，当我们传递对象并且对象被改变时，由于使用的是引用，我们能够得到改变后的对象。由于 Objecgive-C 是一门面向对象的语言，当我们创建一个对象时，大多数时候都应该使用指针。
id 表示一个指向 Objective-C 对象的指针，而 void * 可以表示为任何指针。
另外，使用 id 声明对象时编辑器不会报错，只有在运行时才会提示错误，所以，推荐使用 NSObject * 而不是直接使用 id 创建一个代表任何类的对象。