黑马程序员-----类方法学习引入

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -----

第一讲 类方法学习引入

本小节知识点：

1、【了解】类方法学习思考

2、【了解】实现OC版计算器

思考&实现1：

设计一个“计算器（Calculator）”类

1）实现两个书的 + - * / 的计算

思考：

首先创建一个类

类名：Calculator

属性：第一个数 num1 第二个数 num2 运算结果 result

1 #import <Foundation/Foundation.h>
2 //第一种方法
3 @interface Caculator : NSObject
4 {
5     @public
6    //定义实例变量
7     int _num1;
8     int _num2;
9     float _result;
10 }
11  //四个方法
12 -(void)add;
13 -(void)jian;
14 -(void)cheng;
15 -(void)chu;
16 @end
17 #import "Caculator.h"
18
19 @implementation Caculator
20 -(void)add{
21     _result = _num1 +_num2;
22
23 }
24 -(void)jian{
25  _result = _num1 -_num2;
26 }
27 -(void)cheng{
28
29  _result = _num1 *_num2;
30 }
31 -(void)chu{
32
33    _result = _num1 /(float)_num2;
34 }
35 @end
36
37 //第二种方法 声明类
38 @interface Calculator2 : NSObject
39 //四个方法
40 -(int)add:(int) num1 andNum2:(int) num2;
41 -(int )jian:(int) num1 andNum2:(int) num2;
42 -(int)cheng:(int) num1 andNum2:(int) num2;
43 -(float)chu:(int) num1 andNum2:(int) num2;
44 @end
45
46 #import "Calculator2.h"
47
48 @implementation Calculator2
49 //四个方法
50 -(int)add:(int) num1 andNum2:(int) num2{
51     return num1 + num2;
52 }
53 -(int)jian:(int) num1 andNum2:(int) num2{
54 return num1 - num2;
55
56 }
57 -(int)cheng:(int) num1 andNum2:(int) num2{
58 return num1 * num2;
59 }
60 -(float)chu:(int) num1 andNum2:(int) num2{
61 return num1 /(float) num2;
62 }
63 @end
64
65
66 #import <Foundation/Foundation.h>
67 #import "Caculator.h"
68 #import "Calculator2.h"
69 int main(int argc, const char * argv[])
70 {
71
72     @autoreleasepool {
73
74 //        //创建对象
75 //        Caculator *cal = [Caculator new];
76 //        cal->_num1 = 10;
77 //        cal->_num2 = 3;
78 //
79 //        //加法
80 //        [cal add];
81 //        NSLog(@"%.2f",cal->_result);
82 //        [cal jian];
83 //        NSLog(@"%.2f",cal->_result);
84 //        [cal cheng];
85 //        NSLog(@"%.2f",cal->_result);
86 //        [cal  chu];

87 //        NSLog(@"%.2f",cal->_result);
88
89         //第二种方法
90         Calculator2 *c2 = [Calculator2 new];
91
92         int result = [c2 add:12 andNum2:34];
93         int result2 = [c2 cheng:3 andNum2:10];
94         NSLog(@"%d",result);
95         NSLog(@"%d",result2);
96     }
97     return 0;
98
99 }

第二讲 类方法的调用

本小节知识点：

1、【理解】类方法概述

2、【理解】类方法的调用

Objective-C中的类可以声明两种类型的方法：实例方法和类方法。

1、类方法概述

实例方法就是一个方法，它在类的一个具体实例的范围内执行。也就是说，在你调用一个实例方法前，你必须首先创建类的一个实例。（也叫对象方法）

[对象名 对象方法名];

而类方法，比较起来，也就是说，不需要你创建一个实例。

+表示类方法，就是类调用方法，不依赖与任何对象的方法。

-表示是实例（对象）方法，只能是对象可调用，依赖与任何对象的方法。

2、类方法的调用

[类名称 类方法名称];

#import <Foundation/Foundation.h>

@interface Caculator : NSObject

//四个方法

-(int)add:(int) num1 andNum2:(int) num2;

-(int )jian:(int) num1 andNum2:(int) num2;

-(int)cheng:(int) num1 andNum2:(int) num2;

-(float)chu:(int) num1 andNum2:(int) num2;

//四个方法

+(int)add:(int) num1 andNum2:(int) num2;

+(int )jian:(int) num1 andNum2:(int) num2;

+(int)cheng:(int) num1 andNum2:(int) num2;

+(float)chu:(int) num1 andNum2:(int) num2;

@end

#import "Caculator.h"

@implementation Caculator

//四个方法对象方法

