iOS Objective-C（2014-1-6 20:30、20140114，20140824，20150926、20160106、20160110、20160123）

http://wenku.baidu.com/link?url=7bhWUohjJF6Z7TaV1o8-Ojq3K-H5PgifU9arequRJYM5ynm8gsBAKBiCwbwV3BcdQA47Lsw1dbeI9VI-ifvfwRJKu3gq3DKUJv7HYap23xS
Mac OS X系统培训
Mac OS的内核
Unix
Mac OS X的版本
10.0猎豹
10.1美洲狮
10.3黑豹
10.4老虎
10.5花豹
Mac OS X的键盘
一共有109键
Finder类似于Windows的资源管理器

http://www.docin.com/p-528200772.html
苹果电脑操作系统入门.ppt

丁群：人人都能弹吉他
Xcode5
根据重力感应自动翻转

软酷网
iOS开发环境要求
硬件环境要求
笔记本选择 最佳MacBook Pro，也可以选择MacBook Air
笔记本参数：
CPU i5或者i7
内存 8G
——模拟器在调试时比较占资源
显示器尺寸随意
调试手机iPhone 5及以上版本
——用于真机调试
软件环境要求
操作系统：OS X 10.9.3及以上版本
开发工具：Xcode 6.0及以上版本
——Swift
黑苹果系统开发iOS行不行？
可以，但是OS X安装在兼容机上过程麻烦。不推荐。
黑苹果系统安装教程
http://v.ku6.com/show/S5suv32ygvk2ymaiQHJ30g...html?from=my
苹果开发者账号是否必须？
年费人民币688元。用于真机调试、证书签名、上传App到AppStore上。但对于iOS开发没有影响，在学习iOS研发的过程中不需要购买。

张凌华Sundy
欧阳坚AngryBirds
Cocos2d-android-1使用Java语言
Cocos2d-android是另一个项目，更新太慢。
触屏事件
有的层需要接受点击，有的层不需要接受点击
Android：以左上角为坐标原点的坐标p1
Cocos2d：以左下角为坐标原点的坐标p2
setIsTouchEnable(true);
回调函数主要有3个：
开始触摸屏幕时、离开屏幕时、在屏幕上移动时
MotionEvent对象以屏幕左上角为原点
X坐标是一样的，Y坐标是不一样的
p2=convertToGL(p1);

6.3程序设计原则与App生命周期
iPhone平台的开发者大都采用一种MVC的设计泛型作为制作的原则。
所谓MVC是指一款应用被分为了3部分：模型、视图、控制。
模型：其全称为数据模型，用于保存应用程序中所使用的数据。这些数据与应用产品的业务逻辑相关，它们并不依赖于视图和控制器。
视图：主要指用户可以直观看到并产生交互的视窗、界面和控件。
控制：此部分的主要作用是连接视图与数据模型。
开发者习惯把执行第一行代码的地方称为应用程序的“入口”。
委托是负责为另一个对象处理特定事件的类。委托被广泛地应用在Cocoa框架当中。发布委托的对象持有其他对象（委托）的引用。在适当的时候，它会向委托发送消息。消息用于通知委托对象发布委托的对象将要处理或者已经处理某个事件。作为响应，委托对象会更新外观或者更新自身或应用程序其他对象的状态。
6.4用户界面设计：视图和控件
iPhone应用程序通常只有一个窗口（UIWindow）,表示为一个UIWindow类的实例。
应用程序在启动时创建这个窗口（或者从.nib文件进行装载），并往窗口中加入一个或多个视图，然后将它显示出来。
屏幕矩形可以通过UIScreen对象来取得。
窗口作为容器使用，它是显示层次中最基础的根部。
UIView定义了视图的基本行为,但并不定义其视觉表示。
6.5用户交互：轻击、触摸、手势
类TouchView是UIView的子类。
[self setMultipleTouchEnabled:YES]用来设置当前View窗口是否支持多点触碰的，其默认值为不支持。
touchesBegan方法初始获得用户触碰的位置。
touchesEnded方法作为用户触碰操作的结束。
touchesCancelled方法是当用户的触碰操作因为意外时间而被打断时调用的方法，开发者习惯在此方法内释放资源。
touchesMoved方法是在用户触碰屏幕后，进行滑动行为时调用的方法。
这4个方法传递的参数均为NSSet对象指针和UIEvent对象指针。
NSSet对象指针中包含了触碰点的数目及次数。UIEvent包含了触碰事件本身的属性，比如响应此次触碰事件的界面或者窗口。

chap9 Cocos2D引擎使用指南
0.99.0版本要求苹果的iOS 3.0以上,需要运行在Mac OS-10.5.7版本上。
1.x版本的Cocos2D引擎，稳定版本1.0.1
需要的软硬件环境：
基于英特尔CPU的苹果电脑，至少1GB内存。
Mac OS X 10.6（Snow Leopard）或者更高版本。
任何一台iOS设备。
已经安装了Xcode3.2以上版本。
已经安装了iOS SDK 3.2以上版本。
2.0版本不再兼容旧的系统，只有iPhone 3GS及其以后版本才支持，开发环境也仅仅支持Xcode 4.0之后的版本。在2.0版本中应用了OpenGL ES 2.0，渲染器将直接使用Shader操作GPU进行绘制。
install-templates.sh是Mac平台的命令文件，用来安装Cocos2D引擎在Xcode开发工具中的项目模板。
 
10.5.2 Cocos2D引擎当中的粒子系统
CCParticleSystem类是粒子系统的主要类，它继承自CCNode类，同时实现了CCTextureProtocol纹理协议。
粒子系统类的对象可以被添加到引擎的画面层次当中，并且其必然会包含一张纹理图片用于显示。
CCParticleSystem类所派生的子类CCParticleSystemQuad类适用性要好些。
此类中的粒子属性支持浮点类型。
粒子支持旋转的功能。
在iOS第一代、第二代设备当中，它比CCParticleSystem的效率略慢一点。
在iOS第三代设备当中，它的效率远远超过了CCParticleSystem。
此类的对象将会使用更少的内存和显示内存。

iOS开发电子书籍清单：
1、
Become An Xcoder
Xcode开发员入门导引
2006年8月翻译
2、
iOS 5 Programming Cookbook
2012年5月翻译
3、
iOS从入门到精通
一步一步学习iOS 5编程
4、
苹果iOS 6开发从入门到实战
睿峰科技 编
2013年6月出版
内容简介
本书主要由四部分组成：C语言基础、Objective-C语言、Cocoa框架、高级应用。
iOS概述
2012年6月，苹果公司在WWDC2012上宣布了iOS 6。
2013年1月29日，苹果推出了iOS 6.1正式版的更新。
5、
疯狂iOS讲义(下)——iPhone iPad高级应用与手游开发
李刚 肖文吉 编著
2014年3月出版
内容简介
本书以iOS7.0、Xcode5.0为平台，全面介绍了iOS应用开发的高级知识。
读者在阅读本书之前，建议先掌握《疯狂iOS讲义》上册中的知识。

OS X/iOS/Xcode/Unity/Cocos2d-x版本对应关系
iPhone4
iPhone5
iPhone6
OS X|iOS版本更新|Xcode发售日期
||1.0: 2003年
||2.0: 2005年4月29日
||3.0: 2007年10月26日
Mountain Lion 10.8.0 12A269 2012年7月25日，10.8.3 12D78 2013年3月14日|2011年10月13日 5.0 正式版，2012年3月8日 5.1 正式版，2012年9月20日 6.0正式版，2013年1月30日6.1正式版|4.0: 2011年3月9日 4.6：2013年1月30日 4.6.3：2013年6月14日|Unity4.3.0
Mavericks 10.9.0 13A603 2013年10月22日，10.9.4 13E28 2014年6月30日|2013年9月18日 7.0正式版，2014年3月11日 7.1正式版|5.0: 2013年9月18日 5.0.2：2013年11月11日 5.1：2014年3月11日|
Yosemite 10.10.0 14A389 2014年10月17日，10.10.3 2015年4月9日|2014年9月17日 8.0正式版，2014年10月20日 8.1正式版，2015年4月9日 8.3正式版|6.2：2015年3月10日，6.3：2015年4月9日
OS X v10.11 (El Capitan)||

