隐藏和封装#

有四种访问控制符：==@private(当前类访问权限)，@package(与映像访问权限相同)，@protect(子类访问权限)，@public(公共访问权限)。

对象初始化#

1
#import "Person.h"
2

3
@implementation Person
4

5
-(id) init {
6
    if (self = [super init]) {
7
        self.name = @"四川芬达";
8
        self.saying = @"他们朝我扔粑粑";
9
        self.age = 123;
10
    }
11
    return self;
12
}
13

14
@end

1
NS_ASSUME_NONNULL_BEGIN
2

3
@interface Person : NSObject
4

5
@property (nonatomic,copy) NSString* name;
6
@property (nonatomic,copy) NSString* saying;
7
@property (nonatomic,assign) NSInteger age;
8

9
@end
10

11
NS_ASSUME_NONNULL_END

1
#import <Foundation/Foundation.h>
2
#import "Person.h"
3

4
int main(int argc, const char * argv[]) {
5
    @autoreleasepool {
6
        Person* singer = [[Person alloc] init];
7
        NSLog(@"%@",singer.name);
8
        NSLog(@"%@",singer.saying);
9
        NSLog(@"%ld",singer.age);
10
    }
11
    return 0;
12
}

OC属性及属性关键字#

@property

属性用于封装对象中数据，属性的本质是 ivar + setter + getter。

可以用 @property 语法来声明属性。@property 会帮我们自动生成属性的 setter 和 getter 方法的声明。

@synthesize

帮我们自动生成 setter 和 getter 方法的实现以及 _ivar。

你还可以通过 @synthesize 来指定实例变量名字，如果你不喜欢默认的以下划线开头来命名实例变量的话。但最好还是用默认的，否则影响可读性。

如果不想令编译器合成存取方法，则可以自己实现。如果你只实现了其中一个存取方法 setter or getter，那么另一个还是会由编译器来合成。但是需要注意的是，如果你实现了属性所需的全部方法（如果属性是 readwrite 则需实现 setter and getter，如果是 readonly 则只需实现 getter 方法），那么编译器就不会自动进行 @synthesize，这时候就不会生成该属性的实例变量，需要根据实际情况自己手动 @synthesize 一下。

1
@synthesize ivar = _ivar

@dynamic

告诉编译器不用自动进行 @synthesize，你会在运行时再提供这些方法的实现，无需产生警告，但是它不会影响 @property 生成的 setter 和 getter 方法的声明。@dynamic 是 OC 为动态运行时语言的体现。动态运行时语言与编译时语言的区别：动态运行时语言将函数决议推迟到运行时，编译时语言在编译器进行函数决议。

类、元类、父类的关系#

我们先给出类与对象源码的定义：

我们的类实际上就是一个结构体指针。

1
typedef struct objc_class *Class;
2
struct objc_class {
3
    Class isa;
4
    Class super_class;
5
    const char *name;
6
    long version;
7
    long info;
8
    long instance_size;
9
    struct objc_ivar_list *ivars;
10
    struct objc_method_list **methodLists;
11
    struct objc_cache *cache;
12
    struct objc_protocol_list *protocols;
13
};

我们再来看看对象的定义：

OC的类其实也是一个对象，一个对象就要有一个它属于的类，意味着类也要有一个isa指针，指向其所属的类。那么类的类是什么？就是我们所说的元类，所以，元类就是类的所属类。

这样我们便可以总结出我们类、元类、父类的基本关系：

isa指向 实例对象的所属类实际上就是其所属类，我们的实例对象就是图中的Instance of Subclass。 接下来我们的isa指向了我们的类，那么继续研究我们类的所属类。 从图中可以看出，我们类的所属类实际上就指向了我们的元类。 接下来我们再看我们的元类，我们所有元类的所属类实际上都是根元类，在笔者参考的资料中是这样理解的，因为我们OC中几乎所有的类都是NSObject的子类，所以我们的根元类也可以认为是我们的NSObject的元类。 接着我们再看图中根元类的虚线，根元类所属的类指向了它本身。

superClass指向 我们这里的superClass指向就是我们类的父类，到了这里其实就比较好理解了，元类与我们的类一样，其父类都是一层层往上的，而不像元类所属的类一样，全部指向我们的根元类

在这里唯一需要注意的是我们的根元类的父类是我们的根类，也可以理解为NSObject类。而NSObject类的父类就是nil了。

isKindOfClass && isMemberOfClass#

