Objective-C Fundamentals

164 CHAPTER 8 Dynamic typing and runtime type information
■
Messages are dynamically bound to methods. A runtime procedure matches the
method selector in a message with a particular method implementation that
“belongs to” the receiver object. The mapping can change or be modified
dynamically to change the behavior of the application and to introduce aspects
such as logging without recompilation.
These features give object-oriented programs a great deal of flexibility and power, but
there’s a price to pay. To permit better compile-time type checking and to make code
more self-documenting, you can also choose to more statically type your use of objects
in Objective-C.
8.1 Static vs. dynamic typing
If you declare a variable with a particular object type, the variable can only hold an
object of the specified type or one of its subclasses. The Objective-C compiler also
issues warning if, from the static type information available to it, it appears that an
object assigned to that variable won’t be able to respond to a particular message. As
an example, considering the following code snippet:
CTRentalProperty *house = ...;
[house setAddress:@"13 Adamson Crescent"];
[house setFlag:YES];
Because the variable is statically typed to be of type CTRentalProperty, the compiler
can verify that it should respond to the setAddress: message. On checking the
CTRentalProperty class, however, the compiler will issue a warning that the class may
not respond to the setFlag: message, because according to the static type information
available to the compiler, the CTRentalProperty class doesn’t provide such a message.
Static type checks such as the one demonstrated here can be a helpful
development aid because they enable errors such as typos or incorrect capitalization
to be detected at compile time rather than runtime.
Static typing contrasts with the dynamic typing available when the id datatype is
utilized, as in the following code sample:
id house = ...;
[house setAddress:@"13 Adamson Crescent"];
[house setFlag:YES];
Statically typed objects have the same internal data structure as objects declared to be
ids. The type doesn’t affect the object. It affects only the amount of information given
to the compiler about the object and the amount of information available to those
reading the source code.
8.1.1 Making assumptions about the runtime type
It’s possible to have your cake and eat it too. By this we mean that you can have some
of the benefits of the flexibility associated with dynamic typing while having greater
compile-time checks approaching the level of those offered by fully static typing.