307、setValue：forKey和setObject：forKey的区别是什么？

答:
1, setObject：forkey：中value是不能够为nil的，不然会报错。
setValue：forKey：中value能够为nil，但是当value为nil的时候，会自动调用removeObject：forKey方法。
2, setValue：forKey：中key的参数只能够是NSString类型，而setObject：forKey：的可以是任何类型

238.用变量a给出下面的定义

a)一个整型数（An integer）
b)一个指向整型数的指针（A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）
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 that 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

301、在一个数组中存在一万条以上的字符串，现在要对数组中所有字符串进行拼接操作，请写出拼接方法（要考虑到性能及内存占用情况，ARC模式）。

NSString *string = [array componentsJoinedByString:@","];

236.Static全局变量与普通的全局变量有什么区别?static局部变量和普通局部变量有什么区别?static函数与普通函数有什么区别?

答:
static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝。

222.简述浅拷贝和深拷贝

//浅拷贝就比如像引用类型，而深拷贝就比如值类型。
浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。
深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。
C#中有两种类型变量，一种是值类型变量，一种是引用类型变量。对于前者，copy是属于全盘复制；而对于后者，一般的copy只是浅copy，相当于只传递一个引用指针一样。因此对于后者进行真正copy的时候，也是最费事的，具体的说，必须为其实现ICloneable接口中提供的Clone方法。
浅拷贝(影子克隆):只复制对象的基本类型,对象类型,仍属于原来的引用.
深拷贝(深度克隆):不紧复制对象的基本类,同时也复制原对象中的对象.就是说完全是新对象产生的.

189.浅复制和深复制的区别?

答:简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误！

214.简述浅拷贝和深拷贝

答案：
浅层复制：只复制指向对象的指针，而不复制引用对象本身。
深层复制：复制引用对象本身。
意思就是说我有个A对象，复制一份后得到A_copy对象后，对于浅复制来说，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象本身资源
还是只有一份，那如果我们对A_copy执行了修改操作,那么发现A引用的对象同样被修改，这其实违背了我们复制拷贝的一个思想。深复制就好理解了,内存中存在了
两份独立对象本身。
用网上一哥们通俗的话将就是：
浅复制好比你和你的影子，你完蛋，你的影子也完蛋

深复制好比你和你的克隆人，你完蛋，你的克隆人还活着。

168.浅复制和深复制的区别

简单的来说就是，在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误！
我列举一个例子来说吧：
你正在编写C++程序中有时用到，操作符的重载。最能体现深层拷贝与浅层拷贝的，就是‘=’的重载。

208. Write something about the differencesbetween Objective-C and C++.
     写一些关于Objective-C和C++之间的差异

答案:
1、Objective C基本上是在C +
Smalltalk基础上衍生出来的，C++就是C++。除了都是从C语言分化出来的以外，完全没有任何共性。
2、最大的区别就是Objective C的成员函数调用是基于动态绑定的，类本身并没有限制对象可以有什么函数。相对于C++类会规定好成员有什么函数。这使得Objective C的灵活性很大，但是执行效率也很低。
3、在NeXT系统的时代C++和Objective C都不是那么大众的东西，C++也还没完善，而且那个时代编译器的有优化能力也没现在那么变态。所以选择Objective C也不是很奇怪的事。但是现在Objective C的劣势就越来越明显了，所以苹果开发了Swift，而且就内部消息苹果很可能会准备放弃OC。

209. __unsafe_unretained vs__weak; purposeof __block; NSString const * vs NSString *const

unsafe_unretained往往都是用来声明属性的，如果想声明临时变量就得用__strong,__weak,__unsafe_unretained,__autoreleasing;
block闭包就是能够读取其它函数内部变量的函数;
NSString const HSCoder = @"汉斯哈哈哈";
"HSCoder"不能被修改，"HSCoder"能被修改
NSString * const HSCoder = @"汉斯哈哈哈";
"HSCoder"不能被修改，"*HSCoder"能被修改

191.我们说的OC是动态运行时语言是什么意思?

多态。
答:主要是将数据类型的确定由编译时，推迟到了运行时。
这个问题其实浅涉及到两个概念，运行时和多态。
简单来说，运行时机制使我们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。多态：不同对象以自己的方式响应相同的消息的能力叫做多态。
意思就是假设生物类（life）都用有一个相同的方法-eat;那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，但是调用是我们只需调用各自的eat方法。
也就是不同的对象以自己的方式响应了相同的消息（响应了eat这个选择器）。
因此也可以说，运行时机制是多态的基础。

185.obj-c的优缺点

答:
objc优点：
1)Cateogies
2)Posing
3)动态识别
4)指标计算
5)弹性讯息传递
6)不是一个过度复杂的C衍生语言
7)Objective-C与C++可混合编程

缺点:
1)不支援命名空间
2)不支持运算符重载
3）不支持多重继承
4）使用动态运行时类型，所有的方法都是函数调用，所以很多编译时优化方法都用不到。（如内联函数等），性能低劣。