基于Unity3D的一款iOS游戏的设计与实现
http://www.docin.com/p-1280499104.html
摘要：本文所述的“忍者酷跑”就是一款动作类休闲手机游戏。
项目基于iOS平台，主要采用Unity3D引擎进行开发。对于引擎未能集成的部分功能，则通过iOS平台自身的框架和第三方接口来实现。
1.3论文的主要工作内容
本论文涉及的项目是一款休闲动作类iOS的手机跑酷游戏，在Mac系统上进行开发，开发工具主要采用Unity3D引擎和Xcode。
2.1 iOS游戏开发引擎的比较和选择
2.1.1 Cocos2D
一个基于MIT的开源框架，诞生于2008年，最核心的成员包括Cocos2D-iPhone和Cocos2D-X。
2.1.2 Unity3D
一款商业引擎，一开始只针对Mac平台。
2.2.3基于Unity3D的iOS开发
Unity生成的是相应的Xcode项目工程，而非最终的运行文件。
Unity生成的Xcode工程结构图
Classes文件夹是该工程的核心部分，其主要内容是包含了Unity运行时和Objective-C的代码。应用程序的入口点在main.mm和UnityAppController.mm两个文件中指定。
用户可以从UnityAppController派生创建自己的AppDelegate。
Data文件夹包含游戏资源文件和dll文件等。这个文件夹的内容通常不应在Xcode中改动。
Libraries文件夹包含的是.NET的ARM汇编文件等。其他文件和目录的含义比较清晰，此处不复赘述。
2.3开发语言环境
2.3.1 JavaScript
本项目的客户端主要采用JavaScript来实现，脚本编辑环境和调试环境为Unity3D自带的MonoDevelop。
2.3.2 Objective-C
Objective-C唯一的用途就是为苹果公司的设备进行编程。Objective-C 2.0版本以后，垃圾回收作为iOS编程的重要特性被加入进来。
本项目中，使用Objective-C开发Unity3D未集成的部分iOS功能，如社交分享、图片压缩处理、内购和广告等。具体开发环境为Xcode5.0，操作系统是运行在Vmware上的Mac OS X 10.8.5。
【10.8.3 12D78 2013年3月14日
10.9.0 13A603 2013年10月22日】
2.3.3 Python
本项目中，使用Python进行服务器端的消息推送和HTTP文件下载服务开发，开发使用的是Python2.7自带的集成开发环境IDLE。
3.4.2客户端各模块的设计
（1）用户输入和主角的控制
（2）元素随机生成模块
（3）物理碰撞检测模块
（4）游戏主体控制模块
（5）UI界面模块
（6）社交分享和排名模块
（7）广告和内购模块
总的说来，模块（6）（7）基本上都可以算是引擎外的插件模块。
4.1开发环境的选择
引擎所处的操作系统是Windows 7 64位版。
封装采用C#语言作为桥梁。引擎脚本层支持JavaScript和C#语言之间的互相调用。
Xcode的版本是5.0，能很好的支持iOS7的特性。
【5.0：2013年9月18日，7.0正式版：2013年9月18日】
4.2.5游戏内购模块实现
（1）基于StoreKit框架的金币内购
（2）基于AssetBundle的资源兑换下载

基于Unity3D游戏引擎的休闲类手游设计与实现
http://www.docin.com/p-1400447664.html
2.4 iOS平台简介
界面构建器Interface Builder：开发人员可以通过拖拽方式方便地设置程序窗口，如果想修改他们的属性，可以利用查看器修改并保存为nib文件，nib文件是一种资源文件格式。
Instruments：可以帮助开发人员分析应用程序的性能表现。在程序运行过程中，Instruments可以获取关于程序内存占用量、CPU占用率及网络活动等数据，并将这些数据以图形形式展现出来。
3.2.3 APP内购系统
内购(IN-App Purchase)和广告是目前越来越多的游戏采用的盈利模式，这种模式只需要下载一个版本用户就可以体验全部游戏，开发者利益也会得到保障。
内购是玩家在游戏过程中，通过自己的账号以真实货币购买游戏内的金币、道具、解锁关卡、角色的行为。
3.4性能需求
目前游戏只能在iOS 5.0.1系统版本以上的设备上运行，支持的硬件有iPhone 5S、iPhone 5、iPhone 4S、iPhone 4、iTouch 4。
项目中主要针对的iOS设备是iPhone 5S、iPhone 5、iPhone 4S。这几款设备内存大小分别是1G、1G、512M。
4.4.1 Store Kit框架
Store Kit是苹果公司提供的用于App Store和应用之间通信的框架。
Store Kit流程图
1、获取商品信息阶段
2、请求交易阶段
3、商品获得阶段
5.1游戏开发环境及硬件需求
《无畏勇士》主要采用Unity3D引擎进行开发，选择了C#作为脚本主要开发语言。Xcode版本是5.0。
5.2.2游戏协议文件的编写及序列化
本项目通信协议采用Protocol Buffer的数据交换格式。
6.1全文总结
总结工作成果如下：
（1）实现了基于Unity3D游戏引擎的一个具有社交功能的休闲游戏；
（2）使用Unity3D引擎中的NGUI插件，完成游戏整体的UI界面、各模块背景设置、贴图变化效果、文字翻页显示等功能；
（3）借助WXAPI，实现了游戏中微信好友、朋友圈的分享；
（4）在Xcode环境下，应用Store Kit框架，调用iOS的IAP服务，实现游戏中内购虚拟金币；
（5）对游戏功能、可玩性、内存消耗、响应时间等进行了测试并分析，指出了可能影响游戏体验的因素。

2011年1月之前的Xcode
【
3.0: 2007年10月26日
3.1: 2008年7月11日
3.1.1: 2008年9月12日
3.1.2: 2008年11月24日
3.1.3: 2009年6月17日
3.2: 2009年8月28日
3.2.4: 2010年9月10日
4.0: 2011年3月9日
】
5个简易的iPhone相关程序的实现
1、按钮互动的实现
2、图片与按钮互动的实现
3、文字输入与显示的实现
4、开关与滑杆的实现
5、简易计算器的实现

View-Base Application项目
File|Save保存文件
点选.xib文件，将会开启Interface Builder。
开启后会看见两个窗口：Interface Builder对象窗口和应用程序的View窗口。
-(void)tapA:(id)sender{
myLabel.text=@"我按下了A按钮";
}
-(void)tapB:(id)sender{
myLabel.text=@"我按下了B按钮";
}

-(IBAction)pic1ButtonTapped{
imageView.image=[UIImage imageNamed:@"1.jpg"];
}
-(IBAction)pic2ButtonTapped{
imageView.image=[UIImage imageNamed:@"2.jpg"];
}
-(IBAction)pic3ButtonTapped{
imageView.image=[UIImage imageNamed:@"3.jpg"];
}

// 按下虚拟键盘上的Return时，表示完成编辑
-(IBAction)doneEditing:(id)sender{
// TextField类继承UIResponse类。resignFirstResponser方法可以让对象回到初始状态，因此，可以让虚拟键盘关闭
[sender resignFirstResponser];
}
// 按下按钮时，文字编辑框的内容会传送到Label上
-(IBAction)updateLabel:(id)sender{
display.text=textField.text;
}

// 控制当开关控件改变时所呈现的动作
-(IBAction)switchChange:(id)sender{
UISwitch *mySwitch=(UISwitch *)sender;
if(mySwitch.on)
{
switchState.text=@"Switch is ON!";
}
else
{
switchState.text=@"Switch is OFF!";
}
}

// 控制当滑杆控件改变时所呈现的动作
-(IBAction)sliderChange:(id)sender{
UISlider *mySlider=(UISlider *)sender;
int number=(int)(mySlider.value+0.5f);
}

Win8下Objective-C语言学习
在C:\GNUstep\msys\1.0\下新建home目录，gcc.sh和helloworld.m放在C:\GNUstep\msys\1.0\home下
gcc.sh文件，代码如下：
#!/bin/sh
gcc -fconstant-string-class=NSConstantString -c helloworld.m -I /GNUstep/System/Library/Headers
gcc -o helloworld helloworld.o -L /GNUstep/System/Library/Libraries/ -lobjc -lgnustep-base
./helloworld.exe
helloworld.m文件，代码如下：
#import<Foundation/Foundation.h>

int main(int arvc, char* argv[])
{
    NSLog(@"Hello world!");
    return 0;
}
main.m文件，代码如下：
#import<Foundation/Foundation.h>

int main(int argc, const char * argv[])
{
        NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

        NSLog (@"hello world");
        [pool drain];
        return 0;
}

 Setting up GNUstep Environment...

DELL-@DELL ~
$ cd /home

DELL-@DELL /home
$ ./gcc.sh
2015-09-26 19:23:03.807 helloworld[33120] Hello world!
DELL-@DELL /home
$ ./gcc2.sh
2015-09-26 20:26:06.435 main[45072] hello world

20151221添加：
DELL-@DELL /home
$ ./gcc20151221.sh
2015-12-21 23:12:20.968 oc20151221[7064] Hello world!
2015-12-21 23:12:20.983 oc20151221[7064] setAge 30

 

#import<Foundation/Foundation.h>

@interface Person : NSObject

{
int age;//字段在此定义
}
-(void)setAge:(int)newAge;//函数在此定义
@end

@implementation Person
- (void)setAge:(int)newAge{ 
NSLog(@"setAge %i",newAge); 
return; 
}

@end

int main(int arvc, char* argv[])
{
NSLog(@"Hello world!");
Person *person=[Person alloc];
[person init];
[person setAge:30];
[person release];

return 0;
}
20151224、20151225、20151229添加：

DELL-@DELL ~
$ cd /home
DELL-@DELL /home
$ ./gcc20151224.sh
2015-12-24 17:49:59.604 oc20151224[23176] Score.setCScore 78
2015-12-24 17:49:59.604 oc20151224[23176] Score.cScore 78
2015-12-24 17:49:59.619 oc20151224[23176] 78
组合（Composition）
#import <Foundation/Foundation.h>

@interface Score : NSObject
{
 int _cScore;
}
- (void)setCScore:(int)cScore;
- (int)cScore;
@end

@implementation Score
- (void)setCScore:(int)cScore
{
 _cScore = cScore;
 NSLog(@"Score.setCScore %d",_cScore);
}

- (int)cScore
{
 NSLog(@"Score.cScore %d",_cScore);
 return _cScore;
}

@end

@interface Student : NSObject
{
@public
Score *_score; //组合
int _age;
}
- (void)setScore:(int)cScore;
- (int)score;
@end

