002-OC基础语法

一、关键字：improt与include

1.相同点

　　improt与include都有文件包含的功能

2.不同点

　　improt是OC的关键字，而include是C的关键字；二者的最大区别在于improt可以防止重复包含，而include则容易造成重复包含的问题。

 

二、关键字：NSLog与printf

NSLog是OC的关键字，printf是C的关键字；前者打印输出自动换行，并且打印输出会有时间、日期等信息

 

三、OC的数据类型

1.OC的数据类型分类

　　1）基本数据类型：int、float、double、char

　　2）对象类型：OC的对象类型实际就是C的结构体

　　3）id类型：泛型指针

　　4）BOOL类型：本质就是char类型，可以当成整数来用(YES = 1, NO = 0)

　　5）SEL类型：方法包装

　　6）block类型：本质就是指向函数的指针，另外block弥补了指向函数的指针不能直接保存一个函数体

2.数据类型的特征

　　1）可作为参数传递

　　2）可作为函数的返回值

　　3）可以声明成变量

3.数据类型的作用

　　OC中的这些数据类型也是为了更加合理地分配内存空间

4.重点讲解

　　1）SEL类型

　　　　我们声明对象的方法，被包装成一个SEL类型的变量(SEL s = @selector(方法名))放在对象方法列表中，我们在调用对象方法时，实际上是对象里的isa指针指向该方法列表中SEL变量，通过这个变量指针地址去查找相应的方法。

// Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject

#pragma mark - 成员属性
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
@property (nonatomic, copy) NSString *sex;

#pragma mark - 方法
- (void)name:(NSString *)name age:(int)age sex:(NSString *)sex;

@end


// Person.m文件
#import "Person.h"

@implementation Person

#pragma mark - 方法
- (void)name:(NSString *)name age:(int)age sex:(NSString *)sex
{
    NSLog(@"name = %@, age = %d, sex = %@", name, age, sex);
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Person.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
 
    Person *p = [[Person alloc] init];
    p.name = @"Frank";
    p.age = 25;
    p.sex = @"M";
    // 将方法包装成SEL类型
    // SEL abc = @selector(name:age:sex:);
    // 通过performSelector:方法调用SEL类型的对象方法
    [p performSelector:@selector(name:age:sex:)];
}

@end

　　2）block类型

　　　　实例一：block作为函数参数传递

// Calculate.h文件
#import <Foundation/Foundation.h>

#pragma mark - block类型的声明
typedef int(^CalculateBlock)(int a, int b);

@interface Calculate : NSObject

#pragma mark - 将block类型作为函数参数传递
- (int)calculateWithNumber1:(int)num1 number2:(int)num2 calculateBlock:(CalculateBlock)calculate;

@end


// Calculate.m文件
#import "Calculate.h"

@implementation Calculate

#pragma mark - block作为函数参数传递，其调用在函数调用的时候进行
- (int)calculateWithNumber1:(int)num1 number2:(int)num2 calculateBlock:(CalculateBlock)calculate
{
    return calculate(num1, num2);
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Calculate.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    Calculate *cal = [[Calculate alloc] init];
    int sum = [cal calculateWithNumber1:20 number2:30 calculateBlock:^int(int a, int b) {
        return a + b;
    }];
    NSLog(@"sum = %d", sum);
}

@end

　　　　实例二：block作为成员变量

// Calculate.h文件
#import <Foundation/Foundation.h>

#pragma mark - block类型的声明
typedef int(^CalculateBlock)(int a, int b);

@interface Calculate : NSObject

#pragma mark - 将block类型作为成员属性
@property (nonatomic, copy) CalculateBlock cb;

#pragma mark - 方法
- (void)calculateWithNum1:(int)num1 num2:(int)num2;

@end


// Calculate.m文件
#import "Calculate.h"

@implementation Calculate