OC没有多重继承，Java也没有,C++才有
OC使用协议来实现多重继承

181.static关键字的作用

答案:
（1）设置变量的存储域，函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
（2）限制变量的作用域，在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
（3）限制函数的作用域，在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
（4）在类中的static成员变量意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；
（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

160.static关键字的作用?

在C语言中，关键字static有三个明显的作用：
1).在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2).在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3).在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

188.类别的作用?

答:类别主要有3个作用：
(1)将类的实现分散到多个不同文件或多个不同框架中。
(2)创建对私有方法的前向引用。
(3)向对象添加非正式协议

167.类别的作用

作用：
1.对系统的类或自己定义的类的扩充（只是指，不能声明属性Instance variable）e.g. base64 MD5.但是不能保证所有的方法都能被调用。尤其是在指定一个与系统的方法相同的方法时一定要注意。
文件名：NSString+additions.h
NSString+additions.m
@interface NSString (Base64)
2.可以声明私有方法。
ZYViewController.m
@interfaceZYViewController (additions)
//{
//BOOL isOK;
//}
-(void)ok;
@property
@end
3.可以声明分散类的方法（NSIndexPath）
分散类体现出类别不仅可以扩充系统的方法，而且可以扩充自己定义的类。
由第3个作用可知：不管是否使用的分散类在任何的.h文件中，我只考虑类别中的方法包裹在@interface className ..@end,那么我只明确将来类别中的方法就属于className这个类。

128. iOS里面是否有GBK的字符编码描述?即NSUTF8StringEncoding如果有,是怎样的?

129. 什么情况下使用关键字weak和assign有何不同?

答:assign指针赋值,不对引用计数操作,使用之后如果没有置为nil,可能就会产生野指针;
而weak一旦不进行使用后,永远不会使用了,就不会产生野指针!

33. 下面说法不正确的是 C

A readwrite 是可读可写特性；需要生成getter方法和setter方法时
B readonly 是只读特性 只会生成getter方法 不会生成setter方法 ;不希望属性在类外改变
C assign 是赋值特性，和weak一样，可用weak代替；
D retain 表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;

18、下面关于#import和#include的描述正确的是

A. #import 是 #include 的替代指令，防止重复引用
B. #import 和 #include 不可以混合使用
C. #import 只用于引用 Objective-C的文件， #include 只用于引用C和C++的文件
D. #import 和 #include 的使用效果完全相同

（A）

7.#import跟#include有什么区别,@class呢?#import<>跟#import””有什么区别?

答:#import是Objective-C导入头文件的关键字，#include是C/C++导入头文件的关键字,使用#import头文件会自动只导入一次，不会重复导入，相当于#include和#pragma once；@class告诉编译器某个类的声明，当执行时，才去查看类的实现文件，可以解决头文件的相互包含；

import<>用来包含系统的头文件，#import””用来包含用户头文件。

8.属性readwrite,readonly,assin,retain,copy,nonatomic各是什么作用,在哪种情况下用?

答:
readwrite是可读可写特性；需要生成getter方法和setter方法时
readonly是只读特性只会生成getter方法不会生成setter方法;不希望属性在类外改变
assign是赋值特性，setter方法将传入参数赋值给实例变量；仅设置变量时；
retain表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;
copy表示拷贝特性，setter方法将传入对象复制一份；需要完全一份新的变量时。
nonatomic非原子操作，决定编译器生成的setter
getter是否是原子操作，atomic表示多线程安全，一般使用nonatomic

199..属性readwrite , readonly , assign , retain , copy , nonatomic ,各是什么作用,在哪种情况下用?

答:
assign用于简单数据类型，如NSInteger,double,bool,
retain和copy用于对象，
readwrite是可读可写特性；需要生成getter方法和setter方法时
readonly是只读特性只会生成getter方法不会生成setter方法;不希望属性在类外改变
assign是赋值特性，setter方法将传入参数赋值给实例变量；仅设置变量时；
retain表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;
copy表示赋值特性，setter方法将传入对象复制一份；需要一份新的变量时。
nonatomic非原子操作，atomic原子性操作。原子性指的是一个操作不可以被中途cpu暂停然后调度,即不能被中断,要不就执行完,要不就不执行，就是为了多线程安全的。
一般使用nonatomic。

70.用预处理指令#define声明一个常数,用以表明一年中有多少秒?(忽略闰年问题)

答:#define second 3652460*60

98.设有以下宏定义:

.#defineN4
.#defineY(n)((N + 1) * n)
则执行语句: Y(5 + 1)为:(26)

*93.C++和Objective-C的混合使用,以下描述错误的是()

//未找到答案或是C++JAVA
A. cpp文件只能使用C/C++代码
B. cpp文件include的头文件中,可以出现objective-C的代码
C. mm文件中混用cpp直接使用即可
D. cpp使用objective-C的关键是使用接口,而不能直接使用代码