1
re1：1    [NSObject类对象 isKindOfClass:[NSObject class]]
2
NSObject 的元类的继承链最终指向 NSObject 类本身（因为根元类的父类是 NSObject），因此返回 YES（1）
3

4
re2：0    [NSObject类对象 isMemberOfClass:[NSObject class]]
5
NSObject 的类对象的元类是 NSObject 的元类（metaclass），而非 NSObject 类本身，因此返回 NO（0）。
6

7
re3：0    [GGObject类对象 isKindOfClass:[GGObject class]]
8
GGObject 的元类的继承链未指向 GGObject 类本身（除非显式修改元类继承关系），因此 isKindOfClass: 返回 NO（0）。
9

10
re4：0    [GGObject类对象 isMemberOfClass:[GGObject class]]
11
类对象的元类与目标类 GGObject 不匹配，因此 isMemberOfClass: 返回 NO（0）。
12

13
re5：1    [[NSObject分配的对象] isKindOfClass:[NSObject class]]
14
实例对象是 NSObject 的直接实例，且 isKindOfClass: 会检查类的继承链。
15
NSObject 是所有类的根类，因此返回 YES（1）。
16

17
re6：1    [[NSObject分配的对象] isMemberOfClass:[NSObject class]]
18
实例对象直接属于 NSObject 类，因此 isMemberOfClass: 返回 YES（1）。
19

20
re7：1    [[GGObject分配的对象] isKindOfClass:[GGObject class]]
21
GGObject 实例的类继承自 NSObject，但 isKindOfClass: 会检查到其自身类 GGObject，因此返回 YES（1）。
22

23
re8：1    [[GGObject分配的对象] isMemberOfClass:[GGObject class]]
24
实例对象直接属于 GGObject 类，因此 isMemberOfClass: 返回 YES（1）。

isKindOfClasss：判断类或元类继承链是否包含目标类

isMemberOfClass：严格匹配当前类或元类是否等于目标类

特殊：NSObject 的元类的父类是 NSObject 类本身，因此 [NSObject class] isKindOfClass:[NSObject class] 返回 YES，而其他类（如 GGObject）的元类无此特性

+isKindOfClass 类方法是从当前类的isa指向 (也就是当前类的元类) 开始，沿着 superclass 继承链查找判断和对比类是否相等。 -isKindOfClass 对象方法是从 [self class] (当前类) 开始，沿着 superclass 继承链查找判断和对比类是否相等。 +isMemberOfClass 类方法是直接判断当前类的isa指向 (也就是当前类的元类) 和对比类是否相等。 -isMemberOfClass 对象方法是直接判断 [self class] (当前类) 和对比类是否相等。

编译结果：

关键字#

关键字 含义与用途 @interface 声明一个类或协议 @implementation 实现一个类或协议 @end 结束一个类、实现或协议的定义 @class 向前声明类，解决循环引用 @public @private @protected 成员变量访问控制 @property 声明属性（自动生成 getter/setter） @synthesize 合成属性对应的实例变量（早期） @dynamic 声明属性由开发者手动实现 @protocol 声明协议（类似 Java 中 interface） @optional / @required 协议方法的实现可选或必须 @selector 获取方法选择器 SEL @encode 获取类型的编码 @defs 获取结构体定义（已弃用） @try @catch @finally 异常处理 @throw 抛出异常 @autoreleasepool 自动释放池，用于内存管理 @import 模块导入（代替 #import，更现代） @synchronized 线程同步

1
@interface MyClass : NSObject {
2
    int _value;
3
}
4
- (void)doSomething;
5
@end
6

7
@implementation MyClass
8
- (void)doSomething {
9
    NSLog(@"Doing something");
10
}
11
@end
12

13
int main(int argc, const char * argv[]) {
14
    @autoreleasepool {
15
        NSString *str = [[NSString alloc] initWithFormat:@"Hello"];
16
        NSLog(@"%@", str);
17
    } // 自动释放池在此处释放
18
    return 0;
19
}
20

21
@interface MyClass : NSObject
22
@property (nonatomic, strong) NSString *name;
23
@end
24

25
@implementation MyClass
26
@synthesize name; // 自动生成 _name 和 name 的 getter/setter
27
@end
28

29
@protocol MyDelegate <NSObject>
30
@required
31
- (void)doTask;
32

33
@optional
34
- (void)optionalTask;
35
@end
36

37
SEL s = @selector(doSomething);
38

