OC面向对象多态笔记

面向对象的多态是建立在继承上，可以说没有继承就没有多态；

多态：父类指针指向了子类的对象；

 int main()
 {
       //假设已定义了Animal类和它的子类Dog，那么多态的代码体现就是
         Animal *a = [Dog d];//父类指针指向了子类对象

 }

多态的定义是比较简单的，也好理解，关键在于它的指针动态绑定，究竟调用哪个方法；

 #import <Foundation/Foundation.h>

 //Animal类的声明
 @interface Animal : NSObject
 {
     int _legs;
 }

 - (void)eat;
 - (void)run;
 @end

 //Animal类的实现
 @implementation Animal
 - (void)eat
 {
     NSLog(@"动物在吃东西");

 }

 - (void)run
 {
     NSLog(@"动物在跑");
 }

 @end

 //子类Dog 继承 Animal
 @interface Dog : Animal

 @end
 //子类dog的实现
 @implementation Dog
 //方法的覆盖或叫重写
 - (void)eat
 {
     NSLog(@"狗在吃东西");
 }
 @end

 int main()
 {

     Animal *a = [Dog new];//虽然表面上是一个Animal指针，但是动态绑定后，实际上它指向的是Dog类型的
     [a eat];//动态绑定后，输出的时狗在吃东西，即狗的eat方法

 }

这样就看到了多态的好处，当有两个方法的参数都是对象，且有共同的父类时，这两个方法可以写成一个方法，只需把参数改为父类对象就可以了

//已经定义了Dog，Cat两个类，他们都继承了Animal方法，且定义了eat方法，子类都重写了eat方法
//喂猫吃东西的方法
void catEat(Cat *c)
{
     [c eat];
}
//喂狗吃东西的方法
void dogEat(Dog *d)
{
     [d eat];
}

/******那么这两个方法就比较冗余了，可以用一个方法代替*******/

void animalEat(Animal *a)
{
        [a eat];
}

　　虽然多态用起来减少了代码的冗余，但是由于OC弱类型编程语言的容错能力强，局限性也很明显

1:父类对象不能调用子类的特有方法，但是真得调用了，也只是一个警告，照样能够运行起来；可以用类型转换，将父类对象转成子类的对象

语法：

Animal *aa = [Dog new];
//注意强转的格式带*号
Dog *dd = (Dog *)aa;//这里的强转也只是给编译器看得，不写，也能运行，只不过编译时一个警告；

2:一个类的指针能指向一个和本类好无关系的对象，编译只是一个警告，照样能调用其中的方法；

NSString *ns = [Dog new];
[ns eat];//只是警告，但是能运行，不建议这样写；