View Controllers are responsible for managing the graphical elements (the View) that appear on the screen of the iPhone. The graphical elements that make up the view can be created in Interface Builder (IB) or in code.
Some people prefer to use Interface Builder while others prefer to use code. As the statisticians in my last job used to say,

“Some like to see the pictures and some like to read the book”.

Using IB is like seeing the pictures – you see all the controls in front of you and you can lay them out visually. Writing code is like reading the book – you know precisely what is going on with the controls because you can see all the code that they are using.
Pros, Cons & a Confession
I should say right up front that I do not like Interface Builder. It never really made sense to me and I found it difficult to work with. That being said, many people do like IB because it comes with tools that help you lay out your controls in a pleasing way. You can experiment easily with your UI without constantly rebuilding your project to see the results of your code changes.
At any rate, today I am going to show you how to load a view controller with a label in code. I am hoping to use this as an example for the next few posts that will demonstrate different user controls. In the future I am thinking about comparing and constrasting doing these tasks in IB and in code.
Adding a View Controller & Label in Code
Add a New UIViewController Subclass
From your XCode project, select “File”, “New File…” and then “UIViewController Subclass”. This adds a new UIViewController subclass to your XCode project.
Instantiate a New Object Using initWithNibName
Go to your app delegate’s implementation file (this is the file prefixed with your project name with the words “AppDelegate.m” attached to the end. Type this code into the applicationDidFinishLaunching method to instantiate your view controller and add it’s view to your app window. Don’t forget to import your view controller’s interface file at the top of the file.

#import "TipOfTheWeekAppDelegate.h"
//import your view controller interface file below:
#import "ViewController.h"

//this will reference your project name
@implementation TipOfTheWeekAppDelegate
@synthesize window;
ViewController *vc;

- (void)applicationDidFinishLaunching:(UIApplication *)application {
 vc = [[ViewController alloc]
initWithNibName:nil bundle:nil];

[window makeKeyAndVisible];
}

- (void)dealloc {
 [vc release];

[window release];
[super dealloc];
}

@end

Add Your View Controller Object to the App Window

#import "TipOfTheWeekAppDelegate.h"
//import your view controller interface file below:
#import "ViewController.h"

//this will reference your project name
@implementation TipOfTheWeekAppDelegate
@synthesize window;
ViewController *vc;

- (void)applicationDidFinishLaunching:(UIApplication *)application {
vc = [[ViewController alloc]
initWithNibName:nil bundle:nil];
 [window addSubview:vc.view];

[window makeKeyAndVisible];
}

- (void)dealloc {
[vc release];
[window release];
[super dealloc];
}

@end

Add UI Elements to the View in the View Controller Objects’ loadView Method
To do this step go to your view controller’s implementation file and find the loadView method. Simply add the code here that you need to create your user controls that will appear on the screen. For example, I will add a button to my view controller:

#import "ViewController.h"

@implementation ViewController
UILabel *label;

- (void)loadView{

[super loadView];
 CGRect frame = CGRectMake(10, 10, 300, 300);
label = [[UILabel alloc] initWithFrame:frame];
label.textAlignment = UITextAlignmentCenter;
label.font = [UIFont fontWithName:@"Verdana" size:36];
label.text = @"10";
[self.view addSubview:label];
}
- (void)dealloc {
 [label release];
[super dealloc];
}

@end

So, that is it. It really only takes three steps to create a view controller and then load its view into your app. In the next few posts I am going to build on this example using different user controls.
My Question to YOU:
Do you prefer to use visual tools like Interface Builder or who you rather use code exclusively? Why or why not?

Learn How To Make Your Own iPhone and iPad iOS apps!

If you are completely new to iPhone programming and want to start to developing iPhone apps this ebook will give you everything you need to get started today. You Get the 5 Essential Things You Need to Make iPhone Apps C Procedural Programming Objective-C Object Oriented Programming Cocoa-Touch Model-View-Controller Design Pattern Architecture of Real World iPhone Apps 12 Step App Development Formula

This ebook is much different than the other books out there: it really is a *system* that includes ONLY what you need to know to make iPhone applications. Not only that, but you will get some real insight on how to make a product and how to set up your code in the best way the first time.
Plus, you will get plenty of bonuses including exclusive source code projects. For more information, head on over to the website for the ebook:
Head over to How To Make An iPhone App eBook Website website to find out how to get Matt’s eBook and the bonus source code.

Loops are the gears of programming: they make your code take action.
The two loops I use most often is the for loop (to do a predefined number of steps) and what is usually called a foreach loop (to move though a list of objects).
//This loop simply repeats an action
//a set amount of times:
for (int i=0; i<=3; i++)
NSLog([NSString stringWithFormat:@"i=%i", i]);

//Create an array of strings for the next example:
NSMutableArray *bunchOfThings = [[NSMutableArray alloc] init];
[bunchOfThings addObject:@"Zero"];
[bunchOfThings addObject:@"One"];
[bunchOfThings addObject:@"Two"];
[bunchOfThings addObject:@"Three"];

//This is sometimes called a "for each" loop
//Using this list will repeat actions for each
//object in a list.
//Hint: you can use this for any type of list of
//objects so if you have list of custom defined
//objects this is an easy way to work with them all
//at one time.
for(NSString *s in bunchOfThings)
NSLog([NSString stringWithFormat:@"s=%@", s]);

//The array must be released since it was alloc/init earlier.
[bunchOfThings release];

Learn How To Make Your Own iPhone and iPad iOS apps!

If you are completely new to iPhone programming and want to start to developing iPhone apps this ebook will give you everything you need to get started today. You Get the 5 Essential Things You Need to Make iPhone Apps C Procedural Programming Objective-C Object Oriented Programming Cocoa-Touch Model-View-Controller Design Pattern Architecture of Real World iPhone Apps 12 Step App Development Formula

This ebook is much different than the other books out there: it really is a *system* that includes ONLY what you need to know to make iPhone applications. Not only that, but you will get some real insight on how to make a product and how to set up your code in the best way the first time.
Plus, you will get plenty of bonuses including exclusive source code projects. For more information, head on over to the website for the ebook:
Head over to How To Make An iPhone App eBook Website website to find out how to get Matt’s eBook and the bonus source code.

Have you been wondering how to create a class and use it as an object in Objective-C?
Anyone who is used to object-oriented programming will recognize the pattern demonstrated here. You will learn how to: use properties, allocate and de-allocate objects in memory, use a methods and you will see how to launch the Google Maps app on the iPhone with your address information.
Please note that their are many different ways and some subtleties to implementing a class in Objective-C that will not be discussed here. My goal is to show you the simplest way to get up to speed as soon as possible.
Address Class Introduction
The “Address” class simply stores address information such as street, city and zip code. Address will also return the correctly formated link that Google Maps needs to map the address location. Finally, Address will take the Google link, launch the Google Maps app and drop a pin at the location of the address.
NSObject Subclass
From XCode, select “File” and then “New File…”. You will see a dialog box come that looks like something like this:

Choose NSObject subclass and call it “Address”. XCode will create two files for you: Address.h and Address.m. Classes have two files associated with them: the header file (“h” file extension) and the implementation file (“m” file extension).
The best way to think of the header file is that this is the place were you will define what your class does (but you do not implement anything here). Most of the coding will be done in the “m” file.
Add the Street, City and Zip Properties
In object-oriented programming, classes have properties and methods. Properties describe attributes of the thing represented by the class while methods are the class behaviors. The properties of the Address class are: Street, City, State and Zip – attributes that describe an address.
In Objective-C you must add code in a few places in both the header and implementation files in order to use properties.
In the header file you add code in two places:

In the implementation file you need to “synthesize” the properties using @synthesize. It is also important to add code to release the memory associated with the properties in the class dealloc method.

After you put your code in these four places your properties are ready to be used.

Detour: Using the Address Class Properties in Your Code

Now that you have properties defined in your address class you can use the class to create an object that stores address information. To keep things simple I will add the code right in the app delegate in the applicationDidFinishLaunching method. This is generally the first place you will add code to a new iPhone app.

NOTE: this file is the implementation file for you app delegate. It is usually named something like: “<yourProject>AppDelegate.m”.

First thing I had to do was add a reference to the Address header file I created. This goes at the very top and looks like this:

#import “Address.h”

Now, I simply need to add code to use an address object. The basic pattern is this: allocate memory, create object, use object and de-allocate memory. I will create an Address object, assign address information to it, write out that information to the log and finally I will de-allocate the memory associated with the Address object.

So, that is that – now you can create and use a class in Objective-C. Before we end I want to make this class a little bit more useful by adding a method to create the hyperlink that Google needs to find the address on the map. Then I want give my address objects the ability to launch the Google Map app on the iPhone with the address information contained in the object.
Launch Google Maps from the Address Class
In order to Google Map functionality to the Address class I need to do two things: create a function that will return the address information in string formatted to work with Google Maps and I need to create a method that will take that string and open the Google Maps app.
To create the function I add this to the header file:

and this to the implementation file:

To add the method that opens up the Google Maps app I put this into the header file:

and this into the implementation file:

Conclusion + Where to Get the Files
So, that is it – you now should be able to create your own Objective-C classes to use in your iPhone projects and you have some clues about how to use the Google Maps app. I hope you enjoyed this tutorial. If you have any comments please put them in the form below.
Here is the link to the source code used for this tutorial:
Complete Xcode Project

If you have spent any amount of time learning or working with the iPhone SDK then you are probably getting frustrated with the very wordy (and difficult to remember) nature of the Cocoa framework.  Things that are trivial in environments like .NET or Java can seem awkward and clumsy in Cocoa.
As an example of this wordiness, here is what I do to create a button in code:

 UIButton *button = [UIButton buttonWithType:UIButtonTypeRoundedRect];
button.frame = CGRectZero;
button.contentVerticalAlignment = UIControlContentVerticalAlignmentCenter;
button.contentHorizontalAlignment = UIControlContentHorizontalAlignmentCenter;
[button addTarget:target action:selector forControlEvents:UIControlEventTouchUpInside];
[button setTitleColor:[UIColor blackColor] forState:UIControlStateNormal];
button.backgroundColor = [UIColor clearColor];
button.frame = CGRectMake(10, 10, 100, 50);
[button setTitle:@"Button" forState:UIControlStateNormal];

And here is what I routinely do to use a simple alert box (one line of code in .NET):

 UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Help Message"
message:message
delegate:self
cancelButtonTitle:@"OK"
otherButtonTitles: nil];
[alert show];
[alert release];

