黑马程序员-OC内存管理

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

内存管理
    1.移动设备的内存极其有限，每个app所能占用的内存是有限制的
    2.当app所占用的内存较多时，系统会发出内存警告，这时得回收一些不需要再使用的内存空间，比如回收一些不需要使用的对象、变量等
    3.管理范围：任何继承了NSObject的对象，结其他基本数据类型(int、char、float、double、struct、enum等)无效


引用计数器
    1.每个oc对象都有4个字节的空间用来存储引用计数器
    2.每个OC对象都有自己的引用计数器，是一个整数，表示“对象被引用的次数”，即有多少人正在使用这个OC对象

引用计数器的作用
    1.当使用alloc、new或者copy创建一个新对象时，新对象的引用计数器默认就是1
    2.当一个对象的引用计数器值为0时，对象占用的内存就会被系统回收，换句话说，如果对象的计数器不为0，那么在整个程序运行过程，它占用的内存就不可能被回收，除非整个程序已经退出。

引用计数器的操作
    1.给对象发送一条retain消息，可以使引用计数器值+1(retain方法返回对象本身)
    2.给对象发送一条release消息，可以使引用计数器值-1
    3.可以给对象发送retainCount消息获得当前的引用计数器值

对象的销毁
    1.当一个对象的引用计数器值为0时，那么它将被销毁，其占用的内存被系统回收
    2.当一个对象被销毁时，系统会自动向对象发送一条dealloc消息
    3.一般会重写dealloc方法，在这里释放相关资源，dealloc就像对象的遗言
    4.一旦重写了dealloc方法，就必须调用[super dealloc],并且放在最后面调用
    5.不要直接调用dealloc方法
    6.一旦对象被回收了，它占用的内存就不再可用，坚持使用会导致程序崩溃（即指针错误）

Xcode6找不到Use Automatic Reference Counting

手动关闭arc
    新建项目完成后，点击左侧栏里的第一行，标题
    这时主界面就会出现很多设置的项目。在上方有一个搜索栏。输入language或者ARC。
    在搜索条件将Basic改为All,Combined改为Levels
    然后找到Objective-C Automatic Reference Counting 设置为no
    就可以使用release等代码了

野指针，指向已回收的对象(不可用内存地址)的指针
        //EXC_BAD_ACCESS：访问了一块坏的内存（已经被回收不可用的内存）

打开僵尸对象检测开关：Edit schemes->Run debug->Diagnostics->Memory Management:Objective c Enable Zombie Objects

内存管理原则
1.原则分析
    房间原理，只要房间还有人在用，就不会解散
    只要还有人在用某个对象，那么这个对象就不会回收
    只要你想用这个对象，就让对象的计数器+1
    当你不再使用这个对象时，就让对象的计数器-1
    当你换房间时，原来房间的对象计数器-1，新房间+1

2.原则规范
    如果通过alloc、new或[mutable]copy来创建一个对象，那么必须调用release或 autorelease，不用自己创建的不用管


内存管理代码规范
 1.只要调用了alloc,必须有release(autorelease),如果对象不是通过alloc产生的就不需要release
 2.set方法的代码规范
 1>基本数据类型：直接复制，无需内存管理
 2>oc对象类型
 - (void)setCar:(Car *)car
 {
    //1.他判断是不是新传进来对象
    if(car!=_car)
    {
        //2.对旧对象做一次release
        [_car release];
        //3.对新对象做一次retain
        _car = [car retain];
    }
 }
 3.dealloc方法的代码规范
 1>一定要[super dealloc],而且放到最后面
 2>对self(当前)所拥有的其他对象做一次release
 -(void)dealloc
 {
    [_car release];
    [super dealloc];
 }


如果调用了retain，无论这个对象是如何生成的，都需要调用release.

