iPhone开发：浅析Objective-C的动态特性

青旅半醒 2022-05-15 11:17 99阅读 0赞

### Objective-C有3个动态特性    ###

1，动态类型

Dynamic typing—determining the class of an object at runtime

运行时决定对象类型

2，动态绑定

Dynamic binding—determining the method to invoke at runtime

运行时决定方法调用

3，动态加载

Dynamic loading—adding new modules to a program at runtime

运行时加载新模块

如何理解Objective-C的3这个动态特性呢？

首先，动态类型，简单点说就是 id 类型，可以理解为通用对象类型，一旦被赋值，可以被强制转化为其它类型。可以通过\[obj isKindOfClass:aClass\]，来判断其具体类型，作相应操作。这一点在委托（delegate）中体现得比较充分

动态绑定是基于动态类型的，某个实例被确定后，其类型也是确定的，其对应的属性和方法将会因为类型的确定而确定，这就是动态绑定。

动态加载是程序启动时动态加载可执行代码和资源。例如：多国语言的程序，会在程序启动时只加载设定为某一种语言的资源，而不是全部加载。基于Utility Application的程序，分别在iPhone和iPad上运行的时候，只会加载对应的代码和资源。当然兼容视网膜技术的@2x 图片加载也是这样的

### from：[http://developer.apple.com/library/mac/\#documentation/Cocoa/Conceptual/CocoaFundamentals/CocoaObjects/CocoaObjects.html%23//apple\_ref/doc/uid/TP40002974-CH4-SW32][http_developer.apple.com_library_mac_documentation_Cocoa_Conceptual_CocoaFundamentals_CocoaObjects_CocoaObjects.html_23_apple_ref_doc_uid_TP40002974-CH4-SW32] ###

### The Dynamism of Objective-C ###

Objective-C is a very dynamic language. Its dynamism frees a program from compile-time and link-time constraints and shifts much of the responsibility for symbol resolution to runtime, when the user is in control. Objective-C is more dynamic than other programming languages because its dynamism springs from three sources:

*  Dynamic typing—determining the class of an object at runtime
 *  Dynamic binding—determining the method to invoke at runtime
 *  Dynamic loading—adding new modules to a program at runtime

For dynamic typing, Objective-C introduces the`id`data type, which can represent any Cocoa object. A typical use of this generic object type is shown in this part of the code example from[Listing 2-2][]:

<table style="background-color:rgb(241,245,249);border-collapse:collapse;border-top-width:1px;border-right-width:1px;border-bottom-width:1px;border-left-width:1px;border-top-style:solid;border-right-style:solid;border-bottom-style:solid;border-left-style:solid;border-top-color:rgb(199,207,213);border-right-color:rgb(199,207,213);border-bottom-color:rgb(199,207,213);border-left-color:rgb(199,207,213);"> 
 <tbody> 
  <tr style="border-bottom-width:0px;border-bottom-style:solid;border-bottom-color:rgb(255,255,255);"> 
   <td> <pre>id word;</pre> </td> 
  </tr> 
  <tr style="border-bottom-width:0px;border-bottom-style:solid;border-bottom-color:rgb(255,255,255);"> 
   <td> <pre>while (word = [enm nextObject]) {
       </pre> </td> 
  </tr> 
  <tr style="border-bottom-width:0px;border-bottom-style:solid;border-bottom-color:rgb(255,255,255);"> 
   <td> <pre>    // do something with 'word' variable....</pre> </td> 
  </tr> 
  <tr style="border-bottom-width:0px;border-bottom-style:solid;border-bottom-color:rgb(255,255,255);"> 
   <td> <pre>}</pre> </td> 
  </tr> 
 </tbody> 
</table>

The`id`data type makes it possible to substitute any type of object at runtime. You can thereby let runtime factors dictate what kind of object is to be used in your code. Dynamic typing permits associations between objects to be determined at runtime rather than forcing them to be encoded in a static design.Static type checking at compile time may ensure stricter data integrity, but in exchange for that stricter integrity, dynamic typing gives your program much greater flexibility. And throughobject introspection (for example, asking a dynamically typed, anonymous object what its class is) you can still verify the type of an object at runtime and thus validate its suitability for a particular operation. (Of course, you can always statically check the types of objects when you need to.)

Dynamic typing gives substance todynamic binding, the second kind of dynamism in Objective-C. Just as dynamic typing defers the resolution of an object’s class membership until runtime, dynamic binding defers the decision of which method to invoke until runtime. Method invocations are not bound to code during compilation; they are bound only when a message is actually delivered. With both dynamic typing and dynamic binding, you can obtain different results in your code each time you execute it. Runtime factors determine which receiver is chosen and which method is invoked.

The runtime’s message-dispatch machinery enables dynamic binding. When you send a message to a dynamically typed object, the runtime system uses the receiver’s isa pointer to locate the object’s class, and from there the method implementation to invoke. The method is dynamically bound to the message. And you don’t have to do anything special in your Objective-C code to reap the benefits of dynamic binding. It happens routinely and transparently every time you send a message, especially one to a dynamically typed object.

Dynamic loading, the final type of dynamism, is a feature of Cocoa that depends on Objective-C for runtime support. With dynamic loading, a Cocoa program can load executable code and resources as they’re needed instead of having to load all program components at launch time. The executable code (which is linked prior to loading) often contains new classes that become integrated into the runtime image of the program. Both code and localized resources (including nib files) are packaged in bundles and are explicitly loaded with methods defined in Foundation’s`NSBundle`class.

This “lazy-loading” of program code and resources improves overall performance by placing lower memory demands on the system. Even more importantly, dynamic loading makes applicationsextensible. You can devise a plug-in architecture for your application that allows you and other developers to customize it with additional modules that the application can dynamically load months or even years after the application is released. If the design is right, the classes in these modules will not clash with the classes already in place because each class encapsulates its implementation and has its own namespace.

Dynamic typing—determining the class of an object at runtime

Dynamic binding—determining the method to invoke at runtime

Dynamic loading—adding new modules to a program at runtime

Dynamic typing—determining the class of an object at runtime

Dynamic binding—determining the method to invoke at runtime

Dynamic loading—adding new modules to a program at runtime

Dynamic typing—determining the class of an object at runtime

Dynamic binding—determining the method to invoke at runtime

Dynamic loading—adding new modules to a program at runtime

[http_developer.apple.com_library_mac_documentation_Cocoa_Conceptual_CocoaFundamentals_CocoaObjects_CocoaObjects.html_23_apple_ref_doc_uid_TP40002974-CH4-SW32]: http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CocoaFundamentals/CocoaObjects/CocoaObjects.html%23//apple_ref/doc/uid/TP40002974-CH4-SW32
[Listing 2-2]: http://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CocoaFundamentals/CocoaObjects/CocoaObjects.html#//apple_ref/doc/uid/TP40002974-CH4-SW1