OC基础一

傷城~ 2022-06-09 12:54 481阅读 0赞

**OC语言前期准备**

**一、OC简介**

Oc语言在c语言的基础上，增加了一层最小的面向对象语法，完全兼容C语言，在OC代码中，可以混用c，甚至是c++代码。

可以使用OC开发mac osx平台和ios平台的应用程序。

拓展名：c语言\-.c  OC语言.-m  兼容C++.-mm

注：其实c语言和oc甚至任何一门语言都只是我们为了实现一些功能，达到一些效果而采用的工具，抛开语法的差别外，我想最重要的应该是在解决问题的时候考虑的角度和方法不一样而已，然而这也构成了学习一门语言的重要性。

**二、语法预览**

（一）关键字

基本上所有的关键字都是以@开头的（为了与c语言的关键字区分开来），如@interface  @implementation  @public等，少部分没有以@开头，如id，\_cmd等

（二）字符串以@开头

C语言字符串：“hello”

OC语言字符串：@“hello”

（三）其他语法

基本类型：5种，增加了布尔类型

Nil相当于是null,也就是0。

屏幕输出：NSLog(@“hello”);//自动换行

NSLog(@“age is %d”,2);

**三、OC程序开发过程**

\#import预处理指令有两个作用：（1）与\#include一样，拷贝文件内容（2）可以自动防止文件的内容被重复拷贝

程序编译连接过程：

源文件（.m）\---(编译)---->目标文件（.0）\-----（链接）\---->可执行文件（.out）

Foundation框架。如果要使用框架中的所有头文件那么应该怎么办？包含框架的主头文件。主头文件是一个框架中最主要的头文件，每个框架的主头文件名和框架名一致。

如\#import<foundation/foundation.h>

运行过程如下:

(1)编写OC源文件  .m .c

(2)编译文件  cc -c xx.m  xxx.c

(3)链接  cc xx.o xxx.o  -framework Foundation

(4)运行 ./a.out

**四、类型补充**

Int main（）

BOOL b=YES;

BOOL b1=NO;

BOOL b2=1;//  YES

BOOL b3=2;//  NO

NSLog(@“%i”，b);

BOOL类型与其他类型的用法一致，BOOL类型的本质是char类型的，定义如下：

Typedef signed char BOOL

宏定义:

\#define YES  (BOOL)1

\#define NO   (BOOL)0

布尔类型的输出一般当做整数来用。

**OC语言基础知识**

**一、面向对象**

OC语言是面向对象的，c语言是面向过程的，面向对象和面向过程只是解决问题的两种思考方式，面向过程关注的是解决问题涉及的步骤，面向对象关注的是设计能够实现解决问题所需功能的类。

术语：OO面向对象、OOP面向对象编程

**二、类**

**（一）关于类**

类的设计只关注三个东西：类名、属性和方法

注意：一般名词都是类，拥有相同属性和行为的对象都可以抽象为一个类，类名是标识符的一种，需要符合规范，通常类名的第一个字母大写，且不能有下划线，如果有多个单词则使用驼峰标识。在对方法进行类的划分中，一般采取的做法是谁最熟悉这个方法那么就把这个方法划分给谁。在OC中，对象对方法的调用称为消息机制，即向既定的对象发送了什么消息。

**（二）简单内存分析**

类创建对象，每个对象在内存中都占据一定的存储空间，每个对象都有一份属于自己的单独的成员变量，所有的对象公用类的成员方法，方法在整个内存中只有一份，类本身在内存中占据一份存储空间，类的方法存储于此。

每个对象内部都默认有一个isa指针指向这个对象所使用的类。

\[p eat\];表示给p所指向的对象发送一条eat消息，调用对象的eat方法，此时对象会顺着内部的isa指针找到存储于类中的方法，执行。

isa是对象中的隐藏指针，指向创建这个对象的类。

**（三）类的声明和实现**

1）类的声明：

这里声明了一个Person类，这个类拥有一个@public修饰的属性（成员变量），以及一个对象方法put。

![022244365804110.png][]

2）类的实现：类的声明可以理解为类中的方法的实现

![022244484702675.png][]

3）类的调用：在主函数首先创建了一个Person类型的对象（先调用alloc分配存储空间，后调用init方法初始化为0），并定义了一个Person类型的指针指向创建的这个对象，之后初始化对象成员变量\_age的值为20，然后调用了对象的put方法，打印输出。

![022245056421888.png][]

4)练习，创建一个Person类。

类的声明：

![022246467204534.png][]

类的实现如下：

![022246558453355.png][]

类的调用如下：

![022247047369105.png][]

**（四）常见错误**

（1）@interface  @end和@implementation  @end不能嵌套包含

（2）只有类的声明没有类的实现

（3）漏写@end

（4）两个类的声明嵌套（可以把顺序打乱）

（5）成员变量没有写在\{\}里

（6）方法的声明写在了\{\}里面

（7）在声明时对类的成员变量进行初始化，请注意成员变量不能脱离对象而独立存在

（8）方法无法像函数那样的调用

（9）成员变量和方法不能用static等关键字修饰，不要和c语言混淆

（10）类的实现可以写在mian函数后面，在使用之前只要有声明就可以

**三、OC对象与函数**

**OC对象与函数有着本质的区别：**

（1）方法的实现只能写在@implementation··@end中，对象方法的声明只能写在@interface···@end中间

（2）对象方法都以\-号开头，类方法都以\+号开头

（3）对象方法只能由对象来调用，类方法只能由类来调用，不能当做函数一样调用

