OC第二天-实例变量可见度，setter和getter方法，导入头文件

实例变量可见度、方法、setter、getter
Person.h

#import <Foundation/Foundation.h>

@interface Person : NSObject{

//    在声明成员变量的时候，如果没有使用关键字进行说明，默认是受保护类型
    NSString *_address;



    @public//公开的  可以在本类和类外面访问和修改；可以在任何地方访问和修改；
    NSString *_name;

    @protected//受保护的  作用域 在本类和子类 ；
    NSString *_sex;

    @private//私有的  只能在本类里面对他修饰的成员进行访问 和 修改
    int      _age;


    @package//作用于整个框架Cocoa框架

}

//setter（设置器）的书写格式：实例前面的_去掉，将首字母大写，然后前面加上set；设置器方法没有返回值
//即set+首字母⼤写的实例变量名(忽略下划线)
-(void) setAge:(int)age;
-(void) setName:(NSString *)name;
-(void) setAddress:(NSString *)address;
-(void) setSex:(NSString *)sex;

//getter(访问器)书写格式：变量名字去掉下划线 加上返回值类型

-(int)age;
-(NSString *)name;
-(NSString *)sex;
-(NSString *)address;

//声明一个 自定义的初始化方法
-(id)initWithName:(NSString *)name;


//方法标识后面的括号中的类型是返回值类型；void表示空类型，没有返回值；
-(void) print;

//获取年龄
-(int) getAge;

//id 和instancetype比较： 1、都表示对象类型；2、id在编译阶段不确定类型，instancetype在编译阶段已经确定类型 3、id可以当做参数类型来使用，而instancetype不可以，只能当做返回值类型
-(instancetype) printf;




//:冒号表示方法有参数；:冒号后面就是这个方法的参数 ()里面是参数的类型，()后面是参数的名字；冒号前面是参数的修饰词，就是对参数的解释
//方法名字：initWithName:age:::
-(id) initWithName:(NSString *)name age:(int)age ;


//声明一个设置方法
-(void) setName:(NSString *)name
            age:(int)age
        address:(NSString *)address;

@end

//学生类的声明部分
@interface Student : Person

@end

Person.m

#import "Person.h"

@implementation Person

//设置器的实现
-(void) setAge:(int)age{
    _age = age;
}
-(void) setName:(NSString *)name{
    _name = name;
}
-(void) setAddress:(NSString *)address{
    _address = address;
}
-(void) setSex:(NSString *)sex{
    _sex = sex;
}

//访问器（获取器）的实现
-(int)age{
    return _age;
}
-(NSString *)name{
    return _name;
}
-(NSString *)sex{
    return _sex;
}
-(NSString *)address{
    return _address;
}


//实现一个 自定义的初始化方法
-(id)initWithName:(NSString *)name{
//    先让父类执行一次初始化方法
    self = [super init];
//    然后判断，并对实例变量进行设置
    if (self) {
        _name = name;
    }
    return self;
}


-(void) print{
    NSLog(@"_age = %d",_age);
}

-(int) getAge{
    return 20;
}


-(void) setName:(NSString *)name
            age:(int)age
        address:(NSString *)address{
    _name = name;
    _age = age;
    _address = address;
}

@end

@implementation Student

-(void)print{
    Person *p = [[Person alloc] init];
    p -> _sex = @"man";

}

@end

AudiCar.h

#import <Foundation/Foundation.h>

@interface AudiCar : NSObject{
    @public
    NSString *_color;
    NSString *_brand;
    float    _price;
}
//setter设置器
-(void)setColor:(NSString *)color
          Brand:(NSString *)brand
          Price:(float)price;
//声明两个方法
-(void) print;
//
+(void) run;

@end

AudiCar.m

#import "AudiCar.h"

@implementation AudiCar

-(void)setColor:(NSString *)color
          Brand:(NSString *)brand
          Price:(float)price{
    _color = color;
    _brand = brand;
    _price = price;
}

-(void) print{
    NSLog(@"sf");
}

+(void) run{
    self;//表示类本身，就是类的名字

    //    不能在+方法中访问实例变量
    //    _address;
}

@end

Man.h

#import <Foundation/Foundation.h>
//#import "Woman.h"
@class Woman;//用class关键字声明类，解决用import导入文件时产生的循环编译的问题class只是一个声明的作用，就是告诉编译器 这个类是存在的，但是不编译；

@interface Man : NSObject{
    Man *_woman;

}
@end

Man.m

#import "Man.h"

@implementation Man

@end

Woman.h

#import <Foundation/Foundation.h>
//#import "Man.h"
@class Man;

@interface Woman : NSObject{

    Man *_MAN;
}
@end

Woman.m

#import "Woman.h"

@implementation Woman

@end

main.m

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

#import "Man.h"
#import "Woman.h"


//#include "Person.h"//是C语言中导入头文件的方法，如果在一个文件中重复导入相同的文件，就会出错
//#include "Person.h"

#import "Person.h"//解决了重复导入头文件的问题，避免重复编译的错误；
#import "Person.h"
#import "Person.h"


int main(int argc, const char * argv[]) {

    Person *person = [[Person alloc]init];

    [person setName:@"zhangdan" age:20 address:@"北京"];


    AudiCar *p = [[AudiCar alloc] init];
    [p setColor:@"red" Brand:@"audi" Price:1111111];
    [p print];


    Man *man = [[Man alloc] init];
    Woman *woman =[[Woman alloc] init];


    return 0;
}