【學習筆記】【OC語言】繼承

1.繼承的基本用法

 1 #import <Foundation/Foundation.h>
 2 /*
 3  1.繼承的好處：
 4  1> 抽取重複代碼
 5  2> 創建了類之間的關係
 6  3> 子類能夠擁有父類中的全部成員變量和方法
 7  
 8  2.注意點
 9  1> 基本上全部類的根類是NSObject
10  */
11 
12 
13 /********Animal的聲明*******/
14 @interface Animal : NSObject
15 {
16     int _age;
17     double _weight;
18 }
19 
20 - (void)setAge:(int)age;
21 - (int)age;
22 
23 - (void)setWeight:(double)weight;
24 - (double)weight;
25 @end
26 
27 /********Animal的實現*******/
28 @implementation Animal
29 - (void)setAge:(int)age
30 {
31     _age = age;
32 }
33 - (int)age
34 {
35     return _age;
36 }
37 
38 - (void)setWeight:(double)weight
39 {
40     _weight = weight;
41 }
42 - (double)weight
43 {
44     return _weight;
45 }
46 @end
47 
48 /********Dog*******/
49 // : Animal 繼承了Animal，至關於擁有了Animal裏面的全部成員變量和方法
50 // Animal稱爲Dog的父類
51 // Dog稱爲Animal的子類
52 @interface Dog : Animal
53 @end
54 
55 @implementation Dog
56 @end
57 
58 /********Cat*******/
59 @interface Cat : Animal
60 @end
61 
62 @implementation Cat
63 @end
64 
65 int main()
66 {
67     Dog *d = [Dog new];
68     
69     [d setAge:10];
70     
71     NSLog(@"age=%d", [d age]);
72     return 0;
73 }

子類方法和屬性的訪問過程：若是子類沒有，就去訪問父類的
父類被繼承了仍是能照常使用的
父類的靜態方法
畫繼承結構圖，從子類抽取到父類
NSObject的引出：所有OC類的最終父類，包含了一些經常使用方法，好比+new

2.繼承的專業術語
父類\超類  superclass
子類  subclass\subclasses

3.繼承的細節
單繼承
子類和父類不能有相同的成員變量
方法的重寫

4.super關鍵字
分別調用父類的對象方法和類方法

 1 /*
 2  殭屍
 3  
 4  跳躍殭屍、舞王殭屍、鐵桶殭屍
 5  */
 6 #import <Foundation/Foundation.h>
 7 
 8 /*
 9  super的做用
10  1.直接調用父類中的某個方法
11  2.super處在對象方法中，那麼就會調用父類的對象方法
12    super處在類方法中，那麼就會調用父類的類方法
13  
14  3.使用場合：子類重寫父類的方法時想保留父類的一些行爲
15  */
16 
17 // 殭屍
18 @interface Zoombie : NSObject
19 - (void)walk;
20 
21 + (void)test;
22 - (void)test;
23 
24 @end
25 
26 @implementation Zoombie
27 - (void)walk
28 {
29     NSLog(@"往前挪兩步******");
30 }
31 
32 + (void)test
33 {
34     NSLog(@"Zoombie+test");
35 }
36 
37 - (void)test
38 {
39     NSLog(@"Zoombie-test");
40 }
41 @end
42 
43 // 跳躍殭屍
44 @interface JumpZoombie : Zoombie
45 + (void)haha;
46 - (void)haha2;
47 @end
48 
49 
50 @implementation JumpZoombie
51 
52 + (void)haha
53 {
54     [super test];
55 }
56 
57 - (void)haha2
58 {
59     [super test];
60 }
61 
62 - (void)walk
63 {
64     // 跳兩下
65     NSLog(@"跳兩下");
66     
67     // 走兩下(直接調用父類的walk方法)
68     [super walk];
69     //NSLog(@"往前挪兩步----");
70 
71 }
72 @end
73 
74 int main()
75 {
76     //[JumpZoombie haha];
77     JumpZoombie *jz = [JumpZoombie new];
78     
79     [jz haha2];
80     
81     return 0;
82 }

5.繼承的好處
不改變原來模型的基礎上，拓充方法
創建了類與類之間的聯繫
抽取了公共代碼
壞處：耦合性強

6.繼承的使用場合
它的全部屬性都是你想要的，通常就繼承
它的部分屬性是你想要的，能夠抽取出另外一個父類

7.代碼

 1 /*
 2  1.重寫：子類從新實現父類中的某個方法，覆蓋父類之前的作法
 3  2.注意
 4  1> 父類必須聲明在子類的前面
 5  2> 子類不能擁有和父類相同的成員變量
 6  3> 調用某個方法時，優先去當前類中找，若是找不到，去父類中找
 7  
 8  2.壞處：耦合性太強
 9  */
10 
11 #import <Foundation/Foundation.h>
12 // Person
13 @interface Person : NSObject
14 {
15     int _age;
16 }
17 
18 - (void)setAge:(int)age;
19 - (int)age;
20 
21 - (void)run;
22 
23 + (void)test;
24 
25 @end
26 
27 @implementation Person
28 
29 + (void)test
30 {
31     NSLog(@"Person+test");
32 }
33 
34 - (void)run
35 {
36     NSLog(@"person---跑");
37 }
38 
39 - (void)setAge:(int)age
40 {
41     _age = age;
42 }
43 - (int)age
44 {
45     return _age;
46 }
47 @end
48 
49 // 不容許子類和父類擁有相同名稱的成員變量
50 // Student
51 @interface Student : Person
52 {
53     int _no;
54     // int _age;
55 }
56 
57 + (void)test2;
58 
59 @end
60 
61 @implementation Student
62 // 重寫：子類從新實現父類中的某個方法，覆蓋父類之前的作法
63 - (void)run
64 {
65     NSLog(@"student---跑");
66 }
67 
68 + (void)test2
69 {
70     [self test];
71 }
72 @end
73 
74 
75 int main()
76 {
77     [Student test2];
78     
79 //    Student *s = [Student new];
80 //    
81 //    [s run];
82     
83     return 0;
84 }

繼承的使用場合

 1 /*
 2 1.繼承的使用場合
 3  1> 當兩個類擁有相同屬性和方法的時候，就能夠將相同的東西抽取到一個父類中
 4  2> 當A類徹底擁有B類中的部分屬性和方法時，能夠考慮讓B類繼承A類
 5  A
 6  {
 7     int _age;
 8     int _no;
 9  }
10  
11  B : A
12  {
13     int _weight;
14  }
15  
16  // 繼承：xx 是 xxx
17  // 組合：xxx 擁有 xxx
18  
19  2.組合
20  A
21  {
22      int _age;
23      int _no;
24  }
25  
26  B
27  {
28      A *_a;
29      int _weight;
30  }
31 */
32 
33 @interface Score : NSObject
34 {
35     int _cScore;
36     int _ocScore;
37 }
38 @end
39 
40 @implementation Score
41 @end
42 
43 @interface Student : NSObject
44 {
45     // 組合
46     Score *_score;
47 //    int _cScore;
48 //    int _ocScore;
49     int _age;
50 }
51 @end
52 
53 @implementation Student
54 
55 @end