OC入门笔记

1OC概述
OC主要负责UI界面；C语言和C++可以用于图形处理。OC是一门面向对象的语言。C语言是面向过程的。比C++简单很多
以C语言为基础，完全兼容C语言。OC语言中的所有事物都是对象，都有isa指针。
作用：使用OC开发MacOSX平台（开发电脑桌面的一些软件）和IOS平台的应用程序。
数据类型：char、int、float、double、BOOL（yes o）注意：比C语言加多了最后一位。
nil相当于Java中的null，空值的意思
self相当于Java中的this，指向当前对象的意思
基本语句：循环语句（do while、while、for）、条件语句（if、if-else、switch）、goto语句
for循环快速遍历：for（xx in xx）
基类：NSObject
继承：单继承，用super关键字引用父类对象
异常处理：@cry @catch @finally
注释：//和/*....*/
日志输出：NSLog（@"Hello"）;NSLog 会自动换行，比printf好
3第一个OC的类
类：OC中类分为2个文件
.h，类的声明文件，用于声明变量、函数（方法）
.m，类的实现文件，用于实现.h的函数（方法）
类的声明使用关键字@interface、@end
类的实现使用关键字@implementation、@end

例子：
#import <Foundation.h>
//@interface代表声明一个类
//:代表继承，{}表示定义成员变量
@interface Student :NSObject{
int _age;//方法名是age
}
//get方法：
//-代表动态方法（对象方法）   +代表静态方法(类方法)
//这里声明的所有方法都是公共的
-(int)Age;
//set方法：
-(void)setAge：(int)newAge;//一个冒号代表一个参数方法名是setAge：
@end
实现.m：
#import "Student.h"
@implementation Student
-(int)Age{
 NSLog(@"调用了getAge方法")；
 return _age;
}
-(void)setAge:(int)newAge{
 _age=newAge;
NSLog(@"调用了SetAge方法")；
 }
@end
main.m这个文件
#import <Foundation.h>
#import "Student.h"
int main(int argc,const char *argv[])
{
 @autoreleasepool{
 //创建一个student对象：
 //1调用一个静态方法alloc来分配内存调用类这个方法
 //暂时把id当做是任何对象
Student *stu=[[Student alloc] init];
 [stu setAge:100];
 int age=[stu Age];
 NSLog(@"age is %i",age);
 //释放对象
 [Stu release];
 }
 return 0;
}

4点语法
[Stu setAge:100];相当于
stu.age=100;//set方法赋值
int age=[stu Age]也等效于int age=stu.Age //get方法取值
.一个点代表get方法和set方法。

5构造方法和description方法
自己写一个构造方法：在.h文件中,要求成员变量传给我
-(id)initwithAge:(int)age andNo:(int)no;
实现构造方法：
-(id)initwithAge:(int)age andNo:(int)no{//首先要 调用父类super的构造方法
self=[super init];//如果self不为kong
if (self !=nil){
_age=age;
_no=no;
}
return self;
}
@end
注意：%@代表打印一个OC对象
//在.m中：
重写父类的description方法：当使用%@打印一个对象时候会调用这个方法
-(NSString *)description{
NSString *str=[NSString StringwithFormat：@"age is %i and no is %i",_age,_no];
return str;//stringwithformat方法代表调用一个类的静态方法，不需要释放，静态方法创建的对象都是自动释放的。

}@end
(NSString *)str=@"itcast"//代表OC中的字符串
重点:如果使用系统自带的静态方法创建对象的都是自动释放的。

6********类方法+和实例（对象）方法的区别：
@1实例方法是-，类开头是+ 实例方法是用实例对象访问，类方法的对象是类而不是实例，通常创建对象或者工具类。
在实例方法里，根据继承原理发送消息给self和super其实都是发送给self
在类方法里面self是其他的类的类方法，在类方法中给self发送消息只能发类方法self是类super也是
什么时候用类方法，要创建一个实例时候获取一个共享实例，或者获取关于类的一些共有信息
@2类方法(class method)和实例方法(instance method)。类方法被限定在类范围内，不能被类的实例调用（即脱离实例运行）。alloc就是一种类方法。实例方法限定在对象实例的范围内（即实例化之前不能运行）。init就是一种实例方法，被alloc方法返回的对象实例调用。
NSObject *object1=[NSObject alloc]init];
@3OC对类的定义和实现以及初始化:
//声明类接口，继承NSObject对象（该对象是OC中所有类的顶级父类，所有类都继承于它）
@interface ClassName ：NSObject
+（void）function；//类方法，不需要实例化对象就可以调用的方法
- （void）function2 ：（NSString *）arg；//成员方法，必须通过实例化的对象调用
@end

//实现类
@imlementation ClassName
//成员属性初始化和方法的定义
@end

