OC对象的三大特性：封装、继承和 多态

一、封装

封装：隐藏对象的属性和实现细节，仅对外公开接口，控制程序中属性的读和修改的访问级别。

person.h:

#import <Foundation/Foundation.h>

@interface Person : NSObject
/** 年龄 */
@property (nonatomic, assign) int age;

@end

person.m:

#import "Person.h"

@implementation Person

#pragma mark - 重写set方法
- (void)setAge:(int)age {
    if (age < 0) {
        NSLog(@"年龄不能为负数");
        return;
    } else {
        _age = age;
        return;
    }
}

@end

优点：

1. 隐藏内部实现细节，设置访问权限，提高了数据的安全性。

2. 任何出入的数据都要流经接口，通过重写set方法可以起到过滤数据的作用。

二、继承

继承：指一个对象直接使用另一对象的属性和方法。

Person.h:

#import <Foundation/Foundation.h>

@interface Person : NSObject
/** 年龄 */
@property (nonatomic, assign) int age;
/** 吃方法 */
- (void)eat;

@end

Person.m:

#import "Person.h"

@implementation Person

#pragma mark - 重写set方法
- (void)setAge:(int)age {
    if (age < 0) {
        NSLog(@"年龄不能为负数");
        return;
    } else {
        _age = age;
        return;
    }
}

#pragma mark - 吃方法实现
- (void)eat {
    NSLog(@"Person 吃饭");
}

@end

GoodPerson.h:

#import "Person.h"

// 继承父类Person
@interface GoodPerson : Person
/** 姓名 */
@property (nonatomic, strong) NSString *name;

@end

GoodPerson.m:

#import "GoodPerson.h"

@implementation GoodPerson

- (void)eat {
    NSLog(@"GoodPerson 吃饭");
}

@end

main.m:

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


int main(int argc, const char * argv[]) {
    /** 人 */
    Person *p = [[Person alloc] init];
    p.age = 20;
    [p eat];
    
    /** 好人 */
    GoodPerson *goodP = [[GoodPerson alloc] init];
    goodP.age = 30;
    [goodP eat];
    
    // 好人姓名
    goodP.name = @"Lkun";
    NSLog(@"好人name = %@", goodP.name);
    
    
    return 0;
}

编译运行结果：

2016-08-18 17:53:37.484 01-discription[634:455001] Person 吃饭
2016-08-18 17:53:37.485 01-discription[634:455001] GoodPerson 吃饭
2016-08-18 17:53:37.485 01-discription[634:455001] 好人name = Lkun
Program ended with exit code: 0

                    

注解：

1. 大部分类都继承自NSObject父类，所以也都继承了该类的属性和方法。

2. GoodPerson虽继承了父类Person的属性age和方法eat,但却有其独特的方法name,且重写了父类的方法eat。

3. 当子类对象收到方法消息时则逐层查找，找到即执行。如setName方法在GoodPerson父类就可以找到，而setAge类得在Person父类才能找到

优点：抽取重复代码、建立联系

缺点：耦合性强 

继承：狗是动物，所以狗继承动物类

组合：学生拥有狗，所以把狗作为学生类的一个属性

三、多态

 多态：父类指针指向子类对象，父类类型参数可以接收子类类型参数的传入

Person.h:

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

@interface Person : NSObject
 // 喂食动物的方法
- (void)feedAnimal:(Animal *)animal;

@end

Person.m:

#import "Person.h"

@implementation Person

- (void)feedAnimal:(Animal *)animal {
    [animal eat];
}

@end

Animal.h:

#import <Foundation/Foundation.h>

@interface Animal : NSObject
/** 吃方法 */
- (void)eat;

@end

Animal.m:

#import "Animal.h"

@implementation Animal

- (void)eat {
    NSLog(@"Animal eat");
}

@end

Cat.h:

#import "Animal.h"

@interface Cat : Animal

@end

Cat.m:

#import "Cat.h"

@implementation Cat
#pragma mark - 重写父类的吃方法
- (void)eat {
    NSLog(@"Cat eat");
}

@end

Dog.h:

#import "Animal.h"

@interface Dog : Animal

@end

Dog.m:

#import "Dog.h"

@implementation Dog
#pragma mark - 重写父类吃方法
- (void)eat {
    NSLog(@"Dog eat");
}

@end

main.m:

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


int main(int argc, const char * argv[]) {
    /** 人 */
    Person *p = [[Person alloc] init];
    
    /** 动物 */
    Animal *a = [[Animal alloc] init];
    
    /** 猫 */
    Cat *c = [[Cat alloc] init];
    
    // 父类指针指向Dog实例对象
    Animal *d = [[Dog alloc] init];
    
    
    // 动态检测真正对象是Dog
    [d eat];
    
    // 父类指针类型的参数也可以接收子类指针类型的参数
    [p feedAnimal:a];
    [p feedAnimal:c];
    
    
    return 0;
}

编译运行结果：

2016-08-18 19:42:59.467 01-discription[759:669325] Dog eat
2016-08-18 19:42:59.468 01-discription[759:669325] Animal eat
2016-08-18 19:42:59.468 01-discription[759:669325] Cat eat
Program ended with exit code: 0

 注解：

1. oc语言是编译的时候才动态检测，调用真正的对象，而不管是指针是什么类型。

2. 父类子针作为参数类型时，其子类子针参数都可以传入

3. 父类指针指向子类对象不能使用子类独有的方法，但可以使用强制转换类型，进而调用