iOS9基础知识（OC）笔记

1月16日

Objective C（20世纪80年代初）

一、OC语言概述

1.1985年,Steve Jobs成立了NeXT公司

2.1996年,12月20日,苹果公司宣布收购了NeXT software 公司,NEXTSTEP环境为apple公司下主要开发、发行操作系统OSX的基础,这个开发环境的版本被苹果公司命名为 Cocoa(可可)框架

NSString NS=NEXTSTEP

3.Cocoa框架（Cocoa Touch框架 ->Ctapp ）

1.Fundation框架,基础框架,包括:字符串、数字、数组、字典、集合等

框架名称头文件

#import <Foundation/Foundation.h>

2.Application Kit框架,应用程序工具箱,它包括了实现程序图形、事件驱动和用户界面的全部对象,窗口、对话框、按钮、菜单、滚动条、文本框等,而且这个列表还在不断的添加

二、OC与C区别

1.创建项目的时候，type—>Foundation(OC)

2.main.c->main.m(源代码)

3.#include <stdio.h> -> #import <Foundation/Foundation.h>

4.在OC的开发环境中，是兼容C的语法

5.printf()—>NSLog(@….);日志输出

6. 编译原理OC与C是一样的，只不过编译命令由原来的gcc->clang。eg:clang -framework Foundation main.m

三、逻辑数据类型BOOL

OC中的逻辑值类型：

1.BOOL b2 = YES;//*YES 1 NO 0

2.不用导入头文件

//C中的逻辑值类型

bool isBool = false;

//***OC中的逻辑值类型

BOOL isBool2 = YES;

if (isBool2) {

NSLog(@"条件成立!");

}else{

NSLog(@"条件不成立!");

}

结果：条件成立!

三、OC中的函数

练习：求两个数的关系 a是否大于b

1.函数实现返回值（逻辑类型值）

2.在main函数中传入两个值并得到结果

3.通过if与结果判断，输出结果（NSLog）

#import <Foundation/Foundation.h>

BOOL bu(int i,int j){

if (i>j) {

return YES;

}

else{

return NO;

}

int main(int argc, const char * argv[])

{

@autoreleasepool {

int a=5,b=6;

BOOL isFlag=bu(a,b);

if (isFlag) {

NSLog(@"%d>%d",a,b);

}

else{

NSLog(@"%d<%d",a,b);

}

return 0;

}

结果：5<6

四、什么是面向对象程序开发

1.面向过程

数据结构 + 算法

2.面向对象

属性 + 行为

计算机中的对象Student：（有什么+能干什么）

属性(成员) age,name

方法(函数)study()

如：现实中周边一个对象 -> 计算机中对象?

学生 Student

有什么: 姓名、年龄属性：name、age

能什么: 学习方法：study()

五、类与对象（抽象事物，内存中不存在）

1.类是对象还未产生时，将要是什么样，具有相同属性和行为方法的同一类元素的总称

2.对象就是类经过实例化所产生的一个内存趋于数据

*必须先有类经过实例化才会产生对象，程序需要的是具体的数据，所以程序在执行过程当中，需要的对象。

3.第一个面向对象程序：

1. 类（文件中的代码）

在计算机中每一个类被存在两个文件中：

一、.h声明….属性/方法（属性没有实现，只有声明）

@interface Student : NSObject //类名Student

@property int age;//声明属性

-(void)study;//声明方法
@end

二、 .m实现....方法

@implementation Student //方法的定义、实现

-(void)study{

NSLog(@"学生执行了study方法"); }

@end

2.实例化（main.m文件）

类—>对象

在需要使用对象的地方实例化

1.导入头文件

#import "Student.h"

2.对一个类进行实例化

[类 alloc] 实例化得到一个内存（堆）的首地址

[Student alloc]

通过类发送alloc,通过一个类创建对象,通过stu变量,找到内存的对象

//给类Student 发消息alloc会创建出一个Student类型的对象

3.Student* stu=[Student alloc]实例化；stu就是对象

3.操作对象

属性：给属性赋值或取属性的值

对象.属性=......；//赋值

…=对象.属性；//取值

方法：

[对象方法名]调用对象的方法

***完整程序

Student.h声明

#import <Foundation/Foundation.h>

//声明

@interface Student : NSObject //父类

//属性

@property int age;

//方法

-(void)study;

@end

Student.m实现

#import "Student.h"

@implementation Student

-(void)study{

NSLog(@"学生有学习的能力！");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Student.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

// [类 alloc] 实例化得到一个内存（堆）的首地址

//返回void*-->id任意类型指针

//指针变量地址-->对象（obj）

//id obj=[Student alloc];

//Student* stu=(Student*)obj;

//stu *对象指针实例引用

Student* stu=[Student alloc];

//操作对象

stu.age=18;//属性赋值

[stu study];//调用对象的方法 //发送一个消息

NSLog(@"age:%d",stu.age);//得到属性值

}

return 0;

}

结果：

学生有学习的能力！

age:18

知识点

一、方法(实质是函数)

• 什么是方法（method）

代表一个对象可以干什么，一般来讲方法必须与对象结合使用
对象中内容分为属性和方法两部分：
- 属性是对象中的数据成员,用于描述对象的特征

- 方法是对象中的函数成员,用于描述对象的行为

3.关于函数

1. C语言的函数返回类型函数名();

2.Oc中函数的一般格式:

类型标识 (返回值类型) 函数名:(参数类型)参数名;

+/- (void) show; int

语法格式：

1.-(返回值类型)方法名; //无参方法

//无返回值无参数的方法 method

-(void)method;

2.-(返回值类型)方法名:(参数类型)参数名;//有一个参数方法

//有一个参数的方法

//返回值类型方法名:(参数的类型)参数名;

-(void)method2:(int)arg;

3.-(返回值类型)方法名:(参数类型1)参数名1 :(参数类型2)参数名2;//有两个参数的方法

-(void)method3:(int)age :(char)sex //需注意参数名后需加空格再加冒号

4.-(返回值类型)方法名:(参数类型1)参数名1 :(参数类型2)参数名2 :(参数类型n)参数名n;//3…n…个参数

//返回值类型方法名:(参数的类型)参数名 :(参数的类型)参数名 ...n;

/*定义一个方法，传多个参数：

参数1年龄、参数2性别、参数3学号

参数4工资、参数5家里有几个人。*/

(1) -(void)method3:(int)age

:(char)sex //需注意参数名后需加空格再加冒号

:(int)num

:(float)salary

:(int)count;

(2) -(void)method4WithAge:(int)age

andSex:(char)sex

andNum:(int)num

andSalary:(float)salary

andCount:(int)count;

练习：/*定义一个方法，传多个参数：类：MyClass

参数1年龄、参数2性别、参数3学号

参数4工资、参数5家里有几个人。*/

MyClass.h

#import <Foundation/Foundation.h>

@interface MyClass : NSObject

-(void)method4WithAge:(int)age

andSex:(char)sex

andNum:(int)num

andSalary:(float)salary andCount:(int)count;

@end

MyClass.m

#import "MyClass.h"

@implementation MyClass

-(void)method4WithAge:(int)age

andSex:(char)sex

andNum:(int)num

andSalary:(float)salary andCount:(int)count{

NSLog(@"age:%d sex:%c num:%d salary:%f count:%d",age,sex,num,salary,count);

}

@end

Main.m

#import <Foundation/Foundation.h>

#import "MyClass.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//将类实例化变为对象

MyClass *myClass = [MyClass alloc];

[myClass method4WithAge:19 andSex:'M' andNum:1 andSalary:2000.0f andCount:4];

}

return 0;

}

结果：

age:19 sex:M num:1 salary:2000.000000 count:4

2.公有方法、私有方法

1. 公有方法：即在.h文件中声明，又在.m文件实现。

可以在任意文件中使用。[对象 method];

