OC的构造方法与分类知识点总结

OC语言构造方法：

用来初始化对象的方法，对象方法，以减号开头

为了让对象创建出来，成员变量就会有一些固定的值

重写构造方法的注意点：

先调用父类的构造方法([super init])

再进行子类内部成员变量的初始化

参考：http://www.codes51.com/article/detail_111604.html

构造方法的调用：

完整的创建一个可用的对象：Person *p=[Person new];

New方法的内部会分别调用两个方法来完成2件事情，

1）使用alloc方法来分配存储空间（返回分配的对象）；

2）使用init方法来对对象进行初始化。

可以把new方法拆开如下：

1.调用类方法+alloc分配存储空间，返回未经初始化的对象

Person *p1=[person  alloc];

2.调用对象方法-init进行初始化，返回对象本身

Person *p2=[p1 init];

3.以上两个过程整合为一句：

Person *p=[[Person alloc] init];

说明：init方法就是构造方法，是用来初始化对象的方法，注意这是一个对象方法，一减号开头。默认初始化完毕后，所有成员变量的值都为0。

例如：

Person.h

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property int age;
@end

Person.m

#import "Person.h"

@implementation Person

// 重写-init方法
//- (id)init
//{
//    // 1.一定要调用回super的init方法:初始化父类中声明的一些成员变量和其他属性
//    self = [super init]; // 当前对象 self
//
//
//    // 2.如果对象初始化成功，才有必要进行接下来的初始化
//    if (self != nil)
//    { // 初始化成功
//        _age = 10;
//    }
//
//    // 3.返回一个已经初始化完毕的对象
//    return self;
//}

- (id)init
{
    if ( self = [super init] )
    { // 初始化成功
        _age = 10;
    }

    // 3.返回一个已经初始化完毕的对象
    return self;
}

@end

main.m

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

// 构造方法：用来初始化对象的方法，是个对象方法，-开头
// 重写构造方法的目的：为了让对象创建出来，成员变量就会有一些固定的值
/*
 重写构造方法的注意点
1.先调用父类的构造方法（[super init]）
2.再进行子类内部成员变量的初始化
 */
int main()
{
    // Person *p = [Person new];
    /*
     完整地创建一个可用的对象
     1.分配存储空间  +alloc
     2.初始化 -init
     */

    // 1.调用+alloc分配存储空间
    // Person *p1 = [Person alloc];
    // 2.调用-init进行初始化
    // Person *p2 = [p1 init];

//    // 调用-init进行初始化
//    Person *p3 = [Person new];
//
//
//    // 每个Person对象创建出来，他的_age都是10
//    

    Person *p4 = [[Person alloc] init];

    Student *stu = [[Student alloc] init];

    NSLog(@"------");

    return 0;
}

构造方法使用注意

（1）子类拥有的成员变量包括自己的成员变量以及从父类继承而来的成员变量，在重写构造方法的时候应该首先对从父类继承而来的成员变量先进行初始化。

（2）原则：先初始化父类的，再初始化子类的。

（3）重写构造方法的目的：为了让对象方法一创建出来，成员变量就会有一些固定的值。

（4）注意点：

1、先调用父类的构造方法[super init];

2、再进行子类内部成员变量的初始化。

自定义构造方法：

自定义构造方法的规范：

（1）一定是对象方法，以减号开头

（2）返回值一般是id类型

（3）方法名一般以initWith开头

自定义构造方法例子：

Person.h

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property NSString *name;
@property int age;

/*
 自定义构造方法的规范
 1.一定是对象方法，一定以 - 开头
 2.返回值一般是id类型
 3.方法名一般以initWith开头
*/

- (id)initWithName:(NSString *)name;

- (id)initWithAge:(int)age;

// initWithName:andAge:
- (id)initWithName:(NSString *)name andAge:(int)age;

@end

Person.m

#import "Person.h"

@implementation Person

- (id)init
{
    if ( self = [super init] )
    {
        _name = @"Jack";
    }
    return self;
}