#pragma mark - 方法实现
- (void)calculateWithNum1:(int)num1 num2:(int)num2
{
    // 判断block作为成员变量，是否被赋值
    if (self.cb) {
        // 如果被赋值，就被调用
        self.cb(num1, num2);
    }
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Calculate.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    Calculate *cal = [[Calculate alloc] init];
    // 给cal对象的block类型成员变量cb赋值 -- 也就是block的实现
    cal.cb = ^ int (int a, int b) {
        int sum = a + b;
        return sum;
    };
    
    // 调用cal方法
    [cal calculateWithNum1:20 num2:30];
}

@end

　　　　实例三：主动调用block，block修改外部变量的值

// ViewController.m文件
#import "ViewController.h"

#pragma mark - block类型的声明
typedef void(^BoolBlock)(BOOL);

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // block内部想要改变外部变量的值，则必须使用__block修饰该变量
    __block int i = 1024;
    BoolBlock cb = ^(BOOL bv) {
        if (bv) {
            // block内部修改外部变量的值
            i++;
        }
    };
    BOOL a = YES;
    
    // 主动调用一下block
    cb(a);
}

@end

　　　　关于block，需要注意一下几点：

　　　　　　a.block做成员变量，参数必须用copy，copy会将block的生命周期从栈转移到堆空间，其生命周期就会交给程序员自己管理，不会出现block被提前释放，也就不会造成block野指针错误

　　　　　　b.block作为参数时，为防止循环引用，必须放在函数尾部

　　　　　　c.默认情况下，任何的block都是放在栈里边，随时都可能会被回收，block没有使用retain，理由是retain只是计数器加1，内存地址不会改变，因而不能将block从栈里边放到堆里

　　　　　　d.MRC模式下用__block去修饰block代码块内部需要引用的对象，在ARC模式下用__weak去修饰block内部引用的对象，这样可防止由于循环引用造成的内存泄露

　　　　　　e.block内部修改外部变量的值，必须使用__block修饰该变量，一般情况下我们不建议在block内部去修改外部变量的值

 

四、Category(类别、分类)

1.Category的基本要点

　　1）分类只是扩展方法，不可以扩展成员变量；但是在分类中是可以直接访问原来类中.h文件声明的所有方法和所有成员变量

　　2）分类可以在不获悉、不改变原来类的的同时，可以为原来类扩展一些方法；但是分类只可以扩展原来类的方法，不可以修改和删除原来类的方法

　　3）在分类中重写原类中的方法，会覆盖原来类的方法，并且该重写后的方法只会在分类中有效，对于原来的类是没有影响

　　4）在同一个原有类的多个分类中如果出现了相同的方法，系统会根据编译顺序来决定调用的是哪一个分类中的扩展方法

　　5）分类是可以被继承的，在父类中导入分类的头文件，那么在其子类中也是可以访问分类中的扩展方法

2.Category的优点

　　1）将类的实现分散到多个不同的文件或是不同的框架中

　　2）可以向对象添加非正式协议

　　3）创建私有方法的前向引用

3.Category的创建步骤

　　

　　

　　

// NSString+LD.h文件
#import <Foundation/Foundation.h>

@interface NSString (LD)

#pragma mark - 统计字符串中0-9的个数
+ (int)numberCountOfString:(NSString *)string;
#pragma mark - 统计字符串中0-9的个数
- (int)numberCount;

@end


// NSString+LD.m文件
#import "NSString+LD.h"

@implementation NSString (LD)

#pragma mark - 统计字符串中0-9的个数
+ (int)numberCountOfString:(NSString *)string
{
    return [string numberCount];
}

#pragma mark - 统计字符串中0-9的个数
- (int)numberCount
{
    int count = 0;
    for (int i = 0; i < self.length; i++) {
        unichar c = [self characterAtIndex:i];
        // 字符都是以ASCII码存储的
        if (c >= '0' && c <= '9') {
            count++;
        }
    }
    return count;
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "NSString+LD.h"    // 导入分类头文件

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 调分类中的类方法
    int num1 = [NSString numberCountOfString:@"34ty6iui2"];
    NSLog(@"num1 = %d", num1);
    
    // 调用分类中的对象方法
    NSString *string = @"34ty6iui2";
    int num2 = [string numberCount];
    NSLog(@"num2 = %d", num2);
}

