Objective-C的语法对比（和Java的对比）

  

Objective-C的语法对比（和Java的对比）

1、函数的对比 
例子： 
helloworld方法 
Java 语言： 
    public void helloWorld(bool ishelloworld) {  
    //TODO  
    }

Objective-C语言： 
    -(void) HelloWorld:(BOOL)ishelloworld{  
    //TODO  
    }

前面带有减号(-) 的方法为实例方法，必须使用类的实例才可以调用的。 
对应的有+号， 代表是类的静态方法，不需要实例化即可调用。

2、消息。 
消息的定义：向对象发送信息。 
消息是iOS的运行时环境特有的机制。

Objective-C使用消息传递（本质是字符串）。 
Objective-C是动态语言, Java是静态语言。 
最大的区别在于Objective-C使用消息传递（本质是字符串），因此方法、类和对象可以在运行时确定和修改。Java的方法是与class静态绑定的， 
虽然可以在运行时用反射的机制获取，但效率会下降1个数量级，只在极端的情况下使用。也就是说，前者更加动态。

和C++,Java下的类，或实例调用类或实例的方法类似。这说的是类似，他们的机制实际上是有很大的差别。 
例子： 
[object  message]

[object  message:param1 withParameter:param2]

NSString *string;    
    string = [[NSString alloc] initWithString:@"Hello"];

上面的代码类似于： 
java/c++:object.message() 
java/c++:object.message(param1,param2) 
java/c++: 
string *str ; 
str = new string("Hello");

3、Import 
例子： 
import "Class.h" 
import <Class.h> 
import <director/Class.h> 
这个和C++里的include ,java的import类似

4 、Property 和Synthesize 
Property定义：@property 声明用于自动创建property属性变量的getter和setter 
Synthesize定义：@Synthesize声明实现了property属性变量的getter和setter。

例子: 
在  interface：@property dataType variableName 
在  implementation:  synthesiz variableName

5、头文件中的方法

例子：

-(returnType)method  
    -(returnType)method:(dataType)param1  
    -(returnType)method:(dataType)param1 withParam:(dataType)param2  
类似于: 
C/C++/Java 
    returnType method()  
    returnType method(param1)  
    returnType method(param1,param2)

6、self 
指向自己的指针 
[self method]

类似于：c++/java 
this.method();

7、继承关系和接口实现

例子： 
    ClassA:ParentA  
    ClassA:ParentA<Protocol>  
    ClassA <Protocol>

类似于: 
java: 
    ClassA extends ParentA  
    ClassA extends ParentA implements   interface  
    ClassA implements interface

OC的@protocol和java和C++的interface类似。 
OC中定义类的@interface和java和C++ class关键字类似。

8、空指针

id obj = nil; 
NSString *hello = nil;

nil相当与Java中的null;

9、 id

objective-c的和C++里的(void*)类似

10、Objective-C会生成本地代码，而Java是编译成字节码，再通过JIT机制编译成本地代码。 
平均效率差不多，但内存占用上前者占优，特别是考虑到垃圾回收以后。 
而在移动设备上，Java的垃圾回收机制也可能影响用户体验。

11、@语法是OC特有的一种语法，java是没有的。

12、头文件 
OC都习惯将类定义写在头文件里, 
Objective-C头文件和实现文件： 
头文件：.h结尾 
实现文件：.m结尾， 类似于C++的.cpp文件。

java却根本没有头文件的概念。

13、OC的方法定义和调用算是一大“特色”： 
方法的定义：-(返回类型) 方法名:(参数1类型)参数1变量 参数2标签:(参数2类型)参数2变量...

[类或者实例的指针方法名: 参数1 标签2: 参数2… …]，

为了好看，第一个参数一般不加标签名，当然，标签名都可以隐藏的，但不建议这样做，因为当你接手了一个离职的人程序，其中的JAVA 程序调用了一个有五个甚至更多的参数的方法，但是你手里没有这个方法的API，那么你很难猜得出来这五个参数到底都干什么用的，但是Objective-C调用的时候，每个参数前面都必须有方法的标签名，这样你便能很容易的从标签名看出这个参数是什么意思。

