OC學習篇之---類的三大特性(封裝，繼承，多態) 分類： IOS 2014-12-04 22:20 5088人閱讀 評論(2) 收藏

以前的一片文章介紹了OC中類的初始化方法和點語法的使用：http://blog.csdn.net/jiangwei0910410003/article/details/41683873，今天來繼續學習OC中的類的三大特性，咱們在學習Java的時候都知道，類有三大特性：繼承，封裝，多態，這個也是介紹類的時候，必須提到的話題，那麼今天就來看一下OC中類的三大特性：

1、封裝

學習過Java中類的同窗可能都知道了，封裝就是對類中的一些字段，方法進行保護，不被外界所訪問到，有一種權限的控制功能，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 <Foundation/Foundation.h>

@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文件中進行使用。

爲何要介紹這點知識呢？由於在後面咱們會說到單利模式，到時候就會用到這個知識點了。

2、繼承

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

首先來看一下父類：Car

Car.h

//
//  Car.h
//  06_ExtendDemo
//
//  Created by jiangwei on 14-10-11.
//  Copyright (c) 2014年 jiangwei. All rights reserved.
//

#import <Foundation/Foundation.h>

@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方法，而後在實現咱們本身的邏輯代碼。

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

3、多態

多態對於面向對象思想來講，我的感受是真的很重要，他對之後的編寫代碼的優雅方式也是起到很重要的做用，其實如今不少設計模式中大部分都是用到了多態的特性，Java中的多態特性用起來非常方便的，可是C++中就很難用了，其實多態說白了就是：定義類型和實際類型，通常是基於接口的形式實現的，很少說了，直接看例子吧：

打印機的例子

抽象的打印機類Printer

Printer.h

//
//  Printer.h
//  07_DynamicDemo
//
//  Created by jiangwei on 14-10-11.
//  Copyright (c) 2014年 jiangwei. All rights reserved.
//

#import <Foundation/Foundation.h>

@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.h
//  07_DynamicDemo
//
//  Created by jiangwei on 14-10-11.
//  Copyright (c) 2014年 jiangwei. All rights reserved.
//

#import "Printer.h"

@interface BlackPrinter : Printer

- (void)print;

@end

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.h
//  07_DynamicDemo
//
//  Created by jiangwei on 14-10-11.
//  Copyright (c) 2014年 jiangwei. All rights reserved.
//

#import <Foundation/Foundation.h>

#import "ColorPrinter.h"
#import "BlackPrinter.h"

//擴展性不高，當咱們須要添加一個新的打印機的時候還要定義對應的一個方法
//因此這時候就可使用多態技術了

@interface Person : NSObject{
    NSString *_name;
}

//- (void) printWithColor:(ColorPrinter *)colorPrint;

//- (void) printWithBlack:(BlackPrinter *)blackPrint;

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

@end

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 <Foundation/Foundation.h>

#import "Person.h"
#import "BlackPrinter.h"
#import "ColorPrinter.h"

int main(int argc, const char * 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的過程當中，用多了就天然理解了，不必去刻意的理解。

總結

這篇文章主要介紹了類的三大特性：封裝、繼承、多態，這三個特性也是後面學習面向對象的重要基礎。