2.私有方法：没在.h文件中声明，但在.m文件实现。

只可以在当前(同一)文件中使用，即在main.m文件中不能使用。通过[self method]实现;

3.self

self代表对象自己

self.属性调用对象自己的属性值

[self 方法] 调用对象自己的方法

例：

MyClass.h

#import <Foundation/Foundation.h>

@interface MyClass : NSObject

-(void)publicMethod;//公有方法

@end

MyClass.m

-(void)publicMethod{

NSLog(@"公有方法执行了");

[self privateMethod];//可以实现私有方法

}

-(void)privateMethod{

NSLog(@"私有方法执行了");

}

@end

Main.m

[myClass publicMethod];//公有方

//[myClass privateMethod];//不能调用类的私有方法不执行报错

结果：

公有方法执行了

私有方法执行了

3.成员变量、实例变量

变量就是保存一个数据。

1.成员变量将要保存什么数据。（_变量名）

@interface MyClass : NSObject

{ int _i;}//成员变量 //必须用大括号括起来不能初始化

2.实例变量真正保存什么数据。

3.公有的实例变量与私有的实例变量，最大的区别就是在对象外可见和不可见。默认情况，都不可以直接进行操作。

4.如果需要操作一个实例变量，目前的操作方式只有方法，通过方法来操作实例变量。(方法是操作实例变量的一种方式)。

如：

Point2.h

#import <Foundation/Foundation.h>

@interface Point2 : NSObject

{

int i;//定义成员变量

}

-(void)seti1:(int)num;//赋值

-(int)geti1;//取值返回值

@end

Point2.m

#import "Point2.h"

@implementation Point2

-(void)seti1:(int)num{

i=num;//把参数赋给成员变量，转成用方法进行内部操作

}

-(int)geti1{

return i;//将成员变量值返回

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Point2.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

Point2* stu=[Point2 alloc];

[stu seti1:18];//给实例变量赋值

NSLog(@"i:%d",[stu geti1]);//得到实例变量的值

}

return 0;

}

结果：

i:18

知识点

二、属性

是访问实例变量的一种方式。

1.变量的访问修饰符

• 定义变量

– @public （公有）可以在任意位置访问
– @package 可以在包内部访问,一个项目一定是在同一个包下。
– @protected （受保护）可以在本类内部和子类内部访问
– @private（私有）只可以在本类的内部分访问
*以上在@implementation部分,用大括号括起来
– 默认访问权限:@protected

如：

Myclass.h

#import <Foundation/Foundation.h>

@interface Myclass : NSObject

{

int _i;//实例变量默认protected

@package int _i2;

@public int _i3;

@protected int _i4;

@private int _i5;

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Myclass.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

Myclass* myclass=[Myclass alloc];

myclass->_i2=20;//package 这个项目里使用

myclass->_i3=30;//public 其他的不能访问

}

return 0;

}

2.属性

1.属性是访问实际变量的一种方式

2.属性有两个方法组成（setter/getter方法）。（属性是方法）

3.属性本身不能保存数据，数据是由实例变量保存的

规范：实例变量的命名：_开头

实例变量对应的属性:去掉下划线,首子母大写

如果认为规范不满意，自己重新合成

一、属性的本质三部分组成

a.实例变量

int _age

b.setter和getter方法的声明与实现

1.)setter方法:方法名:“set”+属性名并首子母大写 +“:”+和属性类型一样的参数,无返回值。

-(void)setSex:(char)sex //_age去掉下划线首子母大写

2.)getter方法:方法名和属性名一样,没有参数,返回值类型和属性类型一样。

-(char)sex;

c.点语法

setter方法的实现主要用来给属性赋值的
getter方法的实现主要用来读取属性值的
对象.属性 = 值;=>会自动调用setter方法
变量 = 引用.属性;=>会自动调用getter方法

myclass.sex='m';//自动调用setter方法

myclass.age=18;

NSLog(@"sex:%c age%d",myclass.sex,myclass.age);

练习：对象有性别、年龄的属性

完整程序：

Myclass.h

#import <Foundation/Foundation.h>

@interface Myclass : NSObject

{

char _sex;//实例变量

int _age;

}

-(void)setSex:(char)sex;

-(char)sex;

-(void)setAge:(int)age;

-(int)age;

@end

Myclass.m

#import "Myclass.h"

@implementation Myclass

-(void)setSex:(char)sex{

_sex=sex;//赋值属性与实例变量的关联

}

-(char)sex{

return _sex;//取值属性与实例变量的关联

}

-(void)setAge:(int)age{

_age=age;

}

-(int)age{

return _age;

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Myclass.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

Myclass* myclass=[Myclass alloc];

//实例变量->(return/=)->setter/getter

//setter/getter(语法)<->属性名

//实例变量<->属性名

myclass.sex='m';//自动调用setter方法 [myclass setSex:’m’]

myclass.age=18;

NSLog(@"sex:%c age:%d",myclass.sex,myclass.age);//自动调用getter方法

}

return 0;

}

结果：sex:m age:18

二、声明式属性

a.定义实例变量

b. @property 属性类型属性名（自动生成setter/getter）

@property int age;（.h）

@synthesize 属性名=实例变量

@synthesize age=_age;（.m）

c.点语法

完整程序

Myclass.h

#import <Foundation/Foundation.h>

@interface Myclass : NSObject

{

int _age;//1.实例变量

}

//2.声明属性

@property int age;//属性

@property char sex;

@end

Myclass.m

#import "Myclass.h"

@implementation Myclass

@synthesize age=_age;///将属性与实例变量关联在一起

@synthesize sex=_sex;

@end

main.m

#import <Foundation/Foundation.h>

#import "Myclass.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

Myclass* myclass=[Myclass alloc];

myclass.age=18;

myclass.sex='f';

NSLog(@"age:%d sex:%c",myclass.age,myclass.sex);

}

return 0;

}

结果：age:18 sex:f

三、ios5中的属性

a.定义实例变量 （省略）

b. @property 属性类型属性名（自动生成setter/getter）

@property int age;（.h）

@synthesize 属性名=实例变量

@synthesize age=_age;（.m）

c.点语法

四、ios6中的属性

实例变量都有系统生成的，就不需要合成

a.定义实例变量 （省略）

**b. @property 属性类型属性名（自动生成setter/getter）

@property int age;（.h）

@synthesize 属性名=实例变量（省略）

@synthesize age=_age;（.m）

c.点语法

注：如果对系统生成的setter/getter方法不满意，是可以重写这两个方法（必须两个方法都重写）。（声明属性/setter/getter），但是必须写合成。

在setter/getter方法中，使用点语法要注意（死循环）不要用self.属性名

如：

Myclass.h

#import <Foundation/Foundation.h>

@interface Myclass : NSObject

@property int age;//属性

@property char sex;

@end

Myclass.m

#import "Myclass.h"

@implementation Myclass

@synthesize age=_age;///将属性与实例变量关联在一起必须合成

-(void)setAge:(int)age{

_age=age+5; //同时调用setter和getter方法，给属性手动+5

}

-(int)age{

return _age;

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Myclass.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

Myclass* myclass=[Myclass alloc];

myclass.age=18;

myclass.sex='f';

NSLog(@"age:%d sex:%c",myclass.age,myclass.sex);

}

return 0;

}

结果：age:23 sex:f

知识点

三、初始化

//在创建的时候，就可以确定对象的值，使用初始化方法更简单、直接

//当程序在执行过程当中，如果需要给属性赋值，就使用方法和*属性

*真正初始化对象是由父类解决的

self=[super init]//哪个对象执行的初始化操作，将结果给哪个对象本身（自己）

return self;//当初始化操作完毕之后，经结果返回。

1.初始化(默认值)对象。(无参的初始化方法)

即使不定义无参的初始方法，对象本身也具备。

如果对原有的初始化方法不满意，是可以自定义的