39

40
@class AnotherClass;
41

42
@interface MyClass : NSObject
43
@property (nonatomic, strong) AnotherClass *obj;
44
@end
45

46

47
@synchronized(self) {
48
    // 线程安全的代码
49
}

assign

 assign：对属性只是简单赋值，不更改对所赋的值的引用计数，这个指示符主要适用于NSInteger等基本类型，以及short、float、double、结构体等各种C数据类型。它是一个弱引用声明类型，我们一般不使用assign来修饰对象，因为被assign修饰的对象，在被释放掉以后，指针的地址还是存在的，也就是说指针不会被置为nil，造成野指针，可能导致程序崩掉。那为什么assign就能用来修饰基本数据类型呢，是因为基本数据类型一般分布在栈上，栈的内存会由系统自动处理，因此不会造成野指针  

weak

  weak：该属性也是一个弱引用声明类型，使用weak修饰的对象是不会造成引用计数器+1的，并且引用的对象如果被释放了以后会自动变成nil，不会出现野指针，很好的解决了内存引起的崩溃情况。通常我们会在block和协议的时候使用weak修饰，通过这样的修饰，我们可以规避掉循环引用的问题。

strong

        strong：该属性是一个强引用声明类型，只要该强引用指向被赋值的对象，那么该对象就不会自动回收。

**retain    **     

retain：释放旧的对象，将旧对象的值赋予输入对象，再提高输入对象的索引计数为1；在ARC模式下很少使用，通常用于指针变量，就是说你定义了一个变量，然后这个变量在程序的运行过程当中会改变，并且影响到其他方法。一般用于字符串、数组等

copy

        copy：若使用copy指示符，则调用setter方法给变量赋值的时候，会将被赋值的对象复制一个副本，再将该副本赋值给成员变量。copy指示符会将原成员变量所引用对象的计数减1。          相当于就是说，不用copy的话，会创建一个新的空间，它的内容和原对象内容一模一样，然后指针是指向新空间的。当再有什么操作在对那个对象操作的话，只是在原空间上操作，对新空间没有影响。当成员变量的类型是可变类型，或其子类是可变类型的时候，被赋值的对象有可能在赋值后被修改，如果程序不需要这种修改影响setter方法设置的成员变量的值，此时就可考虑用copy指示符。

strong、copy

** 如果属性声明中指定了copy特性，合成方法会使用类的copy方法 ** ，这里注意：属性并没有MutableCopy特性。 即使是可变的实例变量，也是使用copy特性，正如方法copyWithZone：的执行结果。所以，按照约定会生成一个对象的不可变副本。

相同之处：用于修饰标识拥有关系的对象

不同之处：strong赋值是多个指针指向同一个地址，而copy的复制是每次会在内存中复制一份对象，指针指向不同的地址。所有对于不可变对象我们都应该用copy修饰，为确保对象中的字符串值不会无意变动，应该在设置新属性时拷贝一份。

回顾一下深浅拷贝

深拷贝就是内容拷贝，浅拷贝就是指针拷贝。

深拷贝就是拷贝出来和原来仅仅是值一样，但是内存地址完全不一样的新的对象，创建后和原对象没有任何关系。浅拷贝就是拷贝指向原来对象的指针，使原来的对象的引用计数➕1，可以理解为创建了一个指向原对象的指针的新指针而已，并没有创建一个全新的对象。

1
#import <Foundation/Foundation.h>
2
#import "Person.h"
3

4
int main(int argc, const char * argv[]) {
5
    @autoreleasepool {
6
        NSMutableString *otherName = [[NSMutableString alloc] initWithString:@"Jack "];
7
             Person *person = [[Person alloc] init];
8
             person.name = otherName;
9
             person.age = 23;
10

11
             [otherName appendString:@"and rose"];
12
             NSLog(@"person.name = %@",person.name);
13

14
    }
15
    return 0;
16
}

copy的结果：

strong的结果： 

因为otherName是可变的，person.name属性是copy，所以创建了新的字符串，属于深拷贝，内容拷贝，我们拷贝出来了一个对象，后面的赋值操作都是针对新建的对象进行操作，而我们实际的调用还是原本的对象。所以值并不会改变。 如果设置为strong，strong会持有原来的对象，使原来的对象引用计数+1，其实就是浅拷贝、指针拷贝。这时我们进行操作，更改其值就使本对象发生了改变。

