黑马程序员-继承，组合，super，多态

----------------------
ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------
继承的基本使用和好处
#import <Foundation/Foundation.h>

/*

 1.继承的好处：

 1>
抽取重复代码

 2>
建立了类之间的关系

 3>
子类可以拥有父类中的所有成员变量和方法

 4>不改变原来模型的基础上，拓充方法

 2.注意点

   基本上所有类的根类是NSObject,NSObject is a root class.

 */

 

/********Animal的声明*******/

//有相同的属性和行为，抽出一个父类Animal（先抽取weight属性，再抽取eat方法）

 

/*

 1.重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

 2.注意

 1>
父类必须声明在子类的前面(每个类里面有个指针指向父类叫做superclass)

 2>
子类不能拥有和父类相同的成员变量

 3>
调用某个方法时，优先去当前类中找，如果找不到，去父类中找

 

 2.坏处：耦合性太强

 */

 

@interface Animal : NSObject

{

    int _age;

    double _weight;

}

 

- (void)setAge:(int)age;

- (int)age;

 

- (void)setWeight:(double)weight;

- (double)weight;

 

- (void)run;

 

+ (void)test;

 

@end

 

/********Animal的实现*******/

@implementation Animal

- (void)setAge:(int)age

{

    _age = age;

}

- (int)age

{

    return _age;

}

 

- (void)setWeight:(double)weight

{

    _weight = weight;

}

- (double)weight

{

    return _weight;

}

 

- (void)run

{

   NSLog(@"Person-跑");

}

 

+ (void)test

{

   NSLog(@"Person+test");

}

 

@end

 

/********Dog*******/

//   继承了Animal，相当于拥有了Animal里面的所有成员变量和方法

// Animal称为Dog的父类

// Dog称为Animal的子类

 

@interface Dog : Animal

{

   //int _age;不允许子类和父类拥有相同名称的成员变量

   int _color;//子类在父类的基础上拓充属性和方法

}

 

+ (void)test2;

 

@end

 

@implementation Dog

 

// 重写：子类重新实现父类中的某个方法，覆盖父类以前的做法

- (void)run

{

    NSLog(@"Dog---跑");

}

 

+ (void)test2

{

    [self test];

//调用某个方法时，优先去当前类中找，如果找不到，去父类中找

}

@end

 

/********Cat*******/

@interface Cat : Animal

@end

 

@implementation Cat

@end

 

int main()

{

   Dog *d = [Dog new];//类方法new在NSObject

   

   [d setAge:10];

   

   NSLog(@"age=%d", [d age]);

   [d run];//结果是Person-跑。所以要重写方法。

    return 0;

}

 

关于继承的一些补充：

1，父类被继承了还是能照常使用的

2、NSObject的引出：全部OC类的最终父类，包含了一些常用方法，比如+new

3、父类\超类  superclass   子类  subclass\subclasses

继承的使用场合
/*继承的使用场合

当两个雷拥有相同属性和方法的时候就可以将相同的东西抽取到一个父类

它的所有属性都是你想要的，一般就继承

它的部分属性是你想要的，可以抽取出另一个父类

当A类中完全拥有B类中的部分属性和方法，可以考虑让B类继承A类

A

{

   int _age;

   int _no;

}

 

B

{

   //int _age;

   //int _no;

   int _weight;

}

*/

 

@interface Score : NSObject

{

   int _cScore;

   int _ocScore;

}

@end

 

@implementation Score

@end

 

//继承与组合的区别

//继承 ： XX 是 XX

//组合 ：XX 拥有 XX

 

@interface Student : NSObject

//@interface Student : Score 不符合现实常理，学生不可能是个成绩

 

{

   //用组合

  
Score *_score;

   //int _cScore;

   //int _ocScore;

 

   int _age;

}

@end

@implementation Student

@end

 

            
Super的使用

/*

僵尸

 

跳跃僵尸，舞王僵尸，铁桶僵尸

 

*/

