OC基础-day02

#pragma mark - Day02_01_对象的创建与使用

1）如何通过类创建一个对象

1. 类是抽象的，无法直接使用

2. 对象是类的一个具体实现，可以直接使用

3. 语法

类名 *对象名 = [对象名   new]；

2）如何使用对象

1. 类中有什么，对象中就有什么，类中有的属性，对象中都可以访问

2. 类中的成员变量，默认外界不能访问，我们需要加上修饰符@public

语法:

对象名 -> 属性名

还可以这么使用：（*对象名）.属性名 ；

"扩展

属性:    通常是类暴露出来,外界可以访问或者修改(不一定真实存在)

成员变量: 类声明大括号里面的变量(对象类型和基本数据类型)

实例变量: 类声明大括号里面的变量(对象类型)

"练习

1.定义类

2.通过类来创建对象

3.使用对象

#pragma mark - Day02_02_犯错列表

1). 声明和实现 的 类名要一致.

2). @interface下面有1个大括弧,这个大括弧中才是写属性的.

3). 属性名一定要以下划线开头.

4). 属性是指针的时候,*要么和类型写在一起,要么和属性名写在一起,要么写中间,

5). 对象名其实是个指针变量,所以,对象的命名要遵守变量的命名规范.

6). 访问对象的属性的时候,虽然可以使用*去访问,但是你最好不要这么做,因为所有人都不这么做.都是使用->来访问的.

7). 通过对象名来访问对象的属性的时候,

对象名->属性名;

属性名是带了下划线的.

8). 默认情况下,对象的属性是不允许被外界访问的,应该加1个@public

9). 为对象的属性赋值,其实就是为对象的属性变量赋值,类型要和属性的类型一致.

10). 在类的外部不能直接操作属性,必须要创建对象,操作对象的属性.

11). 无论是为属性赋值,还是取属性的值, 都是操作的对象的属性,都要通过对象名来操作.

#pragma mark - Day02_03_无参数的方法的声明实现调用

1）方法定义

用来描述类共同的行为

类似于函数，只是跟语法不同

2)语法:

无参方法：

声明位置：放在类声明中{}的外面

- (返回值类型)方法名称;

- (void)run;

实现位置：放在类的实现中

- (void)run {

。。。。

}

调用 ：

使用类的对象调用。

语法[对象名  方法名]；

#pragma mark - Day02_04_带1个参数的方法的声明实现调用

1）声明

位置 同样是在.h的{}外面

语法 - （返回值类型）方法名：（参数类型）形参

2）实现

位置，同样是在.m中

语法，加上{}实现就行，并且直接可以使用形参

3）调用

[对象名  方法名：参数]；

把对用的参数穿进去就可以了

#pragma mark - Day02_05_带多个参数的方法的声明实现调用

1）声明

位置 同样是在.h的{}外面

语法 - （返回值类型）方法名：（参数类型）形参1    :（参数类型）形参2    ......

2）实现

位置，同样是在.m中

语法，加上{}实现就行，并且直接可以使用形参

3）调用

[对象名  方法名：参数1   : 参数2]；

#pragma mark - Day02_06_方法的命名规范

1）方法的名称

方法带参数，：也是方法的名字

- (void)run;

- (void)runWithSpeed:(double)speed;

- (void)runWithSpeed:(double)speed1 :(double)speed2;

- (void)runWithSpeed1:(double)speed1 speed2:(double)speed2;

2）命名规范

1.只有一个参数：  XXXXWith：参数   、XXXXWithXXXX：参数

2.多个参数：XXXwith：参数  and ：参数

3.不要使用拼音

#pragma mark - Day02_07_同1个类的多个对象之间毫无关系(重点)

1） 同1个类,可以创建无数个对象.

对象可以创建很多个.所以你在访问属性的时候,必须要指定访问的是那1个对象的属性或者方法.

2） 每1个对象都有自己的属性.

每创建1个对象,这个对象中都有自己的属性和方法.

同1个类的多个对象之间毫无关系.

唯一的关系是:他们是根据同1个类模板创建出来的.

对象中具有相同的属性和方法.

但是对象的属性的值,各自是各自的 不相互影响.

#pragma mark - Day02_08_在方法的实现中直接访问属性(较难)