我们既然创建的是不可变类型，那我们就不希望其发生改变，所以这个时候我们就应该使用copy关键字，strong会使其在外部被修改时发生改变

那么对于可变类型字符串 ，我们使用copy时，按约定会生成一个对象的不可变副本，此时我们进行增删改操作就会因为找不到对象而崩溃

readonly、readwrite

这是访问权限的控制，决定该属性是否可读和可写，默认是readwrite，所以我们定义属性的时候，一般不需要这个修饰。只有只读属性才加上readonly

readonly来控制读写权限的方式就是**只生成setter，**不生成getter

单例模式#

单例模式是因为在某些时候，程序多次创建这一类的对象没有实际的意义，那么我们就只在程序运行的时候只初始化一次，自然就产生了一个单例模式。

定义：

如果一个类始终只能创建一个实例，则这个类被称为单例类。在程序中，单例类只在程序中被初始化一次，所以单例类是存储在全局区域，在编译时分配内存，只要程序还在运行就一只占用内存，只要在程序结束的时候释放这一部分内存

有三个注意点

• 单例类只有一个实例
• 单例类只能自己创建自己的实例
• 单例类必须给其他对象提供这一实例

1
static id _instance = nil;  //定义static全局变量
2

3
@implementation Singleton
4

5
+ (id) shareInstance {
6
  // 先判断_instance是否为空
7
    if (_instance == nil) {
8
      // 为空则初始化
9
        _instance = [[self alloc] init];
10
    }
11
    // 返回实例
12
    return _instance;
13
}
14

15
@end
16
### 使用dispatch_once
17

18

19
上面方法在单线程下可以保证单例只被初始化一次；但是多线程的出现，使得在极端条件下，单例也可能返回了不同的对象。如在单例初始化完成前，多个进程同时访问单例，那么这些进程可能都获得了不同的单例对象。
20

21

22
苹果提供了 dispatch_once(dispatch_once_t *predicate,dispatch_block_t block);函数来避免这个问题，该函数保证相关的块必定会执行，且执行一次。此操作完全是线程安全的。
23

24

25
同样只有实现部分代码：
26

27

28
```objective-c
29
static id _instance = nil;  //定义static全局变量
30

31
@implementation Singleton
32

33
+ (id) shareInstance {
34
    // static修饰标记变量
35
    static dispatch_once_t onceToken;
36
    dispatch_once(&onceToken, ^{
37
        _instance = [[self alloc] init];
38
    });
39
    return _instance;
40
}
41

42
@end
43
### 我们还需要 重写alloc函数 ，使alloc函数返回同一个对象地址。
44

45

46
```objective-c
47
#import "Singleton.h"
48

49
@implementation Singleton
50

51
// 懒汉式线程安全单例
52
+ (instancetype)sharedInstance {
53
    static Singleton *instance = nil;
54
    static dispatch_once_t onceToken;
55
    dispatch_once(&onceToken, ^{
56
        instance = [[super allocWithZone:NULL] init];
57
    });
58
    return instance;
59
}
60

61
// 防止通过 alloc/init 创建新实例
62
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
63
    return [self sharedInstance];
64
}
65

66
// 防止 copy
67
- (id)copyWithZone:(NSZone *)zone {
68
    return self;
69
}
70

71
// 防止 mutableCopy
72
- (id)mutableCopyWithZone:(NSZone *)zone {
73
    return self;
74
}
75

76
@end
77
### 至于两种不同模式：
78

79

80
**懒汉模式**：
81

82

83
· 优点：
84
 **延迟加载**：懒汉模式只有在第一次访问单例实例时才会进行初始化，可以节省资源，提高性能，因为实例只有在需要时才会被创建。
85
 **节省内存：**如果单例对象很大或者初始化过程开销较大，懒汉模式可以避免在程序启动时就创建不必要的对象。
86
 **线程安全性：**可以通过加锁机制（如双重检查锁定）来实现线程安全。
87

88

89
 · 缺点：
90
 **线程安全性开销：**懒汉模式在实现线程安全时可能需要额外的同步机制，这会引入一些性能开销。
91
 **复杂性增加：**实现线程安全的懒汉模式可能需要编写复杂的代码，容易引入错误。
92
 缺点：
93
 **线程安全性开销：**懒汉模式在实现线程安全时可能需要额外的同步机制，这会引入一些性能开销。
94
 **复杂性增加：**实现线程安全的懒汉模式可能需要编写复杂的代码，容易引入错误。
95

96