14、调用类方法：

[Fraction t];

[[Fraction class] t];

Class clazz=[Fraction class];[clazz t];

class 来自于NSObject，相当于JAVA 中的getClass()方法，也就是获取这个类的Class 对象，

clazz 前面没有*，这是因为Class 已经是一个指针。另外这种嵌套调用的方式，你也要习

惯，这就和JAVA 中的A.b().c()没有什么区别。

获取Class 有如下几种方法：

[类或者对象 class]

[类或者对象 superclasss]

NSClassFromString(类名的字符串形式)

你也可以通过如下的函数把Class 转换为字符串形式：

NSStringFromClass(Class)

15、OC中自定义类最好显示继承NSObject，可以获得alloc、init、release等方法。

16、OC中使用nil表示null，但跟java中的null还是有区别的，java中调用null的方法，会报臭名昭著的空指针异常，而OC不会，所以在OC你不必再为空指针而烦恼。

17、对象的初始化

前面我们看到实例化对象最多的方法是：Fraction *frac=[[Fraction alloc] init];

这跟java不一样，java对象创建只需要new一下，同时调用构造方法（实际上虚拟机层面分为两个步骤：new对象，执行<init>方法（包含构造方法）），但是OC中分为两步：分配内存（同时给变量赋初值）、初始化。

（1）、alloc 是从NSObject 继承而来的类方法，用于给对象分配存储空间，所有的成员变量在此时对确定了自己的内存位置，并被赋初值，整数类型为0，浮点数为0.0，BOOL 为NO，对象类型为nil，alloc 方法返回对象的指针。

（2）、init这个方法是从NSObject继承而来的，你可以覆盖它，当然init不是构造方法，只是一个普通方法而已，你甚至可以换成其他方法，只不过我们习惯在方法名前缀加上init。

还记得java中的构造方法没有返回值吧，所以为了达到java这种效果：Test t = new Test(2);OC中需要你手动在普通方法（相当于构造方法）中return self。

18、NSObject中的description方法相当于java中Object的toString方法，，用于获取对象的字符串表示。唯一不同的是OC中需要使用格式化字符串%@，才会触发description被调用：

Fraction *frac=[[Fraction alloc] init];

NSLog(@"%@",frac);

19、Objective-C 的异常都继承自NSException，当然NSException 本身也继承自NSObject。使用下面的语句块进行异常捕获：

@try {

<#statements#>

}

@catch (NSException *exception) {

<#handler#>

}

@finally {  

<#statements#>

}

总体来说，OC中的异常体系和java中的异常体系差不多，唯一的差别就是java中有业务异常，意思就是说你必须捕获他，如果不捕获就会出现编译错误，OC中的异常基本上都属于java中的运行时异常，如果你没有捕获，发生了异常程序就会崩溃，在一些循环批任务中尤其要注意。

20、OC中还有一个特色那就是他的弱类型id，他可以表示任何对象，实际上应该是利用了指针地址的通用性，由于OC中操作对象都必须是指针，而指针本身又是一串地址，所以通过指针可以指向一切不同的对象。

21、继承（感觉和java差不多啊） ，反射（这个和异常一样，感觉跟java也很像）

22、选择器（其实就是C中的函数指针，以及java中的Method类）

23、类别（Category），扩充类的功能，但不可以声明新的成员变量。

类别的应用比较广泛，譬如：第三方的Objective-C 库RegexKitLite 就是对NSString、NSMutableString 做的类别，为Objective-C 的字符类型增加了正则表达式的功能。

24、协议@protocol，这个就是前面说的，相当于java中的interface，思想都是一种约定、规范，只是具体语法不一样罢了。

25、字符串

-(BOOL) isEqualToString: (NSString*) s