@end

4.补充说明

　　分类中不可以扩展原来类的成员变量也不是绝对的。比如在分类中引进运行(runtime)，是可以扩展成员属性的。因为分类扩展的成员变量是不能生成get和set方法的，那么我们可以在.m文件中引进运行时技术，动态地给成员变量添加两个方法(get和set方法)

// Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;

@end


// Person.m文件
#import "Person.h"

@implementation Person

@end


// Person+LD.h文件
#import "Person.h"

@interface Person (LD)

#pragma mark - 分类中扩展的成员属性
@property (nonatomic, assign) double height;

@end


// Person+LD.m文件
#import "Person+LD.h"
#import <objc/message.h>  // 导入运行时头文件

@implementation Person (LD)

// 静态变量
static double HeightKey;

#pragma mark - set方法
- (void)setHeight:(double)height
{
    objc_setAssociatedObject(self, &HeightKey, @(height), OBJC_ASSOCIATION_ASSIGN);
}

#pragma mark - get方法
- (double)height
{
    return [objc_getAssociatedObject(self, &HeightKey) doubleValue];
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Person+LD.h"  // 导入分类头文件

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 调用
    Person *p = [[Person alloc] init];
    p.name = @"Frank";
    p.age = 25;
    p.height = 110.5;     // 分类中扩展的成员属性
    NSLog(@"height = %.2f", p.height);
}

@end

 5.总结

　　分类是对一些系统的类进行功能的补充。就好比是一个产品当你发现它的缺陷和一些不足时，你就会想着去完善和补充，但是产品的缘由功能都是存在的

 

五、Protocol(协议)

1.Protocol的基本要点

　　1）协议方法的声明部分在协议文件中

　　2）协议方法的实现部分在遵循该协议的类文件中

　　3）协议中被关键字@required修饰的协议方法必须在遵循该协议类中去实现，协议中被关键字@optional修饰的协议方法可以选择实现

　　4）对于必须实现的协议方法，我们在调用的时候可以随意调用；但是对于可选择实现的协议方法，我们必须先确定已被实现，方可调用，否则会造成程序异常

　　5）所有的协议都是遵循基协议NSObject

　　6）父类遵循的协议，同样会被继承父类的子类所遵循；但是子类如果不自己实现该协议方法，那么利用该子类调用该协议方法时，其本质还是相当于父类在调用

　　7）协议中是不可以声明成员变量的

　　8）判断遵循协议类是否实现某个协议方法：performSelector:@selector(协议方法)

2.Protocol的创建步骤

　　

　　

 

　　

3.在实际开发中的情况

　　实例一：单独创建一个协议文件

// LDFrankDelegate.h文件
#import <Foundation/Foundation.h>

@protocol LDFrankDelegate <NSObject>

#pragma mark - 协议方法的声明部分
// 必须实现的协议方法(霸王条款)
@required
- (void)eat;
- (void)drink;

// 可以选择实现的方法
@optional
- (void)gamble;
- (void)walk;

@end


// Person.h文件
#import <Foundation/Foundation.h>
#import "LDFrankDelegate.h"  // 导入协议文件

@interface Person : NSObject<LDFrankDelegate> // 遵循协议

@end


// Person.m文件
#import "Person.h"

@implementation Person

#pragma mark - 协议方法的实现部分
// 必须实现以下协议方法
- (void)eat
{
    NSLog(@"eat");
}
- (void)drink
{
    NSLog(@"drink");
}

// 可以选择实现以下协议方法
- (void)gamble
{
    NSLog(@"gamble");
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Person.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    Person *p = [[Person alloc] init];
    // 必须实现的协议方法调用
    [p eat];
    [p drink];
    
    // 可实现的协议方法调用
    // 必须先判断该协议方法是否被实现
    if ([p performSelector:@selector(gamble)]) {
        [p gamble];
    }
    if ([p performSelector:@selector(walk)]) {
        [p walk];
    }
}

