OC_03

#import <Foundation/Foundation.h>
#import "Student.h"
#import "Father.h"
#import "NotSon.h"
#import "Son.h"
#import "SonA.h"
#import "SonB.h"
#import "Animal.h"
#import "Cat.h"
#import "Dog.h"
#import "Person.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
#pragma mark----------封装-------------------
        /*
         面向对象的三大特征:
         封装,继承,多态
         
         封装:隐藏内部的实现,稳定外部的接口
         好处:
            使用起来更加简单
            变量更加安全
            可以隐藏内部实现细节
            开发速度更加快捷
         
         作用:
            方法封装了具体实现的代码
            属性封装了实例变量
            类封装了属性和方法
         */
        NSString *name = @"Yong";
        NSInteger age = 23;
        NSString *homeAddress = @"GZ";
        NSLog(@"Teacher name %@,%ld years old,living in %@",name,age,homeAddress);
        
    
    
    Student *student = [[Student alloc] init];
    
    //方法封装了具体实现的代码
    [student helloWorld];
    
//    [student hiGuys];  //私有方法不被外界所调用
    }
    
#pragma mrak-----------------继承----------------
    /*
     继承:继承是避免冗余,提高代码的可重用和可维护性的有效手段
     
     继承的传递性(书P54):直接父类,间接父类
     
     继承需要符合的关系:is-a
         子类和父类都需要满足 is-a 的关系,才存在继承关系.
     继承概念下 is-a 关系是个单向的关系
     
     子类具有父类的属性和行为,以及自身特色的属性和行为
     要记住 X is-a Y 隐喻着X可以做出任何Y可以做出的事情,而且还有可能会做出更多的事情
     
     */
    /*
     继承的特点
     1.使用继承可以实现代码的重用,减少代码冗余
     2.OC中一个类可以继承另一个类,被继承的类称为 父类 或者 超类(基类),继承的类称为 子类 或者 派生类(孩子类)
     3.子类可以直接"拥有"父类所有允许子类继承的属性和方法
     4.子类可以改变父类中已有的方法,执行不同的代码实现
     5.OC中只允许单一继承,因为多重继承会有称为"致命方块"的问题
     */
    
    Father *father = [[Father alloc] init];
    //点语法的本质是setter 和 getter
    father.name = @"Yong";
    [father sayHolle];
    [father charge];
    
    //如果这样写代码就会十分的冗余,并且这样写没有遵循面向对象的一个重要原则:write once,only once(写一次,仅写一次)
    NotSon *notson = [[NotSon alloc] init];
    notson.name = @"Chen";
    [notson sayHolle];
    [notson charge];
    
    Son *son = [[Son alloc] init];
    [son charge];
    
    son.name = @"Yong";
    son.homeAddress = @"GZ";
    [son sayHolle];
    [son race];
    
#pragma mark---------------NSObject中常用的方法及其功能----------------------
    
    /*
     NSObject中常用的方法及其功能
     1.方法:+(id)alloc
       功能:放回一个分配好内存的对象
       说明:已经分配好内存的对象的实力变量会被初始化成默认值
     
     2.方法:+(id)init
       功能:对已经分配内存大的实例变量初始化(相当于便利初始化函数),不一定要默认的初始化函数,也可以自己写
       说明:常见形式
          -(id)init
         {
           if(self = [super init])
             {
               //初始化
            }
            return self;
         }
     3.方法:+(id)new
       功能:同时调用了alloc和init
     
     4.方法:-(Class)class
           +(Class)class
       功能:返回当前对象所属类
     
     5.方法:-(Class)superclass
           +(Class)superclass
       功能:返回当前对象的父类
     
     6.方法:-(BOOL)isKindOfClass:(Class)aClass
       功能:判定receiver是否为Class的实例
       说明:判断某个实例是否属于某个类或者子类
     
     7.方法:-(BOOL)isMemberOfClass:(Class)aClass
       功能:判断receiver是否为Class的实例
       说明:只能判断某个实例是否属于某个类,不能判断是否属于某个父类
     
     8.方法:+(BOOL)isSubclassOfClass:(Class)aClass
       功能:判断是否为aClass的子类
       说明:判断是否某个类的子类
     
     9.方法:-(BOOL)respondsToSelector:(SEL)aSelector
       功能:判断receiver是否响应某个消息,不包括类方法
     
     10.方法:+(BOOL)InstancesRespondToSelector:(SEL)aSelector
        功能:判断类的对象是否响应某消息
     
     11.方法:-(BOOL)conformsToProtocol:(Protocol *)aProtocol
        功能:判断是否实现某协议
     
     12.方法:-(id)retain
        功能:对象引用计数+1
     
     13.方法:-(oneway void)release
        功能:对象引用计数 -1
     
     14.方法:-(id)autorelease
        功能:对象引用计数 -1,且向autorelsesepool发送消息
     
     15.方法:-(NSUInteger)retainCount
        功能:返回当前引用计数
     
     16.方法:-(void)perfromSelector:(SEL)aSelector
                    withObject:(id)anArgument
                    afterDelay:(NSTimeInvterval)delay;
        功能:隔指定时间之后进行方法调用
     
     */
    