- (id)initWithName:(NSString*)name
{

    if ( self = [super init] )
    {
        _name = name;
    }

    return self;
}

- (id)initWithAge:(int)age
{
    if ( self = [super init] )
    {
        _age = age;
    }
    return self;
}

- (id)initWithName:(NSString *)name andAge:(int)age
{
    if ( self = [super init] )
    {
        _name = name;
        _age = age;
    }
    return self;
}

@end

对应的main.m

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

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        Student *p = [[Student alloc] initWithName:@"Jim" andAge:29 andNo:10];
        NSLog(@"00000");
    }
    return 0;
}

自定义构造方法的使用注意:

（1）自己做自己的事情

（2）父类的方法交给父类的方法来处理，子类的方法处理子类自己独有的属性

成员变量的作用域:

@public

在任何地方都能直接访问对象的成员变量

@private

只能在当前类的对象方法中访问

@protected（可以不写，默认）

能在当前类和子类的对象方法中直接访问

@package

只要处在同一个框架中，就能直接访问对象的成员变量

@interface和@implementation中不能声明同名的成员变量

在@implementation中声明变量，默认是@private的

分类-Category:

分类，在不改变原来模型的情况下,可以给某个类扩充一些方法

分类只能增加方法， 不能增加成员变量

分类方法实现中可以访问原来类中声明的成员变量

分类的优先级最高，方法优先去分类中去找，再去原来类中去找，最后再去父类中找

分类可以重写原来类中的方法，但是会覆盖掉，会导致原来的方法失效，没法再使用

方法调用的优先级：分类(最后参与编译的分类优先) --> 原来类 --> 父类

分类的应用一般是扩展系统的类的方法，比如扩展NSString类的方法

格式:

	分类的声明
@interface 类名 (分类名称)
// 方法声明
@end
?	分类的实现
@implementation 类名 (分类名称)
// 方法实现
@end

好处:

一个庞大的类可以分模块开发

一个庞大的类可以由多个人来编写，更有利于团队合作

给系统自带的类添加分类:

给NSString增加一个类方法：计算某个字符串中阿拉伯数字的个数

给NSString增加一个对象方法：计算当前字符串中阿拉伯数字的个数

注意:

Category可以访问原始类的实例变量，但不能添加变量，只能添加方法。如果想添加变量，可以考虑通过继承创建子类

Category可以实现原始类的方法，但不推荐这么做，因为它是直接替换掉原来的方法，这么做的后果是再也不能访问原来的方法

多个Category中如果实现了相同的方法，只有最后一个参与编译的才会有效

分类的实例：

main.m

/*
 分类的作用：在不改变原来类内容的基础上，可以为类增加一些方法

 使用注意：
 1.分类只能增加方法，不能增加成员变量
 2.分类方法实现中可以访问原来类中声明的成员变量
 3.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法，会导致原来的方法没法再使用
 4.方法调用的优先级：分类(最后参与编译的分类优先) --> 原来类  --> 父类
 */
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Person+MJ.h"
#import "Person+JJ.h"

int main()
{
    Person *p = [[Person alloc] init];
    //p.age = 10;

    // 优先去分类中查找，然后再去原来类中找，最后再去父类中找
    [p test];
   // [p study];

    return 0;
}

Person.h

/*
 分类的作用：在不改变原来类内容的基础上，可以为类增加一些方法

 使用注意：
 1.分类只能增加方法，不能增加成员变量
 2.分类方法实现中可以访问原来类中声明的成员变量
 3.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法，会导致原来的方法没法再使用
 4.方法调用的优先级：分类(最后参与编译的分类优先) --> 原来类  --> 父类
 */
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Person+MJ.h"
#import "Person+JJ.h"

int main()
{
    Person *p = [[Person alloc] init];
    //p.age = 10;

    // 优先去分类中查找，然后再去原来类中找，最后再去父类中找
    [p test];
   // [p study];

    return 0;
}

Person.m

#import "Person.h"

@implementation Person
- (void)test
{
    NSLog(@"Person-test");
}
@end