1） 在方法的实现中,可以直接访问本类的属性.

如果在方法中直接访问了属性的.

方法是通过对象来调用.方法是通过那1个对象来调用的.那么这个方法中访问的属性就是那1个对象的.

#pragma mark - Day02_09_案例演示

1）创建一个对象 Person

特征： 姓名 年龄 体重 智商

行为： 爬山 学习 吃饭 打游戏

声明

@interface HMPerson : NSObject

{

@public

NSString *_name;

int _age;

double _weight;

int _iq;

}

- (void)paShanWithLocation:(NSString *)location;

- (void)study;

- (void)eatWithFood:(NSString *)foodName;

- (void)playGame;

@end

实现

@implementation MKPerson

- (void)paShanWithLocation:(NSString *)location

{

//1,怕1次山.爬山的人的体重就减掉0.5Kg

NSLog(@"我登上了%@!",location);

//2.减.

_weight -= 0.5;

//3. 显示

NSLog(@"我的体重是%.2lf",_weight);

}

- (void)study

{

//每学习1此,智商+1;

NSLog(@"头悬梁,锥刺股");

//智商++;

_iq++;

//显示.

NSLog(@"学习完了以后我的智商是:%d",_iq);

}

- (void)eatWithFood:(NSString *)foodName

{

//1.先吃.

NSLog(@"主人.你给我的%@真好吃!",foodName);

//2.长体重.

_weight++;

//3.显示.

NSLog(@"吃完以后,我的体重是:%.2lf",_weight);

}

- (void)playGame

{

NSLog(@"魔兽毁一生,Doat穷三代!");

//智商--

_iq--;

NSLog(@"我的智商是:%d",_iq);

}

#pragma mark - Day02_10_类加载（难点、重点）

1） 内存中的五大区域.

栈: 存储局部变量.

堆: 允许程序员手动在堆区申请指定的连续的字节数的空间来使用.

BSS段: 存储未初始化的全局变量、静态变量.

数据段(常量区):  存储已经初始化的全局变量、静态变量、常量数据.

代码段:存储程序的代码.

2）类加载.

1. 当我们创建对象的时候,肯定需要访问这个类.因为只有访问了类才知道类中有那些成员.

2. 如果只是声明类指针的时候,也会访问这个类.以确定这个类型是否存在.

'当类第一次被访问的时候,会将类存储到代码段之中. 这个过程叫做类加载.

将类的代码存储在代码之中.

将类的代码以字符串的形式存储在代码段中.

'只有类第1次被访问的时候,才会有类加载.

一旦类被加载到代码区.直到程序结束的时候才会被回收.

#pragma mark - Day02_11_对象在内存中的存储

1. 类的本质是:我们自定义的数据类型.

MKPerson *p1 = [MKPerson new];

2. MKPerson *p1;  int *p;

这句话,仅仅是声明了1个指针变量而已.这个指针变量的类型是HMPerson*.

p1是1个局部的变量.所以p1指针变量是存储在栈区的.

p1是1个指针变量,所以这个变量中只能存储地址.

本质上来讲.p1是1个指针变量 不是1个对象.

3.[MKPerson new];

这句话,才是在真正的创建对象.

new做的事情.

a. 在堆内存中申请一块合适大小的空间.

b. 在申请的这块空间中根据类的模板创建对象.

类中有哪些属性.就把类的属性依次的挨个的一个不落的声明在这个对象中.

对象中除了有类中定义的属性之外,还有1个属性叫做isa 这是1个指针.

这个isa指针指向代码段中的类.

c. 初始化对象的属性.为对象的属性赋默认值

-> 如果属性的类型是基本数据类型.就赋值为0

-> 如果属性的类型是C指针类型.就赋值为NULL

-> 如果属性的类型是OC指针类型.就赋值为nil

d. 返回这个对象在堆空间中的地址.

将这个地址赋值给p1指针.

p1指针指向了堆空间中的HMPerson对象.

#pragma mark - Day02_12_对象在内存中的存储的细节

1) 注意

a. 对象中只有类的属性+isa的指针. 没有方法.isa指针指向了代码段中的类.

b. 如何访问对象的属性.

通过指针就可以找到指针指向的对象.找到对象了,就可以找到对象的属性.