To be fair, every programming language has issues like this to some extent and the purpose of this post is not to bash Cocoa.  The purpose of this post is to suggest a way to make your life easier by learning how to reuse your code.
WARNING: There is a 50% chance that what I am about to suggest will deeply offend you!
There are a few different ways to make your code reusable – in object-oriented programming whole books have been written about this.  What I am about to tell may offend both object-oriented purists as well as people who truly love the way Cocoa does things.
My suggestion is to simply pay attention to the code that you are writing over and over again;  then put this code into static functions in a class that you can simply call from any other classes.  Programming veterans will be familiar with this approach (and might as well skip to the code examples at this point).
So, if you put all that wordy code into a static function you can use that code in the future with only one line required to get the same behavior.  This makes your code more readable and will decrease your time coding because you are not re-doing the same thing over and over again.
WHY WOULD SOMETHING SO COOL OFFEND PEOPLE?
This approach is basically creating global functions and sort of steps on the toes of good object-oriented design that insists that objects created from a class that have all the information and behavior required to get by in your program.  Intermixing global functions doesn’t quite fit into this and could lead to the problem of “spaghetti code” if you are not careful or if you are excessive in this approach.
Other people simply believe that the Cocoa way is the best way and that essentially creating your own framework on top of Cocoa some form of denial system.   Like most system design choices there are +/- and you will have to keep your thinking cap on.
HERE IS WHAT I DO
Personally, I use static functions to help me work with using the log since I hate using the NSString stringWithFormat nonsense.  I also use it for alerts and buttons.  In general, I try to keep the global static functions to very general things and keep anything else in the class where it belongs.  For example, all database access functions I put into a SQLite object that just accesses data.
NSLOG EXAMPLE
I use NSLog a lot while debugging code and even though it only requires one line of code I find it awkward to use.  So, I have created three static functions to automate this for me:

