IOS面试攻略
来自:伊甸网
@
看到这个关键字,我们就应该想到,这是Object-C对C语言的扩展,例如@interface XXX。
@interface
声明类
@implementation
实现类
@protocol
声明协议
@optional
与@protocol配合使用,说明协议中的某个或者某几个方法可以不实现
@required
与@protocol配合使用,说明协议中的某个方法或者某几个方法必须实现
@end
与@interface ,@implementation,@protocol配合使用,代表声明或者实现结束
@encode
@encode为编译器宏,它可以将类型转换为相应的字符串(const char *)。
id
id是指向Objective-C类对象的指针,它可以声明为任何类对象的指针,当在Objective-C中使用id时,编译器会假定你知道id指向哪个类的对象。与void*是不同的是,void*编译器不知道也不假定指向任何类型的指针。
nil
定义为一个常量,如果一个指针的值为nil,代表这个指针没有指向任何对象。
self
在Objective-C中,关键字self与c++中this是同一概念,就是类对象自身的地址,通过self可以调用自己的实例变量和方法
Super
当子类需要调用父类的方法时,会用到Super关键字. Super指向的是父类的指针,子类重写父类的方法时,调用父类的方法是一个比较好的习惯。因为当我们不知道父类在该方法中实现的功能时,如果不调用父类的方法,有可能我们重写的方法会失去该功能,这是我们不愿意看到的情况。
NSNull
NSNull是没有的意思,如果一个字典的值为NSNull,那说明与该值对应的Key是没有值的,例如Key为address,说明与address对应的是值是没有。
self super class public protected private id
[self class] [super class] selector
objective-c runtime reference
标准用法
self = [super init]
new
1 Objective-C有一个特性,就是可以把类当成对象来发送消息,这种用法通常用于新建对像时,例如 XXX *object = [XXX new];
类方法 +
如果想声明属于类而不属于类对象的方法,用+。+用来修饰类的方法,使用+修饰的类方法,是整个类的方法,不属于哪一个类对象,这与C++中的static在类中使用的概念一样,
%@
在NSLog中,使用%@表示要调用对象的description方法。
概念
类
是一种结构,它表示对象的类型,就像int与 char 一样,也可以声明类的变量(对像)
实例化
为类的对象分配内存和初始化,达到可以使用该 类对象的目的。
对象(实例)
类的实例化后的产物
消息
在 Object-C中,类的对象执行的操作,是通过给该类或者该类对象发送消息实现,如:[object func];就是给object对象发送 func消息,类似C++中的方法调用。给object对象发送func消息后,object对象查询所属类的func方法执行。
方法调度
当向一个对象发送消息时(调用方法),这个方法是怎么被调用的呢?这就依赖于方法高度程序,方法调度程序查找的方法如下:
在本类的方法中,找被调用的方法,如果找到了,就调用,如果找不到被沿着继承路径去查找,从哪个类找到,就调用哪个类的方法,如果到最根上的类还是没有找到,那编译就会出错。
继承与复合
在Objective-C中支持继承,但只是支持单一继承(有且只有一个父类有),如果想使用多继承的特性,可以使用分类和协议技术。
继承是is-a,复合是has-a。复合是通过包含指向对象的指针实现的,严格意义上讲,复合是针对于对象间来说,对于基本数据类型来说,它们被认为是对象的一部分。
装箱与拆箱
由于NSArray,NSDirectory等类不能直接存储基本数据类型,所以要想在NSArray\NSDirectory中使用基本数据类型,就得使用装箱与拆箱。
在Objective-C中,可以使用NSNumber和NSValue来实现对数据类型的包装,NSNumber可以实现对基本数据类型的包装,NSValue可以实现对任意类型数据的包装。
将基本类型封装成对象叫装箱,从封装的对象中提取基本类型叫拆箱(取消装箱),其它语言如Java原生支持装箱与拆箱,Ojbective-C不支持自动装箱与拆箱,如果需要得需要自己来实现装箱与拆箱。
存取方法
在 使用类对象的实例变量(成员数据)时,不要直接使用对象中的实例,要使用存以方法来获取或者修改实例,既setter和getter,在 Cocoa中, 存取方法有命名习惯,我们得符合这种习惯,以便于与其它团队成员合作。setter方法是修改或者设置实例值,命名习惯为set+实例名,例有一个类有 path实例变量,那setter命名为setPath,getter命名为Path,为什么不是getPath,因为get在Cocoa中有特殊的含 义,这个含义就是带有get的方法就意味着这个方法通过形参指针(传入函数的参数指针)来返回值。我们要遵守这个命名习惯或者说规则。
在Objective-C 2.0中加入了@property和@synthesize来代替setter和getter,这两个关键字为编译器指令。还有点表达式,存取类成员的值时,可以使用点表达式。
Object.attribute,当点表达式在=号左边时,调用的是setter方法,在=号右边时,调用的是getter方法。
@property 语法为:@property (参数) 类型 变量名.
在这里主要说明一下参数.
参数分为三种:
第一种:读写属性包括(readonly/readwrite/)
第 二种:setter属性(assign,copy,retain),assign是简单的赋值,copy是释放旧成员变量,并新分配内存地址给成 员 变量,将传入参数内容复制一份,给成员变量。retain是将传入 参数引用计数加1,然后将原有的成员变量释放,在将成员变量指向该传入参数。
第三种:与多线程有关(atomic,nonatomic).当使用多线程时,使用atomic,在不使用多线程时使用nonatomic
对象创建与初始化
在Objective-C中创建对象有两种方法,一种是[类 new];另一种是[[类 alloc] init],这两种方法是等价的,但按惯例来讲,使用[[类 alloc] init];
alloc操作是为对象分配内存空间,并将对象的数据成员都初始,int 为0,BOOL 为NO, float 为0.0等。
初始化,默认的初始化函数为init,init返回值为id,为什么回返回id呢,因为要实现链式表达式,在Objective-C中叫嵌套调用。
为什么要嵌套调用??因为初始化方法init返回值可能与alloc返回的对象不是同一个?为什么会发生这种情况?基于类簇的初始化,因为init可以接受参数,在init内部有可能根据不同的参数来返回不同种类型的对象,所以最会发生上面说的情况。
在初始化时,建议使用if (self = [super init])
便利初始化
当一个类需要根据不同的情况来初始化数据成员时,就需要便利初始化函数,与init初始化不同的是,便利初始化函数有参数,参数个数可以有1到N个,N是类数据成员个数。
指定初始化函数:什么是指定初始化函数?在类中,某个初始化函数会被指定为指定的初始化函数,确定指定初始化函数的规则是初始化函数中,参数最多的为指定初始化函数,
其它未被指定为指定初始化函数的初始化函数要调用指定初始化函数来实现。对于该类的子类也是一样,只要重写或者直接使用父类的指定初始化函数。上述文字有些绕,来个例子吧
@interface A{
int x;
int y;
}
-(id) init;
-(id) initWithX:(int) xValue;
-(id) initWithY:(int) yValue;
-(id) initWithXY:(int) xValue
yVal:(int) yValue;
@end
这里initWithXY被确定为指定初始化函数。
-(id) initWithXY:(int) xValue
yVal:(int) yValue{
if (self = [super init]){
x = xValue;
y = yValue;
}
return self;
}
-(id) init{
if (self = self initWithXY:10
yVal:20){
}
return self;
}
.......
@interface B: A{
int z;
}
-(jd) initWithXY......;
@end
@implementation B
-(id) initWithXY:(int) xValue
yVal:(int) yValue{
if (self = [super initWithXY:10
yVal=20]){
z= 40;
}
return self;
}
@end
自动释放池
内存管理是软件代码中的重中之重,内存管理的好坏,直接影响着软件的稳定性。在Cocoa中,有自动释放池,这类似于C++中的智能指针。
NSObject有一个方法是autorelease,当一个对象调用这个方法时,就会将这个对象放入到自动释放池中。
drain,该方法是清空自动释放池,不是销毁它。drain方法只适用于Mac OS X 10.4以上的版本,在我们写的代码中要使用release,release适用于所有版本。
自 动释放池是以栈的方式实现,当创建一个自动释放池A时,A被压入栈顶,这时将接入autorelease消息的对象放入A自动释放池,这时创建一 个新的 B自动释放池,B被压入栈顶,创建完成后删除B,这个接收autorelease消息的对象依然存在,因为A自动释放池依然存在。
引用计数
每个对象都有一个与之相应的整数,称它为引用计数,当该引用计数为0时,Objective-C自动向该对象发送dealloc,以销毁该对向,与该引用计数相关的方法(消息)有下面几个
1 增加引用计数:通过alloc,new,copy创建一个对象时,该对象的引用计数加1(其实就是1,因为之前为0)
2 增加引用计数: retain
3 减少引用计数: release
局部分配内存(临时对象):
1 如果使用alloc,new,copy创建对象,则需要主动调用对象的release方法
2 如果使用非alloc,new,copy创建对象,我们认为该对象引用计数为1,并已经加入了自动释放池,我们不需要主动的调用对象的release方法。
拥有对象(在类中以成员的方法存在):
1 如果使用alloc,new,copy创建对象,则需要在dealloc方法中,释放该对象
2 如果使用非alloc,new,copy创建对象,则在拥有该对象时,保留该对象(执行retain方法),在dealloc方法中,释放该对象。
dealloc
当对象的引用计数为0时,Objective-C会自动发送对象的dealloc消息(自动调用对象的dealloc方法,类似于C++的析构函数),所以我们可以自己重写dealloc方法,来实现类里的对其它使用资源的释放工作。
注意:不要直接在代码中显示调用dealloc方法。
垃圾回收
在Objective-C 2.0中引入了垃圾回收机制(自动管理内存),在工程设置里设置Objective-C Garbage Collection为Required[-fobjc-gc-only]就可以使用垃圾回收机制。
启用垃圾回收机制后,通常的内存管理命令都变成了空操作指令,不执行任何操作。
Objective-C的垃圾回收机制是一种继承性的垃圾回收器,垃圾回收器定期检查变量和对象以及他们之间的指针,当发现没有任何变量指向对象时,就将该对象视为被丢弃的垃圾。所以在不在使用一个对象时,将指针他的指针设置为nil,这时垃圾回收器就会清理该对象。
注意:如果开发iphone软件,则不能使用垃圾回收。在编写iPhone软件时,Apple公司建议不要在自己的代码中使用autorelease方法,并且不要使用创建自动释放对象的函数。
类别
什么是类别?类别是一种为现有类添加新方法的方式。
为什么使用类别或者说使用类别的目的是什么?有以下三点:
第一,可以将类的实现分散到多个不同的文件或多个不同的框架中。
如果一个类需要实现很多个方法,我们可以将方法分类,把分好的类形成类别,可以有效的管理和驾驭代码。
第二,创建对私有方法的前向引用。
第三,向对象添加非正式协议。
委托
委托的意思就是你自己想做某事,你自己不做,你委托给别人做。
在Ojbective-C中,实现委托是通过类别(或非正式协议)或者协议来实现。
举 个例子:Apple要生产iPhone,Apple自己不生产(种种原因,其中之一就是在中国生产成本低,他们赚的银子多),Apple委托富士 康来生 产,本来富士康原来不生产iPhone,现在要生产了,所以他得自己加一个生产iPhone的生产线(类别,增加生产iPhone方法),这就是通过类别 来实现委托。下面用代码来说明这个例子。
.....
Apple *apple = [[Apple alloc ] init];
Foxconn *fox = [[Foxconn alloc] init];
[apple setDelegate:fox];
[apple produceIPhone];
........
@implementation Apple
-(...) setDelegate:(id) x{
delegate = x; //! 将委托的生产对象指定为x
}
-(...) produceIPhone{
[delegate produceIPhone]; //! 委托对象生产iPhone
}
@interface Foxconn : NSObject
...
@end
@interface NSObject(ProduceIPhone) //! Foxconn之前就可以生产其它产品,有过声明和定义
-(...) produceIPhone //! 增加生产iPhone能力
@end
@implementation NSObject(ProduceIPhone)
//! 生产iPhone
-(...) produceIPhone{
......
}
@end
非正式协议
创建一个NSObject的类别, 称为创建一个非正式协议。为什么叫非正式协议呢?
也就是说可以实现,也可以不实现被委托的任务。
拿上面的例子来说,Apple要求Foxconn除了能生产iPhone外,还有一个要求是在一定时间内完成.由于双方没有签合同,所以时间要求和生产要求规格都是非正式协议
选择器
选 择器就是一个方法的名称。选择器是在Objective-C运行时使用的编码方式,以实现快速查找。可以使用@selector预编译指令,获取 选择器 @selector(方法名)。NSObject提供了一个方法respondsToSelector:的方法,来访问对象是否有该方法(响应该消息)。
拿 上面的Apple请Foxconn生产iPhone为例,Apple怎么知道Foxconn有没有生产iPhone的能力呢?Apple就通过 respondsToSelector方法询问Foxconn,是否可以生产iPhone(是否可以响应produceIPhone),询问结果是可以, 那Apple就委托Foxconn生产,Foxconn就生产出来了人们比较喜欢的iPhone产品。
正式协议
与非正式协议比较而言,在Ojbective-C中,正式协议规定的所有方法必须实现。在Ojbective-C2.0中,Apple又增加了两个关键字,协议中的方法也可以不完全实现,是哪个关键字见关键字部份的@optional,@required。
正式协议声明如下:
@protocol XXX
-(...) func1;
-(...) func2;
@end
使用协议:
@interface Object : NSObject //! Object从NSObject派生,并遵循XXX协议,要实现func1,func2函数。
...
@end
习惯用法
分配内存和初始化
self = [super init];
对象间交互
在Objective-C中,所有对象间的交互都是通过指针实现。
快速枚举
for (Type *p in array)
注意:
Objective-C不支持多继承
objective-c只不过是拥有一些附加特性的C语言。本质上就是C语言
1.C语言使用#include通知编译器应在头文件中查询定义。objective-c也可以使用#include来实现这个目的,但你永远不可能这么做,你会用#import,它是GCC编译器提供的,#import可以保证头文件只被包含一次。
xcode会使用预编译头文件(一种经过压缩的,摘要形式的头文件),在通过#import导入这种文件时,加载速度会非常快。
2.什么是框架
框架是一种聚集在一个单元的部件集合,包含头文件,库,图像,声音文件等。苹果公 司将cocoa,Carbon,QuickTime和OpenGL 等技术 作为框架集提供。cocoa的组成部分有Foundation和Application Kit框架。还有一个支持框架的套件,包含 Core Animation和Core Image,这为Cocoa增添了多种精彩的功能。
每个框架都是一个重要的技术集合,通常包含数十个甚至上百个头文件。每个框架都有一个主头文件,它包含了所有框架的各个头文件。通过使用#import导入主头文件,可以使用所有框架的特性。
3.Foundation框架处理的是用户界面之下的层(layer)中得特性,例如数据结构和通信机制。
4.NS前缀
NS这个前缀告诉你函数来自cocoa而不是其他工具包。
两个不同事物使用相同标示符时会导致名称冲突,而前缀可以预防这个大问题。
5.BOOL类型
objective-c中得BOOL实际上是一种对带符号的字符类型(signed char)的定义。它使用8位存储空间,YES为1,NO为0.
6.间接
不在代码中直接使用某个值,而是使用指向该值的指针。另一个意思是,让别的类来完成本类的工作。
例子:
1.循环次数的变量。变量与间接
2.使用从文件读取。文件与间接
在OOP(面向对象编程)中,间接十分重要。OOP使用间接来获取数据,OOP真正的革命性就是它在调用代码中使用间接。比如在调用函数时,不是直接调用,而是间接调用。
7.过程式程序与OOP的区别
过程式程序建立在函数之上,数据为函数服务。面向对象编程从相反的角度来看待问题。它以程序的数据为中心,函数为数据服务。在OOP中,不在重点关注程序中得函数,而是专注与数据。
8.id
id是一种泛型,用于表示任何种类的对象。
9.OOP中得一些术语
类:类是一种结构,它表示对象的类型。对象引用类来获取和本身有关的各种信息,特别是运行什么代码来处理每种操作。
对象:对象是一种结构,它包含值和指向其类的隐藏指针。
实例:实例是“对象”的另一种称呼。
消息:消息是对象可以执行的操作,用于通知对象去做什么。
方法:方法是为响应消息而运行的代码。根据对象的类,消息可以调用不同的方法。
方法调度程序:是objective-c使用的一种机制,用于推测执行什么方法以响应某个特定的消息。
接口:接口是对象的类应该提供的特性的描述。接口不提供实现细节。
实现:实现是使接口正常工作的代码。
10.中缀符
objective- c有一种名为中缀符的语法技术。方法的名称及其参数都是合在一起的。例如: [trxtThing setStringValue:@"Hello there" color:kBlueColor]; 中 setStringValue: 和 color:实际上是参数的名称(实际上是方法名称的一部分)。使代码可读性更强,更容易理解参数的用途。
11.先行短线
-(void)draw;
前面的短线表明这是objective-c方法的生命。这是一种区分函数原型与方法声明的方式,函数原型中没有先行短线。-代表是实例方法。+代表是类方法。
12.@interface
创建某个特定类的对象之前,objective-c编译器需要一些有关该类的信息。他必须知道对象的数据成员和它提供的特性可以使用@interface指令把这种信息传递给编译器。用于定义类的公共接口。
13.@implementation
是一个编译器指令,表明你将为某个类提供代码。类名出现在@implementation之后。该行的结尾处没有分号。因为在objective-c编译器指令后不必使用分号。
@interface和@implementation间的参数名不同是正确的。
在@interface中没有声明却在@implementation中实现的方法是私有方法。
14.实例化
创建对象的过程叫做实例化。实例化对象时,需要分配内存,然后这些内存被初始化并保存一些有用的默认值,这些值不同于你在获得新分配内存时得到的随机值。内存分配和初始化完成后,就创建了一个新的对象实例。
15.继承
创建一个新类时,通常需要定义新类以区别于其他类以及现有类。使用继承可以定义一个具有父类所有功能的新类,它继承了父类的这些功能。
objective-c没有多继承。
创建一个新类时,其对象首先从自身的超类中继承实例变量,然后添加他们自己的实例变量。
超类
父类
子类
孩子类
重写
方法调度:objective-c的方法调度程序将子当前类中搜索响应的方法。如果调度程序无法在接受消息的对象类中找到响应的方法,它就会在该类的超类中进行查找。顺着继承链找到下一个超类进行查找,直到NSObject类中也没有该方法,则会出现运行时错误。
16.复合
对象引用其他对象时,可以利用其他对象提供的特性,这就是复合。
17.UML
UML是一种用图表表示类,类的内容以及他们之间关系的常见方法。
18.多态
使用更具体种类的对象(子类对象)代替一般类型(父类),这种能力称为多态性。
19.self
是一个指向接收消息的对象的指针。指向第一个实例变量isa。因为objective-c编译器已经看到了所有这些类的@interface声明,因此,它能直到对象中实力变量的布局,通过这些重要的信息,编译器可以产生代码并查找任何需要的实例变量。
基地址加偏移:编译器使用“基地址加偏移”机制实现奇妙的功能。给定的对象基地址,是指第一个实例变量的首个字节在内存中得位置,通过在该地址加上偏移地址,编译器就可以查到其他实例变量的位置。
20.间接寻址方式,直接寻址方式
21.super
objective-c提供某种方式来重写方法,并且仍然调用超类的实现方式。当需要超类实现自身的功能,同时在前面或者后面执行某些额外的工作时,这种机制非常有用。为了调用继承方法的实现,需要使用super作为方法调用的目标。
22.cocoa
cocoa实际上是由2个不同的框架组成的:Foundation Kit和 Application Kit。Application Kit包含了所有的用户接口对象和高级类。
Foundation Kit
23.NSAutoreleasePool
mian()函数创建了(通过alloc)并初始化(通过init)了一个NSAutoreleasePool实例。在mian()函数结尾,这个池被排空。这就是Cocoa内存管理的预览。
24.NSRange
typedef struct _NSRange {
unsigned int location;
unsigned int length;
}NSRange;
这个结构体用来表示相关事务的范围,通常是字符串里的字符范围或者数组里的元素范围。
25.三种赋值方式
1.NSRange range;
range.location = 17;
range.length = 4;
2.C语言的聚合结构赋值机制
NSRange range = {17, 4};
3.Cocoa提供的一个快捷函数NSMakeRange()
NSRange range = NSMakeRange(17, 4);
使用NSMakeRange()的好处是你可以在任何能够使用函数的地方使用它,例如在方法调用中将其当成参数传递。
26.几何数据类型
1.NSPoint 代表笛卡儿平面中得一个点(x, y).
typedef struct _NSPoint {
float x;
float y;
}NSPoint;
2.NSSize 用来存储长度和宽度
typedef struct NSSize {
float width;
float height;
}NSSize;
3.NSRect 矩形数据类型,它是由点和大小复合而成
typedef struct _NSRect {
NSPoint origin;
NSSize size;
}NSRect;
27.字符串NSString
stringWithFormat:就是一个工厂方法,它根据你提供的参数创建新对象。
length:长度
isEqualToString:比较字符串内容是否相同
compart:将接受对象和传递来的字符串逐个字符的进行比较。返回一个enum数据
NSCaseInsensitiveSearch:不区分大小写字符。
NSLiteralSearch:进行完全比较,区分大小写
NSNumericSearch:比较字符串的字符个数,而不是字符值。
-(NSRange)rangeOfString:(NSString *)aString;
返回的range.start为开始位置,range.length为长度。
28.NSMutableString可变字符串。
stringWithCapacity:创建一个新的NSMutableString
字符串的大小并不仅限于所提供的容量,这个容量仅是个最优值。如果要创建一个40mb的字符串。
NSMutableString *str = [NSMutableString stringWithCapacity:42];
appendString接受参数aString,然后将其复制到接收对象的末尾。
appendFormat与stringWithFormat:类似,但它将格式化的字符串附加在接收字符串的末尾,而不是创建新的字符串对象。
29.集合家族
1.NSArray:是一个Cocoa类,用来存储对象的有序列表。
两个限制:1.只能存储objective-c的对象,不能存储C语言中得基本数据类型。
2.也不能存储nil。
30.枚举器,快速枚举
31.NSDictionary字典
关键字及其定义的集合。
32.NSNumber包装(以对象形式实现)基本数据类型
装箱:将一个基本类型的数据包装成对象。
取消装箱:从对象中提取基本类型的数据。
objective-c不支持自动装箱。
33.NSValue是NSNumber的父类。
+(NSValue *)valueWithBytes:(const void *)value objCType:(const char *)type;
传 递的参数是你想要包装的数值的地址(如一个NSSize或你自己的struct)。通常,得到的是你想要存储的变量的地址(在C语言中使用操作 符&)。你也可以提供一个用来描述这个数据类型的字符串,通常用来说明struct中实体的类型和大小。你不用自己写代码来生成这个字符 串,@encode编译器指令可以接受数据类型的名称并为你生成合适的字符串。
NSRect rect = NSMakeRect(1, 2, 30, 40);
NSValue *value;
value = [NSValue valueWithBytes:&rect objCType:@encode(NSRect)];
[array addObject:value];
34.NSNull只有一个方法[NSNull null];
[NSNull null]总是返回一样的数值,所以你可以使用运算符==将该值与其他值进行比较。
35.单实例架构:只需要一个实例。
查找文件:
例如:NSFileManager *manager;
manager = [NSFileManager defaultManager];
defaultManager可以为我们创建一个属于我们自己的NSFileManger对象。
NSString *home = [@"~" stringByExpandingTildeInPath];将~替换成当前用户的主目录。
NSDirectoryEnumerator *direnum = [manager enumeratorAtPath:home]; 返回一个 NSDictionaryEnumerator,它是NSEnumerator的子类。每次在这个枚举器对象中调用nextObject时,都会返回该目 录中得一个文件的另一个路径。
36.内存管理
1)对象生命周期
对象的生命周期包括诞生(alloc或者new方法实现),生存(接受消息和执行操作),交友(借助方法的组合和参数)以及当他们的生命结束时最终死去(被释放)。当对象的生命周期结束时,他们的原材料(内存)将被回收以供新的对象使用。
2)引用计数
cocoa 采用了一种称为引用计数的技术,有时候也叫保留计数。每个对象有一个与之相关联的整数,称作它的引用计数器或保留计数器。当某段代码需要 访问一 个对象时,该代码将该对象的保留计数器值+1,表示“我要访问该对象”。当这段代码结束对象访问时,将对象的保留计数器值-1,表示它不再访问该对象,当 保留计数器值为0时,表示不再有代码访问该对象了,因此该对象被销毁,其占用的内存被系统回收以便重用。
alloc,new,copy 1
retain +1
release -1
3)对象所有权
如果一个对象具有指向其他对象的实力变量,则称该对象拥有这些对象。
在类A中 B对象拥有其指向的C对象,则B对象拥有C对象。
如果一个函数创建了一个对象,则称该函数拥有它创建的这个对象。
main()函数创建了对象a 称main()函数拥有a对象
当多个实体拥有某个特定的对象时,对象的所有权关系就更加复杂了,这也是保留计数器值可能大于1的原因。
例子:
main() {
Engine *engine = [Engine new];
[car setEngine:engine];
}
现 在哪个实体拥有engine对象?是main函数还是car类?哪个实体负责确保当engine对象不再被使用时能够收到release消息?因 为 car类正在使用engine对象,所以不可能是main函数。因为main函数随后还可能会使用engine对象,所以也不可能是car类。
解 决方法是让car类保留engine对象,将engine对象的保留计数器值增加到2。这是因为car类和main函数这2个实体都正在使用 engine对象。car类应该在setEngine:方法中保留engine对象,而main函数应该释放engine对象。然后,当car类完成其任 务时再释放engine对象(在其dealloc方法中),最后engine对象占用的资源被回收。
如果您使用名字以“alloc”或 “new”开头或名字中包含“copy”的方法(例如alloc,newObject或mutableCopy) 创建了 一个对象,则您会获得该对象的所有权;或者如果您向一个对象发送了一条retain消息,则您也会获得该对象的所有权。
4)访问方法中得保留和释放
5)自动释放池NSAutoreleasePool
是一个存放实体的池(集合)。你可以用NSMutableArray来编写自己的自动释放池,以容纳对象并在dealloc方法中向池中得所有对象发送release消息。
autorelease
当给一个对象发送autorelease消息时,实际上是将该对象添加到NSAutoreleasePool中。当自动释放池被销毁时,会向该池中得所有对象发送release消息。
6)自动释放池的销毁时间
在我们一直使用的Foudation库工具中,创建和销毁自动释放池的方法非常明确:
NSAutoreleasePool *pool;
pool = [[NSAutoreleasePool alloc] init];
...
[pool release];
创 建一个自动释放池时,该池自动成为活动的池。释放该池时,其保留计数器值归0,然后该池被销毁。在销毁的过程中,该池释放其包含的所有对象。当使 用 Application Kit时,cocoa定期自动为你创建和销毁自动释放池。通常是在程序处理完当前事件以后执行这些操作。你可以使用任意多得自动 释放对象,当不再使用它们时,自动释放池将自动为你清理这些对象。
你可能已经在xcode自动生成代码中遇见过另一种销毁自动释放池中对象的方式:-drain方法。该方法只是清空自动释放池而不是销毁它。并且只适用于mac os x10.4以上的版本。
7)自动释放池的工作过程
我 们在任何时候向一个对象发送autorelease消息,该对象都会呗添加到这个自动释放池中。被加入到自动释放池的对象的引用计数器值不会变 化。当自 动释放池被销毁时(向自动释放池发送release消息,自动释放池的引用计数器值变为0,调用自身的dealloc函数),会调用自身的dealloc 函数,会向池中得对象发送release消息。
37.cocoa内存管理规则
1)当你使用new,alloc或copy方法创建一个对象时,该对象的保留计数器值为1。当不再使用该对象时,你要负责向该对象发送一条release或autorelease消息。这样,该对象将在其使用寿命结束时被销毁。
2)当你通过任何其他方法获得一个对象时,则假设该对象的保留计数器值为1,而且已经被设置为自动释放,你不需要执行任何操作来确保该对象被清理。如果你打算在一段时间内拥有该对象,则需要保留它并确保在操作完成时释放它。
3)如果你保留了某个对象,你需要(最终)释放或自动释放该对象。必须保持retain方法和release方法的使用次数相同。
38.清理自动释放池
由于自动释放池的销毁时间是完全确立的,所以它在循环执行过程中不会被销毁。在迭代中或者循环中,需要建立自己的自动释放池。
39.垃圾回收gc
自 动内存管理机制。objective-c的垃圾回收器是一种继承性的垃圾回收器。与那些已经存在了一段时间的对象相比,新创建的对象更可能被当成 垃圾。 垃圾回收器定期检查变量和对象以及他们之间的指针,当发现没有任何变量指向某个对象时,就将该对象视为应该被丢弃的垃圾。如果你再一个实例变量中指向某个 对象,一定要在某个时候使该实例变量赋值为nil,以取消对该对象的引用并使垃圾回收器知道该对象可以被清理了。
与自动释放池一样,垃圾回收器也是在时间循环结束时才触发。
ARC是什么?
ARC是iOS 5推出的新功能,全称叫 ARC(Automatic Reference Counting)。简单地说,就是代码中自动加入了retain/release,原先需要手动添加的用来处理内存管理的引用计数的代码可以自动地由编译器完成了。
该 机能在 iOS 5/ Mac OS X 10.7 开始导入,利用 Xcode4.2 可以使用该机能。简单地理解ARC,就是通过指定的语 法,让编 译器(LLVM 3.0)在编译代码时,自动生成实例的引用计数管理部分代码。有一点,ARC并不是GC,它只是一种代码静态分析 (Static Analyzer)工具。
40.分配
是一个新对象诞生的过程。是从操作系统获得一块内存并将其指定为存放对象的实例变量的位置。
40.初始化
与分配对应的操作是初始化。初始化从操作系统取得一块内存。准备用于存储对象。
嵌套调用技术非常重要,因为初始化方法返回的对象可能与分配的对象不同。
1)初始化时做什么?
给实例变量赋值并创建你得对象完成任务所需要的其他对象。
2)便利初始化函数
许多类包含便利初始化函数。用来完成某些额外的工作的初始化方法,可以减少你自己完成这些工作的麻烦。
例如:NSString类中-(id)initWithFormat:(NSString *)format,...;
3)指定初始化函数
类中的某个初始化方法被指派为指定初始化函数。该类所有初始化方法使用指定初始化函数执行初始化操作。子类使用其超类的指定初始化函数实现超类的初始化。
例如:其他初始化函数通过指定初始化函数实现。
41.初始化函数规则
不需要为你自己的类创建初始化函数方法。如果不需要设置任何状态,或者只需要alloc方法将内存清零的默认行为,则不需要担心init。
如果构造了一个初始化函数,则一定要在你自己的指定初始化函数中调用超类的指定初始化函数。一定要将超类的初始化函数的值赋给self对象,并返回你自己的初始化方法的值。因为超类可能决定返回一个完全不同的对象。
如果初始化函数不止一个,则要选择一个座位指定初始化函数。被选定的方法应该调用超类指定初始化函数。要按照指定初始化函数的形式实现所有其他初始化函数,就像我们在前面的实现一样。
42.特性@property
objective-c2.0的特性只适用于mac os x 10.5或更高版本。特性主要应用于cocoa的新组件(尤其是华丽夺目的core Animation效果)。
1)简化接口
@property预编译指令的作用是自动生命属性的setter和getter方法。
2)@synthesize也是一种新的编译器功能,表示“创建该属性的访问器”。
3)点表达式
如果点表达式出现在=左边,该属性名称的setter方法(set方法)将被调用。如果点表达式出现在对象变量右边,则该属性名称的getter方法(get方法)将被调用。
4)特性扩展
@property()括号里面的东西,是对应在set方法中要添加的语句。比如我在括号里写retain,就相当于在它的set方法里添加了一句 [xx retain]。
@property属性
属性分为3类:
1.读写属性(Writability)包含:readwrite / readonly
2.setter语义(Setter Semantics)包含:assign / retain / copy
3.原子性(Atomicity)包含:nonatomic
下面具体说明各个属性的含义
readwrite / readonly:
决定是否生成set访问器,readwrite是默认属性,生成getter和setter方法;readonly只生成getter方法,不生成setter方法。
readonly关键字代表setter不会被生成, 所以它不可以和 copy/retain/assign组合使用。
assign / retain / copy:
这些属性用于指定set访问器的语义,也就是说,这些属性决定了以何种方式对数据成员赋予新值。
assign:
直接赋值,索引计数不改变,适用于简单数据类型,例如:NSIngeter、CGFloat、int、char等。
retain:
指针的拷贝,使用的是原来的内存空间。
对象的索引计数加1。
此属性只能用于Objective-C对象类型,而不能用于Core Foundation对象。(原因很明显,retain会增加对象的引用计数,而基本数据类型或者Core Foundation对象都没有引用计数)。
copy:
对象的拷贝,新申请一块内存空间,并把原始内容复制到那片空间。
新对象的索引计数为1。
此属性只对那些实行了NSCopying协议的对象类型有效。
很多Objective-C中的object最好使用用retain,一些特别的object(例如:string)使用copy。
nonatomic:
非原子性访问,不加同步,多线程并发访问会提高性能。如果不加此属性,则默认是两个访问方法都为原子型事务访问。默认值是atomic,为原子操作。
(atomic是Objc使用的一种线程保护技术,基本上来讲,是防止在写未完成的时候被另外一个线程读取,造成数据错误。而这种机制是耗费系统资源的, 所以在iPhone这种小型设备上,如果没有使用多线程间的通讯编程,那么nonatomic是一个非常好的选择。)
5)保留周期retain cycle
引用计数器在该周期中归零。
6)什么是属性访问器
属性访问器(Property Accessor),包括 get 访问器和 set 访问器分别用于字段的读写操作
其设计目的主要是为了实现面向对象(OO)中的封装思想。根据该思想,字段最好设为private,一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问
另外要注意属性本身并不一定和字段相联系
7)self.a与a的区别
self.a使编译器知道我们期望使用访问器访问a。如果只使用裸名a,编译器将假设我们直接修改了实例变量。
8)self.a = nil
这 行代码表示使用nil参数调用setName:方法。生成的访问器方法将自动释放以前的name对象,并使用nil替代a。该方法完成了释放 name对 象所占用内存的操作。当然,也可以只释放name对象以清理其占用的内存。如果你再dealloc方法以外的地方清除特性,那么使用"将nil赋值给对 象"的方法可以将特性设置为nil,同时可以使我们避免对已释放内存的悬空引用问题。
9)特性不是万能的
有些方法不适合特性所能涵盖的方法的相当狭小的范围。特性不支持那些需要接受额外参数的方法。
43.类别@category
1)声明类别
@interface NSString (NumberConvenience)
-(NSNumber *)lengthAsNumber;
@end
该 声明具有2个特点。首先,现有类位于@interface关键字之后,其后是位于圆括号中的一个新名称。该声明表示,类别的名称是 NumberConvenience,而且该类别将向NSString类中添加方法。只要保证类别名称的唯一性,你可以向一个类中添加任意多得类别。
其次,你可以指定希望向其添加类别的类以及类别的名称,而且你还可以列出添加的方法,最后以@end结束。由于不能添加新实现变量,因此与类声明不同的是,类别的声明中没有实例变量部分。
2)实现类别
3)类别的局限性
第一,无法向类中添加新的实例变量。类别没有位置容纳实例变量。
第二,名称冲突,即类别中得方法与现有的方法重名。当发生名称冲突时,类别具有更高的优先级。你得类别方法将完全取代初始方法,从而无法再使用初始方法。有些编程人员在自己的类别方法中增加一个前缀,以确保不发生名称冲突。
有一些技术可以克服类别无法增加新实例变量的局限。例如,可以使用全局字典存储对象与你想要关联的额外变量之间的映射。但此时你可能需要认真考虑一下,类别是否是完成当前任务的最佳选择。
4)类别的作用
cocoa中得类别主要用于3个目的:第一,将类的实现分散到不同文件或者不同框架中。第二,创建对私有方法的前向引用。第三,向对象添加非正式协议。
44.run循环是一种cocoa构造,它一直处于阻塞状态(即不执行任何处理),知道某些事件发生为止。
45.响应选择器
一个类别如何知道其委托对象是否能够处理那些发送给它的消息?
类别首先检查对象,询问其能否响应该选择器。如果该对象能够响应该选择器,
1)选择器@selector()
选择器只是一个方法名称,但它以objective-c运行时使用的特殊方式编码,以快速执行查询。你可以使用@selector()预编译指令选择器,其中方法名位于圆括号中。
46.委托 非正式协议
47.正式协议
与非正式协议一样,正式协议是一个命名的方法列表。但与非正式协议不同的是,正式协议要求显式的采用协议。采用协议的办法是在类的@interface声明中列出协议名称。采用协议意味着你承诺实现该协议的所有方法。
1)声明协议
@protocol NSCopying
-(id)copyWithZone:(NSZone *)zone;
@end
2)采用协议
@interface Car: NSObject
{
}
@end
3)协议和数据类型
如果一个用尖括号括起来的协议名称跟随在id之后,则编译器将知道你期望任意类型的对象,只要其遵守该协议。
4)objective-c2.0的新特性@optional @required
@optional可选择实现的方法
@required必须实现的方法
因此cocoa中得非正式协议正被带有@optional的正式协议所取代。
48.Application Kit
1)IBOutlet与IBAction
他 们实际上只是APPKit提供的#defines。IBOutlet的定义没有任何作用,因此将不会对它进行编译。IBAction定义为 void,这 意味着在AppController中声明的方法的返回类型将使void。IBOutlet和IBAction不执行任何操作,他们并不是用于编译的,实 际上他们是为Interface Builder以及阅读代码的人提供的标记。通过查找IBOutlet和 IBAction,Interface Builder知道AppController对象具有两个能够连接的实例变量。
2)IBOutlet是如何工作的
当 加载nib文件时(MainMenu.nib会在应用程序启动时自动加载,可以创建你自己的nib文件并自行加载),存储在nib文件中得任何对 象都会 被重新创建。这意味着会再后台执行alloc和init方法。所以,当应用程序启动时,会分配并初始化一个AppController实例。在执行 init方法期间,所有IBOutlet实例变量都为nil。只有创建了nib文件中得所有对象(这包括窗口和文本域和按钮),所有连接才算完成。
一 旦建立了所有连接(也就是将NSTextField对象的地址添加到AppController的实例变量中),会向创建的每个对象发送消息 awakeFromNib。一个非常常见的错误是试图在init方法中使用IBOutlet执行一些操作。由于所有实例变量都为nil,发送给他们的所有 消息不执行任何操作,所以在init中得任何尝试都会发生无提示失败。(这是Cocoa导致效率低和占用大量调试时间的一个方面)。如果你想知道为什么这 些操作不起作用,可以使用NSLog输出实例变量的值,并查看他们是否都为nil。对于创建的对象和发送的awakeFromNib消息,都不存在预定义 顺序。
文件加载与保存
49.属性列表
1)自动释放对象
NSDate
NSData NSData对象是不可改变的。他们被创建后就不能改变。可以使用他们,但不能改变其中的内容。
2)编码对象 编码和解码
cocoa具备一种机制来将对象自身转换为某种格式并保存到磁盘中。对象可以将他们的实例变量和其他数据块编码为数据块,然后保存到磁盘中。以后将这些数据块读回到内存中,并且还能基于保存的数据创建新对象。这个过程称为编码和解码。或称为序列化和反序列化。
50.键/值编码 KVC
是一种间接改变对象状态的方式,其实现方法是使用字符串描述要更改的对象状态部分。
1)valueForKey与setValue:forKey:
这两种方法的工作方式相同。他们首先查找名称的setter(getter)方法,如果不存在setter(getter)方法,他们将在类中查找名为名称或_名称的实例变量。然后给它赋值(取值)。无需通过对象指针直接访问实例变量。
2)路径
键路径的深度是任意的,具体取决于对象图。
键路径不仅能引用对象值,还可以引用一些运算符来进行一些运算,例如获取一组值的平均值或返回这组值中得最小值和最大值。
例如:NSNumber *count;
count = [garage valueForKeyPath:@"cars.@count"];
NSLog(@"We have %@ cars", count);
我们将路径“cars.@count”拆开,cars用于获取cars属性,它是来自garage的NSArray类型的值。接下来的部分是@count ,其中@符号意味着后面将进行一些运算。
和 cars@sun.mileage
最大值 cars@min.mileage
最小值 cars@max.mileage
3)整体操作
KVC非常棒的一点是,如果向NSArray请求一个键值,它实际上会查询数组中得每个对象来查找这个键值,然后将查询结果打包到另一个数组中并返回给你。这种方法也适用于通过键路径访问的对象内部的数组。
4)批处理
KVC包含两个调用,可以使用他们对对象进行批量更改。第一个调用是dictionaryWith-ValuesForKeys:。它接受一个字符串数组。该调用获取一些键,对每个键使用valueForKey:,然后为键字符串和刚才获取的值构建一个字典。
1、Object-C有多继承吗?没有的话用什么代替?cocoa 中所有的类都是NSObject 的子类
多继承在这里是用protocol 委托代理 来实现的
你不用去考虑繁琐的多继承 ,虚基类的概念.
ood的多态特性 在 obj-c 中通过委托来实现.
2、Object-C有私有方法吗?私有变量呢?
objective-c – 类里面的方法只有两种, 静态方法和实例方法. 这似乎就不是完整的面向对象了,按照OO的原则就是一个对象只暴露有用的东西. 如果没有了私有方法的话, 对于一些小范围的代码重用就不那么顺手了. 在类里面声名一个私有方法
@interface Controller : NSObject { NSString *something; }
+ (void)thisIsAStaticMethod;
– (void)thisIsAnInstanceMethod;
@end
@interface Controller (private) -
(void)thisIsAPrivateMethod;
@end
@private可以用来修饰私有变量
在Objective‐C中,所有实例变量默认都是私有的,所有实例方法默认都是公有的
3、关键字const什么含义?
const意味着”只读”,下面的声明都是什么意思?
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
前 两个的作用是一样,a是一个常整型数。第三个意味着a是一个指向常整型数的指针(也就是,整型数是不可修改的,但指针可以)。第四个意思a是一个 指向整 型数的常指针(也就是说,指针指向的整型数是可以修改的,但指针是不可修改的)。最后一个意味着a是一个指向常整型数的常指针(也就是说,指针指向的整型 数是不可修改的,同时指针也是不可修改的)。
结论:
?; 关键字const的作用是为给读你代码的人传达非常有用的信息, 实际上,声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花 很多时间清理其它人留下的垃圾,你就会很快学会感谢这点多余的信息。(当然,懂得用const的程序员很少会留下的垃圾让别人来清理的。)
?; 通过给优化器一些附加的信息,使用关键字const也许能产生更紧凑的代码。
?; 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数,防止其被无意的代码修改。简而言之,这样可以减少bug的出现。
欲阻止一个变量被改变,可以使用 const 关键字。在定义该 const 变量时,通常需要对它进行初
始化,因为以后就没有机会再去改变它了;
(2)对指针来说,可以指定指针本身为 const,也可以指定指针所指的数据为 const,或二者同时指定为 const;
(3)在一个函数声明中,const 可以修饰形参,表明它是一个输入参数,在函数内部不能改变其值;
(4)对于类的成员函数,若指定其为 const 类型,则表明其是一个常函数,不能修改类的成员变量;
(5)对于类的成员函数,有时候必须指定其返回值为 const 类型,以使得其返回值不为“左值”。
4、关键字volatile有什么含义?并给出三个不同例子?
一个定义为volatile的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。精确地说就是,优化器在用到
这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子:
并行设备的硬件寄存器(如:状态寄存器)
一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
多线程应用中被几个任务共享的变量
一个参数既可以是const还可以是volatile吗?解释为什么。
一个指针可以是volatile 吗?解释为什么。
下面是答案:
是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
static作用?
函数体内 static 变量的作用范围为该函数体,不同于 auto 变量,该变量的内存只被分配一次,
因此其值在下次调用时仍维持上次的值;
(2)在模块内的 static 全局变量可以被模块内所用函数访问,但不能被模块外其它函数访问;
(3)在模块内的 static 函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明
它的模块内;
(4)在类中的 static 成员变量属于整个类所拥有,对类的所有对象只有一份拷贝;
(5)在类中的 static 成员函数属于整个类所拥有,这个函数不接收 this 指针,因而只能访问类的static 成员变量。
6、#import和#include的区别,@class代表什么?
@class一般用于头文件中需要声明该类的某个实例变量的时候用到,在m文件中还是需要使用#import
而#import比起#include的好处就是不会引起重复包含
7、线程和进程的区别?
进程和线程都是由操作系统所体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。
进 程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程 只是一 个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程 序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。
8、堆和栈的区别?
管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
申请大小:
栈: 在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在 WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因 此,能从栈获得的空间较小。
堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出
分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的。
9、Object-C的内存管理?
1.当你使用new,alloc和copy方法创建一个对象时,该对象的保留计数器值为1.当你不再使用该对象时,你要负责向该对象发送一条release或autorelease消息.这样,该对象将在使用寿命结束时被销毁.
2.当你通过任何其他方法获得一个对象时,则假设该对象的保留计数器值为1,而且已经被设置为自动释放,你不需要执行任何操作来确保该对象被清理.如果你打算在一段时间内拥有该对象,则需要保留它并确保在操作完成时释放它.
3.如果你保留了某个对象,你需要(最终)释放或自动释放该对象.必须保持retain方法和release方法的使用次数相等.
10、为什么很多内置的类,如TableViewController的delegate的属性是assign不是retain?
循环引用
所有的引用计数系统,都存在循环应用的问题。例如下面的引用关系:
对象a创建并引用到了对象b.
对象b创建并引用到了对象c.
对象c创建并引用到了对象b.
这时候b和c的引用计数分别是2和1。当a不再使用b,调用release释放对b的所有权,因为c还引用了b,所以b的引用计数为1,b不会被释放。b不释放,c的引用计数就是1,c也不会被释放。从此,b和c永远留在内存中。
这 种情况,必须打断循环引用,通过其他规则来维护引用关系。比如,我们常见的delegate往往是assign方式的属性而不是retain方式 的属 性,赋值不会增加引用计数,就是为了防止delegation两端产生不必要的循环引用。如果一个UITableViewController 对象a通 过retain获取了UITableView对象b的所有权,这个UITableView对象b的delegate又是a,如果这个delegate是 retain方式的,那基本上就没有机会释放这两个对象了。自己在设计使用delegate模式时,也要注意这点。
11、定义属性时,什么情况使用copy、assign、retain?
assign用于简单数据类型,如NSInteger,double,bool,
retain和copy用于对象,
copy用于当a指向一个对象,b也想指向同样的对象的时候,如果用assign,a如果释放,再调用b会crash,如果用copy 的方式,a和b各自有自己的内存,就可以解决这个问题。
retain 会使计数器加一,也可以解决assign的问题。
另外:atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。在多线程环境下,原子操作是必要的,否则有可能引起错误的结果。
加了atomic,setter函数会变成下面这样:
if (property != newValue) {
[property release];
property = [newValue retain];
}
12、对象是什么时候被release的?
引用计数为0时。
autorelease 实际上只是把对release的调用延迟了,对于每一个Autorelease,系统只是把该Object放入了当前的 Autorelease pool中,当该pool被释放时,该pool中的所有Object会被调用Release。对于每一个Runloop,系统会 隐式创建一个Autorelease pool,这样所有的release pool会构成一个象CallStack一样的一个栈式结构,在每一个 Runloop结束时,当前栈顶的Autorelease pool会被销毁,这样这个pool里的每个Object(就是autorelease的对 象)会被release。那什么是一个Runloop呢?一个UI事件,Timer call, delegate call, 都会是一个新的 Runloop
13、iOS有没有垃圾回收?
Objective-C 2.0也是有垃圾回收机制的,但是只能在Mac OS X Leopard 10.5 以上的版本使用。
14、tableView的重用机制?
查 看UITableView头文件,会找到NSMutableArray* visiableCells,和 NSMutableDictnery* reusableTableCells两个结构。visiableCells内保存当前显示的 cells,reusableTableCells保存可重用的cells。
TableView显示之 初,reusableTableCells为空,那么 tableView dequeueReusableCellWithIdentifier:CellIdentifier返回nil。开始的cell都 是通过 [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] 来创建,而且cellForRowAtIndexPath只是调用最大显示cell数的次数。
比如:有100条数据,iPhone一屏最多显示10个cell。程序最开始显示TableView的情况是:
1. 用 [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] 创建10次cell,并给cell指定同样的重用标识(当然,可以为不同显示类型的cell指定不同的标识)。并且10个cell全部都加入到 visiableCells数组,reusableTableCells为空。
2.向下拖动tableView,当cell1完全移出屏 幕,并且cell11(它也是alloc出来的,原因同上)完全显示出来的时候。 cell11加入到visiableCells,cell1移出visiableCells,cell1加入到reusableTableCells。
3. 接着向下拖动tableView,因为reusableTableCells中已经有值,所以,当需要显示新的 cell,cellForRowAtIndexPath再次被调用的时 候,tableView dequeueReusableCellWithIdentifier:CellIdentifier,返回cell1。 cell1加入到visiableCells,cell1移出reusableTableCells;cell2移出 visiableCells,cell2加入到reusableTableCells。之后再需要显示的Cell就可以正常重用了。
15、ViewController 的loadView、viewDidLoad、viewDidUnload分别是什么时候调用的,在自定义ViewCointroller时在这几个函数中应该做什么工作?
由init、loadView、viewDidLoad、viewDidUnload、dealloc的关系说起
init方法
在init方法中实例化必要的对象(遵从LazyLoad思想)
init方法中初始化ViewController本身
loadView方法
当view需要被展示而它却是nil时,viewController会调用该方法。不要直接调用该方法。
如果手工维护views,必须重载重写该方法
如果使用IB维护views,必须不能重载重写该方法
loadView和IB构建view
你 在控制器中实现了loadView方法,那么你可能会在应用运行的某个时候被内存管理控制调用。 如果设备内存不足的时候, view 控制器会 收到 didReceiveMemoryWarning的消息。 默认的实现是检查当前控制器的view是否在使用。如果它的view不在当前正在使用的 view hierarchy里面,且你的控制器实现了loadView方法,那么这个view将被release, loadView方法将被再次调用 来创建一个新的view。
viewDidLoad方法
viewDidLoad 此方法只有当view从nib文件初始化的时候才被调用。
重载重写该方法以进一步定制view
在iPhone OS 3.0及之后的版本中,还应该重载重写viewDidUnload来释放对view的任何索引
viewDidLoad后调用数据Model
viewDidUnload方法
当系统内存吃紧的时候会调用该方法(注:viewController没有被dealloc)
内存吃紧时,在iPhone OS 3.0之前didReceiveMemoryWarning是释放无用内存的唯一方式,但是OS 3.0及以后viewDidUnload方法是更好的方式
在该方法中将所有IBOutlet(无论是property还是实例变量)置为nil(系统release view时已经将其release掉了)
在 该方法中释放其他与view有关的对象、其他在运行时创建(但非系统必须)的对象、在viewDidLoad中被创建的对象、缓存数据 等 release对象后,将对象置为nil(IBOutlet只需要将其置为nil,系统release view时已经将其release掉了)
一般认为viewDidUnload是viewDidLoad的镜像,因为当view被重新请求时,viewDidLoad还会重新被执行
viewDidUnload中被release的对象必须是很容易被重新创建的对象(比如在viewDidLoad或其他方法中创建的对象),不要release用户数据或其他很难被重新创建的对象
dealloc方法
viewDidUnload和dealloc方法没有关联,dealloc还是继续做它该做的事情
16、ViewController的didReceiveMemoryWarning是在什么时候调用的?默认的操作是什么?
当程序接到内存警告时View Controller将会收到这个消息:didReceiveMemoryWarning
从iOS3.0开始,不需要重载这个函数,把释放内存的代码放到viewDidUnload中去。
这个函数的默认实现是:检查controller是否可以安全地释放它的view(这里加粗的view指的是controller的view属性),比如view本身没有superview并且可以被很容易地重建(从nib或者loadView函数)。
如果view可以被释放,那么这个函数释放view并调用viewDidUnload。
你可以重载这个函数来释放controller中使用的其他内存。但要记得调用这个函数的super实现来允许父类(一般是UIVIewController)释放view。
如果你的ViewController保存着view的子view的引用,那么,在早期的iOS版本中,你应该在这个函数中来释放这些引用。而在iOS3.0或更高版本中,你应该在viewDidUnload中释放这些引用。
17、列举Cocoa中常见的集中多线程的实现,并谈谈多线程安全的几种解决办法,一般什么地方会用到多线程?
NSThread,GCD等。尽量用上层分装好的方法去实现多线程而不是手动调用NSThread。
18、怎么理解MVC,在Cocoa中MVC是怎么实现的?
Model: 代表你的应用程序是什么(不是怎么展现)
Controller: 控制你的Model怎么展现给用户(UI逻辑)
View: Controller的奴隶。。。
1 Model,Controller,View相互通讯的规则:
Controller可以直接和Model通信
Controller也可以直接和View通信
Model和View永远不能直接通信
iOS中View和Controller的通信是透明和固定的,主要通过outlet和action实现
View使用Delegate接口和Controller同步信息
View不直接和数据通信,使用dataSource接口从Controller处获取数据
View的delegate和dataSource一般就是Controller
Controller负责为View翻译和格式化Model的数据
Model使用Notification & KVO的方式分发数据更新信息,Controller可以有选择的监听自己感兴趣的信息。
View也可以监听广播信息,但一般不是Model发出的信息
一个完整的App就是很多MVC的集合
19、delegate和notification区别,分别在什么情况下使用?
Delegate:
消息的发送者(sender)告知接收者(receiver)某个事件将要发生,delegate同意然然后发送者响应事件,delegate机制使得接收者可以改变发送者的行为。通常发送者和接收者的关系是直接的一对多的关系。
Notification:
消息的发送者告知接收者事件已经发生或者将要发送,仅此而已,接收者并不能反过来影响发送者的行为。通常发送者和接收者的关系是间接的多对多关系。
1. 效率肯定是delegate比nsnotification高。
2. delegate 方法比notification更加直接,最典型的特征是,delegate方法往往需要关注返回值,也就是 delegate方法 的结果。比如-windowShouldClose:,需要关心返回的是yes还是no。所以delegate方法往往包含should这个很传神的词。 也就是好比你做我的delegate,我会问你我想关闭窗口你愿意吗?你需要给我一个答案,我根据你的答案来决定如何做下一步。相反 的,notification最大的特色就是不关心接受者的态度,我只管把通告放出来,你接受不接受就是你的事情,同时我也不关心结果。所以 notification往往用did这个词汇,比如NSWindowDidResizeNotification,那么nswindow对象放出这个 notification后就什么都不管了也不会等待接受者的反应。
1)两个模块之间联系不是很紧密,就用notification传值,例如多线程之间传值用notificaiton。
2)delegate 只是一种较为简单的回调,且主要用在一个模块中,例如底层功能完成了,需要把一些值传到上层去,就事先把上层的函数通过 delegate传到底层,然后在底层call这个delegate,它们都在一个模块中,完成一个功能,例如 说 NavgationController 从 B 界面到A 点返回按钮 (调用popViewController方法) 可以用delegate 比较好。
20、self.跟self什么区别?
21、id、nil代表什么?
id 和void *并非完全一样。在上面的代码中,id是指向struct objc_object的一个指针,这个意思基本上是说,id是一个指 向任何 一个继承了Object(或者NSObject)类的对象。需要注意的是id是一个指针,所以你在使用id的时候不需要加星号。比如id foo=nil 定义了一个nil指针,这个指针指向NSObject的一个任意子类。而id *foo=nil则定义了一个指针,这个指针指向另一个指针,被指向的这个 指针指向NSObject的一个子类。
nil和C语言的NULL相同,在objc/objc.h中定义。nil表示一个Objctive-C对象,这个对象的指针指向空(没有东西就是空)。
首字母大写的Nil和nil有一点不一样,Nil定义一个指向空的类(是Class,而不是对象)。
SEL是“selector”的一个类型,表示一个方法的名字
Method(我们常说的方法)表示一种类型,这种类型与selector和实现(implementation)相关
IMP定义为 id (*IMP) (id, SEL, …)。这样说来, IMP是一个指向函数的指针,这个被指向的函数包括id(“self”指针),调用的SEL(方法名),再加上一些其他参数.说白了IMP就是实现方法。
22、内存管理 Autorelease、retain、copy、assign的set方法和含义?
1,你初始化(alloc/init)的对象,你需要释放(release)它。例如:
NSMutableArray aArray = [[NSArray alloc] init]; 后,需要 [aArray release];
2,你retain或copy的,你需要释放它。例如:
[aArray retain] 后,需要 [aArray release];
3,被传递(assign)的对象,你需要斟酌的retain和release。例如:
obj2 = [[obj1 someMethod] autorelease];
对象2接收对象1的一个自动释放的值,或传递一个基本数据类型(NSInteger,NSString)时:你或希望将对象2进行retain,以防止它在被使用之前就被自动释放掉。但是在retain后,一定要在适当的时候进行释放。
关于索引计数(Reference Counting)的问题
retain值 = 索引计数(Reference Counting)
NSArray 对象会retain(retain值加一)任何数组中的对象。当NSArray被卸载(dealloc)的时候,所有数组中的对象会 被 执行一次释放(retain值减一)。不仅仅是NSArray,任何收集类(Collection Classes)都执行类似操作。例如 NSDictionary,甚至UINavigationController。
Alloc/init建立的对象,索引计数为1。无需将其再次retain。
[NSArray array]和[NSDate date]等“方法”建立一个索引计数为1的对象,但是也是一个自动释放对象。所以是本地临时对象,那么无所谓了。如果是打算在全Class中使用的变量(iVar),则必须retain它。
缺省的类方法返回值都被执行了“自动释放”方法。(*如上中的NSArray)
在类中的卸载方法“dealloc”中,release所有未被平衡的NS对象。(*所有未被autorelease,而retain值为1的)
23、类别的作用?
有时我们需要在一个已经定义好的类中增加一些方法,而不想去重写该类。比如,当工程已经很大,代码量比较多,或者类中已经包住很多方法,已经有其他代码调用了该类创建对象并使用该类的方法时,可以使用类别对该类扩充新的方法。
注意:类别只能扩充方法,而不能扩充成员变量。
24、委托(举例)
委托代理(degegate),顾名思义,把某个对象要做的事情委托给别的对象去做。那么别的对象就是这个对象的代理,代替它来打理要做的事。反映到程序中,首先要明确一个对象的委托方是哪个对象,委托所做的内容是什么。
委托机制是一种设计模式,在很多语言中都用到的,这只是个通用的思想,网上会有很多关于这方面的介绍。
那么在苹果开发过程中,用到委托的程序实现思想如下,我主要拿如何在视图之间传输信息做个例子。
譬如:在两个页面(UIIview视图对象)实现传值,用委托(delegate)可以很好做到!
方法:
类A
@interface A:UIView
id transparendValueDelegate;
@property(nomatic, retain) id transparendValueDelegate;
@end
@implemtion A
@synthesize transparendValueDelegate
-(void)Function
{
NSString* value = @"hello";
//让代理对象执行transparendValue动作
[transparendValueDelegate transparendValue: value];
}
@end
类B
@interface B:UIView
NSString* value;
@end
@implemtion B
-(void)transparendValue:(NSString*)fromValue
{
value = fromValue;
NSLog(@"the value is %@ ",value);
}
@end
//下面的设置A代理委托对象为B
//在定义A和B类对象处:
A* a = [[A alloc] init];
B* b = [[B alloc] init];
a. transparendValueDelegate = b;//设置对象a代理为对象b
这样在视图A和B之间可以通过委托来传值!
25、retainCount?
26..属性readwrite,readonly,assign,retain,copy,nonatomic 各是什么作用,在那种情况下用
assign:指定setter方法用简单的赋值,这是默认操作。你可以对标量类型(如int)使用这个属性。你可以想象一个float,它不是一个对象,所以它不能retain、copy。
retain:指定retain应该在后面的对象上调用,前一个值发送一条release消息。你可以想象一个NSString实例,它是一个对象,而且你可能想要retain它。
copy:指定应该使用对象的副本(深度复制),前一个值发送一条release消息。基本上像retain,但是没有增加引用计数,是分配一块新的内存来放置它。
readonly:将只生成getter方法而不生成setter方法(getter方法没有get前缀)。
readwrite:默认属性,将生成不带额外参数的getter和setter方法(setter方法只有一个参数)。
atomic:对于对象的默认属性,就是setter/getter生成的方法是一个原子操作。如果有多个线程同时调用setter的话,不会出现某一个线程执行setter全部语句之前,另一个线程开始执行setter的情况,相关于方法头尾加了锁一样。
nonatomic:不保证setter/getter的原子性,多线程情况下数据可能会有问题。
27.类变量的@protected ,@private ,@public ,@package声明各有什么含义
Objective-C 对存取权限的设定。也是变量的作用域。
protected 该类和所有的子类中的方法可以直接访问这样的变量,这是默认的。
private — 该类中的方法可以访问这样的变量,子类不可以。 public — 除了自己和子类中的方法外,也可以被其他类或者其他模块中的方法所访问。开放性最大。 package — 对于64位图像,这样的成员变量可以在实现这个类的图像中随意访问。
28.浅拷贝和深拷贝区别是什么
简单的来说就是,在有指针的情况下,浅拷贝只是增加了一个指针指向已经存在的内存,而深拷贝就是增加一个指针并且申请一个新的内存,使这个增加的指针指向这个新的内存,采用深拷贝的情况下,释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误
29.Cocoa中与虚基类的概念么?怎么简洁的实现
30.NSString 和 NSMutableString 有什么区别
NSString相当于一个const char* 不可以改变。
而 NSMutableString相当于 char* 可以改变内部的内容。
31.自动释放池跟GC有什么区别?iPhone上有GC么?[pool release] 和[pool drain]有什么区别
”Autorelease Pools”(自动释放池)在应用中的使用技巧。
1,Autorelease Pools概要
一 个”Autorelease Pool”实例中“包含”其它各种调用了”autorelease”方法的对象。当它释放时,其中所有被管理对象都 会收 到”relrease”的消信。注意,同一个对象可以被多次调用”autorelease”方法,并可以放到同一个”Autorelease Pool” 中。引入这个自动释放池机制,对象的”autorelease”方法代替”relrease”方法可以延长它的生命周期,直接到当 前”Autorelrease Pool”释放。如果想让此对象的生命周期超过”Autorelease Pool”,还可以再次”retain”,呵 呵,有意思吧?且让我慢慢道来。
Cocoa总是认为当前至少有一个”Autorelease Pool”对象是可用的。若此对象并不存在,你调用的”autorelease”的所有对象都不会被自动释放掉,可想而知,造成内存泄露。Cocoa把这个错误信息写入日志??仅仅是为了以后分析。
你 可以用”alloc”与”init”方法创建一个”NSAutoreleasePool”对象,并且可以调用”release”或”drain” (”release”与”drain”的区别是”drain”在有GC的环境中会引起GC回收操作,”release”反之。但在非GC环境中,两者相 同。官方的说法是为了程序的兼容性,应该考虑用”drain”代替”release”,)方法来回收它(调用它的”autorelease” 或”retain”方法会引起异常)。在一个完整的上下文最后”Autorelease Pool”对象应该被”release”掉(在方法内或一段循环 体内创建的”Autorelease Pool”对象)。
“Autorelease Pools”的所有实例在栈中管理(我们暂时叫他 “自动释放池栈”),并且它们是可以被嵌套的(父生子,子生孙。。。子 子孙 孙 ^_^)。例如,当我们创建一个”Autorelease Pool”对象后,它就被自动放到“自动释放池栈”的栈顶。当本池对象回收时,它就随之从 这个栈中POP掉。那么也就是说,当任何一个对象调用”autorelease”方法后,它会被放入当前线程中当前栈顶的自动释放池中。
接 下来我们聊聊”Autorelease Pools”的嵌套问题。在你的应用中,你可以任意多的创建”Autorelease Pool”对象, 而这些 对象被当前线程的“自动释放池栈”所管理。那么除了一个接一个的顺序创建并销毁它的情况外,还有一种使用方式,就是嵌套式的创建与使用。例如:在你的主函 数创建了一个”autorelease pool”,然后又调用了创建了”autorelease pool”实例的其它方法;或是在外循环中创建 了”Autorelease Pool”的实例,而内循环中也做了相同的事情。有意思吧,呵呵,嵌套的机制使父Pool实例释放后,它的所有子Pool也 将释放。但这里还存在一些副作用,后续文章会详细讨论。
“Application kit”在一个事件循环里会自动创建一个”autorelease pool”。像鼠标键的按下与释放,所以你编写的代码通常不需要考虑太多这方面的事情。当然,有以下三种情况你会创建与销毁自己的Pool实例:
1,应用不是基于”Application Kit”,像”Command-line tool”,因为它并没有内置的”autorelease pools”的支持。
2,创建线程,你必需在线程开始时创建一个”Autorelease Pool”实例。反之,会造成内存池露(会在以后的文章详细说明线程与池的技巧)。
3,一个循环内创建了太多的临时对象,你应该为他们创建一个”Autorelease Pool”对象,并在下次循还前销毁它们。
2,自动释放池中的”Non-AppKit”应用
在”Non- AppKit”应用中使用自动释放池的机制其实是相当简单的事情。你仅仅需要在main()起始处创 建”Autorelease Pool” 对象,并在结尾处释放掉它。就像在Xcode的Foundation Tool的创建模版里写的一样。这个确保你在应用生命周期内至少有一 个”Autorelease Pool”是可用的。但是,这也使所有在此期间的所有”autorelease”的对象都必需在应用结束后才被释放。这也许 会引起在应用的使用中不断的增长,所以,你仍然考虑在不同的作用域创建新的”Autorelease Pool”。
大多应用中都存在各种级别的循环机制。在这些应用中,你可以在每个循环内的开头创建一个”Autorelease Pool”对象,并在结尾处释放掉它。
例如:
void main()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *args = [[NSProcessInfo processInfo] arguments];
unsigned count, limit = [args count];
for (count = 0; count < limit; count++)
{
NSAutoreleasePool *loopPool = [[NSAutoreleasePool alloc] init];
NSString *fileContents;
NSString *fileName;
fileName = [args objectAtIndex:count];
fileContents = [[[NSString alloc] initWithContentsOfFile:fileName] autorelease];
// this is equivalent to using stringWithContentsOfFile:
[loopPool release];
}
[pool drain];
exit (EXIT_SUCCESS);
}
在 命令行中处理所有以参数传来的文件。一次循环处理一个文件。在循环的开头创建一个”NSAutoreleasePool”对象,并在循环结束时释 放掉。 因此,任何在其中创建并调用“autorelease”的对象都将添加到这个Pool实例中,当本池被释放后,这些对象也将被回收。注意,任何在作用域内 创建的”autoreleased”对象(像”fileName”),虽然并没有显示的调用”autorelease”方法,但都将被当前池所管理并释 放。
32.C和obj-c 如何混用
1)obj-c的编译器处理后缀为m的文件时,可以识别obj-c和c的代码,处理mm文件可以识别obj-c,c,c++代码,但cpp文件必须只能用c/c++代码,而且cpp文件include的头文件中,也不能出现obj-c的代码,因为cpp只是cpp
2)在mm文件中混用cpp直接使用即可,所以obj-c混cpp不是问题
3)在cpp中混用obj-c其实就是使用obj-c编写的模块是我们想要的。
如果模块以类实现,那么要按照cpp class的标准写类的定义,头文件中不能出现obj-c的东西,包括#import cocoa的。实现文件中,即类的实现代码中可以使用obj-c的东西,可以import,只是后缀是mm。
如果模块以函数实现,那么头文件要按c的格式声明函数,实现文件中,c++函数内部可以用obj-c,但后缀还是mm或m。
总 结:只要cpp文件和cpp include的文件中不包含obj-c的东西就可以用了,cpp混用obj-c的关键是使用接口,而不能直接使用 实现代 码,实际上cpp混用的是obj-c编译后的o文件,这个东西其实是无差别的,所以可以用。obj-c的编译器支持cpp
33.响应者链是什么
响 应者链是Application Kit事件处理架构的中心机制。它由一系列链接在一起的响应者对象组成,事件或者动作消息可以沿着这些对象进行 传 递。如图6-20显示的那样,如果一个响应者对象不能处理某个事件或动作-也就是说,它不响应那个消息,或者不认识那个事件,则将该消息重新发送给链中的 下一个响应者。消息沿着响应者链向上、向更高级别的对象传递,直到最终被处理(如果最终还是没有被处理,就会被抛弃)。
当 Application Kit在应用程序中构造对象时,会为每个窗口建立响应者链。响应者链中的基本对象是NSWindow对象及其视图层次。 在视图层次中级别较低的视图将比级别更高的视图优先获得处理事件或动作消息的机会。NSWindow中保有一个第一响应者的引用,它通常是当前窗口中处于 选择状态的视图,窗口通常把响应消息的机会首先给它。对于事件消息,响应者链通常以发生事件的窗口对应的NSWindow对象作为结束,虽然其它对象也可 以作为下一个响应者被加入到NSWindow对象的后面。
34..UIscrollVew用到了什么设计模式?还能再foundation库中找到类似的吗?
组合模式composition,所有的container view都用了这个模式
观察者模式observer,所有的UIResponder都用了这个模式。
模板(Template)模式,所有datasource和delegate接口都是模板模式的典型应用
33. .timer的间隔周期准吗?为什么?怎样实现一个精准的timer?
NSTimer可以精确到50-100毫秒.
NSTimer不是绝对准确的,而且中间耗时或阻塞错过下一个点,那么下一个点就pass过去了
此份面试题包含40个题目,是现在网上能搜索到的一个比较热的一份,但是答案并不是很详细和完整,基本答案来着cocoaChina,和一些自己的补充。
34.Difference between shallow copy and deep copy?
浅复制和深复制的区别?
答案:浅层复制:只复制指向对象的指针,而不复制引用对象本身。
深层复制:复制引用对象本身。
意思就是说我有个A对象,复制一份后得到A_copy对象后,对于浅复制来说,A和A_copy指向的是同一个内存资源,复制的只不过是是一个指针,对象本身资源
还是只有一份,那如果我们对A_copy执行了修改操作,那么发现A引用的对象同样被修改,这其实违背了我们复制拷贝的一个思想。深复制就好理解了,内存中存在了
两份独立对象本身。
用网上一哥们通俗的话将就是:
浅复制好比你和你的影子,你完蛋,你的影子也完蛋
深复制好比你和你的克隆人,你完蛋,你的克隆人还活着。
35.What is advantage of categories? What is difference between implementing a category and inheritance?
类别的作用?继承和类别在实现中有何区别?
答案:category 可以在不获悉,不改变原来代码的情况下往里面添加新的方法,只能添加,不能删除修改。
并且如果类别和原来类中的方法产生名称冲突,则类别将覆盖原来的方法,因为类别具有更高的优先级。
类别主要有3个作用:
(1)将类的实现分散到多个不同文件或多个不同框架中。
(2)创建对私有方法的前向引用。
(3)向对象添加非正式协议。
继承可以增加,修改或者删除方法,并且可以增加属性。
36.Difference between categories and extensions?
类别和类扩展的区别。
答案:category和extensions的不同在于后者可以添加属性。另外后者添加的方法是必须要实现的。
extensions可以认为是一个私有的Category。
37.Difference between protocol in objective c and interfaces in java?
oc中的协议和java中的接口概念有何不同?
答案:OC中的代理有2层含义,官方定义为 formal和informal protocol。前者和Java接口一样。
informal protocol中的方法属于设计模式考虑范畴,不是必须实现的,但是如果有实现,就会改变类的属性。
其实关于正式协议,类别和非正式协议我很早前学习的时候大致看过,也写在了学习教程里
“非正式协议概念其实就是类别的另一种表达方式“这里有一些你可能希望实现的方法,你可以使用他们更好的完成工作”。
这个意思是,这些是可选的。比如我门要一个更好的方法,我们就会申明一个这样的类别去实现。然后你在后期可以直接使用这些更好的方法。
这么看,总觉得类别这玩意儿有点像协议的可选协议。"
现在来看,其实protocal已经开始对两者都统一和规范起来操作,因为资料中说“非正式协议使用interface修饰“,
现在我们看到协议中两个修饰词:“必须实现(@requied)”和“可选实现(@optional)”。
38.What are KVO and KVC?
答案:kvc:键 - 值编码是一种间接访问对象的属性使用字符串来标识属性,而不是通过调用存取方法,直接或通过实例变量访问的机制。
很多情况下可以简化程序代码。apple文档其实给了一个很好的例子。
kvo:键值观察机制,他提供了观察某一属性变化的方法,极大的简化了代码。
具体用看到嗯哼用到过的一个地方是对于按钮点击变化状态的的监控。
比如我自定义的一个button
[cpp]
[self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];
#pragma mark KVO
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
([keyPath isEqualToString:@"highlighted"] ) {
[self setNeedsDisplay];
}
}
对于系统是根据keypath去取的到相应的值发生改变,理论上来说是和kvc机制的道理是一样的。
对于kvc机制如何通过key寻找到value:
“当 通过KVC调用对象时,比如:[self valueForKey:@”someKey”]时,程序会自动试图通过几种不同的方式解析这个调 用。首先 查找对象是否带有 someKey 这个方法,如果没找到,会继续查找对象是否带有someKey这个实例变量(iVar),如果还没有找到,程序会继续 试图调用 -(id) valueForUndefinedKey:这个方法。如果这个方法还是没有被实现的话,程序会抛出一个 NSUndefinedKeyException异常错误。
(cocoachina.com注:Key-Value Coding查找方法 的时候,不仅仅会查找someKey这个方法,还会查找 getsomeKey这个方法,前面加一个get,或者_someKey以及_getsomeKey这几种形式。同时,查找实例变量的时候也会不仅仅查找 someKey这个变量,也会查找_someKey这个变量是否存在。)
设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时,对象能够在错误发生前,有最后的机会响应这个请求。这样做有很多好处,下面的两个例子说明了这样做的好处。“
来至cocoa,这个说法应该挺有道理。
因为我们知道button却是存在一个highlighted实例变量.因此为何上面我们只是add一个相关的keypath就行了,
可以按照kvc查找的逻辑理解,就说的过去了。
39.What is purpose of delegates?
代理的作用?
答案:代理的目的是改变或传递控制链。允许一个类在某些特定时刻通知到其他类,而不需要获取到那些类的指针。可以减少框架复杂度。
另外一点,代理可以理解为java中的回调监听机制的一种类似。
40.What are mutable and immutable types in Objective C?
oc中可修改和不可以修改类型。
答案:可修改不可修改的集合类。这个我个人简单理解就是可动态添加修改和不可动态添加修改一样。
比如NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的,后者可以添加等,可以动态申请新的内存空间。
41.When we call objective c is runtime language what does it mean?
我们说的oc是动态运行时语言是什么意思?
答案:多态。 主要是将数据类型的确定由编译时,推迟到了运行时。
这个问题其实浅涉及到两个概念,运行时和多态。
简单来说,运行时机制使我们直到运行时才去决定一个对象的类别,以及调用该类别对象指定方法。
多态:不同对象以自己的方式响应相同的消息的能力叫做多态。意思就是假设生物类(life)都用有一个相同的方法-eat;
那人类属于生物,猪也属于生物,都继承了life后,实现各自的eat,但是调用是我们只需调用各自的eat方法。
也就是不同的对象以自己的方式响应了相同的消息(响应了eat这个选择器)。
因此也可以说,运行时机制是多态的基础?~~~
42.what is difference between NSNotification and protocol?
通知和协议的不同之处?
答案:协议有控制链(has-a)的关系,通知没有。
首先我一开始也不太明白,什么叫控制链(专业术语了~)。但是简单分析下通知和代理的行为模式,我们大致可以有自己的理解
简单来说,通知的话,它可以一对多,一条消息可以发送给多个消息接受者。
代理按我们的理解,到不是直接说不能一对多,比如我们知道的明星经济代理人,很多时候一个经济人负责好几个明星的事务。
只是对于不同明星间,代理的事物对象都是不一样的,一一对应,不可能说明天要处理A明星要一个发布会,代理人发出处理发布会的消息后,别称B的
发布会了。但是通知就不一样,他只关心发出通知,而不关心多少接收到感兴趣要处理。
因此控制链(has-a从英语单词大致可以看出,单一拥有和可控制的对应关系。
43.What is push notification?
什么是推送消息?
答案:太简单,不作答~~~~~~~~~~
这是cocoa上的答案。
其实到不是说太简单,只是太泛泛的一个概念的东西。就好比说,什么是人。
推送通知更是一种技术。
简单点就是客户端获取资源的一种手段。
普通情况下,都是客户端主动的pull。
推送则是服务器端主动push。
44.Polymorphism?
关于多态性
答案:多态,子类指针可以赋值给父类。
这个题目其实可以出到一切面向对象语言中,
因此关于多态,继承和封装基本最好都有个自我意识的理解,也并非一定要把书上资料上写的能背出来。
最重要的是转化成自我理解。
45.Singleton?
对于单例的理解
答案:11,12题目其实出的有点泛泛的感觉了,可能说是编程语言需要或是必备的基础。
基本能用熟悉的语言写出一个单例,以及可以运用到的场景或是你编程中碰到过运用的此种模式的框架类等。
进一步点,考虑下如何在多线程访问单例时的安全性。
46.What is responder chain?
说说响应链
答案: 事件响应链。包括点击事件,画面刷新事件等。在视图栈内从上至下,或者从下之上传播。
可以说点事件的分发,传递以及处理。具体可以去看下touch事件这块。因为问的太抽象化了
严重怀疑题目出到越后面就越笼统。
47.Difference between frame and bounds?
frame和bounds有什么不同?
答案:frame指的是:该view在父view坐标系统中的位置和大小。(参照点是父亲的坐标系统)
bounds指的是:该view在本身坐标系统中 的位置和大小。(参照点是本身坐标系统)
48.Difference between method and selector?
方法和选择器有何不同?
答案:selector是一个方法的名字,method是一个组合体,包含了名字和实现.
详情可以看apple文档。
49.Is there any garbage collection mechanism in Objective C.?
OC的垃圾回收机制?
答案: OC2.0有Garbage collection,但是iOS平台不提供。
一般我们了解的objective-c对于内存管理都是手动操作的,但是也有自动释放池。
但是差了大部分资料,貌似不要和arc机制搞混就好了。
求更多~~
50.NSOperation queue?
答案:存放NSOperation的集合类。
操作和操作队列,基本可以看成java中的线程和线程池的概念。用于处理ios多线程开发的问题。
网上部分资料提到一点是,虽然是queue,但是却并不是带有队列的概念,放入的操作并非是按照严格的先进现出。
这边又有个疑点是,对于队列来说,先进先出的概念是Afunc添加进队列,Bfunc紧跟着也进入队列,Afunc先执行这个是必然的,
但是Bfunc是等Afunc完全操作完以后,B才开始启动并且执行,因此队列的概念离乱上有点违背了多线程处理这个概念。
但是转念一想其实可以参考银行的取票和叫号系统。
因此对于A比B先排队取票但是B率先执行完操作,我们亦然可以感性认为这还是一个队列。
但是后来看到一票关于这操作队列话题的文章,其中有一句提到
“因为两个操作提交的时间间隔很近,线程池中的线程,谁先启动是不定的。”
瞬间觉得这个queue名字有点忽悠人了,还不如pool~
综合一点,我们知道他可以比较大的用处在于可以帮组多线程编程就好了。
51.What is lazy loading?
答案:懒汉模式,只在用到的时候才去初始化。
也可以理解成延时加载。
我觉得最好也最简单的一个列子就是tableView中图片的加载显示了。
一个延时载,避免内存过高,一个异步加载,避免线程堵塞。
52.Can we use two tableview controllers on one viewcontroller?
是否在一个视图控制器中嵌入两个tableview控制器?
答案:一个视图控制只提供了一个View视图,理论上一个tableViewController也不能放吧,
只能说可以嵌入一个tableview视图。当然,题目本身也有歧义,如果不是我们定性思维认为的UIViewController,
而是宏观的表示视图控制者,那我们倒是可以把其看成一个视图控制者,它可以控制多个视图控制器,比如TabbarController
那样的感觉。
53.Can we use one tableview with two different datasources? How you will achieve this?
一个tableView是否可以关联两个不同的数据源?你会怎么处理?
答案:首先我们从代码来看,数据源如何关联上的,其实是在数据源关联的代理方法里实现的。
因此我们并不关心如何去关联他,他怎么关联上,方法只是让我返回根据自己的需要去设置如相关的数据源。
因此,我觉得可以设置多个数据源啊,但是有个问题是,你这是想干嘛呢?想让列表如何显示,不同的数据源分区块显示?
1.Object-c的类可以多重继承么?可以实现多个接口么??
2.#import 跟#include 又什么区别,@class呢; #import<> 跟 #import”"又什么区别??
3.属性readwrite,readonly,assign,retain,copy,nonatomic 各是什么作用,在那种情况下用 ?
4、为什么很多内置的类,如TableViewController的delegate的属性是assign不是retain?
6,委托是什么?委托的property声明用什么属性?为什么?
代理的目的是改变或传递控制链,允许一个类在某些特定时刻通知到其他类而不需要获取那些类的指针。
7,类别的作用?
1),将类的实现分散到多个类中2),创建对私有方法的引用3),可以添加或修改方法,属性
8,.id 声明的对象有什么特性??
9,.MVC是什么?有什么特性?为什么在iPhone上被广泛运用?
MVC设计模式是三种对象:模型对象,视图对象和控制器对象。模型对象代表应用程序的数据和定义操作数据的逻辑。视图对象显示应用程序的模型数据。控制器对象是协调视图和模型对象。
13,为什么4.0独有的c函数在3.1的机器上运行不会报错(在没有调用的情况下?)而4.0独有的类名在3.1的机器上一运行就报错?
?14,常见的object-c的数据类型有那些, 和 c 的 基本数据类型有什么区别?如:nsinteger 和int
15,.property中属性retain,copy,assgin的含义分别是什么?有什么区别?将其转换成get/set方法怎么做?有什么注意事项?
Notification是一种消息,它传递给一个或多个观察对象用来通知它们程序里发生了一个事件。
当处理单个需要在另外类触发当前类行为的事件时用代理,多个事件用 Notification.
线程创建和启动,NSThread detachNew创建和NSThread 创建两中方式
线程共享同一应用程序的部分内存空间它们拥有对数据相同的访问权限
19.线程和进程的区别和联系?
线程和进程都是程序运行的基本单元,区别在于进程在运行中拥有独立的内存单元,而多个线程共享内存,提高程序效率,线程不能独立执行。
20,线程是什么? 有哪些注意事项.?
21,.notification是同步还是异步? kvo是同步还是异步?notification是全进程空间的通知吗?
22.浅拷贝和深拷贝区别是什么?…
浅复制:只复制指向对象的指针,而不复制引用对象本身。深复制:复制引用对象本身。
24.for(int index = 0; index < 20; index ++){? NSString *tempStr = @”tempStr”;? NSLog(tempStr);? NSNumber *tempNumber = [NSNumber numberWithInt:2];? NSLog(tempNumber);?}?这段代码有什么问题.?会不会造成内存泄露(多线程)?在内存紧张的设备上做大循环时自动释放池是写在循环内好还是循环外好?为什么?
25,.内存管理的几条原则时什么?按照默认法则.那些关键字生成的对象需要手动释放?在和property结合的时候怎样有效的避免内存泄露?
26,.在一个对象释放前.如果他被加到了notificationCenter 中.不在notificationcenter中remove这个对象可能会出现什么问题?
27,.怎样实现一个 singleton的类.给出思路。
单例是在程序生命周期里只被实例化过一次的 类
29.在iphone上有两件事情要做,请问是在一个线程里按顺序做效率高还是两个线程里做效率高?为什么?
30,.runloop是什么?在主线程中的某个函数里调用了异步函数,怎么样block当前线程,且还能响应当前线程的timer事件,touch事件等.
31,ios平台怎么做数据的持久化?coredata和sqlite有无必然联系?coredata是一个关系型数据库吗?
32.阐述一个nil对象从interface bulider产生,到载入程序运行空间,最后被释放时所经历的生命周期.
33,响应者链是什么?
34,.timer的间隔周期准吗?为什么?怎样实现一个精准的timer?
35.UIscrollVew用到了什么设计模式?还能再foundation库中找到类似的吗?
36.C和obj-c 如何混用?
37,ViewController 的 loadView, viewDidLoad, viewDidUnload 分别是在什么时候调用的?
view为空时调用loadView,加载完成时调用viewDidLoad,释放时调用viewDidUnload.
代码中自动加入了retain/release,原先需要手动添加的用来处理内存管理的引用计数的代码可以自动地由编译器完成了,代码高速化,由于使用编译器管理引用计数,减少了低效代码的可能性
40, Object-C有私有方法吗?私有变量呢??没,有。
41、Object-C的内存管理??引用计数器。??
self.表示对象的属性,self表示对象本身
自动释放池中所有对象释放完后释放。
内存释放池提供了一个对象容器,每次对象发送autorelease消息时,对象的引用计数并不真正变化,而是向内存释放池中添加一条记录,记下对象的这 种要求。直到当内存释放池发送drain或release消息时,即当池被销毁前会通知池中的所有对象,全部发送release消息才会真正将引用计数减 少?。?
只用 @ interface声明的变量只能在当前的类中访问,在其他类无法访问,而@ propety声明的变量可以在外部访问。@ propety声明的变量可以打点调用
字符串拼接,强制类型转换
2。viewcontroller的一些方法的说明viewDidLoad, viewWillDisappear, viewWillAppear方法的 顺序和 作用?
3。frame 和 bounds 的 区别 ,bound的大小改变frame 改变吗?
4。sqlite中插入特殊字符的方法和接收到处理方法。
5。谈谈你对数组和链表认识,还有你是怎么用他们的?
6。冒泡算法。
7。socket编程简述
8。asihttp代码原理 ,异步请求的原理,异步请求最大数目,为什么只能这么多?
9。http请求方式?
10。uiview的圆角属性设置方法。
(m_mainImgView.layer.cornerRadius = 6;
m_mainImgView.layer.masksToBounds = YES;)
11。 masksToBounds属性的作用。(决定子layer是否被当前layer的边界剪切。默认是NO。)
来自网络
1.main()
{ int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d",*(a+1),*(ptr-1));
}
答:2 , 5
*(a+1)就是a[1],*(ptr-1)就是a[4],执行结果是2,5
&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小(本例是5个int)
int *ptr=(int *)(&a+1);
则ptr实际是&(a[5]),也就是a+5
原因如下:
&a是数组指针,其类型为 int (*)[5];
而指针加1要根据指针类型加上一定的值,不同类型的指针+1之后增加的大小不同。
a是长度为5的int数组指针,所以要加 5*sizeof(int)
所以ptr实际是a[5]
但是prt与(&a+1)类型是不一样的(这点很重要)
所以prt-1只会减去sizeof(int*)
a,&a的地址是一样的,但意思不一样
a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址,
a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5].
2.以下为Windows NT下的32位C++程序,请计算sizeof的值
void Func ( char str[100] )
{ sizeof( str ) = ? }
void *p = malloc( 100 );
sizeof ( p ) = ?
答:4,4
这题很常见了,Func ( char str[100] )函数中数组名作为函数形参时,在函数体内,数组名失去了本身的内涵,仅仅只是一个指针;在失去其内涵的同时,它还失去了其常量特性,可以作自增、自减等操作,可以被修改。Windows NT 32位平台下,指针的长度(占用内存的大小)为4字节,故sizeof( str ) 、sizeof ( p ) 都为4。
3.还是考指针,不过我对cocoa的代码还是不太熟悉
大概是这样的
-(void)*getNSString(const NSString * inputString)
{inputString = @"This is a main test\n";
return ;}
-main(void)
{ NSString *a=@"Main";
NSString *aString = [NSString stringWithString:@"%@",getNSString(a)];
NSLog(@"%@\n", aString); }
最后问输出的字符串:NULL,output在函数返回后,内存已经被释放。
4.用预处理指令#define声明一个常数,用以表明1年中有多少秒(忽略闰年问题)
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情:
?; #define 语法的基本知识(例如:不能以分号结束,括号的使用,等等)
?; 懂得预处理器将为你计算常数表达式的值,因此,直接写出你是如何计算一年中有多少秒而不是计算出实际的值,是更清晰而没有代价的。
?; 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
?; 如果你在你的表达式中用到UL(表示无符号长整型),那么你有了一个好的起点。记住,第一印象很重要。
写一个"标准"宏MIN,这个宏输入两个参数并返回较小的一个。
#define MIN(A,B)((A) <= (B) ? (A) : (B))
这个测试是为下面的目的而设的:
?;标识#define在宏中应用的基本知识。这是很重要的,因为直到嵌入(inline)操作符变为标准C的一部分,宏是方便产生嵌入代码的唯一方
法,对于嵌入式系统来说,为了能达到要求的性能,嵌入代码经常是必须的方法。
?;三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比 if-then-else更优化的代码,了解这个用法是很重要的。
?; 懂得在宏中小心地把参数用括号括起来
?;我也用这个问题开始讨论宏的副作用,例如:当你写下面的代码时会发生什么事?
least = MIN(*p++, b);
结果是:
((*p++) <= (b) ? (*p++) : (*p++))
这个表达式会产生副作用,指针p会作三次++自增操作。
5.写一个委托的interface
@protocol MyDelegate;
@interface MyClass: NSObject
{ id <MyDelegate> delegate; }
//委托方法
@protocol MyDelegate
- (void)didJobs:(NSArray *)args;
@end
6.写一个NSString类的实现
+ (id)initWithCString:(const char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id) stringWithCString: (const char*)nullTerminatedCString
encoding: (NSStringEncoding)encoding
{
NSString *obj;
obj = [self allocWithZone: NSDefaultMallocZone()];
obj = [obj initWithCString: nullTerminatedCString encoding: encoding];
return AUTORELEASE(obj);
}
7.obj-c有多重继承么?不是的话有什么替代方法?
cocoa中所有的类都是NSObject的子类
多继承在这里是用protocol委托代理来实现的
你不用去考虑繁琐的多继承,虚基类的概念.
ood的多态特性 在obj-c中通过委托来实现.
8.obj-c有私有方法么?私有变量呢
objective-c -类里面的方法只有两种, 静态方法和实例方法. 这似乎就不是完整的面向对象了,按照OO的原则就是一个对象只暴露有用的东西. 如果没有了私有方法的话, 对于一些小范围的代码重用就不那么顺手了. 在类里面声名一个私有方法
@interface Controller : NSObject { NSString *something; }
+ (void)thisIsAStaticMethod;
- (void)thisIsAnInstanceMethod;
@end
@interface Controller (private) -
(void)thisIsAPrivateMethod;
@end
@private可以用来修饰私有变量
在Objective‐C中,所有实例变量默认都是私有的,所有实例方法默认都是公有的
9.关键字const有什么含意?修饰类呢?static的作用,用于类呢?还有extern c的作用
const意味着"只读",下面的声明都是什么意思?
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
前两个的作用是一样,a是一个常整型数。第三个意味着a是一个指向常整型数的指针(也就是,整型数是不可修改的,但指针可以)。第四个意思a是一个指向整型数的常指针(也就是说,指针指向的整型数是可以修改的,但指针是不可修改的)。最后一个意味着a是一个指向常整型数的常指针(也就是说,指针指向的整型数是不可修改的,同时指针也是不可修改的)。
结论:
?;关键字const的作用是为给读你代码的人传达非常有用的信息,实际上,声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果
你曾花很多时间清理其它人留下的垃圾,你就会很快学会感谢这点多余的信息。(当然,懂得用const的程序员很少会留下的垃圾让别人来清
理的。)
?; 通过给优化器一些附加的信息,使用关键字const也许能产生更紧凑的代码。
?; 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数,防止其被无意的代码修改。简而言之,这样可以减少bug的出现。
(1)欲阻止一个变量被改变,可以使用 const 关键字。在定义该 const 变量时,通常需要对它进行初
始化,因为以后就没有机会再去改变它了;
(2)对指针来说,可以指定指针本身为 const,也可以指定指针所指的数据为 const,或二者同时指
定为 const;
(3)在一个函数声明中,const 可以修饰形参,表明它是一个输入参数,在函数内部不能改变其值;
(4)对于类的成员函数,若指定其为 const 类型,则表明其是一个常函数,不能修改类的成员变量;
(5)对于类的成员函数,有时候必须指定其返回值为 const 类型,以使得其返回值不为“左值”。
关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。精确地说就是,优化器在用到
这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子:
?;并行设备的硬件寄存器(如:状态寄存器)
?; 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables) ?; 多线程应用中被几个任务共享的变量
?;一个参数既可以是const还可以是volatile吗?解释为什么。
?; 一个指针可以是volatile 吗?解释为什么。
下面是答案:
?; 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
?; 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
static关键字的作用:
(1)函数体内 static 变量的作用范围为该函数体,不同于 auto 变量,该变量的内存只被分配一次,
因此其值在下次调用时仍维持上次的值;
(2)在模块内的 static 全局变量可以被模块内所用函数访问,但不能被模块外其它函数访问;
(3)在模块内的 static 函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明
它的模块内;
(4)在类中的 static 成员变量属于整个类所拥有,对类的所有对象只有一份拷贝;
(5)在类中的 static 成员函数属于整个类所拥有,这个函数不接收 this 指针,因而只能访问类的static 成员变量。
extern "C"的作用
(1)被 extern "C"限定的函数或变量是 extern 类型的;
extern是 C/C++语言中表明函数和全局变量作用范围(可见性)的关键字,该关键字告诉编译器,
其声明的函数和变量可以在本模块或其它模块中使用。
(2)被 extern "C"修饰的变量和函数是按照 C 语言方式编译和连接的;
extern "C"的惯用法
(1)在 C++中引用 C 语言中的函数和变量,在包含 C 语言头文件(假设为 cExample.h)时,需进
行下列处理:
extern "C"
{ #include "cExample.h" }
而在 C 语言的头文件中,对其外部函数只能指定为 extern 类型,C 语言中不支持 extern "C"声明,
在.c 文件中包含了 extern "C"时会出现编译语法错误。
(2)在 C 中引用 C++语言中的函数和变量时,C++的头文件需添加 extern "C",但是在 C 语言中不
能直接引用声明了 extern "C"的该头文件,应该仅将 C 文件中将 C++中定义的 extern "C"函数声明为
extern 类型。
10.为什么标准头文件都有类似以下的结构?
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
显然,头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用
是防止该头文件被重复引用。
11.#import跟#include的区别,@class呢?
@class一般用于头文件中需要声明该类的某个实例变量的时候用到,在m文件中还是需要使用#import
而#import比起#include的好处就是不会引起交叉编译
12.MVC模式的理解
MVC设计模式考虑三种对象:模型对象、视图对象、和控制器对象。模型对象代表特别的知识和专业技能,它们负责保有应用程序的数据和定义操作数据的逻辑。视图对象知道如何显示应用程序的模型数据,而且可能允许用户对其进行编辑。控制器对象是应用程序的视图对象和模型对象之间的协调者。
13.线程与进程的区别和联系?
进程和线程都是由操作系统所 体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。
程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。
Add
进程和线程都是由操作系统所体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于:
简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程,使得多线程程序的并发性高。
另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.
///
14.列举几种进程的同步机制,并比较其优缺点。
答案: 原子操作 信号量机制 自旋锁 管程,会合,分布式系统
进程之间通信的途径
答案:共享存储系统消息传递系统管道:以文件系统为基础
进程死锁的原因
答案:资源竞争及进程推进顺序非法
死锁的4个必要条件
答案:互斥、请求保持、不可剥夺、环路
死锁的处理
答案:鸵鸟策略、预防策略、避免策略、检测与解除死锁
15.堆和栈的区别
管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
申请大小:
栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。
堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出
分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的。
16.什么是键-值,键路径是什么
模型的性质是通过一个简单的键(通常是个字符串)来指定的。视图和控制器通过键来查找相应的属性值。在一个给定的实体中,同一个属性的所有值具有相同的数据类型。键-值编码技术用于进行这样的查找—它是一种间接访问对象属性的机制。
键路径是一个由用点作分隔符的键组成的字符串,用于指定一个连接在一起的对象性质序列。第一个键的性质是由先前的性质决定的,接下来每个键的值也是相对于其前面的性质。键路径使您可以以独立于模型实现的方式指定相关对象的性质。通过键路径,您可以指定对象图中的一个任意深度的路径,使其指向相关对象的特定属性。
For example, the key path address.streetwould get the value of the address property from the receiving
object, and then determine the street property relative to the address object.
17.c和obj-c如何混用
1)obj-c的编译器处理后缀为m的文件时,可以识别obj-c和c的代码,处理mm文件可以识别obj-c,c,c++代码,但cpp文件必须只能用c/c++代码,而且cpp文件include的头文件中,也不能出现obj-c的代码,因为cpp只是cpp
2) 在mm文件中混用cpp直接使用即可,所以obj-c混cpp不是问题
3)在cpp中混用obj-c其实就是使用obj-c编写的模块是我们想要的。
如果模块以类实现,那么要按照cpp class的标准写类的定义,头文件中不能出现obj-c的东西,包括#import cocoa的。实现文件中,即类的实现代码中可以使用obj-c的东西,可以import,只是后缀是mm。
如果模块以函数实现,那么头文件要按c的格式声明函数,实现文件中,c++函数内部可以用obj-c,但后缀还是mm或m。
总结:只要cpp文件和cpp include的文件中不包含obj-c的东西就可以用了,cpp混用obj-c的关键是使用接口,而不能直接使用实现代码,实际上cpp混用的是obj-c编译后的o文件,这个东西其实是无差别的,所以可以用。obj-c的编译器支持cpp.
18.目标-动作机制
目标是动作消息的接收者。一个控件,或者更为常见的是它的单元,以插座变量(参见"插座变量"部分)
的形式保有其动作消息的目标。
动作是控件发送给目标的消息,或者从目标的角度看,它是目标为了响应动作而实现的方法。
程序需要某些机制来进行事件和指令的翻译。这个机制就是目标-动作机制。
19.cocoa touch框架
iPhoneOS应用程序的基础 Cocoa Touch 框架重用了许多 Mac 系统的成熟模式,但是它更多地专注于触摸的接口和优化。UIKit 为您提供了在 iPhone OS 上实现图形,事件驱动程序的基本工具,其建立在和 Mac OS X 中一样的 Foundation 框架上,包括文件处理,网络,字符串操作等。
Cocoa Touch具有和 iPhone 用户接口一致的特殊设计。有了 UIKit,您可以使用 iPhone OS 上的独特的图形接口控件,按钮,以及全屏视图的功能,您还可以使用加速仪和多点触摸手势来控制您的应用。
各色俱全的框架 除了 UIKit 外,Cocoa Touch 包含了创建世界一流 iPhone 应用程序需要的所有框架,从三维图形,到专业音效,甚至提供设备访问 API 以控制摄像头,或通过 GPS 获知当前位置。Cocoa Touch 既包含只需要几行代码就可以完成全部任务的强大的 Objective-C 框架,也在需要时提供基础的 C 语言 API 来直接访问系统。这些框架包括:
Core Animation
通过 Core Animation,您就可以通过一个基于组合独立图层的简单的编程模型来创建丰富的用户体验。
Core Audio
Core Audio是播放,处理和录制音频的专业技术,能够轻松为您的应用程序添加强大的音频功能。
Core Data
提供了一个面向对象的数据管理解决方案,它易于使用和理解,甚至可处理任何应用或大或小的数据模型。
功能列表:框架分类
下面是 Cocoa Touch 中一小部分可用的框架:
音频和视频
Core Audio
OpenAL
Media Library
AV Foundation
数据管理
Core Data
SQLite
图形和动画
Core Animation
OpenGL ES
Quartz 2D
网络/li>
Bonjour
WebKit
BSD Sockets
用户应用
Address Book
Core Location
Map Kit
Store Kit
20.objc的内存管理
如果您通过分配和初始化(比如[[MyClass alloc] init])的方式来创建对象,您就拥有这个对象,需要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也同样适用。
如果您拷贝一个对象,您也拥有拷贝得到的对象,需要负责该对象的释放。
如果您保持一个对象,您就部分拥有这个对象,需要在不再使用时释放该对象。反过来,
如果您从其它对象那里接收到一个对象,则您不拥有该对象,也不应该释放它(这个规则有少数的例外,在参考文档中有显式的说明)。
21.自动释放池是什么,如何工作
当您向一个对象发送一个autorelease消息时,Cocoa就会将该对象的一个引用放入到最新的自动释放池。它仍然是个正当的对象,因此自动释放池定义的作用域内的其它对象可以向它发送消息。当程序执行到作用域结束的位置时,自动释放池就会被释放,池中的所有对象也就被释放。
1. ojc-c是通过一种"referring counting"(引用计数)的方式来管理内存的, 对象在开始分配内存(alloc)的时候引用计数为一,以后每当碰到有copy,retain的时候引用计数都会加一, 每当碰到release和autorelease的时候引用计数就会减一,如果此对象的计数变为了0, 就会被系统销毁.
2. NSAutoreleasePool 就是用来做引用计数的管理工作的,这个东西一般不用你管的.
3. autorelease和release没什么区别,只是引用计数减一的时机不同而已,autorelease会在对象的使用真正结束的时候才做引用计数减一.
22.类工厂方法是什么
类工厂方法的实现是为了向客户提供方便,它们将分配和初始化合在一个步骤中,返回被创建的对象,并进行自动释放处理。这些方法的形式是+ (type)className...(其中 className不包括任何前缀)。工厂方法可能不仅仅为了方便使用。它们不但可以将分配和初始化合在一起,还可以为初始化过程提供对象的分配信息。类工厂方法的另一个目的是使类(比如NSWorkspace)提供单件实例。虽然init...方法可以确认一 个类在每次程序运行过程只存在一个实例,但它需要首先分配一个“生的”实例,然后还必须释放该实例。工厂方法则可以避免为可能没有用的对象盲目分配内存。
23.单件实例是什么
Foundation和 Application Kit 框架中的一些类只允许创建单件对象,即这些类在当前进程中的唯一实例。举例来说,NSFileManager 和NSWorkspace 类在使用时都是基于进程进行单件对象的实例化。当向这些类请求实例的时候,它们会向您传递单一实例的一个引用,如果该实例还不存在,则首先进行实例的分配和初始化。单件对象充当控制中心的角色,负责指引或协调类的各种服务。如果类在概念上只有一个实例(比如NSWorkspace),就应该产生一个单件实例,而不是多个实例;如果将来某一天可能有多个实例,您可以使用单件实例机制,而不是工厂方法或函数。
24.动态绑定
—在运行时确定要调用的方法
动态绑定将调用方法的确定也推迟到运行时。在编译时,方法的调用并不和代码绑定在一起,只有在消实发送出来之后,才确定被调用的代码。通过动态类型和动态绑定技术,您的代码每次执行都可以得到不同的结果。运行时因子负责确定消息的接收者和被调用的方法。运行时的消息分发机制为动态绑定提供支持。当您向一个动态类型确定了的对象发送消息时,运行环境系统会通过接收者的isa指针定位对象的类,并以此为起点确定被调用的方法,方法和消息是动态绑定的。而且,您不必在Objective-C 代码中做任何工作,就可以自动获取动态绑定的好处。您在每次发送消息时,特别是当消息的接收者是动态类型已经确定的对象时,动态绑定就会例行而透明地发生。
25.obj-c的优缺点
objc优点:
1) Cateogies
2) Posing
3) 动态识别
4) 指标计算
5)弹性讯息传递
6) 不是一个过度复杂的 C 衍生语言
7) Objective-C 与 C++ 可混合编程
缺点:
1) 不支援命名空间
2) 不支持运算符重载
3) 不支持多重继承
4) 使用动态运行时类型,所有的方法都是函数调用,所以很多编译时优化方法都用不到。(如内联函数等),性能低劣。
26.sprintf,strcpy,memcpy使用上有什么要注意的地方
strcpy是一个字符串拷贝的函数,它的函数原型为strcpy(char *dst, const char *src);
将src开始的一段字符串拷贝到dst开始的内存中去,结束的标志符号为'\0',由于拷贝的长度不是由我们自己控制的,所以这个字符串拷贝很容易出错。具备字符串拷贝功能的函数有memcpy,这是一个内存拷贝函数,它的函数原型为memcpy(char *dst, const char* src, unsigned int len);
将长度为len的一段内存,从src拷贝到dst中去,这个函数的长度可控。但是会有内存叠加的问题。
sprintf是格式化函数。将一段数据通过特定的格式,格式化到一个字符串缓冲区中去。sprintf格式化的函数的长度不可控,有可能格式化后的字符串会超出缓冲区的大小,造成溢出。
27.用变量a给出下面的定义
a)一个整型数(An integer)
b)一个指向整型数的指针( A pointer to an integer)
c)一个指向指针的的指针,它指向的指针是指向一个整型数( A pointer to a pointer to an intege)r
d)一个有10个整型数的数组( An array of 10 integers)
e) 一个有10个指针的数组,该指针是指向一个整型数的。(An array of 10 pointers to integers)
f) 一个指向有10个整型数数组的指针( A pointer to an array of 10 integers)
g) 一个指向函数的指针,该函数有一个整型参数并返回一个整型数(A pointer to a function that takes an integer as an argument and returns an integer)
h)一个有10个指针的数组,该指针指向一个函数,该函数有一个整型参数并返回一个整型数( An array of ten pointers to functions t
hat take an integer argument and return an integer )
答案是:
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
来自:蓝色维度
一、属性相关
1.在一个对象的方法里面: self.name = “object”; 和 name =”object” 有什么不同吗?
答:self.name = “object”会调用对象的setName()方法,name = “object”会直接把object赋值给当前对象的name属性。
2.这段代码有什么问题吗:
@implementation Person
- (void)setAge:(int)newAge {
self.age = newAge;
}
答:在进行age属性进行.的赋值时,会调用此方法的setAge方法,这样会进入无休止的循环调用中导致crash.
3.定义属性时,什么情况使用copy,assign,和retain?
答:readwrite 是可读可写特性;需要生成getter方法和setter方法时
readonly 是只读特性 只会生成getter方法 不会生成setter方法 ;不希望属性在类外改变
assign 是赋值特性,setter方法将传入参数赋值给实例变量;仅设置变量时;
retain 表示持有特性,setter方法将传入参数先保留,再赋值,传入参数的retain count会+1;
copy 表示赋值特性,setter方法将传入对象复制一份;需要完全复制一份新的变量时。
// more
nonatomic 非原子操作,决定编译器生成的setter getter是否是原子操作,atomic表示多线程安全,一般使用nonatomic
assign用于简单数据类型,如NSInteger,double,bool,retain 和copy用户对象,copy用于当 a指向一个对象,b也想指向同样的对象的时候,如果用assign,a如果释放,再调用b会crash,如果用copy 的方式,a和b各自有自己的内存,就可以解决这个问题。retain 会使计数器加一,也可以解决assign的问题。另外:atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。在多线程环境下,原子操作是必要的,否则有可能引起错误的结果。加了atomic,setter函数会变成下面这样:
if (property != newValue) {
[property release];
property = [newValue retain];
}
4.写一个setter方法用于完成@property (nonatomic,retain)NSString *name,
写一个setter方法用于完成@property(nonatomic,copy)NSString *name
答:// 这里主要是注意顺序,先要reain传入参数,再release原来的属性。防止name和str是同一个变量时发生错误。
// retain
- (void) setName : (NSString*) str {
[str retain];
[name release];
name = str;
}
// copy
- (void)setName:(NSString *)str
{
id t = [str copy];
[name release];
name = t;
}
5.为什么很多内置类如UITableViewController的delegate属性都是assign而不是retain的?
答:会引起循环引用,导致内存无法释放
二、UIViewController
1.ViewController 的 loadView, viewDidLoad, viewDidUnload 分别是在什么时候调用的?
在自定义ViewController的时候这几个函数里面应该做什么工作?
答:当ViewControll被初始化后,调用self.view属性时,如果view为nil的话,会调用loadView方法。loadView方法调用完成后,会调用viewDidLoad。
当ViewController收到内存不足的警告时,6.0以下版本会调用viewDidUnload方法。
这三个方法,在调用时,首先应该调用super类的同名方法,否则有可能引起循环调用crash。
loadView一般用于使用xib文件的情况,我们可以不重写这个方法。
viewDidLoad里可以加载一些我们自己的view。
viewDidUnload里实现将retain 的view release,如果是retain的IBOutlet view 属性则不要在这里release,IBOutlet会负责release 。
loadView和viewDidLoad里面加载的内容和viewDidUnload里面卸载的内容应该对应,否则容易内存泄露或者过度释放。
2.ViewController 的 didReceiveMemoryWarning 是在什么时候被调用的?默认的操作是什么?
答:当ViewController收到内存不足的警告时,6.0以下版本会调用viewDidUnload方法。
默认操作是调用super的同名方法,将viewController的view的所有subView移除,将view本身释放。
三、C语言相关
1.sizeof与strlen的区别和联系?
答:两者的联系是,都可以返回一个长度。
sizeof返回的是变量或类型所占的字节数。strlen返回的是字符串的长度。
sizeof是关键字,strlen是库函数。
2. 下列两行代码有什么区别?
char a[] = “string”;
char *b = “string”;
a是字符数组,b一个字符串,两者sizeof取值不同。
3. 下列代码会输出什么?
#define SQ(x) (x*x)
int main()
{
int b = 3;
int a = SQ(b + 2);
printf(“%d”, a);
return 0;
}
=b+2*b+2
11,不是25.主是要宏的直接替换问题。定义宏的时候元素上要加小括号.
4. 下列代码有什么问题?
char *foo(int n)
{
char buf[32];
buf[0] = (n != 0) ? ‘T’ : ‘F’;
buf[1] = 0;
return buf;
}
返回的是野指针。
5. 下列代码有什么问题?若有错误请改正。
void swap(int *p1, int *p2)
{
int *p = p1;
p1 = p2;
p2 = p;
}
无法实现交换两个指针,参数应该用指针的指针。
6. 若 char *p = malloc(32); 则 sizeof(p) 的值是什么?
32位机器上是4
7. 用递归方式和非递归方式写函数将一个字符串按字节反转,函数原型如下:
char *reverse(char *str);
非递归:
char *reverse(char *str)
{
if (str == NULL || strlen(str) <= 1) {
return str;
}
int len = strlen(str);
char* b = (char*)malloc(len+1);// 外部去释放
strcpy(b, str);
for (int i=0; i
char x = b[i];
b[i] = b[len-i-1];
b[len-i-1] = x;
}
return b;
}
递归:
char *reverse(char *str)
{
if (str == NULL || strlen(str) <= 1) {
return str;
}
int len = strlen(str);
char e[] = {str[len-1],0};
char s[] = {str[0],0};
char* b = (char*)malloc(len-1);
strncpy(b, str+1,len-2);
char* c = (char*)malloc(len+1);// 外部去释放,递归时可能有泄露
strcat(c, e);
strcat(c, reverse(b));
strcat(c, s);
free(b);
return c;
}
8. 为什么在析构函数中不应该抛出异常?
因为析构函数主要是已经进入清理内存的阶段,这时抛出异常的话没有地方去捕捉,会引起系统异常退出。
9.sprintf,strcpy,memcpy使用上有什么要注意的地方
strcpy是一个字符串拷贝的函数,它的函数原型为strcpy(char *dst, const char *src);
将src开始的一段字符串拷贝到dst开始的内存中去,结束的标志符号为’\0′,由于拷贝的长度不是由我们自己控制的,所以这个字符串拷贝很容易出错。具备字符串拷贝功能的函数有memcpy,这是一个内存拷贝函数,它的函数原型为memcpy(char *dst, const char* src, unsigned int len);
将长度为len的一段内存,从src拷贝到dst中去,这个函数的长度可控。但是会有内存叠加的问题。
sprintf是格式化函数。将一段数据通过特定的格式,格式化到一个字符串缓冲区中去。sprintf格式化的函数的长度不可控,有可能格式化后的字符串会超出缓冲区的大小,造成溢出。
10 程序在内存中运行时,内存分几个区?各自用途?
答:栈区 由编译器自动分配释放存放函数的参数值,局部变量的值等。在高级语言中不需要显式的分配和释放
堆区 一般由程序员手动分配释放,如果不释放可有由OS释放。
数据区 存储全局和静态变量。初始化的全局和静态变量在一块区域,未初始化的放在相邻的一块区域,程序结束后由系统释放。
代码区 存放函数体的二进制代码。
11 引用与指针有什么区别?
答:引用是给变量起一个别名 也就是一个变量有两个名字 他们是同一块空间
指针是分配一块内存用来保存变量的地址 间接引用变量
1.obj-c有多重继承么?不是的话有什么替代方法? Category是什么?重写一个类的方式用继承好还是分类好?为什么?
cocoa 中所有的类都是NSObject 的子类。oc不支持多继承,你不用去考虑繁琐的多继承 ,虚基类的概念.
多继承在这里是用protocol 委托代理 来实现的
Category是类别,重写一个类的方法,用继承还是分类要根据具体情况分析。
分类与继承:
一般情况用分类好,用Category去重写类的方法,仅对本Category有效,不会影响到其他类与原有类的关系。但是如果需要在重写的时候,还要调用原来的方法,就需要用继承了。分类是完全重写,无法调用原来的同名方法。
2.obj-c有私有方法么?私有变量呢 ?
objective-c – 类里面的方法只有两种, 静态方法和实例方法.
但是可以通过把方法的声明和定义都放在.m文件中来实现一个表面上的私有方法。
有私有变量,可以通过@private来修饰,或者把声明放到.m文件中。
在Objective‐C中,所有实例变量默认都是私有的,所有实例方法默认都是公有的
3.#import跟#include的区别? 后面的括号<>与”" 的区别?
#include?可能会重复包含,需要使用#pragram once 或者#ifdef 的方式来避免重复包含
#import没有这个问题,而且不会引起交叉编译
<>包含会从系统目录下开始寻找头文件
“”包含会优先从当前目录下寻找头文件,找不到再去系统目录下寻找。
4.ObjC中,与alloc语义相反的方法是dealloc还是release?
与retain语义相反的方法是dealloc还是release,为什么?
需要与alloc配对使用的方法是dealloc还是release,为什么?
答:alloc与dealloc语意相反,alloc是创建变量,dealloc是释放变量。
retain 对应release,retain 保留一个对象。调用之后,变量的计数加1。调用release后,变量的引用计数减1,当减为0时,dealloc方法会自动调用。我们一般不显示地调用dealloc这个方法。
alloc 需要与release配对使用,因为alloc 这个函数调用之后,变量的计数加1。所以在调用alloc 之后,一定要调用对应的release。
另外,在release一个变量之后,他的值仍然有效,所以最好是后面紧接着再var = nil。
5.OC中加号方法与减号的区别?
答:加号方法是类方法 属于静态方法
减号方法是实例 必须由类的实例来调用
6.常见的object-c的数据类型有那些, 和C的基本数据类型有什么区别?如:NSInteger和int
object-c的数据类型有NSString,NSNumber,NSArray,NSMutableArray,NSData等等,这些都是class,创建后便是对象。
基本类型还有CGFloat,NSInteger等等。这些是为了以后兼容考虑。现在是32位NSInteger占4个字节,如果以后cpu升级了,以后int型占到8位了,不需要修改代码,还有NSInteger就可以做到。
而C语言的基本数据类型int,只是一定字节的内存空间,用于存放数值;而object-c的NSNumber包含有父类NSObject的方法和NSNumber自己的方法,可以完成复杂的操作。
附:objective-c与C++比较
嵌套调用方法:
objective-c [[[对象 方法1] 方法2] 方法3];函数调用顺序,依次由内向外用。
C++ 对象.方法1( ).方法2( ).方法3( );
方法调用形式:
objective-c [ 对象 方法名:参数A 方法名:参数B...];
C++ 对象.方法名(参数列表);
对象的创建:
objective-c 类名 对象指针=[[类名 alloc] 初始化方法];
C++ 类名 对象指针=new 构造方法;
空指针:
objective-c nil // 给空指针发送消息不会崩溃,只是没反应
C++ NULL //设用空指针的方法会崩溃
五、IOS面试之十大问题(资深Cocoa开发)
以下问题的答案依据自己的经验整理来,完善中。。。
1.你使用过Objective-C的运行时编程(Runtime Programming)么?如果使用过,你用它做了什么?你还能记得你所使用的相关的头文件或者某些方法的名称吗?
答:整个OC都是运行在一套Runtime基础之上的。不过大部分我们不直接接触它的Runtime Programming.
我们使用下面这些方法时,动态判断一个对象的类型,是否能对某个方法进行响应等等,都用到了OC的运行时特点。
- (BOOL)isKindOfClass:(Class)aClass;
- (BOOL)isMemberOfClass:(Class)aClass;
- (BOOL)conformsToProtocol:(Protocol *)aProtocol;
- (BOOL)respondsToSelector:(SEL)aSelector;
运行时的一个头文件是objc/runtime.h。
我们可以利用里面的一些方法直接发送消息,如objc_msgSend().
也可以动态的给某个类添加方法,如class_addMethod().
甚至还可以动态添加一个类,如objc_addClass()。
2.你实现过多线程的Core Data么?NSPersistentStoreCoordinator,NSManagedObjectContext和NSManagedObject中的哪些需要在线程中创建或者传递?你是用什么样的策略来实现的?
答:没弄过。
3.Core开头的系列的内容。是否使用过CoreAnimation和CoreGraphics。UI框架和CA,CG框架的联系是什么?分别用CA和CG做过些什么动画或者图像上的内容。(有需要的话还可以涉及Quartz的一些内容)
答:涉及过一些。
UI框架内部还是由CA和CG实现的。
CA做过一些view的描边操作,还有淡入淡出的转场动画。
用CG做过一个画图程序,可以记录画笔的位置及线条颜色,可以合成一个UIImage.
4.是否使用过CoreText或者CoreImage等?如果使用过,请谈谈你使用CoreText或者CoreImage的体验。
答:没弄过。
5.NSNotification和KVO的区别和用法是什么?什么时候应该使用通知,什么时候应该使用KVO,它们的实现上有什么区别吗?如果用protocol和delegate(或者delegate的Array)来实现类似的功能可能吗?如果可能,会有什么潜在的问题?如果不能,为什么?
KVO只能监测属性的变化,通过NSString类型的属性名来实现。但是实现了自动监测,当属性值变化时,会自动通知观察者,不用再添加代码了。
NSNotification比较灵活,可以监测的内容较多,但是需要被观察者手动发送通知,观察者才能响频。
protocol通过添加一个NSArray也能实现类似的功能,但是实现上需要自己处理delegate的添加与删除,自己在属性变化时手动通知,较繁琐,易出错。
6.你用过NSOperationQueue么?如果用过或者了解的话,你为什么要使用NSOperationQueue,实现了什么?请描述它和GCD的区别和类似的地方(提示:可以从两者的实现机制和适用范围来描述)。
7.既然提到GCD,那么问一下在使用GCD以及block时要注意些什么?它们两是一回事儿么?block在ARC中和传统的MRC中的行为和用法有没有什么区别,需要注意些什么?
8.您是否做过异步的网络处理和通讯方面的工作?如果有,能具体介绍一些实现策略么?
做过。
通过注册代码或者block的方式,实现回调。在网络处理方面,统一处理出错的情况,没出错的情况下,将数据分别发送给接收者。
9.对于Objective-C,你认为它最大的优点和最大的不足是什么?对于不足之处,现在有没有可用的方法绕过这些不足来实现需求。如果可以的话,你有没有考虑或者实践过重新实现OC的一些功能,如果有,具体会如何做?
优点: 与C,C++兼容,很多以前的类库可以不用修改直接使用。动态识别,比较灵活。加入类别,扩展方便。
缺点: 不支持重载和多继承,运行时导致效率稍低。
后面的问题没考虑那么多。
10.你实现过一个框架或者库以供别人使用么?如果有,请谈一谈构建框架或者库时候的经验;如果没有,请设想和设计框架的public的API,并指出大概需要如何做、需要注意一些什么方面,来使别人容易地使用你的框架。
答:曾经移植过一个框架,把C++的一套类库移植到OC上面,主要工作就是做一个oc++的接口层。做的过程中,遇到的问题就是在原来框架中,很多头文件中用结构体或者类的地方,没有用指针,导致不能用声明的方式来使用类和结构体,必须在头文件中把其它头文件导入,这样导致整个接口需要提供的头文件太多了。
还封装过供他人调用的接口。建议就是调用方法尽可能简单,做好传入参数的安全检查及错误提醒。因为你无法确定你的调用者给你传什么样的数据进来。如果实现方法中耗时较长,需要用异步的方式进行结果返回,可以选用delegate或者block的方式。
六、开发经验及技巧
1. 下面请求数据用了什么协议,请求的数据格式是什么?
UIWebView *webView = [[UIWebView alloc] initWithFrame:self.view.frame];
[webView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:http://pzpromop.s3.amazonaws.com/PromoNeutral.html]]];
[self.view addSubview:webView];
答:用了http协议,请求的数据格式是html文本。
2. 想传输一张图片,可以用什么协议传输?
答:http.
3.一个UITableView的实例,重新加载数据的方法是什么?
答:reloadData重新加载数据源中的全部数据
- (void)reloadSections:(NSIndexSet *)sections withRowAnimation:(UITableViewRowAnimation)animation;
重新加载指定section中的数据
- (void)reloadRowsAtIndexPaths:(NSArray *)indexPaths withRowAnimation:(UITableViewRowAnimation)animation;
重新加载指定行的数据
4.如何对iOS设备进行性能测试?
Profile-> Instruments ->Time Profiler
5. Object C中创建线程的方法是什么?如果在主线程中执行代码,方法是什么?如果想延时执行代码、方法又是什么?
答:线程创建有三种方法:使用NSThread创建、使用GCD的dispatch、使用子类化的NSOperation,然后将其加入NSOperationQueue;
在主线程执行代码,方法是performSelectorOnMainThread,
如果想延时执行代码可以用performSelector:onThread:withObject:waitUntilDone:或者dispatch_after或者NSTimer
6.建一个工程用到最基本的两个框架是什么?
答:UIKit框架 Foundation框架
7.如果UIView *view 已经实例化 在view 仅添加了N个UIButton类的实例,这些button不是全局的,并且button已经用tag区分开,如何快速找出其中指定的一个button改变它的某个属性?
答:[view viewWithTag:tagValue];
8.如何将产品进行多语言发布?
答:开发中xib针对每个语言做一个。
字符串用NSLocalizedString宏包含起来
Make File Localizable
9.Animation的不同形式,并加以代码示例.
答:枚举如下:
typedef NS_OPTIONS(NSUInteger, UIViewAnimationOptions) {
UIViewAnimationOptionLayoutSubviews = 1 << 0,
UIViewAnimationOptionAllowUserInteraction = 1 << 1, // turn on user interaction while animating
UIViewAnimationOptionBeginFromCurrentState = 1 << 2, // start all views from current value, not initial value
UIViewAnimationOptionRepeat = 1 << 3, // repeat animation indefinitely
UIViewAnimationOptionAutoreverse = 1 << 4, // if repeat, run animation back and forth
UIViewAnimationOptionOverrideInheritedDuration = 1 << 5, // ignore nested duration
UIViewAnimationOptionOverrideInheritedCurve = 1 << 6, // ignore nested curve
UIViewAnimationOptionAllowAnimatedContent = 1 << 7, // animate contents (applies to transitions only)
UIViewAnimationOptionShowHideTransitionViews = 1 << 8, // flip to/from hidden state instead of adding/removing
UIViewAnimationOptionCurveEaseInOut = 0 << 16, // default
UIViewAnimationOptionCurveEaseIn = 1 << 16,
UIViewAnimationOptionCurveEaseOut = 2 << 16,
UIViewAnimationOptionCurveLinear = 3 << 16,
UIViewAnimationOptionTransitionNone = 0 << 20, // default
UIViewAnimationOptionTransitionFlipFromLeft = 1 << 20,
UIViewAnimationOptionTransitionFlipFromRight = 2 << 20,
UIViewAnimationOptionTransitionCurlUp = 3 << 20,
UIViewAnimationOptionTransitionCurlDown = 4 << 20,
UIViewAnimationOptionTransitionCrossDissolve = 5 << 20,
UIViewAnimationOptionTransitionFlipFromTop = 6 << 20,
UIViewAnimationOptionTransitionFlipFromBottom = 7 << 20,
} NS_ENUM_AVAILABLE_IOS(4_0);
感觉这个知道怎么查api就好,用的时候,可以直接查看头文件。
来自:蓝色维度
七、内存管理
1.objc的内存管理简介
(1)如果您通过分配和初始化(比如[[MyClass alloc] init])的方式来创建对象,您就拥有这个对象,需要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也同样适用。
(2)如果您拷贝一个对象,您也拥有拷贝得到的对象,需要负责该对象的释放。
(3)如果您保持一个对象,您就部分拥有这个对象,需要在不再使用时释放该对象。
(4)通过alloc,new, copy, retain的对象,retainCount+1;release或者autorelease后retainCount-1,如果retainCount为0时,对象会被消毁,dealloc方法被调用。
(5)谁拥有,谁管理;
2.什么是retain count?
答:引用计数(ref count或者retain count)。对象的内部保存一个数字,表示被引用的次数。
例如,某个对象被两个指针所指向(引用)那么它的retain count为2。需要销毁对 象的时候,不直接调用dealloc,而是调用release。release会 让retain count减1,只有retain count等于0,系统才会调用dealloc真正销毁这个对象。
3.自动释放池是什么,如何工作?
答:当您向一个对象发送一个autorelease消息时,Cocoa就会将该对象的一个引用放入到最新的自动释放池。它仍然是个正当的对象,因此自动释放池定义的作用域内的其它对象可以向它发送消息。当程序执行到作用域结束的位置时,自动释放池就会被释放,池中的所有对象也就被释放。
4.autorelease的对象是在什么时候被release的?
答:autorelease实际上只是把对release的调用延迟了,对于每一个Autorelease,系统只是把该Object放入了当前的Autorelease pool中,当该pool被释放时,该pool中的所有Object会被调用Release。
对于每一个Runloop, 系统会隐式创建一个Autorelease pool,这样所有的release pool会构成一个象CallStack一样的一个栈式结构,在每一个Runloop结束时,当前栈顶的Autorelease pool会被销毁,这样这个pool里的每个Object(就是autorelease的对象)会被release。
5.那什么是一个Runloop呢?
一个UI事件,Timer call, delegate call, 都会是一个新的Runloop。
6.以下每行代码执行后,person对象的retain count分别是多少
Person *person = [[Person alloc] init]; count 1
[person retain]; count 2
[person release];count 1
[person release];retain count = 1;
7.下面代码中obj2是否需要dealloc?
ClassA *obj1 = [[ClassA alloc] init];
ClassA *obj2 = obj1;
[obj1 hello]; //输出hello
[obj1 release];
[obj2 hello]; //程序能否执行到这一行?
[obj2 release];
答 不需要 他和obj2指向的是同一块空间
8.看下面的程序,第一个NSLog会输出什么?这时str的retainCount是多少?第二个和第三个呢? 为什么?
NSMutableArray* ary = [[NSMutableArray array] retain];
NSString *str = [NSString stringWithFormat:@"test"];
[str retain];
[ary addObject:str];
NSLog(@”%@%d”,str,[str retainCount]);
[str retain];
[str release];
[str release];
NSLog(@”%@%d”,str,[str retainCount]);
[ary removeAllObjects];
NSLog(@”%@%d”,str,[str retainCount]);
答:
str的retainCount创建+1,retain+1,加入数组自动+1
3
retain+1,release-1,release-1
2
数组删除所有对象,所有数组内的对象自动-1
1
9.autorelease和垃圾回收机制(gc)有什么关系?
答:autorelase是用代码手写,在eventloop结束后被释放。
垃圾回收机制开启的话,你只用alloc,不用release,它会自动侦测一些你不用的对象,将它release掉。
可能在实现方式上或者说release的时机判断上有不同,但是效果都是自动relase这个对象。
10.IPhone OS有没有垃圾回收(gc)?
没有。iPhone开发的时候没有垃圾回收机制,OC支持gc,但只限制在Mac OS上。
11.这段代码有什么问题,如何修改
for (int i = 0; i < someLargeNumber; i++)
{
NSString *string = @”Abc”;
string = [string lowercaseString];
string = [string stringByAppendingString:@"xyz"];
NSLog(@“%@”, string);
}
答:同时生成了大量autorelease对象,不利于内存管理。但是如果放在子线程的话,而且没有开启垃圾回收机制的话,则会造成内存泄露。
修改一:
for(int i = 0; i<somelargenumber;i++){
NSAutoreleasePool * pool1 = [[NSAutoreleasePool alloc] init];
NSString *string = @"Abc";
string = [string lowercaseString];
string = [string stringByAppendingString:@"xyz"];
NSLog(@"%@",string);
[pool1 drain];
}
修改二:
NSAutoreleasePool * pool1 = [[NSAutoreleasePool alloc] init];
for(int i = 0; i<somelargenumber;i++){
NSString *string = @"Abc";
string = [string lowercaseString];
string = [string stringByAppendingString:@"xyz"];
NSLog(@"%@",string);
}
[pool1 drain];
一点说明:
修改一的autoreleasePool的建立方法是考虑在如果每次循环生成大量的autorelease对象,这些对象占用很大内存的情况下,循环了1000次,那么这些所有的内存加起来就已经够程序崩溃了,那么这时候加在循环里面可以避免程序崩溃。
但是如果程序循环1000次生成的内存也不是很多,则可以用方法二,提高效率。
[pool drain]和[pool release]在没有垃圾回收机制的情况下,他们的效果是一样的。但是如果做mac开发而且开启了垃圾回收机制的话,要用drain而不是release,因为那种情况下用release只是把pool这个对象清理了,而pool里面的对象是没有被清理掉的。
附:CoreFoundation部分
1)create,copy会形成own关系,不需要时应该CFRelease();
2) get方式得到的object,不形成own关系,不需要管理;
3)一个object作为参数传递到函数中后,receiver不与他形成own关系,也就是可能在任何时间被deallocate掉,所以需要CFRetain();
4)CFIndex count = CFGetRetainCount(obj);
5) myCFObj1 = myCFObj2-->引用拷贝,不会生成2个对象,应该使用CFStringCreatCopy()
6)符合的CF对象,copy时需要自己实现deep copy;
八、CocoaTouch
1.main.m中都发生了什么?
答:程序入口,创建 自动释放池,创建应用程序对象,并启动其主循环,运行程序,释放程序运行期间得所有加入自动释放池的对象。
2.int retVal = UIApplicationMain(argc, argv, nil, nil); 是什么意思?
答:对UIApplication对象进行了初始化,这个方法除了argc 和 argv 参数外,另外这个函数还有两个字符串参数来识别UIApplication类和UIApplication代理类,在这里默认是2个nil,第一个参数为nil就默认把UIApplication类作为缺省值进行初始化,可以在这里不填nil而是使用自己定义的UIApplication子类。至于第二个参数nil就设置为nil就把模板生成的HelloWorldAppdelegate类作为默认值。
3.编写NSArray的setter和getter.
答:getter比较容易,直接返回NSArray的指针就可以了,
setter注意每个元素加进去得时候需要retain一次。
4.什么是Notification?答:观察者模式,controller向defaultNotificationCenter添加自己的notification,其他类注册这个notification就可以收到通知,这些类可以在收到通知时做自己的操作(多观察者默认随机顺序发通知给观察者们,而且每个观察者都要等当前的某个观察者的操作做完才能轮到他来操作,可用NotificationQueue的方式安排观察者的反应顺序,也可以在添加观察者中设定反映时间,取消观察需要在viewDidUnload 跟dealloc中都要注销)。
5.多线程编程中,NSThread子线程与主线程的交互.
答:子线程内执行[self performSelectorOnMainThread:@selector(function:)withObject:];通知主线程执行相应方法。或者用全局变量的方式。
6.objective-c中是所有对象间的交互是如何实现的?(深圳皆凯科技有限公司笔试题)
答:在Objective-C中所有对象间的交互都是通过指针实现的,确切的说话,叫做发送消息。
8.objective-c中是如何实现线程同步的?
答:关键字@synchronized()
7.id 声明的对象有什么特性?
答:id 声明的对象具有运行时的特性,即可以指向任意类型的objcetive-c的对象;
8.cocoa touch框架
iPhone OS 应用程序的基础 Cocoa Touch 框架重用了许多 Mac 系统的成熟模式,但是它更多地专注于触摸的接口和优化。UIKit 为您提供了在 iPhone OS 上实现图形,事件驱动程序的基本工具,其建立在和 Mac OS X中一样的 Foundation 框架上,包括文件处理,网络,字符串操作等。
Cocoa Touch 具有和 iPhone 用户接口一致的特殊设计。有了 UIKit,您可以使用 iPhone OS 上的独特的图形接口控件,按钮,以及全屏视图的功能,您还可以使用加速仪和多点触摸手势来控制您的应用。
各色俱全的框架 除了 UIKit 外,Cocoa Touch 包含了创建世界一流 iPhone 应用程序需要的所有框架,从三维图形,到专业音效,甚至提供设备访问 API 以控制摄像头,或通过 GPS 获知当前位置。Cocoa Touch 既包含只需要几行代码就可以完成全部任务的强大的 Objective-C 框架,也在需要时提供基础的 C 语言 API 来直接访问系统。这些框架包括:
Core Animation
通过 Core Animation,您就可以通过一个基于组合独立图层的简单的编程模型来创建丰富的用户体验。
Core Audio
Core Audio 是播放,处理和录制音频的专业技术,能够轻松为您的应用程序添加强大的音频功能。
Core Data
提供了一个面向对象的数据管理解决方案,它易于使用和理解,甚至可处理任何应用或大或小的数据模型。
功能列表:框架分类
下面是 Cocoa Touch 中一小部分可用的框架:
音频和视频
Core Audio
OpenAL
Media Library
AV Foundation
数据管理
Core Data
SQLite
图形和动画
Core Animation
OpenGL ES
Quartz 2D
网络/li>
Bonjour
WebKit
BSD Sockets
用户应用
Address Book
Core Location
Map Kit
Store Kit
九、设计模式
1.MVC模式的理解
MVC设计模式考虑三种对象:模型对象、视图对象、和控制器对象。模型对象代表特别的知识和专业技能,它们负责保有应用程序的数据和定义操作数据的逻辑。视图对象知道如何显示应用程序的模型数据,而且可能允许用户对其进行编辑。控制器对象是应用程序的视图对象和模型对象之间的协调者。
2.描述一下iOS SDK中如何实现MVC的开发模式
MVC是模型、视图、控制开发模式,对于iOS SDK,所有的View都是视图层的,它应该独立于模型层,由视图控制层来控制。所有的用户数据都是模型层,它应该独立于视图。所有的ViewController都是控制层,由它负责控制视图,访问模型数据。
3.类工厂方法是什么
类工厂方法的实现是为了向客户提供方便,它们将分配和初始化合在一个步骤中,返回被创建的对象,并进行自动释放处理。这些方法的形式是+ (type)className…(其中 className不包括任何前缀)。
工厂方法可能不仅仅为了方便使用。它们不但可以将分配和初始化合在一起,还可以为初始化过程提供对象的分配信息。
类工厂方法的另一个目的是使类(比如NSWorkspace)提供单件实例。虽然init…方法可以确认一个类在每次程序运行过程只存在一个实例,但它需要首先分配一个“生的”实例,然后还必须释放该实例。
工厂方法则可以避免为可能没有用的对象盲目分配内存。
4.单件实例是什么
Foundation 和 Application Kit 框架中的一些类只允许创建单件对象,即这些类在当前进程中的唯一实例。举例来说,NSFileManager 和NSWorkspace 类在使用时都是基于进程进行单件对象的实例化。当向这些类请求实例的时候,它们会向您传递单一实例的一个引用,如果该实例还不存在,则首先进行实例的分配和初始化。单件对象充当控制中心的角色,负责指引或协调类的各种服务。如果类在概念上只有一个实例(比如
NSWorkspace),就应该产生一个单件实例,而不是多个实例;如果将来某一天可能有多个实例,您可以使用单件实例机制,而不是工厂方法或函数。
十、操作系统
1.线程与进程的区别和联系?
答:进程和线程都是由操作系统所体会的程序运行的基本单元,系统利用该基本单元实现系统对应用的并发性。
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。
2.列举几种进程的同步机制,并比较其优缺点。
答案: 原子操作 信号量机制 自旋锁 管程,会合,分布式系统
进程之间通信的途径
答案:共享存储系统消息传递系统管道:以文件系统为基础
进程死锁的原因
答案:资源竞争及进程推进顺序非法
死锁的4个必要条件
答案:互斥、请求保持、不可剥夺、环路
死锁的处理
答案:鸵鸟策略、预防策略、避免策略、检测与解除死锁
3.堆和栈的区别
管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
申请大小:
栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。
堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出
分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的。
十一、杂项
1.动态绑定
—在运行时确定要调用的方法
动态绑定将调用方法的确定也推迟到运行时。在编译时,方法的调用并不和代码绑定在一起,只有在消实发送出来之后,才确定被调用的代码。通过动态类型和动态绑定技术,您的代码每次执行都可以得到不同的结果。运行时因子负责确定消息的接收者和被调用的方法。运行时的消息分发机制为动态绑定提供支持。当您向一个动态类型确定了的对象发送消息时,运行环境系统会通过接收者的isa指针定位对象的类,并以此为起点确定被调用的方法,方法和消息是动态绑定的。而且,您不必在Objective-C 代码中做任何工作,就可以自动获取动态绑定的好处。您在每次发送消息时,
特别是当消息的接收者是动态类型已经确定的对象时,动态绑定就会例行而透明地发生。
2.目标-动作机制
目标是动作消息的接收者。一个控件,或者更为常见的是它的单元,以插座变量(参见”插座变量”部分)的形式保有其动作消息的目标。
动作是控件发送给目标的消息,或者从目标的角度看,它是目标为了响应动作而实现的方法。
程序需要某些机制来进行事件和指令的翻译。这个机制就是目标-动作机制。
3.什么是键-值,键路径是什么
模型的性质是通过一个简单的键(通常是个字符串)来指定的。视图和控制器通过键来查找相应的属性值。在一个给定的实体中,同一个属性的所有值具有相同的数据类型。键-值编码技术用于进行这样的查找—它是一种间接访问对象属性的机制。
键路径是一个由用点作分隔符的键组成的字符串,用于指定一个连接在一起的对象性质序列。第一个键的性质是由先前的性质决定的,接下来每个键的值也是相对于其前面的性质。键路径使您可以以独立于模型实现的方式指定相关对象的性质。通过键路径,您可以指定对象图中的一个任意深度的路径,使其指向相关对象的特定属性。
4.什么时候用delegate,什么时候用Notification?
答:delegate针对one-to-one关系,并且reciever可以返回值给sender,
notification 可以针对one-to-one/many/none,reciever无法返回值给sender.
所以,delegate用于sender希望接受到reciever的某个功能反馈值,notification用于通知多个object某个事件。
5.什么是KVC和KVO?
答:KVC(Key-Value-Coding)内部的实现:一个对象在调用setValue的时候,(1)首先根据方法名找到运行方法的时候所需要的环境参数。(2)他会从自己isa指针结合环境参数,找到具体的方法实现的接口。(3)再直接查找得来的具体的方法实现。
KVO(Key-Value-Observing):当观察者为一个对象的属性进行了注册,被观察对象的isa指针被修改的时候,isa指针就会指向一个中间类,而不是真实的类。所以isa指针其实不需要指向实例对象真实的类。所以我们的程序最好不要依赖于isa指针。在调用类的方法的时候,最好要明确对象实例的类名。
其它回答:
kvc就是key value coding,简而言之就是根据key值改变它的内容,我觉得很类似于dictionary。
kvo就是Key Value Observing,就是相当于你监控特定对象的特定key,当key对应的值发生改变时,会触发它的对应方法。
kvc实现(NSKeyValueCoding Protocol),最简单的方法就是setValue: forKey: 以及valueForKey:方法。例如你实现一个Person类,有两个property name,age,生成一个新对象p,可以用[p setValue:@"Solomon" forKey:@"name"];这样的方法进行赋值。
kvo实现(NSKeyValueObserving Protocol),–addObserver:forKeyPath:options:context:对你想要监控的对象,想要监控的属性添加一个observe,当值改变时,会触发– willChangeValueForKey:等方法。
kvc kvo结合使用,可以当作对对象属性值进行监控的一个notification,它对值进行监控。而notification也同时可以对消息响应之类 做出监控。
简单说KVC就是一个实现并扩展了setter/getter的方法集。
6.Notification和KVO有什么不同?
KVO就是给属性添加一个监控器,当值发生改变的时候,给你一个接口去处理它。textView用过吧,当textView的值改变时,不也有一个textViewDidChange:的delegate方法么?
它就是一个NSObject的protocol,本来就是一个很简单的东西,不要想的很复杂化。这些东西的提出只是为了更方便,而不是它有什么特殊的含义,正如MVC一样。
notification也就是在程序检测event的loop里面加上一个跟踪事件的判断,如果接收到了这个事件,则做自己想要去做的事情。比如一个uiview的对象接收到一个触摸事件,它在系统检测event的无限循环里接收到了它,然后返回一个uitouch的事件让你去处理,从根本上来说它和notification的性质一样的,虽然可能实现方式不尽相同,但是总归是跳不出这个圈子的。
当然,再往底层的东西,怎么去传递notification之类,苹果封装好了,你也不可能知道。就算你是苹果的程序员,由你来实现,也可能有不同的方式来达到同样的目的。而这个已经超出了sdk编程的范围。
IOS面试攻略的更多相关文章
- oc面试攻略
原文出自:http://mobile.51cto.com/iphone-402619.htm 1.Object-C有多继承吗?没有的话用什么代替?cocoa 中所有的类都是NSObject 的子类 多 ...
- iOS图片攻略之:有3x自动生成2x 1x图片
关键字:Xcode插件,生成图片资源 代码类库:其他(Others) GitHub链接:https://github.com/rickytan/RTImageAssets 本项目是一个 Xc ...
- 视频聊天插件:AnyChat使用攻略之iOS开发指南
AnyChat使用攻略之iOS开发指南 这套攻略主要指导刚开始使用AnyChat SDK For iOS的同学,快速搭建SDK环境,和实现音视频开发流程. (需要工程案例文件可联系我们) 在iOS平台 ...
- 寒城攻略:Listo 教你用Swift 语言编写 IOS 平台流媒体播放器
先展示播放器效果: 依然继承 Listo 本人的强迫症,还是从最初到完毕完整的写一个攻略来记录一下,这里声明 Listo 本人也是看了非常多的戴维营攻略才总结分享给大家这一篇攻略的. 首先,Lis ...
- 寒城攻略:Listo 教你用 Swift 写IOS UI 项目计算器
之前总结过 Swift 的语言攻略,这里就不做赘述了,如今做一个实例计算器项目来介绍一下 Swift 的应用.(凝视已经全然.直接上代码) 先看一下效果图: 以下是详细的代码和解释: 分享快乐.开源中 ...
- 从小工到专家 ——读《Java程序员职场全攻略》有感
从小工到专家 ——读<Java程序员职场全攻略>有感 <Java程序员职场全攻略>是以故事的形式,向读者介绍Java程序员的职场经验.作者牛开复在北京从事软件开发,已经是一 ...
- 30天,O2O速成攻略【7.25北京站】
活动概况 时间:2015年7月25日13:30-16:30 地点:车库咖啡(北京市海淀西大街48号鑫鼎宾馆二层) 主办:APICloud.领通科技.快易行 网址:www.apicloud.com 费用 ...
- JAVA EE企业级开发四步走完全攻略 [转]
http://bbs.51cto.com/thread-550558-1.html 本文是J2EE企业级开发四步走完全攻略索引,因内容比较广泛,涉及整个JAVA EE开发相关知识,这是一个长期的计划, ...
- 简单易懂的现代魔法——Play Framework攻略4
接前文:简单易懂的现代魔法——Play Framework攻略3 1.The Object 时隔2个多月,Play Framework系列又更新了,本次的主题是:利用Play Framework实现R ...
随机推荐
- poj 2246 (zoj 1094)
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1094 ZOJ Problem Set - 1094 Matrix Chai ...
- [LeetCode] 310. Minimum Height Trees 解题思路
For a undirected graph with tree characteristics, we can choose any node as the root. The result gra ...
- Maven搭建环境(Linux& Windows)
Linux下安装Maven 1.前提条件: 1)下载并安装好JDK .在终端输入命令“java -version”,如果出现类似如下信息说明JDK安装成功. $ java -version java ...
- linux下ssh使用和配置
常用格式:ssh [-l login_name] [-p port] [user@]hostname 更详细的可以用ssh -h查看. 举例 不指定用户: ssh 192.168.0.11 指定用户: ...
- java:利用数组实现将古诗词纵向输出
java:利用二维数组实现将古诗词纵向输出. 从网络上随便搜索一首古诗词,这里刻意选择句子长短不一的诗词 1.首先先把诗词放进一个二维数组中. 这里将数组类型定义成char 类型,因为将其定义为S ...
- C# 我是个传奇的 using
呵呵呵: ----------------------------------------------------------------------------------------------- ...
- IBinder对象在进程间传递的形式(一)
命题 当service经常被远程调用时,我们经常常使用到aidl来定一个接口供service和client来使用,这个事实上就是使用Binder机制的IPC通信.当client bind servic ...
- JAVA设计模式(09):结构型-代理模式(Proxy)
代理模式是经常使用的结构型设计模式之中的一个,当无法直接訪问某个对象或訪问某个对象存在困难时能够通过一个代理对象来间接訪问,为了保证client使用的透明性,所訪问的真实对象与代理对象须要实现同样的接 ...
- Android AIDL图解
代码来自:http://www.cnblogs.com/mandroid/archive/2011/02/26/1965428.html (XXX.AIDL自动生成的IXXX.java类中 ...
- 在公网(internet)上建立website时不能用http访问
我们在internet的IDC提供的虚拟机上建了新的web site, 域名也从阿里巴巴那里得到二级域名,也经过映射到了虚机的IP, 在本机都可以用域名以Http方式访问,但在internet上的其它 ...