property
    1.set方法内存管理相关的参数
        retain:release旧值 ，retain新值（适用于OC对象类型）
        assing：直接赋值（默认，适用于非OC对象类型）
        copy：release旧值，copy新值(一般用于NSString)
    
    2.是否要生成set方法
        readwrite:同时生成setter和getter的声明、实现
        readonly:只会生成getter的声明、实现
    
    3.多线程管理
        nonatomic:不加线程锁，性能高(ios一般就用这个)
        atomic:加线程锁，性能低（默认）
    
    4.setter和getter方法的名称
        setter : 决定了set方法的名称，一定要有个冒号
        getter : 决定了get方法的名称(一般用在BOOL类型的get方法，一般以is开头)
        
    5.@property(getter = getWeight) int weight;
    6.setHeight,height 同时生成setter和getter的声明、实现
    7.@property (readwrite,assign) int height;
    //不加锁性能高，直接赋值 age
    8.@property (nonatomic,assign) int age;
    //内存管理的name
    9.@property (retain) NSString *name;
    
循环引用

    当互相引用的时候，使用#import"类.h"，类文件将会互相拷贝.
    //而且为了提高编译效率，在头文件里并不需要类的全部内容，所以使用@class就足够了。
    
    1.@class的作用：仅仅告诉编译器，某个名称是一个类
        @class Person;//仅仅告诉编译器，Person是一个类
    
    2.开发中引用一个类的规范
        1>在.h文件中用@class来声明类
        2>在.m文件中用#import来包含类的所有东西
    
    3.@class和#import的区别
        1> #import方式会包含类的所有信息，包括被引用类的变量和方法；
        2> @class方式只是告诉编译器在A.h文件中B *b只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中的信息
        3>如果有上面个头文件都#import了同一个文件，或者这些文件依次被#import那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来讲，使用@class方式就不会出现这种问题了
        4>在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。
    
    3.循环retain
        1>比如A对象retain了B对象，B对象retain了A对象
        2>这样会导致A对象和B对象永远无法释放
    
        解决方案
        当两端互相引用时，应该一端用retain，一端用assign
    
    retain:release旧值 ，retain新值（适用于OC对象类型）
    assing：直接赋值（默认，适用于非OC对象类型）
    
autorelease的基本用法

1.autorelease的基本用法
    1>会将对象放到一个自动释放池中
    2>当自动释放池被销毁时，会对池子里面的所有对象做一次release操作
    3>会返回对象本身
    4>调用完autorelease方法后，对象的计数器不变

2.autorelease的好处
    1>不用再关心对象释放的时间
    2>不用再关心什么时候调用release

3.autorelease的使用注意
    1>占用内存较大的对象不要随便使用autorelease
    2>占用内存较小的时象使用autorelease，没有太大影响

4.自动释放池
    1>在ios程序运行过程中，会创建无数个池子。这些池子都是以栈结构存在(先进后出)
    2>当一个对象调用autorelease方法时，会将这个对象放到栈顶的释放池

5.关于系统类
    1>系统自带的方法里面没有包含alloc、new、copy，说明返回的对象都是autorelease的
    比如不需要的NSString * str = [NSString stringWithFormatL@"age is %d",10];
    比如需要的  NSNumber *num = [[NSNumber alloc]initWithInt:10];
       [num release]
    2>系统规范，方法名以类名开头。
    3>OC不允许类同名，不像java可以用包来区别或c#的命名空间。
    4>开发中经常会提供一些类方法，快速创建一个已经autorelease过的对象。

    6.关于子类
        1>如果在person中初始化时，固定初始化person那么，GoodPerson只能得到Person类对象，而如果指定为self那么谁来执行这个类方法以，就可以获得那个类的初始化
        2>创建对象时，不要直接用类名，一般用self
        例+ (id)person
        {
            return [[ss[self alloc]init] autorelease];
        }
        