@end

 　　实例二：直接将协议文件写入遵循该协议文件中

// Person.h文件
#import <Foundation/Foundation.h>

#pragma mark - 协议的声明
@protocol LDFrankDelegate <NSObject>

#pragma mark - 协议方法的声明部分
// 必须实现的协议方法(霸王条款)
@required
- (void)eat;
- (void)drink;

// 可以选择实现的方法
@optional
- (void)gamble;
- (void)walk;

@end

@interface Person : NSObject<LDFrankDelegate> // 遵循协议

@end


// Person.m文件
#import "Person.h"

@implementation Person

#pragma mark - 协议方法的实现部分
// 必须实现以下协议方法
- (void)eat
{
    NSLog(@"eat");
}
- (void)drink
{
    NSLog(@"drink");
}

// 可以选择实现以下协议方法
- (void)gamble
{
    NSLog(@"gamble");
}

@end

4.总结

　　Protocol只是定义一些接口，是定义行为而不管谁去实现，是一种不负责任行为。就好比在产品外包中，外发公司只需要拿到功能完善的产品，而不去理睬功能实现的过程。

 

六、继承

1.成员变量的访问属性

　　1）private：私有成员属性，不能被外部函数访问，也不能被子类所继承

　　2）protected：保护成员属性，不能被外部函数访问 ，但是可被子类继承

　　3）public：公有成员属性，可以被外部函数访问，也可以被子类继承

　　4）OC中，所有的方法都是公有的

2.关于继承的几个要点

　　1）OC中的NSObject是大部分类的父类，我们称之为基类或是根类，只有当继承自NSObject这个基类，才有创建对象的能力

　　2）子类可从父类继承方法，但有时父类的方法不适合子类，子类就可写一个自己的同名方法，覆盖掉父类的同名方法，叫做重写。重写时，在子类的.h中不必重新声明，直接在.m中写实现即可

　　3）子类可以创建自己的独有方法，该独有方法必须在子类中有完整的声明和实现；子类同时也可以创建自己的成员属性。子类在原有继承基础上，创建自己独有的成员属性和方法，叫做派生

　　4）父类指针可以指向子类

3.继承的好处

　　1）创建大量的相似类的时候，可以先创建一个父类，父类中写一些公有的特性，使这些相似的类继承父类，可以节省工作量

　　2）使用框架中的类，或是已经写好的类，继承该类，生成一个派生类，比原类更好用(NSString、NSArray、NSDictionary都是不能够被继承的)

4.继承的创建步骤

　　

　　

5.实际开发中的问题

// Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    // 公有的
    @public
        NSString *_name;
    
    // 受保护的
    @protected
        NSInteger _age;
    
    // 私有的
    @private
        NSInteger _money;
}

@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, assign) NSInteger money;

#pragma mark - 父类的方法的声明
- (void)eat;
- (void)drink;

@end


// Person.m文件
#import "Person.h"

@implementation Person

#pragma mark - 父类的方法的实现
- (void)eat
{
    NSLog(@"Person eat");
}
- (void)drink
{
    NSLog(@"Person drink");
}

@end


// Boy.h文件
#import "Person.h"

@interface Boy : Person

#pragma mark - 子类独有的成员属性(派生)
@property (nonatomic, copy) NSString *habit;

#pragma mark - 子类独有的方法的声明(派生)
- (void)test;

@end


// Boy.m文件
#import "Boy.h"

@implementation Boy

#pragma mark - 子类独有方法的实现
- (void)test
{
    // 父类中public和protected修饰的成员属性在子类中可以直接访问
    _name = @"Frank";
    _age = 25;
    
    // 父类中private修饰的成员属性在子类中不可以直接访问，只能通过父类的方法去访问
    // _money = 50000000;    // 这个就会报错
    self.money = 50000000;
    [self setMoney:50000000];
    
    NSLog(@"name = %@, age = %ld, money = %ld", _name, _age, [self money]);
}

