OC继承

一、成员访问类型

private：私有成员，不能被外部函数访问（使用），也不能被子类继承；

protected：保护成员，不能被外部函数访问，能够被子类继承；

public：公有成员，能够被外部函数访问，也能够被子类继承。

OC中，全部的方法（消息），都是公有的。

二、重写（继承的另外一部分）

子类能够从父类继承方法，可是有时候父类的方法不适合子类，子类就能够写一个本身的同名方法，覆盖掉父类的同名方法，叫作重写。

重写的时候，在子类的.h中没必要从新声明，直接在.m中写实现就能够。

 1 //父类声明文件
 2 #import <Foundation/Foundation.h>
 3 @interface Father : NSObject
 4 -(void)run;
 5 -(void)jump;
 6 @end
 7 
 8 //父类实现文件
 9 #import "Father.h"
10 @implementation Father
11 -(void)run{
12     NSLog(@"he is running!");
13     return;
14 }
15 -(void)jump{
16     NSLog(@"father can jump 1.2m");
17 }
18 @end

 1 //子类声明文件
 2 #import "Father.h"
 3 
 4 @interface Son : Father
 5 
 6 @end
 7 
 8 //子类实现文件
 9 #import "Son.h"
10 
11 @implementation Son
12 -(void)jump{
13      NSLog(@"he can jump 0.6m");
14 }
15 @end

其中，子类重写父类的jump方法，不须要从新声明。

同一个方法，不一样的实现，称为多态。重写是多态的一种。

继承的好处：

　　1）建立大量的类似类的时候，能够节省工做量。

　　2）使用框架中的类，或已经写好的类，继承该类，生成一个派生类，比原类更好用。

注意：NSString、NSArray、NSDictionary都是不可以继承的。

三、虚方法

OC的方法都是虚方法

　　1）父类的指针能够指向子类的对象

1 Son * son = [[Son alloc] init];
2 Father * p = son;

上面p和son都指向子类的对象；调用方法时，不看指针，看对象，对象的地址指向什么对象，就调用什么方法，称为虚方法。

　　2）调用方法时，不看指针看对象，这样的方法叫作虚方法。虚方法的好处：能够描述不一样事物被相同事件触发，产生不一样的响应（结果）。体会下面的例子

动物的父类声明与实现

1 //动物类声明
2 #import <Foundation/Foundation.h>
3 @interface Animal : NSObject
4 -(void)beBeaten;
5 @end

1 //动物类实现
2 #import "Animal.h"
3 @implementation Animal
4 -(void)beBeaten{
5     return;      //该方法须要子类实现，因此父类不须要写任何实现代码
6 }
7 @end

子类（狗）的声明与实现

1 #import "Animal.h"
2 
3 @interface Dog : Animal
4 
5 @end

1 #import "Dog.h"
2 
3 @implementation Dog
4 //该方法在父类已经声明，因此子类不须要重复声明
5 -(void)beBeaten{
6     NSLog(@"wang,wang...");
7 }
8 @end

子类（猫）的声明与实现

1 #import "Animal.h"
2 
3 @interface Cat : Animal
4 
5 @end

1 #import "Cat.h"
2 
3 @implementation Cat
4 //该方法在父类已经声明，因此子类不须要重复声明
5 -(void)beBeaten{
6 NSLog(@"miao,miao...");
7 }
8 @end

人类的声明与实现

1 #import <Foundation/Foundation.h>
2 #import "Animal.h"
3 @interface Human : NSObject
4 //调用该方法，此处只写一个父类的指针就能够，这是利用了父类的虚方法；
5 //否则，须要写多个方法实现：beatAnimal:(Dog *)dog;beatAnimal:(Cat *)cat;打不一样的动物须要传不一样的对象，因此利用虚方法、父类的指针是很是方便的
6 -(void)beatAnimal:(Animal*)animal;
7 @end

1 #import "Human.h"
2 
3 @implementation Human
4 -(void)beatAnimal:(id)animal{
5     NSLog(@"Human beat the %@",[animal class]);
6     [animal beBeaten];
7 }
8 @end

 1 Dog * dog = [[Dog alloc] init];
 2 Cat * cat = [[Cat alloc] init];
 3 Human * xiaoming = [[Human alloc] init];
 4 [xiaoming beatAnimal:dog];
 5 [xiaoming beatAnimal:cat];
 6 //输出：
 7 //2013-09-29 15:51:00.604 OC[752:303] Human beat the Dog
 8 //2013-09-29 15:51:00.619 OC[752:303] wang,wang...
 9 //2013-09-29 15:51:00.620 OC[752:303] Human beat the Cat
10 //2013-09-29 15:51:00.621 OC[752:303] miao,miao...

 

结题！！！