1、封裝php
封裝就是對類中的一些字段,方法進行保護,不被外界所訪問到,有一種權限的控制功能,Java中有四種訪問權限修飾符:html
1
|
public,
default
,protected,private
|
訪問權限依次遞減,這樣咱們在定義類的時候,哪些字段和方法不想暴露出去,哪些字段和方法能夠暴露,能夠經過修飾符來完成,這就是封裝,下面來看一個例子吧:ios
Car.h程序員
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
// 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中也是有四種訪問權限修飾符:web
1
|
@public、@protected、@private、@package
|
其中默認的修飾符是@private面試
可是這裏要注意的是:OC中的方法是沒有修飾符的概念的,這個和Java有很大的區別,通常都是公開訪問的,即public的,可是咱們怎麼作到讓OC中的一個方法不能被外界訪問呢?編程
OC中是這麼作的,若是想讓一個方法不被外界訪問的話,只須要在.m文件中實現這個方法,不要在頭文件中進行定義,說白了就是:該方法有實現,沒定義,這樣外界在導入頭文件的時候,是沒有這個方法的,可是這個方法咱們能夠在本身的.m文件中進行使用。swift
爲何要介紹這點知識呢?由於在後面咱們會說到單利模式,到時候就會用到這個知識點了。設計模式
2、繼承微信
繼承是類中的一個重要的特性,他的出現使得咱們不必別寫重複的代碼,可重用性很高。固然OC中的繼承和Java中是同樣的,沒多大區別,這裏在看一個例子吧:
首先來看一下父類:Car
Car.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
//
// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
//
// 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須要使用哪一個打印機的時候,就去調用指定的方法:
1
2
|
[person printWithBlack:blackPrint];
//調用黑白打印機
[person printWithColor:colorPrint];
//調用彩色打印機
|
這種設計就很差了,爲何呢?假如如今又有一種打印機,那麼咱們還須要在Person.h中定義一種操做這種打印機的方法,那麼後續若是在添加新的打印機呢?還在添加方法嗎?那麼Person.h文件就會變得很臃腫。因此這時候多態就體現到好處了,使用父類類型,在Person.h中定義一個方法就能夠了:
1
|
- (void) doPrint:(Printer *)printer;
|
這裏看到了,這個方法的參數類型就是父類的類型,這就是多態,定義類型爲父類類型,實際類型爲子類類型
1
2
3
|
- (void) doPrint:(Printer *)printer{
[printer print];
}
|
這裏調用print方法,就是傳遞進來的實際類型的print方法。
1
2
3
4
5
|
Printer *p1 = [[ColorPrinter alloc] init];
Printer *p2 = [[BlackPrinter alloc] init];
[person doPrint:p1];
[person doPrint:p2];
|
這裏的p1,p2表面上的類型是Printer,可是實際類型是子類類型,因此會調用他們本身對應的print方法。
從上面的例子中咱們就能夠看到多態的特新非常重要,固然也是三大特性中比較難理解的,可是在coding的過程當中,用多了就天然理解了,不必去刻意的理解。