Oc语言学习 —— 重点内容总结与拓展（下）

#__NSCFConstantString

#Constant-> 常量

通俗理解其就是常量字符串，是一种编译时常量。 这种对象存储在字符串常量区。

通过打印起 retainCount 的值，发现很大，2^64 - 1，测试证明对其进行 release 操作时，retainCount 不会产生任何变化是创建之后便无法释放掉的对象。

当我们使用不同的字符串对象进行创建时当内容相同，其对象的地址也相同，这也就证明了常量字符串是一种 ** 单例 ** 。

这种对象一般通过字面值 @”…”、CFSTR (”…”) (一种宏定义创建字符串的方法) 或者 stringWithString: 方法（现在会报警告⚠️这个方法等同于字面值创建的方法）。

#__NSCFString

和 __NSCFConstantString 不同， __NSCFString 对象是在运行时创建的一种 NSString 子类，他并不是一种字符串常量。所以和其他的对象一样在被创建时获得了 1 的引用计数。

这种对象被存储在堆上。

通过 NSString 的 stringWithFormat 等方法创建的 NSString 对象一般都是这种类型。 如果字符串长度大于 9 或者如果有中文或其他特殊符号（可能是非 ASCII 字符）存在的话则会直接成为 __NSCFString 类型

#NSTaggedPointerString

理解这个类型，需要明白什么是标签指针，这是苹果在 64 位环境下对 NSString,NSNumber 等对象做的一些优化。

简单来讲可以理解为 ** 把指针指向的内容直接放在了指针变量的内存地址中 ，因为在 64 位环境下指针变量的大小达到了 8 字节足以容纳一些长度较小的内容 **。于是使用了标签指针这种方式来优化数据的存储方式。

从其的引用计数可以看出，这也是一个释放不掉的单例常量对象。当我们使用不同的字符串对象进行创建时当内容相同，其对象的地址也相同。在运行时根据实际情况创建。

对于 NSString 对象来讲，当非字面值常量的数字，英文字母字符串的长度小于等于 9 的时候会自动成为 NSTaggedPointerString 类型。(小于等于 9 这个数据也是原博主进行猜测，经过测试在字符串含有 q 的时候是小于等于 7)

#三种字符串类型的 copy/ mutablecopy / retainCount 情况

总结就是

无论原来的三个的类型是 NSString 还是 NSMutableString 类型

copy 会使原来的对象引用计数加一 (当然仅有正常类型的字符串，而不是单例创建的，毕竟那两个引用计数是无限的)，并拷贝对象地址给新的指针，所以类型与原类型一致。

mutableCopy 不会改变引用计数 ，会拷贝内容到堆上，生成一个 __NSCFString 对象，新对象的引用计数为 1.

#内存分布补充

#二、指针类型强制转换

这一点与 C 语言十分类似。 除了 id 类型变量之外，指针变量只能调用编译时的类型方法，而不能调用运行时的类型方法所以我们需要将变量类型强制转换为运行时的类型，也就是对象的类。 ​

#规范、协议与接口

类是一种具体的实现题，而协议这是定义了一种规范，定义了某一类所需要遵守的规范。

协议不提供任何实现，它体现的是规范和实现分离的设计哲学。   让规范和实现分离正是协议的好处，是一种松耦合的设计。

tips：OC 中协议的作用就相当于其他语言中接口的作用。

  协议定义的是多个类共同的公共行为规范，协议里通常定义的是一组公用方法，但不会为这些方法提供实现，方法的实现则交给类去实现。

#使用类别实现非正式协议

1
#import <Foundation/Foundation.h>
2

3
NS_ASSUME_NONNULL_BEGIN
4

5
@interface NSObject (EaTable)
6
-(void) Lai;
7

8
@end
9

10
NS_ASSUME_NONNULL_END

1
#import <Foundation/Foundation.h>
2

3
NS_ASSUME_NONNULL_BEGIN
4

5
@interface FKLaiCai : NSObject
6
-(void) Lai;
7

8
@end
9

10
NS_ASSUME_NONNULL_END

1
#import "FKLaiCai.h"
2

3
@implementation FKLaiCai
4
-(void) Lai {
5
    NSLog(@"虔诚拜三拜，钱包里面多几百");
6
}
7
@end

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

4
int main(int argc, const char * argv[]) {
5
    @autoreleasepool {
6
        FKLaiCai* Laicai = [[FKLaiCai alloc] init];
7
        [Laicai Lai];
8
    }
9
    return 0;
10
}

运行结果：

​

#正式协议

定义正式协议的时候，不再使用 @interface，@implementation关键字了，而是使用 @protocol关键字，定义正式协议语法如下：

1
@protocol 协议名<父协议1，父协议2>
2