ARC
    将非arc代码重构成arc代码:
    Edit->
    Refactor->Convert to Objective-C ARC ->next->save
    
    使用第三方框架，可能不是arc的，就需要项目中，即需要arc，又可以不用arc
    配置个别类，不使用arc:Xcode->s项目配置页，第一个页->Build Phases-类文件-回车或双击，弹出一个对话框，在对话框中输入-fno-bojc-arc
    -fno-bojc-arc 不支持arc
    -f-bojc-arc   支持arc
    
    ARC判断准则：只要没有强指针指向对象，就会释放对象
    ARC特点
        1>不允许调用release、retain、retainCount
        2>允许重写dealloc，但是不允许调用[super dealloc]
        3>@property的参数
            * strong : 成员变量是强指针(适用于OC对象类型)
            * weak   : 成员变量是弱指针(适用于OC对象类型)
            * assign : 适用于非OC对象类型
        4>使用ARC后，以前的retain改为strong其它一切不变
    
    指针分2种：
    1>强指针：默认情况下，所有的指针都是强针 __Strong
    2>弱指针:只要没有强指针指向对象，对象被清空，如果对象被清空，弱指针被清空__weak
    
    当指针p=nil时，对象没有指针指向而被释放
    相当于，在检测到对象没有指针指向时，被[p release]
    
    __strong Person *p = nil;
    __weak Person *p = nil;
    
    @property (nonatomic,strong) Dog *dog;
    @property (nonatomic,weak) Dog *dog;
    ARC机制下的，写法类似java
    
    当两端循环引用的时候，解决方案:
    1>ARC
        1端用strong，另1端用weak
    2>非ARC

        1端用retain，另1端用assign

Person.h->

#import <Foundation/Foundation.h>@interface Person : NSObject@end

Person.m->

#import "Person.h"@implementation Person//当一个Person对象被回收时自动调用这个方法- (void)dealloc{        NSDate *currDate=[NSDate date];//先获取当前时间    //以下两行是创建一个格式化工具，先初始化一个时间格式，然后定义这个格式    NSDateFormatter *dateFormate=[[NSDateFormatter alloc]init];    [dateFormate setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"];    //利用上面的时间格式工具把日期转换成字符串对象格式    NSString *dateStr=[dateFormate stringFromDate:currDate];        NSLog(@"Person 回收了 time:%@",dateStr);        //一定要调用父类的回收方法,而且要放在最后面    [super dealloc];}+ (void)load{    NSDate *currDate=[NSDate date];//先获取当前时间    //以下两行是创建一个格式化工具，先初始化一个时间格式，然后定义这个格式    NSDateFormatter *dateFormate=[[NSDateFormatter alloc]init];    [dateFormate setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"];    //利用上面的时间格式工具把日期转换成字符串对象格式    NSString *dateStr=[dateFormate stringFromDate:currDate];        NSLog(@"Person load time:%@",dateStr);}@end

main.m->

#import <Foundation/Foundation.h>#import "Person.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        NSLog(@"Hello, World!");        //调用引用计数器 alloc计数器加1        Person *p = [[Person alloc]init];        //类型不匹配需要强转int a = (int),或是使用匹配类型NSInteger        int a = (int)[p retainCount];        NSInteger b =[p retainCount];        NSLog(@"p retainCount 1:%d,%ld",a,b);                //发送release引用计数器减一，减为零时，对象回收        //验证对象是否回收，重写-dealloc       // [p release];        //给对象发送一条retain消息，可以使引用计数器值+1(retain方法返回对象本身)        //当对象被回收时，再发送retain就不对了。        //retain计数器加1,返回对象本身        [p retain];        b =[p retainCount];        NSLog(@"p retainCount 2:%d,%ld",a,b);        [p release];        [p release];        //已回收后多次回收同样报错        //野指针，指向已回收的对象(不可用内存地址)的指针        //EXC_BAD_ACCESS：访问了一块坏的内存（已经被回收不可用的内存）        //[p release];        b =[p retainCount];        NSLog(@"p retainCount 3:%d,%ld",a,b);        //避免野指针的方法        //变成空指针，空指针指向nil,null,0        p = nil;        b =[p retainCount];        NSLog(@"p retainCount 4:%d,%ld",a,b);                //当p = nil;后 [p release]就不报错了，因为指针没有指向作何内存        //无效信息,oc没有空指针错误，给空指针发送消息不报错，仅仅是无效警告        [p release];        //打开僵尸对象检测开关：Edit schemes->Run debug->Diagnostics->Memory Management:Objective c Enable Zombie Objects                //打开僵尸对象检测开关后        // -[Person setAge:]:message sent to deallocated instance 0x100109a10        //给已经释放的对象发送了一条-setAge:消息;        //p.age=10;    }    return 0;}

