- 不要等到明天，明天太遥远，今天就行动。
须读:看完该文章你能做什么？
1.静态数据类型 和 动态数据类型的一个认识。
2.如何创建动态数据类型id类型
3.判断 指定对象 是不是某一个类,或者是子类isKindOfClass
判断指定的对象 是不是当前指定的类的实例isMemberOfClass
判断指定的类,是不是另外一个类的子类isSubclassOfClass
学习前:你必须会什么?
什么继承、什么多态。
1.继承是 B类 继承 A类 ,那么 B类拥有A类的所有属性和方法，并且B类拥有自己的私有属性和方法。
2.多态是 某一类事物的多种形态。比如 猫->猫->动物
父类指针 指向 子类对象
动物的指针 指向了 猫 (这就是多态) 猫是动物
动物 *a = [猫 new];
一、本章笔记
一、静态数据类型和动态数据类型的特点
id是一个数据类型, 并且是一个动态数据类型
既然是数据类型,所以就可以用来
1.定义变量
2.作为函数的参数
3.作为函数的返回值
默认情况下 所有的数据类型 都是静态数据类型
静态数据类型的特点:
在编译时 就知道变量的类型,
知道变量中哪些属性 和 方法
在编译的时候 就可以访问这些属性 和 方法,
并且 如果是通过静态数据类型定义变量,
如果访问了不属于静态数据类型的属性和方法,那么编译器会报错 (如:p 访问 eat方法)
动态数据类型的特点:
在编译的时候 编译器并不知道 变量的真是类型, 只有在运行的时候 才知道它的真实类型
并且 如果通过动态数据类型定义变量, 如果访问了不属于动态类型数据的属性和方法,编译器不会报错
id == NSObject * 万能指针
id 和 NSObject *的区别:
NSObject * 是一个静态数据类型
id 是一个动态数据类型
二、静态数据类型
例子
NSObject *obj = [Person new];
// [obj sleep];
// [obj test];
NSObject *obj2 = [Student new];
三、动态数据类型
>>动态数据类型 (id) 编译器在编译的时候不知道动态数据的真正类型,所以在编译的时候放你一马,然后到运行的时候才会监测你的类型
通过静态数据类型 定义变量, 不能调用子类特有的方法
通过动态数据类型 定义变量, 可以调用子类特有的方法
弊端: 由于动态数据类型可以调用任何方法,所以有可能调用到不属于自己的方法,所以会导致运行时的错误
应用场景 : 多态, 可以减少代码量, 避免调用子类特有的方法 需要强制类型转换
四、为了避免动态数据类型 引发的运行时的错误,一般情况下 如果使用动态数据类型定义一个变量,在调用这个变量的方法之前会进行一次判断,判断当前变量是否能够调用这个方法
1.isKindOfClass , 判断指定的对象 是不是某一个类, 或者是某一个类的子类
2.isMemberOfClass , 判断指定的对象 是不是当前指定的类的实例
3.isSubclassOfClass -- A isSubclassOfClass [B class] 判断 A 是不是 B 的子类
注意、尽量让错误发生在编译时,如果在编译时,能够及时检查错误.
二、code
main.m
#pragma mark 06-动态数据类型
#pragma mark 概念
/*
一、静态数据类型和动态数据类型的特点
id是一个数据类型, 并且是一个动态数据类型
既然是数据类型,所以就可以用来
1.定义变量
2.作为函数的参数
3.作为函数的返回值
默认情况下 所有的数据类型 都是静态数据类型
静态数据类型的特点:
在编译时 就知道变量的类型,
知道变量中哪些属性 和 方法
在编译的时候 就可以访问这些属性 和 方法,
并且 如果是通过静态数据类型定义变量,
如果访问了不属于静态数据类型的属性和方法,那么编译器会报错 (如:p 访问 eat方法)
动态数据类型的特点:
在编译的时候 编译器并不知道 变量的真是类型, 只有在运行的时候 才知道它的真实类型
并且 如果通过动态数据类型定义变量, 如果访问了不属于动态类型数据的属性和方法,编译器不会报错
id == NSObject * 万能指针
id 和 NSObject *的区别:
NSObject * 是一个静态数据类型
id 是一个动态数据类型
二、静态数据类型
例子
NSObject *obj = [Person new];
// [obj sleep];
// [obj test];
NSObject *obj2 = [Student new];
三、动态数据类型
>>动态数据类型 (id) 编译器在编译的时候不知道动态数据的真正类型,所以在编译的时候放你一马,然后到运行的时候才会监测你的类型
通过静态数据类型 定义变量, 不能调用子类特有的方法
通过动态数据类型 定义变量, 可以调用子类特有的方法
弊端: 由于动态数据类型可以调用任何方法,所以有可能调用到不属于自己的方法,所以会导致运行时的错误
应用场景 : 多态, 可以减少代码量, 避免调用子类特有的方法 需要强制类型转换
四、为了避免动态数据类型 引发的运行时的错误,一般情况下 如果使用动态数据类型定义一个变量,在调用这个变量的方法之前会进行一次判断,判断当前变量是否能够调用这个方法
1.isKindOfClass , 判断指定的对象 是不是某一个类, 或者是某一个类的子类
2.isMemberOfClass , 判断指定的对象 是不是当前指定的类的实例
3.isSubclassOfClass -- A isSubclassOfClass [B class] 判断 A 是不是 B 的子类
注意、尽量让错误发生在编译时,如果在编译时,能够及时检查错误.
*/
#pragma mark - 代码
#import <Foundation/Foundation.h>
#pragma mark 类
#import "Person.h"
#import "Student.h"
#pragma mark - main函数
int main(int argc, const char * argv[])
{
/*
id是一个数据类型, 并且是一个动态数据类型
既然是数据类型,所以就可以用来
1.定义变量
2.作为函数的参数
3.作为函数的返回值
默认情况下 所有的数据类型 都是静态数据类型
静态数据类型的特点:
在编译时 就知道变量的类型,
知道变量中哪些属性 和 方法
在编译的时候 就可以访问这些属性 和 方法,
并且 如果是通过静态数据类型定义变量,
如果访问了不属于静态数据类型的属性和方法,那么编译器会报错 (如:p 访问 eat方法)
动态数据类型的特点:
在编译的时候 编译器并不知道 变量的真是类型, 只有在运行的时候 才知道它的真实类型
并且 如果通过动态数据类型定义变量, 如果访问了不属于动态类型数据的属性和方法,编译器不会报错
id == NSObject * 万能指针
id 和 NSObject *的区别:
NSObject * 是一个静态数据类型
id 是一个动态数据类型
*/
#pragma 测试
/*
Person *p = [Person new];
p.age = 25;
[p sleep];
// [p eat];
*/
/*
Person *p = [Student new];
p.age = 25;
[p sleep];
[(Student *)p eat];
// Student *s = (Student *)p;
// [s eat];
*/
#pragma 静态数据类型
/*
NSObject *obj = [Person new];
// [obj sleep];
// [obj test];
NSObject *obj2 = [Student new];
*/
#pragma 动态数据类型 (id) 编译器在编译的时候不知道动态数据的真正类型,所以在编译的时候放你一马,然后到运行的时候才会监测你的类型
#warning 尽量让错误发生在编译时,如果在编译时,能够及时检查错误.
// 通过静态数据类型 定义变量, 不能调用子类特有的方法
// 通过动态数据类型 定义变量, 可以调用子类特有的方法
// 弊端: 由于动态数据类型可以调用任何方法,所以有可能调用到不属于自己的方法,所以会导致运行时的错误
// 应用场景 : 多态, 可以减少代码量, 避免调用子类特有的方法 需要强制类型转换
/*
typedef struct objc_object {
Class isa;
} id;
Description
A pointer to an instance of a class.
Availability iOS (4.0 and later), macOS (10.6 and later), tvOS (9.0 and later), watchOS (2.0 and later)
Declared In Objective-C
More Structure Reference
*/
/*
id obj = [Person new];
[obj sleep];
[obj test];
// Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[Person eat]: unrecognized selector sent to instance 0x1002014b0'
[obj eat]; // 父类 调用 子类方法
id obj2 = [Student new];
[obj2 eat];
*/
#pragma 为了避免动态数据类型 引发的运行时的错误,一般情况下 如果使用动态数据类型定义一个变量,在调用这个变量的方法之前会进行一次判断,判断当前变量是否能够调用这个方法
// id obj = [Person new];
id obj = [Student new];
if ([obj isKindOfClass:[Student class]]) {
// // isKindOfClass , 判断指定的对象 是不是某一个类, 或者是某一个类的子类
// if ([obj isMemberOfClass:[Student class]]) {
// isMemberOfClass , 判断指定的对象 是不是当前指定的类的实例
// if([Student isSubclassOfClass:[Person class]]){
// isSubclassOfClass -- A isSubclassOfClass [B class] 判断 A 是不是 B 的子类
[obj eat];
}
NSLog(@"----");
return 0;
}
Person
>>>.h
#import <Foundation/Foundation.h>
@interface Person : NSObject
@property int age;
- (void)sleep;
@end
>>>.m
#import "Person.h"
@implementation Person
- (void)sleep
{
NSLog(@"睡觉");
}
- (void)test
{
NSLog(@"私有方法 test");
}
@end
Student
>>>.h
#import <Foundation/Foundation.h>
@interface Student : NSObject
- (void)eat;
@end
>>>.m
#import "Student.h"
@implementation Student
- (void)eat
{
NSLog(@"吃饭");
}
@end
