我們都知道，面向對象程序設計中的類有三大特性：繼承，封裝，多態，這三大特性是學習類的時候，必須理解的問題，既是基礎，也是重點。
一、封裝（Encapsulation）
封裝是指利用抽象數據類型將數據和基于數據的操作封裝在一起，使其構成一個不可分割的獨立實體，數據被保護在抽象數據類型的內部，盡可能地隱藏內部的細節，只保留一些對外接口使之與外部發生聯系。即對類中的一些字段、方法進行保護，不被外界訪問到，有一種權限的控制能力，Java中有四種訪問權限修飾符：public、default、protected、private，它們的訪問權限依次遞減，這樣我們在定義類的時候，哪些字段和方法不想暴露出去，哪些字段和方法可以暴露，可以通過不同修飾符來區分，這就是封裝。
舉例說明：
#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;
@end
這里我們可以看到，OC中也有四種權限修飾符：@public、@protected、@private、@package
其中默認的修飾符是@private。
但是這里要注意的是，OC中的方法是沒有修飾符的概念的，這與其它語言有所區別，一般都是公開訪問的，即public的。在OC中，若需要做到讓一個方法不能被外界訪問，只需要在.m文件中實現這個方法，不要在圖文件中進行定義，簡言之，就是該方法有實現而沒有定義，這樣外界在倒入頭文件的時候，是沒有這個方法的，這個方法只可以在自己的.m文件中使用。
二、繼承
繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。 即子類繼承父類的一種方式，子類可對父類進行擴展，父類變了，子類也跟著變。繼承是類中的一個重要特性，其作用在于避免寫重復的代碼，可重用性很高，繼承的目的是為了減少代碼的冗余，還是DRY原則（don`t repeat yourself)。
在Car.h中，在Car類中定義了兩個屬性，以及一些方法：
#import
@interface Car : NSObject{
NSString *_brand;
NSString *_color;
}
- (void)setBrand:(NSString *)brand;
- (void)setColor:(NSString *)color;
- (void)brake;
- (void)quicken;
@end
在Car.m方法中：
#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中，我們可以對Car的方法進行繼承。
Taxi.h文件中：
#import "Car.h"
@interface Taxi : Car{
NSString *_company;//所屬公司
}
//打印發票
- (void)printTick;
@end
Taxi類繼承了父類Car,這里需要導入父類的頭文件，然后在Taxi類中多了一個屬性和方法，與父類一致的方法則繼承或改寫。
Taxi.m文件中：
#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:
在Truck.h中：
#import "Car.h"
//卡車類繼承Car
@interface Truck : Car{
float _maxWeight;//最大載貨量
}
//覆蓋父類的方法brake
//優先調用子類的方法
- (void)brake;
- (void)unload;
@end
這里就自己定義了一個brake方法，這時候就會覆蓋父類中的brake方法了。
在Truck.m中：
#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:
#import
@interface Printer : NSObject
- (void) print;
@end
Printer.m:
#import "Printer.h"
@implementation Printer
- (void)print{
NSLog(@"打印機打印紙張");
}
@end
實現也是很簡單的,下面來看一下具體的子類ColorPrinter:
ColorPrinter.h:
#import "Printer.h"
//修改父類的打印行為
@interface ColorPrinter : Printer
- (void)print;
@end
ColorPrinter.m
ColorPrinter.m:
#import "ColorPrinter.h"
@implementation ColorPrinter
- (void)print{
NSLog(@"彩色打印機");
}
@end
再看一下另一個子類：
BlackPrinter.m:
#import "BlackPrinter.h"
@implementation BlackPrinter
- (void)print{
NSLog(@"黑白打印機");
}
@end
這里我們在定義一個Person類，用來操作具體的打印機。
Person.m:
#import "Person.h"
@implementation Person
/*
- (void) printWithColor:(ColorPrinter *)colorPrint{
[colorPrint print];
}
- (void) printWithBlack:(BlackPrinter *)blackPrint{
[blackPrint print];
}
*/
- (void) doPrint:(Printer *)printer{
[printer print];
}
@end
再來看一下測試代碼：
Person.h:
#import "Person.h"
@implementation Person
/*
- (void) printWithColor:(ColorPrinter *)colorPrint{
[colorPrint print];
}
- (void) printWithBlack:(BlackPrinter *)blackPrint{
[blackPrint print];
}
*/
- (void) doPrint:(Printer *)printer{
[printer print];
}
@end
Person.m:
#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方法。