控制台：
2014-11-09 19:44:55.468 01引用计数器[869:303] Person load time:2014/11/09 19:44:55:461
2014-11-09 19:44:55.468 01引用计数器[869:303] Hello, World!
2014-11-09 19:44:55.469 01引用计数器[869:303] p retainCount 1:1,1
2014-11-09 19:44:55.470 01引用计数器[869:303] p retainCount 2:1,2
2014-11-09 19:44:55.471 01引用计数器[869:303] Person 回收了 time:2014/11/09 19:44:55:471
2014-11-09 19:44:55.471 01引用计数器[869:303] p retainCount 3:1,1
2014-11-09 19:44:55.472 01引用计数器[869:303] p retainCount 4:1,0

Person.h->

#import <Foundation/Foundation.h>#import "Book.h"@interface Person : NSObject{    //当Book是成员变量时，Book无法继承Person    Book *_book;}- (void)setBook:(Book *)book;- (Book *)book;@end

Person.m->

#import "Person.h"#import "Book.h"@implementation Person- (void)setBook:(Book *)book{    //如果_book没有值，就直接retain如果有值，则将原先的release    //可以不加判断直接 release因为oc中空指针发消息不报错    if(_book!=nil){        [_book release];    }    _book = [book retain];}- (Book *)book{    return _book;}- (void)dealloc{    //对象回收前将所持有的资源处理    [_book release];        NSLog(@"Person dealloc");    [super dealloc];}@end

Book.h->

#import <Foundation/Foundation.h>@interface Book : NSObject@end

Book.m->

#import "Book.h"@implementation Book- (void)dealloc{        NSLog(@"Book dealloc");    [super dealloc];}@end

main.m->

#import <Foundation/Foundation.h>#import "Person.h"#import "Book.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        NSLog(@"Hello, World!");        //p计数器加1        Person *p = [[Person alloc]init];                 //b,b2计数器加1        Book *b = [[Book alloc]init];        Book *b2 = [[Book alloc]init];                NSInteger i = [p retainCount];        NSLog(@"p retainCount:%ld",i);                //p调用b b计数器+1        p.book = b;                i = [b retainCount];        NSLog(@"b retainCount:%ld",i);                //p调用b2,b-1 ,b2+1        p.book = b2;                i = [b retainCount];                NSInteger i2 = [b2 retainCount];        NSLog(@"b:%ld,b2 retainCount:%ld",i,i2);                [b release];        b = nil;                [b2 release];        b2 = nil;                //计数器减1        [p release];        p=nil;    }    return 0;}

控制台：
2014-11-09 23:15:57.816 02多对象内存管理[1401:303] Hello, World!
2014-11-09 23:15:57.819 02多对象内存管理[1401:303] p retainCount:1
2014-11-09 23:15:57.820 02多对象内存管理[1401:303] b retainCount:2
2014-11-09 23:15:57.820 02多对象内存管理[1401:303] b:1,b2 retainCount:2
2014-11-09 23:15:57.821 02多对象内存管理[1401:303] Book dealloc
2014-11-09 23:15:57.821 02多对象内存管理[1401:303] Book dealloc
2014-11-09 23:15:57.822 02多对象内存管理[1401:303] Person dealloc

Person.h->

#import <Foundation/Foundation.h>#import "Car.h"@interface Person : NSObject{    int _age;    Car * _car;}- (void)setAge:(int)age;- (int)age;- (void)setCar:(Car *)car;- (Car *)car;@end

Person.m->