-(int)add:(int) num1 andNum2:(int) num2{

return num1 + num2;

}

-(int)jian:(int) num1 andNum2:(int) num2{

return num1 - num2;

}

-(int)cheng:(int) num1 andNum2:(int) num2{

return num1 * num2;

}

-(float)chu:(int) num1 andNum2:(int) num2{

return num1 /(float) num2;

}

//类方法的实现

//四个方法

+(int)add:(int) num1 andNum2:(int) num2{

return num1 + num2;

}

+(int)jian:(int) num1 andNum2:(int) num2{

return num1 - num2;

}

+(int)cheng:(int) num1 andNum2:(int) num2{

return num1 * num2;

}

+(float)chu:(int) num1 andNum2:(int) num2{

return num1 /(float) num2;

}

@end

1 /*
2    类方法：
3
4         ＋开头的方法（定义的过程和对象方法一致，只不过 ＋ 开头）
5
6    类方法的调用：
7
8        [类名  方法名];
9
10     对比学习：
11     Dog类
12       -(void)run;
13     想调用 run方法，
14     1. Dog *dog = [Dog new];
15
16        [dog run];
17
18       Dog类
19
20      +(void)run; //类方法
21
22      想调用run方法，
23      [Dog run];
24  */
25
26
27 #import <Foundation/Foundation.h>
28 #import "Caculator.h"
29 int main(int argc, const char * argv[])
30 {
31
32     @autoreleasepool {
33         Caculator *ca1 = [Caculator new];
34         //通过ca1对象调用其对象方法
35         int result = [ca1 add:23 andNum2:34];
36
37         NSLog(@"result = %d",result);
38         //通过类名调用类方法
39         result = [Caculator add:10 andNum2:20];
40         NSLog(@"result = %d",result);
41
42
43     }
44     return 0;
45 }

第三讲 类方法的使用注意事项

【理解】类方法的使用注意事项

1、类方法可以和实例方法同名，这个并不影响使用，实例方法由实例对象访问调用，类方法要通过类里访问调用，不会有交叉相互影响。

2、类方法也可以是从父类继承而来，子类可以重写类方法，如description类方法就可以在子类里重新定义这个方法。

3、类方法和实例方法一样在interface里声明，在implementation里实现

4、类方法只能被向类发送类方法消息才被执行，向实例对象发送类方法是不能被触发执行的。

5、在类方法里使用了self，这个self执行的类对象class object而不是实例对象instance object

1 #import <Foundation/Foundation.h>
3 @interface Dog : NSObject
6     -(void)run;
7     +(void)run;
8     +(void)eat:( NSString *)foodName;
9
10 @end
11
12 #import "Dog.h"
13
14 @implementation Dog
15 -(void)run{
16     NSLog(@"对象方法 ------- 狗正在疯跑!");
18 }
19 +(void)run{
20     NSLog(@"类方法  ---   狗正在疯跑!");
22 }
23 +(void)eat:(NSString *)foodName{
24
25     NSLog(@"狗正在吃%@",foodName);
26 }
28 @end
31 #import <Foundation/Foundation.h>
32 #import "Dog.h"
33 int main(int argc, const char * argv[])
34 {
35
36     @autoreleasepool {
37         Dog *dog = [Dog new];
38         [dog run]; //对象方法
39         [Dog run]; //类方法
40
41         [Dog eat:@"一根热乎乎的热狗"];
42     }
43     return 0;
44 }

第四讲 类方法易犯的错误

本小节知识点：

1、【理解】类方法的优点

2、【掌握】类方法的易犯错误

3、【理解】类方法和对象方法的比较

1、类方法的优点：

1）节省内存空间

2）提高了效率

3）作为工具方法

2、类方法的易犯错误

1、在类方法中使用了类的成员变量

//通过类方法实现两个数的平均值

+(float) avgNum1:(int)num1 andNum2:(int)num2{

//调用类方法计算两个数的和

return -result/2.0f; // 注意： 类方法中不能使用类的成员变量

}

//通过实例方法实现两个数的平均值

-(float)avg{

//调用类方法计算两个数的和

return _result/2.0f; //注意：在实例方法中可以使用类的成员变量

}

3、类方法与对象方法比较

1）对象方法：

以 - 号开头

可以使用成员变量

用对象调用对象方法

对象方法可以调用当前对象或者其他对象的方法(是通过将对象作为参数传入方法)

