To declare a class, you use the @interface compiler directive, like this:

@interface SomeClass : NSObject {

}

This is done in the header file (.h) and the class declaration contains no implementation. The preceding code declares a class named SomeClass, and this class inherits from the base class named NSObject.

In a typical View Controller class, the class inherits from the UIViewController class, such as in the following:

@interface HelloWorldViewController : UIViewController {

}

To implement a class declared in the header file, you use the @implementation compiler directive, like this:

#import "SomeClass.h"

@implementation SomeClass

@end

This is done in a separate file from the header file. In Objective-C, you define your class in an .m file. Note that the class definition ends with the @end compiler directive.

If your class references another class defined in another file, you need to import the header file of that file before you can use it. Consider the following example where you have defined two classes — SomeClass and AnotherClass. If you are using an instance of the AnotherClass from within SomeClass, you need to import the AnotherClass.h file, as in the following code snippet:

//---SomeClass.h---
#import <Foundation/Foundation.h>
#import "AnotherClass.h"

@interface SomeClass : NSObject {
    //---an object from AnotherClass---
    AnotherClass *anotherClass;
}

@end

//---AnotherClass.h---
#import <Foundation/Foundation.h>

#import "SomeClass.h"

@interface AnotherClass : NSObject {

}

@end

However, if within AnotherClass you want to create an instance of SomeClass, you will not be able to simply import SomeClass.h in AnotherClass, like this:

//---SomeClass.h---
#import <Foundation/Foundation.h>
#import "AnotherClass.h"

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
}

@end

//---AnotherClass.h---
#import <Foundation/Foundation.h>
#import "SomeClass.h" //---cannot simply import here---

@interface AnotherClass : NSObject {
    SomeClass *someClass;  //---using an instance of SomeClass---
}

@end

Doing so results in circular inclusion. To prevent that, Objective-C uses the @class compiler directive as a forward declaration to inform the compiler that the class you specified is a valid class. You usually use the @class compiler directive in the header file, and in the implementation file you can use the @import compiler directive to tell the compiler more about the content of the class that you are using.

Using the @class compiler directive, the program now looks like this:

//---SomeClass.h---
#import <Foundation/Foundation.h>
@class AnotherClass;  //---forward declaration---

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
}

@end

//---AnotherClass.h---
#import <Foundation/Foundation.h>

@class SomeClass;     //---forward declaration---

@interface AnotherClass : NSObject {
    SomeClass *someClass;
}

@end

To create an instance of a class, you typically use the alloc keyword (more on this in the Memory Management section) to allocate memory for the object and then return it to a variable of the class type:

SomeClass *someClass = [SomeClass alloc];

In Objective-C, you need to prefix an object name with the * character when you declare an object. If you are declaring a variable of primitive type (such as float, int, CGRect, NSInteger, and so on), the * character is not required. Here are some examples:

CGRect frame;   //---CGRect is a structure---
 int number;     //---int is a primitive type---
 NSString *str   //---NSString is a class

Besides specifying the returning class type, you can also use the id type, like this:

id someClass = [SomeClass alloc];
 id str;

The id type means that the variable can refer to any type of objects and hence the * is implicitly implied.

Fields are the data members of objects. For example, the following code shows that SomeClass has three fields — anotherClass, rate, and name:

#import <Foundation/Foundation.h>
@class AnotherClass;

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
    float rate;
    NSString *name;
}

@end

By default, the access privilege of all fields is @protected. However, the access privilege can also be @public or @private. The following list shows the various access privileges:

Using the example shown in the previous section, if you now try to access the fields in SomeClass from another class, such as in AnotherClass, you will not be able to see them:

SomeClass *someClass = [SomeClass alloc];
someClass->rate = 5;              //---rate is declared protected---
someClass->name = @"Wei-Meng Lee";  //---name is declared protected---

To make the rate and name visible outside the class, modify the SomeClass.h file by adding the @public compiler directive:

#import <Foundation/Foundation.h>
@class AnotherClass;

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
@public
    float rate;
