day3: 继承、初始化方法、便利构造器

OC第三讲  继承、初始化方法、便利构造器

继承 是面向对象的主要特征
 
 1、OC的根类是NSObject
 2、继承是单向继承，不能双向继承，只有子类继承父类，不能父类继承子类
 3、OC里所有的类只能有一个父类，不可能出现一个类有两个或多个父类，叫单根继承（C++可以继承多个类）
 4、子类继承父类，继承父类的所有成员变量和方法；
 5、子类不能声明跟父类同名的成员变量。
 6、成员变量的内存分配，子类使用父类的方法，成员变量存储是和父类没关系的
 7、子类执行方法的过程：在OC中执行方法的顺序，(1)、在本类中找方法的实现，如果存在就直接执行；(2)、如果不存在就继续在父类查找，如果存在就执行父类里的实现，如果不存在就继续往父类的父类进行查找，直到NSObject为止。(3)、如果NSObject中还没找到就直接崩溃。
 8、super指令 是一个操作指令，只是一个操作符 不是对象 用的是非常非常多
    super的作用是帮助子类去执行父类的方法，不是父类在执行他自己的方法；
 
 方法的调用：
 重写父类声明的方法也叫接口继承
 
 初始化方法：
 9、功能：在创建对象的时候就给成员变量赋值（setter方法是在使用的时候赋值）
 10、初始化方法是减号方法
 11、初始化方法的步骤（1）执行父类的实现（2）判断父类是否执行成功，如果成功给成员变量赋值。如果失败返回NULL
 //完整的重写初始化方法
 -(instancetype)init{
 //1、让子类对象执行父类的方法实现，并将实现结果继承过来
 self = [super init];  //这个self谁调用就是谁的
 //2、判断父类的实现是否执行成功，如果执行成功才给成员变量赋值，如果失败直接返回。
 if (self) {
 _name=@"张三";
 }
 return self;
 }
 
 self：哪个对象调用self就表示谁。
 
 便利构造器：
 12、将对象的创建过程封装在一个类方法里（+方法），构造一个对象并且给他的成员变量赋值。作用：分配内存和初始化方法在一个地方实现
    便利构造器封装了对象的创建过程，进一步简化了对象的创建步骤
    便利构造器是一个加号方法，也就是说是一个“类方法”；
    命名规则：前缀是类名，参数可以有0到多个

Person.h

#import <Foundation/Foundation.h>

//NSObject 是OC里面的根类  所有类都继承于它 它没有父类
//在OC中自定义的类，必须得有一个基类，要么直接继承于NSObject，要么间接继承于NSObject；

@interface Person : NSObject{
    NSString *_name;    //名字
    NSString *_sex;     //性别
    @private
    NSUInteger _age;   //年龄
}
//自定义一个按name初始化的方法(id和instancetype都是泛型)
-(instancetype)initWithName:(NSString *)name;
//自定义给所有成员赋值的方法：
-(instancetype)initWithName:(NSString *)name andSex:(NSString *)sex andAge:(NSUInteger)age;


//声明setter
-(void)setName:(NSString *)name;
//声明getter
-(NSString *)name;
-(void)printHello;


//先写一个没有返回值的+方法
+(void)printf;
//声明一个便利构造器方法,命名规则：类名做前缀，可以有参数
+(Person *)personWithName:(NSString *)name;

@end

Person.m

#import "Person.h"

@implementation Person

//完整的重写初始化方法
-(instancetype)init{
    //1、让子类对象执行父类的方法实现，并将实现结果继承过来
    //self是个指针变量，里面存的地址，失败的话返回NULL
    //谁在调用init这个方法，init就是谁的
    self = [super init];
    //2、判断父类的实现是否执行成功，如果执行成功才给成员变量赋值，如果失败直接返回。
    if (self) {
        _name=@"张三";
    }
    return self;
}
//实现自定义初始化方法
-(instancetype)initWithName:(NSString *)name{
    self = [super init];
    if (self) {
        _name=name;
    }
    return self;
}
//自定义给所有成员赋值的方法：
-(instancetype)initWithName:(NSString *)name andSex:(NSString *)sex andAge:(NSUInteger)age{
    self=[super init];
    if (self) {
        _name=name;
        _sex=sex;
        _age=age;
    }
    return self;
}


-(void)printHello{
    NSLog(@"Hello World");
}
//声明setter
-(void)setName:(NSString *)name{
    _name=name;
}
//声明getter
-(NSString *)name{
    return _name;
}


//+类方法实现的时候中不能有实例变量
//类方法只能用类名来进行调用
+(void)printf{
    //类方法中不能使用成员变量
    //NSLog(@"%@",_name);
    NSLog(@"Hello OC");
}

//便利构造器实现的是将创建对象的过程进行封装，将对象的内存管理放到一个方法中，方便我们在创建对象的时候进行调用，
//便利构造器代码没有省，但是方便了调用
+(Person *)personWithName:(NSString *)name{
    Person *p=[[Person alloc]initWithName:name];
    return p;
}

@end

Student.h

#import "Person.h"
/*在.h 文件里面@class ** 这个类，我们还需要在.m文件里重新引入一遍，
 这样，我们就可以在.m文件里使用了
 
 */

@interface Student : Person{
//    NSString *_name; //子类不能声明跟父类同名的成员变量
    //在子类中声明的实例变量或者方法是子类特有的；
    NSString *_number;
}
-(void)setAge:(NSUInteger)age;
-(NSUInteger)age;

@end

Student.m

#import "Student.h"

@implementation Student

-(instancetype)init{
    self=[super init];
    if (self) {
        ;
    }
    return self;
}

//重写父类声明的方法也叫接口继承
-(void)printHello{
    //super 是一个操作指令，只是一个操作符 不是对象 用的是非常非常多
    //super的作用是帮助子类去执行父类的方法，不是父类在执行他自己的方法；
    [super printHello];
    NSLog(@"我是student的 Hello World");
}

-(void)setAge:(NSUInteger)age{
    //私有成员变量，子类只能继承不能使用
    _age=age;  //因_age为私有变量，所以这里会报错
}

-(NSUInteger)age;{    
    return _age;  //因_age为私有变量，所以这里会报错
}

@end

main.m

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

int main(int argc, const char * argv[]) {
/*
    //创建person对象 alloc是一个加号方法，是NSObject中的方法
    //栈区存的地址都是函数或者方法来分配的
    Person *p=[[Person alloc]init];
    //子类里面声明和定义的方法，父类不能进行调用，只有子类以及子类的子类来调用
    [p printHello];
    //给name赋值
    [p setName:@"ABC"];
    
    
    //创建student对象
    Student *student=[[Student alloc]init];
    //在OC中执行方法的顺序，1、在本类中找方法的实现，如果存在就直接执行；2、如果不存在就继续在父类查找，如果存在就执行父类里的实现，如果不存在就继续往父类的父类进行查找，知道NSObject为止。3、如果NSObject中还没找到就直接崩溃。
//    student=[NSString alloc];
    [student printHello];
    [student setName:@"zhangsan"];    
    NSLog(@"p.name=%@",[p name]);
    NSLog(@"student.name=%@",[student name]);
*/
    Person *p1=[[Person alloc]init];
    Person *p2=[[Person alloc]init];
    Person *p3=[[Person alloc]initWithName:@"123"];
    Person *p4=[[Person alloc]initWithName:@"ABC"];
    
    Student *s=[[Student alloc]init];
    
    //类方法只能用类名来调用
    [Student printf];
    
    //便利构造器的作用，只是方便了调用
    Person *per=[Person personWithName:@"lisi"];
    
    return 0;
}