原文標題:OC學習篇之---類的三大特性(封裝，繼承，多態)

我們都知道，面向對象程序設計中的類有三大特性：繼承，封裝，多態，這個也是介紹類的時候，必須提到的話題，那麼今天就來看一下OC中類的三大特性：

一、封裝

封裝就是對類中的一些字段，方法進行保護，不被外界所訪問到，有一種權限的控制功能，Java中有四種訪問權限修飾符：

public，default，protected，private

訪問權限依次遞減，這樣我們在定義類的時候，哪些字段和方法不想暴露出去，哪些字段和方法可以暴露，可以通過修飾符來完成，這就是封裝，下面來看一個例子吧：

Car.h

//  Car.h  
//  05_ObjectDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import   
  
@interface Car : NSObject{  
    //這個屬性就是對外進行保密的相當於private，所以我們需要在外部訪問的話，必須定義get/set方法  
    //默認的是private的，但是我們可以使用@public設置為public屬性的,那麼在外部可以直接訪問：person->capcity = 2.8;  
    //當然我們一般不這麼使用，因為這會破壞封裝性，這種用法相當於C中的結構體中權限  
    //一共四種：@public,@protected,@private,@package,這個和Java中是相同的  
@public  
    float _capcity; //油量屬性  
}  
  
- (void)run:(float)t;  
  
@end

這裡我們可以看到，OC中也是有四種訪問權限修飾符：

@public、@protected、@private、@package

其中默認的修飾符是@private

但是這裡要注意的是：OC中的方法是沒有修飾符的概念的，這個和Java有很大的區別，一般都是公開訪問的，即public的，但是我們怎麼做到讓OC中的一個方法不能被外界訪問呢？

OC中是這麼做的，如果想讓一個方法不被外界訪問的話，只需要在.m文件中實現這個方法，不要在頭文件中進行定義，說白了就是：該方法有實現，沒定義，這樣外界在導入頭文件的時候，是沒有這個方法的，但是這個方法我們可以在自己的.m文件中進行使用。

為什麼要介紹這點知識呢？因為在後面我們會說到單利模式，到時候就會用到這個知識點了。

二、繼承

繼承是類中的一個重要的特性，他的出現使得我們沒必要別寫重復的代碼，可重用性很高。當然OC中的繼承和Java中是一樣的，沒多大區別，這裡在看一個例子吧：

首先來看一下父類：Car

Car.h

//  
//  Car.h  
//  06_ExtendDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import   
  
@interface Car : NSObject{  
    NSString *_brand;  
    NSString *_color;  
}  
  
- (void)setBrand:(NSString *)brand;  
- (void)setColor:(NSString *)color;  
- (void)brake;  
- (void)quicken;  
  
@end

在Car類中定義了兩個屬性，以及一些方法

Car.m

//  
//  Car.m  
//  06_ExtendDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Car.h"  
  
@implementation Car  
- (void)setBrand:(NSString *)brand{  
    _brand = brand;  
}  
- (void)setColor:(NSString *)color{  
    _color = color;  
}  
- (void)brake{  
    NSLog(@"剎車");  
}  
- (void)quicken{  
    NSLog(@"加速");  
}  
@end

方法的實現

在來看一下子類：

Taxi.h

//  
//  Taxi.h  
//  06_ExtendDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Car.h"  
  
@interface Taxi : Car{  
    NSString *_company;//所屬公司  
}  
  
//打印發票  
- (void)printTick;  
  
@end

看到Taxi類繼承了父類Car,這裡需要導入父類的頭文件，然後在Taxi類中多了一個屬性和方法

Taxi.m

//  
//  Taxi.m  
//  06_ExtendDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Taxi.h"  
  
@implementation Taxi  
  
- (void)printTick{  
    [super brake];  
    [self brake];  
    NSLog(@"%@出租車打印了發票，公司為:%@,顏色為:%@",_brand,_company,_color);  
}  
  
@end

 

對方法的實現，這裡我們看到實現文件中是不需要導入父類Car的頭文件的，因為可以認為，Taxi.h頭文件中已經包含了Car的頭文件了。而且，這裡可以使用super關鍵字來調用父類的方法，同時這裡我們也是可以用self關鍵字來調用，這裡看到其實這兩種方式調用的效果是一樣的，當我們在子類重新實現brake方法的時候(Java中的重寫概念)，那麼這時候super關鍵字調用的還是父類的方法，而self調用的就是重寫之後的brake方法了。同樣，我們也是可以使用父類中的屬性。

再看一下另外一個子類：

Truck.h

//  
//  Truck.h  
//  06_ExtendDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Car.h"  
//卡車類繼承Car  
@interface Truck : Car{  
    float _maxWeight;//最大載貨量  
}  
  
//覆蓋父類的方法brake  
//優先調用子類的方法  
- (void)brake;  
  
- (void)unload;  
  
@end

這裡就自己定義了一個brake方法，這時候就會覆蓋父類中的brake方法了。

Truck.m

//  
//  Truck.m  
//  06_ExtendDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Truck.h"  
  
@implementation Truck  
  
- (void)brake{  
    [super brake];  
    NSLog(@"Truck類中的brake方法");  
}  
  
- (void)unload{  
    [super brake];//調用父類的方法  
    [self brake];//也是可以的  
    NSLog(@"%@的卡車卸貨了，載貨量:%.2f,汽車的顏色:%@",_brand,_maxWeight,_color);  
}  
  