@public
    NSString *name;
}

@end

The following two statements would now be valid:

someClass->rate = 5;              //---rate is declared protected---
someClass->name = @"Wei-Meng Lee";  //---name is declared protected---

Although you can access the fields directly, doing so goes against the design principles of object-oriented programming's rule of encapsulation. A better way is to encapsulate the two fields you want to expose in properties. Refer to the "Properties" section later in this appendix.

Methods are functions that are defined in a class. Objective-C supports two types of methods — instance methods and class methods.

Instance methods can be called only using an instance of the class. Instance methods are prefixed with the minus sign (-) character.

Class methods can be invoked directly using the class name and do not need an instance of the class in order to work. Class methods are prefixed with the plus sign (+) character.

The following code sample shows SomeClass with three instance methods and one class method declared:

#import <Foundation/Foundation.h>
@class AnotherClass;

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
    float rate;
    NSString *name;
}

//---instance methods---
-(void) doSomething;
-(void) doSomething:(NSString *) str;
-(void) doSomething:(NSString *) str withAnotherPara:(float) value;

//---class method---
+(void) alsoDoSomething;

@end

The following shows the implementation of the methods that were declared in the header file:

#import "SomeClass.h"

@implementation SomeClass

-(void) doSomething {
    //---implementation here---
}
-(void) doSomething:(NSString *) str {
    //---implementation here---
}
-(void) doSomething:(NSString *) str withAnotherPara:(float) value {
    //---implementation here---
}

+(void) alsoDoSomething {
    //---implementation here---
}

@end

To invoke the three instance methods, you first need to create an instance of the class and then call them using the instance created:

SomeClass *someClass = [SomeClass alloc];
[someClass doSomething];
[someClass doSomething:@"some text"];
[someClass doSomething:@"some text" withAnotherPara:9.0f];

Class methods can be called directly using the class name, as the following shows:

[SomeClass alsoDoSomething];

In general, you create instance methods when you need to perform some actions that are related to the particular instance of the class (that is, the object). For example, suppose you defined a class that represents the information of an employee. You may expose an instance method that allows you to calculate the overtime wage of an employee. In this case, you use an instance method because the calculation involves data specific to a particular employee object.

Class methods, on the other hand, are commonly used for defining helper methods. For example, you might have a class method called GetOvertimeRate: that returns the rates for working overtime. As all employees get the same rate for working overtime (assuming this is the case for your company), then there is no need to create instance methods and thus a class method will suffice.

The next section shows how to call methods with a varying number of parameters.

In Objective-C, you use the following syntax to call a method:

[object method];

Strictly speaking, in Objective-C you do not call a method; you send a message to an object. The message to be passed to an object is resolved during runtime and is not enforced at compile time. This is why the compiler does not stop you from running your program even though you may have misspelled the name of a method. It does try to warn you that the target object may not respond to your message, though, because the target object will simply ignore the message. Figure D-1 shows the warning by the compiler when one of the parameters for the UIAlertView's initializer is misspelled (the cancelButtonsTitle: should be cancelButtonTitle:).

Figure D.1. Figure D-1

Using the example from the previous section, the doSomething method has no parameter:

-(void) doSomething {
    //---implementation here---
}

Therefore, you can call it like this:

[someClass doSomething];

If a method has one or more inputs, you call it using the following syntax:

[object method:input1];                        //---one input---
[object method:input1 andSecondInput:input2];  //---two inputs---

The interesting thing about Objective-C is the way you call a method with multiple inputs. Using the earlier example:

-(void) doSomething:(NSString *) str withAnotherPara:(float) value {
    //---implementation here---
}

The name of the preceding method is doSomething:withAnotherPara:.

It is important to note the names of methods and to differentiate those that have parameters from those that do not. For example, doSomething refers to a method with no parameter, whereas doSomething: refers to a method with one parameter, and doSomething:withAnotherPara: refers to a method with two parameters. The presence or absence of colons in a method name dictates which method is invoked during runtime. This is important when passing method names as arguments, particularly when using the @selector (discussed in the Selectors section) notation to pass them to a delegate or notification event.

