OC基础 类的三大特性

OC基础  类的三大特性

OC的类和JAVA一样，都有三大特性：继承，封装，多态，那么我们就来看一下OC中类的三大特性。

1.继承

继承的特点：

（1）子类从父类继承了属性和方法。

（2）子类独有的属性和方法不能被父类使用。

（3）子类独有的属性和方法，不能够在子类之间互相使用。

（4）子类能够重写父类的方法，子类调用该方法时：首先调用子类的方法，如果子类没有该方法，就调用父类的该方法。

（5）子类对象指针可以转换成父类对象指针，但是父类对象指针不能够转换成子类对象指针。

三种权限变量的继承：

（1）public和protected修饰的变量可以被子类继承。

（2）private修饰的变量不可以被子类继承。

（3）继承的属性，如果要在子类里面修改，只能使用 "self.属性名"，不能使用 "_属性名"

例子：

Father类，Father.h文件：

#import <Foundation/Foundation.h>

@interface Father : NSObject

@property (nonatomic,strong) NSString *name;

@property (nonatomic) int age;

-(id)initWithName:(NSString *)name andAge:(int)age;

-(void)speakChinese;

-(void)printf;

@end

Father.m文件：

#import "Father.h"

@implementation Father

-(id)initWithName:(NSString *)name andAge:(int)age
{
    self = [super init];
    if(self)
    {
        _name = name;
        self.age = age;
    }
    return self;
}

-(void)speakChinese
{
    NSLog(@"我会说中文");
}

-(void)printf
{
    NSLog(@"我叫%@,我%d岁",_name,_age);
}

@end

Son1类，Son1.h文件：

#import "Father.h"

@interface Son1 : Father

@property (nonatomic) int score;

-(void)speakEnglish;

@end

Son1.m文件：

#import "Son1.h"

@implementation Son1

-(void)speakEnglish
{
    NSLog(@"我会说英文");
}

-(void)printf
{
    NSLog(@"%@,%d,%d",self.name,self.age,self.score);
}

@end

Son2类，Son2.h文件：

#import "Father.h"

@interface Son2 : Father

@property (nonatomic) int money;

-(void)speakFrench;

@end

Son2.m文件：

#import "Son2.h"

@implementation Son2

-(void)speakFrench
{
    NSLog(@"我会说法语，我很屌!");
}

@end

main.m中使用：

#import <Foundation/Foundation.h>
#import "Son1.h"
#import "Father.h"
#import "Son2.h"

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

    @autoreleasepool {

        // insert code here...

        Father *fa = [[Father alloc] initWithName:@"王老大" andAge:];
        NSLog(@"%@%d",fa.name,fa.age);

        [fa speakChinese];
        [fa printf];

        Son1 *son1 = [[Son1 alloc] initWithName:@"王小三" andAge:];
        NSLog(@"%@%d,%d",son1.name,son1.age,son1.score);

        [son1 speakChinese];
        [son1 speakEnglish];
        [son1 printf];

        Son2 *son2 = [[Son2 alloc] initWithName:@"王小二" andAge:];

        [son2 speakChinese];
        [son2 speakFrench];
        [son2 printf];

        Father *fa2 = (Father *)son1;
        [fa2 speakChinese];

        Son1 *son11 = (Son1 *)fa;
        [son11 speakEnglish];

    }
    return ;
}

2.封装

封装：隐藏内部实现，稳定外部接口。

封装就是定义类，定义属性和定义方法。

然而类封装了实例变量和方法，属性则是封装的setter和getter方法

那么封装带来的好处：让我们使用更加简单 ，变量更加安全 ，并且可以隐藏内部实现细节 ，充分的提升了开发速度。

例子：

Student类，Student.h文件：

#import <Foundation/Foundation.h>

@interface Student : NSObject
{
    NSString *_name;
    NSString *_nickName;
}

//@property定义属性
//1,它给该类声明了一个属性名＋下划线的变量
//2,它给该类声明了一个getter方法和一个setter方法

//修饰符
//atomic和nonatomic
//原子性和非原子性,atomic线程安全，nonatomic线程不安全
//一般情况下使用nonatomic

//setter修饰符指定赋值时调用哪个方法来实现setter
//setter修饰符指定读取值时调用哪个方法来实现getter
@property (nonatomic,setter = setNickName:,getter = nickName) NSString *nickName;

//修饰符
//assign用来修饰基本类的
//strong或者retain是用来修饰对象指针的
//readonly只读:只声明和实现getter，不声明和实现setter方法
//readwrite可读写:声明和实现了getter和setter，默认就是readwrite
@property (assign,readonly) int age;
@property (retain,readwrite) NSString *secondName;

-(void)setName:(NSString *)name;
-(NSString *)getName;
-(void)setaaa:(NSString *)aaa;

@end

3.多态

多态性（polymorphism）：允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说：允许将子类类型的指针赋值给父类类型的指针。

不同对象对同一消息的不同响应，子类可以重写父类的方法，多态就是允许方法重名，参数或返回值可以是父类型传入或返回。

多态的特点：

（1）父类类型的指针指向子类对象。

（2）如果函数方法参数中使用的是父类类型，则可以传入父类和子类对象，而不用再去定义多个函数来和相应的类进行匹配了。

（3）父类类型的变量不能直接调用子类特有的方法，如果必须要调用，则必须强制转换为子类特有的方法。

例子：

Animal类，Animal.h文件：

#import <Foundation/Foundation.h>

@interface Animal : NSObject

- (void)name;

@end

Animal.m文件：

#import "Animal.h"

@implementation Animal

- (void)name {
    NSLog(@"动物");
}
@end

Cat继承Animal，Cat.h文件：

#import "Animal.h"

@interface Cat : Animal

- (void)name;

@end

Cat.m文件：

#import "Cat.h"

@implementation Cat

//重写方法
- (void)name {
    NSLog(@"猫");
}

@end

main.m中使用：

#import <Foundation/Foundation.h>
#import "Animal.h"
#import "Cat.h"

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

    @autoreleasepool {

        Animal *animal = [[Animal alloc] init];
        [animal name];

        Cat *cat1 = [[Cat alloc] init];
        [cat1 name];

        //这里会体现多态的用法：动态监控调用哪个方法
         Animal *cat2= [[Cat alloc] init];
         [cat2 name];

    }
    return ;
}