iPhone Development Tutorials

I changed the color and the size of the labels in the Attributes Inspector. For each text field, I added a default value. This can be added by entering some text in the “Text” field in the Attributes Inspector. Once this is done, save the interface and test the application. You may notice that you can’t get rid of the keyboard once you have finished entering text into a text field. One way of fixing this problem is by adding a big invisible button to the interface which will close the keyboard. When the user taps off the keyboard, the big button will be pressed and the keyboard will disappear.

Drag a Round Rect Button from the library to the view window. Now position and resize the button so it fills the entire interface. The interface should now look like this:

iPhone Development Tutorials

Next, select the big button you just created and click Layout > Send To Back. Now the button will be behind all the other elements in the view. But we can still see it. Fix this by opening the Attributes Inspector with the button selected and change the Alpha value slider to 0.

Select the text box you created for the First Name label and in the Attributes Inspector, open up the capitalize drop down menu and select “Words”. This will cause the iPhone to automatically change the first letter of each word entered in that box to a capital letter. Do the same for the Last Name text box and the Title text box. Lastly, select the Number text box you created and in the Attributes Inspector, open up the Keyboard drop down menu and select “Number Pad”. This will ensure that the user can only enter numbers in this field.

Save your work and continue to the next tutorial where we will start adding some code to get our interface elements working.

1. In XCode, click File > New Project
2. In the left pane of the new window, click Application under the iPhone OS heading
3. In the right pane, click Utility Application and then click the Choose button
4. Name the project “Story Time” and click Save.

The Utility Application template we chose this time, sets up a nice flipping function for us. This means we can flip between two different views. Have a look at your new project window. You will notice that in the left pane, we have folder for the main view and a folder for the flipside view. Each of these folders contains some basic classes already set up for us. Now click on the Resources folder. You should see an interface file (.xib) for both the main view and the flipside view. Click “Build and Go” to test it out. Once the simulator is running, you can click the “i” icon at the bottom of the screen to flip over to the other view, then click the “Done” button to flip back. Cool huh?

On a side note, you should have updated to the latest version of the iPhone SDK for iPhone 3.0. If you have not done this, make sure you do before continuing.

Back in XCode, open MainView.xib in the Resources folder. This will open the interface builder ready to edit the main view. You will notice that the “i” icon is already there and set up for you. We will leave this where it is for this tutorial. At the end of this set of tutorials, we will have created a story-telling app which displays a story that the user can edit.

In Interface Builder, click the background and change it’s color to white in the Attributes Inspector. You may notice that it is now hard to see the “i” icon. Let’s change that: select the icon then in the Attributes Inspector, change its “Type” from “Info Light” to “Info Dark”. Now grab the Text View item from the library and drag it onto your View. Resize it so it fills up most of the view. This will be our story. Drag a label item from the library and position it above the text we just added. This will be the title of the story. Resize and position it however you want. Here is how mine looks:

Save this interface and click “Build and Go” in XCode to try it out. Notice that it automatically scrolls the text when you flick it – no coding required! Clicking the “i” icon flips to the other view seamlessly. In the other view, we will add some input boxes to change the story. We will be adding these in the next tutorial. Remember to save your work before proceeding.

#import <UIKit/UIKit.h>
 
@interface HelloiPhoneViewController : UIViewController {
	IBOutlet UILabel *sliderValue;
}
 
@property (nonatomic, retain) UILabel *sliderValue;
 
-(IBAction) sliderChanged: (id) s;
-(IBAction) goButton;
 
@end

So what have we done? We have created an outlet called sliderValue. Outlets send data back to the interface. In this case, we will be sending the value of the slider to the label we created. We also added the @property function to help us retrieve and set the value of sliderValue (our label). Remember that @ property and @synthesize work together to simulate getter and setter methods. For now, ignore “(nonatomic, retain)” you don’t need to know about this yet.
Then we create a new method that will be called sliderChanged that will be run whenever the user interacts with the slider. Notice that we have told this method to accept an argument that it will store in the variable “s”. The variable type is “id” – this is a generic variable so it can accept any variable type. If we had used “int” instead it would have only been able to accept integer variables.