@implementation Student
- (void)setScore:(int)cScore
{
 [_score setCScore:cScore];
}
- (int)score
{
 int cs = [_score cScore];
 return cs;
}
@end

int main()
{
 Student *stu= [Student new];
 stu->_score = [Score new];
 [stu setScore:78];
 NSLog(@"%d",[stu score]);
 return 0;
}
DELL-@DELL /home
$ ./gcc20151224.sh
2015-12-24 16:30:35.278 oc20151224[9984] Parent.setData
2015-12-24 16:30:35.388 oc20151224[9984] num1=666
继承（Inheritance）
#import <Foundation/Foundation.h>

@interface Parent : NSObject
{ 
int num1; 
} 
-(void) setData; 
@end 

@implementation Parent 
-(void) setData
{
num1=666;
NSLog(@"Parent.setData");
}
@end

@interface Child : Parent
-(void) print; 
@end

@implementation Child 
-(void) print
{
NSLog(@"num1=%i",num1);
}
@end

int main(int argc,const char *argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
Child *objChild=[[Child alloc] init];
[objChild setData];
[objChild print];
[objChild release];

[pool drain];
return 0;
}
父类和子类有相同的方法时
DELL-@DELL /home
$ ./gcc20151224.sh
2015-12-24 16:43:33.136 oc20151224[9184] Child.setData
2015-12-24 16:43:33.153 oc20151224[9184] num1=888,num2=999
#import <Foundation/Foundation.h>

@interface Parent : NSObject
{ 
int num1; 
} 
-(void) setData; 
@end 

@implementation Parent
-(void) setData
{
num1=666;
NSLog(@"Parent.setData");
}
@end

@interface Child : Parent
{ 
int num2; 
}
-(void) setData;
-(void) print; 
@end

@implementation Child
-(void) setData
{
num1=888;
num2=999;
NSLog(@"Child.setData");
}
 
-(void) print
{
//NSLog(@"num1=%i",num1);
NSLog(@"num1=%i,num2=%i",num1,num2);
}
@end

int main(int argc,const char *argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
Child *objChild=[[Child alloc] init];
[objChild setData];
[objChild print];
[objChild release];

[pool drain];
return 0;
}
DELL-@DELL /home
$ ./gcc20151224.sh
2015-12-24 17:00:59.388 oc20151224[188] Dog-eat
多态（Polymorphism）
#import <Foundation/Foundation.h>
 
@interface Animal : NSObject
- (void)eat;
@end
 
@implementation Animal
- (void)eat
{
    NSLog(@"Animal-eat");
}
@end
 
@interface Dog : Animal
@end
 
@implementation Dog
- (void)eat
{
    NSLog(@"Dog-eat");
}
@end
 
int main()
{
    Animal* a = [Dog new];
    [a eat];
    
    return 0;
}
DELL-@DELL /home
$ ./gcc20151224.sh
2015-12-24 17:11:37.051 oc20151224[10320] Animal-eat
2015-12-24 17:11:37.061 oc20151224[10320] Dog-eat
2015-12-24 17:11:37.065 oc20151224[10320] Cat-eat
2015-12-24 17:11:37.071 oc20151224[10320] Dog-eat
#import <Foundation/Foundation.h>
 
@interface Animal : NSObject
- (void)eat;
@end
 
@implementation Animal
- (void)eat
{
    NSLog(@"Animal-eat");
}
@end
 
@interface Dog : Animal
@end
 
@implementation Dog
- (void)eat
{
    NSLog(@"Dog-eat");
}
@end

/*
int main()
{
    Animal* a = [Dog new];
    [a eat];
    
    return 0;
}
*/

// Cat
@interface Cat : Animal
@end
 
@implementation Cat
- (void)eat
{
    NSLog(@"Cat-eat");
}
@end
 
void feed(Animal* a)
{
    [a eat];
}
 
int main()
{
    Animal* a = [Animal new];
    feed(a);
    
    Dog* d = [Dog new];
    feed(d);
    
    Cat* c = [Cat new];
    feed(c);
    
    Animal* aa = [Dog new];
    feed(aa);
    
    return 0;
}

20160107添加：
5.6继承与多态
当一个类不再存在父类时，称为根类。
在开发Objective-C程序语言的项目时，开发者定义的类几乎都是NSObject根类的派生子类。
5.6.1来自父类的继承
DELL-@DELL ~
$ cd /home
DELL-@DELL /home
$ ./gcc20160107.sh
2016-01-07 10:28:34.273 oc20160107[5528] x=10
#import<Foundation/Foundation.h>
//#import<Foundation/NSObject.h>

@interface ClassA:NSObject
{
int x;
}
-(void)initVar;
@end

@implementation ClassA
-(void)initVar
{
x=10;
}
@end

@interface ClassB:ClassA
-(void)printVar;
@end

@implementation ClassB
-(void)printVar
{
NSLog(@"x=%i",x);
}
@end

int main(int arvc, char* argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
ClassB * b = [[ClassB alloc] init];
[b initVar];
[b printVar];
[b release];
[pool drain];
return 0;
} 
5.7.1自动释放池
建立一个自动释放池的实例对象。这里的自动释放池对象所管理的对象只局限于Foundation类中的对象。
在程序需要退出或者执行完毕后，需要通过代码来释放这个池。
当这条语句执行时，所有自动释放池中的对象都得到释放，并且这一过程都是自动完成的。
5.7.2引用计数
自动释放池能够实现的基础就是引用计数技术。
alloc方法进行内存分配时，引用次数为1。
Objective-C程序语言中增加一个对象的引用计数方法为：
[对象名 retain]
当程序不再需要此对象时，就可以调用释放方法：
[对象名 release]
此时，自动释放池就会判断。如果此时对象引用计数的值恰为1，则释放此对象；如果大于1，则将其减1。
5.7.3垃圾回收
iOS设备的运行环境并不支持垃圾回收机制。只能够依靠自动释放池和引用计数的方式来管理内存对象。
DELL-@DELL /home
$ cd /home
DELL-@DELL /home
$ ./gcc20151229.sh
2015-12-29 17:48:33.211 ns_number[22704] <
2015-12-29 17:48:33.226 ns_number[22704] 5
2015-12-29 17:48:33.226 ns_number[22704] 3.140000
2015-12-29 17:48:33.226 ns_number[22704] 6.700000
2015-12-29 17:48:33.226 ns_number[22704] A
由NSNumber类别所建立的对象称为数值对象。其中NS是Next Step的缩写。Objective-C的基本数据类型，如int、double、char、BOOL等，都必须先转换为NSNumber类别，否则无法储存为Foundation framework的数值对象。
#import<Foundation/Foundation.h>

int main(int arvc, char* argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
//基本数据类型
//专门用来装基础类型的对象
NSNumber * intNumber = [[NSNumber alloc] initWithInt:5];
NSNumber * intNumber2 = [NSNumber numberWithInt:6];
BOOL ret = [intNumber isEqualToNumber:intNumber2]; //这种比较也是可以跨不同对象的，比如：比较intNumber和floatNumber
//比较两个整型的NSNumber的大小
if ([intNumber compare:intNumber2] == NSOrderedAscending) {
    NSLog(@"<");
}else if([intNumber compare:intNumber2] == NSOrderedSame){
    NSLog(@"=");
}else if([intNumber compare:intNumber2] == NSOrderedDescending){
    NSLog(@">");
}
NSNumber * floatNumber = [[NSNumber alloc] initWithFloat:3.14f];
NSNumber * doubleNumber = [[NSNumber alloc] initWithDouble:6.7];
NSNumber * charNumber = [[NSNumber alloc] initWithChar:'A'];

//通过以下方法可以还原这些基本数据类型的数据
NSLog(@"%d",[intNumber intValue]);
NSLog(@"%f",[floatNumber floatValue]);
NSLog(@"%f",[doubleNumber doubleValue]);
NSLog(@"%c",[charNumber charValue]);

[pool drain];
return 0;
}

DELL-@DELL /home
$ ./gcc20151229.sh
2015-12-29 19:16:12.113 oc20151229[33244] 4
2015-12-29 19:16:12.125 oc20151229[33244] ret=1
2015-12-29 19:16:12.129 oc20151229[33244] ret2=1
2015-12-29 19:16:12.133 oc20151229[33244] ret3=1
2015-12-29 19:16:12.137 oc20151229[33244] before remove:2
2015-12-29 19:16:12.141 oc20151229[33244] after remove:1
2015-12-29 19:16:12.145 oc20151229[33244] after remove:0
数据集对象包括不可变更的数据集对象与可变更的数据集对象。可变更的数据集NSMutableSet是不可变更的数据集NSSet的子类。
#import<Foundation/Foundation.h>