（4）函数属于整个文件，可以写在文件中的任何位置，包括@implementation··@end中，但写在@interface···@end会无法识别，函数的声明可以再main函数内部也可以在main函数外部。

（5）对象方法归类\\对象所有

（6）函数调用不依赖与对象

（7）函数内部不能直接通过成员变量名访问对象的成员变量

**四、类和方法的设计**

工具类：基本没有任何的成员变量，里面的方法基本都是类方法。

注意：在对象方法中可以调用类方法。

需求：设计一个工具类：一个计算器类，要求（1）返回π，（2）计算两个整数的和，（3）计算某个整数的平方。

类的声明部分

![022249262671010.png][]

类的实现部分

![022249409552265.png][]

测试程序：

![022249523926758.png][]

**OC方法和文件编译**

**一、OC方法**

**（一）对象方法**

（1）对象方法以\-开头如 \-（void）xx;

（2）对象方法只能又对象来调用

（3）对象方法中可以访问当前对象的成员变量

（4）调用格式   \[对象名  对象方法名\]；

（5）设计一个学生类和狗类，练习对象方法的使用。

学生类的声明：

![030040263456934.png][]

学生类的实现：

![030040407369632.png][]

狗类的声明：

![030040525804184.png][]

狗类的实现：

![030041188615446.png][]

主程序：

![030041305176239.png][]

**（二）类方法**

（1）类方法以\+开头  如\+（void）put;

（2）类方法只能由类来调用

（3）类方法中不能访问实例（成员）变量，因为类方法又类来调用，并没有创建存储空间来存储类中的成员变量。

（4）调用格式：\[类名  类方法名\]；

（5）类方法的好处和适用场合：

不依赖于对象，执行效率更高；

能用类方法解决的问题，尽量使用类方法；

场合：当方法内部不需要使用到成员变量时，可以改为类方法。

（6）设计一个计算器类，练习使用类方法。

计算器类的声明：

![030041536733714.png][]

计算器类的实现：

![030042031278335.png][]

主程序：直接使用类名调用类方法

![030042135023643.png][]

注意1：可以允许类方法和对象方法同名。

注意2：在对象方法中可以调用类方法。

**（三）方法名**

（1）不带参数的方法

声明：

![030043093453999.png][]

调用：

![030043195955264.png][]

（2）带参数的方法

声明：

![030043327833260.png][]

调用：

![030043539863405.png][]

注意:冒号也是方法名的一部分。

**二、文件编译**

在工作中，通常把不同的类放到不同的文件中，每个类的声明和实现分开，声明写在.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有两个作用：一是和include一样，完完全全的拷贝文件的内容；二是可以自动防止文件内容的重复拷贝（即使文件被多次包含，也只拷贝一份）。

在使用命令行进行编译链接文件的时候，通常是把.m文件单文件编译，然后再把所有的目标文件链接，但是在Xcode中，是把所有的.m文件都进行编译链接的，如果出现重复定义的错误，那大部分问题根源应该就是文件内容被重复包含或者是包含.m文件所引起的。

源文件中不论是使用include还是import，都不能包含.m或者是.c文件，只能放声明。因此，在OC中通常把类拆分开来，拆分成声明和实现两个部分。

提示：这也是编程思想的一种体现，可以说.h和.m文件时完全独立的，只是为了要求有较好的可读性，才要求两个文件的文件名一致，这也是把接口和实现分离，让调用者不必去关心具体的实现细节。

Xcode是写一行编译一行，有简单的修复功能，红色是错误提示，黄色警告。如果在程序中声明了一个变量，但是这个变量没有被使用也会产生警告信息。在调试程序的时候，如果发现整个页面都没有报错，但是一运行就错误，那么一定是链接报错。

**OC内存管理**

**一、基本原理**

**（一）为什么要进行内存管理。**

由于移动设备的内存极其有限，所以每个APP所占的内存也是有限制的，当app所占用的内存较多时，系统就会发出内存警告，这时需要回收一些不需要再继续使用的内存空间，比如回收一些不再使用的对象和变量等。

管理范围：任何继承NSObject的对象，对其他的基本数据类型无效。

本质原因是因为对象和其他数据类型在系统中的存储空间不一样，其它局部变量主要存放于栈中，而对象存储于堆中，当代码块结束时这个代码块中涉及的所有局部变量会被回收，指向对象的指针也被回收，此时对象已经没有指针指向，但依然存在于内存中，造成内存泄露。

**（二）对象的基本结构**

每个OC对象都有自己的引用计数器，是一个整数表示对象被引用的次数，即现在有多少东西在使用这个对象。对象刚被创建时，默认计数器值为1，当计数器的值变为0时，则对象销毁。

在每个OC对象内部，都专门有4个字节的存储空间来存储引用计数器。

**（三）引用计数器的作用**

判断对象要不要回收的唯一依据就是计数器是否为0，若不为0则存在。

**（四）操作**

给对象发送消息，进行相应的计数器操作。

Retain消息：使计数器\+1，改方法返回对象本身

Release消息：使计数器\-1（并不代表释放对象）

retainCount消息：获得对象当前的引用计数器值

**（五） 对象的销毁**

当一个对象的引用计数器为0时，那么它将被销毁，其占用的内存被系统回收。

当对象被销毁时，系统会自动向对象发送一条dealloc消息，一般会重写dealloc方法，在这里释放相关的资源，dealloc就像是对象的“临终遗言”。一旦重写了dealloc方法就必须调用\[super dealloc\]，并且放在代码块的最后调用（不能直接调用dealloc方法）。

