------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -----
第一讲 对象的存储细节
本小节知识点：
1、【理解】对象的存储细节
2、【掌握】使用一个类创建多个对象
一、对象的存储细节
类创建对象，每个对象在内存中都占据一定的存储空间，每个对象都有一份属于自己的单独的成员变量，所有的对象公用类的成员方法，方法在整个内存中只有一份，类本身在内存中占据一份存储空间，类的方法存储与此。
1 #import <Foundation/Foundation.h>
2
3 @interface Person : NSObject
4 {
5 @public
6 int _age;
7 NSString *_name;
8 }
9 //行为
10 -(void)run;
12 @end
13 @implementation Person
14 -(void)run{
15 NSLog(@"人正在跑");
17 }
18 @end
19 int main(int argc, const char * argv[])
20 {
22 @autoreleasepool {
24 Person *p = [Person new];
26 p->_name = @"柯南";
27 p->_age = 13;
29 NSLog(@"姓名:%@,年龄:%d",p->_name,p->_age);
31 [p run];
32
33 //[Person new]做了三件事情
34 //1) 申请内存空间
35 //2) 给实例变量初始化
36 //3) 返回空间的首地址
37
38 //1、申请的空间在内存的哪个区
39 // new 的时候申请的空间在内存的堆区(程序动态分配的内存空间)
40 // 当new的时候内存的布局是怎样的
41 // 初始化的时候：
42 //如果实例变量是基本数据类型，此时给初始化为0
43 //如果 。。。。。OC字符串类型 null
44
45 //2、实例变量又保存在什么地方
46 // 堆区
47 // p(指针变量) 存放在栈区
48
49
50 //3、对象方法保存在什么地方
51 // 代码区
52
53 //4、为什么使用 [p run]; 就可以调用方法了？如何调用的
54 //首先找p对应的堆区的空间，然后找到 _isa指针，再找到_isa指向代码区的空间，
55 //然后到该空间中找 方法
56
57 //5、一个类可以创建多个对象
58 //又创建类一个对象p1
59 Person *p1 = [Person new];
60 p1->_age = 10;
61 p1->_name = @"小叮当";
62 NSLog(@"姓名:%@,年龄:%d",p1->_name,p1 ->_age);
63
64 [p1 run];
65 }
66 return 0;
67 }
第二讲 #pragma mark指令的使用
本小节知识点：
1、【了解】#pragma mark指令的使用
1、#pragma mark指令的使用
功能：简单来说就是对代码的分组，方便代码查找和导航用的。
第三讲 函数和对象方法的区别
对象方法：
-(void)run;
1、对象方法的实现只能写在@implementation …@end中，
对象方法的声明只能写在@interface….@end中
2、对象方法都以 - 号开头，类方法都以 + 号开头
3、对象方法只能由对象来调用，类方法只能由类来调用，不能当做函数一样调用
4、函数属于整个文件，可以写在文件中的任何位置，包括@implementation…@end
中，但写在@interface…@end会无法识别，函数的声明可以在main函数内部也可
以在main函数外部。
5、对象方法归类------->对象所有
函数：
Void run(){
}
1、所有的函数都是平行的
2、函数不存在隶属关系
3、使用的时候可以直接调用
4、不可以访问对象中的成员变量
第四讲 常见错误汇总
1、常见错误
（1）@interface …@end 和@implementation …@end 不能嵌套包含
OC是弱语法，可以只有@implementation，但实际开发中千万不要这样。
@implementation Car : NSObject
{
@public
int _lunzi;
}
@end
//没有报错 但不能这么写
（2）只有类的声明没有类的实现
@interface …@end 和@implementation …@end 不能缺少
（3）漏写@end
（4）两个类的对象声明顺序（可以把顺序打乱）
（5）成员变量没有写在{}里
（6）方法的声明写在了{}里面
（7）在声明时不能对类的成员变量进行初始化，请注意成员变量不能脱离对象而
对立存在
（8）方法无法像函数那样的调用
（9）成员变量和方法不能用static等关键字修饰，不要和c语言混淆
（10）类的实现可以写在main函数后面，在使用之前只要有声明就可以
1 #import <Foundation/Foundation.h>
2
3 @interface Car : NSObject
4 {
5 @public
6 int _lunzi;
7 //错误的 不允许被嵌套
8 // @interface Person : NSObject
9
10 // @end
11 }
12 -(void)stop;
13 @end
14
15 int main(int argc, const char * argv[])
16 {
17
18 @autoreleasepool {
19
20 Car *car = [Car new];
21 car->_lunzi = 4;
22 NSLog(@"%d",car->_lunzi);
23 //调用没有实现的方法,会出现经典错误
24 @try {
25 //有可能会出错的代码
26 [car stop];//语法检查上没有问题，运行是错误的
27 }
28 @catch (NSException *exception) {
29 //错误的处理方法
30 NSLog(@"您调用的方法没有实现！");
31 NSLog(@"%@",exception ); //打印错误的信息
32 }
33 @finally {
34 printf("xxxxxxx\n");
35 }
37 }
38 return 0;
39 }
// /Users/xiaokang/Desktop/OC自学笔记/自学笔记/自学基础视频笔记/自学基础笔记/06-常见错误汇总/06-常见错误汇总/main.m:37:17: Method definition for ‘stop‘ not found
@implementation Car
@end
第五讲 对象和方法之间的关系
本小节知识点：
1、【掌握】对象作为方法的参数
2、【掌握】对象作为方法的返回值
1、对象作为方法的参数
2、对象作为方法的返回值
1 /*
2 对象和方法之间的关系
3 1）对象作为方法的参数
5 // 方法名 形参类型 形参数名
6 -(void)dispPerson:(Person *) person;
8 Person *p1 = [Person new];
10 [p dispPerson:p1] //对象作为方法的实参
11
12 2）对象作为方法的返回值
14 */
17
18 #import <Foundation/Foundation.h>
19 typedef enum {kSexMan,kSexWomen,kSexYao} Sex; //定义一个枚举类型
20
21 #pragma mark Person类的声明
22 //Person类的声明
23 @interface Person : NSObject
24 {
25 @public
26 NSString *_name;
27 Sex _sex;
28 }
29 #pragma mark 对象作为方法的参数
30 //对象作为方法的参数
31 -(void)dispPerson:(Person *) person;
32 #pragma mark 对象作为方法的返回值
33 // 对象作为方法的返回值
34 -(Person *)changSex:(Person *) person;
35 @end
36
37 #pragma mark -
38 #pragma mark Person类的实现
39 //Person类的实现
40 @implementation Person
41 -(void)dispPerson :(Person *) person{
42
43 NSLog(@"姓名:%@,性别:%d",person->_name,person->_sex);
44 }
45 // 对象作为方法的返回值 p2
46 -(Person *)changSex:(Person *) person{
47
48 //修改性别
49 person->_sex = kSexWomen;
50 return person;
51 }
53 @end
54
55 int main(int argc, const char * argv[])
56 {
57
58 @autoreleasepool {
59 //创建对象
60 Person *p = [Person new];
61 //创建对象
62 Person *p1 = [Person new];
63
64 p1->_name = @"凤姐";
65 p1->_sex = kSexWomen;
66
67 Person *p2 = [Person new];
68 p2->_name = @"张三丰";
69 p2->_sex = kSexMan;
70
71 [p dispPerson:p2];
72 [p dispPerson:p1];
73
74 //修改性别
75 //[p changSex:p2]; 这种也可以调用
76 Person *p3 = [p changSex:p2]; //p3和p1都指向同一个空间
77 NSLog(@"姓名:%@,性别:%d\n",p2->_name,p2->_sex);
78 }
79 return 0;
80 }
1 /*
2 对向和方法的之间的关系练习题
3
4 思考&实现1：
5 设计一个“狗”类
6 1、属性
7 颜色
8 速度（单位是m/s）
9 性别
10 体重（单位是kg）
11
12 2、行为
13 吃：没吃一次，体重增加0.5kg，输出吃完后的体重
14 吠（叫）：输出所有的属性
15 跑：每吃一次，体重减少0.5kg，输出速度和跑完后的体重
16 比较颜色：跟别的狗比较颜色，如果一样，两个值做减法得零，返回NO（零
17 值），不一样，做减法得到非零值，返回YES（1）
18
19 比较速度：跟别的狗比较速度，返回速度差（自己的速度 - 其他狗的速度）
20 */
21 #import <Foundation/Foundation.h>
22 //定义狗的性别
23 typedef enum{kSexMale,kSexFemale}Sex;
24 //定义狗的颜色
25 typedef enum {kColorRed,kColorYellow,kColorGreen}Color;
26
27 #pragma mark Dog类的声明
28 //狗类的声明
29 @interface Dog : NSObject
30 {
31 @public
32 Color _color; //狗的颜色
33 int _speed; //狗的速度
34 Sex _sex; //狗的性别
35 float _weight; //狗的体重
36 }
37 //狗的行为
38 -(void)eat:(NSString *)foodName; //体重＋0.5kg
39 -(void)bark; //输出所有属性
40 -(void)run; //体重－0.5kg
41 -(BOOL)isCompareColorWithOther:(Dog *)dog; //比较颜色
42 -(int)isCompareSpeedWithOther:(Dog *)dog; //比较速度差
43
44 @end
45 #pragma mark -
46 #pragma mark Dog类对象方法的实现
47 //Dog类对象方法的实现
48 @implementation Dog
49 -(void)eat:(NSString *)foodName{
50 _weight += 0.5f;
51 NSLog(@"狗正在吃%@,还打了个隔!",foodName);
52 } //体重＋0.5kg
53 -(void)bark{
54
55 NSLog(@"颜色:%d,速度:%d,性别:%d,体重:%.2f",_color,_speed,_sex,_weight);
56
57 } //输出所有属性
58 -(void)run{
60 _weight -= 0.5f;
61 NSLog(@"狗正在以%d的速度向前疯跑!",_speed);
62 } //体重－0.5kg
63
64 //比较狗的颜色
65 -(BOOL)isCompareColorWithOther:(Dog *)dog{
67 if(_color == dog->_color){
68 return YES; //颜色相同
69 }else{
70 return NO;
71 }
73 }
75 //比较狗的速度
76 -(int)isCompareSpeedWithOther:(Dog *)dog{
77
78 return _speed - dog->_speed;
79 } //比较速度差
80
81 @end
82
83 int main(int argc,const char *argv[]){
84
85 @autoreleasepool{
86
87 //创建两条狗对象
88 Dog *d1 = [Dog new];
89
90 d1->_color = kColorYellow;
91 d1->_speed = 60;
92 d1->_sex = kSexMale;
93 d1->_weight = 30;
94
95 [d1 bark]; //狗叫 输出所有属性
96 //狗在吃
97 [d1 eat:@"狗正在吃一根热狗!"];
98 [d1 eat:@"狗正在吃一根火腿肠!"];
99 [d1 bark];
100 [d1 run];
101 [d1 bark];
102
103 Dog *d2 = [Dog new];
104
105 d2->_color = kColorYellow;
106 d2->_speed = 50;
107 d2->_sex = kSexFemale;
108 d2->_weight = 25;
109 [d2 bark];
110 [d2 run];
111 [d2 bark];
112
113 [d2 eat:@"狗正在吃一根热狗!"];
114 [d2 eat:@"狗正在吃一根火腿肠!"];
115 [d2 bark];
116
117 //比较狗颜色
118 BOOL isSameColor = [d1 isCompareColorWithOther:d2];
119 NSLog(@"isSameColor = %d",isSameColor);
120
121 //计算狗速度差
122 int cha = [d1 isCompareSpeedWithOther:d2];
123 NSLog(@"cha = %d",cha);
124 }
125 return 0;
126 }
/*
2、结合前面的“狗”类，设计一个“人”类
1、属性
姓名
狗（养了一条狗）
2、行为
喂狗:每喂一次，狗就会执行“吃”这个行为
遛狗:每溜一次，狗就会执行“跑”这个行为
*/
#import <Foundation/Foundation.h>
//定义狗的性别
typedef enum{kSexMale,kSexFemale,kSexYao}Sex;
//定义狗的颜色的枚举
typedef enum {kColorWhite,kColorYellow,kColorBlack}Color;
#pragma mark -
#pragma mark 狗类的声明
//狗的声明
@interface Dog : NSObject
{
//狗类的实例变量
@public
Color _color; //狗的颜色
int _speed; //狗的速度
Sex _sex; //狗的性别
float _weight; //狗的体重
}
//狗的行为
-(void)eat:(NSString *)foodName; //体重+0.5kg
-(void)bark;
-(void)run; //体重-0.5kg
//比较狗毛的颜色
-(BOOL)isCompareColorWithOther:(Dog *)dog;
//比较速度
-(int)isCompareSpeedWithOther:(Dog *)dog;
@end
#pragma mark Dog类的实现
//Dog类对象方法的实现
@implementation Dog
//狗的行为
-(void)eat:(NSString *)foodName{
_weight += 0.5f;
NSLog(@"狗狗正在吃%@,吃完后还打了个隔!",foodName);
} //体重+0.5kg
-(void)bark{
NSLog(@"颜色:%d,速度:%d,性别:%d,体重:%.2f",_color,_speed,_sex,_weight);
}
-(void)run{
_weight -= 0.5f;
NSLog(@"狗狗正在以%d的速度向前疯跑!",_speed);
} //体重-0.5kg
//比较狗毛的颜色
-(BOOL)isCompareColorWithOther:(Dog *)dog{
//当前狗的颜色 另外一条狗的颜色
if(_color == dog->_color){
return YES; //颜色相同
}else{
return NO;
}
}
//比较速度
-(int)isCompareSpeedWithOther:(Dog *)dog{
return _speed - dog->_speed;
}
@end
#pragma mark -
#pragma mark 人这个类的声明
@interface Person : NSObject
{
@public
NSString *_name;
Dog *_dog; //人养的狗
}
//行为
//喂狗
-(void)feedDog:(NSString *)foodName;
//遛狗
-(void)liuDog;
@end
#pragma mark 人这个类的声明
@implementation Person
//喂狗
-(void)feedDog:(NSString *)foodName{
[_dog eat:foodName];
}
//遛狗
-(void)liuDog{
[_dog run];
}
@end
int main(int argc,const char *argv[]){
@autoreleasepool{
//创建两条狗
Dog *d1 = [Dog new];
d1->_color = kColorYellow;
d1->_speed = 60;
d1->_sex = kSexMale;
d1->_weight = 30;
[d1 bark];
[d1 eat:@"一根热狗"];
[d1 eat:@"一根火腿"];
[d1 bark];
Dog *d2 = [Dog new];
d2->_color = kColorBlack;
d2->_speed = 50;
d2->_sex = kSexFemale;
d2->_weight = 25;
[d2 bark];
//比较狗的颜色
//if 1 相同 0 不同
BOOL isSameColor = [d1 isCompareColorWithOther:d2];
NSLog(@"isSameColor = %d",isSameColor);
//比较狗的速度差
int cha = [d1 isCompareSpeedWithOther:d2];
NSLog(@"速度差 = %d",cha);
//创建人这个对象
Person *p = [Person new];
//给 人 p 一个 dog
p->_dog = d1;
//人要喂狗
[p feedDog:@"骨头"];
[p->_dog run ];
}
return 0;
}
如图：人要喂狗是怎么传递的
第六讲 对象作为方法的参数连续传递
本小节知识点:
1、【掌握】对象作为方法的参数连续传递
1、对象作为方法的参数连续传递
实现功能：士兵开枪 枪射击子弹
枪类：
名称: Gun
属性：型号(_size),子弹个数(_bulletCount)
行为：射击
人类：
名称：Soldier
属性：姓名(_name) life level(等级)
行为: 跑 蹲 开枪 跳
1 /*
2 对象作为方法的参数连续传递
3
4 实现功能：士兵开枪 枪射击子弹
5
6 枪类：
7 名称：Gun
8 属性：型号(_size),子弹个数(_bulletCount)
9 行为:射击
10
11 人类
12 名称：Soldier
13 属性：姓名(_name) life level(等级)
14 行为：跑 蹲 开枪 跳
15 */
16 #import <Foundation/Foundation.h>
17 #pragma mark -
18 #pragma mark 枪类的声明
19 @interface Gun : NSObject
20 {
21 @public
22 //实例变量
23 NSString *_size; //枪的型号
24 int _bulletCount; //枪的子弹个数
25 }
26 //行为
27 -(void)shoot; //射击
28
29 @end
30 #pragma mark 枪类的实现
31 @implementation Gun
32 -(void)shoot{
33
34 NSLog(@"%@ 正在 突突的射击。。。",_size);
35
36 } //射击
37 @end
38 #pragma mark -
39 #pragma mark 士兵这个类的声明
40 @interface Soldier : NSObject
41 {
42 @public
43 NSString *_name;
44 int life ;
45 int level;
46 }
47 //行为
48 -(void)fireByGun:(Gun *) gun; //士兵开枪
49 @end
50 #pragma mark 士兵这个类的实现
51 @implementation Soldier
52 -(void)fireByGun:(Gun *) gun{
53
54 //让枪射击
55 [gun shoot];
56
57 } //士兵开枪
58 @end
59 int main (){
60 @autoreleasepool{
63 //创建一个士兵对象
64 Soldier *s = [Soldier new];
65 s->_name = @"三多";
66 s->life = 98;
67 s->level = 2;
68 //创建一个枪对象
69 Gun *gun = [Gun new];
70 gun->_bulletCount = 3 ;
71 gun->_size = @"小米加步枪";
72 //士兵开枪
73 [s fireByGun:gun];
74 // [s fireByGun:gun];
75 // [s fireByGun:gun];
76 }
77
78 return 0;
79 }
//基本实现了，发现开枪后子弹数没少
//第二步开始实现每开枪一次子弹数减少一个，还要判断子弹数大于0的时候，才会
//减少
1 /*
2 对象作为方法的参数连续传递
3
4 实现功能：士兵开枪 枪射击子弹
5
6 枪类：
7 名称：Gun
8 属性：型号(_size),子弹个数(_bulletCount)
9 行为:射击
10
11 人类
12 名称：Soldier
13 属性：姓名(_name) life level(等级)
14 行为：跑 蹲 开枪 跳
15 */
16 #import <Foundation/Foundation.h>
17 #pragma mark -
18 #pragma mark 枪类的声明
19 @interface Gun : NSObject
20 {
21 @public
22 //实例变量
23 NSString *_size; //枪的型号
24 int _bulletCount; //枪的子弹个数
25 }
26 //行为
27 -(void)shoot; //射击
28
29 @end
30 #pragma mark 枪类的实现
31 @implementation Gun
32 -(void)shoot{
33 //每射击一次，子弹的个数－1 基本完成后，发现子弹个数没变，第二步实现子弹
34 if(_bulletCount>0){
35
36
37 _bulletCount --;
38 NSLog(@"%@ 正在 突突的射击。。。,剩余子弹:%d",_size,_bulletCount);
39 }else{
40 NSLog(@"没有子弹还突突个毛线!");
41 }
42 } //射击
43 @end
44 #pragma mark -
45 #pragma mark 士兵这个类的声明
46 @interface Soldier : NSObject
47 {
48 @public
49 NSString *_name;
50 int life ;
51 int level;
52 }
53 //行为
54 -(void)fireByGun:(Gun *) gun; //士兵开枪
55 @end
56 #pragma mark 士兵这个类的实现
57 @implementation Soldier
58 -(void)fireByGun:(Gun *) gun{
59
60 //让枪射击
61 [gun shoot];
62
63 } //士兵开枪
64 @end
65 int main (){
66 @autoreleasepool{
67
68 //创建一个士兵对象
69 Soldier *s = [Soldier new];
70 s->_name = @"三多";
71 s->life = 98;
72 s->level = 2;
73
//创建一个枪对象
74 Gun *gun = [Gun new];
75 gun->_bulletCount = 3 ;
76 gun->_size = @"小米加步枪";
77 //士兵开枪
78 [s fireByGun:gun];
79 [s fireByGun:gun];
80 [s fireByGun:gun];
81 [s fireByGun:gun];
82 }
83
84 return 0;
85 }
实现功能：士兵开枪 枪射击子弹
子弹类
名称：Bullet
属性：子弹个数，型号(_model)
1 /*
2 对象作为方法的参数连续传递
3
4 实现功能：士兵开枪 枪射击子弹
5
6 枪类：
7 名称：Gun
8 属性：型号(_size),子弹个数(_bulletCount)
9 行为:射击
10
11 人类
12 名称：Soldier
13 属性：姓名(_name) life level(等级)
14 行为：跑 蹲 开枪 跳
15
16 对象作为方法的参数连续传递 2
17 实现功能：士兵开枪 枪射击子弹
18
19 子弹类（弹夹）
20 名称：Bullet
21 属性：子弹个数，型号(_model)
22
23 //要求士兵在射击的时候，不但要给一把枪，还要给 一个弹夹
24 //子弹不能为负数
25 */
26 #import <Foundation/Foundation.h>
27
28 #pragma mark -
29 #pragma mark 子弹类的声明
30 //子弹类的声明
31 @interface Bullet : NSObject
32 {
33 @public
34 NSString *_model; //子弹的型号
35 int _bulletCount; //子弹的个数
36
37 }
38 //行为
39
40 @end
41 #pragma mark 子弹类的声明
42 @implementation Bullet
43
44 @end
45 #pragma mark -
46 #pragma mark 枪类的声明
47 @interface Gun : NSObject
48 {
49 @public
50 //实例变量
51 NSString *_size; //枪的型号
52 }
53 //枪的行为
54 -(void)shoot:(Bullet *)bullet;
55
56 @end
57 #pragma mark 枪类的实现
58 @implementation Gun
59 -(void)shoot:(Bullet *)bullet{
60 //判断子弹数>0
61 //子弹类对象(弹夹)中的子弹的个数
62 if(bullet->_bulletCount>0){
63 //子弹数 －1
64 bullet->_bulletCount --;
65 NSLog(@"啪啪啪，，，枪在射击，剩余子弹:%d",bullet->_bulletCount);
66
67 }else{
68 //如果子弹数<0,提示没子弹了
70 NSLog(@"没子弹了，没子弹了");
71 }
73 }
74 @end
75 #pragma mark -
76 #pragma mark 士兵这个类的声明
77 @interface Soldier : NSObject
78 {
79 @public
80 NSString *_name;
81 int life ;
82 int level;
83 }
84 //行为
85 -(void)fireByGun:(Gun *)gun andBullet:(Bullet *)bullet;
86 //士兵让枪装上子弹（弹夹）来射击
87 @end
88 #pragma mark 士兵这个类的实现
89 @implementation Soldier
90 -(void)fireByGun:(Gun *)gun andBullet:(Bullet *)bullet{
91 //士兵让枪装上子弹（弹夹）来射击
92 //子弹作为参数传递给射击的方法
93 [gun shoot:bullet];
95 }
96 @end
99 int main (){
100 @autoreleasepool{
104 //创建一个士兵对象
105 Soldier *s = [Soldier new];
106 s->_name = @"三多";
107 s->life = 98;
108 s->level = 2;
109 //创建一个枪对象
110 Gun *gun = [Gun new];
111
112 gun->_size = @"小米加步枪";
113
114 //创建子弹类对象
115 Bullet *myBullet = [Bullet new];
116 myBullet->_model = @"5mm口径";
117 myBullet->_bulletCount = 3;
118 //士兵开枪
119 [s fireByGun : gun andBullet : myBullet];
120 [s fireByGun : gun andBullet : myBullet];
121 [s fireByGun : gun andBullet : myBullet];
122 [s fireByGun : gun andBullet : myBullet];
123 // 士兵 开枪 枪对象方法 子弹对象方法 连续传递了两次
124 }
125
126 return 0;
127 }
第七讲 练习题讲解
思考&实现1：
设计一个“学生”类
1)属性
姓名
生日
// 这是一种方法，因为在题目中没有给出行为
用结构体作为类的实例变量（生日）
1 #import <Foundation/Foundation.h>
2
3 typedef struct {
4
5 int year;
6 int month;
7 int day;
8 }MyDate ;
9
10 @interface Student : NSObject
11 {
12 @public
13 NSString *_name; //姓名
14 MyDate _birthday; //生日
15 }
16
17 @end
18 @implementation Student
19
20 @end
21
22 int main(int argc, const char * argv[])
23 {
24
25 @autoreleasepool {
26
27 //创建一个学生类对象
28
29 //第一种方法
30 Student *stu = [Student new];
31
32 stu->_birthday = (MyDate){1981,12,12};
33 NSLog(@"%d,%d,%d",stu->_birthday.year,stu->_birthday.month,stu->_birthday.day);
34 //第二种方法
35 //定义一个结构体变量
36 MyDate d1 = {1982,12,11};
37 stu->_birthday = d1;
38 NSLog(@"%d,%d,%d",stu->_birthday.year,stu->_birthday.month,stu->_birthday.day);
39
40 //第三种方法，逐个赋值
41 stu->_birthday.year = 2014;
42 stu->_birthday.month = 11;
43 stu->_birthday.day = 10;
44 NSLog(@"%d,%d,%d",stu->_birthday.year,stu->_birthday.month,stu->_birthday.day);
45 }
46 return 0;
47 }
第八讲 NSString类介绍及用法
本小节知识点：
【掌握】NSString常见方法
NSString是Objective-C中核心处理字符串的类之一。
NSMutableString
NSDictionary
NSArray //就业班内容
1）创建常量字符串，注意使用“@”符号。
NSString *astring = @"This is a String!";
//c语言的
char *s = "abc";
s = "bcd";
#import <Foundation/Foundation.h>
int main(int argc,const char *argv[]){
@autoreleasepool{
//NSString 是OC中字符串处理的类
//1、创建一个字符串 (第一种方法)
NSString *s =@"banzhang jiecao diaole";
//2、输出一个字符串
NSLog(@"%@",s);
//NSString是一个类 (第二种方法)
NSString *s1 = [NSString new];
s1 = @"jian le ma";
NSLog(@"%@",s1);
//3、创建字符串的第三种方法
//格式化创建字符串（按照指定的格式创建字符串）
// NSString *imgName = [NSString stringWithFormat:@"xxxx%02d.jpg",i];
//类方法
for(int i=0;i<10;i++){
NSString *imgName = [NSString stringWithFormat:@"xxxx%02d.jpg",i];
NSLog(@"%@",imgName);
NSString *imgName = [NSString stringWithFormat:@"xxxx%02d-%02d.jpg",i,i+1];
NSLog(@"%@",imgName);
}
//用一个已经存在的字符串创建一个新的字符串 （第四种方法）
NSString *s2 = [[NSString alloc] initWithString:s1];
NSLog(@"%@",s2);
//注意:使用NSLog是不能打印C中的字符串的
// char *str = "淡定度";
// NSLog(@"%@",str);
}
return 0;
}
第九讲 NSString字符串长度计算方法
本小节知识点：
【掌握】NSString字符串长度计算
1、NSString字符串长度计算
1 // 06-NSString字符串长度计算方法
2 #import <Foundation/Foundation.h>
3
4 int main(int argc, const char * argv[])
5 {
6
7 @autoreleasepool {
8
9 //计算NSString 字符串的长度
10
11 //1)字符串是纯英文的
12 NSString *s1 = @"ban zhang ";
13 NSUInteger len = [s1 length];
14 NSLog(@"len = %ld",len);
15
16 //2)字符串是纯中文
17 //OC字符串中中英文都是一个字符
18 NSString *s2 = @"班长的节操";
19 len =[s2 length];
20 NSLog(@"len = %ld",len);
21
22 //3)中英文混合
23 NSString *s3 = @"班长!";
24 len = [s3 length];
25 NSLog(@"len = %ld",len);
26
27 //C语言中
28 char *s ="班长的节操";
29 // int len1 = strlen(s);
30 printf("len1 = %ld\n",strlen(s));
31 }
32 return 0;
33 }
第十讲 OC多文件开发介绍和实现步骤
本小节知识点：
【了解】为什么要使用多文件
在工作中，通常把不同的类放到不同的文件中，每个类的声明和实现分开，声明写在.h头文件中，实现写在相应的.m文件中去，类名是什么，文件名的前缀就是什么。
假设有两个类，分别是Person类和Dog类，则通常有下面五个文件：
（1） Person.h Person类的声明文件
（2）Person.m Person类的实现文件
（3）Dog.h Dog类的声明文件
（4）Dog.m Dog类的实现文件
（5）Main.m 主函数（程序的入口）
在主函数以及类的实现文件中要使用#import包含相应的头文件。
补充：import有两个作用：
1、和include一样，完完全全的拷贝文件的内容；
2、可以自动防止文件内容的重复拷贝(即使文件被多次包含，也只拷贝一份)。
提示：这也是编程思想的一种体现，可以说.h和.m文件是完全独立的，只是为了要求有较好的可读性，才要求两个文件的文件名一致，这也是把接口和实现分离，让调用者不必去关心具体的实现细节。
二、多文件实现步骤
原文：http://www.cnblogs.com/xiaokang520/p/5062338.html