int main(int arvc, char* argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
NSSet * set = [[NSSet alloc] initWithObjects:@"one",@"two",@"three",@"four", nil];
// 返回集合中对象的个数
NSLog(@"%i",[set count]);
// 判断集合中是否拥有@“two”
BOOL ret = [set containsObject:@"two"];
NSLog(@"ret=%i",ret);
NSSet * set2 = [[NSSet alloc] initWithObjects:@"one",@"two",@"three",@"four", nil];
// 判断两个集合是否相等
BOOL ret2 = [set isEqualToSet:set2];
NSLog(@"ret2=%i",ret2);
NSSet * set3 = [[NSSet alloc] initWithObjects:@"one",@"two",@"three",@"four",@"five", nil];
// 判断set是否是set3的子集合
BOOL ret3 = [set isSubsetOfSet:set3];
NSLog(@"ret3=%i",ret3);
//可变集合NSMutableSet
NSMutableSet * mset = [[NSMutableSet alloc] init];
[mset addObject:@"one"];
[mset addObject:@"two"];
[mset addObject:@"two"]; //如果添加的元素有重复，实际只保留一个
NSLog(@"before remove:%i",[mset count]);
// 删除元素
[mset removeObject:@"two"];
NSLog(@"after remove:%i",[mset count]);
[mset removeAllObjects];
NSLog(@"after remove:%i",[mset count]);
[pool drain];
return 0;
}

DELL-@DELL /home
$ ./ns_array.sh
2015-12-29 19:02:22.530 ns_array[7164] (One, Two, Three, Four)
2015-12-29 19:02:22.542 ns_array[7164] One
2015-12-29 19:02:22.546 ns_array[7164] Two
2015-12-29 19:02:22.550 ns_array[7164] Three
2015-12-29 19:02:22.554 ns_array[7164] Four
2015-12-29 19:02:22.558 ns_array[7164] One
2015-12-29 19:02:22.562 ns_array[7164] Two
2015-12-29 19:02:22.566 ns_array[7164] Three
2015-12-29 19:02:22.570 ns_array[7164] Four
2015-12-29 19:02:22.574 ns_array[7164] One
2015-12-29 19:02:22.578 ns_array[7164] Two
2015-12-29 19:02:22.582 ns_array[7164] Three
2015-12-29 19:02:22.582 ns_array[7164] Four
2015-12-29 19:02:22.586 ns_array[7164] before remove:3
2015-12-29 19:02:22.594 ns_array[7164] after remove:2
2015-12-29 19:02:22.598 ns_array[7164] after remove:1
2015-12-29 19:02:22.602 ns_array[7164] after remove:0
数组对象包括不可变更的数组对象与可变更的数组对象。可变更的数组NSMutableArray是不可变更的数组NSArray的子类。
#import<Foundation/Foundation.h>

int main(int arvc, char* argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
NSArray *array = [[NSArray alloc] initWithObjects:@"One", @"Two", @"Three", @"Four", nil];
// 打印数组，实际上是打印数据的每一个对象。因为数组重写的Description方法
NSLog(@"%@", array);
// 枚举器法
NSEnumerator *enumerator = [array objectEnumerator];
id obj;
while (obj = [enumerator nextObject]) {
     NSLog(@"%@", obj);
}
// 快速枚举法
for(id obj in array){
     NSLog(@"%@", obj);
}
// 使用i值遍历
NSUInteger length = [array count]; //返回数组元素的个数
obj = [array objectAtIndex:2]; //返回单个元素的地址
NSInteger i;
for(i = 0; i<[array count];i++){
     NSLog(@"%@", [array objectAtIndex:i]);
}

NSMutableArray *array1 = [[NSMutableArray alloc] init];
// 往可变数组中添加元素
[array1 addObject:@"one"];
[array1 addObject:@"two"];
[array1 addObject:@"three"];
NSLog(@"before remove:%i",[array1 count]);
// 交换两个数组的位置
[array1 exchangeObjectAtIndex:0 withObjectAtIndex:2];
// 删除元素,remove
[array1 removeObject:@"one"];
NSLog(@"after remove:%i",[array1 count]);
[array1 removeObjectAtIndex:1];
NSLog(@"after remove:%i",[array1 count]);
[array1 removeAllObjects];
NSLog(@"after remove:%i",[array1 count]);
[pool drain];
return 0;
}

DELL-@DELL /home
$ ./ns_dictionary.sh
2015-12-29 18:40:05.559 ns_dictionary[22600] one
2015-12-29 18:40:05.574 ns_dictionary[22600] 3
2015-12-29 18:40:05.574 ns_dictionary[22600] three
2015-12-29 18:40:05.574 ns_dictionary[22600] 1
2015-12-29 18:40:05.574 ns_dictionary[22600] one
2015-12-29 18:40:05.590 ns_dictionary[22600] 2
2015-12-29 18:40:05.590 ns_dictionary[22600] two
2015-12-29 18:40:05.590 ns_dictionary[22600] before remove:2
2015-12-29 18:40:05.590 ns_dictionary[22600] after remove:1
词典对象分为不可变更的词典对象与可变更的词典对象。可变更的词典NSMutableDictionary是不可变更的词典NSDictionary的子类。
#import<Foundation/Foundation.h>

int main(int arvc, char* argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:@"one",@"1",@"two",@"2",@"three",@"3", nil];
// 通过键快速的找到值
NSString *str = [dict objectForKey:@"1"];
NSLog(@"%@",str);
// 这种方式遍历到的是键Key，获得了键，也就获得了值
for(id obj in dict){
NSLog(@"%@",obj);
NSLog(@"%@",[dict objectForKey:obj]);
}
// 初始化
NSMutableDictionary *mDict = [[NSMutableDictionary alloc] init];
//添加
[mDict setObject:@"one" forKey:@"1"];
[mDict setObject:@"two" forKey:@"2"];
NSLog(@"before remove:%i",[mDict count]);
//删除
[mDict removeObjectForKey:@"1"];
NSLog(@"after remove:%i",[mDict count]);
[pool drain];
return 0;
}

DELL-@DELL ~
$ cd /home

DELL-@DELL /home
$ ./gcc20151225.sh
2015-12-25 15:00:51.021 oc20151225[20000] num1=100,num2=200
2015-12-25 15:00:51.031 oc20151225[20000] total=300
封装（Encapsulatation）
等价的语句：
//myClass *obj=[[myClass alloc] init];
myClass *obj=[myClass new];
#include <Foundation/Foundation.h>

@interface myClass:NSObject
{
int num1,num2;
}
-(void)setData;
-(int)sum;
-(void)output;
@end

@implementation myClass
-(void)setData
{
num1=100;
num2=200;
}
-(int)sum
{
return (num1+num2);
}
-(void)output
{
NSLog(@"num1=%i,num2=%i",num1,num2);
}
@end

int main(int argc,const char *argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
myClass *obj=[[myClass alloc] init];
[obj setData];
int total=[obj sum];
[obj output];
NSLog(@"total=%i",total);
[obj release];

[pool drain];
return 0;
}
DELL-@DELL /home
$ ./gcc20151225.sh
2015-12-25 17:09:10.466 oc20151225[20428] num1=100,num2=200
2015-12-25 17:09:10.488 oc20151225[20428] num1=100,num2=200
2015-12-25 17:09:10.494 oc20151225[20428] num1=100,num2=200
2015-12-25 17:09:10.499 oc20151225[20428] total=300
以@property与@synthesize取代setter与getter方法

#include <Foundation/Foundation.h>

@interface myClass:NSObject
{
int num1,num2;
}
@property int num1,num2;
-(void)setData;
-(int)sum;
-(void)output;
@end

@implementation myClass
@synthesize num1,num2;
-(void)setData
{
num1=100;
num2=200;
}
-(int)sum
{
return (num1+num2);
}
-(void)output
{
NSLog(@"num1=%i,num2=%i",num1,num2);
}
@end

int main(int argc,const char *argv[])
{
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];
//myClass *obj=[[myClass alloc] init];
myClass *obj=[myClass new];
//[obj setData];
//[obj setNum1:100];
//[obj setNum2:200];
obj.num1=100;
obj.num2=200;
NSLog(@"num1=%i,num2=%i",[obj num1],[obj num2]);
NSLog(@"num1=%i,num2=%i",obj.num1,obj.num2);
int total=[obj sum];
[obj output];
NSLog(@"total=%i",total);
[obj release];

[pool drain];
return 0;
}
http://www.cnblogs.com/dyllove98/archive/2013/07/25/3215142.html
DELL-@DELL /home
$ ./gcc20151225.sh
2015-12-25 22:39:17.774 oc20151225[932] str :hi
2015-12-25 22:39:17.785 oc20151225[932] str2 :hxh
2015-12-25 22:39:17.791 oc20151225[932] str3 :test3
2015-12-25 22:39:17.797 oc20151225[932] :1
2015-12-25 22:39:17.800 oc20151225[932] :1
2015-12-25 22:39:17.806 oc20151225[932] :{location=3, length=3}
2015-12-25 22:39:17.812 oc20151225[932] :{location=6, length=3}
2015-12-25 22:39:17.817 oc20151225[932] 789
2015-12-25 22:39:17.821 oc20151225[932] 123456
2015-12-25 22:39:17.830 oc20151225[932] 234
2015-12-25 22:39:17.838 oc20151225[932] (1, 2, a, b, c)
2015-12-25 22:39:17.844 oc20151225[932] Path is:User/Wildcat/APP
2015-12-25 22:39:17.847 oc20151225[932] Array is:(User, Wildcat, APP)
2015-12-25 22:39:17.855 oc20151225[932] Array is:User/Wildcat
2015-12-25 22:39:17.858 oc20151225[932] Array is:User/Wildcat/APP/123.txt
2015-12-25 22:39:17.861 oc20151225[932] 123
2015-12-25 22:39:17.863 oc20151225[932] length=10
2015-12-25 22:39:17.867 oc20151225[932] b
2015-12-25 22:39:17.870 oc20151225[932] abc

