黑马程序员——多态

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1、设计一个类

#inport<Foundation/Foundation.h>

//声明
@interface Animal :NSObject

-(void)eat;

@end

@implementation Animal
//方法的实现

-(void)eat
{
NSObject（@"Animal eat"）;
}

@end

@interface Dog :Animal
@end

@implementation Dog

-(void)eat
{
NSObject（@"Dog eat"）;
}

@end

@interface Cat :Animal
@end

@implementation Cat

-(void)eat
{
NSObject（@"Cat eat"）;
}

@end

void feed(Dog *d)
{
[d eat];
}

int main（）
{
//多态：父类指针指向子类对象
Animal *a = [Animal new];
//当调用方法时，会检测对象的真时类型
[a eat];
}

 

输出结果：Dog eat

所以，NSObject *a = [Animal new];

      NSObject *b = [Dog new];

都是多态，当调用方法时会检测真实类型

但  Dog *a = [Animal new]; 和 子类之间：Dog *a = [Cat new];

和 没有父子关系的：NSstring *a = [Dog new]; 不会报错，只有警告

弱语法的体现，但都不合理。

2、把main改为:

int main()
{
Dog *dd = [Dog new];
feed(dd);
}

输出结果：Dog eat

3、把main改为:

int main()
{
Cat *cc = [Cat new];
//feed(cc);
}

这样写不行，因为feed定义时是（Dog *d），所以要想输出Cat eat可能会想再加一个feed

void feed1(Cat *c)
{
[c eat];
}

 

这样mai函数里写：feed1(cc);就行，这样写可以，但太冗余

所以，把feed 与 feed1改为一个feed函数：

void feed(Animal *a）
{
[a eat];
}
int main()
{
Dog *dd = [Dog new];
feed(dd);

Cat *cc = [Cat new];
feed(cc);

Animal *aa = [Animal new];
feed(aa);
}

 

输出结果：Dog eat

   Cat eat

   Animal eat

所以，如果参数中使用的是父类类型，可以传入父类、子类对象

若在Dog中声明和实现-（void）run方法

{
NSLog(@"Dog run");
}
则main函数中：
{
Animal *aa = [Dog new];
[aa run];
}

输出结果：编译有警告

因为Animal没有run方法，但一样能输出Dog run

所以多态的局限性：父类类型的变量不能用来调用子类的方法。

不建议用这种方法。

可以强制类型转换

{

Animal *aa = [Dog new];
Dog *dd =（Dog *）aa;
[dd run];
}

输出结果：Dog run

其中Dog *dd =（Dog *）aa;这句语句是强制类型转换（Dog *）是做给编译器看的，这句等价于Dog *dd = aa;

但这样写不合理，aa是Animal型的，赋给Dog型的，不合理。

所以需Dog *dd =（Dog *）aa这样写。

4、总结：

    1.没有继承就没有多态

    2.代码的体现：父类类型的指针指向子类对象

    3.好处：如函数\方法参数中使用的是父类类型，可传入父类、子类对象

    4.局限性：

 1>父类类型的变量不能直接调用

 2>子类特有的方法，必须强转换为子类类型变量后，才能直接调用子类特有的方法

5、以下是弱语法的体现，不要这样写，容错能力太强

{

 Dog *d = [Cat new];

 [d eat];

}

编译时有警告，运行时出结果：Cat eat

{

 NSstring *d = [Cat new];

 [d eat];

}

编译时有警告，运行时出结果：Cat eat