2.初始化(指定值)对象。(有参的初始化方法)

有参的初始化方法必须自定义。

1.有参的都以“initWith...”开头（规定）

2.初始化方法只能用一次

int i ;

int i = 0;//默认值

int i = 10;//指定值

[MyClass alloc];

[MyClass alloc]init];//默认值无参的初始化方法

[MyClass alloc]initWithAge:18];//指定值有参的初始化方法

完整有参初始化方法程序：

Student.h

#import <Foundation/Foundation.h>

@interface Student : NSObject

@property int age;//属性

@property char sex;

@property int num;

-(id)initWithAge:(int)age andSex:(char)sex andNum:(int)num;//有参初始化

@end

Student.m

#import "Student.h"

@implementation Student

-(id)initWithAge:(int)age andSex:(char)sex andNum:(int)num{

self=[super init];

if (self) {

//默认初始化成功后，初始化其他属性值

_age=age; 参数赋给属性

//self.sex=sex;//同等

_sex=sex;

_num=num;

}

return self;

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Student.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//Student* student=[[Student alloc]init];

Student* student=[[Student alloc]initWithAge:18 andSex:'m' andNum:123];

NSLog(@"age:%d sex:%c num:%d",student.age,student.sex,student.num);

}

return 0;

}

结果： age:18 sex:m num:123

*创建类的时候，加前缀，前缀大写，类名大写，加起来不超过4个

注意区分不同的知识点：实例变量_age 参数age 属性.age

2.id类型任意类型指针

id是一个指针,但在使用时无需加*，相当于void*

3.self关键字

代表当前对象本身,还可以代表当前类

1.[myclass method]；

如果method方法中，有一个self关键字，self就相当于myclass对象本身。

2.在对象的内部如果调用本身的属性，self.属性

如果调用本身的属性，[self 方法]

4.super关键字

练习：

创建两个Point2对象，它有横坐标x，纵坐标y。

保存两个坐标值。

(1)普通方法set/get方法普通方法

TRPoint.h

#import <Foundation/Foundation.h>

@interface TRPoint : NSObject

{

//实例变量

int _x;//横坐标

int _y;//纵坐标

}

//普通方法

-(void)setX:(int)x;//赋值

-(int)getX;//取值

-(void)setY:(int)y;//赋值

-(int)getY;//取值

-(void)show;//查看横、纵坐标

@end

TRPoint.m

#import "TRPoint.h"

@implementation TRPoint

-(void)show{

//普通方法也可以访问实例变量

NSLog(@"横坐标:%d 纵坐标:%d",_x,_y);

//NSLog(@"横坐标:%d 纵坐标:%d",[self getX],[self getY]);

}//查看横、纵坐标

-(void)setX:(int)x{

_x = x;

}//赋值

-(int)getX{

return _x;

}//取值

-(void)setY:(int)y{

_y = y;

}//赋值

-(int)getY{

return _y;

}//取值

@end

main.m

TRPoint *p1 =[TRPoint alloc];

[p1 setX:3];//普通方法赋值

[p1 setY:4];

[p1 show];

结果：横坐标:3 纵坐标:4

(2)属性

<1>属性本质

<2>声明式属性

<3>ios5

<4>ios6

**show取值：

-(void)show{

1.//普通方法中可以直接访问实例变量

//NSLog(@"横坐标:%d 纵坐标:%d",_x,_y);

2.//getter方法也可以访问实例变量

//NSLog(@"横坐标:%d 纵坐标:%d",[self x],[self y]);

3.//属性可以访问实例变量

NSLog(@"横坐标:%d 纵坐标:%d",self.x,self.y);

}

(3)初始化方法

知识点

四、实例方法、类方法

1.方法分为两类：

1.实例方法

-开头的方法，都是实例方法；

通过实例调用的方法

[myClass method];

2.类方法

+开头的方法，都是类方法；

通过类调用的方法是类方法

[TRMyClass method2];

2.实例方法

-实例方法就是对象方法

-实例方法必须在定义对象之后,由对象来调用

3.类方法

-类方法就是静态方法 (代码区)

-类方法主要的使用就是用来创建对象的

- 类方法不能访问实例变量和属性，但类方法可以创建对象，通过对象访问实例变量和其属性

***类方法与实例方法区别

- 实例方法与实例有关系的,所以实例方法可以调用、读取实例中的实例变量或属性。

- 类方法与实例无关系的,所以类方法不可以调用、读取实例例中实例变量和属性。

- 在类方法中可以创建对象,当然访问该对象的实例变量和属性。

4.工厂方法

类方法用来创建对象的方法就是工厂方法

1.无参工厂方法

创建对象，并给属性一个默认值。

+(TRStudent*)student{

return [[TRStudent alloc]init];

}

2.有参工厂方法

1.要依赖有参的初始化方法

-(id)initWithAge:(int)age;

2.创建对象，并给属性一个指定的值

+(TRStudent*)studentWithAge:(int)age andSex:(char)sex andSalary:(double)salary{ //TRStudent*类型

return [[TRStudent alloc]initWithAge:age andSex:sex andSalary:salary];

}

规范：

工厂方法的方法名一定以类名开头,注意去除了前缀,首字母要小写

工厂方法，不但使用自定义类，官方的类也遵守这个规范

练习：重构5个对象的年龄、性别、工资工厂方法

完整程序：

TRStudent.h

#import <Foundation/Foundation.h>

@interface TRStudent : NSObject

@property int age;

@property char sex;

@property double salary;

//方法

-(void)show;

//有参初始化

-(id)initWithAge:(int)age andSex:(char)sex andSalary:(double)salary;

//无参的工厂方法

+(TRStudent*)student;

//有参工厂方法

+(TRStudent*)studentWithAge:(int)age andSex:(char)sex andSalary:(double)salary;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

//方法查看

-(void)show{

NSLog(@"age:%d sex:%c salary:%f",_age,_sex,_salary);

}

//有参初始化实现

-(id)initWithAge:(int)age andSex:(char)sex andSalary:(double)salary{

self=[super init];

if (self) {

_age=age;

_sex=sex;

_salary=salary;

}

return self;

}

//无参工厂方法实现

+(TRStudent*)student{

return [[TRStudent alloc]init];

}

//有参工厂方法实现

+(TRStudent*)studentWithAge:(int)age andSex:(char)sex andSalary:(double)salary{

return [[TRStudent alloc]initWithAge:age andSex:sex andSalary:salary];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//初始化方法使用

TRStudent* stu=[[TRStudent alloc]initWithAge:20 andSex:'F' andSalary:5600];

[stu show];

TRStudent* stu2=[TRStudent studentWithAge:18 andSex:'M' andSalary:5000];

[stu2 show];

//工厂方法使用

TRStudent* stu3=[TRStudent studentWithAge:19 andSex:'F' andSalary:5500];

[stu3 show];

}

return 0;

}

结果：

age:20 sex:F salary:5600.000000

age:18 sex:M salary:5000.000000

age:19 sex:F salary:5500.000000

5.单例模式（Singleton）

*有时候只需要一个对象，并且这个对象是唯一的，单例模式

利用类方法来创建和访问对象

*注：现在所说的单例不严谨，alloc还可以创建新的对象，要注意只能使用单例模式方法创建对象。

在多线程里面，会有办法解决alloc永远也只创建一个对象。

TRStudent.h

#import <Foundation/Foundation.h>

@interface TRStudent : NSObject

//类方法

//返回值类型也是对象类型

+(TRStudent*)shareStudent;

@end

TRStudent.m

#import "TRStudent.h"

//全局变量

static TRStudent* stu=nil;

@implementation TRStudent

+(TRStudent*)shareStudent{

if (stu==nil) {//原来没有创建过对象

stu=[[TRStudent alloc]init];

}

return stu;

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRStudent*stu1=[TRStudent shareStudent];

NSLog(@"%p",stu1);

TRStudent*stu2=[TRStudent shareStudent];

NSLog(@"%p",stu2);

}