iOS开发：OC语言
1集面向对象概念
面向对象关心怎样控制对象，只需要关心接口就可以了。
冰箱开的动作是属于冰箱的
普通人不需要关心是怎样打开的
老板只需要发布命令，监督员工是否做完，老板是一个指挥者，不需要亲历亲为。
2集基本语法概述
OC所有关键字都有@开始
OC2.0引入的关键字
OC特有：for in
OC基类NSObject
是单继承、支持接口（OC里面叫协议）、使用接口来实现多继承、所有函数都是虚函数
OC的布尔类型是BOOL
OC类分为2个文件，.h文件和.m文件
类声明的例子
Dog.h
:表示继承
{}之间只能写字段，不能写函数
类实现的例子
Dog.m
创建/销毁OC对象
alloc类似于C++中的new
release类似于C++中的delete

函数定义在}和@end之间
字段定义都有三种作用域
OC中缺省是保护类型
OC中函数全部是public
所有OC类、接口声明必须带*
*既表示真正的指针，也表示引用
@interface表示类的声明
函数定义前面的-表示对象的方法，+表示类的方法
第二个冒号之前必须加个空格
类似于C中的
Int f(int x);
Int f();
Float f(int x,int y);
函数调用对比
无参数
一个参数
二个参数
带标签
OC的函数重载是一个简略的版本
OC不是严格的函数重载，跟参数类型没关系
g:和g:重名了，不行
g::和g::重名了，不行
函数的声明
写构造函数
- (id) init;
- (id) initWithID:(int)newID;
- (id) initWithID:(int)newID andAge:(int)newAge;

-(void) setID:(int)newID;
-(int) getID;

函数的实现
写构造函数
- (id) init
{
self=[super init];
//super表示父类
//self表示对象自己
if(self)
{
ID=1;
age=2;
price=60.0f;
}
return self;
}

-(void) setID:(int)newID
{
ID=newID;
}

-(int) getID
{
return ID;

}

main.m中调用Dog
Dog *dog1=[Dog alloc];
[dog1 init];
int ID=[dog1 getID];

Dog *dog2=[Dog alloc];
[dog2 initWithID:100 andAge:26 andPrice:68.88];
或Dog *dog2=[[Dog alloc] initWithID:100 andAge:26 andPrice:68.88];
ID=[dog2 getID];
3集类和对象的关系
类是抽象的概念 
人开电脑
现实生活中，先有对象才有类
计算机中，先有类才有对象
对象的内存分布
Person *xiaoming=[[Person alloc] init];
xiaoming->_age=20;
xiaoming->_name=@"小明";
4集类的封装
第二个写法：
[xiaoming setAge:20];
[xiaoming setName:@"小明"];
int a=[xiaoming getAge];
5集构造析构函数
OC的构造函数以initWith****开头
主要做些初始化相关的工作
析构函数dealloc
对象从内存中销毁前夕调用的函数
不是所有语言都有析构函数
对象销毁的时候调用 对象计数器=0
- (void) dealloc{
[super dealloc];
}
不要人为的调用[xiaozhang dealloc];
[xiaozhang release];

加号的方法 静态方法
//只调用一次
+ (void)initialize{
}
6集self指针
7集点语法
8集Category语法
9集基本数据结构——NSString
10集基本数据结构——NSArray

C++和Objective-C混编（官方文档翻译） http://www.docin.com/p-70701288.html
苹果的Objective-C编译器允许用户在同一个源文件里自由地混合使用C++和Objective-C，混编后的语言叫Objective-C++。有了它，你就可以在Objective-C应用程序中使用已有的C++类库。
Objective-C和C++混编的要点
在Objective-C++中，可以用C++代码调用方法也可以从Objective-C调用方法。在这两种语言里对象都是指针，可以在任何地方使用。例如，C++类可以使用Objective-C对象指针作为

数据成员，Objective-C类也可以有C++对象指针做实例变量。
注意：Xcode需要源文件以.mm为扩展名，这样才能启动编译器的Objective-C++扩展。
可以在OC接口中声明C++类，OC接口中定义的C++类是全局范围的。
OC++编译器定义了__cplusplus和__OBJC__预处理器常量，分别指定C++和OC。如前所述，OC++不允许C++类继承自OC对象，也不允许OC类继承自C++对象。
与OC不容的是，C++对象是静态类型的，有运行时多态是特殊情况。两种语言的对象模型因此不能直接兼容。更根本的，OC和C++对象在内存中的布局是互不相容的，也就是说，一般不可能创建一个对象实例从两种语言的角度来说都是有效的。因此，两种类型层次结构不能被混合。
你可以在OC类内部声明C++类，编译器把这些类当作已声明在全局名称空间来对待。
OC允许C结构作为实例变量，不管它是否声明在OC声明内部。
OC没有名字空间的概念。不能在C++名字空间内部声明OC类，也不能在OC类里声明名字空间。
OC类，协议，分类不能声明在C++ template里，C++ template也不能声明在OC接口，协议，分类的范围内。
但是，OC类可以做C++ template的参数，C++ template参数也可以做OC消息表达式的接收者或参数（不能通过selector）。

Windows下的Objective-C集成开发环境的搭建
http://www.docin.com/p-729519584.html#documentinfo
有三类方法搭建Objective-C的IDE：
1.使用苹果的平台，集成开发环境使用Xcode。但如果没有苹果平台，想在Windows环境下学习Objective-C，可以采用以下两种方法：
2.在Windows环境下设置一个苹果虚拟机，但这对个人电脑的性能要求较高，不是所有的个人电脑都可以，而且虚拟机的运行速度也较慢；
3.采用Codeblocks IDE开发环境，对其进行配置，搭建成支持Objective-C 的编译、调试、 运行的集成开发环境。这种方法对个人电脑的性能几乎没有要求，可以快速构建。 

http://www.docin.com/p-316920788.html
Smalltalk是第一个真正意义上的面向对象语言。Objective-C比较冷门。它完全借鉴了Smalltalk的思想，有着类似的语法和动态机制。
Objective-C是一门语言，而Cocoa是这门语言用于MacOS X开发的一个类库。
我们完全可以不使用Cocoa，只去用Objective-C。
例如gcc就是一个不使用Cocoa的编译器。不过在MacOS X平台，几乎所有的功能都要依赖于Cocoa完成。
Objective-C是C语言的超集。类似于C++，良好的的源代码能够直接被 Objective-C 编译器编译。不同于C++直接改变C语言的设计思路，Objective-C仅仅是在C语言基础上增加了一 些概念。例如，对于类的概念，C++是增加了一个全新的关键字class，把它作为语言内置的特性，而Objective-C则是将类转换成一个struct去处理。所以，为了避免冲突， Objective-C的关键字都是以@开头。一个简单的关键字列表是： @class,@interface,@implementation,@public,@private,@protected,@try,@catch,@throw,@finally,@end,@protocol,@selector,@synchronized,@encode,@defs。Objective-C2.0又增加了@optional,@required,@property,@dynamic,@synthesize这几个。
另外的一些值也类似于关键字，有nil和NIl，类型id，SEL和BOOL，布尔变量YES和NO。最后，特定上下文中会有一些关键字，分别是：in,out,inout,bycopy,byref,oneway和

