黑马程序员——OC基础语法—点语法和成员变量作用域

OC基础语法——点语法和成员变量作用域

 

  1.点语法：

      点语法只适用于setter和getter方法，点语法的产生是为了让其它语言的程序员快速上手于OC，在不用点语法之前，调用setter的格式是：

 [对象名 方法名:值]

而点语法来说就简化多了它是这样用的：

 [对象名.成员变量=值] 

这里并不是访问成员变量，而是调用setter方法，点语法做的事情就是把点语法的格式转成正常调用setter方法的格式。

 普通调用set和ge方法：

Student *stu = [Student new];

[stu setAge:100];

int age = [stu age];

点语法：

stu.age = 100;

int age = stu.age;

1. 点语法的本质：

其实点语法的本质还是方法调用

当使用点语法时，编译器会自动展开成相应的方法

Person类：

#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    int _age;    // 年龄
    NSString *_name;   // 姓名
}

// 年龄的setter和getter方法

- (void)setAge:(int)age;
- (int)age;

// 姓名的setter和getter方法
- (void)setName:(NSString *)name;
- (NSString *)name;

@end

#import “Person.h”

@implementation Person

- (void)setAge:(int)age
{
    //_age = age;
   
    NSLog(@"setAge:");
   
    // 会引发死循环
    //self.age = age; // [self setAge:age];
}

- (int)age
{
    NSLog(@"age");
    return _age;
    // 会引发死循环
    //return self.age;// [self age];
}

- (void)setName:(NSString *)name
{
    _name = name;
}

- (NSString *)name
{
    return _name;
}

@end

 

main函数：

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

int main(int argc, const char * argv[])
{
    Person *p = [Person new];
   
    // 点语法的本质还是方法调用
    p.age = 10; // [p setAge:10];         // 点语法之调用setter方法
    
    int a = p.age; // [p age];          // 点语法之调用getter方法
    
    
    p.name = @"Jack";
   
    NSString *s = p.name;
   
    NSLog(@"%@", s);
   
    return 0;
}

 

p.name=10 和 [p setName:10] 其实是等价的，p.name  和  [p name]  也是等价的。

 

2.注意引发死循环：

  - (void)setAge:(int)age

{  

[ self.age=10];

}

 

 

2.成员变量的作用域：

   1.含义：成员变量的作用域就是成员变量可访问的范围

   2.四种类型：

第一种 @private 修饰符 含义为：私有的。它的作用域是只能在当前类的实现 @implementation 中访问。

第二种 @protected 修饰符 含义为：被保护的。它的作用域可以在当前类以及子类的 @implementation 中访问。

第三种 @public 修饰符 含义为：公共的。它的作用域是在任何地方都可以访问。

第四种 @package 修饰符 含义为：包。它的作用域是同一框架中可以访问。

 

Person类：

#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    int _no; // 学号
   
    @public // 在任何地方都能直接访问对象的成员变量
    int _age;  // 年龄
   
   
    @private  // 只能在当前类的对象方法中直接访问
    int _height; // 身高
   
    @protected // 能在当前类和子类的对象方法中直接访问
    int _weight;  // 体重
    int _money;   // 金钱
}

// 身高t的setter和getter方法

- (void)setHeight:(int)height;
- (int)height;

- (void)test;
@end

 

#import "Person.h"

@implementation Person
{
    int _aaa;// 默认就是私有
   
    @public
    int _bbb;
    // @implementation中不能定义和@interface中同名的成员变量
    // int _no;
}

- (void)test
{
    _age = 19;
   
    _height = 20;
   
    _weight = 50;
   
    _aaa = 10;
}

- (void)setHeight:(int)height
{
    _height = height;
}

- (int)height
{
    return _height;
}

@end

 

Student类：

#import "Person.h"

@interface Student : Person
- (void)study;
@end

#import "Student.h"

@implementation Student
- (void)study
{
   
    // _height = 10;      //  直接访问不了heighr，在父类中类型是@private
    [self setHeight:10];       // 可以调用父类中的setter方法间接访问height
    
    
    int h = [self height];
   
    _weight = 100;    // protected 在子类中可以直接访问父类的成员变量
}
@end

main函数：

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

@implementation Car : NSObject
{
@public
    int _speed;   //  速度
   
@protected
    int _wheels;   //  车轮
}

// 速度的setter和getter方法

- (void)setSpeed:(int)speed
{
    _speed = speed;
}
- (int)speed
{
    return _speed;
}

@end

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

    @autoreleasepool {
        Student *stu = [Student new];
       
       
        [stu setHeight:100];    // 间接访问height
       
       
        NSLog(@"%d", [stu height]);
       
        /*
        Car *c = [Car new];
        c->_speed = 250;      //  在@implementation 中也可以定义成员变量，但成员变量默认就是@private，因此不能直接访问speed变量
        */
        //c.speed = 10;
       
        // NSLog(@"%d", c.speed);
       
        //[c setSpeed:<#(int)#>];
       
        /*
        Person *p = [Person new];
        p->_bbb = 10;                    //   这里也是一样，不能直接去访问bbb
        p->_age = 100;
        */
        //p->_height = 20;
       
       
        //p->_weight = 10;
    }
    return 0;
}

 

我们在 @interface 中定义的成员变量如果不加修饰符默认是 @protected ，而在 @implementation 中定义的成员变量不加修饰符就默认是 @private

需要注意的是子类是没有办法直接访问父类中 @private 类型的变量，但是子类中依然会有这个变量，并且可以通过调用父类中的 setter 和 getter 访问这个变量。