Objective C 2.0 Basics

Objective C tries to defer as many decisions from compile time and link time to run time as possible. Whenever possible it tries to dynamically perform operations such as creating objects and determining what methods to invoke. Therefore the Objective C language needs not only the compiler but the runtime system to execute compiled code.

A pointer to an object data structure.

nil

The runtime system can find the exact class the object belongs to just by asking the object.

It allows the object to perform introspection.

To find out about oneself.

The programmer is responsible for determining the lifetime of objects.

The programmer passes on the responsibility for determining the lifetime of objects to the "Garbage Collector"

By sending it a "message."

[receiver message];

It tells the myRectangle object to perform its display method which causes the rectangle to display itself.

The method name in a message serves to "select" the method's implementation.

foo:

setXY:: // bad way
setX:y: // good way

Extra arguments are separated by commas.

Example:
[receiver makeGroup:group, memberOne, memberTwo, memberThree];

group here is required.
memberOne, memberTwo, memberThree were optional.

Nothing.

The ability for one object to appear as and be used like another object. For example B implements A. Where A is an abstract class.

The selection of a method's implementation at runtime. When a message is sent, the runtime messaging routine looks at the method named in the message. It locates the receiver's implementation of the method and "calls" the method and passes to it a pointer to the receiver's instance variables.

[myInstance setValue:10]

myInstance.value = 10;

No because y is untyped and z is undeclared.

The same.

The compiler creates just one accessible object for each class, it is called the class object. It knows how to build new objects belonging to the class.

The objects that the "class object" builds.

Each new class you define is based on another class from which it inherits methods and instance variables.

Instance Variables.

NSObject

The parent class.

A child class.

A class that groups methods and instance variables that can be used by a number of different subclasses into a common definition. Objective C does not prevent you from instantiating a abstract class.

isMemberOfClass. It is a method defined by NSObject.

if ([anObject isMemberOfClass: someClass]) { ... }

isKindOfClass. It is a method defined by NSObject.

If ([anObject isKindOfClass: someClass]) { ... }

myRectangle = [[Rectangle alloc] init];

static int *aInt;

+ (int *)myMethod
{
return 1;
}

- (id)init
{
if (self = [super init])
{
...
}
}

Initializes the instance variables of the receiver and returns itself.

@property

@property(attribute1, attribute2, etc...)

getter: foo
setter: setFoo:

@property(getter=gettername, setter=settername) type propertyname;

@property (readonly) type propertyname;

It means code from your app can call the properties getter/setters from multiple threads without fear of a crash or inconsistent value. This usually means that both the getter and setter are synchronized using a locking mechanism.

species the setter to use simple assignment. This is the default.

The previous value is sent a release message(dealloc).

The previous value is sent a release message(dealloc). A copy is made by invoking the copy method.

if a property is @dynamic (the default) you must provide the getter and setter yourself. If you @synthesize a property, the compiler will create them for you.

@dynamic value;

- (NSString *)value
{
return value;
}

- (void)setValue:(NSString *)newValue
{
if (value != newValue)
{
value = [newValue copy];
}
}

Allows you to add methods to existing classes (like prototype in javascript).

No.

Yes.

Class extensions allow you to define additional required API outside of the main @interface block. It is similar to using categories aside from the fact that you don't provide the category name.

It declares methods that can be implemented by any class (interface?).

a directive.

@protocol name
@required
required method declarations here
@optional
optional method declarations here
@end

In a class's declaration inside <> brackets.

Example:
@interface Formatter : NSObject < Formatting, Prettifying >

if (![receiver conformsToProtocol:@protocol(MyProtocolName)])

for (Type newVarName in aCollection)
{
statements.
}

@try, @catch, @throw, @finally

The code inside the @finally block must be executed whether or not the exception was thrown or not.

Yes, each for different exceptions.

NSException *exception = [NSException exceptionWithName:@"HotTeaException"

reason:@"The tea is too hot" userInfo:nil];

@throw exception;

Yes.

It takes in one argument which is a object. The object is now referred to as a mutual exclusion semaphore. The section of code will be locked when it is executing.

@synchronized (self)
{
..critical code here..
}

A protected (by locking) variable that will be accessed by shared resources.

A pattern where one object periodically sends messages to another object specified as its delegate to ask for input or notify the delegate that an event is occuring.

The target-action mechanism enables a control object(button, slider, etc...) in response to a user event to send a message to another object.

A promise to the compiler that a class will be defined somewhere else and that it doesn't need to waste time checking for it now.

@class MyViewController

first you must call alloc then initWithNibName:bundle:

An instance of a variable that connects to a object in a nib file.

One way to create a outlet is to ctrl+mouse drag from the object containing the outlet to the destination object.

IBOutlet

IBAction

textFieldShouldReturn

send resignFirstResponder message

A directory containing code and resources.

They are bundles containing resources built using the interface builder.

Send the classname the alloc message.
[myClass alloc]

- (BOOL)textFieldShouldReturn:(UITextField *)theTextField

UIView *controllersView = [myViewController view];