关于Objective-C

Objective-C 是一种通用、高级、面向对象的编程语言。它扩展了标准的 ANSI C 编程语言，将 Smalltalk 式的消息传递机制加入到 ANSI C 中。目前主要支持的编译器有 GCC 和 Clang。

历史

Objective-C 主要由 Stepstone 公司的 Brad Cox 和 Tom Love 在 19 世纪 80 年代发明。

1981年 Brad Cox 和 Tom Love 还在 ITT 公司技术中心任职时，接触到了 SmallTalk语言。Cox 当时对软件设计和开发问题非常感兴趣，他很快地意识到 SmallTalk 语言在系统工程构建中具有无法估量的价值。

1983 年，Cox 与 Love 合伙成立了 Productivity Products International（PPI）公司，将 Objective-C 及其相关库商品化贩售，并在之后将公司改名为StepStone。

1988年，斯蒂夫·乔布斯（Steve Jobs）离开苹果公司后成立了 NeXT Computer 公司，NeXT 公司买下 Objective-C 语言的授权，并扩展了 GCC 使之支持 Objective-C 的编译，基于 Objective-C 开发了 AppKit 与 Foundation Kit 等库，作为 NeXTSTEP 的的用户界面与开发环境的基础。

1996年12月20日，苹果公司宣布收购 NeXT Software 公司，NEXTSTEP/OPENSTEP 环境成为苹果操作系统下一个主要发行版本 OS X 的基础。

C语言的严格超集

• 任何C语言程序不经修改就可以直接通过Objective-C编译器成功编译
• Objective-C 源程序中可以直接使用任何C语言代码

正是由于以上优势，在 Swift 推出之后，许多和 C 有直接交互的部分大多仍旧使用 Objective-C 编写。

SmallTalk 式的消息传递模型

Objective-C 最大的特色是承自 Smalltalk 的消息传递模型（message passing），此机制与 C Family 式的主流风格差异甚大。

如在 java 中，方法调用：

obj.method(argument);

Objective-C 里的方法调用：

[obj method:argument];

Objective-C 与其说调用对象的方法，不如说向对象传递消息更为精确。
二者并不仅仅是语法上的差异，还有基本行为上的不同。

举个🌰：

[car fly];

Java 的解读是 “调用 car 类的 fly 方法”。
若 car 类里没有定义 fly 方法，那编译不会通过。

Objective-C 里，则解读为 “向 car 对象发送 fly 消息”。
若 car 类内定义有 fly 方法就运行方法内的代码，若 car 内不存在 fly 方法，则程序依旧可以通过编译，运行期则抛出异常： unrecognized selector sent to instance 0x8871710

Objective-C 因为运行期才处理消息，允许发送未知消息给对象。同时空对象 nil 接受消息后默认为不做事，所以送消息给 nil 也不用担心程序崩溃。

布尔（BOOL）

Java 的布尔数据类型 boolean 具有 true 和 false 两个值，Objective-C 的 BOOL 具有 YES 和 NO 两个值。

Objective-C 中的 BOOL 实际上一种对带符号的字符类型（signed char）的类型定义。通过 #define 把 YES 定义为1，NO 定义为0。

字符串（NSString）

Objective-C 字符串由双引号包裹，并在引号前加一个@符号，如：

NSString *name = @"Tony";

import 语句

在C语言中，使用 #include 导入入头文件。在Objective-C中，类似的指令 #import 保证一个文件只会被包含一次，类似于一般头文件中的：

#ifndef XXX
#define XXX ...
#endif

类的定义与实现

Objective-C 中将类的定义（interface）与实现（implementation）分为两个部分。
类的定义文件遵循 C 语言惯例以 .h 为后缀，实现文件以 .m 为后缀。

定义部分，定义类的名称、数据成员和方法。 以关键字 @interface 开始，@end 结束：

@interface MyClass : NSObject {
    int memberVar1; // 实体变量
    id  memberVar2;
}