return 0;

}

结果：

0x100202ff0

知识点

五、MRC内存管理

1.内存管理

在计算机中，堆内存的使用，是需要程序员手动创建，并且使用完毕

以后要手动销毁(回收)，这个过程叫做内存管理。

在OC中，内存管理又有两种方式：

MRC:手动内存管理完全由程序员控制

ARC:自动内存管理由程序员通知编译，编译帮我们控制

• 进程空间
- 代码区:只读。
- 堆:自己创建、自己回收释放,对象是保存在堆区的。

- 全局区:进程启动时分配,进行结束时释放。
- 栈:局部变量,自动创建、自动释放空间

2.MRC手动内存管理

注：ios6，强制使用ARC

*改项目内存管理

1.项目默认的内存管理是ARC，将内存管理改为MRC

项目—>Basic(选择ALL)—>右搜索（ARC）—>Apple LLVM 5.1-Language -Objective C （Automatic Reference Counting ） —>No

2.由于程序在执行的时候，不一定立刻回收堆内存，可能会出现异常，也可能不会出现。

Edit Schema->Run…->Diag…->Mem…Manage…Objective-C Enabel Zombie Objects 打开

MRC手动管理引用计数器

Manual手动

Reference Counting引用计数器

一、程序通过代码通知引用计数器做加1或减1操作：

1.向对象发送alloc、copy、new通知引用计数器加1.

在OC当对象不再使用时候，如果忘记发送release消息，内存溢出，资源浪费

2.当对象不再使用,发送release通知引用计数器减1.

3.当引用计数器为0时，会自动释放该对象的堆内存空间

4.当对象销毁时，会自动执行dealloc方法

当对象销毁时，对象中的实例变量、方法均不可用,内存管理存在的问题

二、内存管理存在的问题：

(1)如果对象销毁，但引用的值还在存，此时存在野指针问题，使用空指针解决野指针问题。

并且对象的实例方法与实例变量不可使用，否则会报异常、crash。

(2)如果对象未销毁，此时存在内存泄漏问题，造成资源浪费。

3.release和dealloc

1.[stu release];//销毁对象，引用计数器减1,变为0，自动执行dealloc

2.//当引用计数器为0时，会自动销毁对象

-(void)dealloc{

//真正的对象销毁由父类操作的

[super dealloc];}

4.retainCount和retain

1.[stu retainCount]//查看当前计数器的值RC

2.[stu retain];//通知引用计数器加1

3.[stu release];//通知引用计数器减1

//内存管理原则，哪里加1，就去哪里减1

5.声明式属性

a.不但解决了内存的赋值问题，还解决了内存问题。

b.默认情况下，声明式没有解决内存问题。

@property(retain) TRBook* book;解决内存问题

c.声明式属性只解决了setter(所有情况)/getter（没有内存问题）内存问题

注：减1操作，还是需要手动在dealloc方法里面解决

***总结：

一个对象的内存管理

两个引用共用一个对象的内存管理

一个对象的属性是引用类型的内存管理

一个对象的属性的引用如果发生改变时的内存管理

声明式属性的内存管理

一、一个对象的内存管理证明：（空指针和野指针问题）

TRStudent.h

#import <Foundation/Foundation.h>

@interface TRStudent : NSObject

-(void)study;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)study{

NSLog(@"学生具有学习的能力");

}

//当引用计数器为0时会自动销毁对象并自动执行该方法

-(void)dealloc{

NSLog(@"dealloc执行销毁stu");

//真正的对象销毁由父类操作的

[super dealloc];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//RC:1

TRStudent *stu = [[TRStudent alloc]init];

NSUInteger count = [stu retainCount];//可以查看对象引用计数器的值

NSLog(@"count:%lu",count);

[stu study];

//RC:0

NSLog(@"release销毁前");

[stu release];

//查看对象的引用计数器的值，在对象销毁后是可能有问题的

/* count = [stu retainCount];

NSLog(@"count2:%lu",count); */

//stu引用，相当于代表两个值

//stu引用指向对象的值(数据)

//stu引用本身的值(地址)

//在OC野指针问题也叫crash、异常

//在OC当对象不再使用时候，如果忘记发送release消息，内存溢出，资源浪费

stu = nil;//空指针解决野指针问题

//在OC当中，可以向空引用发送消息没有任何反应

NSLog(@"stu:%p",stu);

[stu study];//野指针

NSLog(@"release销毁后");

}

return 0;

}

结果：

count:1

学生具有学习的能力

release销毁前

dealloc执行销毁stu

stu:0x0

release销毁后

二、两个引用共用一个对象的内存管理

TRStudent.h

#import <Foundation/Foundation.h>

@interface TRStudent : NSObject

-(void)study;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)study{

NSLog(@"学生具有学习的能力");

}

//当引用计数器为0时会自动销毁对象并自动执行该方法

-(void)dealloc{

NSLog(@"dealloc销毁");

//真正的对象销毁由父类操作的

[super dealloc];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//RC:1

TRStudent *stu = [[TRStudent alloc] init];

stu和stu2共用一个内存空间

TRStudent *stu2 = stu;//引用赋值不会通知引用计数器加1

[stu2 retain];//通知引用计数器加1 RC:2

NSLog(@"RC:%lu",[stu retainCount]);

[stu study];

[stu release]; //通知引用计数器减1 //RC:2-1

[stu2 study];

[stu2 release];//RC:0

}

return 0;

}

结果：

RC:2

学生具有学习的能力

dealloc销毁

三、一个对象的属性是引用类型的内存管理证明

TRBook.h

#import <Foundation/Foundation.h>

@interface TRBook : NSObject

@property int price;

@end

TRBook.m

#import "TRBook.h"

@implementation TRBook

-(void)dealloc{

NSLog(@"TRBook销毁了");

[super dealloc];

}

@end

TRStudent.h

#import <Foundation/Foundation.h>

#import "TRBook.h"

@interface TRStudent : NSObject

{

TRBook* _book;

}

//setter/getter

-(void)setBook:(TRBook*)book;

-(TRBook*)book;

-(void)study;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)setBook:(TRBook*)book{

_book = book;

[_book retain];

}

-(TRBook*)book{

return _book;

}

-(void)study{

NSLog(@"学生具有学习的能力看书:%d",self.book.price);

}

//当引用计数器为0时会自动销毁对象并自动执行该方法

-(void)dealloc{

[_book release];

NSLog(@"TRStudent销毁了");

//真正的对象销毁由父类操作的

[super dealloc];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

#import "TRBook.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRBook *sanguo = [[TRBook alloc]init];

sanguo.price = 10;

TRStudent *stu = [[TRStudent alloc]init];

stu.book = sanguo;

[sanguo release];

[stu study];

[stu release];

//内存管理原则：哪里加1，哪里就有责任减1

}

return 0;

}

结果：

学生具有学习的能力看书:10

TRBook销毁了

TRStudent销毁了

四、一个对象的属性的引用如果发生改变时的内存管理

TRBook.h

TRBook.m

同上

TRStudent.h

同上

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)setBook:(TRBook*)book{

if (_book==nil) {

_book = book;

[_book retain];

}else{

[_book release];

_book = book;

[_book retain];

}

-(TRBook*)book{

return _book;

}

-(void)study{

NSLog(@"学生具有学习的能力看书:%d",self.book.price);

}

//当引用计数器为0时会自动销毁对象并自动执行该方法

-(void)dealloc{

[_book release];//三1 水1 学0

NSLog(@"TRStudent销毁了");

//真正的对象销毁由父类操作的

[super dealloc];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

#import "TRBook.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRBook *sanguo = [[TRBook alloc]init];

sanguo.price = 10;

//三1 水0 学0

TRBook *shuihu = [[TRBook alloc]init];

//三1 水1 学0

shuihu.price = 20;

TRStudent *stu = [[TRStudent alloc]init];

//三1 水1 学1

stu.book = sanguo;[sanguo release];//三1 水1 学1

[stu study];

stu.book = shuihu;

[stu study];//三1 水2 学1

[stu release];//三1 水2 学0

[shuihu release];//三1 水0 学0

//内存管理原则：哪里加1，哪里就有责任减1

}

return 0;

}