p1->_name = @"jack";

c. 如何调用对象的方法?[p1 sayHi];

通过p1指针找到对象,发现是在调用方法.那么再根据对象的isa指针找到代码段中的类,再找到类中的对应的方法来执行.

d. 为什么方法不保存在对象中.

因为不管对象有多少个.方法的代码都是一样的.没有必要保存多份,只保存1份就可以了

e. 相同类的对象的isa指针的值一定都是一样的.

2) 对象的属性的初始值.

我们创建1个对象 如果没有为这个对象的属性赋值.那么这个对象的属性是有值的.

属性的类型是基本数据类型:  0

OC指针:      nil

C指针:       NULL

#pragma mark - Day02_13_nil值

1) C语言中学习的NULL.

a). NULL是1个值. 是C语言中指针变量的值.

b). 如果1个指针的值为NULL值,就代表这个指针不指向内存中的任何空间.

c). NULL本质上是1个宏.

define NULL ((void*)0)

所以 NULL 和 0 等价.

2) nil

a). nil也是1个值. 它也是1个指针变量的值.

b). nil的本质也是1个宏.

#define __DARWIN_NULL ((void *)0)

所以,nil和NULL完全是等价的.

c). 所以,如果你想要让1个指针不指向任何空间.

可以为这个指针变量赋值为NULL nil 0

3) 使用建议

a). 如果希望C指针不指向任何空间.我们一般为其赋值为NULL

b). 如果希望OC指针不指向任何空间,我们一般赋值nil

4) 注意问题

如果1个类指针的值为nil

HMPerson *p1 = nil;

代表p1指针不指向任何对象.

1. 所以这个时候 你通过p1去访问p1指向的对象的属性的时候,肯定的会报错.

2. 这个时候, 通过这个指针去调用方法的时候,

不会报错.也不会崩溃.只是没有任何反应的.

"扩展

void * 是C语言的万能指针

#pragma mark - Day02_14_多个指针指向同1个对象

"提问

int a = 10;

int *p1 = &a;

int *p2 = p1;

*p2 = 9;

a   的值是多少?

*p1 的值是多少?

1) 类型相同的OC类指针变量之间是可以相互赋值的

HMPerson *p1 = [HMPerson new];

HMperson *p2 = p1;

这个时候.p1和p2指针指向了同1个对象.

无论通过p1指针去访问对象.还是通过p2指针去访问对象,

访问的都是同1个对象.

2) 凡是你看到了new 就代表重新创建了1个对象.

[类名 new]; 就代表新创建了1个对象. 结果就是新创建的这个对象的地址.

[类名 new]; 其实啊,这是在调用1个方法.new是方法名称.

new方法的功能:创建对象.

new方法的返回值: 创建的对象的地址.

MKPerson *p1 = [MKPerson new];

p1->_name = @"李凯";

p1->_age = 17;

MKPerson *p2 = p1;

p2->_name = @"花花";

p2 = [MKPerson new];

NSLog(@"p1->_name = %@",p1->_name);

打印的值是“花花”

#pragma mark - Day02_15_分组导航标记

1) 存在的问题

当1个文件中的代码太多的时候,要找某1段代码.很难找.

2) 一种快速的方式查找文件中的代码.

Xcode 提供了导航条可以快速查找.

3) 分组导航标记.

1. #pragma mark 标记名.

2. #pragma mark -  就会产生1条分割线.

3. #pragma mark - 标记名.  就会产生1条分割线.并取1个标记名.

"扩展

自定义代码块

#pragma mark -  Day02_16_方法与函数

1) 之前在C语言中学习的叫做函数.

void test();

在OC类中定义的叫做方法.

- (void)sayHi;

2) 相同点:

1). 都封装1段代码,都表示1个相对独立的功能.

2). 函数/方法 如果不被调用,那么其中的代码是不会被执行.

3) 不同点.

1. 语法不同.

2. 定义的位置不一样.

a. 函数除了函数的内部和@interface的大括弧中不能定义.其他的地方都是可以定义的.

b. 而方法的声明只能在@interface的大括弧的外面,实现只能在@implementation中.

就算你把函数写在类中,这个函数也不是属于这个类的.

3. 归属感不同.