With that done, time to move over to the implementation file. Save “HelloiPhoneViewController.h” and open “HelloiPhoneViewController.m”. First of all we need to synthesize the sliderValue variable. so add this line after the “@implementation” line:

@synthesize sliderValue;

Now lets add the “sliderChanged” method below:

-(IBAction)sliderChanged: (id) s {
	UISlider *slider = (UISlider *) s;
	float sliderPosition = (slider.value);
	NSString *text = [[NSString alloc] initWithFormat: @"%0.1f", sliderPosition];
	sliderValue.text = text;
	[text release];
}

Let’s have a look at what we did here.

UISlider *slider = (UISlider *) s;

Here we created a new UISlider object from Apple’s UISlider class and called it “slider”. We then told it to store the slider that is passed into the method. (that would be the slider we created in the previous tutorial.)

float sliderPosition = (slider.value);

Here we created a float variable called sliderPosition. Float stands for “Floating-point” and it’s a type of variable that holds digits just like the int variable does – however, a float variable can store a decimal point whereas an int can’t. If you tried to store the number “27.8″ in an int variable, the decimal would be cut off and it would return “27″. Note that it doesn’t round the number up or down, it just cuts the decimal places off. There are many types of variable that you will learn about as we go.
We then store the value of our slider in the variable.

NSString *text = [[NSString alloc] initWithFormat: @"%0.1f", sliderPosition];

Now we create a new object called “text”. This is an NSString object. It is used to store strings (text) because there isn’t a variable type in Objective-C that does this. We then initialize it and use “%f” to tell it to store the sliderPosition float after the comma. However, by inserting “0.1″ before the “f”, we are telling it to only store one decimal place. You may remember doing something like this when printing using the NSLog method.

sliderValue.text = text;
[text release];

Then we pass the nicely formatted NSString object to our label using “sliderValue.text” and release the “text” object from memory.

Make sure you understand what we have done here before you move on.
Save “HelloiPhoneViewController.m” and return to the project window. Click the Resources folder and double-click the “HelloiPhoneViewController.xib” file to open the Interface Builder.
Now let’s connect up the slider and the label with the code we just wrote. Click the slider you placed on your interface to select it and open the Connections Inspector. (Tools > Connections Inspector)
Now grab the circle next to “Value Changed” and drag a line over to the “Files Owner” icon. In the menu that pops up, click the “sliderChanged:” option. This is the same thing we did with the button in the last tutorial, but now we are using our “sliderChanged” method. Now the slider will change the value of “sliderValue” but we want this value to appear in the label below. Here is how to do that:
Hold down the control(⌃) key on the keyboard and drag a line from the “File Owner” icon to the “0.5″ label you added last time. A menu should pop up with two options (sliderValue and view). Click sliderValue and hey presto, the label will now update every time the slider is moved. Save the file and test it out! Dragging the slider to the left should cycle the number down to 0 and the the right should cycle it up to 1.

Great work! Save the project and proceed to the next tutorial.

Today we will start by adding a button to our interface. So click the Resources folder in the project window and double click “HelloiPhoneViewController.xib” to open the Interface Builder. We already have a label set up, so let’s add a button below it. In Interface Builder, select “Round Rect Button” in the Library window and drag it onto your view just below the label we created. Double click on your new button and type in “GO”. Feel free to move or resize the button however you want. You can resize using the blue dots when the button is selected. When you are happy with your button, proceed to the next step.

We have a button now, but it doesn’t do anything yet. Let’s add a slider and then we can add functionality to them later. Drag a “Silder” from the Library window to your view somewhere below the button. Resize it to fill the width of the view. Now drag another “Label” from the Library and place it below the slider. This label will change when the slider is moved with the help of some code. Change the label to say “0.5″. When the slider is to the left, we will set the slider label to 0 and set it to 1 when it is to the right. Since we are initializing the slider in the middle, the label should initially read 0.5. Highlight the new label and set the alignment to the center. This can be done in the Attributes Inspector. Your interface should now look something like this:

Let’s add some functionality to our interface.

Save your interface in Interface Builder by clicking File > Save. Now switch back to XCode and open “HelloiPhoneViewController.h” for editing. It is located in the Classes folder.
By now you should understand how to create a basic Objective-C application. If you don’t please read through the previous tutorials. Edit “HelloiPhoneViewController.h” to look like this:

#import <UIKit/UIKit.h>
 
@interface HelloiPhoneViewController : UIViewController {
 
}
 
-(IBAction) goButton;
 
@end

We have created a new method called goButton. But notice that instead of using “void”, we used “IBAction”. This is simply telling the compiler that we are returning an Interface Builder action. We will run the goButton method whenever the GO button we created is tapped.
Save the file and open “HelloiPhoneViewController.m” to fill out the method we created. You may notice that there is already some methods defined, some of them commented out. Leave them as they are for now, and add the following code for the goButton method:

-(IBAction) goButton {
	UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Button Pressed" 
	message:@"You pressed the GO button!"
	delegate:nil
	cancelButtonTitle:@"OK"
	otherButtonTitles:nil];
	[alert show];
	[alert release];
}

Lets look at what we did here:

UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Button Pressed"

In this line we created an object called “alert” from the UIAlertView class. (this is a class that apple have written for us to handle alerts.) We then allocated a space in the memory for it using alloc and then initialized it with the title “Button Pressed”.

message:@"You pressed the GO button!"

This line set the message that we will display to the user in the alert.

delegate:nil
cancelButtonTitle:@"OK"
otherButtonTitles:nil];

We then used cancelButtonTitle to create a button on the alert box and set the button’s text to “OK”. We used a Cancel button because it will simply remove the alert box from the screen when pressed. OtherButtonTitles is set to nil because we dont want any more buttons in the alert box. You don’t have to worry about the delegate setting for now.

[alert show];
[alert release];

Then we ran a method from the UIAlertView class called “show” which shows the alert to the user, then we released the alert object from the memory. Memory management is important. Everything you load into memory should be removed when finished with. The iPhone only has a limited amount of memory available, so you have to use it wisely.
Make sure you understand what we did, and save the file.

Now we have the alert set up, let’s link the GO button to the goButton method so the alert is activated when the button is tapped. Switch back to Interface Builder. Click the GO button in your view window. Now open the Connections Inspector. This can be done by clicking Tools > Connections Inspector. Notice that the Connections Inspector uses the same window as the Attributes Inspector. They can be switched between using the tabs at the top of the window or by using the keyboard shortcuts.

In the Connections Inspector you will notice a list of actions that can be performed on the button. The one we want to use is “Touch Up Inside”. This means when the user’s finger leaves the button. Drag a line from the circle next to “Touch Up Inside” over to the “File’s Owner” icon in the HelloiPhoneViewController.xib window. Release the mouse and a menu should pop up with our goButton method listed. Click it to assign that method to the button’s action. The Connections Inspector should now have the goButton method listed under the “Touch Up Inside” event. Save the interface and switch back to XCode.

Great! Now we have created a button, created a method that will be run when the button is tapped and connected the two together! That wasn’t too hard was it? Now click Build and Run to test it out! Clicking the button will show the alert we created, but moving the slider won’t do much. We will add some functionality to the slider in the next tutorial.

The simple answer is you can’t. Not at the moment anyway, and there aren’t any signs on the horizon either. You wouldn’t expect Microsoft to allow Mac users to develop XNA games on the Mac would you? Of course, it would be nice. As a primary Windows user myself, I would rather be creating developing iPhone applications in the familiar Windows environment, but it’s just one of those things.

However, don’t be put off by the price of a Mac. The Mac Mini may not be as powerful the iMac or Mac Pro, but its cheap and you dont need much power if you are developing iPhone applications. A Mac Mini has more than enough horse-power for that. On top of that the iPhone SDK (software development kit) is absolutely free!

1. In XCode, click File > New Project
2. In the left pane of the new window, click Application under the iPhone OS heading
3. In the right pane, click View Based Application and then click the Choose button
4. Name the project “HelloiPhone” and click Save

You will notice that there are a few folders set up for you in the left pane of the project window. For now you don’t need to know what all the files in each folder do.
Click Build and Go. A new application will open called iPhone Simulator, and in it comes a nice shiny iPhone for you to play with. This is where you can test your applications. As soon as it loads, it will boot up the application that you just created. You haven’t done anything to it yet so it is just a gray screen. Press the home button (the square symbol at the bottom) to exit the application. Go ahead and play around with it – use it just like a real iphone but use your mouse to control it instead. Try clicking Hardware > Rotate Left or Right to flip the iPhone on it’s side.

