When defining a category you must import the class’s interface file.

One mention goes to package which cares about how many bits your platform has. google for this (search box available above)

Default return type is id.

class MyClass extends BaseClass implements Comma,Separated,List,OfInterfaces {
  //fields and constants
  private String name;

  //method definitions
  public String getName(){
    return this.name;
  }
}

#import “BaseClass.h”
@Class AClassThatsBeingMentioned, AnotherClassLikeThat;

@interface MyClass : BaseClass <Protocol1, Protocol2>
{
  //instance variables
  NSNumber *number;
}

//method declarations
- (void) printThatNumber();
@end

//and then don’t forget the implementation

#import “MyClass.h”

@implementation MyClass
//method definitions
- (void) printThatNumber(){
  //can you figure this one out?
}
@end

Still: @Class is used when no instances are created / used in your implementation but rather parameter names are of that particular type. Is is simply a low-weight #import.

interface A extends AnotherInterface, YetAnotherInterface{
  void foo();
  void foo2();
  [...]
}

@Protocol A <AnotherProtocol, YetAnotherProtocol>

//required by default
- (void) fooBar;

@optional
- (void) foo;
- (void) foo2;
@required
- (void) bar;
- (void) bar2;

@end

Can incorporate another protocol just like Interfaces can extend other interfaces.

Methods are @required (by default) or @optional. Use these to group the mandatory and the optional methods or your interface protocol.

You can declare objects that adopt a protocol:
id <MyProtocol> myObject;

And last, you can forward reference a protocol:
@protocol ForwardProtocol;
@protocol MyProtocol
- foo(id <ForwardProtocol> myObject);
@end
Confused? It’s okay, you’ll never use this anyway. (Unless you don’t have a Java shaped brain of course but an objc one.)

or for non static typing:
id myObject = [[MyClass alloc] init];

and for static fields
static {
}

/* Honestly, when did you last use this rather than a constructor with arguments? */

and for Class initialization

+ (void) initialize;

The runtime will call initialize before using a class object. I am a little bit confused myself but I believe them.

unless I am wrong of course.

isMemberOfClass – actual class
isKindOfClass – is or inherits from (instanceof)
respondsToSelector – implements method
conformsToProtocol – implements (“conforms” to protocol)

Responds to selector means that the method exists in the class passed as argument while conforms to protocol means that ALL the methods in the protocol. I suspect that a YES response is returned if the methods defined by the protocol exist in the type passed as argument even if the type does not conform to the protocol.

@try; @catch; @finally and @throw are the keywords.

Once an exception is caught it can be re-thrown by using @throw without having to specify the argument.

Invoking non-existent methods. Say they have been deprecated and removed from the API.

- (void) forwardInvocation: (NSInvocation *) theInvocation {
  if ([delegateObject respondsToSelector: [theInvocation selector]]){
    [theInvocation invokeWithTarget:delegateObject];
  } else {
    [super forwardInvocation:theInvocation];
  }
}

Here’s what just happened: a method that does not exist on our “self” was called and the runtime forwarded the call to the method I wrote above. It could’ve freaked out but it didn’t, it kept its calm and got my kudos. The original call message is obviously wrapped inside the NSInvocation. Brilliant!

Note: the NSObject’s forwardInvocation doesn’t do much. Soz.

Can replace @deprecated, multiple inheritance (I can almost hear your cry), surrogate objects, proxies, delegates and more. It is up to you to confuse the crap out of all those that try to steal your job.

Piece of advice: consider overriding respondsToSelector, isKindOfClass, etc to make it look like your surrogate objects actually belong in the type hierarchy. That will simply make you irreplaceable.

Type qualifiers:
- oneway – to specify that the call is asynchronous
- in – the relevant data is being passed in the message
- out – the argument is used to return info by reference
- inout – in and out together. duh! inout is the default too except for const arguments for which in is the default obviously.
- bycopy – return / pass a copy of the object rather than a pointer to an address. Must ensure that the receiver is aware of the type (in its address space).
- byref – !bycopy and is the sad default.

Example:
- (oneway void) goOutsideAndEnjoyTheSun;
- setStuff:(in struct things *) aThing;

New to pointers? Then trust me: out and inout only make sense for pointers.