Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- objc:start [2015-02-27 07:24] – "Klassen-Methoden" eingefügt a.kamola
+++ objc:start [2015-03-09 19:27] (aktuell) – [Hello World] Link zu GitHub a.kamola
@@ Zeile 1: / Zeile 1: @@
 ====== Objective-C ======
-===== Klassen-Methoden =====
+//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.
-//Klassen-Methoden// sind Methoden einer Klasse, die verwendet werden können, ohne das ein Objekt erzeugt werden muss.
+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.
-In anderen Objekt-orientierten Programmiersprachen werden diese Methoden auch [[lexikon:oop|statische Methoden]] genannt.
+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 =====