对象的初始化：ClassName *obj = [[ClassName alloc] init]
OC中以消息机制传递信息，发送alloc消息给类分配内存空间，发送init消息生成对象，指针指向对象本身。

类方法的调用:
[obj function]；第一种
NSString *str = [NSString stringWithString:@"hello”];第二种
[obj function2 : str];

OC7-self、自动释放、变量作用域
类：方法的声明和实现，都必须以+或者-开头：+表示类方法（静态方法）调用类名使用；-表示对象（实例）方法（动态方法）
在.h声明的所有方法都是public类型（通过Category可以实现private）
变量的作用域：
@public全局都可以访问
@protected只能在类内部和子类中访问
@private只能在类内部访问
变量必须定义在类的{}中
成员变量默认情况下是@protected，子类可以访问父类的成员变量。
补充：
-(void)test{
 int age=self.age;
}
self在动态方法中是指调用这个方法的当前对象
+(void)test2{
 [student alloc];等效于[self alloc]
}
@end
self在静态代表类名，静态方法通过类名来调用。谁调用方法，self就指向谁。
如果直接把方法写在.m文件中，没有在.h文件中进行声明，那么就是私有方法

OC8-@property和@synthesize
@property让编译器自动生成getter和setter的声明(编译器的特性)
用@property int age；就可以代替下面两行：
-(int)age;//getter
-(void)setAge:(int)newAge;//setter当编译器遇到@property时会自动展开成getter和setter的声明。。。
用@synthesize age=_age；就可以代替下面6行：
-(void)setAge:(int)newAge{
 age=newAge;
}
-(int)age{
 return age;
}
@synthesize让编译器自动生成getter和setter的实现。
注意：@synthesize默认会去访问跟age同名的变量，如果找不到同名的变量会自动生成一个私有的同名变量age
Xcode4.5的环境下，可以省略@synthesize，并且默认会去访问_age这个成员变量，如果找不到_age这个成员变量，会自动生成一个叫做_age私有成员变量。
如果我们在.m文件里面手动实现了setter和getter方法，那么@synthesize就不会生成setter和getter方法，相当于作废；如果我们只是纯粹手动实现了getter方法，那么@synthesize会帮我们生成setter方法的实现，并不会生成getter方法的实现；如果我们只是实现了setter方法，没有实现getter方法，那么@synthesize就不会帮我们实现setter方法，而会帮我们生成标准的getter方法实现；果我们两个都没有实现，那么@synthesize就会帮我们生成标准的setter方法和getter方法。

OC9-内存管理1-retain和release
内存管理范围：任何继承了NSObject的对象都要释放，对基本数据类型无效；
原理：每个对象内部都保存了一个与之相关联的整数，称为引用计数器；
当使用alloc、new或者copy创建一个对象时，对象的引用计数器被设置为1
给对象发送一条retain消息，可以使用计数器+1；
给对象发送一条release消息，可以使用计数器-1；
当一个对象的引用计数器值为0时，那么它将被销毁，其占用的内存被系统回收，OC也会自动向对象发送一条dealloc消息。一般会重写dealloc方法，在这里释放相关资源。一定不要直接调用dealloc方法；
可以给对象发送retainCount消息获得当前的引用计数器值。
注意：其实发送消息就是调用方法的意思。
_(void)dealloc {
 NSLog(@"%@被销毁了"，self)；
}
[super dealloc];
//一定要调用super的dealloc方法，而且最好放在最后面调用
注意点：不要重复释放，会发送野指针错误，也就是说访问了不属于你的内存。
NSLog(@"count:% zi",[stu retainCount]);//z代表无符号
内存管理原则：
1谁创建，谁释放。如果你通过alloc、new或者（mutable）copy来创建一个对象，那么你必须调用release或者autorelease。
2一般来说，除了alloc、new或者copy之外的方法创建的对象都被声明了autorelease
3谁retain，谁release。只有你调用了retain，不管这个对象如何生成的，你都要用release

OC11-@class关键字
用@class+类名可以代替#import "Student.h"
作用：只是声明一个类
注意：如果是继承某个类，就要导入类的头文件；如果只是定义成员变量、属性，用@class
区别：
通常引用一个类有2种办法：一种是通过#import方式引入；一种是通过@class引入。#import方式包含被引用类的所有信息，包括被引用类的方法和变量；@class方式只是告诉编译器在A.h文件中B*b只是类的声明，具体这个类里面有什么信息这里不需要知道，等实现文件中真正要用时，才会真正去查看B类中信息。使用@class方式由于只需要知道被引用类的名称就可以了，而在实现类由于要用到被引用类中的实体变量和方法，所有在.m文件中需要使用#import来包含被引用类的头文件。如果有上百个头文件都#import了同一个文件，或者这些文件一次被#import，那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来讲，使用@class方式就不会出现这种问题了。对于循环依赖关系来说，比如A类引用B类，B类引用A类代码，编译会报错。

OC12-内存管理@property参数详解
@property（retain）//get方法不需要管理内存。这里的retain代表：在set方法中，release旧值，retain新值。
格式：@property(参数1，参数2)类型 名字   参数可有可无，比如：
@property int age；是基本数据就写这样，如果是对象，就写@peoperty （retain）写retain会帮忙管理内存，不写不会管理。
@property(notatomic,retain)面试时候会问：1表示不需要枷锁get方法和set方法，不需要考虑线程安全问题，只要提高性能；2表示不需要内存管理。
参数分为3类：
读写属性：readwrite/readonly
setter处理：assign/retain/copy
原子性：atomic/nonatomic
readonly代表只生成get方法声明和实现；默认是readwrite，同时生成get和set方法的声明；assign：默认基本类型，setter方法直接赋值，而不进行retain操作；retain代表：setter方法release旧值，retain新值；@property默认为atomic，提供多线程安全，保证线程安全，降低性能；copy：setter方法release旧值，再copy新值
nonatomic代表方法不许考虑线程安全问题，禁止多线程，变量保护，提高性能（多用nonatomic）

OC13-内存管理autorelease
autorelease pool自动释放池统一回收对象当自动释放池销毁，池里面的所有对象会调用一次release方法。
@autoreleasepool{
student * stu=[[[student alloc]init]autorelease];//创建一个对象
}
重点：一般可以为类添加一个快速创建对象的静态方法
.h声明：+（id）studentWithAge:(int)age;//快速创建一个对象，意思就是把一个age给我我就快速创建一个student对象
.m实现：
+(id)student{
return [[[student alloc]init]autorelease]；
}
+(id)studentWithage:(int)age{
 student * stu=[[[student alloc]init]autorelease]；
 stu.age=age;
 return  stu;
}

OC14-Category
怎么创建一个分类？
分类只能扩展方法，不能增加成员变量
//()代表一个分类，而()中的内容就是分类名称
注意：类名后面有冒号：代表继承；有括号（）代表分类  比如
@interface student ：NSOject
@interface student （test）
方便团队合作

OC15-Protocol
简单来说就是一系列方法列表，可以声明很多方法，声明方法可以被任何类实现，称为代理模式。
在iOS开发和OS X开发中，apple采用了大量的代理模式来实现MVC中的view和controller的解耦。
怎么实现一个协议？
@protocol 协议名称<NSObject>//<>代表实现某个协议
@end
比如：.h中
@protocol ButtonDelegate<NSObject>
-（void）onclick;
@end
@interface Button：NSobject
//delegate就是按钮的监听器
@property（nonatomic,retain）id <ButtonDelegate> delegate;
@end

.m中
-（void）dealloc{
[_delegate release];
[super dealloc];
}//没有内存泄露

OC16-Block在iOS4.0就开始出现
Block封装了一段代码，可以在任何时候执行；
定义一个Block：int (^Sum) (int,int)=^(inta,intb){
return a+b；
};
int a=sum(10,12);
BSLog(@“%i”,a);
//定义了一个叫sum的block对象，带有两个参数，返回int类型，等式右边就是block的实现
还可以声明一个变量，可以访问局部变量，但是不能修改。
如果外部变量已经用__block关键字进行了声明，就可以在block内部修改这个变量。

18Foundation1-常用结构体—NSRange
包含很多类：NSString，NSarray，NSDictionary等等
NSRange是用来表示范围的。location表示范围的起始位置；length表示该范围所含的元素个数。
创建NSRange结构体变量：直接给成员赋值
NSRange range=NSMakeRange(7,3);最常用
NSString *str = NSStringFromRange(range);
NSLog(@“%@”,str);

NSPoint也是结构体，表示一个点，有x和y。
创建NSPoint结构体变量:
p=CGPointMake(3,4);快速创建，最常用的
NSString *str = NSStringFromPoint(p);
NSLog(@“%@”,str);

NSSize表示用来存储宽度和高度
定义：
NSSize size;
size.width = 100;
size.height = 90;
NSString *str = NSStringFromSize(size);
NSLog(@“%@”,str);

NSRect表示存储位置和尺寸的，已经包含point和size
NSSize rect;
rect.origin.x= 10;
rect.origin.y = 11;
rect.origin.width= 100;
rect.origin.height = 90;
//rect=NSMakeRect(10,11,100,90);//代替上面几行
//rect=CGRectMake(10,11,100,90);
NSString *str = NSStringFromRect(rect);
NSLog(@“%@”,str);

19.NSString的创建
直接赋值：NSString *str1= @“A String”;//不需要管理内存,常量字符串创建
快速创建：NSString *str2 = [[NSString alloc]init];
或者：NSString *str3 = [[NSString alloc]initWithString:@“A string”];
静态方法：
str3 = [NSString stringwithString:@“A string”];不需要管理内存
或者:
//这个是使用C语言的字符串来表示
NSString *str4 = [[NSString alloc]initwithUTF8String:“A string”];
   str4 = [NSString stringwithUTF8String:“A string”];
或者：NSString *str5 = [[NSString alloc]initwithFormat:@“My age is %i and height is %.2f”,str];
str5 = [NSString stringwithFormat:@“My age is %i and height is %.2f”,19，1.55f];

从文件中读取文本
NSString *path = @“/Users/apple/Desktop/test.txt”；//文件路径
NSString *str1=[NSString stringwithContentsOfFile:path];//过期的方法不能解析中文
NSLog(@“%@”,str1);
还可以用其他不过期的方法：
//定义一个NSError的变量
NSError *error;
NSString *str1=[NSString stringwithContentsOfFile:path encoding: NSUTF8stringEncoding error:error];//UTF8表示指定字符串编码（包含中文）
if (error=nil){//没有错误信息
NSLog(@“读取文件成功：%@“，str1);
}
else{

NSLog(@“读取文件失败：%@“，error);
}

20Foundation3-指向指针的指针
void changeStr(NSString **str2){
*str2=@“123”;
}
int main (){
NSString *str=@“456”;
changeStr(&str);
NSLog(@“%@”,str);
}

21Foundation4-NSString的导出
将字符串写入文件
void stringExport(){
NSString *str=@“123456”;
NSString *path=@“/Users/apple/Desktop/test.txt”;
[str writeToFile:path atomically:Yes  encoding:NSUTF8StringEncoding error:&error];
if(error){
//[error locallizeDescription]会返回主要的错误信息
NSLog(@“写入失败：%@”，error);
}else {
NSLog(@“写入成功”);
}
}
//YES代表原子性操作，也就是会创建一个中间的临时文件
//如果文件不存在，会自动创建文件；如果文件夹不存在，会直接报错
//编码指定错误也会报错
int main(){

stringExport();
}

22Foundation5-NSString的常用方法
(1)NSString大小写方法
void caseTest(){
NSString *str=@“GuangDong”;
//转成大写
NSLog(@”大写：%@“，[str uppercaseString]);
//转成小写
NSLog(@”小写：%@“，[str lowercaseString]);
//首字母变大写，其他字母变小写
NSLog(@”首字母变大写，其他字母变小写：%@“，[@”age“ capitalizedString]);}
int main(){
@autoreleasepool{
caseTest();
}
return 0;
}
(2)NSString的比较
（BOOL）isEqualToString：//比较字符串内容是否相同
void compare（）{
BOOL result=[@“abc”isEqualToString:@“Abc”];
NSLog(@“%i”,result);
}
//比较两个字符串的大小
返回值you很多：
BSOrderdAscending 右边字符串比左边大
BSOrderdSame两个字符串内容相同
BSOrderdDecending  左边字符串比右边大
NSComparisonResult result = [@“abc”]compare:[@“Abc”];
if(result == BSOrderdSame){
NSLog(@“两个字符串内容相同”);
}elseif(result ==BSOrderdAscending){
NSLog(@“右边大于左边”);
}elseif(result== BSOrderdDecending ){
NSLog(@“右边小于左边”);}
//忽略大小写比较，返回值与compare一样
NSComparisonResult result=[@“abc”]caseInsensitiveCompare:[@“Abc”];
(3)NSString搜索字符串
void search(){
NSString *str = @“123456.txt”;
//以什么开头
NSLog(@“是否以12开头：%i”，[str hasPrefix:@“12”]);
//以什么结尾
NSLog(@“是否以txt结尾：%i”，[str hasSuffix:@“txt”]);}
//查找对应的字符串的位置location,length
NSRange range = [str rangOfString:@“345”];
//把一个结构体转为字符串打印
if（range.location==NSNotFound）{
NSLog(@“找不到”)；
}else{
NSLog(@“找到的范围是：%@”,NSStringFromRange(range));
}
//从尾部开始搜索字符串
range =[str rangeOfString:@“456” options:NSBackwardsSearch];
NSLog……
//指定范围搜索
NSRange range = [str rangeOfString:”@456” options:NSBackwardsSearch range:@“23456” ];
(4)NSString的截取
//从开头到尾部
substringFromIndex
void subString(){
NSString *str = @“123456”;
//从索引3开截取到尾部
NSLod(@“%@”,[str subsstringFromIndex:3]);
//从头部开始截取到索引3之前
NSLod(@“%@”,[str subsstringToIndex:3]);
//指定范围进行截取
NSRange range = NSMakeRange(2,3);//封装对象范围
NSLod(@“%@”,[str subsstringwithRange:range]);
//切割字符串
NSString *str2 = @“1,2,3,4,5”;
 NSArray *array = [str2 componentsSeparatedBystring:@“,”];
NSLog(@“%@”,array);
}
//从array这个集合取出元素
NSString *str = [array bjectAtIndex:0];
NSLog(@“%@”,str3);
(5)NSString与路径（与文件操作有关）
void pathTest(){
//快速创建一个自动释放的数组
NSMutableArray *components = [NSMutableArray array];
[components addObject:@“Users”];
[components addObject:@“mj”];
[components addObject:@“DeskTop”];
//将数组中的所有字符串拼接成一个路径
NSString *path = [NSString pathwithComponents:components];
NSLog(@“%@”,path);
//将一个路径分解成一个数组
NSArray *cmps = [path pathComponents];
NSLog(@“%@”,cmps);
//是否是绝对路径,依据是前面有无/
path = @“users/mj/test”;//path是一个字符常量。不可变
NSLog(@“%i”,[path isAbsoluutePath]);
//最后一个目录或者文件夹
NSLog(@“最后一个目录:%@”,[path lastPathComponent]);
//删除最后一个目录或者文件夹
NSLog(@“%@”,[path stringByDeletinglastPathComponent]);
//在最后面拼接一个目录
NSLog(@“%@”,[path stringByAppendingPathComponent:@“abc”]);
}
(6)NSString与拓展名
void extension（）{
NSString *str = @“/user/mj/test.txt”;
//获得拓展名
NSLog(@“拓展名：%@”，[str pathExtension]);
//删除尾部拓展名
NSLog(@“%@”，[str stringByDeletingpathExtension]);
//在尾部添加一个拓展名
NSLog(@“%@”，[str stringByAppendingpathExtension:@“mp3”]);
}
(7)
NSString其他用法
void other（）{
NSString *str = @“1”;
//把一个字符串转为int类型
int a = [str intvalue];//intvalue可以是doublevalue,longvalue等等
NSLog(@“%i”,);
//返回字符串长度,在oc中，计算字数，C语言中，一个汉字占据3个字符，计算字符数
NSLog(@“length=%zi”,[@“我是字符串”length]);
//从字符中取出字符
unichar c = [@“abc” characterAtIndex:0];
NSLog(@“%c”,c);
//返回C语言中的字符串
const char *s = [@“abc”UTF8String];
NSLog(@“%s”,s);
}

23Foundation6-NSMutableString
创建可变字符串的方法：
void stringCreate(){
NSMutableString = [[NSString alloc]initwithcapacity:10];容量//预先分配10个字数的存储空间
//设置字符串内容
[str setstring:@“1234”];
//拼接一个字符串
[str appending：@“567”];
//拼接字符串
[str appendFormat:@“age is %i and height is %.2f”,27,1.55f];
//替换字符串
NSRange range = NSMakeRange(7,3);//NSRange range = [str rangeofstring:@“height”];
[str replacecharacterInRange:range  withstring:@“no”];
//插入字符串
[str insertstring:@“abc” atIndex:2];
//删除字符串
range = [str rangeofstring:@“age”];
[str deletecharactersInrange:range];
NSLog(@“%@”,str);
}

24Foundation7-NSArray的创建和遍历
存储一系列的对象有序，不能存储C语言中的基本数据类型,只能装OC对象
（1）创建数组方法：（不需要管理内存）
1NSArray *array = [NSArray array];//创建一个空数组
2array = [NSArry arraywithobject:@“123”];创建有元素的数组
3array = [NSArry arraywithobjects:@“a”,@“b”,@“c”];创建多个元素的数组
unsigned int count =[array count];//查看数组元素的方法//count = array.count;
（2）数组的基本使用查询
void arrayuse（）{

NSArray *array = [NSArraywithobjects:@“a”,@“b”,@“c”，nil];
//判断是否包含某个元素
if（[array contains object:@“a”]）{
NSLog(@“包含了字符串a”);
}
返回最后一个元素
NSString *last = [array lastobject];
//获得index位置对象的元素
NSString *str = [array objectAtIndex:1];
//查找元素的位置
int index = [array indexofobject:@“c”];
//在指定范围查找元素的位置
int index = [array indexofobject:@“c” inRange:@“abc”];
}
(3)数组的内存管理
当把一个对象塞进数组中时，这个对象的计数器会加1，也就是说数组会对它们进行一次retain操作，
数组被销毁时候会对内部所有元素都做一次release操作。
（4）NSArray比较
//比较两个集合内容是否相同
(BOOL)isequaltoarray:(array *)otherarray;
//返回两个集合中第一个相同的对象元素
(id)firstobjectcommonwitharray:(NSArray *)otherarray;
(5)NSArray给元素发送消息，也就是调用方法
//让数组里面的所有对象都调用test方法
[array makeobjectsperformselector:@selector(test)];
(6)NSArray的遍历方法
NSArray *array = [NSArraywithobjects:@“1”,@“2”,@“3”，nil];
int count = array.count;
1遍历for(int i=0,i<count;i++){
id obj=[array objectAtIndex:i];
NSLog(@“%i-%@“，i，obj);
}
2快速遍历
NSArray *array = [NSArraywithobjects:@“1”,@“2”,@“3”，nil];
int i=0；
for (id obj in array){
NSLog(@“%i-%@“，i，obj);
i++；
}
3使用代码块block遍历
NSArray *array = [NSArraywithobjects:@“1”,@“2”,@“3”，nil];
[array enumerateobjectsusingblock:^(id obj,NSUInteger idx,BOO*stop){
NSLog(@“%i-%@“，i，obj);
if（idx==1）{*stop = YES；//遍历停止，利用指针修改BOOL外面的变量
}
}];
4迭代器方式遍历数组
NSEnumerator *enumerator = [array objectEnumerator];
//反序迭代器从尾部开始遍历元素
NSEnumerator *enumerator = [array reverseobjectEnumerator];
//获取下一个需要遍历的元素
id obj =nil;
while (obj=[enumerator nextobject]){
NSLog(@“obj=%@“，obj);
};
//返回这个迭代器的所有元素,allobjects是取出没有被遍历过的对象
NSArray *array = [enumerator allobjects];

25Foundation8-NSArray的排序
1派生出新的数组或者集合
void arraynew(){
NSArray *array = [NSArraywithobjects:@“1”,@“2”,nil];

NSArray *array2= [array arrayByAddingObject:@“3”];
//nil代表结束
NSArray *array3= [array arrayByAddingObjectsFromArray:[NSArray arraywithobjects:@“4”,@“6”,nil];

NSArray *array4 = [NSArraywithobjects:@“1”,@“2”,@“3”，nil];
NSrange range =NSMakerange(1,2);
 NSArray *array5 = [array4 subarraywithrange:range];
}
2其他方法
NSArray *array = [NSArraywithobjects:@“1”,@“2”,@“3”，nil];
//把数组中所有元素链接起来拼接成一个字符串
NSString *str=[array componentsJoinedByString:@“,”];
//将一个数组写入文件(生成一个XML文件)
NSString *path=@“usersappledesktoparray.xml”;
[array writetofile:path atomically:YES];
//从文件中读取数组内容（文件有严格要求）
NSArray *array2=[NSArray arraywithcontentsoffile:path];
3数组排序sort
NSArray *array = [NSArraywithobjects:@“2”,@“3”,@“4”，nil];
//返回一个排好序的数组，原来数组元素顺序不会改变,指定元素比较方法
NSArray *array2=[array sortedArrayusingselector:@selector(compare:)];
//利用block进行排序
NSArray *array3=[array sortedArrayusingcomparator:^NSComparisonResult(student *obj,student *obj){

}

26Foundation9-NSMutableArray
可变的NSArray数组的子类，
初始化：NSMutableArray *array = [NSMutableArray  arraywithobjects:@“a”,@“b”,@“c”，nil];
添加元素：[array addobject:@“2”];
1NSMutableArray *array = [NSMutablrArray array];//创建一个空数组
2NSMutableArray *array = [NSMutableArray arraywithobject:@“123”];创建有元素的数组
3NSMutableArray *array= [NSMutableArray  arraywithobjects:@“a”,@“b”,@“c”];创建多个元素的数组
删除元素：
[array removeobject:@“2”];
删除所有元素：[array removeallobjects:@“2”];
删除index位置的元素:
-(void) removeobjectsAtindex:(NSIndex *)index;
删除index位置的suoyou元素:
-(void) removeobject:(id)anobject;
删除特定元素：
-（void ）removebject:(id)anobject inRange:(NARang)range;
在range范围内查找特定的元素进行删除：
-（void ）removebjectsinarray:（NSArray *）otherarray;
删除同时存在于otherArray和当前集合中的所有元素：
-（void ）removebjectsinrange:(NSRange)range;
替换元素：
[array replaceobjectatindex:1 withobject:@“4”];
NSMutableArray的排序：
[array sortUsingselector:@selector(compare:)];

27Foundation10-NSDictonary
字典的作用：通过唯一的key找到对应的value。不可变
创建字典：
1初始化方法NSDictionary *dict = [NSDictionary dictionary];
NSDictionary *dict = [NSDictionary dictionarywithobject:@“v” forkey:@“k”];一对键值对(最常用)
NSDictionary *dict = [NSDictionary dictionarywithobjectsAndkeys:
@“v1,@“k1”,
@“v2,@“k2”,
@“v3,@“3”,nil];
NSDictionary *dict = [NSDictionary dictionarywithobjects:objects forkeys:keys];
2字典的基本使用
返回字典的key数（多少个键值对）
-（NSInteger）count;
id obj = [dict objectforkey:(@“k2”)];取出某个值
将字典写入文件中：
NSString *path = @“/user/apple/desktop/dict.xml”;
[dict writetofile:path atomically:YES];
从文件中读取内容：
dict = [NSDictionary dictionarywithcontentsoffile:path];
NSLog(@“dict=%@,dict”);
返回所有的key:
NSArray *array = [dict allkeys];
返回object的所有key:
返回所有的value：
NSArray *objects = [dict allvalues];
根据多个key取出对应的多个value:当key找不到对应的value时，用marker参数值代替
objects = [dict objectsforkeys:[NSArray arraywithobjects：@“k1”,@“2”，nil]notfoundmarker:@“not-found”];
遍历字典:
void dictfor(){
NSDictionary *dict = [NSDictionary dictionarywithobjectsandkeys:

@“v1,@“k1”,
@“v2,@“k2”,
@“v3,@“3”,nil
};
遍历字典所有key:
for(id key in dict){
id value = [dict objectforkey:key];
}
in main(){
void dict();
}
2迭代器遍历：
NSEnumerator *enumer = [dict keyEnumerator];
id key = nil;
while(key = [enumer nextobject]){
id value = [dict objectforkey:key];
NSLog(@“%@=%@,key,value”);
//对象迭代器：
//[dict objectEnumerator];
}
3block遍历字典：
[dict enumeratekeysandobjectsusingblock:
^(id key,id obj,BOOL *stop){
NSLog(@“%@=%@,key,obj”);
}];
3字典的内存管理：
一个对象称为字典的key或者Value时，会做一次retian操作，也就是计数器会加1
当字典被销毁时，里面的所有key和value都会做一次release操作，也就是计数器会减1
void dictmemory(){
student *stu1 = [student studentwithname:@“stu1”];
student *stu2 = [student studentwithname:@“stu2”];
student *stu3 = [student studentwithname:@“stu3”];
NSDictionary *dict = [NSDictionary dictionarywithobjectsandkeys:

@“stu1,@“k1”,
@“stu2,@“k2”,
@“stu3,@“k3”,nil
};

28Foundation11-NSMutableDictonary，不存在排序问题
创建和MSDictionary一样。
添加元素：
[dict setobject:stu1 forkey:@“k1”];
当出现莫名其妙的错误，首先先（项目环境）clean，再运行；
不行再：第一个，然后build phases(编译环境.m文件的错误，可能少编译一个了)。
删除所有键值对：
[dict removeallobjects];
添加其他字典到当前字典中：
NSDictionary *other= [NSDictionary dictionarywithobject:@“v2” forkey:@“k2”]；
[dict addentreiesfromdictionary:other];

29Foundation12-NSNumber
NSNumber基本数据类型（仅数字类型）包装成对象，这样就可以间接将基本数据类型存进NSArray，NSdictionary等集合中。
常见的初始化方法：
void number（）{静态方法以类名开头
NSNumber *number = [NSNumber numberwithint:10];
NSMutableArray *array = [NSMutablearray array];
添加数值到数组中
[array addobject:number];
取出来还是一个NSNumber对象，不支持自动解包(不会自动转化为int类型)
NSNumber *number1 = [array lastobject];
将NSNumber转化成int类型
int num = [number1 intvalue];
NSLog(@“num=%i”,num);
}

30Foundation13-NSValue包装结构体
把结构体包装成OC对象。
NSNumber是NSValue的子类，NSValue可以包装任意值，包装结构体后加入NSArray,NSDictionary等集合中
CGPoint point = CGPointMake(10,10);
将结构体变量包装成一个对象
NSValue *value = [NSValue valuewithpoint:point];
添加value
[array add object:value];
取出当时放进去的value
NSVaule *value1 = [array lastobject];
CGPonit point1 = [value1 pointvalue];
看看point和point1是否一样？同一个？
BOOL result = CGPonitEqualtopoint(point1,point);
第二种：
typed struct{
int year；
int month；
int day;
}date;
void value（）{
date = {2014，3，7}；
void *代表一个指针，传结构体的地址&date
char *type =@encode(date) ;根据结构体类型生成对应的描述字符串
NSValue  *value = [NSValue value:&date withobjCType:type];
定义一个结构体变量
date date1;
取出包装的结构体
[value get value:&date1];
}
取出类型描述的字符串
[value objType];

31Foundation14-NSNull
集合中不能存放nil值的，因为nil在集合中有特殊含义，但是有时候需要表达什么都没有就使用NSNull，
也是NSObject的一个子类。
创建和获取：
NSNull *n = [NSNull null];全局只有一个实例就是单例。返回永远只有一个值
NSNull *n1 = [NSNull null];
NSNull *n2 = [NSNull null];

32Foundation15-NSDate
1NSDate的静态初始化：
NSdate *date = [NSdate date];
//now:11:12:40
//date:11:12:50
date = [NSDate datewithTimeIntervalsinceNow:10];
date = []NSDate datewithTimeIntervalSince1970:10;
date = [NSDate distantFuture];返回一个将来的时间，随机的
date = [NSDte distantpast];返回一个比较遥远的过去时间
2NSDate的基本使用
NSdate *date = [NSdate date];
[date timeIntervalSince1970];返回19701月1日开始走过的时间
跟其他时间进行对比
[date timeIntervalSincedate:(NSDate *)];
返回比较早的时间
[date earlierdate:date];
返回比较晚的时间
[date laterdate:date];
3void dateformat(){格式化
NSdate *date = [NSdate date];
//2013-04-07 11：12；35
NSDateformatter *formatter = [[NSDateformatter alloc]init];
formatter.dateformat = @“yyyy-MM-dd HH:mm:ss”;//HH是24进制，hh是12进制
}

33Foundation16-NSObject和反射
NSObject是基类。
 student *stu = [[[student alloc]init]autorelease];
//iskindof判断对象是否属于某个类或者子类
if([stu iskindofclass:[person class]]){
NSLog(@“stu属于Person或者继承自person”);
}；
//ismemberof判断对象是否属于某个类（不包括子类）
BOOL result = [stu ismenberofclass:[student class]];
NSLog(@“%i”,result);
直接调用
[stu test];
间接调用
[stu performselector:@selector(test)];
[stu performselector:@selector(test2:) withobject:@“abc”];必须是OC对象
[stu performselector:@selector(test2:) withobject:@“abc” afterdelay：2];
反射：
void reflect（）{
//类名的反射
NSString *string = @“person”;
class class = NSClassfromstring(str);
person *person = [[class alloc]init;
NSLog(@“%@”,person);
[person release];
//class变成字符串
NSString *name = NSStringfromclass([person class]);
//方法的反射
NSString *method = @“test”;
SEL selector = NSSelectorfromstring(method);
[person performselector:selector];
将SEL转换为字符串
NSString *selectorname = NSStringfromselector(selector);
}

34OC18-copy语法copy和mutablecopy拷贝
一个对象使用copy或者mutable copy方法可以创建对象的副本
copy 需要先实现NSCoppying协议，创建的是不可变副本如NSString,NSArray,NSDictionary
mutblecopy  需要先实现NSMutablecopying协议，创建的是可变的副本，如
NSMutablestring，NSMutableArray,NSMutableDictionary.
深复制：内容拷贝，源对象和副本指向不同的两个对象，源对象引用计数器不变，副本计数器设置为1.
浅复制：指针拷贝（地址），源对象和副本指向的是同一个对象，对象的引用计数器加1，其实相当于做了一次retain操作
只有不可变对象创建不可变副本才是浅复制，其他都是深复制。
void stringmutablecopy（）{深拷贝

NSString *string = [[NSString alloc]initwithformat:@“age is %i”,10];
产生一个新的对象，计数器为1，源对象计数器不变
NSMutablestring *str = [string mutablecopy];

[str appendstring:@“abcd”];

[str release];
[string release];
}

void stringcopy（）{浅拷贝不可变对象调用copy方法
NSString *string = [[NSString alloc]initwithformat:@“age is %i”,10];
没有产生一个新的对象，源对象计数器加1
NSstring *str = [string copy];
[string release];
}

copy的目的：改变副本时候，不会影响到源对象
//copy代表set方法会release旧对象，copy新对象
retain代表set方法会release旧对象，copy新对象内部的成员变量
string用copy策略，其他对象一般用retain。
修改外面的变量，并不会影响到内部的变量。

@property（nonatmic,copy）NSString *name;
演示student的name的copy：
void studentnamecopy(){
student *stu =[[ [student alloc]init]autorelease];
NSMutablestring*string = [NSMutablestring stringwithdormat:@“age is %i”，10];
stu.name = string;
[string appendstring:@”abcd”];
NSLog(@“name=%@”,stu.name);
NSLog(@“string=%@”,string);
}
在main.m文件中
演示student的copy：
void studentcopy(){
student *stu1 =[ [student student withname:@“stu1”];
student *stu2 = [stu1 copy];
[stu2 release];
}

在student.m文件中
+（id）studentwithname:(NSString *)name {
student *stu = [[[student alloc]init]autorelease];
stu.name = name;
return stu;
}
-(void)dealloc{
[_name release];
[super dealloc];
}
copying协议方法：
-（id）copywithzone:(NSZone *)zone{//alloc是分配存储空间的意思
student *copy = [[student allocwithzone:zone]init];
copy.name = self.name;拷贝名字给副本对象

}
@end