结果：

学生具有学习的能力看书:10

TRBook销毁了

学生具有学习的能力看书:20

TRStudent销毁了

TRBook销毁了

五、声明式属性的内存管理

TRBook.h

TRBook.m

同上

TRStudent.h

#import <Foundation/Foundation.h>

#import "TRBook.h"

@interface TRStudent : NSObject

{

//TRBook* _book;

}

@property(retain) TRBook* book;

//setter/getter

-(void)setBook:(TRBook*)book;

-(TRBook*)book;

-(void)study;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)study{

NSLog(@"学生具有学习的能力看书:%d",self.book.price);

}

//当引用计数器为0时会自动销毁对象并自动执行该方法

-(void)dealloc{

[_book release];//三1 水1 学0

NSLog(@"TRStudent销毁了");

//真正的对象销毁由父类操作的

[super dealloc];

}

@end

main.m

同上

6.自动释放池（autorelease）

1.可以通过自动释放池管理多个对象的release操作（仅一次）

2.当自动释放池结束的时候，会向池中每个对象发送release消息

3.注意两个问题：

a.一定要有代码块

@autoreleasepool{}

b.一定要手动将对象放入自动释放池中

[对象 autorelease ]

4.使用场景：

getter方法需要

工厂方法需要

代码使用场景复杂，也会需要

完整程序：

TRStufent.h

#import <Foundation/Foundation.h>

@interface TRStufent : NSObject

@end

TRStufent.m

#import "TRStufent.h"

@implementation TRStufent

-(void)dealloc{

NSLog(@"对象销毁");

[super dealloc];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStufent.h"

int main(int argc, const char * argv[])

{

//自动释放池

@autoreleasepool {//开始

//默认情况，对象是没有放入自动释放池

//需要向对象发送autorelease消息，才会将对象放入自动释放池管理

TRStufent* stu=[[[TRStufent alloc]init]autorelease];

TRStufent* stu2=[[[TRStufent alloc]init]autorelease];

NSLog(@"自动释放池末尾");

}

NSLog(@"程序末尾");

return 0;

}

结果：

自动释放池末尾

对象销毁

程序末尾

练习：

学生和书的故事，可否属性的本质（setter/getter）来解决。工厂方法

7.retain, assgin, copy, readonly，atomic，nonatomic关键字

声明式属性的使用：

声明式属性叫编译期语法

@property(retain,nonatomic)TRBook*book;

参数1：

retain：修饰引用（对象）数据类型

assgin：修饰基本数据类型（默认）

copy：一些对象需要复制才能使用NSString

readonly：只读，只有setter方法，没有getter方法

参数2：

保证多线程的安全性

atomic：原子性线程是安全的，但效率低（默认）

nonatomic：非原子性线程是不安全的，但效率高

练习：

有一个电脑TRComputer类,能干什么playGame, 显示cpu信息、mem信息。TRCpu类,有运行频率hz x G, TRMem类,有内存的容量size x G。

1.创建类、对象

第一次玩游戏 CS intelP3 1G hz KingMax 2G size

第二次玩游戏战地4 IntelP4 2G hz KingMax2 8G size

2.给类添加属性、初始化方法、工厂⽅法

3.声明式属性⽅方式,解决内存问题。

完整程序：

TRCpu.h

#import <Foundation/Foundation.h>

@interface TRCpu : NSObject

@property(nonatomic,assign) float hz;

-(id)initWithHz:(int)hz;

+(TRCpu*)cpuWithHz:(int)hz;

@end

TRCpu.m

#import "TRCpu.h"

@implementation TRCpu

-(id)initWithHz:(int)hz{

self = [super init];

if (self) {

self.hz = hz;

}

return self;

}

+(TRCpu*)cpuWithHz:(int)hz{

return [[[TRCpu alloc]initWithHz:hz] autorelease];

}

-(void)dealloc{

NSLog(@"cpu销毁了hz:%f",self.hz);

[super dealloc];

}

@end

TRMem.h

TRMem.m

同上

TRComputer.h

#import <Foundation/Foundation.h>

#import "TRCpu.h"

#import "TRMem.h"

@interface TRComputer : NSObject

@property(nonatomic,retain)TRCpu *cpu;

@property(nonatomic,retain)TRMem *mem;

-(id)initWithCpu:(TRCpu*)cpu andMem:(TRMem*)mem;

+(TRComputer*)computerWithCpu:(TRCpu*)cpu andMem:(TRMem*)mem;

-(void)playGame;

@end

TRComputer.m

#import "TRComputer.h"

@implementation TRComputer

-(id)initWithCpu:(TRCpu*)cpu andMem:(TRMem*)mem{

self = [super init];

if (self) {

//_cpu = cpu;[_cpu retain];

self.cpu = cpu;

self.mem = mem;

}

return self;

}

+(TRComputer*)computerWithCpu:(TRCpu*)cpu andMem:(TRMem*)mem{

return [[[TRComputer alloc]initWithCpu:cpu andMem:mem] autorelease];

}

-(void)playGame{

NSLog(@"cpu hz:%f mem size:%f",self.cpu.hz,self.mem.size);

}

-(void)dealloc{

[self.cpu release];

[self.mem release];

NSLog(@"computer对象销毁了");

[super dealloc];

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRComputer.h"

#import "TRCpu.h"

#import "TRMem.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRCpu *intelP3 = [TRCpu cpuWithHz:1];

TRMem *kingMax = [TRMem memWithSize:2];

TRComputer *computer = [TRComputer computerWithCpu:intelP3 andMem:kingMax];

[computer playGame];

TRCpu *intelP4 = [[[TRCpu alloc]initWithHz:2] autorelease];

TRMem *kingMax2 = [[[TRMem alloc]initWithSize:8]autorelease];

computer.cpu = intelP4;

computer.mem = kingMax2;

[computer playGame];

}

return 0;

}

结果：

cpu hz:1.000000 mem size:2.000000

cpu hz:2.000000 mem size:8.000000

cpu销毁了hz:2.000000

mem size:8.000000 销毁了

computer对象销毁了

mem size:2.000000 销毁了

cpu销毁了hz:1.000000

知识点

六、面向对象的三大特性及封装

1.封装

1.将信息（属性、方法）封装在一个对象中，

只给外界公开访问的接口, 而且把具体实现隐藏起来

需要公开的内容在.h文件中声明，不需要公开的内容在.m文件中实现（隐藏源代码）

2.好处：增强可读性、可维护性、可扩展性

1)代码结构更清晰
2)可以和第三方合作,但又保护了源代码,避免泄漏

2.继承

1.继承是一种代码复用技术,是类与类之间的一种关系(与内存关)。
2.A类继承B类,A类中就直接拥有B类中的属性和方法。我们就把A类叫B类的子类(派生类),把B类叫做A类的父类(基类)。OC中的继承为单继承。
3. 继承是一种关系:继承是类与类之间的关系,是一种“is a”关系。狗是动物狗:动物

4.方法的重写：如果重写父类的方法,优先调用子类的方法,如果子类没有重写父类的方法,则调用父类的方法

5.继承的优缺点

1.提高了程序的复杂度,维护性和扩展性降低

2.破坏类的封装性

6.为什么使用继承

1.代码复用

2.制定规则

3.为了多态

完整程序：

TRAnimal.h

#import <Foundation/Foundation.h>

