OC语言day04-06id类型

pragma mark id类型(动态数据类型)

pragma mark 概念

/**
 一个人类、一个学生类(继承人类)
 Person *obj
 Studnet *obj2
 
 
 isKindOfClass(包含子类) ---- 判断指定的对象 是否是某个类, 或者  某个类的子类
 if ([objc isKindOfClass:[Student class]]) {
 // isKindOfClass(objc 是不是 Student 这个类) ,
 [objc2 eat];
 }
 NSLog(@"----");
 
 
 isMemberOfClass(不包含子类) ---- 判断指定的对象 是否是 当前指定的类的实例 (不包含子类)
 if ([objc isMemberOfClass:[Student class]]) {
 // isKindOfClass(是不是这个类) ,
 [objc2 eat];
 }
 NSLog(@"----");
 
 
 isSubclassOfClass --- 这个类 是不是 xxx 这个类型的子类
 // Student 这个类型 是不是 Person 这个类型的子类
 if ([Student isSubclassOfClass:[Person class]]) {
 [objc2 eat];
 }
 else
 {
 NSLog(@"不是");
 }
 */

pragma mark 代码

#import 
#pragma mark 类
#import "Person.h"
#import "Student.h"

#pragma mark main函数
int main(int argc, const char * argv[])
{
    /*
     id 是一个数据类型, 并且是一个动态数据类型
     既然是 数据类型, 所以就可以用来
     1. 定义变量
     2. 作为函数的参数
     3. 作为函数的返回值
     
     默认情况下 所有的数据类型 都是静态数据类型
     
     
     静态数据类型的特点 : 
     在编译时就知道变量的类型.
     知道变量中有哪些属性和方法.
     在编译的时候 就 可以访问这些属性和方法, 并且如果是通过静态数据类型的属性和方法, 那么编译器就会报错
     
     动态数据类型的特点 :
     在编译的时候 编译器并不知道 变量的真实类型 , 只有在运行的时候 才知道它的真实类型
     并且 如果通过动态数据类型 定义变量, 如果访问了 不属于动态数据类型的属性 和 方法 , 编译不会报错
     */
#warning 静态类型 : 将一个指针 变量定义为特定类的对象时,使用的是静态类型, 在编译的时候就知道这个指针变量所属的类, 这个这个变量总是存储特定类的对象
//    Person *p  =[Person new];
//    p.age = 22;
//    [p sleep];
//    [p eat];

    /*
#warning 多态
    Person *p = [Student new];
    p.age = 22;
    [p sleep];
//    [p eat];
#warning 多态的时候 使用强制类型转换
    Student *stu = (Student *)p;
    [stu eat];
     */
    
#warning 动态类型
    // id == NSObject * 万能指针
    /*
     id 和 NSObject * 的区别:
     NSObject * 是一个静态数据类型
     id 是一个动态数据类型
     */
    
#warning NSOject 静态的数据类型
    /*
    NSObject *obj = [Person new];
//    [obj sleep]; // 会把 obj 当作成 NSObject的对象来看待 obj 没有sleep方法
//     [obj test];
    NSObject *obj2 = [Student new];
     */
    
#warning 动态数据类型 id (应用场景: 多态)
    /*
    // 通过静态数据类型 定义变量, 不能调用子类 特有的方法
    
    // 通过动态数据类型 定义变量, 可以调用子类 特有的方法
    // 通过动态数据类型 定义变量, 可以调用私有方法
    
    // 弊端: 由于动态数据类型 可以调用任意方法, 所以有可能 调用到不属于自己的方法, 而且编译时又不会报错, 所以可能导致运行的错误
    // 应用场景 : 多态, 可以减少代码量, 避免调用 子类特有的方法 需要强制类型转换
    id obj = [Person new];
    [obj sleep];
//    [obj test];
    [obj eat];
    id obj2 = [Student new];
    [obj2 eat];
//    [obj2 test];
     */
    
#warning 为了 避免动态数据类型 引发的运行时的错误, 一般情况下 如果使用动态数据类型 定义一个变量, 在调用这个变量的方法之前会进行一次判断,判断当前变量是否能够调用这个方法
    id objc = [Person new]; // 不会执行 isKindOfClass里面的方法 因为里面判断的是一个Student类型
//    id objc2 = [Student new];
;
    // 判断 objc 是不是 属于 这个类型的
    // 判断 objc 是不是 属于 student这个类型
#warning isKindOfClass ---- 判断指定的对象 是否是某个类, 或者某个类的子类
    // 判断 objc 这个对象 是不是 student这个类 或者子类
    /*
    if ([objc isKindOfClass:[Student class]]) {
        // isKindOfClass(是不是这个类) ,
        [objc2 eat];
    }
    NSLog(@"----");
     */
#warning isMemberOfClass ---- 判断指定的对象 是否是 当前指定的类的实例 (不包含子类)
    /*
    if ([objc isMemberOfClass:[Student class]]) {
        // isMemberOfClass
        [objc2 eat];
    }
    NSLog(@"----");
     */
    
#warning isSubclassOfClass --- 这个类 是不是 Person 这个类型的子类
    /*
    // Student 这个类型 是不是 Person 这个类型的子类
    if ([Student isSubclassOfClass:[Person class]]) {
        [objc2 eat];
    }
    else
    {
        NSLog(@"不是");
    }
     */
    return 0;
}

---

Person.h // (人类)

#import 

@interface Person : NSObject

- (void)sleep;
@property int age;
@end

Person.m

#import "Person.h"

@implementation Person

- (void)sleep
{
    NSLog(@"人在睡觉");
}

- (void)test
{
    NSLog(@"私有方法");
}
@end

---

Student.h // 学生类(人类的子类)

#import "Person.h"

@interface Student : Person

- (void)eat;
@end

Student.m

#import "Student.h"

@implementation Student
- (void)eat
{
    NSLog(@"吃饭");
}
@end