94.以下哪一段代码不会抛出异常( C& D )

A. NSArray array = @[1, 2, 3];NSNumbernumber = array[3];// @[@1,@ 2,@ 3]
B. NSDictionary *dict = @{@”key”: nil};//value不能为空
C. NSString *str = nil; NSString *str2 =[str substringFromIndex:3];
D. NSString *str = @”hi”;NSString *str2 =[str substringFromIndex:3];

99.如下程序用于把＂blue＂字符串返回,请指出其中的错误.

//不确定
char GetBlue(){
char pcColor;
charpcNewColor;
pcColor = “blue”;
pcNewColor =(char)malloc(strlen(pcColor));
strcpy(pcNewColor, pcColor);
return pcNewColor;
}
答:strcpy是一个字符串拷贝的函数,它的函数原型为strcpy(char *dst, c*****t char *src);将src开始的一段字符串拷贝到dst开始的内存中去,结束的标志符号为'\0',由于拷贝的长度不是由我们控制的,所以这个字符串拷贝很容易出错

106.请写出一个xml文件,用于描述一个书架,书架上有2本书,书本的类别(category)分别是cooking,children.要求tag中包含书名(title),作者(author).类别(category)要用属性表示.

答:
书名1<\title>
作者1<\author>
<\book>
书名2<\title>
作者2<\author>
<\book>

关键字
107.strcpy和memcpy的最大区别是什么?

答:
1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

109.@class用途

答:@class一般用于头文件中声明某个类的实例变量的时候用到.它只是声明,至于内部的实现是没有告诉编译器的.

110.delegate使用assign or retain简述理由.

答：assign，防止出现循环引用；

111.NSString与NSData之间的转换过程中要特别注意的事项是什么?

解:
NSString转换成NSData对象
NSData *xmlData = [@"testdata"dataUsingEncoding:NSUTF8StringEncoding];

NSData转换成NSString对象
NSData *data;
NSString *result = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

NSData转换成char*
NSData *data;
char *test=[data bytes];

char转换成NSData对象
byte tempData = malloc(sizeof(byte)*16);
NSData *content=[NSData dataWithBytes:tempData length:16];

转换过程中要注意NSData的编码格式问题.

解决方法:
先设置断点然后在控制台po出NSData的变量，看看会显示什么。
如果po出的NSData是可阅读的，直接能看到文本的内容，则使用[NSString stringWithFormat:NSData] (这里的NSData指的是你需要转换成NSString的NSData变量)即可。
如果po出的NSData是不可阅读的乱码，那一般都是有编码格式的，最常用的是NSUTF8StringEncoding，另外还有NSASCIIStringEncoding等，你可以在Apple文档里找到编码格式的那个枚举类型，挨个尝试。

112.请用代码如何判断某个对象obj是否支持某个method.

解:
if ([srespondsToSelector:@selector(print:)]) {
    [s print:@"支持这个方法"];
}

113.请用简单的代码展示@protocol的定义及实现.

解:
#warning代理第一步:声明协议
@protocol MarryMe
-(void)makeMoney;
@end

#warning代理第二步:声明代理
@property(nonatomic,assign)id myDeleget;
.m文件中
#warning代理第三步:代理人执行协议方法
[self.myDeleget makeMoney];
代理人.m文件中
#warning代理第四步:签订协议
@interface Boy : NSObject
Girl *girl = [[Girl alloc] init];
#warning代理第五步:成为代理人
girl.myDeleget = self;
[girl getMessage:message];
#warning协议代理第六步:实现协议方法
-(void)makeMoney{
        NSLog(@"aaa");
}

4.描述下Abstract Class和interface的异同，写出Objective-C Interface的定义语句。

抽象类和接口的异同
抽象类的变体

2.描述下#import和#include的作用，说下它们的区别。

导入文件的可避免重复性问题
.h文件中的变量，外部可以直接访问么？（注意是变量，不是property）
直接访问的话是没法访问到的，可以通过runtime的ivar去获取他的所有变量信息遍历就可以获取到

二叉搜索树的概念，时间复杂度多少？
它获取是一个空树、或者是具有以下性质的二叉树：若他的左子树不空，则左子树上所有节点上的值均小于他根节点的值，若他的右子树不空，则右子树上所有节点的值均大于他根节点的值。
<时间复杂度不知>
.#define和const定义的变量，有什么区别
define:无类型校验、无分配内存、使用的话内存上多次拷贝、预处理的时候展开
const:有类型校验、有分配内存、使用的话内存上一次拷贝、编译运行阶段使用

14、如何浅拷贝与深拷贝的理解？