There are some things that the iPhone simulator can’t do. It doesn’t include things like GPS to find it’s location or an accelerometer to detect movement or tilting. You also cant use multi-touch as you only have one mouse. For these things you will need to test on a real iPhone. However, you are only allowed to use a real iPhone if you have paid for and been accepted to Apple’s Standard Developer Program or higher. But for learning the basics, the simulator is fine.

Quit the simulator when you are done and return to XCode.

In the left pane of the project window, click the Resources folder and in the right pane, double-click “HelloiPhoneViewController.xib”. Another new application will open. This application is called Interface Builder and it is what we will use to design and lay out our interfaces. When developing iPhone applications, the three applications: XCode, Interface Builder and iPhone Simulator work together to help you easily and efficiently create iPhone applications.

When Interface Builder is open, you should be presented with three windows. One named after the file we just opened, one called View and one called Library. For now, let’s just worry about the View and Library windows. The view window represents your application interface. At the moment it is gray, just as you saw it on the iPhone Simulator. The library contains all the interface elements that Apple have designed for you.

Let’s go ahead and make our interface less boring. In the Library window, scroll down to Label, then drag and drop it into the View window. It is all pretty intuitive. Double click the text once it is in the View and change it to say: “Hello iPhone!”. Press the Enter or Return key to confirm. Now let’s say we want the text to be a little bit bigger and white. No problem. In the menu bar, click Tools > Attribute Inspector. This will open a fourth window. Using the Attribute Inspector window, you can edit the appearance of elements.

With the text label still selected, change the Font Size value in the Attribute inspector to 25. You may notice that some of the text was cut off when it got bigger. So just grab one of the blue corner dots surrounding the text and drag it to make the Label big enough to display all the text.

In the Attribute Inspector, click the Text color box (black at the moment) and in the Colors window that appears, click the top (white) area of the vertical slider. Close the Color window and the Attribute Inspector. Now click and drag the Label in the View window to position it nicely in the middle. There! All done! Let’s go ahead and test our first iPhone application!

Click File > Save to save the interface file, then switch back to XCode and click Build and Go to test it in the iPhone simulator.

Great stuff! We did all that without having to enter a single line of code! Why don’t you switch back to the Interface Inspector and play around with the Attributes Inspector to change the appearance of the Label we created. In the next tutorial we will be trying out some of the other iPhone interface elements from the Library. Click here to head there now.

Ok, now we have two classes in our project. “Television” and “MutableTelevision”. The Television class does the basic things that we would expect a television to do. But what if we want a class that does all that but has extra features? We could write all the methods again for the new class, but an easier option would be to use inheritance and make MutableTelevision a child of Television.

Open “MutableTelevision.h” and let’s start creating the interface file. Edit it to look like this:

#import <Cocoa/Cocoa.h>
#import "Television.h"
 
@interface MutableTelevision : Television
 
-(void) mute;
 
@end

Let’s look at what we did. First, as always, we tell the compiler that we are creating an interface file, then we name it. But then we tell it that the Television class is the parent of this class by using the : operator. Notice that you need to import the parent class. Look at “Telelvision.h” again – you will notice that we seem to have inherited a class called NSObject. We didn’t create that class, it is already set up for us by Apple. You don’t need to understand everything this class does, but we have used one of it’s methods before. The NSLog method for printing text to the console is simply a method from the NSObject class.

Another name for parent and child classes is superclasses and subclasses. They mean the same thing – but it is useful to know both terms. So, we know that MutableTelevision is a child (or subclass) of Television, and Television is a child (or subclass) of NSObject. Even though MutableTelevision does not directly inherit NSObject, it inherits everything in the Television class including it’s parent class (or superclass), NSObject. We did not define any instance variables because the channel variable is already inherited from Television.

Once you understand this, save “MutableTelevision.h” and open “MutableTelevision.m” to fill out that mute method. Edit the file to look like this:

#import "MutableTelevision.h"
 
 
@implementation MutableTelevision
 
-(void) mute {
 
	NSLog(@"The TV is now on mute.");
}
 
@end