+ (return_type)class_method; // 类方法

- (return_type)instance_method1; // 实例方法
- (return_type)instance_method2:(int)p1;
- (return_type)instance_method3:(int)p1 andPar:(int)p2;
@end

实现部分，以关键字 @implementation 开始，@end 结束：

@implementation MyClass {
    int memberVar3; // 私有实体变量
}

- (return_type)instance_method1 {
    ....
}

- (return_type)instance_method2:(int)p1 {
    ....
}

- (return_type)instance_method3:(int)p1 andPar:(int)p2 {
    ....
}
@end

上述代码 Java 版对照：

public class MyClass {
    protected int memberVar1;
    protected pointer memberVar2;
    private int memberVar3;
    
    public (return_type) instance_method1() {
        ....
    }
    
    public (return_type) instance_method2(int p1) {
        ....
    }
    
    public (return_type) instance_method3andPar(int p1, int p2) {
        ....
    }
}

方法前面的 +/- 代表函数的类型：加号（+）代表类方法（class method），不需要实例就可以调用，与 Java 的静态方法相似。减号（-）即是一般的实例方法（instance method）。

创建对象

Objective-C 创建对象需通过 alloc 和 init 两个消息。alloc 是分配内存，init 则是初始化对象。 init 与 alloc 都是定义在 NSObject 里的方法，父对象收到这两个信息并做出正确回应后，新对象才创建完毕。

举个🌰：

MyObject *obj = [[MyObject alloc] init];

MyObject *obj = [MyObject new]; // 也可以这么写，new 相当于 alloc + init

Java 版本：

MyObject obj = new MyObject();

协议（Protocol）

协议类似与 Java 语言中的接口。

协议的定义以 @protocol 开头，@end 结尾：

@protocol SayHello
- (void)sayHello;
@end

协议中定义的方法分为必须实现的方法和可选实现的方法。协议中的方法默认必须实现，可选实现的方法以 @optional 为标识。

@protocol SomeProtocol
 - (void)method1; // 必须实现
@optional
- (void)method2; // 可选实现
- (void)method3; // 可选实现
@end

实现一个协议：

@interface SomeClass : SomeSuperClass <SomeProtocol>
@end

@implementation SomeClass
 - (void)method1 {
  // ...
}

- (void)method2 {
  // ...
}

- (void)method3 {
  // ...
}
@end

分类（Category）

分类可以给一个已经存在的类增加方法，而不用去改它的源码。类似于 Swift 和 Kotlin 中的扩展（extension）。

比如，NSString 是 Objective-C 内置的系统类，我们创建一个它的分类以支持加法运算：

// interface 部分
@interface NSString (Calculation)
- (NSString *)stringByAdding:(NSString *)aString; // 加
@end

// implementation 部分
@implementation NSObject (Calculation)
- (NSString *)stringByAdding:(NSString *)aString {
    // ...
}
@end

使用的时候，只要包含NSObject+Calculation.h，就可以使用了：

NSString *str = @"100";
NSString *result = [str stringByAdding:10]; // result is 110

引用计数

Objective-C 使用引用计数来管理对象的生命周期。

如果想使某个对象继续存活，那就递增其引用计数（reatain）；用完了之后，就递减其计数（release）。当计数为0时，系统就会将它销毁。

memory_management_2x.png

iOS5 开始引入了自动引用计数 （ARC， Automatic Reference Counting）
简单地说，ARC 在编译时为代码在合适的位置加上 retain 和 release。

属性

属性（property）是 Objective-C 的一项特性，用于封装对象中的数据。实例变量一般通过“存取方法”（access method）来访问。其中，“获取方法”（getter）用于读取变量值，而“设置方法”（setter）用于写入变量值。

Xcode 4.4时代之前，需要一个属性的时候：

// .h
@property NSObejct *foo;

// .m
@synthesize foo = _foo;