参考答案：
所谓浅拷贝是指只复制指向对象的指针，而不复制引用对象本身（同一份内存），而所谓深拷贝是指复制引用对象本身（新创建了一份内存）。
打个比方：
浅复制好比是你的影子，当你挂了，影子也消失了。 深复制好比克隆你，即使你挂了，新克隆出来的人是新的生命，不会因为你挂了也跟着挂。

15、使用是懒加载？常见场景？

参考答案：
所谓懒加载是指在真正需要到的时候才真正载入内存。常见的场景就是重写属性的getter方法，在getter方法中判断是否创建过或者加载过，若未创建过或者未加载过，则创建或者加载。
懒加载可以优化性能，有的功能一般情况下不会使用到，但是这些功能一使用就会占较大的内存，此时使用懒加载就非常的好了。
常见的写法：

-(NSMutableArray *)dataSource {
    if (_dataSource == nil) {
        _dataSource = [[NSMutableArray alloc]init];
        // 添加默认数据等
        // ...
    }
}

7、头文件中声明的成员变量（不是属性），外部可直接访问么？

参考答案：
外部不能直接访问头文件所声明的成员变量，需要提供成员变量的getter方法才能在外部访问。
而属性已经直接给我们自动生成了getter方法，因此外部可以直接访问属性。

3、#define定义的宏和const定义的常量有什么区别？

参考答案：
* #define定义宏的指令，程序在预处理阶段将用#define所定义的内容只是进行了替换。因此程序运行时，常量表中并没有用#define所定义的宏，系统并不为它分配内存，而且在编译时不会检查数据类型，出错的概率要大一些。
* const定义的常量，在程序运行时是存放在常量表中，系统会为它分配内存，而且在编译时会进行类型检查。
* #define定义表达式时要注意“边缘效应”，例如如下定义：
#define N 2 + 3 // 我们预想的N值是5，我们这样使用N
int a = N / 2;  // 我们预想的a的值是2.5，可实际上a的值是3.5

322、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？

答:可以。在不适用static或者const(隐式static)情况下,变量的定义只能出现一次，否则会导致重复定义。但却可以声明多次。因此全局变量不可以定义在头文件中。因为当该头文件被多个c文件包含的话，会导致重复定义。因此一般做法是在某个特定的头文件中声明，而在另外一个特定的c文件中定义。需要使用就包含前者。

312、声明NSString类型的属性时，用copy和strong的区别是什么？

copy修饰的NSString,在初始化时,如果来源是NSMutableString的话,会对来源进行一次深拷贝,将来源的内存地址复制一份,这样,两个对象就一点关系就没有了,无论你怎么操作来源,都不会对自己的NSString有任何影响。

314、static全局变量与普通的全局变量有什么区别？static普通函数有什么区别？

全局变量(外部变量)的说明之前再冠以static就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。static函数与普通函数有什么区别？只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在

当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件。

6、用预处理指令#define声明一个常数，用以表明一年中有多少秒（忽略闰年问题）

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
#define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。

7、定义属性时，什么时候用copy，assign和retain

当用copy时，set方法会先release旧值，再copy一个新的对象，reference count 为1（减少了对上下文的依赖）；
当用assign，直接赋值，无retain操作。当用retain，release旧值，retain新值；
1.非ARC
1> copy : 只用于NSString\block
2> retain : 除NSString\block以外的OC对象
3> assign : 基本数据类型、枚举、结构体（非OC对象），当2个对象相互引用，一端用retain，一端用assign

2.ARC
1> copy : 只用于NSString\block
2> strong : 除NSString\block以外的OC对象
3> weak : 当2个对象相互引用，一端用strong，一端用weak
4> assgin : 基本数据类型、枚举、结构体（非OC对象）

NSString、NSArray、NSDictionary 等等经常使用copy关键字，是因为他们有对应的可变类型：NSMutableString、NSMutableArray、NSMutableDictionary；

block 使用 copy 是从 MRC 遗留下来的“传统”,在 MRC 中,方法内部的 block 是在栈区的,使用 copy 可以把它放到堆区.在 ARC 中写不写都行：对于 block 使用 copy 还是 strong 效果是一样的，但写上 copy 也无伤大雅，还能时刻提醒我们：编译器自动对 block 进行了 copy 操作。如果不写 copy ，该类的调用者有可能会忘记或者根本不知道“编译器会自动对 block 进行了 copy 操作”，他们有可能会在调用之前自行拷贝属性值。这种操作多余而低效。
下面做下解释： copy 此特质所表达的所属关系与 strong 类似。然而设置方法并不保留新值，而是将其“拷贝” (copy)。 当属性类型为 NSString 时，经常用此特质来保护其封装性，因为传递给设置方法的新值有可能指向一个 NSMutableString 类的实例。这个类是 NSString 的子类，表示一种可修改其值的字符串，此时若是不拷贝字符串，那么设置完属性之后，字符串的值就可能会在对象不知情的情况下遭人更改。所以，这时就要拷贝一份“不可变” (immutable)的字符串，确保对象中的字符串值不会无意间变动。只要实现属性所用的对象是“可变的” (mutable)，就应该在设置新属性值时拷贝一份。
用@property 声明 NSString、NSArray、NSDictionary 经常使用 copy 关键字，是因为他们有对应的可变类型：NSMutableString、NSMutableArray、NSMutableDictionary，他们之间可能进行赋值操作，为确保对象中的字符串值不会无意间变动，应该在设置新属性值时拷贝一份。

