黑马程序员——OC语言学习——关键字id、构造方法、Category-分类、类的本质、 description方法、 SEL方法

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

一、  关键字id

id :  万能指针，能指向和操作任何OC对象

id  == NSObject *

好处：

1.函数中的参数如果写成id类型，则可以同时接受父类和子类对象。

2.万能指针id不会像多态那样产生警告，比如，在父类调用子类对象特有方法时，必须父类强转为子类

而，若被赋值为id类型，则可以直接调用子类对象特有方法

#import <Foundation/Foundation.h>
@interface Person : NSObject
- (void)test;
@end

@implementation Person
- (void)test
{
    NSLog(@"调用了Person的test方法");
}
@end

@interface Student : Person
- (void)test;
- (void)test1;
@end
@implementation Student
- (void)test
{
    NSLog(@"调用了Student的test方法");
}
- (void)test1
{
    NSLog(@"调用了Student的test1方法");
}

@end

void test(id d) //可传如任意类型对象
{
    [d test];
}

int main()
{
    /*NSString *p = [Student new];不能用除了自己类型和父类类型来存储，自身对象，否则会产生错误调用不了对象方法
     */
    //Person *p = [Student new]; // 多态
    //p.test1; //父类指针调用子类特有方法，产生错误，不能调用
    
    id p = [Student new]; // 万能指针，能指向\操作任何OC对象
    
    [p test1];
    
    //[p test];
    
    test(p);
    
    return 0;
}

二、  构造方法

1.对象生成过程

当OC程序一运行的时候，系统就会把程序中的类加载到内存中

我们在生成一个对象的时候，是先调用类中的alloc方法，给对象分配一个内存空间。

这时这个对象内存中一切还没有赋值初始化，再调用这个产生的对象中的init方法初始化对象。

所以，一个对象的产生是经过两个过程，

1> 通过类中alloc方法给对象分配内存空间（这时对象就已经产生了）

2> 再经过以产生的对象中的init方法给对象初始化

    // 1.调用+alloc分配存储空间

    // Person *p1 = [Person alloc];

    // 2.调用-init进行初始化

    // Person *p2 = [p1 init];

 

2.构造方法

  构造方法：用来初始化对象的方法，是个对象方法，-开头

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

 重写构造方法的注意点

1.先调用父类的构造方法（[super init]）

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

3. 重写-init方法标准格式

//     - (id)init

//     {

//                // 1.一定要调用回super的init方法:初始化父类中声明的一些成员变量和其他属性

//               self = [super init]; // 当前对象 self

//    

//                // 2.如果对象初始化成功，才有必要进行接下来的初始化

//              if (self != nil)

//              {     // 初始化成功

//                      _age = XXX;

//              }

//    

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

//               return self;

//      }

或者简写为

//     - (id)init

//     {

//               if (self != [super init])

//               {      // 初始化成功

//                       _age = 10;

//               }

//                // 返回一个已经初始化完毕的对象

//                return self;

//      }

如：将Person对象创建出来，使他的实例变量_age初始化数值为20

- (id)init
{
    if ( self = [super init] )
    { // 初始化成功
        _age = 10;
    }
    
    // 返回一个已经初始化完毕的对象
    return self;
}

4.自定义构造方法

初始化的时候在自定义实例变量的属性值。

自定义构造方法的规范

 1.一定是对象方法，一定以 - 开头

 2.返回值一般是id类型

 3.方法名一般以initWith开头

#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
@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

子类student初始化

// 父类的属性交给父类方法去处理，子类方法处理子类自己的属性
- (id)initWithName:(NSString *)name andAge:(int)age andNo:(int)no
{
    // 将name、age传递到父类方法中进行初始化
    if ( self = [super initWithName:name andAge:age])
    {
        _no = no;
    }
    
    return self;
}

三、 Category-分类

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

 

 使用注意：

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

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

 3.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法，会导致原来的方法没法再使用

 4.分类可以创建于主类同名的方法，方法调用的优先级：分类(最后参与编译的分类优先) --> 原来类  --> 父类

 

/******************Person对象方法和实现********************/
@interface Person : NSObject
{
    int _age;
}
@property int age;
- (void)test;
@end
@implementation Person
- (void)test
{
    NSLog(@"Person-test");
}
@end

想给该Person对象再增加一个方法，就用分类方法

实际操作：

再创建一个Objective-C Category文本，类名为： Person+自定义文字，如：Person+test2

文本内容如下：

@interface Person (test2)
- (void)test2;
@end

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

// 方法调用的优先级：分类(最后参与编译的分类优先) --> 原来类  --> 父类
- (void)test // 可以定义与主类同名方法
{
    NSLog(@"Person (JJ)-test");
}
@end

1.分类的作用——给对象添加新的方法

如：

给NSString类添加计算字符中阿拉伯数字个数的方法

@interface NSString (NSString_Number)
+ (int)numberCountOfString:(NSString *)str; // 类方法
- (int)numberCount;                         // 对象方法
@end
@implementation NSString (NSString_Number)
+ (int)numberCountOfString:(NSString *)str  // 类方法实现
{
    int count = 0;
    for (int i = 0; i < [str length]; i++) { // [字符串 length]计算字符串长度
        unichar c = [str characterAtIndex:i]; // [字符串 characterAtIndex:i] 字符中i角标位的字符
        if (c >= '0' && c <= '9') {            // 筛选范围，阿拉伯数字
            count++;
        }
    }
    return count;
}

- (int)numberCount  //对象方法实现
{
    return [NSString numberCountOfString:self];
}
@end

四、 类的本质

类其实也是一种对象，在程序运行时，系统会把程序中所有的类加载到内存中，用Class来创建所有的类，称为类对象，用Class创建。

类对象:类名即代表类对象

获取类对象的两种方式