比较两个字符串是否相等，与JAVA 一致的地方是==比较指针，比较对象是否相同要用到equal 方法。

-(NSMutableString*) appendString: (NSString*) s

这与JAVA 的StringBuffer 的append 没什么区别。

26、数组

Cocoa 使用NSArray 表示数组，但是它不能存储基本数据类型、enum、struct、nil，只能存储Objective-C 的对象。

NSArray *array=[NSArray arrayWithObjects: @"One", @"Two", @"Three", nil];

从这个类方法arrayWithObjects 的定义可以看出，它使用nil 表示数组元素结束，这也是nil 不能存储在NSArray 中的原因。

NSMutableArray 为长度可变的数组，相当于JAVA 中的List：

NSMutableArray *mArray=[NSMutableArray arrayWithCapacity: 10];

[mArray addObject: @"Apple"];//添加数组元素

NSEnumerator *e = [mArray objectEnumerator];//获取数组的迭代器，相当于JAVA 中的Iterator，reserveObjectEnumerator 用于获取反转之后的数组迭代器。与JAVA 一致的地方是你在使用迭代器时，不能对数组进行添加、删除操作。

for(NSString *ms in mArray){

NSLog(@"%@",ms);

}

//for-each 快速枚举为Objective-C 2.0 的新特性，Windows 上的GNUStep 并不支持。

27、字典（哈希表）

NSDictionary 用于存储key-value 的数据结构，与JAVA 中的Map 类似。

NSDictionary *dic=[NSDictionary dictionaryWithObjectsAndKeys: @"Apple", @"A", @"Google",@"G", nil];//dictionaryWithObjectAndKeys 后的可变参数，每两个为一个value-key，以nil 表示结束。

NSLog(@"%@",[dic objectForKey: @"A"]);//按照指定的key 查询value

同样的有NSMutableDictionary 表示长度可变的字典。

NSMutableDictionary *mDic=[NSMutableDictionary dictionaryWithCapacity: 10];

[mDic setObject: @"Apple" forKey: @"A"];//添加value-key 对

for(id key in mDic){

NSLog(@"%@ : %@",key,[mDic objectForKey: key]);

}

//快速迭代的for-each 循环

28、哈希Set

NSSet 表示以hash 方式计算存储位置的集合，与JAVA 中的HashSet 是一致的。在NSSet 中的每个对象都有一个唯一的hash 值，重复的对象将只能保留一个。因此，这引出了Objective-C中的对象比较问题，这需要你实现从NSObject 继承而来的如下两个方法：

- (BOOL) isEqual: (id) anObject;

- (NSUInteger) hash;

这与JAVA 的对象比较没有什么区别，两个相等的对象必须有相同的hashCode，所以这两个方法必须同时实现。

同样的，NSMutableSet 表示长度可变的哈希Set。

29、封装类（相当于java的包装器）

前面的几个容器类的对象都不能存放基本数据结构、enum、struct、nil，怎么办呢？在JAVA中我们知道所有的基本数据类型都有对应的封装类，例如：int---Integer、boolean---Boolean，使用封装类可以把基本数据类型包装为对象，而封装类本身又有方法可以返回原来的基本数据类型。Cocoa 使用NSValue 作为封装类。

NSRect rect=NSMakeRect(1,2,30,50);//这个是在前面提到过的一个表示矩形的结构体

NSValue *v=[NSValue valueWithBytes: &rect objCType: @encode(NSRect)];

/java <wbr>与oc之间的比较alueWithBytes 要求传入包装数据的地址，也就是变量中存储的数据的首地址，我们依然使用C 语言的&作为地址运算符，计算指针存储的首地址。

//objCType 要求传入用于描述数据的类型、大小的字符串，使用@encode 指令包装数据所属的类型。

NSMutableArray *mArray=[NSMutableArray arrayWithCapacity: 3];

[mArray addObject: v];

NSRect rect2;

[[mArray objectAtIndex: 0] getValue: &rect2];

