oc语言学习之基础知识点介绍（五）：OC进阶

一、点语法介绍

/*
 以前封装后，要给属性赋值，必须调用方法
 这样做，有两个缺点：
                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
");
        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