#pragma mark-------------------多态--------------------
    /*
     多态:多态就是对于不同的对象响应同一个方法时做出不同的反应,它是建立在继承的基础上面
       1.继承同一父类的子类,他们本身具有自己的特性
       2.继承同一父类的子类,在执行同一命令的时候,具有不同的效果
     */
    
    SonA *sonA = [[SonA alloc] init];
    sonA.name = @"SonA";
    [sonA sayHolle];
    
    SonB *sonB = [[SonB alloc] init];
    sonB.name = @"SonB";
    [sonB sayHolle];
    
    /*
     多态的好处:
     1.可以简化编程接口
        允许在多个类中定义同一消息接口
        可以定义一个通用的调用方法,以简化调用
     2.把不同的子类对象都当做父类来看
        可以屏蔽不同子类对象之间的差异,写出同用的代码
        做出通用的编程,以适应需求的不断变化
     */
    
    //1.可以简化编程接口
    id animal = nil; //由于id类型的通用性质(指向任意对象),我们可以将创建好的任意对象赋值给animal
    animal = [Cat new];
    [animal eat];
    animal = [Dog new];
    [animal eat];
    
    //把不同的子类对象都当做父类来看
    Animal *animalB = nil;
    animalB = [Cat new];
    [animalB eat];
    
    animalB = [Dog new];
    [animalB eat];
    
    /*
     开闭原则 和 里氏替换原则
     开闭原则(Open Close Principle  OCP)对扩展开放,对修改关闭
     里氏替换原则(Liskvo Substitution Principle  LSP)任何基类可以出现的地方,子类一定可以出现(基类就是已存在的用来派生新类的父类,也就是基类)
     */
    
    Person *person = [[Person alloc] init];
    
    Cat *cat = [Cat new];
    Dog *dog = [Dog new];
    
    [person feedCat:cat];
    [person feedDog:dog];
    
    [person feedAnimal:cat];
    [person feedAnimal:dog];
    //cat 和 dog 都是父类型Animal的指针,分别指向了子类型对象,然后当做参数传入了Person类中参数是Animal的-(void)feedAnimal:(Animal *)animal当中.这符合了里氏替换原则.
    return 0;
}

在Person.h文件里

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

@interface Person : NSObject

-(void)feedCat:(Cat *)cat;

-(void)feedDog:(Dog *)dog;

//参数是父类型动物类型,无论喂养什么动物,都可以满足我们需求,不用修改Person类,增加我们响应的方法.符合了"开闭原则"
-(void)feedAnimal:(Animal *)animal;


@end

在Person.m文件里

@implementation Person

-(void)feedCat:(Cat *)cat
{
    NSLog(@"人喂猫");
    [cat eat];
}

-(void)feedDog:(Dog *)dog
{
    NSLog(@"人喂狗");
    [dog eat];
}
-(void)feedAnimal:(Animal *)animal
{
    if ([animal isMemberOfClass:[Cat class]])
    {
        [animal eat];
        NSLog(@"cat cat!!");
    }
    if ([animal isMemberOfClass:[Dog class]])
    {
        [animal eat];
        NSLog(@"dog dog!!");
    }
}
@end

在Dog.h文件里

@interface Dog : Animal

@end

在Dog.m文件里

-(void)eat
{
    [super eat];
    NSLog(@"Dog eats meat!");
}
@end

在Cat.h文件里

@interface Cat : Animal

@end

在Cat.m文件里

-(void)eat
{
    [super eat];
    NSLog(@"Cat eats fish!");
}

@end

在Animal.h文件里

@interface Animal : NSObject

-(void)eat;

@end

在Animal.m文件里

@implementation Animal

-(void)eat
{
    NSLog(@"动物吃东西!");
}
@end

在SonB.h文件里

@interface SonB : Father

@end

在SonB.m文件里

@implementation SonB

-(void)sayHolle
{
    [super sayHolle];
    NSLog(@"I am SonB");
 
}

@end

在SonA.h文件里

@interface SonA : Father

@end

在SonA.m文件里

@implementation SonA

-(void)sayHolle
{

    [super sayHolle];
    NSLog(@"I am SonA");
    
}
@end

在Son.h文件里

//@inteface 类名:父类名,在OC中,使用冒号表示一个类继承了另一个类.冒号的含义是扩展,意味着子类出了继承父类的属性的方法外,还可以扩展出自己的特色属性和方法(一般情况下,我们继承于NSObject类,可以获取NSObject类中的大量有用的特性)
@interface Son : Father

@property(nonatomic,strong)NSString *homeAddress;

//自己的方法
-(void)race;

@end

在Son.m文件里

@implementation Son

//重新父类的charge方法
-(void)charge
{
    /*
     重新继承中的方法
     特点:
        1.发生在父类和子类之间
        2.方法名相同,参数列表相同,返回类型相同
     */
    NSLog(@"拿老爸的卡出了刷一下,