#import <Foundation/Foundation.h>

/*

super的作用

1.直接调用父类中的某个方法

2.super处在对象方法中，那么就会调用父类对象方法，

 
super处在类方法中，那么就会调用父类类方法。

3.使用场合： 子类重写父类方法想保留父类一些行为；

*/

 

@interface Zoombie : NSObject

 

- (void)walk;

 

+ (void)test;

- (void)test;

 

@end

 

@implementation Zoombie

 

- (void)walk

{

   NSLog(@"往前挪来两步");

}

+ (void)test

{

   NSLog(@"Zoombie+test");

}

- (void)test

{

   NSLog(@"Zoombie-test");

}

 

@end

 

//跳跃僵尸

 

@interface JumpZoombie : Zoombie

 

- (void)walk;

+ (void)haha;

- (void)haha2;

@end

 

@implementation JumpZoombie

 

- (void)walk //super使用场合

{

   //跳两下

   NSLog(@"跳两下");

 

   //走两下

   //NSLog(@"往前挪来两步");这里是父类方法都有，用父类方法直接调用

   [super walk];//直接调用父类的walk方法

}

 

+ (void)haha

{

   [super test];//+,所以super找父类里面+方法；

}

 

- (void)haha2

{

   [super test];//-，super找父类-方法；

}

@end

 

int main()

{

   JumpZoombie *jz = [JumpZoombie new];

   [jz walk];

   [JumpZoombie haha];

   return 0;

}

 

 

#import <Foundation/Foundation.h>

/*多态

1，没有继承就没有多态，多态就是多种形态

2，代码提醒：父类类型的指针指向子类对象

3，好处：用一个父类指针变量就可以指向多个对象，如果函数\方法的参数中使用的是父类类型，可以传入父类子类对象。

4.局限性：父类类型的变量
不能 直接调用子类特有的方法，如果想调用，必须强制转为子类型变量后，才能直接调用。

*/

{

@interface Animal : NSObject

- (void)eat;

@end

 

@implementation Animal

- (void)eat

{

   NSLog(@"Animal吃东西");

}

@end

//狗

@interface Dog : Animal

 

- (void)eat;

- (void)run;

 

@end

 

@implementation Dog

- (void)eat

{

   NSLog(@"Dog吃东西");

}

 

- (void)run

{

   NSLog(@"Dog--跑起来");

}

 

@end

 

@interface Cat : Animal

- (void)eat；

@end

 

@implementation Cat

- (void)eat

{

   NSLog(@"Cat吃东西");

}

@end

 

//这个函数是专门用来喂狗

void feed(Dog *d)

{

   [d eat];

}

 

void feed2(Cat *c)

{

   [c eat];

}

/*上面两个函数代码重复性，Cat Dog拥有共同父类Animal.考虑用多态所以用下面的多态代码替换,节省代码*/

 

void feed(Animal *a)

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

{

   [a eat];

}

 

int main

 

{

   Animal *aa = [Dog new];//编译会认为aa是个Animal类型

   [aa run];

//运行为动态检测其真实类型是个Dog类型，编译跟运行在OC里是两码事。


  

   //局限性

 

   /*Dog *dd =[Dog new];

   feed(dd);

 

   Cat *cc = [Cat new];

   feed(cc);

  

   Animal *aa = [Animal new];

   feed(aa);

 

 

   NSObject *n = [Dog new];

   NSObject *n2 = [Animal new];

  

   //NSString *s = [Cat new];

   /*Cat *c = [Animal new];动物是猫不符合常理，但是是弱语法，只是警告。*/

   Animal *a = [Cat new];

  

   //多种形态

   Dog *d = [Dog new];//Dog 类型

   [d eat];

 

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

   Animal *a = [Dog new];

 

   [a eat];//调用方法时会动态检测对象的真实类型

  

   return 0;

}

----------------------
ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com