Method calls can also be nested, as the following example shows:

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

Here, you first call the alloc class method of the NSString class and then call the initWithString: method of the returning result from the alloc method, which is of type id, a generic C type that Objective-C uses for an arbitrary object.

In general, you should not nest more than three levels because anything more than that makes the code difficult to read.

Properties allow you to expose your fields in your class so that you can control how values are set or returned. In the earlier example (in the Access Privileges section), you saw that you can directly access the fields of a class using the --> operator. However, this is not the ideal way and you should ideally expose your fields as properties.

Prior to Objective-C 2.0, programmers had to declare methods to make the fields accessible to other classes, like this:

#import <Foundation/Foundation.h>
@class AnotherClass;

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
    float rate;
    NSString *name;
}

//---expose the rate field---
-(float) rate;                         //---get the value of rate---
-(void) setRate:(float) value;         //---set the value of rate

//---expose the name field---
-(NSString *) name;                   //---get the value of name---
-(void) setName:(NSString *) value;   //---set the value of name---

@end

These methods are known as getters and setters (or sometimes better known as accessors and mutators). The implementation of these methods may look like this:

#import "SomeClass.h"

@implementation SomeClass

-(float) rate {
    return rate;
}

-(void) setRate:(float) value {
    rate = value;
}

-(NSString *) name {
    return name;
}

-(void) setName:(NSString *) value {
    [value retain];
    [name release];
    name = value;
}

@end

To set the value of these properties, you need to call the methods prefixed with the set keyword:

SomeClass *sc = [[SomeClass alloc] init];
[sc setRate:5.0f];
[sc setName:@"Wei-Meng Lee"];

Alternatively, you can use the dot notation introduced in Objective-C 2.0:

SomeClass *sc = [[SomeClass alloc] init];
sc.rate = 5;
sc.name = @"Wei-Meng Lee";

To obtain the values of properties, you can either call the methods directly or use the dot notation in Objective-C 2.0:

NSLog([sc name]); //---call the method---
NSLog(sc.name);   //---dot notation

To make a property read only, simply remove the method prefixed with the set keyword.

Notice that within the setName: method, you have various statements using the retain and release keywords. These keywords relate to memory management in Objective-C; you learn more about them in the "Memory Management" section, later in this appendix.

In Objective-C 2.0, you don't need to define getters and setters in order to expose fields as properties. You can do so via the @property and @synthesize compiler directives. Using the same example, you can use the @property to expose the rate and name fields as properties, like this:

#import <Foundation/Foundation.h>
@class AnotherClass;

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
    float rate;
    NSString *name;
}

@property float rate;
@property (retain, nonatomic) NSString *name;

@end

The first @property statement defines rate to be a property. The second statement defines name as a property as well, but it also specifies the behavior of this property. In this case, it indicates the behavior as retain and nonatomic, which you learn more about in the section on memory management later in this appendix. In particular, nonatomic means that the property is not accessed in a thread-safe manner. This is alright if you are not writing multi-threaded applications. Most of the time, you will use the retain and nonatomic combination when declaring properties.

In the implementation file, rather than define the getter and setter methods, you can simply use the @synthesize keyword to get the compiler to automatically generate the getters and setters for you:

#import "SomeClass.h"

@implementation SomeClass
@synthesize rate, name;

@end

As shown, you can combine several properties using a single @synthesize keyword. However, you can also separate them into individual statements:

@synthesize rate;
@synthesize name;

You can now use your properties as usual:

//---setting using setRate---
[sc setRate:5.0f];
[sc setName:@"Wei-Meng Lee"];

//---setting using dot notation---
sc.rate = 5;
sc.name = @"Wei-Meng Lee";

//---getting---
NSLog([sc name]); //---using the name method
NSLog(sc.name);   //---dot notation

To make a property read only, use the readonly keyword. The following statement makes the name property read only:

