2018-05-24 学习对象初始化
一.生命周期
一个对象的生命周期有诞生（通过alloc或者new方法实现）、生存（接收消息和执行操作）、交友（借助方法的组合和参数）以及死亡（被释放）。释放之后，原来占用的内存可供新对象使用。
1.引用计数
当某段代码需要访问一个对象的时候，该对象的保留计数器加1，表示“我要访问该对象”；当这段代码结束对这个对象的访问时，该对象的保留计数器减1，表示它不再访问该对象。当保留计数器的值为0的时候，表示不再有代码访问该对象了，因此对象被销毁，其占用的内存会被回收。
当使用alloc、new方法或者通过copy消息创建一个对象的时候，对象的保留计数器设置为1。要增加对象的保留计数器值，可以给对象发送一条retain消息。要减少对象的保留计数器值，可以给对象发送一条release消息。
2.自动释放
Cocoa有个概念叫做自动释放池，没错就是那个NSAutoreleasePool。
当我们申请一个对象的时候，可以用alloc关键词，在ARC的xcode是不用自己手动调用release方法的，因为自动释放池会帮我们自动释放掉。
- (NSString *)description
{
NSString *description;
description = [[NSString alloc] initWithFormat:@"I am %d years old", 4];
return description;
}
3.内存管理
以下规则只针对ARC：
- 当使用new、alloc或者copy创建一个对象的时候偶，该对象的保留计数器值为1，当不再使用该对象的时候，要向该对象发送一条release或autorelease消息，这样，该对象将会在其使用寿命结束的时候被销毁。
- 当通过任何其他方法获得一个对象时，则假设该对象的保留计数器值为1，而且已经被设置为自动释放，不需要执行任何操作来确保该对象被清理。如果打算在一段时间内拥有该对象，则需要保留它并确保在操作完成时释放它。
- 如果保留了某个对象，需要最终释放或自动释放该对象。必须保持retain方法和release方法使用次数相等。
4.垃圾回收
关于ARC和MRC的区别，具体参考该博文：
https://www.jianshu.com/p/48665652e4e4
OC2.0引入了自动内存管理机制，也称垃圾回收。使用ARC后，系统会检测出何时需要保持对象，何时需要自动释放对象，何时需要释放对象，编译器会管理好对象的内存，会在何时的地方插入retain, release和autorelease，通过生成正确的代码去自动释放或者保持对象。我们完全不用担心编译器会出错。
二.初始化对象
Cocoa的初始化惯例其实是用[[类名 alloc] init]而不是[类名 new]，即便这两种方法是等价的。但是为什么要用alloc+init呢，看看这篇博文就知道了。
https://blog.csdn.net/xf931456371/article/details/50321357
原来是因为这个原因：
如果要用new方法去初始化的话，那么调用类的初始化就只能在类的init函数定义了。
但是如果用alloc+init的话，初始化的类型可以千变万化，你可以改init的名字，也可以改传入init的参数。
Person.h如下：
#import <Foundation/Foundation.h>
@interface Person : NSObject
@property (nonatomic, assign) NSString* name;
@property (nonatomic, assign) int age;
-(id) initWithName: (NSString *) name andAge: (int) age;
@end
Person.m如下：
#import "Person.h"
@implementation Person
@synthesize name = _name;
@synthesize age = _age;
-(id) initWithName:(NSString *)name andAge:(int)age
{
if (self = [super init]) {
_name = name;
_age = age;
}
return self;
}
@end
Main.m如下：
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import "Person.h"
int main(int argc, char * argv[]) {
@autoreleasepool {
Person *person;
person = [[Person alloc] initWithName: @"Hoben"
andAge: 5];
NSLog(@"%@'s age is %d", [person name], [person age]);
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
1.分配与初始化
分配是一个新对象诞生的过程，从操作系统获得一块内存并将其指定为存放对象的实例变量的位置。向某个类发送alloc消息的结果，就是为该类分配一块足够大的内存，以存放该类的全部实例变量。
同时，alloc方法还顺便将这块内存区域全部初始化为0.所有BOOL类型变量被初始化为NO，所有int类型变量被初始化为0，所有float类型变量被初始化为0.0，所有指针被初始化为nil。
但是，一个刚刚分配的对象并不能立即使用，需要先初始化该对象，然后才使用它。OC拆分成了两个明确的步骤：分配和初始化，因此，只分配而不初始化的操作是错误的，以下是个反例：
Car *car = [Car alloc];
这个代码能运行，但可能会出现奇奇怪怪的bug。
2.初始化
初始化，即从操作系统取得一块内存，准备用于存储对象。init方法几乎总是返回它们正在初始化的对象。初始化应该要嵌套使用，将alloc和init放在同一行内，如：
//正确的代码
Car *car = [[Car alloc] init];
//错误的代码
//Car *car = [Car alloc];
//[car init];
这种嵌套是很必要的，因为初始化方法返回的对象可能和分配的对象不一样。
3.编写初始化方法
回到我们之前写过的init方法：
- (id)init
{
self = [super init];
if (self) {
// doSomething;
}
return self;
}
self = [super init]，其作用是使超类完成它们自己的初始化工作。从根类NSObject继承的类调用超类的初始化方法，可以使NSObject执行所需的任何操作，以便对象能够响应消息并处理保留计数器。而从其他类继承的类调用超类的初始化方法，可以使子类有机会实现自己的全新的初始化。
实例变量所在的内存位置到隐藏的self参数之间的距离是固定的。如果从init方法返回一个新对象，则需要更新self，以便其后的任何实例变量的引用可以被映射到正确的内存位置。所以要用self = [super init]进行赋值。
如果在初始化对象的时候出现问题，则init方法可能返回nil。如使用init方法接收一个URL并使用网站的图像文件初始化一个图像对象。如果网络故障导致init方法返回nil，则这个方法的主体代码将不会执行。
最后，return (self)即将[super init]的返回值赋给self。
4.初始化的方式
在我之前做的例子中，初始化有两种方法：车造车、人造车
第一种方法即在Car.h文件中的init函数创建了Engine对象和4个tire对象，最后在main.m文件中调用alloc和init，使车变得可以运行。
第二种方法则在Car.h中什么都不做，而是定义了一个set方法和一个get方法，在main.m文件中，先创建Engine和tire对象，再将它们装到Car中去。
相比之下，第一种方法更适用于即买即用，如果Car类的预期用途是创建和使用基本的car对象，那用第一种方法。
第二种方法更适用于面对不同种类的tire和Engine，这时候需要在main.m文件中定义不同的零件，把他们再装到Car上面去。
5.让初始化更便利
许多类都包含便利初始化函数，让初始化便利得更痛快一些。
NSString的初始化：
NSString *string = [[NSString alloc] initWithFormat: @"Yes"];
initWithContentsOfFile:
读取文件内容并使文件内容初始化一个字符串：
NSString *string = [[NSString alloc] initWithContentsOfFile: @"/tmp/words.txt"];
6.改造我的Car代码
之前用到的new是时候换换了，这次我们再给Tire加点属性：
//Tire.h
@property (nonatomic, assign) float pressure;
@property (nonatomic, assign) float treadDepth;
-(void) setPressure:(float)pressure;
-(void) setTreadDepth:(float)treadDepth;
//Tire.m
@synthesize treadDepth = _treadDepth;
@synthesize pressure = _pressure;
-(void) setTreadDepth:(float)treadDepth
{
_treadDepth = treadDepth;
}
-(void) setPressure:(float)pressure
{
_pressure = pressure;
}
- (NSString *)description
{
return [NSString stringWithFormat:@"Tire!
Pressure: %.1f TreadDepth: %.1f", _pressure, _treadDepth];
}
- (instancetype)init
{
self = [super init];
if (self) {
_pressure = 34.0;
_treadDepth = 24.0;
}
return self;
}
Car *car = [[Car alloc] init];
Engine *engine = [[Slant6 alloc] init];
[car setEngine: engine];
for (int i = 0; i < 4; i++) {
Tire *tire = [[Tire alloc] init];
[tire setPressure: 24.0 + I];
[tire setTreadDepth: 35.0 + I];
[car setTire: tire atIndex: I];
}
[car print];
看到car的Tire数组有点不舒服，把它换成NSMutableArray：
//Car.h
@interface Car : NSObject
{
Engine *engine;
// Tire *tires[4];
NSMutableArray *tires;
}
//Car.m
- (instancetype)init
{
self = [super init];
if (self) {
tires = [[NSMutableArray alloc] init];
for (int i = 0; i < 4; i++) {
[tires addObject: [NSNull null]];
}
}
return self;
}
-(void) setTire:(Tire *)tire
atIndex:(int)index
{
if (index < 0 || index > 3) {
NSLog(@"bad index (%d) in setTire:atIndex", index);
exit(1);
}
// tires[index] = tire;
[tires replaceObjectAtIndex: index withObject: tire];
}
7.便利化初始函数遇上继承
把我们的Tire初始化改得更简洁一些吧：
//Tire.m
- (instancetype)init
{
self = [super init];
if (self) {
_pressure = 34.0;
_treadDepth = 24.0;
}
return self;
}
-(id) initPressure:(float)pressure andTreadDepth:(float)treadDepth
{
if (self = [super init]) {
_pressure = pressure;
_treadDepth = treadDepth;
}
return self;
}
-(id) initPressure:(float)pressure
{
if (self = [super init]) {
_pressure = pressure;
_treadDepth = 24.0;
}
return self;
}
-(id) initThreadDepth:(float)treadDepth
{
if (self = [super init]) {
_pressure = 24.0;
_treadDepth = treadDepth;
}
return self;
}
是的，我又加了一些init方法，来确保两个变量能得到初始化。
现在给我们的AllWeatherRadial添加点属性：
//AllWeatherRadial.h
#import <Foundation/Foundation.h>
#import "Tire.h"
@interface AllWeatherRadial : Tire
@property (nonatomic, assign) float rainHandling;
@property (nonatomic, assign) float snowHandling;
-(void) setRainHandling:(float)rainHandling;
-(void) setSnowHandling:(float)snowHandling;
再加个init：
- (instancetype)init
{
self = [super init];
if (self) {
_rainHandling = 23.7;
_snowHandling = 42.5;
}
return self;
}
在main里面init一下：
Car *car = [[Car alloc] init];
Engine *engine = [[Slant6 alloc] init];
[car setEngine: engine];
for (int i = 0; i < 4; i++) {
AllWeatherRadial *tire = [[AllWeatherRadial alloc] initPressure:53.0 andTreadDepth:66.0];
[car setTire: tire atIndex: I];
}
[car print];
猜猜会发生什么事？
。。。
我擦，为啥我辛辛苦苦在继承类里面初始化的值不见了？！
冷静冷静，我们看看main函数是怎么初始化的：
看到这行没有，没错，因为AllWeatherRadial里面没有initPressure函数！
那怎么解决呢？难不成每个继承的子类都要加上我之前定义的四种init方法？哇，如果有n个子类继承了m个方法的话，那不是凉了，m*n个方法，有得你写了。。
不要担心，OC爸爸有一招妙招：
观察到没有， initPressure:(float)pressure andTreadDepth:(float)treadDepth是四个方法里面普适性最强的一个了，其他三个方法都可以按照这个来改，于是，我们让Tire.m变成这般：
//Tire.m
-(id) initPressure:(float)pressure andTreadDepth:(float)treadDepth
{
if (self = [super init]) {
_pressure = pressure;
_treadDepth = treadDepth;
}
return self;
}
- (id)init
{
// self = [super init];
self = [self initPressure: 34 andTreadDepth: 20]
if (self) {
// _pressure = 34.0;
// _treadDepth = 24.0;
}
return self;
}
-(id) initPressure:(float)pressure
{
if (self = [self initPressure: pressure andTreadDepth: 20]) {
// _pressure = pressure;
// _treadDepth = 24.0;
}
return self;
}
-(id) initThreadDepth:(float)treadDepth
{
if (self = [self initPressure: 34 andTreadDepth: treadDepth]) {
// _pressure = 24.0;
// _treadDepth = treadDepth;
}
return self;
}
//AllWeatherRadial.m
-(id) initPressure:(float)pressure andTreadDepth:(float)treadDepth
{
self = [super initPressure: pressure andTreadDepth: treadDepth];
if (self) {
_rainHandling = 23.7;
_snowHandling = 42.5;
}
return self;
}
成功啦！