//子类继承父类

//子类将拥有父类所有的属性和方法

@interface TRAnimal : NSObject

@property(nonatomic,assign)int age;

-(void)eat;

@end

TRAnimal.m

#import "TRAnimal.h"

@implementation TRAnimal

-(void)eat{

NSLog(@"%d岁的狗狗嗅一下",self.age);

}

@end

TRCat.h

TRCat.m

-(void)eat{

NSLog(@“喵喵喵);//方法的重写（方法名相同、参数类型相同）优先调用子类

}

TRDog.h

TRDog.m

以上的TRDog继承了TRAnimal的特性，只需在创建类的时候把NSObject改为TRAnimal父类

main.m

#import <Foundation/Foundation.h>

#import "TRAnimal.h"

#import "TRDog.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRAnimal* animal=[[TRAnimal alloc]init];

animal.age=3;

[animal eat];

TRDog* dog=[[TRDog alloc]init];

dog.age=2;

[dog eat];

TRCat* dog=[[TRCat alloc]init];

[cat eat];

}

return 0;

}

结果：

3岁的狗狗嗅一下

2岁的狗狗嗅一下

喵喵喵

3.组合(一体机)

1.表示两个对象之间是整体和部分的强关系,是“contains- a”关系

2.部分的生命周期不能超越整体

TRCpu.h

#import <Foundation/Foundation.h>

@interface TRCpu : NSObject

-(void)run;

@end

TRCpu.m

#import "TRCpu.h"

@implementation TRCpu

-(void)run{

NSLog(@"cpu运行了");

}

@end

TRComputer.h

#import <Foundation/Foundation.h>

#import "TRCpu.h"

@interface TRComputer : NSObject

-(void)powerOn;

-(void)start;

-(id)init;

@end

TRComputer.m

#import "TRComputer.h"

@interface TRComputer()

@property(nonatomic,retain)TRCpu* cpu;

@end

@implementation TRComputer

-(id)init{

self = [super init];

if (self) {

self.cpu = [[TRCpu alloc]init];组合体现

}

return self;

}

-(void)powerOn{

NSLog(@"接通电源");

[self.cpu run];

[self start];

}

-(void)start{

NSLog(@"开始使用电脑");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRComputer.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//一体机

TRComputer *computer = [[TRComputer alloc]init];

[computer powerOn];

}

return 0;

}

结果：

接通电源

cpu运行了

开始使用电脑

4.聚合（台式机）

1.表示两个对象之间是整体和部分的弱关系,是“has a”关系

2. 部分的生命周期可以超越整体

TRCpu.h

TRCpu.m

同上

TRComputer.h

#import <Foundation/Foundation.h>

#import "TRCpu.h"

@interface TRComputer : NSObject

@property(nonatomic,retain)TRCpu* cpu;

-(void)powerOn;

-(void)start;

@end

TRComputer.m

#import "TRComputer.h"

@implementation TRComputer

-(void)powerOn{

NSLog(@"接通电源");

[self.cpu run];

[self start];

}

-(void)start{

NSLog(@"开始使用电脑");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRCpu.h"

#import "TRComputer.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//台式机

TRCpu *cpu = [[TRCpu alloc]init];

TRComputer *computer = [[TRComputer alloc]init];

computer.cpu = cpu;

[computer powerOn];

}

return 0;

}

结果：

接通电源

cpu运行了

开始使用电脑

知识点

十七、多态

1.多种形态，包括引用多态、方法多态。

a.引用多态

父类的引用可以指向本类对象

父类的引用也可以指向子类对象

b.方法多态 (如果引用指向子类对象)

如果子类重写了父类的方法，则优先调用子类的方法

如果子类没有重写父类的方法，则调用父类的方法

多态的引用只能调用父类的共享属性、方法，不能调用子类独有的方法

2.好处：可以让我们设计更合理的代码,使用代码更通用,使用程序的

可维护性和可扩展性更强

例：

TRAnimal.h

#import <Foundation/Foundation.h>

@interface TRAnimal : NSObject

-(void)eat;

@end

TRAnimal.m

#import "TRAnimal.h"

@implementation TRAnimal

-(void)eat{

NSLog(@"动物具有吃的能力");

}

@end

"TRDog.h

#import "TRAnimal.h"

@interface TRDog : TRAnimal

-(void)watchDoor;

@end

"TRDog.m

#import "TRDog.h"

@implementation TRDog

-(void)watchDoor{

NSLog(@"狗是有看家的能力的");

}

-(void)eat{

NSLog(@"狗是吃骨头的");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRAnimal.h"

#import "TRDog.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//XX对于一个引用变量,可以指向任何类的对象

//多态：引用多态父类引用可以指向本类对象或子类对象

TRAnimal *animal = [[TRAnimal alloc]init];

TRAnimal *animal2 = [[TRDog alloc]init];

//多态的引用只能调用父类的共享属性、方法，不能调用子类独有的方法

//[animal2 watchDoor];

//多态：方法多态

[animal eat];

//如果子类重写了父类的方法，优先调用子类的方法，如果子类没有重写父类的方法，则调用父类的方法

[animal2 eat];

}

return 0;

}

2.多态可以用于数组

代码可以灵活处理一系列的数据

TRTransportation* trans[3] = {tran1,tran2…};

例：

@autoreleasepool {

TREmployee *e1 = [TRManager managerWithName:@"zhangsan" andJob:@"coder" andSalary:8000.0f];

TREmployee *e2 = [TRManager managerWithName:@"li" andJob:@"tester" andSalary:6500.0f];

TREmployee *e3 = [TRStaff staffWithName:@"wangwu" andJob:@"coder" andSalary:6000.0f];

TREmployee *e4 = [TRStaff staffWithName:@"zhaoliu" andJob:@"tester" andSalary:4500];

//多态可以使用在数组中

//引用多态

TREmployee* emps[4]={e1,e2,e3,e4};

for (int i=0; i<4; i++) {

[emps[i] show];//方法多态

}

3.多态可以用于方法的参数（最终的类）

方法可以灵活处理一系列的参数

TRTaxi.h

#import "TRTransportation.h"

@interface TRTaxi : TRTransportation

@end

TRTaxi.m

#import "TRTaxi.h"

@implementation TRTaxi

-(void)show{

NSLog(@"交通工具为的士");

}

@end

TRBus.h

#import "TRTransportation.h"

@interface TRBus : TRTransportation

@end

TRBus.m

#import "TRBus.h"

@implementation TRBus

-(void)show{

NSLog(@"交通工具为巴士");

}

@end

TRBike.h

#import "TRTransportation.h"

@interface TRBike : TRTransportation

@end

TRBike.m

#import "TRBike.h"

@implementation TRBike

-(void)show{

NSLog(@"交通工具为自行车");

}

@end

TRStudent.h

#import <Foundation/Foundation.h>

#import "TRTransportation.h"

@interface TRStudent : NSObject

-(void)gotoSchoolByTran:(TRTransportation*)tran;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

//参数多态

-(void)gotoSchoolByTran:(TRTransportation*)tran{

NSLog(@"学生上学乘坐:");

[tran show];

}

@end

TRTransportation.h

#import <Foundation/Foundation.h>

@interface TRTransportation : NSObject

-(void)show;

@end

TRTransportation.m

#import "TRTransportation.h"

@implementation TRTransportation

-(void)show{

NSLog(@"显示交通工具的信息");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRTransportation.h"

#import "TRTaxi.h"

#import "TRBus.h"

#import "TRBike.h"

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRTransportation* tran = [[TRTaxi alloc]init];

TRBus *bus = [[TRBus alloc]init];

TRBike *bike = [[TRBike alloc]init];

TRStudent *stu = [[TRStudent alloc]init];

[stu gotoSchoolByTran:bike];

}

return 0;

}

结果：

学生上学乘坐:

交通工具为自行车

