iOS学习笔记01—初始化对象

iOS学习笔记01—初始化对象

1、关于alloc和init嵌套调用：

// 我们总是以如下方式嵌套alloc和init调用，为什么？
CExample *example1 = [[CExample alloc] init];

// 而不是像下面这样调用
CExample *example2 = [CExample alloc];
[example2 init];

答案：
因为初始化（init）方法返回的对象可能与分配（alloc）的对象不同。比如类簇中的NSString和NSArray等，实际上是一群隐藏在通用接口之下的与实现相关的类，创建NSString对象时，实际获得的可能是NSLiteralString、NSCFString、NSSimpleCString、NSBallOfString或者其他未写入文档的与实现相关的对象。由于init方法可以接受参数，所以该方法的代码能够检查其接受的参数的值，并判断返回另一个类的对象可能更合适。基于这种一认知，字符串初始化函数可能决定创建一个属于其他类的对象（该对象更适合被期望的字符串的要求），然后返回该对象而不是原来的对象。

还是举个例子来看吧：
有如下3个类，声明如下
@interface Car : NSObject
- (id)initWithCarBrandName: (NSString *)carBrandName;
- (void)print;

@end

@interface Benz : Car

@end

@interface Bmw : Car

@end

实现如下

@implementation Car

- (id)initWithCarBrandName:(NSString *)carBrandName{

[self autorelease];

if ([carBrandName isEqualToString:
@"BMW"]) {
return [[Bmw alloc]init];
}

if ([carBrandName isEqualToString:
@"BENZ"]) {
return [[Benz alloc] init];
}

returnnil;
}

- (void)print{

NSLog(@"I am in Car print");
}

@end

@implementation Benz
- (void)print{

NSLog(@"I am in Benz print");
}

@end

@implementation Bmw
- (void)print{

NSLog(@"I am in Bmw print");
}

@end

调用如下
Car *car1 = [[Car alloc] initWithCarBrandName:@"BMW"];

[car1 print]; //输出“I am in Bmw print”

Car *car2 = [Car alloc];

[car2 initWithCarBrandName:@"BENZ"]; //
实际上-initXXX的结果必须要有assignment，否则单独call -initXXX，等于白做。

[car2 print]; //输出“I am in Car print”

// 下面这么做虽然拆分了alloc和init，但init返回的对象赋给了alloc返回的对象，也可以
Car *car3 = [Car alloc];

car3 = [car3initWithCarBrandName:
@"BENZ"];

[car3 print]; //输出“I am in Benz print”

2、关于self = [super init];
先看一下官方文档给出的初始化示例代码：
-(id)init{

//
为什么要将父类初始化之后，用其返回的对象指针覆盖当前对象的指针。
if (self = [super init]) {

// Do additional init
}

return (self);
}

@end

为什么要将父类初始化之后，用其返回的对象指针覆盖当前对象的指针?
答案：
[super init]的返回值（假设是变量superRet）有以下几种情况：
1）superRet==nil
此时父类初始化失败，self随之被赋值为nil并返回，表现正常。
2）superRet==self
大部分类的初始化都是这个结果。此时赋值没有任何影响。
3）superRet!=self
这种情况正是大部分人疑惑的地方。执行self = [super
init]之后，我们创建的对象将会被重定向到另外一块内存上。接下来重点解释这种情况。

回想一下，self是每个方法的一个隐藏参数，指向当前对象。因此，这是一个局部变量。那么，为什么我们要改变一个局部变量的值呢？事实上，self必须要改变。我们将在下面解释为什么要这样做。
[super init]实际上有可能返回不同于当前对象的另外一个对象。
实例变量所在的内存位置到隐藏的self参数之间的距离是固定的，如果从init方法返回一个新对象，则需要更新self，以便其后的任何实例变量的引用可以被映射到正确的内存位置，这也是我们需要使用self =
[super init]这种形式的重要原因。

单例模式就是self必须要改变的一种情况。
而且有一个 API可以用一个对象替换新分配的对象。Core Data（Apple提供的
Cocoa里面的一个 API）就是用了这种 API，对实例数据做一些特殊的操作，从而让这些数据能够和数据库的字段关联起来。当继承 NSManagedObject类的时候，就需要仔细对待这种替换。在这种情形下，self就要指向两个对象：一个是
alloc返回的对象，一个是 [super init]返回的对象。修改self的值对代码有一定的影响：每次访问实例数据的时候都是隐式的。正如下面的代码所示：

@interface B : A {
int i;
}

@end

@implementation B
-(id) init {

//
此时，self 指向 alloc返回的值

//
假设 A进行了替换操作，返回一个不同的
self
id newSelf = [super init];
NSLog(@"%d", i);//输出
self->i的值
self = newSelf;
//有人会认为 i没有变化

NSLog(@"%d", i);//事实上，此时的 self->i,
实际是 newSelf->i,

//
和之前的值可能不一样了

returnself;
}

@end

...
B* b = [[B alloc] init];

self = [super
init] 简洁明了，也不必担心以后会引入 bug。然而，我们应该注意旧的self指向的对象的命运：它必须被释放。第一规则很简单：谁替换self指针，谁就要负责处理旧的self指针。在这里，也就是
[super init]负责完成这一操作。

总结一下，出现父类指针跟子类指针不一样的情况其实就是父类的init方法返回的对象跟原先创建的对象不一样，分为以下几种：
1）单件。
此时如果执行self = [super
init]将使所有子类指向这个单件的内存。
这不仅使所有子类互相修改数据，甚至访问子类自己增加的变量的时候，可能会崩溃。
建议不要继承单件、或者保证单件的子类也是单件。

2）ClassClusters（类簇），初始化方法返回了不同的子类。
以下是对象初始化后，返回不同的子类的例子：
NSString *str1 = [NSString alloc];
NSString *str2 = [str1 initWithString:@"hello"];
上面的str1和str2是不一样的对象，存在于不同的内存块中，在GNUStep里面，str1是GSPlaceholderString对象，str2是GSCInlineString对象。

3）共享。
先看例子：
NSNumber *n1 = [[NSNumber alloc] initWithInt:1];

NSNumber *n2 = [[NSNumberalloc]
initWithInt:1];
以上的n1和n2，指向了同一块内存！
由于NSNumber是创建之后就不能修改的对象，所以Foundation在这里做了一些优化，相同数值的NSNumber对象将共享同一块内存。

4）父类可能在初始化中释放了当前的对象并创建了新的内存区域。
这时，子类需要将self指向新的内存区域才能正常工作。所以一定要执行self
= [super init];

总结：
在初始化方法中使用self = [super init]语句是Objective-C的标准做法。
一般情况下都要用以上语句来防止父类改变对象的内存地址导致self指针指向无效内存。
但是在父类是单件、类簇或者有共享资源的时候，必须依照实际情况考虑是否加上这行代码。
总之，当需要继承父类的时候，调用父类的init之前，必须知道父类的init方法的工作方式。