#import "Person.h"@implementation Person- (void)setAge:(int)age{    //基础数据类型不需要管理内存    _age = age;}- (int)age{    return _age;}- (void)setCar:(Car *)car{    //因为p的车_car和c1相同，而p在setCar中又release所以 c1-1,而之后的retain便不可用了。因为内存无效    //p.car = c1;    //解决办法在p setCar中判断如果新车与旧车是同一款，则不进行操作        if(_car!=car){            //因为oc空指针发消息不报错，所以不用判断，直接发回收信息        [_car release];        //将新车赋给人        _car = [car retain];        }}- (Car *)car{    return _car;}- (void)dealloc{    //回收所拥有的车    [_car release];    NSLog(@"age:%d of Person dealloc",_age);    [super dealloc];}@end

Car.h->

#import <Foundation/Foundation.h>@interface Car : NSObject{    int _speed;}- (void)setSpeed:(int)speed;- (int)speed;@end

Car.m->

#import "Car.h"@implementation Car- (void)setSpeed:(int)speed{    //基础数据类型不需要管理内存    _speed = speed;}- (int)speed{    return _speed;}- (void)dealloc{    NSLog(@"speed:%d of Car dealloc",_speed);    [super dealloc];}@end

main.m->

////  main.m//  03set方法内存管理////  Created by Whome on 14-11-9.//  Copyright (c) 2014年 Whome. All rights reserved.//#import <Foundation/Foundation.h>#import "Person.h"#import "Car.h"/* 内存管理代码规范 1.只要调用了alloc,必须有release(autorelease),如果对象不是通过alloc产生的就不需要release 2.set方法的代码规范 1>基本数据类型：直接复制，无需内存管理 2>oc对象类型 - (void)setCar:(Car *)car {    //1.他判断是不是新传进来对象    if(car!=_car)    {        //2.对旧对象做一次release        [_car release];        //3.对新对象做一次retain        _car = [car retain];    } } 3.dealloc方法的代码规范 1>一定要[super dealloc],而且放到最后面 2>对self(当前)所拥有的其他对象做一次release -(void)dealloc {    [_car release];    [super dealloc]; } */int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        NSLog(@"Hello, World!");        //年龄为20的人 p-1        Person *p = [[Person alloc]init];        p.age =20;        //速度为70的车 c-1        Car *c = [[Car alloc]init];        c.speed = 70;        //速度为100的车 c1-1        Car *c1 = [[Car alloc]init];        c1.speed = 100;        //年龄20的人有了速度70的人 c-2        p.car = c;        //年龄20的人有了速度100的人 c-1 c1-2        p.car = c1;                //一个不严谨的写法        // c1-1        //[c1 release];                //因为p的车_car和c1相同，而p在setCar中又release所以 c1-1,而之后的retain便不可用了。因为内存无效        //p.car = c1;                //解决办法在p setCar中判断如果新车与旧车是同一款，则不进行操作                [p release];                [c release];                [c1 release];            }    return 0;}

控制台:

2014-11-10 06:12:56.265 03set方法内存管理[458:303] Hello, World!
2014-11-10 06:12:56.269 03set方法内存管理[458:303] age:20 of Person dealloc
2014-11-10 06:12:56.270 03set方法内存管理[458:303] speed:70 of Car dealloc
2014-11-10 06:12:56.271 03set方法内存管理[458:303] speed:100 of Car dealloc

Person.h->

#import <Foundation/Foundation.h>#import "Book.h"/* 1.set方法内存管理相关的参数 retain:release旧值 ，retain新值（适用于OC 对象类型） assing：直接赋值（默认，适用于非OC对象类型 ） copy：release旧值，copy新值  2.是否要生成set方法 readwrite:同时生成setter和getter的声明、实 现 readonly:只会生成getter的声明、实现  3.多线程管理 nonatomic:不加线程锁，性能高(ios一般就用这 个) atomic:加线程锁，性能低（默认）  4.setter和getter方法的名称 setter : 决定了set方法的名称，一定要有个冒 号 getter : 决定了get方法的名称(一般用在BOOL 类型的get方法，一般以is开头)  */@interface Person : NSObject//(retain)：相当于会在set方法中release旧值,retain新值//缺点dealloc还是需要手写@property(retain)Book *book;//返回BOOL类型的方法一般以is开头@property (getter=isRich) BOOL rich;//getter名为getW,setter名为setW@property(getter = ss,setter = qwerq:) int weight;//setHeight,height 同时生成setter和getter的声明、实现@property (readwrite,assign) int height;//不加锁性能高，直接赋值 age@property (nonatomic,assign) int age;//内存管理的name@property (retain) NSString *name;@end