1 #import <Foundation/Foundation.h>
2 #import "Dog.h"
3
4 @interface Car : NSObject
5 {
6    @public
7     int _speed;
8 }
9 -(void)run;
10 -(void)test;
11 +(void)run;
12 +(void)run:(int)speed;
13 +(void)test:(Dog *)dog;
14 +(void)t1;
15 @end
16
17 //
18
19 #import "Car.h"
20
21 @implementation Car
22 -(void)run{
23
24      NSLog(@"车正在以%d码的速度跑",_speed);
25     //对象方法中可以调用其他的对象方法
26     //1）当前对象方法中创建对象(可以是当前类的实例对象，也可以是其他类的实例对象)，使用新创建的对象调用对象方法
27     //    Car *car1 = [Car new];
28     //    [car1 test];
29     //    其他的实例对象
30     //    Person *p = [Person new];
31     //    [p eat];
32     //2）可以使用self
33        [self test];
34     //3）对象作为方法的参数传递过来，可以使用传递过来的对象调用方法
35
36 }
37 -(void)test{
38
39     NSLog(@"test------");
40 }
41 +(void)run{
42 ///Volumes/VMware Shared Folders/自学视频基础笔记/视频第十八天的课程/OC6-类方法易犯错误/Car.m:17:44: Instance variable '_speed' accessed in class method
43
44     //类方法里面访问了实例变量，这是不允许的，
45     // NSLog(@"车正在以%d码的速度跑",_speed);
46     NSLog(@"类方法－－－车正在跑");
47
48     //在类方法中可以调用其他类方法
49     //1）可以直接使用本类类名(或者其他类名)调用类方法
50     [Car run:250];
51     [Dog run];
52     //可以使用self吗?
53     [self run:100];
54
55 }
56 +(void)run:(int)speed{
57     NSLog(@"类方法－－－车正在以%d码的速度跑",speed);
58
59 }
60 +(void)test:(Dog *)dog{
61
62     //在类方法中可以调用对象方法
63     //1）对象作为方法的参数传递过来
64     //2）可以创建一个对象
65     Dog *d1 = [Dog new];
66     [d1 eat];
67
68     [dog eat];
69 }
70
71 +(void)t1{
72
73    //类方法可以调用其他类方法
74    //类方法不能调用自身
75
76 //    NSLog(@"Car的类方法 t1");
77 //    [Car t1];    //自己调用自己  无限循环
78 }
79 @end
80
81
82     2）类方法：
83      以+开头
84     不可以使用成员变量
85     用类名调用类方法
86     类方法可以调用对象方法（是通过将对象作为参数传入方法）和类方法
87     类方法不可以调用自身，会造成死循环
88
89 #import <Foundation/Foundation.h>
90
91 @interface Dog : NSObject
92 {
93
94 }
95 +(void)run;
96 -(void)eat;
97
98 @end
99
100 #import "Dog.h"
101
102 @implementation Dog
103 +(void)run{
104     NSLog(@"狗正在疯跑");
105 }
106 -(void)eat{
107
108     NSLog(@"狗正在吃");
109 }
110 @end
111
112 #import <Foundation/Foundation.h>
113 #import "Car.h"
114 int main(int argc, const char * argv[])
115 {
116
117     @autoreleasepool {
118         //对象方法调用
119         Car *car = [Car new];
120          car->_speed = 200;
121         [car run];     //实例方法调用
122          //类方法调用
123         [Car run];
124         [Car run:50];  //对象作为方法的参数传递过来
125
126         //类方法用对象方法调用
127         Dog *d1 = [Dog new];
128         [Car test:d1];   //狗正在吃
129
130      //   [Car t1];  类方法调用自己 无限循环
131     }
132     return 0;
133 }

第五讲 类方法应用场景

本小节知识点：

【理解】OC类方法应用场景

1、OC类方法应用场景

如果我们调用一个方法，该方法中不需要使用成员变量，那么我们可以将该方法声

明为类方法。

[Car run];

练习：

有一个手机的类iPhone，该类中有一个枚举类型的实例变量_color

kColorBlack 黑色 kColorWhtie 白色 kColorTHJ 土豪金

1）请定义一个类方法，实现返回真实手机颜色，而非枚举值。

//+(NSString *)getPhoneColor:(Color)color;