getter,setter,readwrite,readonly,assign,retain,copy,nonatomic等。
注释
Objective-C使用//和/*…*/两种注释风格。
变量声明的位置
Objective-C允许在代码块的中部声明变量，而不仅仅在块的最开始处。
新增的值和变量
BOOL,YES,NO
C++中使用bool表示布尔类型。Objective-C中则使用BOOL，其值为YES和NO。
nil，Nil和id
简单来说：
每一个对象都是id类型的。该类型可以作为一种弱类型使用。id是一个指针，所以在使用时应注意是否需要再加*。例如id *foo=nil，实际是定义一个指针的指针；
nil等价于指向对象的NULL指针。nil和NULL不应该被混用。实际上，nil并不简单是NULL指针；
Nil等价于指针nil的类。在Objective-C中，一个类也是一个对象（作为元类Meta-Class的实例）。
nil代表NULL指针，但它也是一个类的对象，nil就是Nil类的实例。C++没有对应的概念，不过，如果你熟悉Java的话，应该知道每一个类对象都对应一个Class实例，类似这个。
SEL
SEL用于存储选择器selector的值。所谓选择器，就是不属于任何类实例对象的函数标识符。这些值可以由@selector获取。选择器可以当函数指针，但实际上它并不是一个真正的指向 函数的指针。
@encode
为了更好的互操作性，Objective-C的数据类型，甚至自定义类型、函数或方法的元类型，都可以使用ASCII编码。
@encode(aType)可以返回该类型的C字符串（char*）的表示。
源文件
与C++类似，Objective-C同样建议将声明和实现区分开。Objective-C的头文件后缀名是.h，源代码后缀名是.m。Objective-C使用#import引入其它头文件。与#include不同的是，#import保证头文件只被引入一次。另外，#import 不仅仅针对Objective-C的头文件，即便是标准C的头文件，比如stdlib.h，同样可以使用#import引入。
NS前缀
类NSObject，NSString都有一个前缀NS。这是Cocoa框架的前缀（Cocoa开发公司是neXTStep）。
函数和方法的区别
Objective-C并不是“使用方括号表示函数调用”的语言。
这并不是方法调用，而是发送一条消息。看上去并没有什么区别，实际上，这是Objective-C的强大之处。例如，这种语法允许你在运行时动态添加方法。
在Objective-C中，所有的类都是对象，并且可以被动态管理：也就是说，你可以在运行时增加新的类，根据类的名字实例化一个类，以及调用类的方法。这比C++的RTTI更加强大，而 后者只不过是为一个“static”的语言增加的一点点功能而已。C++的RTTI在很多情况下是不被推荐使用的，因为它过于依赖编译器的实现，牺牲了跨平台的能力。
根类，id类型，nil和Nil的值
任何一个面向对象的语言都要管理很多类。同Java类似，Objective-C有一个根类，所有的类都应该继承自这个根类（值得注意的是，在Java中，你声明一个类而不去显式指定它继承 的父类，那么这个类就是Object类的直接子类，然而，在Objective-C中，单根类的子类必须被显式地说明）；而C++并没有这么一个类。Cocoa中，这个根类就是NSObject，它提供了 很多运行时所必须的能力，例如内存分配等等。另外需要说明一点，单根类并不是Objective-C语言规范要求的，它只不过是根据面向对象理论实现的。因此，所有Java虚拟机的实现 ，这个单根类都是Object，但是在 Objective-C中，这就是与类库相关的了：在Cocoa中，这个单根类是NSObject，而在gcc的实现里则是Object。
严格说来，每一个类都应该是NSObject的子类（）相比之下，Java应该说，每一个类都必须是Object的子类，因此使用NSObject*类型应该可以指到所有类对象的指针。 但是，实际 上我们使用的是id类型。这个类型更加简短，更重要的是，id类型是动态类型检查的，相比来说，NSObject*则是静态类型检查。Objective-C里面没有泛型，那么我们就可以使用id 很方便的实现类似泛型的机制了。在Objective-C里面，指向空的指针应该声明为nil，不能是NULL。 这两者虽然很相似但并不可以互换。一个普通的C指针可以指向NULL，但是 Objective-C的类指针必须指向nil。正如前文所说，Objective-C里面，类也是对象（元类Meta-Class的对象）。nil所对应的类就是Nil。
类声明
属性和方法
在Objective-C里面，属性attribute被称为实例数据Instance data，成员函数member functions被称为方法methods。
在C++中，属性和成员函数都在类的花括块中被声明。方法的实现类似于C语言，只不过需要有作用于指示符（Foo::）来说明这个函数属于哪个类。
Objective-C中，属性和方法必须要分开声明。属性在花括号中声明，方法要跟在下面。它们的实现要在@implementation块中。
这是与C++的主要不同。在Objective-C中，有些方法可以不被暴露在接口中，例如private的。而C++中，即便是private函数，也能够在头文件中被看到。简单来说，这种分开式的声 明可以避免private函数污染头文件。
实例方法以减号-开头，而static方法以+开头。注意，这并不是UML中的private和public的区别！参数的类型要在小括号中，参数之间使用冒号:分割。
Objective-C中，类声明的末尾不需要使用分号;。同时注意，Objective-C的类声明关键字是@interface，而不是@class。@class关键字只用于前向声明。最后，如果类里面没有任 何数据，那么花括号可以被省略。
前向声明
为避免循环引用，C语言有一个前向声明的机制，即仅仅告诉存在性，而不理会具体实现。
C++使用class关键字实现前向声明。在Objective-C中则是使用@class关键字；另外，还可以使用@protocol关键字来声明一个协议（我们会在后面说到这个概念，类似于Java里面的Interface）。

private，protected和public
访问可见性是面向对象语言的一个很重要的概念。它规定了在源代码级别哪些是可见的。可见性保证了类的封装性。
在C++中，属性和方法可以是private，protected和public的。默认是private。  
在Objective-C中，只有成员数据可以是private，protected和public的，默认是protected。方法只能是public的。然而，我们可以在@implementation块中实现一些方法，而不在@interface中声明；或者是使用分类机制（class categories）。这样做虽然不能阻止方法被调用，但是减少了暴露。不经过声明实现一些方法是Objective-C的一种特殊属性，有着特殊的目的。我们会在后面进行说明。  
Objective-C中的继承只能是public的，不可以是private和protected继承。这一点，Objective-C更像Java而不是C++。
static属性 
Objective-C中不允许声明static属性。但是，我们有一些变通的方法：在实现文件中使用全局变量（也可以添加static关键字来控制可见性，类似C语言）。这样，类就可以通过方法访问到，而这样的全局变量的初始化可以在类的initialize方法中完成。
类和对象（续）  
方法
Objective-C中的方法与C++的函数在语法方面风格迥异。下面，我们就来讲述Objective-C的方法。原型、调用、实例方法和类方法
以-开头的是实例方法，以+开头的是类方法（相当于C++里面的static函数）。Objective-C的方法都是public的；
返回值和参数的类型都需要用小括号括起来；
参数之间使用冒号:分割；
参数可以与一个标签label关联起来，所谓标签，就是在:之前的一个名字。标签被认为是方法名字的一部分。这使得方法比函数更易读。事实上，我们应该始终使用标签。注意，第一个参数没有标签，通常它的标签就是指的方法名；
方法名可以与属性名相同，这使getter方法变得很简单。
Objective-C（不带label，即直接从C++翻译来）
Objective-C (带有label)
注意，方括号语法不应该读作“调用shelf对象的InsertObject方法”，而应该是“向shelf对象发送一个InsertObject消息”。这是Objective-C的实现方式。
this，self和super
一个消息有两个特殊的目标对象：self和super。self是指当前对象（类似C++的this），super指父对象。Objective-C里面没有this指针，取而代之的是self。
注意，self不是一个关键字。实际上，它是每个消息接收时的隐藏参数，其值就是当前对象。它的值可以被改变，这一点不同于C++的this指针。然而，这一点仅仅在构造函数中有用。
在方法中访问实例变量
同C++一样，Objective-C在方法中也可以访问当前对象的实例变量。不同之处在于，C++需要使用this->，而Objective-C使用的是self->。
原型的Id、签名和重载
C++和Objective-C使用截然不同的两种方式去区分： 前者使用参数类型，后者使用参数标签。
在C++中，只要函数具有不同的参数类型，它们就可以具有相同的名字。const也可以作为一种重载依据。
在Objective-C中，所有的函数都是普通的C函数，不能被重载（除非指定使用C99标准）。方法则具有不同的语法，重载的依据是label。
基于label的重载可以很明白地解释方法的名字
显然，Objective-C的方法使用label区分，而不是类型。利用这种机制，我们就可以使用选择器selector来指定一个方法，而不是“成员函数指针”。
类和对象（续二）
成员函数的指针：选择器
在Objective-C中，方法具有包含了括号和标签的特殊语法。普通的函数不能使用这种语法。在Objective-C和C语言中，函数指针具有相同的概念，但是对于成员函数指针则有所不同。
在C++中，尽管语法很怪异，但确实兼容C语言的，成员函数指针也是基于类型的。
在Objective-C中，引入了一个新的类型：指向成员函数的指针被称为选择器selector。它的类型是SEL，值通过@selector获得。@selector接受方法名（包括label）。
使用类NSInvocation则可以通过选择器调用方法。大多时候，工具方法族performSelector:（继承自NSObject）更方便，约束也更大一些。
这些方法的返回值同被调用的函数的返回值是一样的。对于那些参数不是对象的方法，应该使用该类型的包装类，如NSNumber等。NSInvocation也有类似的功能，并且更为强大。
我们可以使用respondsToSelector:方法来检查对象是否可被触发方法。
最后，@selector的值是在编译器决定的，因此它并不会减慢程序的运行效率。
因此，选择器可被用作函数参数。通用算法，例如排序，就可以使用这种技术实现。
严格说来，选择器并不是一个函数指针。它的底层实现是一个C字符串，在运行时被注册为方法的标识符。当类被加载之后，它的方法会被自动注册到一个表中，所以@selector可以很好的工作。根据这种实现，我们就可以使用==来判断内存地址是否相同，从而得出选择器是否相同，而无需使用字符串函数。
方法的真实地址，也就是看做C字符串的地址，其实可以看作是IMP类型。这种类型很少使用，处了在做优化的时候。例如虚调用实际使用选择器处理，而不是IMP。
最后，你应该记得我们曾经说过Objective-C里面的self指针，类似于C++的this指针，是作为每一个方法的隐藏参数传递的。其实这里还有第二个隐藏参数，就是_cmd。_cmd指的是当前方法。
参数的默认值
Objective-C不允许参数带有默认值。所以，如果某些参数是可选的，那么就应当创建多个方法的副本。在构造函数中，这一现象成为指定构造函数（designated initializer）。
可变参数
Objective-C允许可变参数，语法同C语言一样，使用...作为最后一个参数。
匿名参数
C++允许匿名参数，它可以将不使用的参数类型作为一种占位符。Objective-C不允许匿名参数。
原型修饰符（const,static,virtual,"=0",friend,throw）
在C++中，还有一些可以作为函数原型的修饰符，但在Objective-C中，这都是不允许的。以下是这个的列表：
const：方法不能使用const修饰。既然没有了const，也就不存在mutable了；
static：用于区别实例方法和类方法的是原型前面的-和+；
virtual：Objective-C中所有方法都是virtual的，因此没有必要使用这个修饰符。纯虚函数则是声明为一个典型的协议protocol；
friend：Objective-C里面没有friend这个概念；
throw：在C++中，可以指定函数会抛除哪些异常，但是Objective-C不能这么做。
类和对象（续三）
消息和消息传输
给nil发送消息
将消息代理给未知对象
代理delegation是Cocoa框架中UI元素的一个很常见的部分。代理可以将消息转发给一个未知的对象。通过代理，一个对象可以将一些任务交给另外的对象。
转发：处理未知消息
调用forwardInvocation:方法。这个方法可以将消息进行转发。这个方法是NSObject的，默认不做任何操作。
向下转型
C++中，父类指针调用子类的函数时，需要有一个向下转型的操作，使用dynamic_cast关键字。Objective-C中没有类似C++的专门的向下转型的操作符，使用C风格的转型语法就可以了。
继承
简单继承
Objective-C也有继承的概念，但是不能多重继承。不过，它也有别的途径实现类似多重继承的机制，这个我们后面会讲到。
如果你要在子类中调用父类的函数，需要使用super。
多重继承
Java同样不允许多重继承。但是它提供了interface来模拟多重继承。
类似的，Objective-C也有同样的机制，这就是协议protocol和分类categories。
虚拟性
虚方法
在Objective-C中，所有方法都是虚的，因此，没有virtual关键字或其等价物。
虚方法重定义
在Objective-C中，你可以定义一个没有在@interface块里面声明的方法。但这并不是一种替代private的机制，因为这种方法实际是能够被调用的。
纯虚方法则是使用正式协议formal protocols来实现。
虚继承
Objective-C中不允许多重继承，因此也就没有虚继承的问题。
协议
Java和C#使用接口interface的概念来弥补多重继承的不足。Objective-C也使用了类似的机制，成为协议protocol。协议并不是真正的类：它只能声明方法，不能添加数据。有两种类型的协议：正式的formal和非正式的informal。
正式协议
正式协议的方法，所有实现这个协议的类都必须实现。这就是一种验证，也就是说，只要这个类实现这个协议，那么它肯定可以处理协议中规定的方法。一个类可以实现任意多个协议。
C++中，协议可以由抽象类和纯虚函数实现。C++的抽象类要比Objective-C的协议强大的多，因为抽象类可以带有数据。
Objective-C中，协议是一个特殊的概念，使用尖括号<...>表明。注意，尖括号在Objective-C中不是模板的意思，Objective-C中没有类似C++模板的概念。
一个类也可以不经过协议声明，直接实现协议规定的方法。
实现了正式协议的对象的类型同协议本身是兼容的。这一机制可以作为协议的筛选操作。
可选方法
有时我们需要这么一种机制：我们的类需要实现一部分协议中规定的方法，而不是整个协议。
在Objective-C 1.0中就有非正式协议了，Objective-C 2.0则提出了新的关键字@optional和@required，用以区分可选方法和必须方法。
非正式协议
非正式协议并不是真正的协议，它对代码没有约束力。非正式协议允许开发者将一些方法归类，从而可以更好的组织代码。所以，非正式协议并不是协议的宽松版本。另外一个相似的概念就是分类。
分类名在小括号中被指定。
严格说来，除了原型部分，非正式协议对编译器没有什么意义，因为它并不能约束代码。不过，非正式协议可以形成很好的自解释代码，让API更具可读性。
继承（续）
Protocol对象
运行时，协议就像是类对象，其类型是Protocol*。@protocol关键字不仅用于声明协议，还可以用于根据协议名返回Protocol*对象。
远程对象的消息传递
由于Objective-C的动态机制，远程对象之间的消息传递变得很简单。所谓远程对象，是指两个或多个处于不同程序，甚至不同机器，但是可以通过代理完成同一任务，或者交换信息 的对象。正式协议就是一种可以确保对象提供了这种服务的有效手段。正式协议还提供了很多额外的关键字，可以更好的说明各种参数。这些关键字分别是in，out，inout，bycopy， byref和oneway。
这些关键字仅对远程对象有效，并且仅在协议中使用。出了协议，它们就不被认为是关键字。这些关键字被插入到协议中声明的方法原型之中，提供它们所修饰的参数的额外信息。以下是详细说明：
in：参数是输入参数；
out：参数是输出参数；
inout：参数既是输入参数，又是输出参数。
bycopy：复制传值。
byref：引用传值。
oneway：方法是异步的，也就是不会立即返回，因此它的返回值必须是void。
分类
创建类的分类categories，可以将一个很大的类分割成若干小部分。每个分类都是类的一部分，一个类可以使用任意多个分类，但都不可以添加实例数据。
仅仅为一个方法就去继承显得有些得不偿失。分类就可以很好的解决这个问题。
在Objective-C中，NSString是Cocoa框架的一个标准类。它是使用分类机制进行的扩展，只能在当前程序中使用。注意此时并没有新增加类。每一个NSString对象都可以从这个扩展获得统计元音数目的能力，甚至常量字符串也可以。
同时注意，分类不能增加实例数据，因此没有花括号块。
分类也可以使匿名的, 更适合于private的实现。
混合使用协议、分类和子类