Person.m->

#import "Person.h"@implementation Person/* @property(retain)Book *book; 等同于 - (void)setBook:(Book *)book {    if(_book!=book){         [_book release];        _book = [book retain];     } } - (Book *)book {    return _book; } */- (void)dealloc{    //回收所拥有的书    [_book release];    NSLog(@"Person dealloc");    [super dealloc];}@endBook.h->#import <Foundation/Foundation.h>@interface Book : NSObject@endBook.m->#import "Book.h"@implementation Book- (void)dealloc{    NSLog(@"Book dealloc");    [super dealloc];}@end

main.m->

#import <Foundation/Foundation.h>#import "Person.h"#import "Book.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        NSLog(@"Hello, World!");        Person *p = [[Person alloc]init];        Book *b = [[Book alloc]init];                p.book = b;        NSInteger i = [b retainCount];        //p.qwerq不好使        [p qwerq:100];        p.age = 0;        p.rich = 1;        NSLog(@"age:%d,rich=%d weight:%d i:%ld",p.age,p.isRich,p.ss,i);        [p release];        p = nil;        [b release];        b = nil;    }    return 0;}

控制台:

2014-11-10 08:22:26.994 04set方法_property[708:303] Hello, World!
2014-11-10 08:22:27.000 04set方法_property[708:303] age:0,rich=1 weight:100 i:2
2014-11-10 08:22:27.001 04set方法_property[708:303] Person dealloc
2014-11-10 08:22:27.003 04set方法_property[708:303] Book dealloc

Person.h->

#import <Foundation/Foundation.h>//仅标明Card是一个类@class Card;@interface Person : NSObject//retain:release旧值 ，retain新值（适用于OC对象类型）@property (nonatomic,retain) Card *card;@end

Person.m->

#import "Person.h"#import "Card.h"@implementation Person+ (void)initialize{    NSLog(@"initalize Person");}+ (void)load{    NSLog(@"load Person");}- (void)dealloc{        [_card release];        NSLog(@"dealloc Person");        [super dealloc];}@end

Card.h->

#import <Foundation/Foundation.h>//仅标明Person是一个类@class Person;@interface Card : NSObject//assing：直接赋值（默认，适用于非OC对象类型）@property (nonatomic,assign) Person *person;@end

Card.m->

#import "Card.h"#import "Person.h"@implementation Card+ (void)initialize{    NSLog(@"initalize Card");}+ (void)load{    NSLog(@"load Card");}- (void)dealloc{        [_person release];        NSLog(@"dealloc Card");        [super dealloc];}@end

main.m->

#import <Foundation/Foundation.h>#import "Person.h"#import "Card.h"/*  循环retain 1>比如A对象retain了B对象，B对象retain了A对象 2>这样会导致A对象和B对象永远无法释放  解决方案 当两端互相引用时，应该一端用retain，一端用assign  */int main(int argc, const char * argv[]) {    @autoreleasepool {        // insert code here...        NSLog(@"Hello, World!");                //p-1        Person *p = [[Person alloc]init];        //c-1        Card *c = [[Card alloc]init];        //c-2        p.card = c;        //p-1        c.person = p;                //c-1        [c release];                //p-0 c-0                [p release];    }    return 0;}

控制台:

2014-11-11 04:07:22.155 05循环引用[388:303] load Person
2014-11-11 04:07:22.159 05循环引用[388:303] load Card
2014-11-11 04:07:22.159 05循环引用[388:303] Hello, World!
2014-11-11 04:07:22.160 05循环引用[388:303] initalize Person
2014-11-11 04:07:22.160 05循环引用[388:303] initalize Card
2014-11-11 04:07:22.161 05循环引用[388:303] dealloc Card
2014-11-11 04:07:22.161 05循环引用[388:303] dealloc Person