4.多态可以用于方法的返回值类型（第二大类）

方法的返回值类型更加灵活，可以返回一系列对象

例：

其他文件内容不变，改以下：

TRTransportation.h

#import <Foundation/Foundation.h>

typedef enum{BIKE,BUS,TAXI} type;

@interface TRTransportation : NSObject

+(TRTransportation*)getTranByNum:(type)t;

-(void)show;

@end

TRTransportation.m

#import "TRTransportation.h"

#import "TRBike.h"

#import "TRBus.h"

#import "TRTaxi.h"

@implementation TRTransportation

+(TRTransportation*)getTranByNum:(type)t{

switch (t) {

case BIKE:

return [[TRBike alloc]init];

break;

case BUS:

return [[TRBus alloc]init];

break;

case TAXI:

return [[TRTaxi alloc]init];

break;

default:

return nil;

break;

}

-(void)show{

NSLog(@"显示交通工具的信息");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRTransportation.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRTransportation *tran = [TRTransportation getTranByNum:TAXI];

[tran show];

}

return 0;

}

结果：

交通工具为的士

作业：

练习：重构

1.写出以下类，用最少的代码解决问题。

TRShape形状类

|—————+—————|

TRRectangle矩形x,y TRCircle圆形r

TRSquare正方形x

求：周长perimeter与面积area，show方法查看周长和面积。(输出显示)

要使用属性、初始化方法、工厂方法、内存管理、继承。

2.创建一个TREmployee类，TRStaff普通职员，TRManager领导，工资salary、工种job、姓名name，方法输出个人信息show方法，如果相应的工种领导的工资会比较普通职员高2000。TRHR类，人力资源，通过参数来招人，最少代码解决。(初始化方法、工厂方法、内存管理)

1.软件工程师coder 6000 2.测试工程师4500 3.高级软件工程师8000

4.软+领 5.测+领 6.高软+领

查看所有员工的信息？（TRHR通过工厂方法，多态返回值给TREmployee）

TRHR.h

#import <Foundation/Foundation.h>

#import "TREmployee.h"

@interface TRHr : NSObject

//工厂方法

+(TREmployee*)hrWithNum:(int)num;

@end

TRHR.m

#import "TRHR.h"

#import "TRStaff.h"

#import "TRManager.h"

@implementation TRHr

+(TREmployee *)hrWithNum:(int)num{

switch (num) {

case 1:

return [[TRStaff alloc]initWithName:@"张三" andJob:@"软件工程师" andSalary:6000.0f];

break;

case 2:

return [[TRStaff alloc]initWithName:@"李四" andJob:@"测试工程师" andSalary:4500.0f];

break;

case 3:

return [[TRStaff alloc]initWithName:@"王五" andJob:@"高级软件工程师" andSalary:8000.0f];

break;

case 4:

return [[TRManager alloc]initWithName:@"赵六" andJob:@"软件工程师领导" andSalary:6000.0f];

break;

case 5:

return [[TRManager alloc]initWithName:@"钱七" andJob:@"测试工程师领导" andSalary:4500.0f];

break;

case 6:

return [[TRManager alloc]initWithName:@"黑八" andJob:@"高软件工程师领导" andSalary:8000.0f];

break;

default:

return nil;

break;

}

@end

main.m

@autoreleasepool {

TREmployee* emps[3];

TREmployee* emp1 = [TRHr hrWithNum:1];

TREmployee* emp2 = [TRHr hrWithNum:4];

TREmployee* emp3 = [TRHr hrWithNum:2];

emps[0] = emp1;

emps[1] = emp2;

emps[2] = emp3;

for (int i = 0; i<3; i++) {

[emps[i] print];

}

3./*创建一个Person类，show方法，*/查看艺术品的详细信息。print查看当前艺术品的详细。创建三个艺术品，分别查看它们的信息。

艺术品名称product 作者author 年代year

演唱者singer 时长time 人数count

Arts艺术品（父类）多态参数返回给Person类

|—————+—————|

Painting(油画) Music(音乐)

|———+——|

Pop(流行音乐) Rock(摇滚)

TRPerson.h

#import <Foundation/Foundation.h>

#import "TRArts.h"

@interface TRPerson : NSObject

-(void)show:(TRArts*)art;

@end

TRPerson.m

#import "TRPerson.h"

@implementation TRPerson

-(void)show:(TRArts*)art{

[art print];

}

@end

main.m

@autoreleasepool {

TRArts *a1 = [TRPainting paintingWithProduct:@"蒙娜丽莎" andAuthor:@"达芬奇" andYear:1780];

//[a1 print];

TRArts *a2 = [TRPop popWithProduct:@"小苹果" andAuthor:@"筷子兄弟" andYear:2014 andSinger:@"筷子兄弟" andTime:3.5f];

//[a2 print];

TRArts *a3 = [TRRock rockWithProduct:@"尽情摇摆" andAuthor:@"未知" andYear:2000 andSinger:@"Beyond" andTime:4.5 andCount:5];

//[a3 print];

TRArts* arts[3] = {a1,a2,a3};

TRPerson *person = [[TRPerson alloc]init];

for (int i=0; i<3; i++) {

[person show:arts[i]];

}

二、协议

xcode6

source->OC File->type(protocol)

1.协议Protocol

协议指的是双方(苹果公司,程序员)的约定。

遵守一个约定，就等增强类的功能。

双方(程序员,程序员)

a.协议语法:

@protocol 协议名<父协议>

@required（默认）

必须遵守的属性或方法

drive;方法

@optional

可以遵守的属性或方法

@end

b.遵守协议

(1)类必须遵守协议

@interface 类名:父类名<协议>

(2)必须协议的方法

在.m文件中，必须实现协议中要求的方法

c.协议的使用

父类引用可以指向子类(类型)的对象

协议引用可以指向任意类(类型)的对象(遵守协议)(方法属性)

//任意类型

id<协议> p = 对象<遵守协议实现方法>;

只能调用协议中定义的方法

[p 协议中的方法消息];

p.协议中的属性;

d.协议的引用

可以用在数组，可以用在参数，也可以用在返回值类型。

TRProtocol.h

#import <Foundation/Foundation.h>

//协议中只有方法的声明没有方法的实现

@protocol TRProtocol <NSObject>//协议名称默认@required

-(void)method;

@end

TRMyClass.h

#import <Foundation/Foundation.h>

#import "TRProtocol.h"

//遵守协议必须实现协议中的方法

@interface TRMyClass : NSObject<TRProtocol>

-(void)method2;

@end

TRMyClass.m

#import "TRMyClass.h"

@implementation TRMyClass

-(void)method2{

NSLog(@"类自己的方法");

}

-(void)method{

NSLog(@"实现了协议的方法");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRProtocol.h"

#import "TRMyClass.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//协议引用

//协议引用可以指向任意"类型"遵守了协议的对象

id<TRProtocol> p = [[TRMyClass alloc]init];

//通过协议引用可以调用协议中的方法

[p method];

//只能调用协议方法，不可以调用类方法

//[p method2];

//用于数组、参数、返回值类型

}

return 0;

}

结果：

实现了协议的方法

1.协议与多态

1.多态关注的是类的类型，

2.而协议并不关注类的类型，关注的是类的方法和属性

2.协议的继承

1.协议的继承相当于协议的合并

2.协议的引用只能调用协议中声明的方法或属性。

例：

TRTarena1.h

#import <Foundation/Foundation.h>

@protocol TRTarena1 <NSObject>

-(void)study;

@end

TRTarena2.h

#import <Foundation/Foundation.h>

#import "TRTarena1.h"

//子协议继承父协议

@protocol TRTarena2 <TRTarena1>

-(void)learn;

@end

TRStudent.h

#import <Foundation/Foundation.h>

#import "TRTarena2.h"

@interface TRStudent : NSObject<TRTarena2>

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)learn{

NSLog(@"子协议中要求的方法");

}

-(void)study{

NSLog(@"父协议中要求的方法");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRTarena1.h"

#import "TRTarena2.h"

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

//协议的引用只能调用协议中声明的方法

id<TRTarena1> p = [[TRStudent alloc]init];

[p study];

//协议的继承，相当于协议的合并

//协议的引用只能调用协议中声明的方法

id<TRTarena2> p2 = [[TRStudent alloc]init];

[p2 learn];

[p2 study];

}

return 0;

}

