Kernel Panic » oop

ObjC class

Pelaez — Thu, 04 Jun 2009 22:45:32 +0000

This is a “template” of a very basic ObjC class, with some things explained, you should copy it and paste it into a text editor to see it more clearly.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//This USUALLY goes in a file called myClass.h
#import

@interface myClass:NSObject{ //"myClass" is the name of my class, NSObject is the superclass of my class
//Instance variables (These will be the object's attributes)
//Example:
NSString *string;
}
//property declaration (Tells the compiler how to handle the variable, in this case, it will be read only)
@property(readonly) NSString *string;
//declaration of methods
-(void)init; //Instance methods, you need to call these through an object of this class, notice the '-' sign
+(void)doSomething; //Class methods, you call these directly, not through an object [myClass something], notice the '+' sign
@end //end of the interface declaration

//This USUALLY goes in a file called myClass.m
@implement myClass

//sytnesize tells the compiler to create the getter and setter methods depending on how you declared in @property, in this case it will only create a getter method
//If you want to create the getter and setter methods yourself, you can use @dynamic instead
@synthesize string;
//implementation of declared methods
-(void)init{
//Some code
}
+(void)doSomething{
//some code
}
@end //end of the implementation

ObjC 1

Pelaez — Fri, 29 May 2009 00:13:44 +0000

Personally, I had never used a language with a sintax like ObjC (if there’s another one with the same/similar sintax), so, comming from using C and Java, it was quite confusing.

While ObjC uses C as a core, and accessing properties is quite similar as in other languages (object.property;), methods are a little bit different from other languages I’ve used.

Methods

This is the kind of stuff that confused me the most:

1	[something somethingElse:anotherThing more:Damn];

So yea, it’s kinda like WTF?

Basically, what we are doing here is sending a message called “somethingElse”, with parameters “anotherThing” and “Damn”, to an object called “something”.

So let’s take a look at some actual code, this is the way we call an UIAlertView:

1
2
3

UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Hello" message:@"Hello World" delegate:nil cancelButtonTitle:@"Close" otherButtonTitles:nil];
[alert show];
[alert autorelease];

Should be more understandable:

First, we are creating a new object called “alert”, of the type “UIAlertView”. Then we are initializing it, then showing it, and then tell it to be autoreleased. (Note, nil is ObjC’s null).

What [UIAlertView alloc] does is tell the OS to make some space in the RAM for a new object of the type UIAlertView.

Next, what initWithTitle:@”Hello”… does is initialize the alert with title “Hello”, message “Hello World”, etc. What [alert show] will do is to show the alert, and [alert autorelease] will autorelease when it’s not needed anymore.

If you go to the frameworks and find UIAlert.h, you’ll find that it has a method like this:

1	- (id)initWithTitle:(NSString )title message:(NSString )message delegate:(id /<UIAlertViewDelegate>/)delegate cancelButtonTitle:(NSString )cancelButtonTitle otherButtonTitles:(NSString )otherButtonTitles, ...;

There you can see where everything came from. In C, it would look like:

1	id initWithTitle(NSString title, NSString message, id delegate, NSString cancelButtonTitle, NSString *otherButtonTitles...);

That’s how methods are in ObjC, basically.

Headers

Now, usually, before using an object, you have to set it up for it to work/look as you want, then you use it, and then you release it, for example, we want to add a label that says Hello World in the middle of the screen:

1
2
3
4
5
6
7
8
9

//We init the label with the a frame of 320 by 460, set up in the origin
UILabel *helloLabel = [[UILabel alloc] initWithFrame:CGRectMake(0.0f, 0.0f, 320.0f, 460.0f)];
//Here we set up some properties, like text, textColor and backgroundColor
[helloLabel setText:@"Hello World"];
[helloLabel setTextColor:[UIColor whiteColor]];
[helloLabel setBackgroundColor:[UIColor clearColor]];
//Next we add it to the current view, and then we release it
[self.view addSubview:helloLabel];
[helloLabel release];

Note that we are doing all the changes before adding it to as a subview, otherwise, the user could see as the properties are changing, and see the object being modified. We don’t want that.

Anyway, if you go to UILabel.h and look for “initWithFrame”, “setText”, “setTextColor”, etc., you won’t find those methods.

The first one is a method from UIView. If you don’t find it in the class you are using, it’s in one of it’s superclasses, when UILabel is declared, it’s declared like this: UILabel : UIView. That means it’s a subclass of UIView, and that it inherited some methods and properties of it (you probably knew this already if you had used OOP before).

The other methods are “setters”. If you go to UILabel.h, you’ll see something like: “@property(nonatomic, retain) NSString *text”. That means that ObjC will automatically create a getter method called “getText”, that will return the value of “text”, and a setter method called “setText”, which will take a NSSting as a parameter and will assign that string to “text”. There are other modifiers (besides nonatomic and retain), but I’ll come by them later.

Object Orientated Programming

Pelaez — Thu, 28 May 2009 00:20:45 +0000

I thought it would be important for any readers of this blog (if there are any), to know what Object Orientated Programming is and to know at least the very basic of it.

So here it is, a very quick overview on Object Orientated Programming (OOP)

In OOP, you define classes, which are abstractions of things, for example, an animal class (the most used example in my experience). Classes have attributes and methods, in this case, attributes would be size, color, etc., while methods would be run, jump, eat, etc.

However, “animal” is too abstract, so we could create a dog class that is a subclass of the animal class. It inherits most of the attributes (there are different kind of attributes, private and protected *) and methods from the animal class, but it implements some new ones.

When at runtime, we create objects from those classes, say, an object called “Lassie” that is of the dog kind.

When we create them, we have to set up some of their attributes, for that we use initializers or constructors. In ObjC, they are methods which’s names usually start with “initWith…”. They are usually quite clear of what they require.

*Kinds of attributes :

In ObjC, attributes are, by default, private. If you don’t specify it, other objects can’t access them.

To make them accessible, we use @property and @synthesize/@dynamic on the interface declaration.

There you have a really quick overview on how OOP works.