1 #import <Foundation/Foundation.h>
3 typedef enum {kColorBlack,kColorWhite,kColorTHJ}Color;
4 @interface IPhone : NSObject
5 {   @public
6     Color  _color;
8 }
9 +(NSString *)getPhoneColor:(Color)color;
10 @end
11
12 #import "IPhone.h"
13
14 @implementation IPhone
15 +(NSString *)getPhoneColor:(Color)color{
16
17     NSString *colorName;
18     //根据color的值做判断
19     // 0              1          2
20     //kColorBlack kColorWhite  kColorTHJ
21     switch (color) {
22         case kColorBlack:
23             colorName = @"黑色";
24             break;
25         case kColorWhite :
26             colorName = @"白色";
27             break;
28         case kColorTHJ:
29             colorName = @"土豪金";
30             break;
32         default:
33             break;
34     }
35     return colorName;
36 }
37 @end
38
39 #import <Foundation/Foundation.h>
40 #import "IPhone.h"
41 int main(int argc, const char * argv[])
42 {
44     @autoreleasepool {
47         NSString *str = [IPhone getPhoneColor:kColorTHJ];
48         NSLog(@"%@",str);
49     }
50     return 0;
51 }

第六讲 匿名类的概念及使用

本小节知识点：

1、【了解】匿名类的概念

2、【理解】匿名类访问成员变量

3、【理解】匿名类调用方法

1、匿名类的概念

1 #import <Foundation/Foundation.h>
2
3 @interface Car : NSObject
4 {
5     @public
6     int _speed;
7 }
8 -(void)start;
9 -(void)stop;
10 @end
11
12 #import "Car.h"
13
14 @implementation Car
15 -(void)start{
16
17     NSLog(@"车已经启动,正准备以%d的速度跑",_speed);
18 }
19 -(void)stop{
20
21     NSLog(@"咯吱，车停了");
22 }
23 @end
24
25 #import <Foundation/Foundation.h>
26 #import "Car.h"
27 int main(int argc, const char * argv[])
28 {
29
30     @autoreleasepool {
31
32         // 创建对象
33         Car *car1 = [Car new];
34
35         car1->_speed = 100;
36
37         //找到栈区，找到堆区， 找到代码区
38         [car1 start];
39
40         //[Car new];  实质上对象的存储空间
41
42         //匿名类(匿名对象)时候用
43         //1、使用匿名类访问实例变量(能，只能访问一次)
44         //以后再次访问，实际上访问新的空间了
45         [Car new]->_speed = 250;
46         NSLog(@"_speed = %d",[Car new]->_speed); // 0
47
48         //2、使用匿名 的类，可以调用方法
49         //
50         [[Car new] stop];  //可以
51
52         // 3、  申请空间  初始化
53         [[Car alloc] init];  //等价于 [Car new];
54
55         //使用alloc init 的方式调用 stop方法
56          [[[Car alloc] init] stop];
57
58     }
59     return 0;
60 }

2、匿名类作为方法的参数

本小节知识点：

1、【掌握】匿名类作为方法的参数

2、【了解】匿名类的优缺点

1 #import <Foundation/Foundation.h>
2
3 @interface Car : NSObject
4 {
5     @public
6     int _speed;
7 }
8 -(void)start;
9 -(void)stop;
10 @end
11
12 #import "Car.h"
13
14 @implementation Car
15 -(void)start{
16
17     NSLog(@"车已经启动,正准备以%d的速度跑",_speed);
18 }
19 -(void)stop{
20
21     NSLog(@"咯吱，车停了");
22 }
23 @end
24
25 #import <Foundation/Foundation.h>
26 #import "Car.h"
27 @interface Person : NSObject
28 {
29
30 }
31 -(void)goHome:(Car *)car;
32 @end
33
34 #import "Person.h"
35
36 @implementation Person
37 -(void)goHome:(Car *)car{
38
39     //人开车回家，实质是车跑
40     [car start];
41 }
42
43 @end
44
45 #import <Foundation/Foundation.h>
46 #import "Person.h"
47 int main(int argc, const char * argv[])
48 {
49
50     @autoreleasepool {
51
52         Person *p = [[Person alloc] init ];
53         //创建一个车
54         Car *car = [Car new];
55         car->_speed = 80;
56     //    [p goHome:car];
57
58         //1、匿名类作为方法的参数使用
59    //     [p goHome:[Car new]];
60
61         //匿名类调用方法，参数又是匿名类
62         [[Person new] goHome:[Car new]];  //0
63     }
64     return 0;
65 }

2、匿名类优缺点

优点：可以简化代码，方便方法调用

缺点：匿名对象实例化以后，只能正确的使用成员变量一次

常见用法：

//下面两句的作用是等价的

Person *p = [[Person alloc] init];

Person *p1 = [Person new];

两者的区别：

alloc 和 init 分别把分配内存和初始化的工作分开。这样更加的灵活，可以自行初始

化对象的成员变量值

而不像new每次都初始化为0

new 是吧分配内存和初始化的工作一起完成了，先分配内存，然后调用类的构造函

数。