黑马程序员——OC基础语法—类的本质和SEL类型

OC基础语法—类的本质和SEL类型

一、类的本质：

 1.概念：其实类也是一个对象，是Class类型的对象，简称“类对象”

 

 2.原理：类在内存中只创建一次，相对于内存来说，类是内存里的一个对象，由Class创建

 代码示例：

  Person *p = [Person class]

 3.在创建对象时执行的两个步骤：

   1).利用Class创建Person类对象

   2).利用Person类对象创建Person类型的对象

  4. +load方法和+initialize方法：

         1). +load方法的使用：

            (1).在程序启动的时候会加载所有的类和分类，并调用所有类和分类的+load方法

            (2).先加载父类，再加载子类；也就是先调用父类的+load，再调用子类的+load

            (3).先加载元原始类，再加载分类

            (4).不管程序运行过程有没有用到这个类，都会调用+load加载

         2). +initialize方法的使用：

            (1).当第一次使用某个类时，就会调用类方法 +initialize方法

            (2).调用+initialize方法时，分优先级。先调用分类，没有分类再调用父类，最后才是子类。

      代码示例：

   GoodStudent 类：

#import "Student.h"

@interface GoodStudent : Student


@end

#import "GoodStudent.h"


@implementation GoodStudent
+ (void)load
{
    NSLog(@"GoodStudent---load");
}

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


@end

Person 类：

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property int age;

+ (void)test;

@end

#import "Person.h"


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

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

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

@end

Person+MJ 分类：

#import "Person.h"

@interface Person (MJ)

@end

#import "Person+MJ.h"

@implementation Person (MJ)
+ (void)load
{
    NSLog(@"Person(MJ)---load");
}
+ (void)initialize
{
    NSLog(@"Person(MJ)-initialize");
}
@end

Student 类：

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

@interface Student : Person

@end

#import "Student.h"

@implementation Student

// 在类被加载的时候调用
+ (void)load
{
    NSLog(@"Student---load");
}

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

@end

main 函数：

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

int main()
{
    // [[GoodStudent alloc] init];
    
    return 0;
}


void test1()
{
    Person *p = [[Person alloc] init];
    
    //[Person test];
    
    // 内存中的类对象
    // 类对象 == 类
    Class c = [p class];
    [c test];
    
    Person *p2 = [[c new] init];
    
    
    NSLog(@"00000");
}


void test()
{
    // 利用Person这个类创建了2个Person类型的对象
    Person *p = [[Person alloc] init];
    
    Person *p2 = [[Person alloc] init];
    
    Person *p3 = [[Person alloc] init];
    
    // 获取内存中的类对象
    Class c = [p class];
    
    Class c2 = [p2 class];
    
    // 获取内存中的类对象
    Class c3 = [Person class];
    
    
    NSLog(@"c=%p, c2=%p, c3=%p", c, c2, c3);
    
}

    5. +load方法和+initialize方法的注意点：

      1). +load是加载，只要程序运行就加载被调用。

      2). +initialize是初始化，只有在使用到时，才被调用。 

      3). +load最后加载分类。 

      4). +initialize优先加载分类。

    6. +initiasize使用的好处：可以在类第一次使用时做一些判断之类的事情。

二、description方法：

  

    1. 本质：分为 +description方法和 -description方法

    2. 作用：使用NSLog和%@输出某个对象时，会调用对象的description方法或类的description方法，并拿到返回值进行输出。

  代码示例：

  

 Person 类：

#import <Foundation/Foundation.h>

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

#import "Person.h"

@implementation Person

// 决定了实例对象的输出结果
- (NSString *)description
{

    return [NSString stringWithFormat:@"age=%d, name=%@", _age, _name];

    //return @"3424324";
}

// 决定了类对象的输出结果
+ (NSString *)description
{
    return @"Abc";
}

@end

main 函数：

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


int main()
{

    Person *p = [[Person alloc] init];
    
    // 指针变量的地址
    NSLog(@"%p", &p);
    // 对象的地址
    NSLog(@"%p", p);
    // <类名：对象地址>
    NSLog(@"%@", p);
   
    return 0;
}


void test2()
{
    Class c = [Person class];
    
    // 1.会调用类的+description方法
    // 2.拿到+description方法的返回值（NSString *）显示到屏幕上
    NSLog(@"%@", c);
}


void test1()
{
    Person *p = [[Person alloc] init];
    p.age = 20;
    p.name = @"Jack";
    // 默认情况下，利用NSLog和%@输出对象时，结果是：<类名：内存地址>
    
    // 1.会调用对象p的-description方法
    // 2.拿到-description方法的返回值（NSString *）显示到屏幕上
    // 3.-description方法默认返回的是“类名+内存地址”
    NSLog(@"%@", p);
    
    //Person *p2 = [[Person alloc] init];
    //NSLog(@"%@", p2);
    
    //NSString *name = @"Rose";
    
    //NSLog(@"我的名字是%@", name);
    
    Person *p2 = [[Person alloc] init];
    p2.age = 25;
    p2.name = @"Jake";
    
    NSLog(@"%@", p2);
}

 3. 注意死循环：

    如果在description方法中加入：NSLog(@"%@", self);会引发死循环

三、NSLog输出：

    1. __FILE__ ：输出源代码文件名

    2.__LINE__ ：输出NSLog代码在第几行

    3.__func__：输出当前函数名

四、SEL类型：

     1. SEL的本质：

       1).每个类的方法列表都存储在类对象中

       2).每个方法都有一个与之对应的SEL类型的对象

       3).根据一个SEL对象就可以找到方法的地址，进而调用方法

    2 示例：

   [p test];等价于: [p performSelector:@selector(test)];

   [p test:@"wiwiwi"]; 等价于: [p performSelector:@selector(test:)withObject:@"wiwiwi"];

   3.SEL原理：

     1).把test包装成SEL类型的数据

     2).根据SEL数据找到对象的地址

     3).根据方法地址调用对应的方法

   4. 将SEL对象和NSString对象互转

        将SEL对象转为NSString对象

        NSStringFromSelector(@selector(test));

        将NSString对象转为SEL对象

        NSSelectorFromString(@"skjak");

代码示例：

Person 类：

#import <Foundation/Foundation.h>

@interface Person : NSObject

+ (void)test;

- (void)test2;

- (void)test3:(NSString *)abc;

@end

#import "Person.h"

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

- (void)test2
{
    // _cmd代表着当前方法
    
    NSString *str = NSStringFromSelector(_cmd);
    
    
    NSLog(@"调用了test2方法-----%@", str);
}

- (void)test3:(NSString *)abc
{
    NSLog(@"test3-----%@", abc);
}
@end

main 函数：

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

int main()
{
    Person *p = [[Person alloc] init];
    
    [p test2];
    
//    NSString *name = @"test2";
//    
//    SEL s = NSSelectorFromString(name);
//    
//    [p performSelector:s];
    
    
    // 间接调用test2方法
    //[p performSelector:@selector(test2)];
    
    //[p test3:@"123"];
    
    
//    SEL s = @selector(test3:);
//    
//    [p performSelector:s withObject:@"456"];
    
    //[p test2];

    return 0;
}

  5. 死循环注意： [self performSelector:_cmd];

  6  SEL小结：

      1).其中每一个方法中都有一个 _cmd，它里面存储的是已经封装好的当前方法的SEL数据，也就是说：_cmd == @selector(方法名)

      2).消息日志其实也是SEL类型，通过SEL找到方法地址就可以调用方法。