2.属性readwrite、readonly、assign、retain、copy、nonatomic各是什么作用，在哪种情况下用？

1.readwrite：修饰对象可读可写，会生成getter和setter方法
2.readonly：修饰对象仅可读，只生成getter方法
3.assign：修饰基本数据类型（NSInteger，CGFloat）和C数据类型（int, float, double, char）
4.retain：修饰对象类型，指定强引用与strong一样，引用计数+1
5.copy：深拷贝，源对象引用计数不变，副本对象引用计数+1，常用修饰字符串

• copy 与 retain 的区别
  copy: 创建一个新的对象，新的对象引用计数加1，被copy对象的引用计数不变，改变新拷贝的对象时，被拷贝的对象不会发生改变，两者无直接联系
  retain：创建一个指针，对象的引用计数加1，两个指针同时指向同一对象，新旧指针都可以改变对象的值
  retain属性表示两个对象地址相同（建立一个指针，指针拷贝），内容当然相同，这个对象的retain值+1。也就是说，retain 是指针拷贝，copy 是内容拷贝。

6.nonatomic：如果该对象无需考虑多线程的情况，请加入这个属性，这样会让编译器少生成一些互斥加锁代码，不用耗费系统资源，可以提高效率。

• nonatomic和atomic对比
  atomic：线程安全，需要消耗大量的资源
  nonatomic：非线程安全，适合内存小的移动设备

总结
关于nonatomic是线程不安全的，当有多个线程同时修改属性name的值的时候，拿到的结果可能不是自己想要的，因为当属性设置nonatomic的话是允许多个线程是可以同时修改name的值。
简单来说atomic是串行，nonatomic是并行,但如果要真正实现防止多线程修改某属性的值的时候，单单设atomic是不够的，还需要更完善的防止手法

2、引用与指针有什么区别？

答 引用是给变量起一个别名 也就是一个变量有两个名字 他们是同一块空间 指针是分配一块内存用来保存变量的地址 间接引用变量

15、OC中加号方法与减号的区别？

答 加号方法是类方法 可以用类名来调用 减号方法是实例方法 必须由类的实例来调用

16、如何修饰私有变量？

答 在OC中默认变量属性都是有私有的 我们可以property关键字来修饰 以便可以不同过接口直接访问

17、建一个工程用到最基本的两个框架是什么？

答 cocoa Touch框架 Function框架

22、self.name = "object" name = "object"的区别

答: self.name 需要要合成属性然后系统会默认生成set get方法 所以在赋值是会调用set方法，name = "object"则直接赋值

10.对于语句NSString *obj = [[NSData alloc] init]; obj在编译时和运行时分别是什么类型的对象?

答:编译时是NSString的类型；运行时是NSData类型的对象

1、引用与指针有什么区别？

引用就是给变量起一个别名，在使用的时候，直接用别名调用就可以了，引用最好初始化，因为引用为空，对象都不存在就更别提别名了，引用的内容一般也是固定的，所以相对来说比较安全。

指针想要使用变量的时候，是一种间接引用，一般要通过&或者*来达到效果。指针可以为空指针，因为只是指向空地址而已，可以任意改变，只要改指其他内存地址就可以了。

指针和引用的联系与区别

★ 相同点：

1. 都是地址的概念；
   指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。

★ 区别：

1. 指针是一个实体，而引用仅是个别名；
2. 引用使用时无需解引用(*)，指针需要解引用；
3. 引用只能在定义时被初始化一次，之后不可变；指针可变；
4. 引用没有 const，指针有 const；
5. 引用不能为空，指针可以为空；
6. “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小；
7. 指针和引用的自增(++)运算意义不一样；
   8.从内存分配上看：程序为指针变量分配内存区域，而引用不需要分配内存区域。

参考答案：
(1)当引用被创建时，它必须被初始化。而指针则可以在任何时候被初始化。
(2)一旦一个引用被初始化为指向一个对象，它就不能被改变为对另一个对象的引用。而指针则可以在任何时候指向另一个对象。
(3)不可能有NULL引用。必须确保引用是和一块合法的存储单元关联。

进一步解析：
指针和引用都是C++中的基本语法成份，它们既有联系，也有不同之处。
它们都是地址的概念，其中指针指向一块内存，它的内容是所指内存的地址；而引用是某块内存的别名，具体来说，指针是一个变量的地址，引用是一个变量的别名。