A very simple method here that just prints a message to the console. Save and close “MutableTelevision.h”, then open “Objects Intro.m”. Edit it to look like this:

#import <Foundation/Foundation.h>
#import "MutableTelevision.h"
 
int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	int chanChange;
 
	MutableTelevision *myTV = [[MutableTelevision alloc] init];
 
	NSLog(@"Type in the channel number:");
	scanf("%i", &chanChange);
 
	[myTV changeChannel: chanChange];
	[myTV mute];
 
    [myTV release];
    [pool drain];
    return 0;
}

The main changes here are the import statements importing “MutableTelevision.h” instead of “Television.h” and the creation of the MutableTelevision object. Notice that we are still using the name myTV as the object name, except now the object is created by the MutableTelevision class rather than the Television class. Run the program to test it out with the new mute method. You may notice that the changeChannel method worked even though we didn’t define it in “MutableTelevision”. This is because MutableTelevision has inherited all the methods and variables from the Television class. If we tried to use the mute method with a Television object however, it wouldn’t work because there is no mute method in the Television class or in any class above it in the hierarchy.

We still have a lot to learn about Objective-C, but you are probably hoping to start working with the iPhone interface. So in our next tutorials I will introduce development in the iPhone environment while introducing more Objective-C concepts as we go. Play around with what you have learned so far.

When you are ready, move on to the next tutorial.

Once you have done that, open “Objects Intro.m” and edit it to look like this:

#import <Foundation/Foundation.h>
#import "Television.h"
 
int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	int chanChange;
 
	Television *myTV = [[Television alloc] init];
 
	NSLog(@"Type in the channel number:");
	scanf("%i", &chanChange);
 
	[myTV changeChannel: chanChange];
	[myTV watch];
 
    [myTV release];
    [pool drain];
    return 0;
}

Let’s look at what we did. First we created an integer variable called “chanChange”. Then we asked the user to enter a number. The scanf function is used to accept user input from the console. So we tell scanf that we are expecting an integer using “%i” and then specify the variable to store it in: “&changeChan”. Then as before, we call the “changeChannel” method and pass the “chanChange” variable into it. The “watch” method is then called to print out whatever channel number the user entered.

Easy huh? Now let’s say that the television only has 10 channels. If the user enters a channel number higher than 10, we want to tell them that the channel doesn’t exist. Save “Objects Intro.m” and open “Television.m”. Edit the “changeChannel” method to look like this:

-(void) changeChannel: (int) c {
 
	if (c > 10) {
		channel = c;
		NSLog(@"You are watching channel %i", channel);
	} else {
		NSLog(@"Sorry, this channel doesn't exist.");
	}
}

If you have used programming languages before, you will probably recognize the if statement. What we have said here is: “if the channel number (c) is greater than 10, change the channel to that number and print a confirmation message, otherwise (else) print an error message.” So if the condition within the brackets is met, the statements within the following curly brackets are executed. If the condition is not met, the statements after “else” are executed. Make sure you understand this before we move on.

Now that the “changeChannel” method does what the “watch” method already did, we have no need for the “watch” method any more. So go ahead and delete the entire “watch” method. Once this is done you should only have two methods left. “turnOff” and “changeChannel”. Save “Television.m” and open “Television.h”. Now go ahead and delete the line that declares the “watch” method here too – otherwise the compiler will throw an error. Save “Television.h” and open “Objects Intro.m”.

Delete the following line from “Objects Intro.m”:

[myTV watch];

Now save and run your program. After being asked to type in the channel number, type in a number from 1 to 10 and press Enter or Return. If everything went well, it should then print out the confirmation statement you wrote. Now run the program again and enter a number higher than 10.

Great work! Save the project and proceed to the next tutorial.

If you remember, last time we created the Television class which we used to create a Television object which could print out two different statements. Today we will add a new method that will change the channel of the television. To do this the television needs to be able to store some data. Let’s go ahead and create a space to store that data now. Open “Television.h” and edit the empty brackets to look like this:

@interface Television : NSObject {
	int channel;
}

We have now got an instance variable in which to store the channel number. An instance variable is data held by an object. For example, if we created two Television objects from the Television class, we could set the channel number of myTV1 to 3, and the channel number of myTV2 to 7. Both Televisions are produced by the Television class, but each can store their own data. But how do we change the channel? This is where Accessor Methods come in.