//NSValue 的-(void) getValue: (void*) value 方法可以将NSValue 中的数据内容取出，要求传入的参数是一个指针，也就是说getValue 方法将你传入的指针指向存储的数据。

//一般Cocoa 中的getXXX 方法都是这个作用，这也是为什么前面的getter 方法不要以get作为方法前缀的原因。

对于基本数据类型，你可以使用简便的NSNumber 来封装，它是NSValue 的子类。

如果你想存储空值到集合类，可以使用NSNull，它使用NSNull *n =[NSNull null];的方式创建。

30、日期类型

Cocoa 中使用NSDate 类型表示日期。

31、数据缓冲区（其实就是java中的字节数组）

Cocoa 中使用NSData 类型来实现缓冲区，用于存储二进制的数据类型，譬如：从网络下载回来的文件等。

NSData 是长度不可变的数据缓冲区，还有一个NSMutableData 用来存储长度可变的数据缓冲区。

32、写入和读取属性（简直就是java序列化和反序列化的翻版）

在iPhone 的*.ipa 文件中，你经常可以看到*.plist 文件，它保存了程序的相关属性，叫做属性列表。其实它就是NSArray、NSDictionary、NSString、NSData 持久化之后的文件。

这几个类型都有一个成员方法writeToFile: (NSString*) file atomically: BOOL 用于将自己写入到一个文件。atomically 为YES 表示文件先存储到临时文件区，如果文件保存成功，再替换掉原始文件，这样的好处是可以防止在保存文件过程中出错，但是仅适用于小文件，因为你相当于是在临时文件存储区也放了一份，再加上原始文件，就是两份文件，如果文件比较大，将会占用较多的用户的磁盘空间。

如果你要持久化的类型不是上述的数组、字典、缓冲区，那该怎么办呢？Objective-C 中也有和JAVA 一样的序列化、反序列化支持，使用NSCoding 协议。NSCoding 协议定义了如下两个方法：

-(void) encodeWithCoder: (NSCoder*) coder;

-(id) initWithCoder: (NSCoder*) decoder;

第一个方法相当于编码对象，第二个方法是解码回对象，也就相当于给类型定义了一个新的init 方法而已。

33、对象的复制

对象的复制就相当于JAVA 中的clone()方法，也就是对象的深度复制，所谓深度复制就是重新分配一个存储空间，并将原对象的内容都复制过来，从这些描述可以看出，复制也会分配空间，那就是你要对复制出来的对象release，就是前面所说的alloc、new、copy 操作创建的对象，要手工release。

Objective-C 中的一个对象是否可以被复制，要看它的类型是否遵循NSCopying 协议，这个协议中有个复制方法-(id) copyWithZone: (*NSZone) zone 需要我们去实现。

34、多线程

Objective-C 的多线程编程与JAVA 语言极其类似分为原始的线程操作、线程池两种，后者其实就是使用队列等机制对前者的封装。JAVA 也一样，原始的线程操作使用Thread 类，线程池的操作使用java.util.concurrent.*中的类库。

Objective-C 中NSThread 类型表示线程，NSCondition 用于执行同步操作，在功能和用法上相当于JAVA 中的java.util.concurrent.*包中的Lock 对象。

另外，Objective-C 也支持@synchronized 指令做代码同步，写法也和JAVA 中的很相似。

@synchronized(要加锁的对象){

//同步执行的代码

}

另外比较有趣的是，如果你想更新UI 上的某一个部件，就需要在发起的新线程里调用UI 所在的主线程上的一个方法，新线程不能直接访问主线程的方法，需要在run 方法中使用如下的方法：

- (void) performSelectorOnMainThread: (SEL) aSelector withObject: (id) arg waitUntilDone: (BOOL) wait

如果你对java的swing熟悉的话，你应该知道在UI界，大多数更新界面的都必须在一个单线程中执行，因为如果更新界面是多线程的话会很难处理的，java swing处理的方法是更新界面的代码放在专门更新UI的线程下执行，其实这里IOS也是这么一个思想。

