黑马程序员——OC基础---基础小结（类方法，匿名对象，封装）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一、类方法
1.加号开头。
2.类方法只能用类名调用。
3.类方法中不能访问成员变量。
4.类方法可以调用类方法。
5.允许类方法和对象方法同名。

类方法的好处和使用场合
1.不依赖于对象，执行效率高。
2.能用类方法就用类方法。
3.当方法内部不需要使用到成员变量时，就可以改用类方法。

示例：

#import <Foundation/Foundation.h>

@interface Car : NSObject
{  
}
+(void)run;
@end
@implementation Car
+(void)run
{
    NSLog(@"车在跑");
}

@end
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        [Car run];

    }
    return 0;
}

运行结果：

二、匿名对象
1.没有名次的对象叫匿名对象。
2.有名称的对象，用一个指针来接受了对象的地址叫有名称对象。

匿名对象的使用场景：1.当对象方法仅仅调用一次的时候。2.匿名对象可以作为实际参数传递。

示例：

#import <Foundation/Foundation.h>
@interface Car : NSObject
{
    int _speed;
}
-(void)setSpeed:(int)speed;
-(void) run;
@end

@implementation Car
-(void)setSpeed:(int)speed
{
    _speed = speed;
}
-(void)run
{
    NSLog(@"车在跑，速度%d",_speed);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...

        [[Car new]setSpeed:110];
        //匿名类访问成员变量只能访问一次
        [[Car new]run];
    }
    return 0;
}

输出结果：

三、封装
封装是对属性的封装。
规范写法：
set方法
1.一定是对象方法
2.返回值一定是void
3.一定以set开头，后面接上成员变量去掉下划线的名称，首字母大写
4.一定有参数，参数类型一定和成员变量相同。

get方法
1.一定是对象方法
2.一定有返回值，返回值和成员变量类型相同
3.方法名称直接写成员变量名称去掉下划线
4.一定没有参数

封装的原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共的方法对其访问。

优点：可以过滤掉一些不符合逻辑的数据，提高代码的健壮性。

示例：
Person.h文件

#import <Foundation/Foundation.h>

typedef enum
{
    kSexMan,kSexWomen

}Sex;

@interface Person : NSObject
{
    //姓名
    NSString *_name;
    //年龄
    int _age;
    //性别
    Sex _sex;
    //身高
    float _height;

}

-(void) setName:(NSString *)name;
-(NSString *)name;
-(void) setAge:(int)age;
-(int) age;
-(void) setSex:(Sex)sex;
-(Sex) sex;
-(void) setHeight:(float)height;
-(float) height;
@end

Person.m文件

#import "Person.h"

@implementation Person


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

-(NSString *)name
{
    return _name;
}

-(void)setAge:(int)age
{
    _age = age;
}

-(int)age
{
    return _age;
}

-(void)setSex:(Sex)sex
{
    _sex = sex;
}

-(Sex)sex
{
    return _sex;
}

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

-(float)height
{
    return _height;
}

@end

main()文件

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


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        Person *p = [[Person alloc]init];
        [p setName:@"king"];
        [p setAge:23];
        [p setSex:kSexMan];

        NSLog(@"%@,%d,%d",[p name],[p age],[p sex]);
    }
    return 0;
}

输出结果：

四、组合模式
在一个类中声明其它对象的指针变量。

优点：全局的对象方法都可以访问，简化了我们的代码。
缺点：依赖性很强。

使用场景：当多个方法都使用到了同一个对象，就把它设置为成员变量。

示例：
IPhone.h

#import <Foundation/Foundation.h>

@interface IPhone : NSObject
{
    NSString *_phoneNum;
}

-(void) setPhoneNum:(NSString *)phoneNum;
-(NSString *) phoneNum;

//打电话
-(void) callPhone;

@end

IPhone.m

#import "IPhone.h"

@implementation IPhone

-(void)setPhoneNum:(NSString *)phoneNum
{
    _phoneNum = phoneNum;
}

-(NSString *)phoneNum
{
    return _phoneNum;
}
-(void)callPhone{
    NSLog(@"给人打电话，电话号码是%@",_phoneNum);
}
@end

People.h

#import <Foundation/Foundation.h>
#import "IPhone.h"
@interface People : NSObject

-(void)callPhonePeople:(IPhone *) iphone;
@end

People.m

#import "People.h"

@implementation People

-(void)callPhonePeople:(IPhone *)iphone
{
    [iphone setPhoneNum:@"110"];
    [iphone callPhone];
}
@end

main.m

#import <Foundation/Foundation.h>
#import "People.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        IPhone *ip = [[IPhone alloc]init];
        People *p = [[People alloc]init];
        //people依赖iphone
        [p callPhonePeople:ip];
    }
    return 0;
}

运行结果：

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-