一旦对象被回收了，那么他所占据的存储空间就不再可用，坚持使用会导致程序崩溃（野指针错误）。

**二、相关概念和使用注意**

野指针错误：访问了一块坏的内存（已经被回收的，不可用的内存）。

僵尸对象：所占内存已经被回收的对象，僵尸对象不能再被使用。（打开僵尸对象检测）

![030113520339984.png][]

空指针：没有指向任何东西的指针（存储的东西是0,null，nil），给空指针发送消息不会报错

注意：不能使用\[p retaion\]让僵尸对象起死复生。

**三、内存管理原则**

**（一）原则**

只要还有人在使用某个对象，那么这个对象就不会被回收；

只要你想使用这个对象，那么就应该让这个对象的引用计数器\+1；

当你不想使用这个对象时，应该让对象的引用计数器\-1；

**（二）谁创建，谁release**

（1）如果你通过alloc,new,copy来创建了一个对象，那么你就必须调用release或者autorelease方法

（2）不是你创建的就不用你去负责

**（三）谁retain，谁release**

只要你调用了retain，无论这个对象时如何生成的，你都要调用release

**（四）总结**

有始有终，有加就应该有减。曾经让某个对象计数器加1，就应该让其在最后\-1.

**四、内存管理代码规范**

**（一）只要调用了alloc，就必须有release(autorelease)**

**（二）Set方法的代码规范**

（1）基本数据类型：直接复制

\-（void）setAge:(int)age

\_age=age;

（2）OC对象类型

\-（void）setCar:(Car \*)car

//1.先判断是不是新传进来的对象

If(car!=\_car)

//2 对旧对象做一次release

\[\_car release\];//若没有旧对象，则没有影响

//3.对新对象做一次retain

\_car=\[car retain\];

**（三）dealloc方法的代码规范**

（1）一定要\[super dealloc\]，而且要放到最后

（2）对self（当前）所拥有的的其他对象做一次release操作

\-（void）dealloc

\[\_car release\];

\[super dealloc\];

**五、@property的参数**

**（1）内存管理相关参数**

Retain:对对象release旧值，retain新值（适用于OC对象类型）

Assign:直接赋值（默认，适用于非oc对象类型）

Copy:release旧值，copy新值

**（2）是否要生成set方法（若为只读属性，则不生成）**

Readonly:只读，只会生成getter的声明和实现

Readwrite:默认的，同时生成setter和getter的声明和实现

**（3）多线程管理（苹果在一定程度上屏蔽了多线程操作）**

Nonatomic:高性能，一般使用这个

Atomic:低性能

**（4）Set和get方法的名称**

修改set和get方法的名称，主要用于布尔类型。因为返回布尔类型的方法名一般以is开头，修改名称一般用在布尔类型中的getter。

@propery(setter=setAbc,getter=isRich) BOOL rich;

BOOL b=p.isRich;// 调用

**六、内存管理中的循环引用问题以及解决**

案例：每个人有一张身份证，每张身份证对应一个人，不能使用\#import的方式相互包含，这就形成了循环引用。

新的关键字：@class 类名；——解决循环引用问题，提高性能

@class仅仅告诉编译器，在进行编译的时候把后面的名字作为一个类来处理。

（1）@class的作用：声明一个类，告诉编译器某个名称是一个类

（2）开发中引用一个类的规范

1）在.h文件中使用@class来声明类

2）在.m文件中真正要使用到的时候，使用\#import来包含类中的所有东西

（3）两端循环引用的解决方法

一端使用retain,一端使用assign（使用assign的在dealloc中也不用再release）

**七、Autorelease**

**(一)基本用法**

（1）会将对象放到一个自动释放池中

（2）当自动释放池被销毁时，会对池子里的所有对象做一次release

（3）会返回对象本身

（4）调用完autorelease方法后，对象的计数器不受影响（销毁时影响）

**(二)好处**

（1）不需要再关心对象释放的时间

（2）不需要再关心什么时候调用release

**(三)使用注意**

(1)占用内存较大的对象，不要随便使用autorelease，应该使用release来精确控制

(2)占用内存较小的对象使用autorelease，没有太大的影响

**(四)错误写法**

（1）连续调用多次autorelease，释放池销毁时执行两次release(-1吗？)

（2）Alloc之后调用了autorelease，之后又调用了release。

**(五)自动释放池**

（1）在ios程序运行过程中，会创建无数个池子，这些池子都是以栈结构（先进后出）存在的。

（2）当一个对象调用autorelease时，会将这个对象放到位于栈顶的释放池中

**(六)自动释放池的创建方式**

（1）ios 5.0以前的创建方式

NSAutoreleasePool \*pool=\[\[NSAutoreleasePool alloc\] init\];

