====== Objective-C ======

//Objective-C// ist eine [[lexikon:oop|Objekt-orientierte Programmiersprache]] die fast ausschließlich von Apple für ihre Betriebssysteme [[macosx:development|MacOS X]] und [[ios:development|iOS]] und deren Programme verwendet wird. Sie basiert auf der Programmiersprachen [[c:start|C]] und erweitert sie um die [[lexikon:oop|Objekt-orientierung]], die stark an die Programmiersprache [[smalltalk:start|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 [[apple:foundation:start|Foundation]] und [[apple:cocoa:start|Cocoa]] bzw. [[apple:cocoa-touch:start|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.

===== Hello World =====

<code objc helloworld.m>
#import <stdio.h>

int main(void) {
	printf("Hello World!\n");

	return 0;
}
</code>

[[https://github.com/akamola/helloworld/blob/master/helloworld.m|"Hello World"-Beispiel auf GitHub]]
==== Hello World mit OOP ====

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

<code objc 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;
}
</code>

===== Dateien =====

^ Datei-Endung ^ Beschreibung ^
| ''.h'' | Header-Datei mit öffentlichen Klassen-, Typen-, Funktions- und Konstanten-Definitionen |
| ''.m'' | Quellcode-Datei mit Objective-C- **oder** C-Code |
| ''.mm'' | Quellcode-Datei mit Objective-C, C- **oder** C++-Code |

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

===== Compilieren =====

Auf der Konsole lassen sich Objective-C-Dateien am einfachsten mit ''[[clang:start|clang]]'' compilieren:

<code bash>
clang foobar.m -o foobar -framework Foundation
</code>

Statt mit ''clang'' lassen sich Objective-C-Dateien auch mit [[gcc:start|GCC]] compilieren:

<code bash>
gcc foobar.m -o foobar -framework Foundation
</code>

===== Konstanten =====

Konstanten werden, wie in [[c:start|C]], über die Compiler-Direktive ''#define'' am Anfang einer Datei definiert.

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

<code objc>
#define FOOBAR 23
</code>

Wenn Objective-C – wie in der Regel üblich – mit dem [[apple:foundation:start|Foundation-Framework]] verwendet wird, dann sollten lieber [[apple:foundation:start#konstanten|statische Eigenschaften]] statt Konstanten mit ''#define'' verwendet werden.

Quelle: [[http://stackoverflow.com/a/17228508|Stack Overflow: What is the best way to create constants in Objective-C?]]

===== Typen =====

^ Typ ^ Erklärung ^ Erlaubte Werte ^
| ''BOOL'' | Wahrheitswerte ("boolean") | ''YES'', ''NO'' |

===== Code-Blöcke =====

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

<code objc>
void (^foobar)(void) = ^{
	// Code
}
</code>

Aufruf des Code-Blocks:

<code objc>
foobar();
</code>

===== Klassen =====

==== Einbinden von Dateien ====

Dateien werden in Objective-C üblicherweise mit der [[lexikon:compiler#directives|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.

===== Methoden =====

==== Klassen-Methoden ====

//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 [[lexikon:oop|statische Methoden]] genannt.

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

<code objc>
+ (void)fooClassMethod;
</code>

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

<code objc>
[FooBar fooClassMethod];
</code>

==== Instanz-Methoden ====

//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:

<code objc>
- (void)barInstanceMethod;
</code>

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

<code objc>
FooBar *foobar = [[FooBar alloc] init];

[foobar barInstanceMethod];
</code>

==== Objekte auf Methoden überprüfen ====

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

<code objc>
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
}
</code>

===== Delegates =====

==== Eigenen Delegate definieren ====

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

<code objc 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
</code>

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:

<code objc>
if (self.delegate && [self.delegate respondsToSelector:@selector(optionalDelegateMethodOne)]) {
	[self.delegate optionalDelegateMethodOne];
}
</code>

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:

<code objc>
#import "FooBar.h" // Import the class with delegate to use it

@interface FooViewController : UIViewController <FooBarDelegate> 
</code>

Quelle: [[http://www.idev101.com/code/Objective-C/delegate.html|iPhone Development 101: Objective-C: Delegate Protocols]]

===== Links =====

  * [[https://pinboard.in/u:aberaberarne/t:objc|Arnes Link-Sammlung zu Objectice-C]]

==== Tutorials ====

  * [[https://www.codeschool.com/courses/try-objective-c|Code School: Try Objective-C]]\\ Kostenlos nach Registrierung bei //Code School//

=== Kostenpflichtige Tutorials ===

  * [[https://www.video2brain.com/de/videotraining/objective-c-3-0-das-grosse-training|video2brain: Objective-C 3.0 – Das große Training]]