【黑马程序员】iOS学习之路——Objective-C之内存管理

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

一、基本原理

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

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

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

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

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

//
//  main.m
//  01-引用计数器的基本操作
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

/*
 1.方法的基本使用
 1> retain ：计数器+1，会返回对象本身
 2> release ：计数器-1，没有返回值
 3> retainCount ：获取当前的计数器
 4> dealloc
  * 当一个对象要被回收的时候，就会调用
  * 一定要调用[super dealloc]，这句调用要放在最后面
 
 2.概念
 1> 僵尸对象 ：所占用内存已经被回收的对象，僵尸对象不能再使用
 2> 野指针 ：指向僵尸对象（不可用内存）的指针，给野指针发送消息会报错（EXC_BAD_ACCESS）
 3> 空指针 ：没有指向任何东西的指针（存储的东西是nil、NULL、0），给空指针发送消息不会报错
 
 */

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    // 1
    Person *p = [[Person alloc] init];
    
    //NSUInteger c = [p retainCount];
    
    //NSLog(@"计数器：%ld", c);
    
    
    // 2 retain方法返回的是对象本身
    [p retain];
    
    // 1
    [p release];
    
    // 0 野指针：指向僵尸对象（不可用内存）的指针
    [p release];
    
    [p retain];
    
    // -[Person setAge:]: message sent to deallocated instance 0x100109a10
    // 给已经释放的对象发送了一条-setAge:消息：
    p.age = 10;
    //[p setAge:10];
    
    // 指针p变成空指针
    //p = nil;
    
    // EXC_BAD_ACCESS : 访问了一块坏的内存（已经被回收、已经不可用的内存
    // 野指针错误
    // OC不存在空指针错误，给空指针发送消息，不报错
    [p release];
    [p release];
    [p release];
    [p release];
    
    [nil release];
    
    return 0;
}

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property int age;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"

@implementation Person


// 当一个Person对象被回收的时候，就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");
    
    // super的dealloc一定要调用，而且放在最后面
    [super dealloc];
}

@end

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

2.谁创建，谁release
如果你通过alloc、new或[mutable]copy来创建一个对象，那么你必须调用release或autorelease
换句话说，不是你创建的，就不用你去[auto]release

3.谁retain，谁release
只要你调用了retain，无论这个对象是如何生成的，你都要调用release

4.总结
有始有终，有加就有减
曾经让对象的计数器+1，就必须在最后让对象计数器-1

//
//  main.m
//  02-多个对象之间的内存管理
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

/*
 1.你想使用（占用）某个对象，就应该让对象的计数器+1（让对象做一次retain操作）
 2.你不想再使用（占用）某个对象，就应该让对象的计数器-1（让对象做一次release）
 
 3.谁retain，谁release
 
 4.谁alloc，谁release
 */

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Book.h"

int main()
{
    // b-1
    Book *b = [[Book alloc] init];
    // p-1
    Person *p1 = [[Person alloc] init];
    
    //p1想占用b这本书
    // b-2
    [p1 setBook:b];
    
    // p-0
    // b-1
    [p1 release];
    p1 = nil;
    
    // b-0
    [b release];
    b = nil;
    return 0;
}

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>
#import "Book.h"

@interface Person : NSObject
{
    Book *_book;
}

- (void)setBook:(Book *)book;
- (Book *)book;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"

@implementation Person
- (void)setBook:(Book *)book
{
    _book = [book retain];
}

- (Book *)book
{
    return _book;
}

