With this article I have realized that Programming in Objective-C is very much similar to Java except syntax if considering import of files, getter and setter methods and their return types.

I am trying to create a directory where I want to save the Mobile no and Name of the person and want to same it in the iPhone memry. For this I am using XCode IDE.

Can you please guide me, how can I save data in iPhone memory.

Waiting for your new article on saving data in iPhonr memory.

With regards,

Ankit Thakur

I always use properties (getters and setters) in C# so this definitely helps me understand how to set them up in Obj-C. Same goes for the foreach loop in C# when looping through enumerated objects and seeing how it’s done in Obj-C.

I’m glad to see that Obj-C 2.0 has introduced simpler ways to set properties and iteration loops or I’d have given up. Well, probably not since I love the machine!

Keep ‘em coming!

Using ObjC2 properties forgoes the need to write getter-setter methods entirely:

@interface SomeClass : NSObject
{
NSString *_str;
NSDate *_date;
int _x
}
@property(retain, readwrite) NSString *str;
@property(retain, readwrite) NSDate *date;
@property(assign, readwrite) int x;
:

@implementation SomeClass
@synthesize str = _str;
@synthesize date = _date;
@synthesize x = _x;

In this case the @property declaration, combined with the @synthesize, will automatically generate getter/setter methods for each instance variable — a real time-saver when your class declares a 20 variables (or even if you only declare 1). Since most getter/setter implementations follow the same code template, this can be a nice time saver and leaves the code less cluttered and easier to maintain.

Properties declared with (retain, …) will automatically call [NSObject retain] when a new value is assigned to the instance variable via the synthesized setter, as well as [NSObject release] for the previously assigned object. The “assign” modifier tells the compiler to generate a simple assignment, useful for non-Cocoa variable types, or NSObject references which do not need to be retained. Variables can alternately be declared “readonly”, which generates compiler errors if the code attempts to make an assignment. These are the most common modifiers — the Objective-C 2.0 guide defines others for special cases.

Concurrent with the new property declarations is the change to “.” notation for accessing getter/setting methods.

SomeClass *anInst = [[[SomeClass alloc] init] autorelease];
anInst.str = @”Hello, world!”; // retained
anInst.date = [NSDate date]; // retained
anInst.x = 5; // assigned

The underscore (“_”) notation in the instance variable declarations are optional, but a useful way to distinguish direct variable references from getter/setter references in your code.

@implementation SomeClass
:
- (void) setDefaultX
{
_x = 5; // direct assignment
}

Once you get used to the property syntax, the older form of Objective-C feels clunky.

Fast enumeration is a newer way to iterate through NSArray collections. The traditional way of writing iteration loops is familiar to most Cocoa programmers:

NSArray *aList = [myClass getListOfObjects];
NSEnumerator *anEnum = [aList objectEnumerator];
NSString *aStr = nil;
while (nil != (aStr = [anEnum nextObject])) {…}

With fast enumeration, the same code appears as follows:

NSArray *aList = [myClass getListOfObjects];
for (NSString *aStr in aList) {…}

Not only is it less code, which is always a good thing, but the fast enumeration form allows the compiler to make optimizations in the loop interation that can be several times faster than the older NSEnumerator-based loops.

I find these new features of Objective-C 2.0 to be very handy in writing more compact, readable code, which lets me concentrate more on the logic of my own application, rather than the syntactic overhead of writing classes.

Enjoy!