OC总结第二讲：实例变量可见度和方法

实例变量有3种常用的可见度：@public  @protected  @private

public(公有的）

实例变量可以在类的外部和内部操作

protected(受保护的，默认的）

实例变量只能在该类和其子类内操作

private（私有的）

实例对象只能在该类内访问

所谓的内部，指的是相应类的@implementation和@end之间

方法:

1.类方法:只能类使用 例如: +(id)alloc 注意:类方法中不能使用实例变量

 

2.实例方法: 只能对象使用, - (void)satHi

 

程序：

main文件中

#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p = [[Person alloc] init];
        [p personName];
        //实例方法，只能实例对象调用

        [p sendValue:10 andAnother:20];

        //类方法只能类名调用
        [Person sayHi];
    }
    return 0;

}

.h文件中

#import <Foundation/Foundation.h>

@interface Person : NSObject{

  //  @protected   //受保护的：只有本类以及其子类可以使用
  //  @private       //私有的：只有本类可以使用
  //  @public        //公有的，谁都能使用

  //  @package     //包内可用

    NSString *name;
    int      age;

}

-(void)personName1;

//-/+ (返回值类型)方法名:(参数类型)第一个参数名  (中间要有空格)第二个参数形容词:(参数类型)第二个参数名

-(void)sendValue:(int)a andAnother:(int)b;

//形参名不要与成员变量名重复

-(void)persoName:(NSString *)newName andAge:(int)newAge;

//类方法

+(void)sayHi;

@end

.m文件中

//self关键字：在实例方法中，self代表的是类的实例（对象），在类方法里，self代表的是类本身

#import "Person.h"
@implementation Person
-(void)personName{
    name = @"胡汉三";
    NSLog(@"%@",name);
}
-(void)sendValue:(int)a andAnother:(int)b{
    NSLog(@"--%d,%d",a,b);
   // [Person sayHi];
}
-(void)persoName:(NSString *)newName andAge:(int)newAge{
    name = newName;
    age = newAge;

}

+(void)sayHi{
    NSLog(@"哈喽");

}

@end

 

初始化方法：

1.自定义初始化

-（id）init 这个初始化方法只能给实例变量设置默认值，不灵活

-（id）initWithName：

 

main文件

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //初始化，产生一个对象，将其赋值给实例变量（对象）

       // Student *stu = [[Student alloc] init];

        //便利初始化方法的调用

        Student *stu = [[Student alloc] initWithName:@"吴老二"];

        NSLog(@"--%@",stu);//当我们打印一个对象时，默认调用其描述方法

        [stu sayHi];
    }
    return 0;

}

2.便利构造器初始化

 

main文件中

#import <Foundation/Foundation.h>

#import "Student.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //便利构造器的调用，[类名  方法名 ];
        Student *stu = [Student studentWithName:@"小强" andAge:20];
        NSLog(@"%@",stu);
    }
    return 0;

}

 

.h文件

//便利构造器：通过类方式实现对象的初始化以及成员变量的赋值
#import <Foundation/Foundation.h>

@interface Student : NSObject{
    NSString *name;
    int      age;
}

- (Student *)initWithName:(NSString *)newName1 andAge:(int)newAge1;

//遍历构造器方法声明：+(类名 *)类名小写With变量名
+ (Student *)studentWithName:(NSString *)newName andAge:(int)newAge;

@end

 

.m文件

#import "Student.h"

@implementation Student

-(Student *)initWithName:(NSString *)newName1 andAge:(int)newAge1{
    self = [super init];
    if (self) {
        name = newName1;
        age = newAge1;
    }
    return self;
}

//便利构造器实现：
+(Student *)studentWithName:(NSString *)newName andAge:(int)newAge{
   

   //初始化一个对象

//     原始的初始化方法
    Student *stu = [[Student alloc] init];
    //给成员变量赋值（类方法里无法直接使用成员变量，因为成员变量属于对象）
    stu->name = newName;
    stu->age = newAge;

 //便利初始化

   // Student *stu = [[Student alloc] initWithName:newName andAge:newAge];
    NSLog(@"---%@",stu->name);
    //将初始化完成后的对象返回
    return stu;
}
-(NSString *)description{
    return name;
}
@end

 

.h文件

//便利初始化：在初始化的同时给成员变量赋值

#import <Foundation/Foundation.h>

@interface Student : NSObject{
    NSString *name;

}

//便利初始化方法命名：-(类名 *)initWith成员变量名：（类型）参数名

-(Student *)initWithName:(NSString *)newName;

- (void)sayHi;

@end

 

.m文件中

#import "Student.h"

@implementation Student

- (Student *)initWithName:(NSString *)newName{
   
    self = [super init];//通过父类调用init初始化方法，产生一个对象，此处的self就是类的对象
   
    //判断是否初始化成功，未初始化之前，self = nil
    if (self) {
        //如果初始化成功，则进行相关操作（比如，给成员变量赋值）
        name = newName;

    }

    //将初始化完成后的对象返回

    return self;

}

//类的描述方法，默认返回对象的地址，我们可以对其重写，实现我们想要的效果

-(NSString *)description{ 

    return name;

}

-(void)sayHi{
    NSLog(@"我叫：%@",name);

}

@end

 

self和super关键字

self指的是类对象本身 self用来调用本类对象的方法

super是父类对象本身 super调用父类的方法

 

self 是类的隐藏的参数，指向当前调用方法的类，另一个隐藏参数是_cmd，代表当前类方法的selector。
super并不是隐藏的参数，它只是一个“编译器指示符”，它和self指向的是相同的消息接收者。

当使用self调用方法时，会从当前类的方法列表中开始找，如果没有，就从父类中再找；

而当使用super时，则从父类的方法列表中开始找，然后调用父类的这个方法。