- (void)dealloc
{
    [_book release];
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Book.h
 */
#import <Foundation/Foundation.h>

@interface Book : NSObject
{
    int _price;
}

- (void)setPrice:(int)price;
- (int)price;


@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Book.m
 */

#import "Book.h"


@implementation Book

- (void)setPrice:(int)price
{
    _price = price;
}

- (int)price
{
    return _price;
}
- (void)dealloc
{
    NSLog(@"Book对象被回收");
    [super dealloc];
}
@end

如果你有个OC对象类型的成员变量，就必须管理这个成员变量的内存。比如有个Book *_book
1.set方法的实现
- (void)setBook:(Book *)book{
	if (book != _book) {
		[_book release];
		_book = [book retain];
	}
}

2.dealloc方法的实现
- (void)dealloc {
	[_book release];
	[super dealloc];
}

//
//  main.m
//  03-set方法的内存管理
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Car.h"
#import "Person.h"
#import "Student.h"
#import "Dog.h"
/*
 内存管理代码规范：
 1.只要调用了alloc，必须有release（autorelease）
   对象不是通过alloc产生的，就不需要release
 
 2.set方法的代码规范
 1> 基本数据类型：直接复制
 - (void)setAge:(int)age
 { 
    _age = age;
 }
 
 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];
 }
 */

// 速度为100的车子：
// 速度为200的车子：p1->_car

int main()
{
    // stu - 1
    Student *stu = [[Student alloc] init];
    
    // Car - 2
    // 这行内存有内存泄露
    //stu.car = [[Car alloc] init];
    
    // stu - 0
    // Car - 1
    [stu release];
    
    
    // 这行内存有内存泄露
    // [[Car alloc] init].speed = 100;
    
    return 0;
}


void test3()
{
    Student *stu = [[Student alloc] init];
    
    
    Car *c = [[Car alloc] init];
    stu.car = c;
    
    
    Dog *d = [[Dog alloc] init];
    
    stu.dog = d;
    
    
    NSString *s = @"Jack";
    
    stu.name = s;
    
    [d release];
    [c release];
    [stu release];
}

void test2()
{
    Person *p1 = [[Person alloc] init];
    p1.age = 20;
    
    // c1 - 1
    Car *c1 = [[Car alloc] init];
    c1.speed = 100;
    // c1 - 2
    p1.car = c1;
    // c1 - 1
    [c1 release];
    
    Car *c2 = [[Car alloc] init];
    c2.speed = 200;
    // c1 - 0
    p1.car = c2;
    
    [c2 release];
    
    [p1 release];
}

void test1()
{
    // p-1
    Person *p = [[Person alloc] init];
    p.age = 20;
    
    // c1-1
    Car *c1 = [[Car alloc] init];
    c1.speed = 250;
    
    // c1-2
    p.car = c1;
    
    // c1-1
    [c1 release];
    
    
    
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    
    
    
    
    [p release];
}

void test()
{
    // p-1
    Person *p = [[Person alloc] init];
    p.age = 20;
    
    // c1-1
    Car *c1 = [[Car alloc] init];
    c1.speed = 250;
    
    // p想拥有c1
    // c1-2
    p.car = c1;  // [p setCar:c1];
    
    // c2-1
    Car *c2 = [[Car alloc] init];
    c2.speed = 300;
    
    // p将车换成了c2
    // c1-1
    // c2-2
    p.car = c2;
    
    // c2-1
    [c2 release];
    // c1-0
    [c1 release];
    // p-0 c2-0
    [p release];
}

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>
#import "Car.h"

@interface Person : NSObject
{
    Car *_car;
    int _age;
}

- (void)setAge:(int)age;
- (int)age;

- (void)setCar:(Car *)car;
- (Car *)car;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"

// _car -> c1  0

@implementation Person
- (void)setCar:(Car *)car
{
    if (car != _car)
    {
        // 对当前正在使用的车（旧车）做一次release
        [_car release];
        
        // 对新车做一次retain操作
        _car = [car retain];
    }
}
- (Car *)car
{
    return _car;
}

- (void)setAge:(int)age
{ // 基本数据类型不需要管理内存
    _age = age;
}
- (int)age
{
    return _age;
}

- (void)dealloc
{
    // 当人不在了，代表不用车了
    // 对车做一次release操作
    [_car release];
    
    NSLog(@"%d岁的Person对象被回收了", _age);
    
    [super dealloc];
}

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Student.h
 */
#import <Foundation/Foundation.h>
#import "Car.h"
#import "Dog.h"

@interface Student : NSObject
{
    int _no;
    NSString *_name;
    Car *_car;
    Dog *_dog;
}

- (void)setNo:(int)no;
- (int)no;

- (void)setName:(NSString *)name;
- (NSString *)name;

- (void)setCar:(Car *)car;
- (Car *)car;

- (void)setDog:(Dog *)dog;
- (Dog *)dog;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Student.m
 */

#import "Student.h"

@implementation Student
- (void)setNo:(int)no
{
    _no = no;
}
- (int)no
{
    return _no;
}

- (void)setName:(NSString *)name
{
    if ( name != _name )
    {
        [_name release];
        _name = [name retain];
    }
}

- (NSString *)name
{
    return _name;
}

- (void)setCar:(Car *)car
{
    if ( car != _car )
    {
        [_car release];
        _car = [car retain];
    }
}
- (Car *)car
{
    return _car;
}

- (void)setDog:(Dog *)dog
{
    if ( dog != _dog )
    {
        [_dog release];
        _dog = [dog retain];
    }
}
- (Dog *)dog
{
    return _dog;
}

- (void)dealloc
{
    [_name release];
    [_car release];
    [_dog release];
    
    [super dealloc];
}
@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Car.h
 */
#import <Foundation/Foundation.h>

@interface Car : NSObject
{
    int _speed;
}

- (void)setSpeed:(int)speed;
- (int)speed;
@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Car.m
 */

#import "Car.h"

@implementation Car
- (void)setSpeed:(int)speed
{
    _speed = speed;
}
- (int)speed
{
    return _speed;
}


- (void)dealloc
{
    /*
     _speed ：直接访问成员变量
     self->_speed ：直接访问成员变量
     self.speed : get方法
     [self speed] : get方法
     */
    
    NSLog(@"速度为%d的Car对象被回收了", _speed);
    
    [super dealloc];
}

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Dog.h
 */
#import <Foundation/Foundation.h>

@interface Dog : NSObject

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Dog.m
 */

#import "Dog.h"

@implementation Dog

@end

1.控制set方法的内存管理
retain ： release旧值，retain新值（用于OC对象）
assign ： 直接赋值，不做任何内存管理(默认，用于非OC对象类型)
copy   ： release旧值，copy新值（一般用于NSString *）
 
2.控制需不需生成set方法
readwrite ：同时生成set方法和get方法（默认）
readonly  ：只会生成get方法
 
3.多线程管理
atomic    ：性能低（默认）
nonatomic ：性能高
 
4.控制set方法和get方法的名称
setter ： 设置set方法的名称，一定有个冒号:
getter ： 设置get方法的名称

//
//  main.m
//  04-@property参数
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"
#import "Book.h"

int main()
{
    Book *b = [[Book alloc] init];
    Person *p = [[Person alloc] init];
    
    p.book = b;
    
    
    NSLog(@"%ld", [b retainCount]);
    
    
    [p release];
    [b release];
    return 0;
}

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>
#import "Book.h"

@interface Person : NSObject
@property int age;

// retain : 生成的set方法里面，release旧值，retain新值
@property (retain) Book *book;
@property (retain) NSString *name;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"

@implementation Person

//- (void)setBook:(Book *)book
//{
//    if (_book != book)
//    {
//        [_book release];
//        
//        _book = [book retain];
//    }
//}

- (void)dealloc
{
    [_book release];
    [_name release];
    [super dealloc];
}

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Student.h
 */
#import <Foundation/Foundation.h>
#import "Book.h"

@interface Student : NSObject

@property (retain) Book *book;

@property (retain) NSString *name;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Student.m
 */

#import "Student.h"

@implementation Student


- (void)dealloc
{
    [_book release];
    [_name release];
    
    [super dealloc];
}

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Book.h
 */
#import <Foundation/Foundation.h>

@interface Book : NSObject

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Book.m
 */

#import "Book.h"

@implementation Book

@end

1.@class
使用场景
对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类
 	 
这种代码编译会报错。当使用@class在两个类相互声明，就不会出现编译报错
用法概括
使用 @class 类名; 就可以引用一个类，说明一下它是一个类
和#import的区别
#import方式会包含被引用类的所有信息，包括被引用类的变量和方法；@class方式只是告诉编译器在A.h文件中 B *b 只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看B类中信息
如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来 讲，使用@class方式就不会出现这种问题了
在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类


2.循环retain
比如A对象retain了B对象，B对象retain了A对象
这样会导致A对象和B对象永远无法释放

3.解决方案
当两端互相引用时，应该一端用retain、一端用assign

//
//  main.m
//  07-循环引用
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//


/*
 1.@class的作用：仅仅告诉编译器，某个名称是一个类
 @class Person; // 仅仅告诉编译器，Person是一个类
 
 2.开发中引用一个类的规范
 1> 在.h文件中用@class来声明类
 2> 在.m文件中用#import来包含类的所有东西
 
 3.两端循环引用解决方案
 1> 一端用retain
 2> 一端用assign
 
 */

#import <Foundation/Foundation.h>
#import "Card.h"
#import "Person.h"

int main()
{
    // 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;
}

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>
#import "Card.h"
// @class仅仅是告诉编译器，Card是一个类
//@class Card;

@interface Person : NSObject

@property (nonatomic, retain) Card *card;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"
#import "Card.h"

@implementation Person

- (void)dealloc
{
    NSLog(@"Person被销毁了");
    [_card release];
    
    [super dealloc];
}

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Card.h
 */
#import <Foundation/Foundation.h>


@class Person;

@interface Card : NSObject

@property (nonatomic, assign) Person *person;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Card.m
 */

#import "Card.h"
#import "Person.h"

@implementation Card


- (void)dealloc
{
    NSLog(@"Car被销毁了");
    
    // [_person release];
    
    [super dealloc];
}

@end

1.autorelease
给某个对象发送一条autorelease消息时，就会将这个对象加到一个自动释放池中
当自动释放池销毁时，会给池子里面的所有对象发送一条release消息
调用autorelease方法时并不会改变对象的计数器，并且会返回对象本身
autorelease实际上只是把对release的调用延迟了，对于每一次autorelease，系统只是把该对象放入了当前的autorelease pool中，当该pool被释放时，该pool中的所有对象会被调用Release

2.自动释放池的创建
ios 5.0后
@autoreleasepool
{
    // ....
}
ios 5.0前
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// .....
[pool release]; // 或[pool drain];
在程序运行过程中，可以创建多个自动释放池，它们是以栈的形式存在内存中
OC对象只需要发送一条autorelease消息,就会把这个对象添加到最近的自动释放池中(栈顶的释放池)

3.应用实例
跟release的对比
以前:

Book *book = [[Book alloc] init];
[book release];
现在:
Book *book = [[[Book alloc] init] autorelease];
// 不要再调用[book release];

一般可以为类添加一个快速创建对象的类方法
+ (id)book {
    return [[[Book alloc] init] autorelease];
}
外界调用[Book book]时，根本不用考虑在什么时候释放返回的Book对象

4.规律
一般来说,除了alloc、new或copy之外的方法创建的对象都被声明了autorelease
比如下面的对象都已经是autorelease的，不需要再release
NSNumber *n = [NSNumber numberWithInt:100];
NSString *s = [NSString stringWithFormat:@"jack"];
NSString *s2 = @"rose";

//
//  main.m
//  08-autorelease
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

/*
 1.autorelease的基本用法
 1> 会将对象放到一个自动释放池中
 2> 当自动释放池被销毁时，会对池子里面的所有对象做一次release操作
 3> 会返回对象本身
 4> 调用完autorelease方法后，对象的计数器不变
 
 2.autorelease的好处
 1> 不用再关心对象释放的时间
 2> 不用再关心什么时候调用release
 
 3.autorelease的使用注意
 1> 占用内存较大的对象不要随便使用autorelease
 2> 占用内存较小的对象使用autorelease，没有太大影响
 
 
 4.错误写法
 1> alloc之后调用了autorelease，又调用release
 @autoreleasepool
 {
    // 1
    Person *p = [[[Person alloc] init] autorelease];
 
    // 0
    [p release];
 }
 
 2> 连续调用多次autorelease
 @autoreleasepool
 {
    Person *p = [[[[Person alloc] init] autorelease] autorelease];
 }
 
 5.自动释放池
 1> 在iOS程序运行过程中，会创建无数个池子。这些池子都是以栈结构存在（先进后出）
 2> 当一个对象调用autorelease方法时，会将这个对象放到栈顶的释放池
 
 
 6.自动释放池的创建方式
 1> iOS 5.0前
 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 
 [pool release]; // [pool drain];
 
 
 2> iOS 5.0 开始
 @autoreleasepool
 {
    
 }
 */

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    Person *pp = [[[Person alloc] init] autorelease];
    
    [pool release]; // [pool drain];
    
    @autoreleasepool
    {
    
        // 1
        Person *p = [[[[Person alloc] init] autorelease] autorelease];
        
        // 0
        // [p release];
    }
    
    return 0;
}