但它们的不同之处也很明显，体现在以下方面：
指针是一个实体，而引用仅是个别名；
引用必须被初始化，指针不必；
引用只能在定义时被初始化一次，之后不可变；指针可以改变所指的对象；
可以有const指针，但是没有const引用；
不存在指向空值的引用，但是存在指向空值的指针，即引用不能为空，指针可以为空；
“sizeof 引用”得到的是所指向的变量（对象）的大小，而“sizeof 指针”得到的是指针本身（所指向的变量或对象的地址）的大小；
指针和引用的自增（++）运算意义不一样；
程序为指针变量分配内存区域，而引用不需要分配内存区域；
指针可以有多级，但是引用只能是一级，例如int **p是合法的，而 int &&a是不合法的；
指针和引用作为函数参数进行传递时也不同。用指针传递参数，可以实现对实参进行改变的目的；在将引用作为函数参数进行传递时，实质上传递的是实参本身，而不是实参的一个拷贝，因此对形参的修改其实是对实参的修改。

2、简述struct和class的区别。

首先，讨论这个问题应该仅从语法上讨论，如果讨论不同人之间编程风格上的差异，那这个问题是没有答案的。毕竟不同的人偏好不同。

从语法上，在C++中（只讨论C++中）。class和struct做类型定义时只有两点区别：
（一）默认继承权限。如果不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理；
（二）成员的默认访问权限。class的成员默认是private权限，struct默认是public权限。
除了这两点，class和struct基本就是一个东西。语法上没有任何其它区别。

不能因为学过C就总觉得连C++中struct和class都区别很大，下面列举的说明可能比较无聊，因为struct和class本来就是基本一样的东西，无需多说。但这些说明可能有助于澄清一些常见的关于struct和class的错误认识：
（1）都可以有成员函数；包括各类构造函数，析构函数，重载的运算符，友元类，友元结构，友元函数，虚函数，纯虚函数，静态函数；
（2）都可以有一大堆public/private/protected修饰符在里边；
（3）虽然这种风格不再被提倡，但语法上二者都可以使用大括号的方式初始化：Aa={1,2,3};不管A是个struct还是个class，前提是这个类/结构足够简单，比如所有的成员都是public的，所有的成员都是简单类型，没有显式声明的构造函数。
（4）都可以进行复杂的继承甚至多重继承，一个struct可以继承自一个class，反之亦可；一个struct可以同时继承5个class和5个struct，虽然这样做不太好。
（5）如果说class的设计需要注意OO的原则和风格，那么没任何理由说设计struct就不需要注意。
（6）再次说明，以上所有说法都是指在C++语言中，至于在C里的情况，C里是根本没有“class”，而C的struct从根本上也只是个包装数据的语法机制。
最后，作为语言的两个关键字，除去定义类型时有上述区别之外，另外还有一点点：“class”这个关键字还用于定义模板参数，就像“typename”。但关键字“struct”不用于定义模板参数。

26、私有属性和私有方法

/*
 1.写一个私有属性
    不能被外界访问的,并且在外面也不会有提示，做到真正的私有。
 
   在@interface大括号里面就不要写声明，而是在implementation里面加上大括号，在大括号里面写属性的声明。
 
    那么这个属性就是真正的私有，就只能在本类中访问， 外面不能访问，并且连提示都不会有。
 
    此时这个属性，用任何访问修饰符修饰，都是不起作用的，默认这个属性就是私有的。
 
 2.如果我们写一个方法，只想让他在本类中调用，而不能在外面调用。
   那么这个方法就不要写声明，直接写实现。
 
 3.私有属性和私有方法，都是可以继承给子类的。只不过子类里面是不能访问从父类继承过来的的私有属性和私有方法的。
 */

/*
 1.方法的重写
 
   如果子类的从父类继承过来的方法，他的实现和父类不同，他有自己的实现，那么这个从父类继承过来的方法，就要重写。
 
 2.重写的语法：
 
    就是在子类中，重新的实现一下这个从父类继承过来需要被重写的方法。
 */

22、浅复制和深复制的区别？

浅复制和深复制的区别：浅拷贝只是增加了一个指针指向已经存在的内存，两个指针指向同一快内存，就相当于本来一个人有自己的名字A，然后那，又给他取了个名字B，但是你在叫A、B的时候，都是同一个人来答复；而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，就相当于本来一个人有自己的名字A，然后那，他有一个孪生兄弟名字叫做B，所以你叫A、B的时候是不同的人答复。

针对指针型对象的拷贝，有浅复制和深复制两种。
浅复制：将原始对象的指针值复制到副本中，即指针拷贝，原始对象和副本共享引用的数据；相当于创建了一个文件的快捷方式。
深复制：复制原始对象指针所引用的数据，并将其赋给副本对象，即内容拷贝，相当于创建了一份新的文件。
例如，当我们为一个类的属性添加copy关键字时，那么对这个属性赋值时（即：调用setter方法），就会执行深拷贝操作。当我们把属性关键字改为strong或者weak时，那么对这个属性赋值时，就会执行浅拷贝（只拷贝指针地址）。
NSString *string = @"test";NSString *string1 = [string copy];NSString *string2 = [string mutableCopy];

