This set of blog posts is more for my own memory than anything else. I’m playing with iPhone development and wanted to draw similarities as-well as write down things I learn whilst getting to grasp with Objective-C.
So here we go. Let’s start at the beginning by looking at some core differences between the 2. The order might be a bit rambling but that’s just me writing stuff down that drops into my head! Soon I’ll try get onto the more visual aspects of iphone development but I think it’s essential to get your head around how to structure objective-c code before diving into guis.
For the record I learnt a lot from Dr Google, and this website was especially good: http://www.otierney.net/objective-c.html
1. Almost everything is a pointer.
To ‘create’ an instance of an object in Objective-C we tend to have 2 choices. The first involves ‘allocating’ memory for the object then ‘initialising’ it in some way. The 2nd involves calling a factory (think static) method on a class.
Whichever we do what we end up with is a pointer to an object. In Objective-C we must explicitly show this by using the * character. So to create an NSString object (a fairly core object) we can say:
NSString* myString = [NSString alloc];
more on the syntax in a minute.
To create the string object with a value:
NSString* myString = [[NSString alloc] initWithString: @”Hello” ];
Or you can say:
NSString* myString = [NSString stringWithString: @”Hello”];
The 1st two use instance methods on the NSString to initialize it. The 2nd uses a factory method to create the string. The main difference between the 2 is that by explicitly allocating the string (the 1st way) you are responsible for releasing the memory. With the 2nd way you aren’t. I’ll leave the specifics for another post as it deserves more time!
2. Calling a method on an object.
In C# / Java this is done via the dot (.) notation. So to call method Foo on object bar we say bar.Foo(). If we want to pass parameters to this method call we put them inside the parenthesis. So bar.Foo(someParameter);
Objective-C talks in terms of messages instead of method calls but for this example lets think of them as the same sort of idea. There are reasons for this as we’ll see soon. The syntax is weird at first sight -
means the same as bar.Foo(); in C# and
[bar foo: someParameter]
is the equivalent of bar.Foo(someParameter);
As you can see Objective-C looks a bit confusing at 1st sight especially if you’ve used C# Attributes before which use a square bracket notation.
3. Declaring a method on an object.
Objective-C uses Interface (header) files to declare members, methods, properties etc. that will appear in the class body. So you have 2 files. A .h and a .m file.
To declare a method we must add its signature to the .h file, and the contents of it to the .m file. Using the Foo.Bar(someParameter method) we end up with:
- [void] Bar: (NSString*) theParameter
- (void) Bar: (NSString*) theParameter
In a nutshell
the minus sign denotes an instance method rather than a class (static) method which would use a + sign.
[void] is the return value. In this case my method returns nothing.
Bar is the name of the method (followed by colon if there are parameters).
Then come the parameters. In this case I’m asking for an NSString* where the * means a pointer. Objective-C pretty much uses pointers for everything other than primitive values (int, float, etc). So-far (heh heh caveat alert) I haven’t seen a pointer being de-referenced explicitly as in C++.
To send multiple parameters is a bit weird:
- (void) setLatitude: (int) latitude andLongitude: (int) longitude
This method requires 2 integers. ‘latitude’ and ‘longitude’. To call this method we’d write:
[myFoo setLatitude: 98 andLongitude: 50];
Looks a bit bizarre huh?!
OK that’s enough for today. Next time I’ll try write about some other fundamentals – especially memory management (iphone’s version of Objective-C doesn’t have Garbage Collection).