Accessor methods (otherwise known as Getter and Setter methods) are used to modify the variables held by an object. It may be hard to get your head round how they work at the moment – but stick with me – the more we use them, the more you will understand them.

In some programming languages, you have to write your accessor methods yourself – but in Objective-C, they can be generated automatically by using @property and @synthesize. Let’s not worry about what these do for the moment – just know that @property belongs in the interface file and @synthesize belongs in the implementation file. Together, they can be used to modify your instance variables. Let’s add them now. Add the @property statement to “Television.h” so it looks like this:

#import <Cocoa/Cocoa.h>
 
 
@interface Television : NSObject {
	int channel;
}
 
@property int channel;
 
-(void) watch;
-(void) turnOff;
 
@end

When using the @ property statement, you must tell the compiler what type of variable it is and the name of the variable(s) to be changed. Now the channel variable can be modified, we need a method that we will use to modify it. Let’s call that method changeChannel. So add this line below the turnOff method:

-(void) changeChannel: (int) c;

You may notice that this method declaration looks a little different to the others. This is because it takes an argument. By doing this we can pass a variable into the method when we invoke (or call) it. So this method takes an integer variable which is temporarily named “c”. This will become clearer as we continue with this tutorial.

We are finished with the interface file for now, so save it and open “Television.m” (the implementation file) to flesh out that new method.
Wait. Before we touch the changeChannel method, we need to add the @synthesizer statement so we can change that channel variable in the interface file. Add the following line below @implementation Television:

@synthesize channel;

Great. With that done, we can start editing the changeChannel method. Add the following method below the other two:

-(void) changeChannel: (int) c {
	channel = c;
 
}

That was pretty easy right? Any variable passed into that method will be stored in “c” – then we set the value of the “channel” instance variable to the integer stored in “c”. Now our television can change channel! But wait! How are we going to know what channel we are watching if it’s not a real TV? Change the “watch” method so it looks like this:

-(void) watch {
	NSLog(@"You are watching channel %i", channel);
}

Simple we just altered the output of the watch method so it tells us what channel we are currently watching. We are now ready to use our TV. Save and close “Television.m” and open “Objects Intro.m”. Edit the file to look like this:

#import <Foundation/Foundation.h>
#import "Television.h"
 
int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
	Television *myTV = [[Television alloc] init];
 
	[myTV changeChannel: 4];
	[myTV watch];
 
    [myTV release];
    [pool drain];
    return 0;
}

All we did is call the method “changeChannel” with 4 as an argument (remember, we are passing the number 4 into the method), and then we called the “watch” method to display the value of channel. Save and run the program to see the result. (remember to open the console using Run > Console).

“channel” is now a property of the television object. We can access properties like this: object.property

Delete this line:

[myTV watch];

and replace it with this line:

NSLog(@"You are watching channel %i", myTV.channel);

Now run the program again. The same result! myTV.channel gets the value of “channel” from your myTV object. You can even set the value of properties this way. Delete this line:

[myTV changeChannel: 4];

and replace it with this line:

myTV.channel = 7;

Now build and run again. This does exactly the same function as the changeChannel method does, but with much less code! It is still important that we wrote the changeChannel method though – to show you how to pass variables into a method. We could delete changeChannel now, but we will leave it as we will be modifying it in an upcoming tutorial.

Once you are confident that you understand what we have done today, head over to the next tutorial now.
Remember, if you spot any mistakes PLEASE point them out to me. Thanks.

Let’s start by creating a new project in XCode. Fire up XCode and follow these steps:

1. In XCode, click File > New Project
2. Choose Command Line Utility > Foundation Tool
3. Name the project “Objects Intro” and save it.

In the project window, click the Source folder in the left-hand pane to view your source files. You should have one called “Objects Intro.m” and one called “Objects Intro_Prefix.pch” (which you can ignore for now.)

Object oriented programming languages are based around the use of objects. Objects can represent real life objects (like a chair or a car), or can be more abstract. Objects can hold variables, change variables and pass information between each other. This makes the development of complex applications much more simple. You will understand them more as we continue. Let’s make an object right now!
 