@end

這裡就可以看到，我們會在brake方法中調用一下父類的brake方法，然後在實現我們自己的邏輯代碼。

好了，繼承就說這麼多了，其實封裝和繼承兩個特性沒什麼難度的，很容易理解的，下面在來看一下最後一個特性：多態

三、多態

多態對於面向對象思想來說，個人感覺是真的很重要，他對以後的編寫代碼的優雅方式也是起到很重要的作用，其實現在很多設計模式中大部分都是用到了多態的特性，Java中的多態特性用起來很是方便的，但是C++中就很難用了，其實多態說白了就是：定義類型和實際類型，一般是基於接口的形式實現的，不多說了，直接看例子吧：

打印機的例子

抽象的打印機類Printer

Printer.h

//  
//  Printer.h  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import   
  
@interface Printer : NSObject  
  
- (void) print;  
  
@end

就是一個簡單的方法print

Printer.m

//  
//  Printer.m  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Printer.h"  
  
@implementation Printer  
  
- (void)print{  
    NSLog(@"打印機打印紙張");  
}  
  
@end

實現也是很簡單的

下面來看一下具體的子類

ColorPrinter.h

//  
//  ColorPrinter.h  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Printer.h"  
  
//修改父類的打印行為  
@interface ColorPrinter : Printer  
- (void)print;  
@end

ColorPrinter.m

//  
//  ColorPrinter.m  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "ColorPrinter.h"  
  
@implementation ColorPrinter  
  
- (void)print{  
    NSLog(@"彩色打印機");  
}  
  
@end

在看一下另外一個子類

BlackPrinter.h

BlackPrinter.m
//  
//  BlackPrinter.m  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "BlackPrinter.h"  
  
@implementation BlackPrinter  
  
- (void)print{  
    NSLog(@"黑白打印機");  
}  
  
@end

這裡我們在定義一個Person類，用來操作具體的打印機

Person.h 

Person.m
//  
//  Person.m  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import "Person.h"  
  
@implementation Person  
  
/* 
- (void) printWithColor:(ColorPrinter *)colorPrint{ 
    [colorPrint print]; 
} 
 
- (void) printWithBlack:(BlackPrinter *)blackPrint{ 
    [blackPrint print]; 
} 
 */  
  
- (void) doPrint:(Printer *)printer{  
    [printer print];  
}  
  
@end

再來看一下測試代碼：

main.m

//  
//  main.m  
//  07_DynamicDemo  
//  
//  Created by jiangwei on 14-10-11.  
//  Copyright (c) 2014年 jiangwei. All rights reserved.  
//  
  
#import   
  
#import "Person.h"  
#import "BlackPrinter.h"  
#import "ColorPrinter.h"  
  
int main(int argc, const charchar * argv[]) {  
    @autoreleasepool {  
          
        Person *person =[[Person alloc] init];  
          
        ColorPrinter *colorPrint = [[ColorPrinter alloc] init];  
        BlackPrinter *blackPrint = [[BlackPrinter alloc] init];  
          
        //多態的定義  
        /* 
        Printer *p1 = [[ColorPrinter alloc] init]; 
        Printer *p2 = [[BlackPrinter alloc] init]; 
         
        [person doPrint:p1]; 
        [person doPrint:p2]; 
         */  
          
        //通過控制台輸入的命令來控制使用哪個打印機  
        int cmd;  
        do{  
            scanf("%d",&cmd);  
            if(cmd == 1){  
                [person doPrint:colorPrint];  
            }else if(cmd == 2){  
                [person doPrint:blackPrint];  
            }  
        }while (1);  
          
    }  
    return 0;  
}

下面就來詳細講解一下多態的好處

上面的例子是一個彩色打印機和黑白打印機這兩種打印機，然後Person類中有一個操作打印的方法，當然這個方法是需要打印機對象的，如果不用多態機制實現的話(Person.h中注釋的代碼部分)，就是給兩種打印機單獨定義個操作的方法，然後在Person.m(代碼中注釋的部分)中用具體的打印機對象進行操作，在main.m文件中，我們看到，當Person需要使用哪個打印機的時候，就去調用指定的方法：

[person printWithBlack:blackPrint];//調用黑白打印機  
[person printWithColor:colorPrint];//調用彩色打印機

這種設計就不好了，為什麼呢？假如現在又有一種打印機，那麼我們還需要在Person.h中定義一種操作這種打印機的方法，那麼後續如果在添加新的打印機呢？還在添加方法嗎？那麼Person.h文件就會變得很臃腫。所以這時候多態就體現到好處了，使用父類類型，在Person.h中定義一個方法就可以了：

- (void) doPrint:(Printer *)printer;

這裡看到了，這個方法的參數類型就是父類的類型，這就是多態，定義類型為父類類型，實際類型為子類類型

- (void) doPrint:(Printer *)printer{  
    [printer print];  
}

這裡調用print方法，就是傳遞進來的實際類型的print方法。

Printer *p1 = [[ColorPrinter alloc] init];  
Printer *p2 = [[BlackPrinter alloc] init];  
          
[person doPrint:p1];  
[person doPrint:p2];

這裡的p1,p2表面上的類型是Printer，但是實際類型是子類類型，所以會調用他們自己對應的print方法。

從上面的例子中我們就可以看到多態的特新很是重要，當然也是三大特性中比較難理解的，但是在coding的過程中，用多了就自然理解了，沒必要去刻意的理解。