一、点语法介绍
/* 以前封装后,要给属性赋值,必须调用方法 这样做,有两个缺点: 1.代码量多,调用方法要写的东西多。 2.看起来并不像是给属性赋值,也不像取值。 我们用点语法就可以更好的解决! 点语法的语法: 对象.属性; 注意:这里的属性不需要加_ 对象.属性 = 值; 点语法的本质: 其实就是调用getter或者setter方法。 点语法注意事项: 1.在类的方法里面如果用self.age 这个是调用方法,self->_age 是直接调用成员变量。 2.千万记得不要在setter或者getter方法里面用点语法,否则,死循环。 3.用点语法之前必须保证你的setter和getter方法的方法名符合命名的规范。 提示:点语法,也可以称之为 语法糖。 本质可以理解为是编译器的特性。 因为其他面向对象的语言都是用.来访问属性。 */ #import <Foundation/Foundation.h> #import "Person.h" int main(int argc, const char * argv[]) { @autoreleasepool { Person *p = [Person new]; // [p setName:@"刘德华"]; p.name = @"张学友"; //这一句就相当于上一句,编译后也是编译成 [p setName:@"张学友"]; // [p setAge:16]; p.age = 16; //这一句就相当于上一句 // [p setWeight:100]; p.weight = 100; //这一句就相当于上一句 // NSLog(@"名字=%@ 年龄:%d",[p name],[p age]); NSLog(@"名字=%@ 年龄:%d",p.name,p.age); } return 0; }
二、@property和synthesize关键字
/* @property 作用:帮我们生成setter和getter方法的声明。 语法: @property 类型 属性名; 注意:属性名不加_ 如果只用@property关键字的话,在实现类中,setter和getter方法需要自己实现。 既然有关键字可以生成setter和getter方法的声明,肯定就有关键字可以生成setter和getter方法的实现。 @synthesize: 作用:自动生成getter和setter方法的实现 语法: @synthesize 特性名(属性名) @synthesize做了多少事: 1.生成getter和setter方法的实现 2.还会生成一个私有的成员变量,成员变量名字就是特性名 3.实现的方法里是给自己生成的那个私有成员变量赋值 4.如果想指定给某个成员变量赋值,就在特性名后面加一个 = 成员变量名; 例:@synthesize name = _name; 5.如果你想过滤,就自己重写 批量生成方法的实现: 语法: @synthesize 特性名1,特性名2………………特性名n 批量生成方法的声明: 语法:@property 类型 特性名1,特性名2………………特性名n 例:@property NSString *name,*nickName; 注意:批量生成时,类型必须一致 */ #import <Foundation/Foundation.h> @interface Person : NSObject{ NSString *_name; int _age; } //这样就会给_name封装getter和setter的声明 @property NSString *name; /* -(void)setName:(NSString *)name; -(NSString *)name; */ //这样就会给_age封装getter和setter的声明 @property int age; /* -(void)setAge:(int)age; -(int)age; */ -(void)sayHi; @end // // Person.m // OC第五天 // // Created by iOS001 on 15/11/5. // // #import "Person.h" @implementation Person //@synthesize name;//自动生成了_name的getter和setter的实现 // //@synthesize age;//自动了_age的getter和setter的实现 //@synthesize name = _name;//自动生成了_name的getter和setter的实现 // //@synthesize age = _age;//自动了_age的getter和setter的实现 @synthesize name = _name,age=_age; //批量操作。 -(void)setAge:(int)age{ if (age < 0 || age > 120) { _age = 18; }else{ _age = age; } } /* -(void)setName:(NSString *)name{ _name = name; } -(NSString *)name{ return _name; } -(void)setAge:(int)age{ _age = age; } -(int)age{ return _age; } */ @end
上面的语法是在Xcode 4.4以前的用法,在现在的新版XCode中,可以不这么复杂。
/* @property增强使用: 用法跟之前的@property用法,完全一样 但是,它除了能生成声明以外,还能声明实现 而且,它还能帮我们生成私有的成员变量! 做的事:1.声明属性的setter和getter方法的声明 2.实现属性的setter和getter方法 3.生成一个以特性名加下划线的私有成员变量 注意:如果类的属性中已经存在同名的带下划线的成员变量,那么不会帮我们在生成了,操作的就是这个带下划线的成员变量。 @property封装对象类型 @property不能封装C语言数组 */ #import <Foundation/Foundation.h> @interface Person : NSObject{ NSString *_name; } @property NSString *name; @end #import "Person.h" @implementation Person @end /* 1.@property帮我们生成的实现,是没有任何逻辑过滤,如果我们要过滤,就重写。 2.如果getter方法和setter方法都有重写的话,那么@property不会帮我们生成私有成员变量了。 如果非要两个都重写的话,就自己定义一个成员变量。 */ #import <Foundation/Foundation.h> @interface Person : NSObject{ int _age; } @property NSString *name; @property int age; @end #import "Person.h" @implementation Person -(void)setAge:(int)age{ if(age<0 ||age>150){ _age = 16; }else{ _age = age; } } -(int)age{ return _age; } @end #import <Foundation/Foundation.h> #import "Person.h" int main(int argc, const char * argv[]) { @autoreleasepool { Person *p = [Person new]; p.name = @"草稚京"; p.age = -30; NSLog(@"p.name=%@ p.age=%d",p.name,p.age); } return 0; }
三、动态类型和静态类型的概念
/* 动态类型: 简单来说就是编译的时候,并不知道具体是什么类型的对象,直到运行的时候才知道是什么类型的对象 所以,运行的时候确定了对象的类型,然后才会去找到对应的类型里看有没有这个方法,如果有这个方法就执行,没有这个方法就报错 静态类型: 就是编译的时候就知道是什么类型了 比如说 int char float double int nums[10]; 一旦定义就不可能再调用char *数组,或者改成char *数组 动态类型的好处: 1.灵活 2.为了实现多态 */ //比如说我现在有3个类,Person、Student、Teacher,三个类中都有SayHi方法。Student和Teacher是继承并重写了Person类中的SayHi方法。 #import <Foundation/Foundation.h> #import "Person.h" #import "Student.h" #import "Teacher.h" int main(int argc, const char * argv[]) { @autoreleasepool { /* Person *p = [Person new]; //动态类型 // [p study];//因为编译阶段,它并不知道你是什么对象,所以不可能让你调用这个方法 [p performSelector:@selector(study)];//因为这是一个运行时才绑定的方法 */ /* printf("请输入序号--0--Person 1--Student 2--Teacher\n"); int num; scanf("%d",&num); Person *p; switch (num) { case 0: p = [Person new]; break; case 1: p = [Student new]; break; case 2: p = [Teacher new]; break; default: p = [Person new]; break; } [p sayHi];//现在编译器知道是哪个对象的sayHi吗???只能运行时才知道?? */ } return 0; }
四、id类型的使用
/* 动态类型: 在编译的时候并不知道具体是什么类型的对象,在运行的时候知道是什么类型的对象。 NSObject:根类。所有的人直接或者间接的继承自NSObject。 两个检查: 编译期检查: 因为OC是动态类型语言,那么也就是说类型只有在运行的时候才会被确定,所以在编译的时候没法检查真正指向的对象是类型,所以更加没法知道你指向的对象类型是否包含某个方法 检查范围:1.去检查它的指针类型里面是否有这个成员(属性、方法),如果有就让你编译通过,如果没有 2.就去父类的父类找,如果有,就编译通过,如果没有,再继续找 3.直到找到NSObject都还没有的话,就报错。 一句话概括:就是只会去赋值号左边的类型里找。 运行期检查: 就是运行的时候类型就确定了,所以就可以检查真正的那个对象里面包不包含这个成员了。 1.先去真正的对象类型里面找,如果找到就执行,如果没找到就继续往父类找。 2.去父类找,找到就执行,没找到就继续往父类的父类找,找到就执行,没找到继续往上找。 3.直到找到NSObject还没有,那么就程序运行的时候崩掉(闪退)。 我希望有一种类型的指针可以指向我任意的对象,并且,我用中括号的方式来调用方法,又不会经过编译期检查(编译时不会报错),有没有呢? id类型: 其实就是一个万能指针,所以任何对象都可以指向。 非常方便的体现什么叫动态类型。 任意对象都可以指向! 好处:灵活,任意类型都可以指向,哪怕上一步指向Student对象,下一步可以立即再指向NSString 缺点:因为编译器没有检查类型有没有方法,所以如果直接调用可能会报错 id是万能指针,任意类型的对象都能指向. 然后用id类型的变量可以调用方法,但是编译器不一定会报错,只能在运行时如果没有才报错。 id需要注意的地方: 1.用id类型指向的对象,不能用点语法 2.那能不能直接调用方法来赋值呢?可以!能不能用方法取值?也可以! id的作用: 1.指向任意类型 2.当做参数传递 注意:虽然任意类型的对象都可以传,但是运行时可能会报错 3.当做返回值返回 注意:任意类型都可以接收,那么很可能运行时会出问题 */ #import <Foundation/Foundation.h> #import "Person.h" #import "Student.h" int main(int argc, const char * argv[]) { @autoreleasepool { /* Person *p = [Student new]; //动态类型,只有运行的时候才直到指向的是Student对象 //[p sayHi];//编译器的时候也是去Person找,只不过正好这时候Person有 [p study]; //此时会报错,因为这时候是编译期检查,像这种中括号调用方法,都是编译期检查 */ /* id p = [Student new]; [p study]; //有没有经历运行期检查??肯定有! [p sayHi]; NSLog(@"%@",p); p = @"哈哈哈哈哈哈"; NSLog(@"%@",p); p = [Person new]; */ id p = [Person new]; [p study];//运行的时候才知道是Person类型,但是Person及其父类都没有study方法,所以运行报错 /* [p performSelector:@selector(test)]; //编译的时候没法检查 //[p sayHi];//而是先在真正指向的对象——student里面先找,找到了就执行 // NSLog(@"%@",p); // // [p study]; //Xcode编译的时候只会根据你的指针类型来检查,而并不会根据你具体指向的对象类型来检查 // // NSObject *obj = [Student new]; // // NSLog(@"%@",obj); // */ } return 0; }
五、动态类型和动态方法的检测以及响应方法的方法
1、态类型的检测
/* 动态类型检测:我们自己写代码来检测对象是否属于一个类。 因为我们之前用id类型是可以调用任意方法的,编译器不会报错,但是运行时报错。 所以我们就在想,能不能在调用方法之前,我们自己写代码判断一下id类型指向的对象是不是某一个类,如果是我才让你调用。 动态类型检测的方法: 1) 语法:[对象 isKindOfClass:Class]; 注意:这个方法是用来检测一个对象是不是右边这个类的对象,或者是这个类子类的对象,如果是则返回YES,如果不是返回NO 例: [p isKindOfClass:[Person class] ]; 解释:判断p这个对象是不是Person类的对象,或者是Person子类的对象,如果是返回YES,如果不是返回NO。 注意:包括子类的子类,子类的子类的子类………………………… 2) [对象 isMemberOfClass:Class]; 判断 对象 是不是某个类的对象,不包括子类。 跟上面的区别只在于,判断的时候不包括子类。 总结:isKindOfClass不能确切的确定是哪一个具体的类的对象(因为还能包括子类)。 isMemberOfClass 可以确切的知道是不是某一个类(因为不包括子类)。 3) 注意,接下来是类方法 [类名 isSubOfClass:Class]; 判断某一个类,是否是另外一个类的子类,包括子类的子类,以及自己类。 也就是说一个类如果是右边这个的类的本类,或者子类或者子类的子类都会返回YES,否则返回NO。 */ #import <Foundation/Foundation.h> #import "Person.h" #import "Student.h" #import "GoodStudent.h" int main(int argc, const char * argv[]) { @autoreleasepool { /* id obj = [Person new]; //我们能不能在调用这个方法之前,自己写代码判断一下,obj是不是Student类型,如果是,我就让你调用,不是,就 //[obj study];//编译不报错,运行报错 if([obj isKindOfClass:[Student class]]){//判断obj是不是student类型 //如果是就执行 [obj study]; }else{ NSLog(@"obj不是Student类型"); } */ //isKindOfClass的用法 /* // id obj = [Person new]; // BOOL res = [obj isKindOfClass:[Student class] ]; // // NSLog(@"%d",res); //0 // BOOL res = [obj isKindOfClass:[Person class] ]; // // NSLog(@"%d",res); //1 // BOOL res = [obj isKindOfClass:[NSObject class] ]; // // NSLog(@"%d",res);//1 id obj = [GoodStudent new]; BOOL res = [obj isKindOfClass:[Person class]]; NSLog(@"%d",res);//也是1 */ //isMemberOfClass的用法 /* id obj = [GoodStudent new]; BOOL res1 = [obj isKindOfClass:[Person class] ];//这种方法包括子类 BOOL res2 = [obj isMemberOfClass:[Person class] ];//这种方法不包括子类 NSLog(@"res1=%d res2=%d",res1,res2);//1 0 */ //isSubOfClass的用法(类方法) /* // BOOL res = [Student isSubclassOfClass:[Person class]]; // // NSLog(@"%d",res);//1 // BOOL res = [GoodStudent isSubclassOfClass:[Person class]]; // // NSLog(@"%d",res);//1 // BOOL res = [Person isSubclassOfClass:[Person class]]; // // NSLog(@"%d",res);//1 //这一句是问Person是Student子类吗? BOOL res = [Person isSubclassOfClass:[Student class]]; NSLog(@"%d",res);//0 */ } return 0; }
2、动态方法的检测
/* 因为之前用id类型调用方法,可能会出错,所以我们想先判断一下这个类型是不是拥有某个方法。 之前的做法是,判断一下某个对象是不是某个类的。那能不能具体一点,直接判断一下某个对象有没有某个方法呢? 动态方法检测! 1.(重点) [对象 respondsToSelector:SEL]; 例:[obj respondsToSelector:@selector(study)] 这是在判断obj有没有study这个方法,如果有返回YES,如果没有返回NO 注意:如果传入的是类方法,那么会返回0,因为类方法不属于对象 2.类方法(用的少) [类名 instancesRespondToSelector:SEL];//判断类方法的 判断某个类是否有某个对象方法,如果有则返回YES,否则返回NO 跟上面效果一样,只不过这是一个类方法用类名判断 */ #import <Foundation/Foundation.h> #import "Person.h" #import "Student.h" #import "GoodStudent.h" int main(int argc, const char * argv[]) { @autoreleasepool { /* id obj = [Student new]; //[obj study];//是不是要在这之前判断一下obj指向的对象有没有study这个方法,如果有才调用 if( [obj respondsToSelector:@selector(study)] ){ [obj study]; }else{ NSLog(@"没有study方法"); } */
//respondsToSelcetor的用法 /* id p = [Person new]; BOOL res = [p respondsToSelector:@selector(clsPerson)]; NSLog(@"%d",res);//0 */ // id obj = [Person new]; // BOOL res = [Person instancesRespondToSelector:@selector(sayHi)];//只能判断对象方法 // NSLog(@"%d",res); } return 0; }
3、响应方法的方法
/* 响应方法就叫调用方法。 以前我们用[] 现在我们用响应方法的方法: [对象 performSelector:SEL]; 调用某个方法,是没有参数的时候 例: [obj performSelector:@selector(sayHi)]; [对象 performSelector:SEL withObject:id]; 调用某个方法,是有1个参数的情况 例:[obj performSelector:@selector(sayName:) withObject:@"刘德华"]; //最多只有2个参数 [obj performSelector:(SEL) withObject:(id) withObject:(id) 这是有两个参数的情况 例:[obj performSelector:@selector(sayName:andNickName:) withObject:@"发哥" withObject:@"花卷"]; */ #import <Foundation/Foundation.h> #import "Person.h" int main(int argc, const char * argv[]) { @autoreleasepool { id obj = [Person new]; //这个是没参数的时候 // [obj performSelector:@selector(sayHi)]; // if([obj respondsToSelector:@selector(sayName:)]){ // //这个是有1个参数的时候 // [obj performSelector:@selector(sayName:) withObject:@"刘德华"]; // }else{ // NSLog(@"没有这个方法"); // } if([obj respondsToSelector:@selector(sayName:andNickName:)]){ //这个是有1个参数的时候 [obj performSelector:@selector(sayName:andNickName:) withObject:@"发哥" withObject:@"花卷"]; }else{ NSLog(@"没有这个方法"); } } return 0; }
六、构造和重写
1、构造
/* 创建一个对象: [类名 new]; new关键字做了三件事: 1.开辟堆空间(相当于创建对象) 2.初始化对象 3.返回对象(返回堆空间首地址) 其实new关键字它并不能开辟堆空间和初始化对象 而是调用了两个方法,一个是alloc,一个是init alloc开辟堆空间(创建对象),然后会返回这个对象 会调用这个alloc返回的对象的init方法,就是初始化对象的 init方法又会返回这个对象(堆空间地址) 构造方法是什么? 构造方法其实就是初始化对象的方法,也就是说init就是我们的构造方法 [Person new] 相当于 [ [Person alloc] init ]; */ #import <Foundation/Foundation.h> #import "Person.h" int main(int argc, const char * argv[]) { @autoreleasepool { Person *p = [Person new]; //创建了一个person对象并且初始化 //其实上面的语句类似于下面的步骤 // Person *p2 = [Person alloc];//创建对象 // Person *p3 = [p2 init];//初始化对象 //上面两句可以合并到一句 Person *p2 = [[Person alloc] init]; } return 0; }
2、重写
/* init方法会帮我们初始化对象为0,对象类型初始化为nil。 因为默认的只会帮我们初始化为0,我想以后创建对象,都是初始化为我指定的值。 那么就需要重写init方法,因为init方法,因为父类是默认初始化为0,我重写就自己重新赋值就好了。 重写init方法必须符合写法规范 方法体要遵从以下规则: if( self = [super init] ){ //做想初始化的事 } return self; 因为有些属性是父类里面提供初始化的,所以一定要加[super init],因为初始化的时候可能会未知原因出错,所以需要判断一下。 instancetype是什么? 之前可以用id作为返回值,但是不安全,因为我可以返回任意类型。 比如说:我其实想返回一个Person对象,但是你给我返回一个OC字符串。。。。 那么编译并不会报错,但是运行时可能出现严重的问题! 所以,问题来了:有没有一种东西,可以让我返回类型,并且安全:意思就是你返回的对象一定是我这个类的。 就要用instancetype instancetype还可以代表返回的是本类或者子类 注意:instancetype只能做方法的返回值,不能做参数,也不能做类型来定义 总结:instancetype主要是用来返回对象的,而且返回的是本类或子类的对象 */ #import <Foundation/Foundation.h> #import "Person.h" #import "Student.h" int main(int argc, const char * argv[]) { @autoreleasepool { /* Person *p = [Person new]; [p sayHi];//null 0 */ // Person *p = [Person dedaoPersonInstance]; // // [p sayHi]; // // //这里得到的究竟是Person呢还是Student?? // Student *s = [Student dedaoPersonInstance]; // //Person *p = [[Person alloc] init];//因为init要返回一个对象,所以用instancetype,因为子类也可能要通过int方法返回对象 Student *s = [[Student alloc] init]; [s sayHi]; } return 0; } //在Person类的实现类中 +(instancetype)dedaoPersonInstance{ Person *p = [self new]; //当然可以,谁调用就是谁,self就代表Person return p; // return @"哈哈哈哈"; } /** * 重写构造方法 * 返回初始化的对象 */ -(instancetype)init{ if(self = [super init]){ //现在初始化为以下的值了 _name = @"刘大同"; _age = 16; } return self; }
//在Student实现类中 #import "Student.h" @implementation Student -(instancetype)init{ if(self = [super init]){ _stuNo = 1; } return self; } -(void)sayHi{ NSLog(@"name=%@,age=%d,id=%d",_name,_age,_stuNo); } @end
3、自定义构造方法
/* 之前重写构造方法,初始化的值都已经固定写死了,不灵活了 如果我们想一个对象初始化的时候按照我给的值来初始化,怎么办? 就要自定义构造方法,自定义的构造方法里面要给参数 步骤: 1.是一个对象方法 2.以initWith开头,后面接XXXXX 3.有参数(几个参数,根据你想初始化几个值确定) 4.有返回值,类型是instancetype 注意:方法体里面也要遵从规范: if(self = [super init]){ //初始化的语句 } return self; */ #import <Foundation/Foundation.h> #import "Person.h" int main(int argc, const char * argv[]) { @autoreleasepool { // Person *p = [[Person alloc] init]; // // [p sayHi]; //一定要会用,以后也会经常用到 Person *p = [[Person alloc] initWithName:@"孙悟空" andAge:99]; [p sayHi]; } return 0; } #import "Person.h" @implementation Person -(instancetype)initWithName:(NSString *)name andAge:(int)age{ if(self = [super init]){ _name = name; _age = age; } return self; } +(instancetype)dedaoPersonInstance{ Person *p = [self new]; //当然可以,谁调用就是谁,self就代表Person return p; // return @"哈哈哈哈"; } /** * 重写构造方法 * 返回初始化的对象 */ -(instancetype)init{ if(self = [super init]){ //现在初始化为以下的值了 _name = @"刘大同"; _age = 16; } return self; } -(void)sayHi{ NSLog(@"name=%@ age=%d",_name,_age); } @end