#pragma mark - 子类重写父类的方法
- (void)eat
{
    NSLog(@"男孩都喜欢吃好吃的");
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Boy.h"    // 导入子类的头文件

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // 父类的指针可以指向子类
    Person *p = [[Boy alloc] init];
    
    // 父类指针指向子类，调用的方法如果是子类的重写方法，那么其调用的还是子类的方法
    [p eat];
    
    // 父类指针指向子类，不可以通过父类指针调用子类的派生方法
    // [p test];    // 这个会报错
}

@end

 

七、多态

1.概念

　　对态就是给不同的对象发送相同的消息，得到的反应结果是不一样的

2.实现多态的条件

　　1）必须有继承关系：实现多态的对象必须是满足继承关系的对象

　　2）必须有重写父类的方法

　　3）必须有父类指针指向子类的对象

3.多态在实际开发中的应用

　　总结：响应消息，不看指针，看对象

// Animal.h文件
#import <Foundation/Foundation.h>

@interface Animal : NSObject

#pragma mark - 父类方法的声明
- (void)beated;

@end


// Animal.m文件
#import "Animal.h"

@implementation Animal

#pragma mark - 父类方法的实现
- (void)beated
{
    NSLog(@"父类被打， 不知道怎么反应!");
}

@end


// Cat.h文件
#import "Animal.h"

@interface Cat : Animal

@end


// Cat.m文件
#import "Cat.h"

@implementation Cat

#pragma mark - 重写父类方法
- (void)beated
{
    NSLog(@"猫被打：miao, miao, 跑到树上!");
}

@end


// Tiger.h文件
#import "Animal.h"

@interface Tiger : Animal

@end


// Tiger.m文件
#import "Tiger.h"

@implementation Tiger

#pragma mark - 重写父类方法
- (void)beated
{
    NSLog(@"老虎被打：Come on, I am hungry!");
}

@end


// Wolf.h文件
#import "Animal.h"

@interface Wolf : Animal

@end


// Wolf.m文件
#import "Wolf.h"

@implementation Wolf

#pragma mark - 重写父类方法
- (void)beated
{
    NSLog(@"狼被打: 我还会回来的!");
}

@end


// Person.h文件
#import <Foundation/Foundation.h>
#import "Animal.h"

@interface Person : NSObject

#pragma mark - Animal 可以接受所有的子类
// 参数：animal，可以接受所有继承自Animal类的子类对象
- (void)beat:(Animal *)animal;

@end


// Person.m文件
#import "Person.h"

@implementation Person

#pragma mark - 使用了父类的指针，作为形参
- (void)beat:(Animal *)animal
{
    NSLog(@"%@ 被打啦", NSStringFromClass([animal class]));
    [animal beated];
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Person.h"
#import "Cat.h"
#import "Tiger.h"
#import "Wolf.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    
    Person *p = [[Person alloc] init];
    
    // 初始化子类
    Cat *cat = [[Cat alloc] init];
    Tiger *tiger = [[Tiger alloc] init];
    Wolf *wolf = [[Wolf alloc] init];
    
    // 通过父类指针调用子类重写的方法 -- 得到不同的反应结果
    [p beat:cat];
    [p beat:tiger];
    [p beat:wolf];
}

@end

 

八、封装

1.类是对数据和功能的封装。其中成员属性就是读对数据的封装，而方法就是对功能的封装

2.在OC语言中，使用@interface和@implementation来处理类

3.@interface就好像暴露在外面的时钟表面，像外界提供展示以及接口。

4.@implementation就好像隐藏在时钟内部的构造实现，把具体的实现封装了起来。

 

九、self关键字与点语法

1.self关键字

　　1）self是一个指针，谁调用了当前方法，self就指向谁(出现在对象方法中，就代表着当前对象，出现在类方法中，就代表着当前类)

　　2）self的用途:

　　　　a.可以利用 self->成员变量名 访问当前对象内部的成员变量(仅在对象方法中)

　　　　b.[self 方法名]；可以调用其他的对象方法或者是类方法

 2.点语法

　　1）为什么要使用点语法