\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`

\[pool  release\];//\[pool drain\];用于mac

（2）Ios5.0以后

@autoreleasepool

\{//开始代表创建自动释放池

·······

\}//结束代表销毁自动释放池

**(七)Autorelease注意**

(1)系统自带的方法中，如果不包含alloc new copy等，则这些方法返回的对象都是autorelease的，如\[NSDate  date\]；

(2)开发中经常会写一些类方法来快速创建一个autorelease对象，创建对象时不要直接使用类名，而是使用self

**八、ARC内存管理机制**

**（一）ARC的判断准则：**

只要没有强指针指向对象，对象就会被释放。

**（二）指针分类：**

（1）强指针：默认的情况下，所有的指针都是强指针，关键字strong

（2）弱指针：\_ \_weak关键字修饰的指针

声明一个弱指针如下：

\_ \_weak Person \*p;

ARC中，只要弱指针指向的对象不在了，就直接把弱指针做清空操作。

\_ \_weak Person \*p=\[\[Person alloc\]  init\];//不合理，对象一创建出来就被释放掉，对象释放掉后，ARC把指针自动清零。

ARC中在property处不再使用retain,而是使用strong，在dealloc中不需要再\[super dealloc\]。

@property（nonatomic,strong）Dog \*dog;// 意味着生成的成员变量\_dog是一个强指针，相当于以前的retain。

如果换成是弱指针，则换成weak，不需要加\_ \_。

**（三）ARC的特点总结：**

（1）不允许调用release，retain，retainCount

（2）不允许重写dealloc,但是不允许调用\[super dealloc\]

（3）@property的参数：

Strong:相当于原来的retain（适用于OC对象类型），成员变量是强指针

Weak:相当于原来的assign,(适用于oc对象类型)，成员变量是弱指针

Assign：适用于非OC对象类型（基础类型）

**（四）补充**

让程序兼容ARC和非ARC部分。转变为非ARC  -fno-objc-arc  转变为ARC的， \-f-objc-arc 。

ARC也需要考虑循环引用问题：一端使用retain，另一端使用assign。

![030114208307448.png][]

提示：字符串是特殊的对象，但不需要使用release手动释放，这种字符串对象默认就是autorelease的，不用额外的去管内存。

**OC面向对象—封装**

**一、面向对象和封装**

面向对象的三大特性：封装（成员变量）、继承和多态

在OC语言中，使用@interface和@implementation来处理类。

![031549117058673.png][]

@interface就好像暴露在外面的时钟表面，像外界提供展示以及接口。@implementation就好像隐藏在时钟内部的构造实现，把具体的实现封装了起来。

**二、Set方法**

在开发过程中，考虑到安全性要求，我们一般不在成员变量名前面使用@public、@protected等关键字修饰，而是使用Set方法来为对象提供成员变量的值。在set方法的内部也可以对一些不合理的赋值进行筛选过滤。

Set方法的作用：为外界提供一个设置成员变量值的方法

命名规范：

（1）方法名必须以set开头

（2）Set后面跟上成员变量的名称，首字母大写

（3）返回值一定是void

（4）一定要接收一个参数，而且参数类型需要和成员变量的类型一致

（5）形参名不能喝成员变量名一样（苹果官方推荐成员变量名前加\_以示区分）

Set方法的好处：

（1）不让数据暴露在外，保证了数据的安全性

（2）对设置的数据进行过滤

Set方法使用示例：

Set方法的声明：

![031550177831294.png][]

Set方法的实现：

![031550287834188.png][]

测试程序：

![031550425648298.png][]

**三、Get方法**

Get方法的作用：为调用者返回对象内部的成员变量

命名规范：

（1）一定有返回值，返回值的类型和成员变量的类型一致

（2）方法名和成员变量名一样

（3）不需要接收任何参数

Get方法使用示例：

Get方法的声明：

![031551169707508.png][]

Get方法的实现：

![031551311273434.png][]

测试程序：

![031551444397701.png][]

注意1：在实际的开发中，不一定set和get方法都会提供，如果内部的成员变量比如学生的学号这样的数据只允许外界读取，但是不允许修改的情况，则通常只提供get方法而不提供set方法。

注意2：成员变量名的命名以下划线开头，get方法名不需要带下划线，使用下划线开头有两个好处：（1）与get方法的方法名区分开来；（2）可以喝一些其他的局部变量区分开来，下划线开头的变量，通常都是类的成员变量。

**四、Self关键字**

Self是一个指针，谁调用了当前方法，self就指向谁

【出现在对象方法中，就代表着当前对象，出现在类方法中，就代表着当前类】

Self的用途:

(1)可以利用self->成员变量名访问当前对象内部的成员变量（仅在对象方法中）

(2)\[self 方法名\]；可以调用其他的对象方法或者是类方法

**五、练习**

要求：设计一个成绩类

![031552434553631.png][]

实现：

![031553027838702.png][]

测试程序：

![031553258305676.png][]

**OC面向对象—继承**

**一、基本概念**

程序的世界和人类的“对象”世界在思想上是没有设么区别的，富二代继承了父母，自然就拥有了父母拥有的所有资源，子类继承了父类同样就拥有了父类所有的方法和属性（成员变量）。

![031641297981978.png][]

在这里动物是猫类和狗类的父类，黑猫和白猫类是猫类的子类。

继承的好处：

（1）抽取出了重复的代码

（2）建立了类和类之间的联系

继承的缺点：

耦合性太强

**二、OC中的继承**

@interface Animal:NSObject

//动物里继承了NSObject，获得NSObject类的方法；

@end

@interface Dog :Animal

//dog类继承Animal类

@end

注意：OC语言是单继承语言。在oc语言中，基本上所有类的根类都是NSObject类。

**三、继承的使用注意**

（1）编译器从上往下执行，所以在子类前面至少应该要有父类的声明；

（2）OC中不允许子类和父类拥有相同名称的成员变量名；

（3）OC中的子类可以拥有和父类相同名称的方法，在子类调用时，优先去自己的内部寻找，如果没有则一层一层的往上找；

提示：重写即子类重新实现了父类中的某个方法，覆盖了父类以前的实现。

示意图：一共有三个类，Person类继承了NSObject类，Student类继承了Person类。

![031641575488255.png][]

创建一个Student \*s=\[\[Student alloc\] init\];

此时会把Student类和这个类的父类加载进内存。

提示：每个类中都有一个super class指针，该指针指向自己的父类。对象中有一个isa指针，该指针指向调用该对象的类。

**四、继承和组合**

继承的适用场合：

（1）当两个类拥有相同的属性和方法时，就可以将相同的属性和方法抽取到一个父类中。

（2）当A类完全拥有B类中的部分属性和方法时，可以考虑让B类继承A类（考虑），在这种情况下，也可以考虑使用组合。

继承：\#\#\#是xxx,如狗是动物，可以让狗继承动物类

组合：\#\#\#拥有xxx，如学生有书，可以让书这个类作为学生类的属性

**五、关键字super**

Super关键字，在子类中重写方法时，可以让调用者跳过这一层而调用父类中的方法。

作用：

（1）直接调用父类中的某一个方法

（2）Super处在对象方法中，那么就会调用父类的对象方法；super处于类方法中，那么就会调用父类的类方法。

使用场景：子类在重写父类方法时，想要保留父类的一些行为。

**OC面向对象—多态**

**一、基本概念**

多态在代码中的体现，即为多种形态，必须要有继承，没有继承就没有多态。

在使用多态是，会进行动态检测，以调用真实的对象方法。

多态在代码中的体现即父类指针指向子类对象。

Animal类的声明

![031859059234704.png][]

Animal类的实现

![031859155808854.png][]

Dog类继承自Animal类

![031859275333907.png][]

Dog类的实现

![031859373302099.png][]

测试程序：

![031859545646798.png][]

**二、使用注意**

代码分析：

Dog \*d=\[\[Animal  alloc\] init\];   动物是一条狗？语义正确吗？

NSString \*str=\[Dog  new\];     狗是一个字符串？正确吗？

Oc语言是一门弱语法的语言，编译的时候并不会报错，所以这就要求我们在实际的开发过程中一定要按照既定的规范来写代码，不要出现狗是一个字符串这样的问题。

多态的好处：

需要一个新的函数专门用来喂狗

Void feed(Dog \*d)

\[d  eat\];

如果这个时候也需要喂猫，那就应该重写新一个新的函数

Void feed(Cat \*c)

\[c  eat\];

而狗和猫实际上都继承自动物这个类，在这里就可以使用多态来简化代码了。

这里只需要把函数的参数写成是Animal \*类型的，那么Dog和Cat类型的对象就都可以传入进来。

调用的时候直接改变参数就可以了。

多态的局限性：父类类型的指针变量不能直接调用子类特有的方法。

不建议的做法~

Animal \*a=\[\[Dog alloc\] init\];

\[a run\];//在Animal类中没有run方法，这里调用了狗对象的方法。

解决方法：可以将a强制转换为Dog\*类型的变量，如下：

Dog \*d=(Dog \*)a;//使用强制转换，这里a和d指向的是同一个狗对象

**三、多态使用总结**

（1）没有继承就没有多态

（2）代码的体现：父类类型的指针指向子类对象

（3）好处：如果函数方法参数中使用的是父类类型，则可以传入父类和子类对象，而不用再去定义多个函数来和相应的类进行匹配了。

（4）局限性：父类类型的变量不能直接调用子类特有的方法，如果必须要调用，则必须强制转换为子类特有的方法。

**四、字符串补充内容**

@“234”字符串也是一个对象，属于NSString这个类。下面是对字符串对象的一些代码说明：

![031900133613312.png][]

字符串对象的length方法：计算的是字符串的字数，而不是像strlen函数那样，计算的是字符数。如“哈ha123”length得出的结果是6，返回unsigned long类型，而strlen函数得出的结果是8，因为一个汉字占3个字节。

提示：字数也包括空格。

![031900310025596.png][]

**OC点语法和变量作用域**

**一、点语法**

**（一）认识点语法**

声明一个Person类:

![复制代码][copycode.gif]

1 #import <Foundation/Foundation.h>
     2 
     3 @interface Person : NSObject 4 { 5     int _age;//默认为@protected
     6 } 7 
     8 - (void)setAge:(int)age; 9 - (int)age; 10 
    11 @end

![复制代码][copycode.gif]

Person类的实现：

![复制代码][copycode.gif]

1 #import "Person.h"
     2 
     3 @implementation Person 4 
     5 - (void)setAge:(int)age 6 { 7     _age = age;// 不能写成self.age = newAge,相当与 [self setAge:newAge];
     8 } 9 
    10 - (int)age  //get方法
    11 { 12     return _age; 13 } 14 
    15 @end

![复制代码][copycode.gif]

点语法的使用：

![复制代码][copycode.gif]

1 #import <Foundation/Foundation.h>
     2 #import "Person.h"
     3 
     4 int main(int argc, const char * argv[]) 5 { 6 
     7 @autoreleasepool { 8         
     9         // insert code here...
    10         Person *person = [[Person alloc] init]; 11         
    12         //[person setAge:10];
    13         person.age = 10;//点语法，等效与[person setAge:10]; 14 //这里并不是给person的属性赋值，而是调用person的setAge方法 15         
    16         //int age = [person age];
    17         int age = person.age;//等效与int age = [person age]
    18        NSLog(@"age is %i", age); 19 [person release]; 20         
    21 } 22     return 0; 23 }

![复制代码][copycode.gif]

**（二）点语法的作用**

OC设计点语法的目的，是为了让其他语言的开发者可以很快的上手OC语言开发，使用点语法，让它和其他面向对象的语言如java很像。

**（三）点语法的本质**

点语法的本质是方法的调用，而不是访问成员变量，当使用点语法时，编译器会自动展开成相应的方法。切记点语法的本质是转换成相应的set和get方法，如果没有set和get方法，则不能使用点语法。

如：

Stu.age=10;展开为：\[stu setAge:10\];

int  a=stu.age;展开为：\[stu age\];

编译器如何知道是set方法还是get方法？主要是看赋值（可以使用断点调试来查看）。

在OC中访问成员变量只有一种方式即使用\-> 如stu->age，这种情况要求在@public的前提下。

**（四）点语法的使用注意**

下面的使用方式是一个死循环：

(1)在set方法中，self.age=age;相当于是\[self setAge:age\];

(2)在get方法中，return self.age;相当于是\[self age\];

**二、变量作用域**

**（一）变量的作用域主要分为四种：**

（1）@public (公开的)在有对象的前提下，任何地方都可以直接访问。

（2）@protected （受保护的）只能在当前类和子类的对象方法中访问

（3）@private （私有的）只能在当前类的对象方法中才能直接访问

（4）@package (框架级别的)作用域介于私有和公开之间，只要处于同一个框架中就可以直接通过变量名访问

**（二）使用注意和补充**

（1）在类的实现即.m文件中也可以声明成员变量，但是因为在其他文件中通常都只是包含头文件而不会包含实现文件，所以在这里声明的成员变量是@private的。在.m中定义的成员变量不能喝它的头文件.h中的成员变量同名，在这期间使用@public等关键字也是徒劳的。

（2）在@interface  @end之间声明的成员变量如果不做特别的说明，那么其默认是protected的。

（3）一个类继承了另一个类，那么就拥有了父类的所有成员变量和方法，注意所有的成员变量它都拥有，只是有的它不能直接访问。

**OC语言@property @synthesize和id**

**一、@property @synthesize关键字**

注意：这两个关键字是编译器特性，让xcode可以自动生成getter和setter的声明和实现。

**（一）@property 关键字**

@property 关键字可以自动生成某个成员变量的setter和getter方法的声明

@property int age;

编译时遇到这一行，则自动扩展成下面两句：

\- (void)setAge:(int)age;

\- (int)age;

**（二）@synthesize关键字**

@synthesize关键字帮助生成成员变量的setter和getter方法的实现。

语法：@synthesize age=\_age;

相当于下面的代码：

\- （void）setAge:(int)age

\_age=age;

\- (int)age

Return \_age;

**（三）关键字的使用和使用注意**

类的声明部分：

![041148142839436.png][]

类的实现部分：

![041148236117786.png][]

测试程序：

![041148312675890.png][]

新版本中：

类的声明部分：

![041148441423857.png][]

类的实现部分：

![041148541583052.png][]

测试程序：

![041149048617388.png][]

（1）在老式的代码中，@property只能写在@interface  @end中，@synthesize只能写在@implementation   @end中，自从xcode 4.4后，@property就独揽了@property和@synthesize的功能。

（2）@property int age;这句话完成了3个功能：1）生成\_age成员变量的get和set方法的声明；2）生成\_age成员变量set和get方法的实现；3）生成一个\_age的成员变量。

注意：这种方式生成的成员变量是private的。

（3）可以通过在\{\}中加上int \_age;显示的声明\_age为protected的。

（4）原则：get和set方法同变量一样，如果你自己定义了，那么就使用你已经定义的，如果没有定义，那么就自动生成一个。

（5）手动实现：

1）如果手动实现了set方法，那么编译器就只生成get方法和成员变量；

2）如果手动实现了get方法，那么编译器就只生成set方法和成员变量；

3）如果set和get方法都是手动实现的，那么编译器将不会生成成员变量。

![041149244862017.png][]

**二、Id**

id 是一种类型，万能指针，能够指向\\操作任何的对象。

注意：在id的定义中，已经包好了\*号。Id指针只能指向os的对象。

id 类型的定义

Typedef struct objc object\{

Class isa;

\} \*id;

局限性：调用一个不存在的方法，编译器会马上报错。

**OC语言构造方法**

**一、构造方法**

**（一）构造方法的调用**

完整的创建一个可用的对象：Person \*p=\[Person new\];

New方法的内部会分别调用两个方法来完成2件事情，1）使用alloc方法来分配存储空间（返回分配的对象）；2）使用init方法来对对象进行初始化。

可以把new方法拆开如下：

1.调用类方法\+alloc分配存储空间，返回未经初始化的对象

Person \*p1=\[person  alloc\];

2.调用对象方法\-init进行初始化，返回对象本身

Person \*p2=\[p1 init\];

3.以上两个过程整合为一句：

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

说明：init方法就是构造方法，是用来初始化对象的方法，注意这是一个对象方法，一减号开头。默认初始化完毕后，所有成员变量的值都为0。

**（二）构造方法的代码示例**

需求1，如果我需要让每个对象创建出来的初始值是10，而不是1，应该怎么办呢？

![041444069393799.png][]

需求2，让学生继承人类，要求学生对象初始化之后，年龄是10，学号是1，怎么办？

![041444182522021.png][]

**（三）构造方法使用注意**

（1）子类拥有的成员变量包括自己的成员变量以及从父类继承而来的成员变量，在重写构造方法的时候应该首先对从父类继承而来的成员变量先进行初始化。

（2）原则：先初始化父类的，再初始化子类的。

（3）重写构造方法的目的：为了让对象方法一创建出来，成员变量就会有一些固定的值。

（4）注意点：\#1先调用父类的构造方法\[super init\]; \#2再进行子类内部成员变量的初始化。

**二、自定义构造方法**

**（一）自定义构造方法的规范**

（1）一定是对象方法，以减号开头

（2）返回值一般是id类型

（3）方法名一般以initWith开头

**（二）自定义构造方法的代码实现**

Person类的声明，其中声明了两个接收参数的自定义构造方法

![041444312673030.png][]

Person类的实现

![041444389554079.png][]

Student继承自Person类，声明了一个接收三个参数的构造方法

![041444457988769.png][]

Student类的实现

![041444551893607.png][]

测试主程序

![041445045029483.png][]

**（三）自定义构造方法的使用注意**

（1）自己做自己的事情

（2）父类的方法交给父类的方法来处理，子类的方法处理子类自己独有的属性

**OC语言类的深入和分类**

**一、分类**

**（一）分类的基本知识 **

概念：Category  分类是OC特有的语言，依赖于类。

分类的作用：在不改变原来的类内容的基础上，为类增加一些方法。

添加一个分类：

![051631510731578.png][]

![051632151203724.png][]

文件结构图：

![051632349951896.png][]

在分类中添加一个方法

![051632444178273.png][]

Study方法的实现

![051633031674002.png][]

测试程序：

![051633146826454.png][]

**（二）分类的使用注意**

（1）分类只能增加方法（包括类方法和对象方法），不能增加成员变量

（2）在分类方法的实现中可以访问原来类中的成员变量；

（3）分类中可以重新实现原来类中的方法，但是会覆盖掉原来的方法，导致原来的方法无法再使用（警告）；

（4）方法调用的优先级：分类\->原来的类\->父类，若包含有多个分类，则最后参与编译的分类优先；

（5）在很多的情况下，往往是给系统自带的类添加分类，如NSObject和NSString，因为有的时候，系统类可能并不能满足我们的要求。

（6）在大规模的应用中，通常把相应的功能写成一个分类，可以有无限个分类，对原有类进行扩充，一般分模块写，一个模块一个分类。

**（三）分类编程练习**

（1）给NSString类增加一个类方法，计算某个字符串对象中阿拉伯数字的个数；

（2）给NSString类增加一个对象方法，计算当前字符串对象中阿拉伯数字的个数；

分类中方法的声明

![051633347926697.png][]

分类中方法的实现

![051633439326990.png][]

测试程序：

![051634062923121.png][]

**二、类的深入研究**

**（一）类的本质**

类本身也是一个对象，是class类型的对象，简称“类对象”。

Class类型的定义：

Typedef struct obj class \*class;

类名就代表着类对象，每个类只有一个类对象。

利用class 创建 Person类

利用Person 创建Person类型的对象

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

获取内存中的类对象有两种方法：

（1）class c=\[p claa\];//指向类的对象的指针调用class方法

（2）Class c1=\[Person class\];//使用类名调用class方法

注意：c和c1打印出来的地址相同，class c2=\[p claa\];可以证明所有的对象共用一个类方法。

**（二）类的加载和初始化**

![051634228856691.png][]

测试程序：

![051634343383657.png][]

1.当程序启动时，就会加载项目中所有的类和分类，而且加载后会调用每个类和分类的\+load方法，只会调用一次；

2.当第一次使用某个类时，就会调用当前类的\+initialize方法；

3.先加载父类，再加载子类（先调用父类的\+load方法，再调用子类的\+load方法，最后调用分类的\+load方法），先初始化父类，再初始化子类（先调用父类的\+initialize方法，再调用子类的\+initialize方法）。

4.注意：在初始化的时候，如果在分类中重写了\+initialize方法，则会覆盖掉父类的。

5.重写\+initialize方法可以监听类的使用情况。

[022244365804110.png]: /images/20220609/6fbf8761c10e46ce89ced18c854c570e.png
[022244484702675.png]: /images/20220609/6d225c21978c4bd58796affb93772af8.png
[022245056421888.png]: /images/20220609/16c5dba1f17b4d5dba6aec26651b58b9.png
[022246467204534.png]: /images/20220609/d26705f56016476bbb53d26c75cd2f04.png
[022246558453355.png]: /images/20220609/e2a5e9e538d0477fbb2cfeb7d9cef7bb.png
[022247047369105.png]: /images/20220609/8e79b9f93e394b0fbf71ca63c30b64b0.png
[022249262671010.png]: /images/20220609/49b4bb748bb04f2fab4f6053235b1c90.png
[022249409552265.png]: /images/20220609/c8d4e013e64e4f46b0d679f307daad66.png
[022249523926758.png]: /images/20220609/5c14dbbd372141d48ab2a5f64e06f830.png
[030040263456934.png]: /images/20220609/c865d278c1ec4f31971bfa7c9f975f23.png
[030040407369632.png]: /images/20220609/98348e0b71d94e3590e70ded7d03ed83.png
[030040525804184.png]: /images/20220609/8c9cce9e583849efb4f4ec7ec008f4af.png
[030041188615446.png]: /images/20220609/9ebed38bcc8840679b3faa2e4aa05e38.png
[030041305176239.png]: /images/20220609/e1095c6a2c4148aa83d72913a6e24289.png
[030041536733714.png]: /images/20220609/31132805783b4c2294d9b151d63913ec.png
[030042031278335.png]: /images/20220609/1e01f91408c84259bd8949cdf31bf8fa.png
[030042135023643.png]: /images/20220609/86f8c0db9a2b4cec99be87479c3b4587.png
[030043093453999.png]: /images/20220609/4ba5d9d38f7e4699b4f8d1f55af66b08.png
[030043195955264.png]: /images/20220609/ce5421587ea84333b8fa79034fbe317d.png
[030043327833260.png]: /images/20220609/8668e8a078e44354aad998528dcd165e.png
[030043539863405.png]: /images/20220609/35c653c104f94c748cb1cc945fd3d6dc.png
[030113520339984.png]: /images/20220609/8ebebc7bcf1b4352b0813f254ed38b00.png
[030114208307448.png]: /images/20220609/2394ecd1645c4c80b61920ff2d3c918c.png
[031549117058673.png]: /images/20220609/d76b61b845d948928589efa99642b50a.png
[031550177831294.png]: /images/20220609/bfe397e118d34993ba1cd689bb2589fb.png
[031550287834188.png]: /images/20220609/116f43250e8b4b68a1e21bd78470641b.png
[031550425648298.png]: /images/20220609/d9f6dc7d4e044c1f90020a344149c032.png
[031551169707508.png]: /images/20220609/d9e0aa480f73459fbaad63cf301b3c6f.png
[031551311273434.png]: /images/20220609/a44143727c3b4b9a922eb23b825786d3.png
[031551444397701.png]: /images/20220609/82da6368e8d841bd82d59330342b5d26.png
[031552434553631.png]: /images/20220609/9a57f772b14840d190faa0cd761535b8.png
[031553027838702.png]: /images/20220609/880a3152088847d8827876510a21e099.png
[031553258305676.png]: /images/20220609/35a16c0a670d40419a90455e6d088785.png
[031641297981978.png]: /images/20220609/4b7e5816e0f8482f9881ba0f8d9a9bd8.png
[031641575488255.png]: /images/20220609/39f57227db75450c870d697cf33bd3f9.png
[031859059234704.png]: /images/20220609/a6499705104e4e459361a91c1026f5ce.png
[031859155808854.png]: /images/20220609/13021923bbd24fe491bc7b29502d26f2.png
[031859275333907.png]: /images/20220609/1a1391da7cfb4c06a7b92a8b11c45b91.png
[031859373302099.png]: /images/20220609/dcde43de2210431e8fdba992f47aec94.png
[031859545646798.png]: /images/20220609/da48a814965e44d0a8f35efc012f1932.png
[031900133613312.png]: /images/20220609/5e2817be67814048b58b0790a6790193.png
[031900310025596.png]: /images/20220609/18a338d7f7514a0eba35069e8430503d.png
[copycode.gif]: /images/20220609/4aa0905bbade4a579ad08f1e14b46907.png
[041148142839436.png]: /images/20220609/c9a6ba83602944f58d8f4c1424d2c346.png
[041148236117786.png]: /images/20220609/9253d5ff7d5143cd968dd28ed5a64e01.png
[041148312675890.png]: /images/20220609/f96e244da8654a9cb8435b7e7aabbb33.png
[041148441423857.png]: /images/20220609/839a413c0e5a499fa5ff73a1c59d771a.png
[041148541583052.png]: /images/20220609/a3ed385a16db446fb2f05bd5e012b655.png
[041149048617388.png]: /images/20220609/4be06f309d07444c8bb7de0384c0bf77.png
[041149244862017.png]: /images/20220609/ae59ddea90404770bcb743fe693bb721.png
[041444069393799.png]: /images/20220609/b73a953b8bfe495197e96188a481ff1a.png
[041444182522021.png]: /images/20220609/dc3826d41de24bc6b5bd0c4eaf0bbaad.png
[041444312673030.png]: /images/20220609/e3e22bcdc8cd46cb8e31e4b4f37f75a9.png
[041444389554079.png]: /images/20220609/a2830d6e9ce043c7996df11a74c56e66.png
[041444457988769.png]: /images/20220609/465967af240b4252a3e46f6ff4b7058a.png
[041444551893607.png]: /images/20220609/06974bc70644489294db76a6482569b8.png
[041445045029483.png]: /images/20220609/0752157f355d4a7298d9f9e81e819263.png
[051631510731578.png]: /images/20220609/d014a7b68d8a44d49df51317556768af.png
[051632151203724.png]: /images/20220609/f6ab2425d7ae49c5a899324aaab051f6.png
[051632349951896.png]: /images/20220609/1a2d6e7167734243b520f4c1b18c0f38.png
[051632444178273.png]: /images/20220609/c5649dbb133c43dc85ab8039619f0c27.png
[051633031674002.png]: /images/20220609/f429926e77644361935523ed98021deb.png
[051633146826454.png]: /images/20220609/5930d48fda6a405bacb45313f624b5b3.png
[051633347926697.png]: /images/20220609/08dffe3486444ec28edab88a39254080.png
[051633439326990.png]: /images/20220609/386ad052e56d4bda9516b58f65cc551b.png
[051634062923121.png]: /images/20220609/a1a8806398054ff1afd04e3f6915f900.png
[051634228856691.png]: /images/20220609/ac01aa2c39cc40f2ae86a11bd0d998e0.png
[051634343383657.png]: /images/20220609/b61ce5c24d96431f8000829406487cb4.png