The Basics of an Objective-C Program

For our second iPhone program we are going to actually write code rather than just use Interface Builder.
This code will be in Objective-C so we are going to go over the Basics of Objective-C.
Objective-C can be compiled from the command-line in any environment in you have gcc. We will first look at such a program then work our way back to the iPhone.
Header Files use the extension .h
Implementations use the extension .m (named for mplementation)

A .h file typically might be used to define an interface of a class. This might have the format:


@interface classname : superclassname {
   int my_field; 
    // instance variables can be any C type or  the generic id type.
}
+classMethod1; // + means class method; - means instance method
+(return_type)classMethod2;
+(return_type)classMethod3:(param1_type)parameter_varName;
-(return_type)instanceMethod1:(param1_type)param1_varName :(param2_type)param2_varName;
-(return_type)instanceMethod2WithParameter: (param1_type)param1_varName andOtherParameter:(param2_type)param2_varName;
@end

Implementation Files

To implement the functions you use an implementation file and the syntax:

@implementation classname
+classMethod {
    // implementation
}
-instanceMethod {
    // implementation
}
@end

Invoking Methods

A call obj.method(parameter); in C++ might look like [obj method:parameter]; in Objective-C.

You can have multiple parameters:

[obj method:parameter1 paramName2: parameter2]

To instantiate a class you can send either the new message or instantiate in two steps:
```
    MyObject * o = [MyObject new];
    MyObject * o = [[MyObject alloc] init];
```
You can override the init method of your class to make a new constructor.
The second way is preferred. We first allocate memory for our object; then send it an init message.
Rather than just init we might create a method that takes arguments and inits, in which case the second approach is more flexible.

Example Objective-C Program

// Interface File
#import <objc/Object.h>

@interface MyHello : Object {
   int myNumber;
}
-setNumber:(int)aNumber;
-sayHello;

@end

Example Program cont'd

// implementation file
#import <stdio.h>
#import "MyHello.h" 
@implementation MyHello
-setNumber:(int)aNumber {    myNumber = aNumber;
} 
-sayHello{    
   printf("Hello! %d\n", myNumber);
} 
-(id) init { //self is like this in Java
    self = [super init];
    if (self) { myNumber = 0; }
    return self;}  
@end

Objective-C Example Last Part.

#import "MyHello.h"
int main(void){
MyHello *hello = [MyHello new];  
[hello setNumber:10]; 
   //set the number to echo
[hello sayHello];
return 0;
}
/* To compile in gcc could type:
gcc -x objective-c -Wno-import main.m MyHello.m -lobjc  

You can actually build XCode projects from the command line:
/Developer/usr/bin/xcodebuild -target project
*/

Quiz

Which of the following is true of a phone simulator?

It executes machine code for the target device
It executes machine code for the computer on which you are running it.
It never supports networking.

Objectice-C Types, Foundation Kit

Objective-C was defined before C had a boolean type.
To do booleans in Objective-C you declare a variable to be of type BOOL. This has two values: YES or NO.
We set object pointers to nil rather than NULL, if we haven't declared an object or what to make sure we don't have garbage.
In the Cocoa Touch we will generally have our objects extend at least NSObject which is in the header Foundation/NSObject.h
To get this we will generally import the header Foundation/Foundation.h of the Foundation kit, which also has several other useful classes:
- NSInt - wrapper for an int
- NSString, NSMutableString -- which have a large range of functions for manipulating strings, especially in Unicode.
- NSArray, NSMutableArray -- for arrays
- NSSet, NSMutableSet -- for undordered sets of items
More information about these classes can be found by looking at Help > Documentation and clicking on the Foundation bookmark in XCode.

Reference Counting

In C, we do dynamic memory management with malloc and free.
In Objective-C, a system of reference counting is used.
We already know alloc can be used to allocate memory for our object.

To free up memory associated with our object we should create a dealloc implementation:

-(void)dealloc
{
 /* call release on instance variable; then... */
 [super dealloc];
}

We will almost never directly call dealloc, except as in [super dealloc]...

Instead, we will use the messages retain and release..

[myObj retain]; //increases myObj's reference count by 1.
[myObj release]; // decreases myObj's reference count by 1.

When an object is initially allocated its reference count is set to 1.
If an object's reference count goes to 0, the runtime system will call dealloc for you.

Starting a Second Project

Let's now create a second view-based iPhone app and take a look at some of code files...
Our second application is going to have two buttons which control the content of a label on the screen
iPhone projects often use the MVC (Model View Controller) design pattern.
This pattern makes use of three types of classes:
- Model: The classes that hold your application's data
- View: Made up of window, widgets, etc that the user can see and interact with
- Controller: Binds the models and views together and has the application logic that decides how to handle the user's input.

Objective-C - Towards our Second iPhone App

Outline