头文件中加上@property，那么编译器会自动添加下面一段代码：

- (NSObject *)foo; 
- (void)setFoo:(NSObject *)newFoo; 

在 .m 中实现：

- (NSObject *)foo {
    return _foo;
}

- (void)setFoo:(NSObject *)newFoo {
    [foo retain];
    [_foo release];
    _foo = foo;
}

自动引用计数时代，喜大普奔，一切都变得简单了，只需要一句话：

@property (nonatomic, strong) NSObejct *foo;

@property(*) 括号中的属性内容:

• 原子性：atomic 和 nonatomic，默认为atomic。
• 读写权限：readwrite 和 readonly， 默认为 readwrite，同时生成setter和getter，所以本质上是由@synthesize来实现的。而 readonly 就是代表只生成 getter 方法。
• 指定方法名：使用getter=<name>或setter=<name>来指定方法名。
• 内存管理：assign，strong，weak，copy。

当 B 是 A 的 strong 属性，A 又是 B 的 strong 属性，此时就会造成循环引用，如图：

QQ20180730-212815@2x.png

此时，A 若想被释放，需要引用计数为0。而 B 持有 A，所以想要 A dealloc，需要 B 发送 release 消息到 A。而 B 只有 dealloc 时，才会发送 release 到 A，并且 B dealloc 也需要 A 向其发送 release 消息。这样 A 和 B 互相等待对方的 release 消息，造成循环引用，导致内存无法释放。

解决循环引用：将其中一方的属性使用 weak 修饰。

点语法

属性合成的方法可以通过点语法调用：

obj.foo = newFoo;

// 上述代码等同于
[obj setFoo:newFoo];

点语法的本质还是方法调用，是一种编译器行为，编译器会自动进行转换，来判断调用 set 方法还是 get 方法。

代码块 （block）

block 对象是对函数的扩展。除了函数中的代码，block 还包含变量绑定。block 也被称为闭包（closure）。block 是以 “^” 开头为标识的。后面跟的一个括号标示 block 需要的参数列表。

一个简单的🌰：

void (^myBlock) (int) = ^(int input) {
    NSLog(@"input number is %d", input);
};

// 调用 block 
myBlock(1);
// 输出：input number is 1

block 使用局部变量：

NSString *name = @"Candy";
void (^myBlock) (void) = ^ {
    NSLog(@"name is %@", name);
};

myBlock();
// 输出：name is Candy

block 可以方便的使用局部变量 name，但是你不能修改它，当你尝试修改 name 时，会报错 Variable is not assignable (missing __block type specifier)。

此时你需要用 __block 修饰 name：

__block NSString *name = @"Candy";
void (^myBlock) (void) = ^ {
    name = @"Jack"
    NSLog(@"name is %@", name);
};

myBlock();
// 输出：name is Jack

block 使用实例变量：

// 定义的实例变量 userName
@property (nonatomic, copy) NSString *name;

// block 使用实例变量
void (^myBlock) (void) = ^ {
    NSLog(@"ins is %@", self.name);
};

当 block 本身为实例变量，而 block 内部又使用了 实例变量，此时就会出现循环引用。
举个🌰：

// 定义的实例变量 userName 和 myBlock
@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) void (^myBlock)(void);

// block 使用实例变量
_myBlock = ^ {
    NSLog(@"name is %@", self.name);
 };

此时会有警告：Capturing 'self' strongly in this block is likely to lead to a retain cycle
简单来说，是因为 self 引用了 myBlock，myBlock 又引用了 self。

解决 block 循环引用：

// 定义的实例变量 userName 和 myBlock
@property (nonatomic, copy) NSString *userName;
@property (nonatomic, copy) void (^myBlock)(void);

// block 使用实例变量
__weak typeof(self) weakSelf = self;
self.myBlock = ^ {
    NSLog(@"name is %@", weakSelf.userName);
 };