a. 函数就像是1个没有家的孩子,每1个函数是孤立的.

b. 方法是属于类的.类就是方法的家.

4. 调用形式不同.

a. 函数直接调用.

b. 方法必须要通过对象名来调用.

#pragma mark - Day02_17_都是你的错

创建类常见错误

1). @interface是类的声明. @implementation是类的实现 他们之间不能相互嵌套.

声明和实现是相对独立的 不能嵌套

2). 类的声明和实现必须都要有

3). 类必须要先声明然后再实现

4). @end不能省略

5). OC方法不能像函数那样直接调用 而是要创建对象 通过对象来调用

6). 成员变量不允许声明的同时初始化

7). 类的声明必须要放在使用类的前面.实现可以放在使用类的后面

8). 类语法上其实可以只有实现没有声明.

例如:

@implementation MKDog : NSObject

{

@public

NSString *_name;

int _age;

}

- (void)shout

{

NSLog(@"汪汪.....");

}

@end

虽然这样写是可以的,但是千万别这么写.很不规范.

9). 方法只有声明 没有实现

unrecognized selector sent to instance 0x100105a80

只要你看到了这个错误,就代表你调用的方法这个对象中没有 或者 没有实现.

实例--对象.

#pragma mark -  Day02_18_多文件开发

1） 需求，为什么要多文件开发？

如果将所有的类都写在main.m文件中,

那么类就会越来越多.canshufangfadedhihuyizhidyiduinahanchuanguolaipandaunchuanzhihhiihihchanfangfaebu

缺点

-> 这个文件就会很庞大.

-> 不容易维护.

-> 不利于团队开发.

2） 我们的一般做法.

1. 1个类独占1个模块.

1个模块至少分为两个文件

.h 文件.  h head 头文件. 在这个文件中我们写类的声明.

.m 文件   实现文件. 写上类的实现.

2. 什么时候要使用这个类,就只需要引入这个类模块的头文件就可以了.

3） 从现在开始.类不要再写在main.m中

而是应该独占1个模块.

.h  类的声明

.m  类的实现. 在.m中引入.h

4） NewFile --> cocoaClass --> 自动添加头文件和实现文件.并且还帮你把类的框架搭好.

5)  Xcode 可以自动生成前缀模板

#pragma mark - Day02_19_对象作为方法的参数(一)(重点)

1）对象与方法.

对象作为方法的参数.

对象作为方法的返回值.

2） 对象可以作为方法的参数.

因为类是我们自定义的数据类型.

1. 如何将对象作为方法的参数.

参数的类型写类的指针类型.

- (void)liuGouWith:(MKDog *)dog

2. 在调用这个方法的时候. 实参对象要和形参要求的一致.

3. 对象传递是 地址 传递.

传递完成以后,形参指针和实参指针其实指向的是同1个对象.

在方法的内部.通过形参指针访问对象的时候 其实啊 访问的就是实现指向的那个对象.

#pragma mark - Day02_20_对象作为方法的参数(二)

对象作为方法的返回值实际应用

1）首先创建一个人的类

有两个属性，一个是名字(name)，另一个是剩余寿命(leftLife)

还有一个死的方法

再创建一个上帝类,名字(name),年龄(age)

有一个杀人的方法 (参数是人类型对象,把人的剩余寿命变为0)

声明:

@interface MKPerson : NSObject

{

@public

NSString *_name;

int _leftLife;

}

- (void)die;

@end

实现:

@implementation MKPerson

- (void)die

{

NSLog(@"救命啊.我叫%@.",_name);

NSLog(@"大不了,二十年后又是1条好汉.");

}

@end

上帝声明

#import <Foundation/Foundation.h>

#import "MKPerson.h"

@interface MKGod : NSObject

{

@public

NSString *_name;

int _age;

}

- (void)killWithPerson:(MKPerson *)per;

@end

实现

@implementation MKGod

- (void)killWithPerson:(MKPerson *)per

{

NSLog(@"孽畜:%@.我是%@,赶紧过来受死!",per->_name,_name);

per->_leftLife = 0;

[per die];

}

@end

在这里，通过上帝对象的killWithPerson：方法，我们把person对象传给上帝对象，上帝对象对person对象做处理。这个时候，我们就是把对象当做参数传递。