Class c = [类名 class]; 用类获取类对象

Class c2 = [对象指针 class]; 用类生成的对象来获取类对象

当类第一次被加载到内存中时会调用类方法+ (void)load 

当类第一次用来创建对象时，会调用类方法+ (void)initialize

load方法：程序以运行类，加载到内存中调用的方法

当程序启动的时，就会加载项目中所有的类和分类，而且加载后会掉用每个类和分类的+load方法。只会调用一次

先加载父类再加载子类（先调用父类的方法，再调用子类的+load方法）

initialize方法 ：监听作用 ，查看我们类什么时候第一次被调用

当第一次使用某个类的时候就会调用类的+initialize方法

      在使第一次用某个子类的时候

先初始化父类，再初始化子类（先调用父类的+initialize的方法，再调用子类的+initialize方法）

     在第一次使用父类的时候

父类分类中的+initialize方法会覆盖父类的+initialize方法

例子：

#import <Foundation/Foundation.h>

@interface Person : NSObject  // 人
@property int age;
@end
@implementation Person
// 当程序启动的时候，就会加载一次项目中所有的类。类加载完毕后就会调用+load方法
+ (void)load
{
    NSLog(@"Person---load");
}

// 当第一次使用这个类的时候，就会调用一次+initialize方法
+ (void)initialize
{
    NSLog(@"Person-initialize");
}
@end

@interface Student : Person // 学生  子类 继承父类人
@end
@implementation Student
// 在类被加载的时候调用
+ (void)load
{
    NSLog(@"Student---load");
}

+ (void)initialize
{
    NSLog(@"Student-initialize");
}
@end

@interface Person (MJ) // Person的分类
@end
@implementation Person (MJ)
+ (void)load
{
    NSLog(@"Person(MJ)---load");
}
+ (void)initialize
{
    NSLog(@"Person(MJ)-initialize");
}
@end

int main()
{
    id d = [[Person alloc]init];
    return 0;
}

结果:

查看关键字方法：

鼠标挪到，所要查的关键字，或者文字，按住option键，关键字上方会出现问问号？再单击鼠标

就会出现苹果官方文档注释

五、  description方法

用NSLog和@输出对象中讯息

-   (NSString *)description  默认输出<类名：内存地址>

+  (NSString *)description  默认输出 类名

不能在description方法中尝试打印输出类或者对象本身，否则会引发死循环]

#import<Foundation/Foundation.h>
@interface Person : NSObject
@property int age;
@property NSString *name;
@end
@implementation Person

// 决定了实例对象的输出结果
//- (NSString *)description
//{
//    // 下面代码会引发死循环
//    // NSLog(@"%@", self);
//    return [NSString stringWithFormat:@"age=%d, name=%@", _age, _name];
//    //return @"3424324";
//}

- (NSString *)description
{
    return [NSString stringWithFormat:@"age=%d, name=%@", _age, _name];
}
// 决定了类对象的输出结果
+ (NSString *)description
{
    return @"Abc";
}
@end

int main()
{
    Person *p = [[Person alloc]init];
    p.age = 21;
    p.name = @"dymost";
    
    [p description];
    
    Class c = [p class];
    
    [c description];
    
    return 0;
}

六、  SEL方法

方法是写在类中，类创建的对象调用方法是时候，调用类中的方法，类中的每个方法都会存储一个SEL类型数据，当对象调用类方法；

如：[p test]; 系统会将test方法名转换成SEL型数据，再到类中遍历所以SEL数据，找到对应的SEL数据的方法。

这次找到方法是有缓存的，当下次再调用test方法的时候，就不用遍历所以SEL数据，直接引用上次的结果。

如果一个方法调用的非常频繁，每次都将方法名包装成SEL数据，则会很耗性能，若用SEL方法访问方法，则效率会提高

SEL其实是对方法的一种包装，将方法包装成一个SEL类型的数据，去找对应的方法地址。找到方法地址就可以调用方法

  其实消息就是SEL

#import<Foundation/Foundation.h>
@interface Person : NSObject
- (void)test;
- (void)test2;
- (void)test3:(NSString *)name;
@end
@implementation Person
- (void)test
{
    NSLog(@"调用了test方法");
}

- (void)test2
{
    // 反之我们也可以将一个SEL类型数据转化成一个字符串
    // _cmd代表着当前方法
    
    NSString *str = NSStringFromSelector(_cmd);
    NSLog(@"%@", str);

    // 会引发死循环
    // [self performSelector:_cmd];
    
    NSLog(@"调用了test2方法");
}

- (void)test3:(NSString *)name
{
    NSLog(@"%@调用了test3方法", name);
}
@end
int main()
{
    Person *p = [[Person alloc]init];
    /*
     [p test];
      1.把test包装成SEL类型的数据
      2.根据SEL数据找到对应的方法地址
      3.根据方法地址调用对应的方法
     用SEL调用对象方法，也就相当于将上述方法拆分
     */
    // 1.把test2包装成SEL类型的数据
    SEL s = @selector(test2);
    // 2.根据SEL数据找到对应的方法地址
    // 3.根据方法地址调用对应的方法
    [p performSelector:s];
    
    /*
     当我们知道对象方法名（字符串）的时候同样可以利用SEL调用该方法
     且每个对象方法内都存在一个_cmd 代表当前方法的方法名
     反之我们也可以将一个SEL类型数据转化成一个字符串
     */
    NSString *name = @"test2";
    
    SEL s2 = NSSelectorFromString(name);
    
    [p performSelector:s2];
    
    /*
     当方法有参数时，SEL的调用方法
     切记方法后的：一定要带: 那也是方法名的一部分
     */
    SEL s3 = @selector(test3:);
    
    [p performSelector:s3 withObject:@"dymost"];
    
    
    return 0;
}

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