objective-c

In the Java programming language there are both raw and wrapper objects to represent numbers. For example, int and Integer, double and Double, etc. If one wanted to add a numeric object to a Collection object, it required using the wrapper object rather than the raw type.

With the introduction of autoboxing in Java 1.5, moving between these types would largely be handled by the compiler, but there is still a distinction.

Just as with null types, Objective-C also requires that you wrap raw types before inserting them into objects or using them in variable argument lists where the type id is expected. To help us with this, cocoa provides NSNumber.

One of the really powerful libraries available to C++ programmers is the Standard Template Library (STL). While Cocoa has fantastic built-in classes, sometimes it is beneficial--especially when working with algorithms where raw numbers are being used and speed is more important--to use the STL.

Using the STL in Objective-C requires that you switch the file to use Objective-C++ by changing the file ending to .mm. After that you can import the various STL libraries normally: #import <vector>.

See Also:

• Standard Template Library Programmer's Guide
  
• The Objective-C 2.0 Programming Language: Using C++ With Objective-C

One thing that developers who are new to Objective-C will notice immediately are the number of null keywords. We have a choice of:

• nil
  
• Nil
  
• NULL

Under the hood there isn't much difference between these (as of this writing they are all defined exactly the same way), but by convention they have some subtle variations, and they have some odd behavior around them that it pays to understand.

One of the difficulties in iPhone is that it lacks Core Data, thus requiring developers to handle the database directly. While the system has SQLite built in (in libsqlite3.0.dylib ), the functions just beg to be wrapped up into something more usable.

Arithmetic underflow and the 2's compliment representation of numbers is serious problems in writing algorithms, especially when dealing with financial transactions. A lot of developers skirt around this problem by using double precision, but that is asking for trouble in applications--such as financial applications--that are more sensitive to these problems.

To get around this, different languages and libraries have implemented objects allow for either fixed or arbitrary precision. Java has BigDecimal, python has decimal, and various languages can take advantage of bc.

Objective-C--via the Cocoa library--has NSDecimalNumber. It isn't quite an arbitrary precision library, but is suitable for a wide range of applications that need precise mathematical calculations.

In Java 5 the java.util.concurrent.Callable interface was introduced. This is a generic interface that works like a Runnable, except that it returns a value and can throw checked exceptions.

Using Cocoa, we have a tool that can be used for similar purposes in Objective-C called NSInvocation. We use it transparently in the forwarding implementation of the Strategy Pattern, but don't really get into the details of how it works. Here we'll do that and set one up manually, as well as develop a factory-style method for generating them "on" the fly using variable argument lists.

The Cocoa framework provides a function called NSLog and the somewhat lesser known NSLogv. Coming from a Java and a Python background, where I have good loggers (Log4J and java.util.logging in Java, and the logging module in Python), I wanted something more... robust.

One of the more interesting features of some scripting languages is the programmer's ability to modify existent--and sometimes even built-in--classes. It can be used to segment functionality in a large class, split source for one class between several files, and add convenience methods.

Objective-C also has this capability through the use of Categories.

When developing for the Mac or the iPhone we frequently run into the situation of needing to grab the delegate. Thankfully this is stored in a singleton object and very easy to fetch:

When working with the Observer Pattern and the Singleton Pattern it is easy to see how they relate to the Java or C++ versions of the same concept. Everything basically plugs into the same places you would expect, coming from another Object Oriented language. The implementation isn't all that different.

We are going to see something a little more interesting when working with the Strategy Pattern in Objective-C. The Strategy Pattern is one of the most basic patterns and is even covered in the introduction to Head First Design Patterns. While the concept is identical in Objective-C as it is in Java and C++, the implementation is much closer to languages with first-class functions such as Python.

To do this, we will take advantage of one of the more powerful features of Objective-C: Forwarding.