　　　　a.为了方便别的程序员转到OC上面来(C++/Java/C#都是使用的点语法)

　　　　b.为了让程序设计简单化，隐藏一些内存管理、多线程、同步、枷锁的细节

　　2）点语法的调用

　　　　a.点语法与set方法：

　　　　　　person.name = @"Frank";       // 点语法赋值

　　　　　　[person setName:@"Frank"];   // set方法

　　　　b.点语法与get方法：

　　　　　　person.name;                        // 点语法取值

　　　　　　[person name];                     // get方法

　　3）点语法的条件

　　　　a.对象调用点语法，对象必须实现set和get方法

　　　　b.使用点语法的set方法，只能够带有一个参数

 

十、对象之间的关系

1.匿名对象

// Book.h文件
#import <Foundation/Foundation.h>

@interface Book : NSObject

@end


// Book.m文件
#import "Book.h"

@implementation Book

@end


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

@interface Person : NSObject

#pragma mark - 成员属性
@property (nonatomic, copy) NSString *name;

#pragma mark - 方法声明
- (void)readBook:(Book *)book;

@end


// Person.m文件
#import "Person.h"

@implementation Person

#pragma mark - 方法实现
- (void)readBook:(Book *)book
{
    NSLog(@"读书");
}

@end


// ViewController.m文件
#import "ViewController.h"
#import "Person.h"
#import "Book.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
 
    // [类名 new]；   // 创建一个匿名对象
    [[Person new] readBook:[Book new]];
}

@end

　　匿名对象的作用:

　　　　1）当调用使用次数很少的方法的时候，就直接使用匿名对象调用

　　　　2）匿名对象可以作为参数传递，当不需要给传递的对象的成员变量赋值的时候，就使用匿名对象作为参数传递

2.依赖关系

　　1）A对象作为B对象的局部变量或是方法形参，则B依赖于A，这时我们讲AB对象之间是一种依赖关系

　　2）在面向对象编程中：

　　　　耦合度：指的是修改一个对象而对另一个对象的影响程度

　　　　低耦合：指的是修改一个对象对其他对象的影响程度比较小

　　　　高内聚：一个对象仅仅只做与自己相关的事情

3.关联关系

　　简单地讲，就是指A对象为B对象的成员变量，我们就说A对象与B对象之间存在一种关联关系

　　关联关系的耦合度要高于依赖关系

 

十一、类与对象

1.类

　　1）类的本质：类其实也是个对象，只不过是类对象

// Person.h文件
#import <Foundation/Foundation.h>

@interface Person : NSObject

#pragma mark - 成员属性
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;

@end


// Person.m文件
#import "Person.h"

@implementation Person

@end


// Viewcontroller.m文件
#import "ViewController.h"
#import "Person.h"  // 导入头文件

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 1.利用类去创建类的对象
    Person *p = [[Person alloc] init];
    p.name = @"Dave";
    p.age = 10;
    
    // 2.利用类对象去创建类的对象
    Class c = [p class];  // 内存中的类对象，我们也可以使用这个类对象去调用类方法
    Person *p1 = [[c new] init];
    p1.name = @"Frank";
    p1.age = 25;
}

@end

　　2）类的加载

　　　　两大方法：+ (void)load;  + (void)initialize;

　　　　　　a.当程序启动时，就会加载项目中所有的类和分类，而且加载会调用load方法，该方法只会调用一次

　　　　　　b.当程序第一次使用某个类时，就会调用该类的initialize方法

　　　　　　c.类加载的顺序：先加载父类，再加载子类(先调用父类的load方法，后调用子类的load方法)；对于分类，先加载原来类，再加载分类

　　　　　　d.第一次使用子类：先初始化父类，再初始化子类(先调用父类的initialize方法，后调用子类的initialize方法)

2.对象

　　OC的对象实质就是C语言中的结构体

 

十二、description方法

1.调用

　　打印输出对象时调用该方法，我们一般可以在这里返回对象的属性输出

2.方法

　　类方法：+ (NSString *)description;

　　对象方法：- (NSString *)description;

 

 

（未完待续......）