1. In your project, click File > New File
2. Click Cocoa in the left pane and select Objective-C class from the right pane. Click the Next button to continue.
3. In the next window, name your file: “Television.m” (without quotes) and make sure “Also create Television.h” is checked.
4. Click the finish button.

Great! You should have two more files in your source folder now: “Television.m” and “Television.h”. We just created a Television object right? Wrong. What we have created is a Television Class. A class is a collection of variables and methods that all work together. Methods are instructions to the computer to do something. In the previous tutorials, we created the Hello World method which told the computer to print some text and add some numbers together. However, that method wasn’t really part of a class.

In object oriented programming, objects are instances of classes. What we will do next is create the Television class that we can use to create a Television object. Why did we create two new files? Well the ‘.h’ header file (or interface file) is basically a plan of how the class will look. The ‘.m’ method file (or implementation file) is where most of our code will go. Imagine the interface file as the outline of a drawing and the implementation file as the details and colors of the drawing. Let’s go ahead and fill these files out – starting with the interface file:

Double click “Television.h” to open it for editing.

Edit the file to look like this:

#import <Cocoa/Cocoa.h>
 
@interface Television : NSObject {
}
 
-(void) watch;
-(void) turnOff;
 
@end

Ok, save the file and let’s have a look at what we did.
First, we used @interface to tell the compiler what kind of file we were creating. Then we told it the name of the class is Television. We can ignore : NSObject for now. Next, we created two methods. One called “watch” and one called “turnOff”. (void) means no values are returned from the method. We will learn about returning values later. @end ends the interface file.

Did you notice that “watch” and “turnOff” are things we would typically do to a real-life television? What else could you do? Have a think. We could have created methods for everything that we do to a TV, but to keep it simple I chose just to use watch and turn off for now.
Now that we have created a plan for the Television class, we need to tell it what to do! Close Television.h and open Television.m.
Now edit Television.m to look like this:

#import "Television.h"
 
@implementation Television
 
-(void) watch {
	NSLog(@"You are watching the TV");
}
 
-(void) turnOff {
	NSLog(@"The TV is now off.");
 
}
 
@end

Let’s have a look at what we did. We used the #import function to import our Television.h file. Then we started the implementation file with @implementation Television. Do you remember the two methods we created in the interface file? Well in the implementation file we are telling them what to do! First we tell the “watch” method to print out that we are watching the TV. Next, we tell the turnOff method to print out a message confirming that the TV is off.

Great! Now our TV class is ready to be made into an object so we can use it! Save and close Television.m and open “Objects Intro.m”. You may notice that this file is identical to the Hello World file from the first tutorials. Remove the // insert code here and NSLog(@"Hello, World!"); lines and add the following line in their place:

Television *myTV = [[Television alloc] init];

You just created a Television object! An object is an instance of a class. We called our Television object “myTV”. [Television alloc] init]; This part of the line allocates some memory to store the object in and initializes it. Don’t worry too much about this yet. Now we have a Television object ready to use, let’s do something with it! But what can we do? Well, we have already defined what it can do with the watch and turnOff methods. Let’s watch it first! Add the following lines below the last one we typed:

[myTV watch];
[myTV release];

Add the following line at the top, under the first import statement:

#import "Television.h"

Always remember to import the header files of the classes you use. Now, save and run the program! Remember to open the console by clicking Run > Console.
If all went well, your program should have printed: “You are watching the TV”. Let’s look at that code we just wrote. [myTV watch]; called the watch method from your TV object and ran the code in that method! The second line: [myTV release]; calls a method that we didn’t create. We will learn about this later – but for now you just need to know that release clears that object from memory. You must always clear anything you use from memory when you are finished with it.

Why don’t we test the other method now? Change [myTV watch]; to [myTV turnOff];
If that method worked, it should have printed “The TV is now off.” Great! If you had left [myTV watch]; and added [myTV turnOff]; both lines of text would have been printed to the console.

So what did we do today? We created a class called Television and gave it two methods. Then we created a Television object (or instance of the Television class) and called the methods we created. Then using release, we removed the Television object from memory.
Go through each file we created and add some comments explaining what is happening.

In the next tutorial, we will be giving the Television class some properties, so remember to save your project.