@property (readonly) NSString *name;

When you create an instance of a class, you often initialize it at the same time. For example, in the earlier example (in the Class Instantiation section), you had this statement:

SomeClass *sc = [[SomeClass alloc] init];

The alloc keyword allocates memory for the object, and when an object is returned, the init method is called on the object to initialize the object. Recall that in SomeClass, you do not define a method named init. So where does the init method come from? It is actually defined in the NSObject class, which is the base class of most classes in Objective-C. The init method is known as an initializer.

If you want to create additional initializers, you can define methods that begin with the init word. (The use of the init word is more of a norm than a hard-and-fast rule.)

#import <Foundation/Foundation.h>
@class AnotherClass;

@interface SomeClass : NSObject {
    AnotherClass *anotherClass;
    float rate;
    NSString *name;
}

-(void) doSomething;
-(void) doSomething:(NSString *) str;
-(void) doSomething:(NSString *) str withAnotherPara:(float) value;
+(void) alsoDoSomething;

- (id)initWithName:(NSString *) n;
- (id)initWithName:(NSString *) n andRate:(float) r;

@property float rate;
@property (retain, nonatomic) NSString *name;

@end

The preceding example contains two additional initializers: initWithName: and initWithName:andRate:. You can provide the implementations for the two initializers as follows:

#import "SomeClass.h"
@implementation SomeClass
@synthesize rate, name;

- (id)initWithName:(NSString *) n
{
    return [self initWithName:n andRate:0.0f];
}

- (id)initWithName:(NSString *) n andRate:(float) r
{
    if (self = [super init]) {
        self.name = n;
        self.rate = r;
    }
    return self;
}

-(void) doSomething {
}

-(void) doSomething:(NSString *) str {
}

-(void) doSomething:(NSString *) str withAnotherPara:(float) value {
}

+(void) alsoDoSomething {
}

@end

Note that in the initWithName:andRate: initializer implementation, you first call the init initializer of the super (base) class so that its base class is properly initialized, which is necessary before you can initialize the current class:

- (id)initWithName:(NSString *) n andRate:(float) r
{
    if (self = [super init]) {
       //...
       //...
    }
    return self;
}

The rule for defining an initializer is simple: If a class is initialized properly, it should return a reference to self (hence the id type). If it fails, it should return nil.

For the initWithName: initializer implementation, notice that it calls the initWithName:andRate: initializer:

- (id)initWithName:(NSString *) n
{
    return [self initWithName:n andRate:0.0f];
}

In general, if you have multiple initializers, each with different parameters, you should chain them by ensuring that they all call a single initializer that performs the call to the super class's init initializer. In Objective-C, the initializer that performs the call to the super class's init initializer is called the designated initializer.

To use the initializers, you can now call them during instantiation time:

SomeClass *sc1 = [[SomeClass alloc] initWithName:@"Wei-Meng Lee" andRate:35];
SomeClass *sc2 = [[SomeClass alloc] initWithName:@"Wei-Meng Lee"];

To help you allocate and de-allocate memory for objects, the iPhone OS uses a scheme known as reference counting to keep track of objects to determine whether they are still needed or can be disposed of. Reference counting basically uses a counter for each object, and as each object is created, the count increases by 1. When an object is released, the count decreases by 1. When the count reaches 0, the memory associated with the object is reclaimed by the OS.

In Objective-C, a few important keywords are associated with memory management. The following sections take a look at each of them.

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

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

NSString *str = [NSString new];

NSString *str = [[NSString alloc] init];

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

NSString *str = [[NSString alloc] initWithString:@"Hello"];
NSString *str2 = str;
[str2 retain];
[str release];

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

//...do what you want with the object...

[str release];

NSString *str = [[NSString alloc] initWithString:@"Hello"];
NSString *str2 = str;
[str release];
[str2 release];  //---this is not OK as you do not own str2---

NSString *str = [[NSString alloc] initWithString:@"Hello"];
NSString *str2 = str;
[str2 retain];
[str release];
[str2 release];  //---this is now OK as you now own str2---