void test()
{
    @autoreleasepool
    {// { 开始代表创建了释放池
        
        // autorelease方法会返回对象本身
        // 调用完autorelease方法后，对象的计数器不变
        // autorelease会将对象放到一个自动释放池中
        // 当自动释放池被销毁时，会对池子里面的所有对象做一次release操作
        Person *p = [[[Person alloc] init] autorelease];
        
        p.age = 10;
        
        
        
        @autoreleasepool
        {
            // 1
            Person *p2 = [[[Person alloc] init] autorelease];
            p2.age = 10;
            
            
        }
        
        
        Person *p3 = [[[Person alloc] init] autorelease];
        
        
    } // } 结束代表销毁释放池
}<pre name="code" class="objc">//
//  main.m
//  09-autoreleased的应用
//
//  Created by apple on 13-8-9.
//  Copyright (c) 2013年 itcast. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Person.h"
#import "GoodPerson.h"

/*
 1.系统自带的方法里面没有包含alloc、new、copy，说明返回的对象都是autorelease的
 
 2.开发中经常会提供一些类方法，快速创建一个已经autorelease过的对象
 1> 创建对象时不要直接用类名，一般用self
 + (id)person
 {
    return [[[self alloc] init] autorelease];
 }
 */

int main()
{
    @autoreleasepool {
        Person *p = [Person personWithAge:100];
        
        
        GoodPerson *p2 = [GoodPerson personWithAge:10];
        
        p2.money = 100;
    }
    return 0;
}