+(void) logThis:(NSString *) message;
+(void) logThis:(NSString *) message andThisFloat:(float) number;
+(void) logThis:(NSString *) message andThisObject:(id) object;

This makes it easy to shoot out a message to the log – either by itself, with number value (very common need) or the string value of any object.
Here I will show you the steps required to create these static functions so that you can do for yourself in the future.
First, open up your favorite XCode project and add a NSObject subclass file.  You will have two files (one with a h file extension and one with a m file extension).  You will need to edit both. 
Open the header file (with the h!) and add this code:

#import
@interface ASFunctions : NSObject {
}
+(void) logThis:(NSString *) message;
+(void) logThis:(NSString *) message andThisFloat:(float) number;
+(void) logThis:(NSString *) message andThisObject:(id) object;
@end

Now, add this code to the implementation file (m):

+(void) logThis:(NSString *) message{
NSLog(message);
}

+(void) logThis:(NSString *) message andThisFloat:(float) number{
NSLog([NSString stringWithFormat:@"%@ = %f", message, number]);
}

+(void) logThis:(NSString *) message andThisObject:(id) object{
NSLog([NSString stringWithFormat:@"%@ = %@", message, object]);
}

Put this after the @implementation but before the @end.  Ok, almost done.  In order to use this from another part of the program you must add some code to the file you are working with.  For instance, I am going to add these functions to my app delegate for simplicity.  Add the reference to the header file to the top:

#import "ASFunctions.h"

Now all you need to do is simply call the functions as you need them. Since they are static you do not need to worry about allocating the object. Here is how to use the simplest log function I wrote:

 [ASFunctions logThis:@"Writin' to da log!"];

Using the other functions is similar:

 [ASFunctions logThis:@"Writin' to da log!" andThisFloat:4];

Well, that is it. These examples are almost too simple for this approach but I hope they give you some ideas about the code you would like to put into static functions.
Want some input about the future direction of this blog? Please fill out our survey!
What do YOU think?  What functions make sense to be put into global static functions?  What don’t?  Should everything be object-oriented or what?
Comment below!

In this post I am going to demonstrate how to create a class and use it as an object in Objective-C.  Anyone who is used to object-oriented programming will recognize the pattern demonstrated here.  You will learn how to: use properties, allocate and de-allocate objects in memory, use a methods and you will see how to launch the Google Maps app on the iPhone with your address information.
Please note that their are many different ways and some subtleties to implementing a class in Objective-C that will not be discussed here.  My goal is to show you the simplest way to get up to speed as soon as possible.
Address Class Introduction
The “Address” class simply stores address information such as street, city and zip code.  Address will also return the correctly formated link that Google Maps needs to map the address location.  Finally, Address will take the Google link, launch the Google Maps app and drop a pin at the location of the address.
First Things First
From XCode, select “File” and then “New File…”.  You will see a dialog box come that looks like something like this:

Choose NSObject subclass and call it “Address”.  XCode will create two files for you: Address.h and Address.m.  Classes have two files associated with them: the header file (“h” file extension) and the implementation file (“m” file extension).
The best way to think of the header file is that this is the place were you will define what your class does (but you do not implement anything here).  Most of the coding will be done in the “m” file.
Add the Street, City and Zip Properties
In object-oriented programming, classes have properties and methods.  Properties describe attributes of the thing represented by the class while methods are the class behaviors.  The properties of the Address class are: Street, City, State and Zip – attributes that describe an address.
In Objective-C you must add code in a few places in both the header and implementation files in order to use properties.
In the header file you add code in two places:

In the implementation file you need to “synthesize” the properties using @synthesize.  It is also important to add code to release the memory associated with the properties in the class dealloc method.

After you put your code in these four places your properties are ready to be used.

Detour: Using the Address Class Properties in Your Code

Now that you have properties defined in your address class you can use the class to create an object that stores address information.  To keep things simple I will add the code right in the app delegate in the applicationDidFinishLaunching method.  This is generally the first place you will add code to a new iPhone app.

NOTE: this file is the implementation file for you app delegate.  It is usually named something like: “<yourProject>AppDelegate.m”.

First thing I had to do was add a reference to the Address header file I created.  This goes at the very top and looks like this:

#import “Address.h”

Now, I simply need to add code to use an address object.  The basic pattern is this: allocate memory, create object, use object and de-allocate memory.  I will create an Address object, assign address information to it, write out that information to the log and finally I will de-allocate the memory associated with the Address object.

So, that is that – now you can create and use a class in Objective-C.  Before we end I want to make this class a little bit more useful by adding a method to create the hyperlink that Google needs to find the address on the map.  Then I want give my address objects the ability to launch the Google Map app on the iPhone with the address information contained in the object.
Launch Google Maps from the Address Class
In order to Google Map functionality to the Address class I need to do two things: create a function that will return the address information in string formatted to work with Google Maps and I need to create a method that will take that string and open the Google Maps app.
To create the function I add this to the header file:

and this to the implementation file:

To add the method that opens up the Google Maps app I put this into the header file:

and this into the implementation file:

Conclusion + Where to Get the Files
So, that is it – you now should be able to create your own Objective-C classes to use in your iPhone projects and you have some clues about how to use the Google Maps app.  I hope you enjoyed this tutorial.  If you have any comments please put them in the form below.