Objective-C ist eine Objekt-orientierte Programmiersprache die fast ausschließlich von Apple für ihre Betriebssysteme MacOS X und iOS und deren Programme verwendet wird. Sie basiert auf der Programmiersprachen C und erweitert sie um die Objekt-orientierung, die stark an die Programmiersprache Smalltalk angelehnt ist.

Objective-C ist dabei eine Erweiterung von C um Objekt-Orientierung (weshalb sich auch reine C-Programme problemlos mit einem Objective-C-Compiler übersetzen lassen). Deshalb spricht man bei Objective-C auch von einer C-Ebene und einer Objective-C-Ebene: Zur C-Ebene gehören alle Sprach-Bestandteile (Grammatik, Typen, etc.) von C; zur Objective-C-Ebene gehören alle Erweiterungen, die nicht zu C gehören.

Da Objective-C fast ausschließlich von Apple verwendet wird ist die Sprache fast untrennbar von Apples Frameworks Foundation und Cocoa bzw. Cocoa Touch. Die Namen „Objective-C“, „Foundation“ und „Cocoa“ werden deshalb oft (wegen einer fehlenden klaren Trennung) synonym verwendet.
Wir versuchen aber die Dinge in diesem Wiki – nach bestem Wissen – klarer zu trennen.

helloworld.m

#import <stdio.h>
 
int main(void) {
	printf("Hello World!\n");
 
	return 0;
}

"Hello World"-Beispiel auf GitHub

Ein Beispiel mit Objekt-Orientierung: Folgendes Beispiel ist für den GCC ausgelegt, um dieses Programm etwa mit Xcode compilieren zu können sind ein paar kleine Änderungen nötig. Problemlos lässt sich aber das C-"Hello World"-Programm mit einem Objective-C-Compilier compilieren.

helloworld.m

#import <stdio.h>
#import <objc/Object.h>
 
@interface Hello
- (void) init;
- (void) say;
@end
 
@implementation Hello
- (void) init {
	[super init];
}
 
- (void) say {
	printf("Hello World!\n");
}
@end
 
int main() {
	Hello *hello = [Hello new];
 
	[hello say];
	[hello free];
 
	retrun 0;
}

In Dateien mit der Endung .mm wird üblicherweise kein C-Code, sondern nur Objective-C- mit C++-Code verwendet!)

Auf der Konsole lassen sich Objective-C-Dateien am einfachsten mit clang compilieren:

clang foobar.m -o foobar -framework Foundation

Statt mit clang lassen sich Objective-C-Dateien auch mit GCC compilieren:

gcc foobar.m -o foobar -framework Foundation

Konstanten werden, wie in C, über die Compiler-Direktive #define am Anfang einer Datei definiert.

Dieses Beispiel definiert eine Konstante FOOBAR mit dem Zahlen-Wert 23:

#define FOOBAR 23

Wenn Objective-C – wie in der Regel üblich – mit dem Foundation-Framework verwendet wird, dann sollten lieber statische Eigenschaften statt Konstanten mit #define verwendet werden.

Quelle: Stack Overflow: What is the best way to create constants in Objective-C?

Code-Abschnitte lassen sich in Blöcke kapseln und durch Zuweisung zu einer Variable (hier foobar) wiederverwenden:

void (^foobar)(void) = ^{
	// Code
}

Aufruf des Code-Blocks:

foobar();

Dateien werden in Objective-C üblicherweise mit der Compiler-Direktive #import eingebunden. Diese ist ähnlich zur, in C üblichen, Direktive #include (die in Objective-C immer noch verwendet werden kann), aber sie stellt darüberhinaus sicher, dass eine Datei immer nur einmal eingebunden wird.

Klassen-Methoden sind Methoden einer Klasse, die verwendet werden können, ohne das ein Objekt erzeugt werden muss. In anderen Objekt-orientierten Programmiersprachen werden diese Methoden auch statische Methoden genannt.

Klassen-Methoden sind in Objective-C an einem + zu Beginn der Signatur zu erkennen:

+ (void)fooClassMethod;

Die Klassen-Methode kann nun in anderen Klassen wie folgt direkt verwendet werden:

[FooBar fooClassMethod];

Instanz-Methoden sind die Methoden einer Klasse, die nur verwendet werden können, wenn aus einer Klasse ein Objekt erzeugt wurde. Daher sagt man auch umgangssprachlich „eine (Instanz-)Methode wird auf ein Objekt angewendet“.

Instanz-Methoden sind in Objective-C an einem - zu Beginn der Signatur zu erkennen:

- (void)barInstanceMethod;

Instanz-Methoden können in anderen Klassen erst verwendet werden, wenn vorher ein Objekt mit der Klasse erzeugt wurde:

FooBar *foobar = [[FooBar alloc] init];
 
[foobar barInstanceMethod];

Zur Verhinderung von Laufzeitfehlern, kann man Objekte darauf testen, ob sie über eine bestimmte Methode verfügen:

if([foobar respondsToSelector:@selector(methodName:)]) {
	// Code, if the method exists on the object
} else {
	// Alternate code, if the method doesn't exist on the object
}

Delegates werden über ein Protokoll in der Header-Datei einer Klasse definiert:

FooBar.h

#import <UIKit/UIKit.h>
 
@protocol FooBarDelegate;
 
@interface FooBar: UIViewController
 
// Delegate property of the class
@property (nonatomic, weak) id<FooBarDelegate> delegate;
 
@end
 
// Delegate
 
@protocol FooBarDelegate <NSObject>
 
@required
-(void)requiredDelegateMethod;
 
@optional
-(void)optionalDelegateMethodOne;
-(void)optionalDelegateMethodTwo:(NSString *)withArgument;
 
@end

In der Implementierung kann immer auf die Delegate-Methode verwiesen werden, wobei mit folgender Abfrage sichergestellt werden sollte, dass die Delegate-Methode auch vorhanden ist:

if (self.delegate && [self.delegate respondsToSelector:@selector(optionalDelegateMethodOne)]) {
	[self.delegate optionalDelegateMethodOne];
}

Um den Delegate in einer anderen Klasse zu verwenden muss nun einfach die Header-Datei der Klasse mit dem Delegate importiert und der Delegate im Interface definiert werden:

#import "FooBar.h" // Import the class with delegate to use it
 
@interface FooViewController : UIViewController <FooBarDelegate> 

Quelle: iPhone Development 101: Objective-C: Delegate Protocols

• Arnes Link-Sammlung zu Objectice-C

• Code School: Try Objective-C
  Kostenlos nach Registrierung bei Code School

• video2brain: Objective-C 3.0 – Das große Training