3
{
4

5
    多个方法定义
6

7
}

对于上述语法，做出以下详细说明：

1、协议名应与类名采用相同的命名规则

2、一个协议可以有多个字节父协议，但协议只能继承协议，不能继承类

3、协议中定义的方法只有方法签名，没有方法实现

4、协议中包含的方法可以是类方法，也可以是实例方法

tips：因为协议定义的是多个类共同的公共行为规范，所以，协议里所有的方法都是公开的访问权限。

1

2
#import <Foundation/Foundation.h>
3

4
NS_ASSUME_NONNULL_BEGIN
5

6
@protocol Printable <NSObject>
7

8
@required
9
-(void)printInfo;
10

11

12
@end
13

14
NS_ASSUME_NONNULL_END

1

2
#import <Foundation/Foundation.h>
3
#import "Printable.h"
4

5
NS_ASSUME_NONNULL_BEGIN
6

7
@interface Person : NSObject<Printable>
8

9
@property (nonatomic,copy) NSString* name;
10
@property (nonatomic,assign) NSInteger age;
11

12
@end
13

14
NS_ASSUME_NONNULL_END

1

2
#import "Person.h"
3

4
@implementation Person
5

6
-(void) printInfo {
7
    NSLog(@"Name: %@, Age: %ld", self.name, self.age);
8
}
9

10
- (NSString *)infoSummary {
11
    return [NSString stringWithFormat:@"%@ is %ld years old.", self.name, (long)self.age];
12
}
13
@end

1
#import "Person.h"
2
#import "Printable.h"
3

4
int main(int argc, const char * argv[]) {
5
    @autoreleasepool {
6
        Person *p = [[Person alloc] init];
7
        p.name = @"揽佬";
8
        p.age = 99;
9
        [p printInfo];
10
    }
11
    return 0;
12
}

​

我们也可以一个协议，这个协议同时继承两个协议：

1
#import <Foundation/Foundation.h>
2
#import "FKOutput.h"
3
#import "FKProductable.h"
4

5
NS_ASSUME_NONNULL_BEGIN
6

7
//定义协议，继承了FKutput、FKProductable两个协议
8
@protocol FKPrintable <FKOutput, FKProductable>
9
//定义协议的方法
10
- (NSString*) printColor;
11

12
@end
13

14
NS_ASSUME_NONNULL_END

tips：协议的继承和类的继承不一样，协议完全支持多继承，即一个协议可以有多个直接的父协议。和类继承相似，子协议继承某个父协议，将会获得父协议中的所有方法。一个协议继承多个父协议时, 多个父协议排在 <> 中间，多个协议口见以（,）隔开。

#遵守（实现协议）

在类的接口可以继承该类继承的父类，以及遵守的协议，一个类可以同时遵守多个协议，语法如下：

1
@interface 类名:父类<协议1, 协议2...>

如果程序需要使用协议来定义变量，有以下两种语法：

1
- NSObject<协议1,协议2...>* 变量；
2
 - id<协议1,协议2...>* 变量；
3
### 协议的意义
4

5

6
1，在多个类具有相同行为时，如果没有协议，你必须知道每个对象的具体类型并单独处理。
7

8

9
```objective-c
10
NSArray<id<Printable>> *objects = @[p, d, r];
11

12
for (id<Printable> obj in objects) {
13
    [obj printInfo]; // 不关心具体类名
14
}

但是在使用协议后，只要你遵守了协议，我就可以调用你的方法。

2，解耦代码，实现高内聚 

#正式协议与非正式协议

非正式协议通过为 NSObject 创建类别来实现，而正式协议直接使用 @protocol 创建； 遵守非正式协议通过继承带特定类别的 NSObject 来实现，而遵守正式协议则有专门的 OC 语法来实现； 遵守非正式协议不要求实现协议中定义的所有方法；而遵守正式协议则必须实现协议中定义的所有方法。   为了弥补遵守正式协议必须实现协议的所有方法造成灵活性不足，在 OC 还有两个关键字：

**@optional：** 位于该关键字只后、@required 或 @end 之前声明的方法是可选的，实现类可选择是否实现这些方法。 **@required：** 位于该关键字之后、@optional 或 @end 之前声明的方法是必需的，实现类必需实现这些方法。 通过在正式协议中使用以上两个关键字，正式协议完全可以代替非正式协议的功能。

#协议与委托

协议体现的是一种规范，定义协议的类可以把协议定义的方法委托给实现协议的类，这样可以让类定义具有更好的通用性，因为具体的动作将由该协议的实现类去完成。无论是基于 Mac 的 Cococa 应用开发还是 iOS 开发，各种应用程序大量依赖委托这个概念。