Person.h->

#import <Foundation/Foundation.h>@interface Person : NSObject@property (nonatomic,assign) int age;//简化类初始化写法+ (id)person;//初始化并给成员变量赋值+ (id)personWithAge:(int)age;@end

Person.m->

#import "Person.h"@implementation Person- (void)dealloc{    NSLog(@"age:%d Person dealloc",_age);    [super dealloc];}//简化类初始化写法+ (id)person{    //如果在person中初始化时，固定初始化person那么，GoodPerson只能得到Person类对象，而如果指定为self那么谁来执行这个类方法以，就可以获得那个类的初始化    return [[[self alloc]init]autorelease];}//初始化并给成员变量赋值+ (id)personWithAge:(int)age{    Person *p = [self person];    p.age = age;    return p;}@end

GoodPerson.h->

#import "Person.h"@interface GoodPerson : Person@property (nonatomic,assign) int money;@end

GoodPerson.m->

#import "GoodPerson.h"@implementation GoodPerson- (void)dealloc{    NSLog(@"money:%d GoodPerson dealloc",_money);    [super dealloc];}@end

main.m->

#import <Foundation/Foundation.h>#import "Person.h"#import "GoodPerson.h"/* autorelease方法会返回对象本身 调用完autorelease方法后，对象的计数器不变 autorelease会将对象放到一个自动释放池中 当自动释放池被销毁时，会对池子里面的所有对象做一次release操作 */int main(int argc, const char * argv[]) {               //一个内存栈，一般存放占用内存较小的对象    //声明这个代码块是一个自动释放池，当自动释放池销毁时，autorelease的对象将被release    @autoreleasepool    {//｛开始代表创建了释放池        Person *p1 = [[[Person alloc]init]autorelease];        p1.age = 20;    }//}结束代表销毁释放池            //自动释放池的其它写法    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];    Person *pp = [[[Person alloc]init]autorelease];    pp.age = 100;    [pool release];            //将池子清空    //[pool drain];        //简化类初始化写法,初始化成员变量,栈先进后出    @autoreleasepool {        Person *pw = [Person person];        pw.age = 101;                Person *pw1 = [Person personWithAge:102];    }            //常用错误    //1.没有放在@autoreleasepool｛｝中是无法调用release的    Person *p2 = [[[Person alloc]init]autorelease];    p2.age = 10;        //2.发送了两次autorelease，当池销毁时，也会发送两次release，但是在上一次的时候，已经变成野指针了，所以无效//    @autoreleasepool//    {//        Person *p3 = [[[[Person alloc]init]autorelease] autorelease];//    }        //2.当p4发送release后，p4已经成为野指针了，而当池子销毁时，会再一次发送release所以无效。//    @autoreleasepool//    {//        Person *p4 = [[[Person alloc]init]autorelease];//        //        [p4 release];//    }            //关于子类细节    @autoreleasepool {                //如果在person中初始化时，固定初始化person那么，GoodPerson只能得到Person类对象，而如果指定为self那么谁来执行这个类方法以，就可以获得那个类的初始化        GoodPerson *gp = [GoodPerson personWithAge:103];        // '-[Person setMoney:]: unrecognized selector sent to instance 0x100603970'        gp.money = 10;    }         return 0;}

控制台:

2014-11-11 08:37:58.637 06-autorelease[565:303] age:20 Person dealloc
2014-11-11 08:37:58.639 06-autorelease[565:303] age:100 Person dealloc
2014-11-11 08:37:58.640 06-autorelease[565:303] age:102 Person dealloc
2014-11-11 08:37:58.641 06-autorelease[565:303] age:101 Person dealloc
2014-11-11 08:37:58.642 06-autorelease[565:303] money:10 GoodPerson dealloc
2014-11-11 08:37:58.643 06-autorelease[565:303] age:103 Person dealloc
Program ended with exit code: 0