void test()
{
    Person *p = [[Person alloc] init];
    
    p.age = 200;
    
    [p release];
    
    // 包
    // Student com.mj.test
    // Student com.mj.test2
    
    // MJStudent
    
    // SBStudent
    
    // Next Step
    
    
    @autoreleasepool
    {
        //        Person *p2 = [Person person];
        //
        //        p2.age = 100;
        
        Person *p2 = [Person personWithAge:100];
        
        //        Person *p2 = [[[Person alloc] init] autorelease];
        //
        //        p2.age = 300;
        
        
        NSString *str = @"123123";
        
        NSString *str2 = [NSString stringWithFormat:@"age is %d", 10];
        
        NSNumber *num = [[NSNumber alloc] initWithInt:10];
        [num release];
        
        
        NSNumber *num2 = [NSNumber numberWithInt:100];
    }
}

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (nonatomic, assign) int age;


+ (id)person;

+ (id)personWithAge:(int)age;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"

@implementation Person


+ (id)person
{
    return [[[self alloc] init] autorelease];
}


+ (id)personWithAge:(int)age
{
    Person *p = [self person];
    p.age = age;
    return p;
}

- (void)dealloc
{
    NSLog(@"%d岁的人被销毁了", _age);
    
    [super dealloc];
}
@end

/*
 作者：MJ
 描述：
 时间：
 文件名：GoodPerson.h
 */
#import "Person.h"

@interface GoodPerson : Person

@property (nonatomic, assign) int money;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：GoodPerson.m
 */

#import "GoodPerson.h"

@implementation GoodPerson

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.h
 */
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic, assign) int age;

@end

/*
 作者：MJ
 描述：
 时间：
 文件名：Person.m
 */

#import "Person.h"

@implementation Person
- (void)dealloc
{
    NSLog(@"Person---dealloc");
    
    [super dealloc];
}
@end