-(void) setName:(NSString *) value {
    [value retain];
    [name release];
    name = value;
}

-(void) setName:(NSString *) value {
    name = value;
}

[value retain];
    [name release];
    name = value;

NSString *str = [NSString stringWithFormat:@"%d", 4];

NSString *str1 = [[NSString alloc] initWithFormat:@"%d", 4];
[str1 release]; //---this is ok because you own str1---

NSString *str2 = [NSString stringWithFormat:@"%d", 4];
[str2 release]; //---this is not ok because you don't own str2---
//---str2 will be removed automatically when the autorelease pool is activated---

NSString *str2 = [[NSString stringWithFormat:@"%d", 4] retain];

NSString *str = [[NSString stringWithFormat:@"%d", 4] retain];
[str autorelease];  //you don't own it anymore; still available
NSlog(str);         //still accessible for now

NSString *str2 = [NSString stringWithFormat:@"%d", 4];

NSString *str2 = @"4";

for (int i=0; i<=99999; i++){
    NSString *str = [NSString stringWithFormat:@"%d", i];
    //...
    //...
}

for (int i=0; i<=99999; i++){
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    NSString *str1 = [NSString stringWithFormat:@"%d", i];
    NSString *str2 = [NSString stringWithFormat:@"%d", i];
    NSString *str3 = [NSString stringWithFormat:@"%d", i];
    //...
    //...
    [pool release];
}

@property (retain, nonatomic) NSString *name;

-(void) dealloc {
    [self.name release];   //---release the name property---
    [super dealloc];
}

SomeClass *sc1 = [[SomeClass alloc] initWithName:@"Wei-Meng Lee" andRate:35];
//...do something here...
[sc1 release];  //---reference count goes to 0; dealloc will be called---

- (void)didReceiveMemoryWarning {
    //---insert code here to free unused objects---
    [super didReceiveMemoryWarning];
}

- (void)applicationDidReceiveMemoryWarning:(UIApplication *)application
{
    //---insert code here to free unused objects---
    [[ImageCache sharedImageCache] removeAllImagesInMemory];
}

In Objective-C, a delegate is just an object that has been assigned by another object as the object responsible for handling events. Consider the case of the UIAlertView example that you have seen previously:

UIAlertView *alert = [[UIAlertView alloc]
                             initWithTitle:@"Hello"
                             message:@"This is an alert view"
                             delegate:self
                             cancelButtonTitle:@"OK"
                             otherButtonTitles:nil];

The initializer of the UIAlertView class includes a parameter called the delegate. Setting this parameter to self means that the current object is responsible for handling all the events fired by this instance of the UIAlertView class. If you don't need to handle events fired by this instance, you can simply set it to nil:

UIAlertView *alert = [[UIAlertView alloc]
                         initWithTitle:@"Hello"
                             message:@"This is an alert view"
                             delegate:nil
                             cancelButtonTitle:@"OK"
                             otherButtonTitles:nil];

If you have multiple buttons on the alert view and want to know which button was tapped, you need to handle the methods defined in the UIAlertViewDelegate protocol. You can either implement it in the same class in which the UIAlertView class was instantiated (as shown in the previous section), or create a new class to implement the method, like this:

//---SomeClass.m---
@implementation SomeClass

- (void)alertView:(UIAlertView *)alertView
clickedButtonAtIndex:(NSInteger)buttonIndex {

    NSLog([NSString stringWithFormat:@"%d", buttonIndex]);

}

@end

To ensure that the alert view knows where to look for the method, create an instance of SomeClass and then set it as the delegate:

SomeClass *myDelegate = [[SomeClass alloc] init];

UIAlertView *alert = [[UIAlertView alloc]
                         initWithTitle:@"Hello"
                         message:@"This is an alert view"
                         delegate:myDelegate
                         cancelButtonTitle:@"OK"
                         otherButtonTitles:@"Option 1", @"Option 2", nil];
[alert show];