copy->复制指针（创建一个指针指向原始的内存地址）
mutableCopy->复制指针及内容（创建新的内存地址）
string:[0x100001058]test
string1:[0x100001058]test
string2:[0x100201600]test

23、类别的作用？继承和类别在实现中有何区别？

category 可以在不获悉，不改变原来代码的情况下往里面添加新的方法，只能添加，不能删除修改。// category:类、种类
并且如果类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，因为类别具有更高的优先级。//类别跟类的优先级
类别主要有3个作用：
(1)将类的实现分散到多个不同文件或多个不同框架中。
(2)创建对私有方法的前向引用。
(3)向对象添加非正式协议。
继承可以增加，修改或者删除方法，并且可以增加属性。//非正式协议:是使用类别category来实现，非正式协议是NSObject的一个类别，这样任何类的对象都可以作为委托对象来使用，它可以列出对象能够执行的所有方法，这样用来实现委托， 我们可以使用选择器来判断该非正式协议中是否有这个方法。正式协议:是一个命名的方法列表，与非正式协议相比不同的是，它要求显示的采用协议，采用协议的方法是在类的＠ｉｎｔｅｒｆａｃｅ声明中列出协议的名称，此时，实现协议的类应该遵守协议，承诺实现协议中的所有方法。

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 吗？解释为什么。

4.如何让自己的类用 copy 修饰符？如何重写带 copy 关键字的 setter

若想令自己所写的对象具有拷贝功能，则需实现 NSCopying 协议。如果自定义的对象分为可变版本与不可变版本，那么就要同时实现 NSCopying 与 NSMutableCopying 协议。

具体步骤：
1.需声明该类遵从 NSCopying 协议
2.实现 NSCopying 协议。该协议只有一个方法:
-(id)copyWithZone:(NSZone *)zone;
注意：一提到让自己的类用 copy 修饰符，我们总是想覆写copy方法，其实真正需要实现的却是 “copyWithZone” 方法。

14.建一个工程用到最基本的两个框架是什么？

Foundation和UIKit框架

i++和++i的区别

如果有表达式 a = i++ 它等价于 a = i ; i = i + 1;
如果有表达式 a = ++i 它等价于 i = i + 1; a = i;
两者的区别是：

• i++：是先赋值，然后再自增；
• ++i是先自增，后赋值

&和&&的区别

一、简要说明
按位与：a&b是把a和b都转换成二进制数然后再进行与的运算；
逻辑与：a&&b就是当且仅当两个操作数均为 true时，其结果才为 true；只要有一个为零，a&&b就为零。
例如：
a&b 9&8
1001
1000
结果是1000
a&&b 9&&8 结果是1
&对每一个都判断；
&&只要前面是false就输出false，而不继续判断后面了

二、详细解释
有关&和&&的详细解释如下：
&，双目运算符：将两个表达式的值按二进制位展开，对应的位(bit)按值进行“与”运算，结果保留在该位上…
比如170&204
对应二进制就是
10101010B
&11001100B
=10001000B…
170&204=136…
该位只要有一个值为0结果为0，否则结果为1。
如果两数位数不同，则较短数高位补零，再运算，比如char a=100;int b=260;
a&b实际是0000 0000 0110 0100&0000 0001 0000 0100.其结果为int型0000 0000 000 0100即4…
&&:双目运算符，计算两个表达式同时成立的“真值”（同时成立真值为真否则为假）
逻辑真值有两种，1为真，0为假，但在运算时用非零表示真，0表示假…
即：数值->逻辑真值－－非0为真，0为假/逻辑真值->数值－－真为1，假为0…
例如：char a=1,b=0,c=-1;那么a真b假c真。a&&b和c&&b为假值为0，a&&c为真值为1

3.OC中加好方法和减号方法的区别

＋的方法，其实就是类方法了，通过类名调用。
－的话，实咧方法，类的实列(对象)才可以调用的。

4.类别的作用，继承与类别在实现中有何区别

类别歧视就是情况下往里面添加新的方法，只能添加，不能删除修改，继承可以增加，修改或者删除方法，并且可以增加属性。

1、Object－c的类可以多重继承么？可以实现多个接口么？Category是什么？重写一个类的方式用继承好还是分类好？为什么？

Object-c的类不可以多重继承；可以实现多个接口，通过实现多个接口可以完成C++的多重继承；Category是类别，一般情况用分类好，用Category去重写类的方法，仅对本Category有效，不会影响到其他类与原有类的关系。

2、#import 跟#include 又什么区别，@class呢, ＃import<> 跟 #import”"又什么区别？