http://www.docin.com/p-740239178.html
5.2主要类型
应用商店：App Store是苹果公司为iOS操作系统所创建和维护的数字化应用发布平台，允许用户从iTunes Store浏览和下载一些由iOS SDK或者Mac SDK开发的应用程序。根据应用发布的不同情况，用户可以付费或者免费下载。 应用程序可以直接下载到iOS设备，也可以通过Mac OS X或者Windows平台下的iTunes下载到计算机中。其中包含游戏、日程管理、词典、图库及许多实用的软件。
【
chap12发布游戏
2008年7月，苹果应用商店App Store上线。
12.1市场规模
12.2发布的版本
免费营收模式的游戏应用贡献了65%的游戏总收入，付费游戏的收入只占35%。
在App Store中游戏产品大多数会具有两个版本：付费版本以及免费版本。
12.3提交游戏产品
】
内置程序：iOS最新版本中的应用（因设备不同部分应用可能会有所差异）：电话、Mail、Safari、音乐、视频、SpringBoard、短信、日历、照片、相机、FaceTime、Photo Booth、股市、地图（Apple Map）、天气、备忘录、 杂志 、提醒事项 、时钟、计算器、指南针、语音备忘录、App Store、Game Center、设置、通讯录、iTunes、Nike+iPod、Voice Control 、Siri；
Web应用程序：在2007年苹果全球开发者大会上，苹果宣布iPhone和iPod Touch将会通过Safari网络浏览器支持某些 第三方应用程序，这些应用程序被称为Web应用程序。它们能通过AJAX网络技术编写出来。
第三方软件：iOS只支持从App Store用官方的方法安装软件。但经过iOS越狱后，一款名为Cydia的软件会被安装在设备，通过安装破解补丁即可通过第三方平台安装软件。
6关于越狱
6.1简介
iOS越狱（iOS Jailbreaking）是用于获取苹果公司便携装置操作系统iOS最高权限的一种技术手段，用户使用这种技术及软件可以获取到iOS的最高权限，甚至可能进一步揭开营运商对手机网络的限制。众所周知，iOS系统为闭源系统，非开源。用户权限很低，通过越狱老大开系统封闭的大门，使用户完全掌控iOS系统，可以随意的修改系统文件，安装插件，以及安装一些App Store中没有的软件。
6.3DFU
DFU（Device Firmware Update）是iOS设备的一种固件升级模式。越狱往往需要进入DFU模式。
6.4现目前能越狱的系统
因为苹果在发布iOS6.1.4版本系统的时候成功封堵了以前版本被黑客们用来进行越狱的漏洞，所以现在的越狱软件最高只支持iOS6.1.3及其以前的系统，而最新的iOS 7也是不支持越狱的。
7.iOS系统发展历史
7.1iOS1：iPhone诞生，专注用户体验
7.1.1iOS的人机交互界面
在iOS之前，智能手机使用键盘或手写笔输入，没有使用全触控屏幕。
7.1.3移动Safari浏览器
这是第一个移动浏览器，支持Flash插件，具有跟桌面浏览器一致的性能、功能和兼容性。
7.2iOS2：苹果的APP时代开始了
7.3iOS3：功能开始完善
iOS3.2开始可以应用于iPad
与iPhone开启的智能手机新时代一样，iPad也开启了平板电脑时代。  
7.4iOS4：总算支持多任务
7.5iOS5：开始测试Siri功能
7.6iOS6：告别谷歌地图，拥抱社交
9iOS最新系统iOS7

http://www.docin.com/p-707736630.html
3.1.1操作界面
iOS操作采用的是多点触控直接操作，控制方法包括滑动、轻触屏幕和图标及按键。操作有：滑动、轻按、缩小及放大。此外，iOS移动设备中还内置了加速器，使得旋转iOS设备时，

界面也可以得到旋转，这也使得iPhone等便携设备更便于使用。自3GS开始，iPhone装备有陀螺仪，这使得iPhone有了重力感应，游戏效果更加的突出。
屏幕的下方是home键，点按回到主界面。底部是dock，可安放4个使用者最经常使用的程序的图标。屏幕最上方是状态栏。
Objective-C不支持运算符重载，也只允许对象单继承，但其引入的Categories和protocols可以提供很多多重继承的好处。
Xcode支持多种语言，如：C，C++，Objective-C，Java。另外，Xcode的编译速度也极快。
iOS包含了SQLite数据库，它是一个简单的、轻量级的数据库。 它支持Windows/Linux/Unix等主流的操作系统。
JSON是一种轻量级的，以文字为基础，且易于让人阅读。
JSON用于描述数据结构，有以下形式存在：
1.对象
2.名称/值对
3.值的有序列表
4.字符串
5.数值
6.布尔值

