OC的继承和多态

面向对象的三大特征： 封装、继承、多态

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

好处:使用起来更加简单

    变量更加安全

    可以隐藏内部实现

    开发速度更加快捷

作用: 类来封装了属性和方法

    方法封装了实现的代码

    属性封装了成员的变量

例：

（main文件）

#import "Student.h"

        NSString *name = @"Jack";

        NSInteger age = 25;

        NSString *homeAddress = @"GZ";

        NSLog(@"Student' s name is %@，%ld years old,living in %@",name,age,homeAddress);

        

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

        [stu helloWorld];

   //私有方法 ，不被外界所调用    [stu hiGuys];

(.h文件)

interface Student : NSObject{    

使用类来封装成员变量

    NSString *_name;

    NSInteger _agel;

    NSString *_homeAddress;

}

@property(nonatomic,strong)NSString *name;

@property(nonatomic,assign)NSInteger age;

@property(nonatomic,strong)NSString *homeAddress;

//使用类来封装了功能代码

-(void)helloWorld;

@end

@implementation Student

（.m文件）

-(id)init{         

    if (self = [super init]) {

        _name = @"Jack";

        _age = 25;

        _homeAddress = @"GZ";

        

    }

    return self;

}

@end

2.继承：继承是避免冗于，提高代码的可重用性和维护的有效手段

继承的传递性：直接父类  间接父类

继承需要符合的关系：is-a

子类和父类都需要满足 is-a 关系，才存在继承

继承概念下的 is-a 关系是个单向的关系

子类具有父类的属性和行为，以及自身特殊的属性和行为

例；

(main文件)

#import <Foundation/Foundation.h>

#import "Father.h"

Father *father = [[Father alloc]init];

        father.name = @"Jack";

        [father sayHello];

        [father charge];

        NotInheritedSon *aSon = [[NotInheritedSon alloc]init];

        aSon.name = @"xxx";

        [aSon sayHello];

        [aSon charge];

        

        Son *son = [[Son alloc]init];

        [son charge];

        son.homeAdress = @"GZ";

        [son sayHello];

        [son race];

 return 0;

（Father.h文件）

#import <Foundation/Foundation.h>

@interface Father : NSObject

@property(nonatomic,strong)NSString *name;

@property(nonatomic,assign)NSInteger age;

@property(nonatomic,strong)NSString *home;

-(void)sayHello;

-(void)charge;

@end

（Father.m文件）

#import "Father.h"

@implementation Father

-(void)sayHello{

    NSLog(@"Hello everybody,my name is %@",self.name);

}

-(void)charge{

    NSLog(@"老子有钱，你随便刷！");

}

@end

3.多态：多态就是对于不同对象响应同一个方法时做出的不同反应，它是建立在继承的基础上面。

 1.继承于同一父类的子类，他们本身具有自己的特征

 2.继承于同一父类的子类，在执行同一命令的时候，具有不同的效果

多态的好处：

1.可以简化变成接口

  允许多个类中定义同一消息接口

  可以定义一个通用的调用方法，以简化调用

2.把不同的子类对象都当做父类来看

  可以屏蔽不同子类对象之间的差异，写出通用的代码

  做出通用的编程，以适应需求的不断变化

例：

(main文件）

 SonA *sonA = [[SonA alloc]init];

        sonA.name = @"sonA";

        [sonA sayHello];

        

        SonB *sonB = [[SonB alloc]init];

        sonB.name = @"sonB";

        [sonB sayHello];

 return 0;

}

（SonA.h文件）

#import "Father.h"

@interface SonB : Father

@end

（SonB.m文件）

@implementation SonB

-(void)sayHello{

    [super sayHello];

    NSLog(@"I am sonB");

}

@end

（SonA.h文件）

#import "Father.h"

@interface SonA : Father

@end

(SonA.m文件)

@implementation SonA

-(void)sayHello{

    [super sayHello];

    NSLog(@"I am sonA");

@end

(main文件)

1.可以简化变成接口

        id animal = nil;    //由于id类型的通用性质，我们可以将创建好任意对象赋值给animal

        animal = [Cat new];

        [animal eat];

        

        animal = [Dog new];

        [animal eat];

        

        

//2.把不同的子类对象都当做父类来看

        Animal *animalB = nil;

        

        animalB = [Cat new];

        [animalB eat];

        

        animalB = [Dog new];

        [animalB eat];

        /*

         开闭原则和里氏原则

         开闭原则:对推展开放，对修改关闭

         里氏替换原则:任何基类可以出现的地方，子类一定可以出现

         */

        Cat *cat = [Cat new];

        Dog *dog = [Dog new];

        

        Person *p = [[Person alloc]init];

        [p feedCat:cat];

        [p feedDog:dog];

 return 0;

}

（Animal.h文件）        

#import <Foundation/Foundation.h>

@interface Animal : NSObject

-(void)eat;

@end

（Animal.m文件）

@implementation Animal

-(void)eat{

    NSLog(@"动物吃东西");

}

@end

（Cat.h文件）

#import "Animal.h"

@interface Cat : Animal

@end

（Cat.m文件）

@implementation Cat

-(void)eat{

    NSLog(@"猫吃鱼");

}

@end

（Dog.h文件）

#import "Animal.h"

@interface Dog : Animal

@end

(Dog.m文件)

@implementation Dog

-(void)eat{

    NSLog(@"狗吃狗");

}

@end