.#import是Objective-C导入头文件的关键字，#include是C/C++导入头文件的关键字，使用#import头文件会自动只导入一次，不会重复导入，相当于#include和#pragma once；
@class告诉编译器某个类的声明，当执行时，才去查看类的实现文件，可以解决头文件的相互包含；
.#import<>用来包含系统的头文件，#import””用来包含用户头文件。

3、属性readwrite，readonly，assign，retain，copy，nonatomic 各是什么作用，在那种情况下用？

readwrite 是可读可写特性；需要生成getter方法和setter方法时
readonly 是只读特性 只会生成getter方法 不会生成setter方法 ;不希望属性在类外改变
assign 是赋值特性，setter方法将传入参数赋值给实例变量；仅设置变量时；
retain 表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;
copy 表示拷贝特性，setter方法将传入对象复制一份；需要完全一份新的变量时。
nonatomic 非原子操作，决定编译器生成的setter getter是否是原子操作，
atomic表示多线程安全，一般使用nonatomic

4.写一个setter方法用于完成@property （nonatomic,retain）NSString *name,写一个setter方法用于完成@property（nonatomic，copy）NSString *name

[cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
- (void)setName:(NSString *) str  
{  
    [str retain];  
    [name release];  
    name = str;  
}  
- (void)setName:(NSString *)str  
{  
    id t = [str copy];  
    [name release];  
    name = t;  
} 

22、浅拷贝和深拷贝区别？

在有指针的情况下，浅拷贝只是增加了一个指针指向已经存在的内存，而深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存，采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错 误。

6、当A类中的某个方法执行到某处时，这时想在B类中执行某个方法，如何做？举出一个方法说明。

答：可以用委托方法来实现，在A类中初始化一个成员让他指向B类就可以调用B的方法了。

7、int retVal = UIApplicationMain(argh,argue,nil,nil)；是什么意思？

对UIApplication对象进行了初始化，这个方法除了argc 和 argv 参数外，另外这个函数还有2个两个字符串参数来识别UIApplication类和UIApplication代理类，在这里默认是2个nil,第一个参数为nil就默认把UIApplication类作为缺省值进行初始化，可以在这里不填nil而是使用自己定义的UIApplication子类。至于第二个参数nil就设置为nil就把模板生成的HelloWorldAppdelegate类作为默认值。

4、建一个工程用到最基本的两个框架是什么？

cocoa Touch框架 Function框架

2 引用与指针有什么区别？

答：
引用是给变量起一个别名，也就是一个变量有两个名字，他们是同一块空间。
指针是分配一块内存用来保存变量的地址，间接引用变量。

1、请说明一下在objective_c里定义属性copy与assign的区别

assign：指定setter方法用简单的赋值，这是默认操作。你可以对标量类型（如int）使用这个属性。你可以想象一个float，它不是一个对象，所以它不能retain、copy。
assign: 简单赋值，不更改索引计数(Reference Counting).使用assign: 对基础数据类型 （NSInteger）和C数据类型（int, float, double, char,等）
copy：指定应该使用对象的副本（深度复制），前一个值发送一条release消息。基本上像retain，但是没有增加引用计数，是分配一块新的内存来放置它。copy是创建一个新对象，retain是创建一个指针，引用对象计数加1。
copy： 建立一个索引计数为1的对象，然后释放旧对象，copy是创建一个新对象，retain是创建一个指针，引用对象计数加1。
retain：指定retain应该在后面的对象上调用，前一个值发送一条release消息。你可以想象一个NSString实例，它是一个对象，而且你可能想要retain它。
retain：释放旧的对象，将旧对象的值赋予输入对象，再提高输入对象的索引计数为1 ，使用retain： 对其他NSObject和其子类 ，retain，是说明该属性在赋值的时候，先release之前的值，然后再赋新值给属性，引用再加1。
readonly：将只生成getter方法而不生成setter方法（getter方法没有get前缀）。
readwrite：默认属性，将生成不带额外参数的getter和setter方法（setter方法只有一个参数）。
atomic：对于对象的默认属性，就是setter/getter生成的方法是一个原子操作。如果有多个线程同时调用setter的话，不会出现某一个线程执行setter全部语句之前，另一个线程开始执行setter的情况，相关于方法头尾加了锁一样。
nonatomic：不保证setter/getter的原子性，多线程情况下数据可能会有问题。nonatomic，非原子性访问，不加同步，多线程并发访问会提高性能。先释放原先变量，再将新变量 retain然后赋值；
注意，如果不加此属性，则默认是两个访问方法都为原子型事务访问。

2、什么时候使用NSMutableArray，什么时候使用NSArray？

NSArray是静态的数组，就是它所指向的内容是不可改变的，它指向一段内存区域，一旦初始化，不能通过它对该内存区域的数据进行修改操作，但是它可以读数据。
NSMutableArray是动态的是NSArray的子类，可以对所指向的内存区域内容进行更改，并可以增加数组内容
NSArray和NSmutableArray的第一个数据的下标为0。