Person.h->

#import <Foundation/Foundation.h>@class Dog;@interface Person : NSObject//强指针@property (nonatomic,strong) Dog *dog;@end

Person.m->

#import "Person.h"@implementation Person- (void)dealloc{    NSLog(@"Person dealloc");    //ARC不允许，调用父类的dealloc    //[super dealloc];}@end

Dog.h->

#import <Foundation/Foundation.h>@class Person;@interface Dog : NSObject//强指针@property (nonatomic,strong) Person *person;@end

Dog.m->

#import "Dog.h"@implementation Dog- (void)dealloc{    NSLog(@"Dog dealloc");}@end

main.m->

#import <Foundation/Foundation.h>#import "Person.h"#import "Dog.h"/*  ARC判断准则：只要没有强指针指向对象，就会释放对象  ARC特点 1>不允许调用release、retain、retainCount 2>允许重写dealloc，但是不允许调用[super dealloc] 3>@property的参数 * strong : 成员变量是强指针(适用于OC对象类型) * weak   : 成员变量是弱指针(适用于OC对象类型) * assign : 适用于非OC对象类型 4>使用ARC后，以前的retain改为strong其它一 切不变  指针分2种： 1>强指针：默认情况下，所有的指针都是强针 __Strong 2>弱指针:只要没有强指针指向对象，对象被清空 ，如果对象被清空，弱指针被清空__weak  当指针p=nil时，对象没有指针指向而被释放相当于，在检测到对象没有指针指向时，被[p release]  __strong Person *p = nil;  __weak Person *p = nil;  ARC机制下的，写法类似java */int main(int argc, const char * argv[]) {        //强指针，默认强指针    __strong Person *p = [[Person alloc]init];    NSLog(@"p:%@",p);        //弱指针    __weak Person *p2 =p;        NSLog(@"p2-1:%@",p2);        p = nil;    p2 = nil;        //错误写法，因为没有强指针指向类对象，类对象不会存在，类对象不存在，指向类对象的弱指针也会被清空    p2 = [[Person alloc]init];        NSLog(@"p2-2:%@",p2);    p = [[Person alloc]init];        Dog *d = [[Dog alloc]init];        p.dog = d;        NSLog(@"p.dog-1:%@",p.dog);        d = nil;        p.dog = d;        NSLog(@"p.dog-2:%@",p.dog);        //arc的循环引用    //因为都是强指针，所以会导至无法释放，解决办法，将其中d.person变为弱指针，即人不存在了，指针无聊。    p = [[Person alloc]init];    d = [[Dog alloc]init];        p.dog = d;    d.person = p;        /*     当main结束时首先销毁d，然后销毁p，然后人和狗的类还存在，它们互相强指针，所以都没释放，但是如果将其中一个弱指针，那么被弱指针指向的类对象，就可以被销毁，它的强指针成员也就不存在，那么那个拥有弱指针成员的类对象也就被销毁     */        return 0;}

控制台:
2014-11-11 23:20:01.803 07ＡＲＣ[627:303] p:<Person: 0x100601a80>
2014-11-11 23:20:01.805 07ＡＲＣ[627:303] p2-1:<Person: 0x100601a80>
2014-11-11 23:20:01.805 07ＡＲＣ[627:303] Person dealloc
2014-11-11 23:20:01.806 07ＡＲＣ[627:303] Person dealloc
2014-11-11 23:20:01.806 07ＡＲＣ[627:303] p2-2:(null)
2014-11-11 23:20:01.807 07ＡＲＣ[627:303] p.dog-1:<Dog: 0x1001042f0>
2014-11-11 23:20:01.807 07ＡＲＣ[627:303] Dog dealloc
2014-11-11 23:20:01.808 07ＡＲＣ[627:303] p.dog-2:(null)
2014-11-11 23:20:01.809 07ＡＲＣ[627:303] Person dealloc
Program ended with exit code: 0

       

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------