Objective-C 使用NSOperation、NSOperationQueue 两个类型实现线程池的操作，NSOpertion就好比JAVA 中的Runnable，其中的main（名字有点儿奇怪）方法也就是你要执行的操作，NSOperationQueue 是一个线程池队列，你只需要把NSOperation 添加到NSOperationQueue，队列就会retain 你的NSOperation，然后执行其中的操作，直到执行完毕。队列中会有多个操作，队列会按照你添加的顺序逐个执行，也就说队列中的任务是串行的。

跟java一样，如果线程池可以满足你的业务需求，尽量使用线程池，而不是原始的NSThread，因为使用线程池屏蔽了许多线程自身需要处理的问题，代码也更加简洁。

35、KVC 与KVO（这个话题真高级）

KVC 是NSKeyValueCoding 的缩写，它是Foundation Kit 中的一个NSObject 的Category，作用你可以类比JAVA 中的反射机制，就是动态访问一个对象中的属性。

KVC 在解析key 的字符串的时候，是会比你正常调用setter、getter 要慢的，而且编译器无法在编译器对你的方法调用做出检查（因为你的属性名都是字符串，只有运行时才会知道你有没有写错），出错的几率也会提高，所以请不要随意使用KVC，而省去setter、getter 方法。KVC 一般用于动态绑定，也就是运行时才能确定谁调用哪个方法，编译期并不确定。

KVO就是NSKeyValueObserving的缩写，它也是Foundation Kit中的一个NSObject的Category，KVO 基于KVC 实现，基于观察者设计模式（Observer Pattern）实现的一种通知机制，你可以类比JAVA 中的JMS，通过订阅的方式，实现了两个对象之间的解耦，但又可以让他们相互调用。（具体请查资料）

36、谓词NSPredicate

Cocoa 提供了NSPredicate 用于指定过滤条件，谓词是指在计算机中表示计算真假值的函数，它使用起来有点儿像SQL 的查询条件，主要用于从集合中分拣出符合条件的对象，也可以用于字符串的正则匹配。

相同的：

◆两种语言都是面向对象的

◆两种语言使用同样的设计模式，例如MVC

◆两种语言使用相似的数据库存储技术，例如ORM

不同的：

◆创建对象： 
Java对象是在运行时通过new关键字创建的。因此Java程序员无需担心内存分配问题。而在Objective-C中，一个对象可以由三个关键字创建，alloc、new或者copy，这三个关键字在创建对象时都会增加对象的持有计数(retain count)，持有计数是Objective-C特有的内存管理方法，显示有多少个指针指向对象，是否可以被内存管理器回收。 
在OC中所有对象的存取都是用指针，C++中还有引用，OC中没有。 
◆内存管理(销毁对象)： 
Java是垃圾回收，Java的引用对象都存储在JVM的堆内存中，一旦不再被引用，就可以作为垃圾回收。

Objective-C使用的是内存管理器，是引用计数，而不是垃圾回收器。如果你在内存中创建了一个对象，那么必须使用release方法来释放对象。release方法会减少持有计数，当计数降到0时，被引用的对象会接受一个来自高级类的dealloc方法，释放它占用的内存并重新分配。如果忘记了释放内存或释放失败，那么会造成内存泄露和不可预见的错误。

前者发生在运行时，后者在编译期。 
2011的WWDC中Apple展示了最新的ARC（Automatic Reference Counting），极大减轻了程序员管理内存的负担， 
但其本质依然是编译期的基于引用计数的内存管理。补充：虽然OC也可以用垃圾回收，不过使用的人很少，这也是后来ARC出现的原因吧。

◆过多释放和过早重新分配内存： 
由于垃圾回收机制，Java程序员可以完全不考虑这些问题。但Objective-C程序员需要小心，不能释放出比分配的更多的内存。如果在已经重新分配的对象上过多释放内存，就会造成应用的崩溃。