97
 **饿汉模式：**
98

99

100
**优点：**
101
 **简单：**饿汉模式实现简单，不需要考虑线程安全问题，因为实例在类加载时就已经创建。
102
 **线程安全性：**由于实例在类加载时创建，不会存在多个实例的风险，因此线程安全。
103

104

105
 **缺点：**
106
 **无法实现延迟加载：**饿汉模式在程序启动时就创建实例，无法实现延迟加载，可能会浪费资源，特别是当实例很大或初始化开销较大时。
107
 **可能引起性能问题：**如果单例类的实例在程序启动时没有被使用，那么创建实例的开销可能是不必要的。
108
 不适用于某些情况：如果单例对象的创建依赖于某些外部因素，而这些因素在程序启动时无法确定，那么饿汉模式可能不适用。
109

110

111
 总的来说，懒汉模式适用于需要延迟加载实例的情况，可以节省资源和提高性能，但需要考虑线程安全性。饿汉模式适用于需要简单实现和线程安全性的情况，但不支持延迟加载。选择哪种模式应根据具体需求和性能考虑来决定。
112

113

114
## 重写description方法
115

116

117
我们将我们的值包装成对象后我们肯定就需要打印他了。**当我们用NSLog单独打印我们的对象时，实际上是调用我们的description方法来返回我们的类的十六位进制**，但是我们并不想要得到这个东西，我们想要得到的是他的值，所以我们就要重写我们的description方法。
118

119

120
```objective-c
121
@implementation Person
122

123
- (NSString *)description {
124
    return [NSString stringWithFormat:@"Person: name = %@, age = %ld", self.name, (long)self.age];
125
}
126

127
@end

==与isEqual与hash#

比较方式 方法/符号 作用 是否可重写 比较内容 指针比较 == 判断两个对象地址是否相同 不可重写 内存地址 内容比较 isEqual: 判断两个对象内容是否相等 通常需重写 对象内容 哈希值比较 hash 通常与 isEqual: 搭配使用 通常需重写 内容生成的整数

isEqual 默认是实现是==（也就是地址比较）因此，如果你定义自己的类，**要比较内容，必须重写该方法 **

1
@implementation Person
2

3
- (BOOL)isEqual:(id)object {
4
    if (![object isKindOfClass:[Person class]]) return NO;
5
    Person *other = (Person *)object;
6
    return [self.name isEqualToString:other.name] && self.age == other.age;
7
}

hash：对象的哈希值，用于快速查找和集合操作。默认NSObject会返回一个基于地址的hash。当你重写了isEqual，必须配套重写hash

下面举几个例子：

1
@interface Person : NSObject
2
@property (nonatomic, copy) NSString *name;
3
@property (nonatomic, assign) NSInteger age;
4
@end
5

6
@implementation Person
7

8
- (BOOL)isEqual:(id)object {
9
    if (![object isKindOfClass:[Person class]]) return NO;
10
    Person *other = (Person *)object;
11
    return [self.name isEqualToString:other.name] && self.age == other.age;
12
}
13

14
- (NSUInteger)hash {
15
    return self.name.hash ^ self.age;
16
}
17

18
@end

1
@interface Book : NSObject
2
@property (nonatomic, copy) NSString *title;
3
@property (nonatomic, copy) NSString *isbn;
4
@end
5

6
@implementation Book
7

8
- (BOOL)isEqual:(id)object {
9
    if (![object isKindOfClass:[Book class]]) return NO;
10
    return [self.isbn isEqualToString:((Book *)object).isbn];
11
}
12

13
- (NSUInteger)hash {
14
    return self.isbn.hash; // 因为只看 isbn 是否相同
15
}
16

17
@end

1
@interface UserAccount : NSObject
2
@property (nonatomic, copy) NSString *username;
3
@property (nonatomic, copy) NSString *email;
4
@end
5

6
@implementation UserAccount
7

8
- (BOOL)isEqual:(id)object {
9
    if (![object isKindOfClass:[UserAccount class]]) return NO;
10
    UserAccount *other = object;
11
    return [self.username isEqualToString:other.username] &&
12
           [self.email isEqualToString:other.email];
13
}
14

15
- (NSUInteger)hash {
16
    return self.username.hash ^ self.email.hash;
17
}
18

19
@end

特别鸣谢：感谢iOS各级学长学姐的博客分享

原文发布于 CSDN：【OC】OC语言学习 —— 重点内容总结与拓展（上）