结果：

父协议中要求的方法

子协议中要求的方法

父协议中要求的方法

3.多个协议

一个类可以遵守多个协议，也相当于协议的合并

@interface 类：父类<协议1，协议2>

TRStudent.h遵守协议的时候

#import <Foundation/Foundation.h>

#import "TRTarena6.h"

#import "TRTarena2.h"

@interface TRStudent : NSObject<TRTarena2,TRTarena6>

4.**协议中要求的属性，我们在遵守的时候要合成一下属性

5.协议也可以与类定义在一个文件中（只需将协议中的内容复制到类的定义中）

TRStudent.h

#import <Foundation/Foundation.h>

#import "TRTarena6.h"

//#import "TRTarena2.h"

#import <Foundation/Foundation.h>//遵守协议时只需将协议TRTarena2中的文件复制过来

@protocol TRTarena2 <NSObject>

@end

@interface TRStudent : NSObject <TRTarena6>

@end

知识点

七、分类

增强类能力

a.继承：优点与缺点都继承了

b.协议：要修改源代码

c.分类：可以灵活的给指定的类添加能力，不需要修改源代码

一、分类

1.语法规则：

分类文件命名：主类类名+分类类名

#import "TRPerson+TRWeapon.h"

2. *.h文件存放分类的声明部分内容

@interface 主类类名(分类类名)

//添加方法声明

@end

*.m文件存放分类的实现部分内容

@implementation 主类类名(分类类名)

//添加方法实现
@end

3.在主函数中导入分类头文件，主类对象既可以调用分类的方法

**注：1.分类中是不可以声明实例变量的,自然也不可以创建属性

2. 在分类中是可以访问主类的属性,也可以访问主类的实例变

TRPerson.h

#import <Foundation/Foundation.h>

@interface TRPerson : NSObject

{

int _i;//主类中声明实例变量

}

@property int i;//主类中声明属性

-(void)job;

@end

TRPerson.m

#import "TRPerson.h"

@implementation TRPerson

@synthesize i = _i;//主类中合成实例变量

-(void)job{

NSLog(@"具有工作的能力");

}

@end

TRPerson+TRWeapon.h

#import "TRPerson.h"

//主类类名分类类名

@interface TRPerson (TRWeapon)

{

//int _i;//分类中不可以添加实例变量

}

//@property int i;//分类中属性是没有意义的

-(void)fire;

@end

TRPerson+TRWeapon.m

#import "TRPerson+TRWeapon.h"

@implementation TRPerson (TRWeapon)

//@synthesize i = _i;//

-(void)fire{

_i = 10;//分类中是可以访问主类的实例变量

self.i = 20;//分类中是可以访问主类的属性

NSLog(@"具有了开火的能力");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRPerson.h"

#import "TRPerson+TRWeapon.h"

#import "NSString+TRConnection.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

TRPerson *person = [[TRPerson alloc]init];

[person job];

[person fire];

}

return 0;

}

具有工作的能力

具有了开火的能力

2.给系统类添加分类

*分类不但可以给自己添加分类，还可以给系统添加分类。

可以给系统提供的类,如NSObject、NSString等,添加分类

NSString+TRFunction.h

如：NSString* n=[[NSString alloc]init];

[n function];

二、扩展

1.扩展是一个特殊的分类。没有扩展名。

2.保存的文件命名:

主类类名_扩展的文件名.h 只有.h文件

TRPerson_TRExtension.h

3.***扩展只能在类的.m文件中使用

4.可以给一个类添加私有的实例变量、方法、属性

例：

TRPerson.h

#import <Foundation/Foundation.h>

@interface TRPerson : NSObject

{

int _i;

}

@property int i;

-(void)job;

@end

TRPerson.m

#import "TRPerson.h"

//#import "TRPerson_TRExtension.h"

@interface TRPerson ()//同上，只是复制过来

{

int _i2;//扩展中声明实例变量

}

-(void)method;//扩展中添加的方法

@property int i2;

@end

@implementation TRPerson

@synthesize i = _i;

-(void)method{

_i2 = 10;

//self.i2 = 20;

NSLog(@"添加一个私有的方法。%d",self.i2);

}

//类本身具有的方法

-(void)job{

//_i = 30;

self.i = 40;

NSLog(@"具有工作的能力%d",self.i);

}

@end

TRPerson_TRExtension.h

#import "TRPerson.h"

@interface TRPerson ()

-(void)method;//添加的方法

@end

main.m

#import <Foundation/Foundation.h>

#import "TRPerson.h"

#import "TRPerson_TRExtension.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

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

[p job];

[p method];

}

return 0;

}

结果：

具有工作的能力40

添加一个私有的方法。10

• 分类与扩展的区别

- 分类:是不可以声明实例变量,通常是公开的,文件名通常为:"主类类名+分类类名.h”

- 扩展:是可以声明实例变量,是私有的,文件名通常为:“主类类名_扩展标识.h”,注意没有扩展名的

知识点

八、ARC内存管理

1.强引用：(__strong) 强引用指向对象的时候，会自动通知引用计数器加1，当超出强引用的作用域，会自动通知引用计数器减1。（系统默认为强引用）

TRStudent.h

#import <Foundation/Foundation.h>

@interface TRStudent : NSObject

-(void)study;

@end

TRStudent.m

#import "TRStudent.h"

@implementation TRStudent

-(void)study{

NSLog(@"学生具有学习的能力");

}

-(void)dealloc{

NSLog(@"学生对象销毁了");

}

@end

main.m

#import <Foundation/Foundation.h>

#import "TRStudent.h"

int main(int argc, const char * argv[])

{

@autoreleasepool {

__strong TRStudent *stu2 = nil;

if (1==1) {

//默认就是强引用

TRStudent *stu = [[TRStudent alloc]init];//通知引用计数器为1

stu2 = stu;//RC:1+1=2 retain

NSLog(@"代码块末尾");

}//通知引用计数器减1 RC:2-1

[stu2 study];

}//RC:1-1=0 销毁了

NSLog(@"程序末尾");

return 0;

}

结果：

代码块末尾

学生具有学习的能力

学生对象销毁了

程序末尾

2.弱引用：(__weak)仅仅的是指向对象，并不会通知引用计数器做加1或减1操作。而且不存在野指针问题，当对象不存在的时候，弱引用会自动置空。

**注意：创建对象时候，不可使用弱引用。

3. _unsafe_unretain关键字

1.@property(nonatomic,unsafe_unretained)int age;

2.- unsafe_unretained等同于“assgin”,功能和__weak几乎一样,唯一不同,没有“zeroing weak reference”,通常使用在基本数据类型

4.ARC与MRC混编

（1）手动把MRC的代码转换成ARC的代码

retain=>strong release、autorelease、[super dealloc]删除掉

（2）自动将MRC转换成ARC的功能

1.由 xcode帮我们删掉相应的方法：

菜单栏(Edit)->Refacotor(重构)->Convert to Objective-C ARC

恢复到MRC：File->Restore snapshot……

2.通知编译器继续编译MRC代码：

项目栏->Build Phases->Compile Sources(1 item)->选择文件双击->- fno-objc-arc

恢复到MRC：-fobjc-arc

posted @ 2015-12-14 20:00 乌托邦小余阅读(436) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

夜鹰噬魂

iOS9基础知识（OC）笔记

公告