http://www.docin.com/p-607127505.html
2.1.1iOS系统层次结构
iOS系统结构的4个层次分别是核心操作系统层、核心服务层、媒体层、可触摸层。
位于iOS系统结构最下面的一层是核心操作系统层：它包括内存管理、文件系统、电源管理和一些其他的操作系统任务。它包括以下组件：OS X Kernel，Mach 3.0，BSD Sockets，Power Mgmt,File System，Keychain，Certificates和Security。
除了这四层之外，位于iOS最上层的是应用程序层。
在iOS中Object-C可以和C++混合编译，这种混合源文件的格式为.mm。
表2-1iOS中常用的框架
框架名称，功能
CoreFoundation.framework，提供抽象的常用数据类型，如Unicode string，XML，URL
CoreGraphics.framework，提供2D绘制的基于C的API
Foundation.framework，提供Object-C的基础类（像NSObject）、基本数据类型和操作系统服务等
GameKit.framework，为游戏提供网络功能：点对点互联和游戏中的语音交流
MapKit.framework，为应用程序提供内嵌地图和接口
MediaPlayer.framework，提供播放视频和音频的功能
OpenGLES.framework，提供简洁而高效的绘制2D和3D图形的OpenGL API子集
QuartzCore,framework，提供动画特效以及用硬件进行渲染的能力
StoreKit,framework，为应用程序提供在程序运行中消费的支持
SystemConfiguration,framework，检测当前网络是否可用和硬件设备状态的能力
UIKit,framework，创建和管理应用程序的用户界面

http://www.docin.com/p-740576767.html
http://www.docin.com/p-667299752.html

2.1ios系统描述

2.1.1ios系统简介

iOS是运行于iPhone、iPod touch以及iPad设备的操作系统，它管理设备硬件并为手机本地应用程序的实现提供基础技术。

iPhone SDK包含开发、安装及运行本地应用程序所需的工具及接口。本地应用程序使用iOS系统框架和Objective-C语言进行构建，并且直接运行于iOS设备。

2.1.2ios系统发展历程

iOS最早于2007年1月9日，苹果在Macworld展览会上公布，随后于同年的6月份发布第一版iOS操作系统，当初命名为“iPhone runs OS X”。 

2.1.3iOS架构

iOS架构和Mac OS的基础架构相似。

iOs的层：Cocoa Touch，Media，Core Services， Core OS。

Cocoa Touch层：包含创建iOS应用程序所需的关键框架。 

媒体层：包含图形技术、音频技术和视频技术。

Core Services层：为所有的应用程序提供基础系统服务。

Core OS层：是很多其他技术的构建基础。
2.2构建ios开发环境
构造iPhone环境首先对CPU有一个要求，CPU必须是64位的，同时该电脑应该支持硬件虚拟化。
2.3XCode
XCode是苹果公司开发工具套件。套件和核心是Xcode应用程序本身，它用于提供基本的源代码开发环境。下面介绍开发iOS软件将会使用到的关键应用程序。
2.3.1Xcode
Xcode是一个集成开发环境。

2.3.2Interface Builder

Interface Builder以所见及所得方式组装用户界面。通过Interface Builder，把标准系统控件拖拽到应用程序窗口，并最终组装出应用程序的用户界面。界面的内容保存到nib文件（一种定制的资源文件格式）。

2.3.3Instruments

在iOS应用程序运行于模拟器或设备上时，可以利用Instruments环境分析其性能。

2.4Objective-C开发语言

Xcode下开发语言是Objective-C，同时也能融合C和C++开发。

http://www.docin.com/p-510467867.html
苹果iOS是由苹果公司开发的手持设备操作系统。苹果公司最早于2007年1月9日的Macworld大会上公布这个系统，最初始设计给iPhone使用的，后来陆续套用到iPad touch、iPad以及

Apple TV等苹果产品上。iOS与苹果的Mac OS　Ｘ操作系统一样，它也是以Darwin为基础的，因此同样属于类Unix的商业操作系统。原本这个系统名为iPhone OS，直到2010年6月7日

WWDC大会上宣布改名为iOS。
iOS的历史
2007年1月iOS1视觉的革命
2008年7月iOS2appstore发布
2009年6月iOS3性能大提升
2010年6月iOS4多任务时代
2011年10月iOS5Siri和iCloud
2012年6月iOS6再见了，Google
iOS系统架构
iOS是Apple长期积累的结果，系统核心和应用框架都采用C/C++或object-C开发，而应用采用CocoaTouch框架，以object-C开发，应用编译后以本机代码在设备上运行，因此具有很高

的运行效率。
iOS与Android比较
iOS来源于Apple的OSX，是UNIX系统，使用ObjectC这个古老语言来做开发。
Android是Google基于Linux搞来的，严格意义上讲Android并不是一个Linux
系统，它没有Linux的xwin，没有glibc，缺乏一整套标准的Linux程序。Android应用绝大部分都是使用Java开发。Android是一个全新的操作系统。
所以：
Android使用Java，上手容易很多。
iOS没有虚拟机，性能要好一些。
iOS的开发框架基本上和Mac上通用。
iOS和设备紧密集成。软硬件一家公司通吃。但是Android无法做到。
iOS是被Apple严格控制的系统。在大部分情况下，第三方应用是无法拿到所有API的。这意味着系统级别的很多功能只有Apple能做（比如打电话，拦截短信）。此外一些涉及用户隐私的API还会导致系统弹出对话框询问用户。反过来Android完全不一样，首先Android是开源的，在设计上Android就允许自由替换系统组件，Android也没有强制限制API的情况。所以：
Android平台可以做的事情远远比iOS多。
Android平台也可以跑其他系统的Runtime。
任何人可以拿Android自己改个独立的系统出来。
iOS上唯一的下载应用途径就是Appstore，开发者做应用上线还要通过Apple审核。就算通过了，Apple一样随时可以下架。管理非常严格。反过来Android上非常松懈。所以：
iOS上的精品软件多，竞争激烈但管理有序，开发者也容易挣钱。

20151214添加：

下载并安装iToolsSetup_1_8_3_5.exe
【iTools 1.8.5.0支持iOS9系统】
设备类型：iPhone4(8GB)
序列号：DX4J5T5PDP0N
越狱状态：已越狱
系统版本：5.1.1

iPhone怎么扫描二维码
如果你的IPhone已经越狱了，那只要手机安装了91助手即可。

3种查看iOS设备（iPhone/iPad/iPod touch）固件版本的方法
方法1：在主屏幕依次点击进入【设置】->【通用】->【关于本机】，就可以看到【版本】信息。
版本：5.1.1(9B208)
型号：MD128CH
序列号：DX4J5T5PDP0N
无限局域网地址：6C:3E:6D:10:0A:13
蓝牙：6C:3E:6D:10:0A:12
IMEI：013277005185086
ICCID：89860082191109879639
调制解调器固件：04.12.01
方法2：通过PC端91助手查询固件版本
方法3：通过官方iTunes来查看固件版本
1、下载安装iTunes
2、将您的iOS设备使用USB数据线连接电脑，此时请确保您的设备处于开机状态。
3、打开iTunes，在iTunes自动识别设备后，在iTunes侧边栏，点击你的设备名称，在右侧【摘要】页面，就能查看到设备的固件版本了。
iPhone4
8GB
容量：6.39GB
序列号：DX4J5T5PDP0N

创建Apple ID、iCloud账户：new XorStr(0x0A,22,"\x62\x6A\x62\x7E\x66\x60\x65\x60\x7B\x7D\x73\x2D\x23\x57\x29\x2F\x29\x35\x7F\x72\x73").ToString()，密码：new XorStr(0xA1,12,"\xE9\xD1\xD2\x95\x9C\x92\x9E\x9A\x99\x9A\x92").ToString()，救援邮箱：new XorStr(0x76,21,"\x1E\x16\x16\x01\x13\x1A\x13\x15\x0B\x1E\xB8\xB4\xC2\xB2\xB2\xB6\xA8\xE4\xE7\xE4").ToString()
此Apple ID尚未在iTunes Store使用。请检查您的帐户信息。 
绑定深圳招行卡



WhatsMyIP
IP Address:
fe80::20c:29ff:fe98:df3a%en0
Debug area：
2016-01-23 20:47:49.814 WhatsMyIP[666:c07] IP Address: fe80::20c:29ff:fe98:df3a%en0
越狱iPhone4+iOS5.1.1真机测试：
2016-01-15 18:28:41.103 DeviceInfo[351:707] Mac地址:6C:3E:6D:10:0A:13
未越狱iPhone4+iOS7.1.1真机测试：
IP Address:fe80::494:d7d1:7bf9:1541%en0
2016-01-28 17:06:31.305 WhatsMyIP[274:60b] Mac地址:02:00:00:00:00:00

iMac OS X介绍
2001年从Macintosh电脑上分离出来成为OS X 10.0
2014年推出OS X 10.10
OS X Yosemite 10.10.2
底层Unix
OS X GUI
下方是工具栏
Finder等同于资源管理器
三种格式：
.ipa
.pxl
.peb
2014.9发布iOS 8
500万以上的App
解决问题的方式
1、使用Xcode的帮助文档