1 Objektorientierte Programmierung: Grundlagen

Werbung
Auf einen Blick
TEIL I: Einführung ............................................................ 23
TEIL II: Objective-C ......................................................... 49
TEIL III: Cocoa .................................................................. 135
TEIL IV: iPhone ................................................................ 399
TEIL V: Weitere Themen .................................................. 473
Anhang ............................................................................ 491
Inhalt
Vorworte ......................................................................................................
Geleitwort des Gutachters ........................................................................
Einleitung .....................................................................................................
15
17
19
TEIL I: Einführung
1
Objektorientierte Programmierung: Grundlagen .......
25
2
Ein erstes Programm: »Hallo Anwender!« ....................
31
2.1
2.2
2.3
32
33
36
37
42
45
46
2.4
2.5
Projekt anlegen .......................................................................
Den Controller erstellen ........................................................
Grafische Oberfläche erstellen ..............................................
2.3.1
Oberfläche gestalten und Elemente platzieren
2.3.2
Elemente mit dem Controller verbinden ...........
Programmcode erstellen ........................................................
Kompilieren und Ausführen des Programms .....................
TEIL II: Objective-C
3
Grundlagen von Objective-C ............................................ 51
3.1
3.2
Grundlegende Konventionen ...............................................
3.1.1
Ausdruck .................................................................
3.1.2
Anweisung ..............................................................
3.1.3
Anweisungen in Blöcken ......................................
3.1.4
Bezeichner ...............................................................
3.1.5
Operatoren .............................................................
3.1.6
Reservierte Schlüsselwörter .................................
3.1.7
Kommentare ...........................................................
Ein einfaches Programm in Objective-C .............................
3.2.1
Ein Programm eingeben und kompilieren .........
3.2.2
Der Aufbau im Detail ............................................
52
52
53
53
53
54
55
55
56
57
59
5
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 5
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
4
Variablen und Datentypen ................................................
63
4.1
4.2
4.3
Einführung ................................................................................
Gültigkeitsbereich von Variablen .........................................
Datentypen der Programmiersprache C ..............................
4.3.1
Einfache C-Datentypen .........................................
4.3.2
Typkonvertierung ...................................................
4.3.3
Listen .......................................................................
4.3.4
C-Zeichenketten mit »char« .................................
4.3.5
Datenstrukturen mit »struct« ...............................
Typen von Objekten in Objective-C ....................................
4.4.1
Der allgemeine Datentyp »id« .............................
4.4.2
Zahlen mit »NSNumber« ......................................
4.4.3
Zeichen mit »NSString« .........................................
4.4.4
Listen mit NSArray .................................................
4.4.5
Benannte Listen mit »NSDictionary« ..................
Zusammenfassung und Ausblick ..........................................
63
65
68
68
70
71
72
73
75
76
77
78
80
82
84
Bedingungen und Funktionen .........................................
87
5.1
87
87
88
89
89
91
93
95
96
4.4
4.5
5
5.2
5.3
6
Grundlagen ..............................................................................
5.1.1
Vergleichsoperatoren ............................................
5.1.2
Logische Operatoren .............................................
Steuerungsanweisungen ........................................................
5.2.1
Bedingte Ausführung: »if« ....................................
5.2.2
Mehrfachauswahl: »switch« .................................
5.2.3
In Kürze: Bedingter Ausdruck .............................
5.2.4
Abschließende Empfehlungen .............................
Funktionen ...............................................................................
Schleifen ................................................................................ 101
6.1
6.2
Schleifen definieren ................................................................
6.1.1
Bedingte Wiederholung: »while« ........................
6.1.2
Prüfung am Ende: »do . . . while« ......................
6.1.3
Die Zählschleife: »for« ...........................................
Mehr Komfort ..........................................................................
6.2.1
Definition in der Schleife ......................................
6.2.2
Verkürzte Schreibweisen ......................................
6.2.3
Schnelle Aufzählung mit Fast Enumeration ......
101
101
103
104
108
108
108
109
6
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 6
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
7
Objektorientierte Programmierung: Klassen erstellen
und bearbeiten .................................................................... 113
7.1
7.2
Aufbau von Klassen in Objective-C .....................................
7.1.1
Deklaration einer Klasse .......................................
7.1.2
Implementierung einer Klasse .............................
7.1.3
Allozieren und Initialisieren von Objekten .......
7.1.4
Die Klasse »Autor« verwenden ...........................
7.1.5
Klassenmethoden ..................................................
7.1.6
Propertys in Objective-C 2.0 ...............................
Speicherverwaltung ................................................................
7.2.1
Grundlagen .............................................................
7.2.2
Garbage Collection ................................................
7.2.3
Referenzen zählen .................................................
113
115
117
118
121
122
123
126
127
127
129
TEIL III: Cocoa
8
Grundlagen von Cocoa ....................................................... 137
8.1
8.2
8.3
8.4
8.5
9
Einführung und Entwurfsmuster ..........................................
8.1.1
Cocoa als Framework ............................................
8.1.2
Model-View-Controller ........................................
8.1.3
Delegation ..............................................................
8.1.4
Observer ..................................................................
8.1.5
Target-Action ..........................................................
Bestandteile von Cocoa .........................................................
Cocoa in der Praxis .................................................................
Der Interface Builder ..............................................................
Die Dokumentation von Apple ............................................
137
138
139
139
141
142
142
143
148
152
Fenster, Views und Voreinstellungen ............................. 155
9.1
9.2
Das Fenster für die Einstellungen ........................................
9.1.1
Attribute und Elemente des Fensters ................
9.1.2
Der »First Responder«, »Next Key View«
und das Hauptmenü ..............................................
9.1.3
Anlegen des Delegates für Applikation und
Einstellungs-Panel ..................................................
Voreinstellungen des Benutzers speichern .........................
9.2.1
Personalisierung von »Info.plist« ........................
9.2.2
Implementierung der Controller-Klasse .............
156
156
157
160
162
163
164
7
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 7
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
9.3
9.2.3
Garbage Collection aktivieren ............................. 168
Symbolleiste im Hauptfenster ............................................... 168
10 Datenmodelle mit Core Data ........................................... 173
10.1 Bestandteile von Core Data ..................................................
10.2 Datenmodell erstellen ............................................................
10.2.1
Entitäten anlegen ...................................................
10.2.2 Attribute erzeugen und definieren .....................
10.2.3 Beziehungen definieren ........................................
10.2.4 Suchabfragen definieren .......................................
10.3 Erweiterung des Objective-C-Codes ...................................
10.3.1
AppDelegate erweitern ........................................
10.3.2 Deklaration eines Core Data Controllers ...........
10.4 Erweiterung der grafischen Oberfläche ..............................
10.5 Implementierung des »AppDelegate« .................................
10.5.1
Definition einer privaten Kategorie ....................
10.5.2 Einlesen des Objektmodells .................................
10.5.3 Öffnen der Dateiablage ........................................
10.5.4 Initialisieren des Objektkontextes ......................
10.5.5 Speichern der Daten .............................................
10.5.6 Zugriff auf Standardwerte ....................................
10.6 Der CoreDataExampleController ..........................................
10.6.1
Hinzufügen einiger Hilfsmethoden .....................
10.6.2 Tags in Managed Objects .....................................
10.6.3 Anzeigen aller gespeicherten Schlagwörter ......
10.6.4 Neuen Artikel anlegen ..........................................
10.6.5 Anzeige aller Artikel ..............................................
10.6.6 Anzeigen von verschlagworteten Artikeln ........
10.7 Ausführen der Anwendung ...................................................
174
176
177
178
180
183
186
186
187
189
192
192
193
194
197
198
199
200
201
203
204
206
209
210
211
11 Cocoa Bindings .................................................................... 213
11.1 Grundlagen und Key-Value Coding .....................................
11.2 Erstellung der grafischen Oberfläche ..................................
11.2.1
Array Controller hinzufügen ................................
11.2.2 Table View für Artikel anlegen ............................
11.2.3 Textfelder für Titel und Autor ergänzen .............
11.2.4 Ein Feld für die Datumseingabe platzieren .......
11.2.5 »Array Controller« für die Schlagwörter ............
11.2.6 Table View für die Schlagwörter .........................
213
215
216
216
218
219
220
221
8
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 8
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
11.2.7
11.3
11.4
11.5
11.6
»Text View« für den Inhalt des
Weblog-Artikels .....................................................
Artikel hinzufügen und löschen ...........................................
11.3.1
Symbolleiste verbinden ........................................
11.3.2 Individualisierte Managed Objects .....................
Hinzufügen von Tags ..............................................................
11.4.1
Schaltflächen und individualisierte Klasse ........
11.4.2 Array Controller für die Tags ................................
11.4.3 Panel für die Tags erstellen ..................................
Ein Tag einem Artikel zuweisen ............................................
11.5.1
Schaltfläche und Aktivierungsregeln ..................
11.5.2 Target-Action-Methode im »App Delegate« .....
Benutzerfreundlichkeit steigern – Weitere Möglichkeiten
mit Cocoa Bindings .................................................................
11.6.1
Artikel nach Datum sortieren ..............................
11.6.2 Views deaktivieren ................................................
11.6.3 Anzahl der vorhandenen Artikel darstellen ......
11.6.4 »NSUserDefaultController« für die
Voreinstellungen ....................................................
11.6.5 Menüpunkte und Cocoa Bindings ......................
222
223
224
224
227
227
229
229
232
232
234
236
237
238
239
240
242
12 Fehlerbehandlung und Debugging ................................. 245
12.1 Fehler während der Entwicklung erkennen .......................
12.1.1
Protokolle mit NSLog ............................................
12.1.2
Bedingter Abbruch mit assert und NSAssert ....
12.2 Fehlersuche in Xcode .............................................................
12.2.1
Fehlermeldungen beim Kompilieren ..................
12.2.2 Debugger und Breakpoints ..................................
12.3 Auf Laufzeitfehler mit »NSError« und »NSAlert«
reagieren ...................................................................................
245
246
248
252
253
254
259
13 Arbeiten mit Texten im »TextView« ............................... 265
13.1 »TextView« und »NSAttributedString« ................................
13.2 Text mit Hyperlinks versehen ................................................
13.2.1
Kategorien in Objective-C-Klassen .....................
13.2.2 Menü und Target-Actions verbinden .................
13.2.3 Implementierung der Kategorie ..........................
265
267
269
270
271
9
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 9
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
14 Netzwerke und WebKit .................................................... 277
14.1 WebKit zur Darstellung von Webseiten .............................
14.1.1
Grafische Oberfläche erweitern ..........................
14.1.2
Spezielle Xib-Datei einbinden .............................
14.1.3
WebPanelController implementieren .................
14.1.4
AppDelegate erweitern ........................................
14.2 Kommunikation ins Netzwerk ..............................................
14.2.1
Grundlagen des »URL Loading System« ............
14.2.2 Synchrone und asynchrone Kommunikation ....
14.3 Integration eines externen Frameworks .............................
14.3.1
Die MetaWeblog-Schnittstelle ............................
14.3.2 XML-RPC Framework einbinden ........................
14.3.3 Nutzung des XML-RPC Frameworks ..................
14.3.4 »AppDelegate« um Protokoll erweitern ............
14.4 Artikeldaten in HTML konvertieren .....................................
14.5 Methoden zum Versand ........................................................
14.5.1
Target-Action zum Senden ...................................
14.5.2 Die »XMLRPCConnectionDelegate«Methoden ...............................................................
14.6 Grafische Oberfläche erweitern ............................................
14.6.1
Menüpunkt zum Senden ......................................
14.6.2 Symbolleiste ergänzen ..........................................
14.6.3 Einsatz eines »NSProgressIndicator« ..................
278
278
280
282
285
287
288
290
293
293
294
299
300
301
304
304
307
309
309
311
313
15 Exkurs: Arbeiten mit dem Schlüsselbund ..................... 317
15.1 Die Hilfsklasse »MHKeychainItem« .....................................
15.1.1
Instanzvariablen und Propertys deklarieren ......
15.1.2
Propertys synthetisieren .......................................
15.1.3
Zugriff auf den Schlüsselbund .............................
15.2 Programmstart und »sendeArtikel:« überarbeiten ............
15.3 Grafische Oberfläche überarbeiten ......................................
15.3.1
Fenster der Einstellungen anpassen ...................
15.3.2 Änderungen an »MainMenu.xib« und
»AppDelegate« .......................................................
15.3.3 Implementierung des »PreferencesController«
318
319
320
322
329
332
332
334
335
10
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 10
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
16 Drucken und »NSOperationQueues« ............................. 339
16.1 Verarbeitung von Druckjobs .................................................
16.1.1
Deklaration der Kategorie für den Druck ..........
16.1.2
Implementierung der Kategorie ..........................
16.1.3
Anpassungen im Interface Builder ......................
16.2 Nebenläufigkeit mit »NSOperationQueues« ......................
16.2.1
Simulation eines langlebigen Programmteils ....
16.2.2 Grundlagen von »NSOperationQueue« und
»NSInvocationOperation« ....................................
16.2.3 Aufbereitung der Artikel in einem
Nebenthread ...........................................................
340
341
342
348
349
350
350
352
17 Zwischenablage und Widerrufen .................................... 359
17.1 Die Zwischenablage über »NSPasteboard« ........................
17.1.1
Grundlagen .............................................................
17.1.2
RTF aus der Zwischenablage ................................
17.1.3
Copy, Paste und die Responder-Kette ...............
17.2 Widerrufen mit dem »NSUndoManager« ...........................
17.2.1
Grundlagen .............................................................
17.2.2
»Undo« für die Views aktivieren .........................
17.2.3
»Undo« und Core Data .........................................
17.2.4
Das Setzen von Links rückgängig machen .........
359
360
361
365
370
370
370
371
372
18 Mit Dateien arbeiten ......................................................... 377
18.1 Dateien öffnen und speichern ..............................................
18.1.1
Dateien öffnen mit dem »NSOpenPanel« .........
18.1.2
Dateien speichern und das »NSSavePanel« .......
18.2 Einsatz des »NSFileManager« ...............................................
377
378
380
382
19 Core Animation .................................................................... 385
19.1 Grundlagen ..............................................................................
19.2 Eigenschaften animieren und Filter anwenden .................
19.2.1
Transparenz im WebView .....................................
19.2.2 Filter im WebPanel ................................................
19.3 Explizite Animationen ............................................................
386
387
388
390
394
11
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 11
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
TEIL IV: iPhone
20 Grundlagen der iPhone-Entwicklung ............................. 401
20.1
20.2
20.3
20.4
20.5
20.6
Gemeinsame Software-Architektur ......................................
Modernisierte und neue Frameworks .................................
Einschränkungen des iPhone OS ..........................................
Entwicklungsumgebung .........................................................
Architektur einer iPhone-Anwendung ................................
Kommunikation im Netzwerk ...............................................
401
402
402
403
404
406
21 Der WeblogClient mit Cocoa Touch ............................... 407
21.1 Neues iPhone-Projekt erstellen ............................................
21.2 Core Data-Modell erstellen ..................................................
21.3 Vorbereitungen für die Artikelübersicht .............................
21.3.1
Arbeiten an »MainWindow.xib« .........................
21.3.2 Klasse für den »UITableViewController«
anlegen ....................................................................
21.3.3 Verbindungen zum Controller herstellen ..........
21.4 Application Delegate überarbeiten .....................................
21.5 Implementierung der Artikelübersicht ................................
21.5.1
Controller zum Verwalten der Suchergebnisse
21.5.2 Target-Action für neue Artikel .............................
21.5.3 Initialisierung des Controllers ..............................
21.5.4 Delegate-Methoden zur Darstellung von
Inhalten ...................................................................
21.5.5 Löschen von Artikeln ............................................
21.6 Ansicht für die Details erstellen ...........................................
21.6.1
Eigene Ressourcendatei für das View ................
21.6.2 Neue Controller-Klasse deklarieren ....................
21.6.3 »UITableViewDelegate«- und
»UITableViewDataSource«-Methoden
implementieren ......................................................
21.6.4 Änderungen am »ArtikelOverviewController«
21.6.5 »File’s Owner« und Delegates definieren ..........
21.7 Views für Eingaben .................................................................
21.7.1
Spezialisierte »UIViewController« anlegen ........
21.7.2
»UIViewController« im Interface Builder
instanziieren ...........................................................
21.7.3
Implementierung des »TextFieldController« .....
21.7.4
Implementierung des »DatePickerController«
407
409
410
410
412
414
415
418
418
419
420
424
428
429
429
431
433
437
438
439
439
441
443
445
12
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 12
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
21.7.5
21.7.6
Implementierung des »TextViewController« ..... 446
Selektion im »DetailedViewController« ............. 449
22 Einstellungen, Netzwerk und Test .................................. 453
22.1 Einstellungen der Applikation ..............................................
22.2 »Settings Bundle« hinzufügen und konfigurieren ..............
22.2.1
»NSUserDefaults« integrieren ..............................
22.2.2 Autor für neuen Artikel anpassen .......................
22.3 Kommunikation im Netzwerk ...............................................
22.3.1
Einbindung des XML-RPC-Frameworks .............
22.3.2 »DetailedViewController« erweitern ..................
22.3.3 »UITableViewDelegate« erweitern ......................
22.4 Testphase auf einem Entwicklungsgerät .............................
22.4.1
iPhone Developer Portal ......................................
22.4.2 »Provisioning Profile« installieren .......................
22.4.3 Veröffentlichen der Anwendung .........................
453
454
456
459
459
460
461
465
466
467
470
471
TEIL V: Weitere Themen
23 Tipps und Tricks zu Xcode ................................................ 475
23.1 Rund um den Quelltext .........................................................
23.1.1
Einrücken, Vervollständigen, Umbenennen ......
23.1.2
Markierungen und Lesezeichen ..........................
23.2 Funktionen und Klassen überblicken ..................................
23.3 Projektdateien organisieren ..................................................
475
475
479
481
482
24 Cocoa jenseits von Objective-C ...................................... 483
24.1
24.2
24.3
24.4
Python und PyObjC ................................................................
Ruby und MacRuby ................................................................
JavaScript und JSCocoa ..........................................................
F-Script ......................................................................................
483
486
488
489
13
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 13
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Inhalt
Anhang .......................................................................................... 491
A
B
C
D
Mit der Dokumentation arbeiten ....................................................
A.1 Von Guides, Klassen und Referenzen ..................................
A.2 Sich ein Thema erarbeiten .....................................................
A.3 Mehr Komfort bei der Recherche ........................................
Lokalisierung .......................................................................................
B.1 Lokalisierte Ressourcen ..........................................................
B.2 Texte lokalisieren .....................................................................
Glossar .................................................................................................
Die Buch-DVD ....................................................................................
493
493
495
496
499
499
501
503
505
Index ............................................................................................................. 507
14
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 14
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Der Begriff Objektorientierung ist in der Informatik mittlerweile
allgegenwärtig. Dieses Kapitel macht Sie mit den grundlegenden
Überlegungen dieser Methode vertraut und führt Sie theoretisch in
die Verfahren ein, die in den folgenden Kapiteln Anwendung finden
werden.
1
Objektorientierte Programmierung:
Grundlagen
Ein Paradigma bezeichnet in der Informatik unter anderem die Art und
Weise, wie in einer Programmiersprache dem Computer Anweisungen
erteilt werden. In dieser noch recht jungen Disziplin haben sich in den
letzten Jahrzehnten eine Reihe solcher Paradigmen etabliert und sind
zum Teil auch wieder verschwunden. Der zurzeit bekannteste und am
weitesten verbreitete Ansatz ist die objektorientierte Programmierung.
Ein Paradigma . . .
Auf die Entwicklung vieler jüngerer Programmiersprachen wie Java, Ruby und auch Objective-C hatte Smalltalk-80 einen großen Einfluss. Nicht
zufällig wurde Smalltalk-80 bei dem Unternehmen Xerox entwickelt, von
dessen Entwicklungsabteilung Steve Jobs eine ganze Reihe von Anregungen für die Gestaltung grafischer Benutzeroberflächen erhalten hat.
Smalltalk-80 setzt auf eine konsequente Objektorientierung. In Smalltalk-80 handelt es sich bei allem um ein Objekt.
Smalltalk als Pate
Als Objekt wird in der objektorientierten Programmierung eine Abstraktion eines reellen Gegenstands oder eines Akteurs in einem System betrachtet. Etwas genauer gesagt, handelt es sich bei einem Objekt um eine
Abstraktion von komplexeren Gegebenheiten. In einem Objekt werden
Daten (Text, Zahlen, . . . ) und Operationen auf diese Daten (Addition
von Zahlen, Ausgabe der Zeichenkette als Großbuchstaben, . . . ) gruppiert. Mit dieser Bindung zwischen den eigentlichen Daten und den für
diese verfügbaren Operationen wird den Daten ein gewisses Verhalten
gegeben.
Objekt
In der Zeit vor der objektorientierten Programmierung wurden in den
Programmiersprachen immer Daten und Operationen getrennt. Für Entwickler bedeutete dies, dass sie sehr genau darauf achten mussten, welche
Daten sie zu welchem Zeitpunkt einer bestimmten Operation unterziehen
Daten und
Operationen
25
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 25
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
1
Objektorientierte Programmierung: Grundlagen
konnten. Zum Beispiel ist die Ausgabe der Zeichenkette als Großbuchstaben bei einer Zahl nicht möglich. Der Grund für dieses Problem bestand
natürlich nicht zuletzt in der Architektur des Computers an sich, bei der
Daten und Programme strikt getrennt werden.
Die objektorientierte Programmierung hat dieses Defizit berücksichtigt
und Daten sowie die möglichen Operationen zu einem Objekt gruppiert. Sie bietet ferner Strukturierungs- und Kommunikationsmechanismen. Das eigentliche Programm entsteht dann aus einem Geflecht von
Objekten, die miteinander interagieren.
Nachrichten
an Objekte
Die Interaktion von Objekten wird über Nachrichten realisiert. Erhält ein
Objekt eine Nachricht, dann wird beim Empfänger eine Operation ausgelöst, die an den Daten des Empfängers eine Veränderung vornehmen
kann. Mit der Anweisung
[textObjekt appendString:@"Mehr Text"];
wird dem bereits existierenden Objekt mit der Bezeichnung textObjekt
die Nachricht appendString: geschickt. Diese Nachricht löst eine Operation aus, bei der dem schon vorhandenen Text weiterer Text am Ende
hinzugefügt wird. Die in dem Objekt enthaltenen Daten in Form einer
Zeichenkette werden geändert. Das empfangende Objekt reagiert also
auf Nachrichten und besitzt ein bestimmtes Verhalten. Die Beschreibung
solcher Objekte und von deren Interaktion in Form von Nachrichten ist
eines der wichtigsten Konzepte der Objektorientierung.
Kapselung
von Daten
Um diesen Grad der Abstraktion bei der Programmierung zu erreichen,
müssen die Daten innerhalb des Objekts eingekapselt werden. Der Vorteil
für den Entwickler besteht darin, dass er sich für den inneren Aufbau
des Objekts im Grunde nicht mehr interessieren muss. Wichtig sind in
diesem Zusammenhang nur die Nachrichten, die dem Objekt übermittelt
werden können, und die Kenntnis dessen, was das Objekt als Ergebnis
zurückgeben wird.
Klassen und
Instanzen
Wenn Sie eine Anwendung mit Objective-C und Cocoa entwickeln, werden Sie schnell viele Objekte erzeugen und diesen Nachrichten übermitteln. Die meisten dieser Objekte werden eine Art von Standardobjekten
sein, etwa ein Objekt, dessen Datenbestand eine Zeichenkette bildet.
»Art« bedeutet in diesem Zusammenhang, dass die erzeugten und in Ihrem Programm verfügbaren Objekte zur gleichen Klasse gehören oder
denselben Typ besitzen. Die akkurate Bezeichnung für diesen Sachverhalt lautet, dass ein Objekt die Instanz einer Klasse ist. Objekte derselben
Klasse reagieren auf dieselben Nachrichten und führen somit auch die
26
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 26
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Objektorientierte Programmierung: Grundlagen
1
gleichen Operationen auf die enthaltenen Daten aus. Die in den verschiedenen Instanzen einer Klasse enthaltenen Daten sind oft vom gleichen
Typ (Zahlen, Text, . . . ), wenn auch die Werte sich unterscheiden mögen.
Letzteres macht die Individualität eines Objekts aus. Bei den Fenstern,
die Ihnen zum Beispiel im Finder angezeigt werden, handelt es sich um
Objekte, die eine Instanz der Klasse NSWindow darstellen. Bei den einzelnen Fenstern unterscheiden sich die enthaltenen und dargestellten Daten
natürlich. Die Fenster haben eine unterschiedliche Position auf dem Bildschirm, der angezeigte Ordner ist von Fenster zu Fenster verschieden,
und auch die Art der Darstellung und die Titelzeile der einzelnen Fenster
können sich ändern.
Die Daten eines Objekts, zu denen eine Zahl, ein Text, der Titel eines Fensters und dessen Größe gehören können, werden als Attribute bezeichnet.
Bei komplexeren Attributen können diese Attribute selbst Objekte sein.
Zum Beispiel wird die Symbolleiste eines Fensters auf diese Weise realisiert. Das Objekt, das das Fenster darstellt, ist eine Instanz der Klasse
NSWindow. Diese enthält als ein Attribut eine Instanz der Klasse NSToolbar, über die die Symbolleiste realisiert wird. Diese Kompositionalität
von Objekten wird in diesem Buch immer wieder anhand von Beispielen erläutert. In objektorientierten Sprachen wie Objective-C haben Sie
von außen keinen direkten Zugriff auf die Attribute eines Objekts. Um
ein Attribut zu ändern, müssen Sie dem jeweiligen Objekt die passende
Nachricht schicken.
Attribute eines
Objekts
Die Operationen eines Objekts werden mit Methoden realisiert. Eine Methode in Objective-C entspricht einer Funktion (siehe Abschnitt 5.3), die
dann aber nicht dem gesamten Programm, sondern nur der Klasse zugeordnet wird. Um auf die Attribute eines Objekts zugreifen, die Daten also
manipulieren zu können, müssen Sie die passende Methode aufrufen. Bei
Objective-C verhält es sich so, dass die Methode ausgeführt wird, wenn
die gleichnamige Nachricht an das Objekt geschickt wird. Eine Nachricht
in der Form [textObjekt appendString:@"Mehr Text"] führt also dazu,
dass die Methode appendString: aufgerufen und ausgeführt wird.
Methode
Wenn Sie ein Objekt aus einer Klasse erzeugen, also zum Beispiel ein
neues Fenster öffnen, dann wird dies als Instanziierung einer Klasse bezeichnet. Das Objekt, in diesem Beispiel das Fenster, erhält eine eindeutige Identität. Wenn das Programm ausgeführt wird, dann wird dem Objekt eine eindeutige Adresse im Hauptspeicher zugewiesen. Die Attribute
dieser konkreten Objekte können Sie dann mit den Methoden ändern.
Die individuellen Attribute eines eindeutigen Objekts können auch als
Instanzvariablen bezeichnet werden. Wenn zwei Objekte die gleichen At-
Instanzen
27
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 27
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
1
Objektorientierte Programmierung: Grundlagen
tribute besitzen – die Fenster sehen absolut identisch aus –, dann sind
sie zwar in Bezug auf die Attribute gleich, besitzen aber nicht dieselbe
Identität, da es sich ja um zwei Fenster handelt.
Vererbung
Wenn Sie ein umfangreicheres Programm entwickeln, werden Sie irgendwann den Punkt erreichen, an dem Sie Objekte von Klassen instanziieren möchten, diese aber nicht mehr Ihren Anforderungen entsprechen.
Sie könnten natürlich eine neue Klasse implementieren, die die bereits
vorhandenen Klassen ersetzt und dieser neuen Klasse dann noch die Attribute und Methoden hinzufügen, die Sie benötigen. Dieser immer mal
wieder auftretenden Situation begegnen objektorientierte Programmiersprachen mit der Möglichkeit, dass eine neue Klasse die Eigenschaften
einer schon vorhandenen Klasse erbt. Die neue Klasse wird dann als
Subklasse bezeichnet, die schon vorhandene Klasse ist die Superklasse.
Diese Vererbung ist eine der herausragenden Eigenschaften objektorientierter Programmierung. Sie hilft, bei sehr großen Programmierprojekten wie zum Beispiel einem Betriebssystem eine wohlstrukturierte Softwarearchitektur zu definieren, da gemeinsame Eigenschaften dieser Architektur bereits in einer sehr frühen Superklasse implementiert werden
können und jede Subklasse eine Spezialisierung ihrer Vaterklasse ist.
Abbildung 1.1 Beispiele für mehrere Spezialisierungen von »NSView«
NSView
So bildet die Klasse NSView die Basis für fast alle Elemente, die in einem
Fenster erscheinen können. Das Fenster in Abbildung 1.1 enthält einige Spezialisierungen, also Subklassen von NSView. Die Schaltflächen auf
der linken Seite sind zwei Instanzen der Subklasse NSButton, der Fortschrittsbalken ist eine Instanz der Subklasse NSProgressIndicator, und
die Auswahlliste ist eine Instanz der Subklasse NSPopUpButton.
Polymorphie
Es ist möglich, dass Objekte unterschiedlicher Klassen auf die gleichen
Nachrichten unterschiedlich reagieren. Besitzen zwei Objekte Methoden
mit dem gleichen Namen, so ist deren Implementierung in der jeweiligen
Klasse unterschiedlich. Diese Möglichkeit zur Polymorphie wird bei der
Arbeit mit dem Cocoa-Framework gerne genutzt, um bestimmte Konven-
28
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 28
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Objektorientierte Programmierung: Grundlagen
1
tionen bei der Arbeit mit dem Framework zu etablieren. Beispielsweise
müssen Objekte, die von der Klasse NSView abstammen, auf die Nachricht
drawRect: reagieren. Mit dieser Nachricht wird dem Objekt mitgeteilt,
welcher für den Anwender sichtbare Bereich neu zu zeichnen ist, weil
zum Beispiel ein darüber liegendes Fenster verschoben wurde. Wie dies
jedoch geschieht und was dort gezeichnet wird, ist von Subklasse zu
Subklasse unterschiedlich.
Diese Konventionen für die Arbeit mit Objekten bilden eine Art Muster
für den Entwurf einer Anwendung. In Abschnitt 8.1.1 wird Ihnen dieses
Konzept anhand eines Beispiels erläutert.
Entwurfsmuster
29
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 29
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Index
.NET 113
.h 33
.m 33
.xcdatamodel 176, 409
/System/Library/Frameworks 286
#ifdef 247
#import 45, 60, 99
#pragma mark 480
@class 188
@count 239
@dynamic 227
@end 117
@implementation 45, 117
@interface 115
@property 124, 194
@protocol 299
@selector() 141, 354, 372, 422
@synthesize 124, 201
1:1-Beziehung 181
1:n-Beziehung 181
A
Active Build Configuration 248
add: 224
addObserver:forKeyPath:
options:context: 336
Aktivierungsregel 232, 311
alloc 118
Allowed Toolbar Items 169
Also create . . . 35, 145
Alternating Rows 217
animated 423
Anweisung 53
API 503
App ID 468
App Store 471
AppDelegate 161
AppKit 143, 401
Apple Event 503
Apple Worldwide Developer Relations Certification Authority 468
AppleScript 503
Application 140, 149
Application Delegate 404
Application Kit 143
Application Programming Interface 503
Application Support 194, 264
applicationDidFinishLaunching: 416,
418
applicationDocumentsDirectory 409
applicationShouldTerminate: 198
applicationWillFinishLaunching: 161,
164
Arithmetischer Operator 54
Array 71
Array Controller 216
ASCII 72
assert() 248, 251
Attribut 27
Attributes Inspector 38
Aufruf-Stack 255
Ausdruck 52
Auto Rearrange Content 216, 229
Automatically Hide Scrollers 217
autorelease 131
Autosave 280
Autosizing 281
B
becomeFirstResponder 444
Bedingter Ausdruck 93
beginEditing 273
Behaviour 40
Bezeichner 53
Binary data 222
Bind to 216
Bit-Operator 55
BOOL 68
Boole, George 68
break 93, 103
Breakpoint 245, 255
Bridging 483
BSD-Socket 277, 287
Build 295
Build and Go 33, 46
Build failed 253
Build Phase 297
Build-Einstellungen 168
507
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 507
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
Build-Phase 503
Bundle 193, 295, 503
Bundle Identifier 163
C
C 68, 127
Standard C99 108
Standardblibiothek 251
Zeichenkette 326
C++ 113, 127, 140
C-Zeichenketten 72
C# 127, 140
CAAnimation 387
CABasicAnimation
animationWithKeyPath: 397
autoreverses 397
CALayer 386
addAnimation:forKey: 397
canRemove 233
CAOpenGLLayer 387
Carbon 18, 503
Cascading Stylesheet 278, 344
case 91, 92
CF 321
CGFloat 69
CGPoint 397
CGSize 441
char 61, 69, 70, 72
Chrome 278
CI Filter Browser 390
CIFilter 392
filterWithName: 392
setDefaults 392
CIPixellate 392
Circular Progress Indicator 314
Class 43, 160
Class Actions 43
Class Model 481
Class Outlets 43, 160
Close 243
Cocoa 137
Cocoa Application 32, 155
Cocoa Simulator 282
Cocoa Touch Class 412
Cocoa.h 60
Cocoa
Streams 287
Code Sense 477
Codierung 369, 503
Columns 217
configurations 453
Connections Inspector 44
Content Set 221
Controller Content 221
Controller Key 216, 218
Cookie 288
copy 120, 125
Copy Files 298
copy: 366
Core Animation 385, 402
setWantsLayer: 386
Core Data 143, 355, 407, 413
Abstract 178
Add Attribute 179
Attributes 178
Class 177
commitEditing 199
Datenmodell 176
Default Value 179
Destination 181
Indexed 179
Löschregel 182
Parent 178
Relationships 178
save: 199
Transient 179
Undo 371
Core Foundation 321, 503
Core Image Filter 385, 390
Core Library 152
Core Location 402
Cover Flow 385
Cross-Compiler 403
Custom View 394
cut: 366, 369
Czarny, Eric 294
D
Data Source 414
Date Picker 219
Daten 25
Kapselung 26
Datentyp 68
Konvertierung 70
Wertebereich 69
Datum 176
dealloc 133, 415
Debug-Modus 247
508
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 508
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
Debugger 245, 254, 351
Debugger Console 246
default 93
Definition 503
Deklaration 270, 503
Delegation 139
Delegationsmethode 154
detailTextLabel 427
Dialog
Modal 268
do . . . while 103
Doc Sets 152
Dokumentation 152
double 69
drawRect: 386
E
Edit in Scope 478
Edit Project Settings 250
Editable 40
editButtonItem 421
else 90
Empty File 57
encodeWithCoder: 370
Encoding 291, 503
end 45
endEditing 273
Endlosschleife 106
Entity Name 229
Entwicklungszeit 245
Entwurfsmuster 29, 138
Errors and Warnings 253
exit code 259
F
F-Script 489
Fast Enumeration 109
Fetch Request 183
File’s Owner 148, 284, 390, 410
finalize 321, 390
First Responder 149, 157, 223, 266,
377
FIXME 480
float 69
Font Manager 149
for 104
Formatstring 246
Foundation 113, 142
Foundation.h 60
Framework 138, 402, 503
Hinzufügen 286, 460
FreeBSD 52
Funktion 96
Deklarieren 99
Kopf 96
Parameter 97
Rumpf 96
G
Garbage Collection 60, 127, 168,
402
gcc 52, 58, 245
gdb 254
Generate accessors 225
Generate Obj-C 2.0 Propertys 225
Getter-Methode 123
GitHub 488
GNU C Compiler 51
GNU Debugger 254
Google 278
Groups & Files 33
H
Header-Datei 99, 114, 145
Headers 217
Heap 64, 127
HotCocoa 487
HTML 345
HTTP 503
HUD-Panel 280
Hypertext Transfer Protocol 503
I
IBAction 36, 46, 142
IBOutlet 36, 142, 145
ibtool 500
id 76
Identity Inspector 43
IEEE 754 503
if 87, 89
Implementierung 45
Indirektion 214
Info.plist 163
informell 140
init 118
509
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 509
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
initialFirstResponder 158, 223
Initialisierung 503
initWithCoder: 370
Inspector 37, 150
AppleScript 152
Attributes 151
Bindings 151
Connections 152
Effects 151
Identity 152
Size 151
Installation Directory 296
Instanz 26, 75
Instanziierung 503
Instanzmethode 116, 153
Instanzvariable 115, 269, 351, 369
int 65, 69
Interface Builder 36, 148
Hilfslinien 39
Inspector 37
Library 37
Simulated User Interface Elements 404
Interface Builder Identity 216
iPhone
Identifier 468
iPhone Developer Program 466
iPhone Distribution Certificate 471
iPhone OS 113
iPhone Simulator 403
IsSecure 456
J
Java 25, 113, 127, 140, 152
JavaScript 278, 388, 488
Jobs, Steve 25
JSCocoa 488
K
Kategorie 140, 192, 269, 320
Key Equiv. 271
Key-Value Coding 213, 504
Operatoren 239
Key-Value Observing 142, 318, 388,
504
Keychain 317
Klasse 26
Deklaration 114, 115
Implementierung 114, 117
Klassenmethode 122, 153
Kommentar 55
Konsole 246
Konstante 154
Konventionen 51
kSecAccountItemAttr 328
kTextFeldSection 431
Kurzbefehl 270
KVC 504
KVO 504
L
Label 169
Laufzeit 245
Laufzeitsystem 504
leftBarButtonItem 421
Library 37, 149
Linked Frameworks 286, 296
Linken 504
Linux 52
Liste 71
Terminierung 72
Localizable.strings 501
Localization native development region 424
Logischer Operator 55, 88
Lokalisierung 155
long 69
M
MacRuby 486
main() 60, 143
MainMenu 37, 149, 159
MainMenu.xib 37
MainWindow.xib 404, 410
makeKeyAndOrderFront 231
makeKeyAndOrderFront: 159
makeKeyAndVisible 416
Managed Object Class 225
Mediator 139
Menübefehl
Kurzbefehl 270
Menüeintrag
Deaktivieren 310
Menüpunkt
Hinzufügen 243, 270
Umbenennen 242
510
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 510
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
NSArrayController 213, 216, 229
Auswahl prüfen 313
setSelectedObjects: 364
NSAssert() 248
NSAttributedString 265
dataFromRange:
documentAttributes:error: 301
NSAutoreleasePool 132
NSButton 28, 40, 145
NSCoder 370
NSComparisonResult 92
N
NSController 213
NSData 290, 362, 363, 377
Nachricht 26, 75
initWithContentsOfURL: 292
Navigation Controller 411
writeToFile:atomically: 381
Navigation Item 411
NSDate 176
Navigation-based Application 407
NSDateFormatter 431
navigationItem 421
NSDictionary 82, 110
NeXT 137
dictionaryWithContentsOfFile: 83
NeXT Interface Builder 36
dictionaryWithObjectsAndKeys: 82
nextKeyView 158, 223
objectForKey: 83
NeXTStep 36, 137, 483, 504
NSDictionaryController 213
Nib 36
NSDragPboard 361
nil 81
NSEntityDescription 204
NO 69
insertNewObjectForEntityForName:
No Editor 33
inManagedObjectContext: 204
noErr 322
NSError 245, 260, 322
Notification 154
NSExcludedElementsNotification Center 141
DocumentAttribute 302
NS 137
NSFetchedResultsController 413, 418
NS_BLOCK_ASSERTIONS 251
objectAtIndexPath: 426
NSAddTemplate 169, 229
performFetch: 423
NSAlert 245, 260, 262
NSFetchRequest
207, 237
addButtonWithTitle: 263
setEntity: 204
setInformativeText: 263
setSortDescriptors: 205, 237
setMessageText: 263
NSFileHandle 377, 380
NSAlertFirstButtonReturn 263
readDataToEndOfFile 380
NSApp 272
beginSheet:modalForWindow:modalDelegate: NSFileManager 197, 377, 382
copyPath:toPath:handler: 383
didEndSelector:contextInfo: 272
createDirectoryAtPath:attributes: 197
endSheet: 273
movePath:toPath:handler: 382
mainWindow 347
removeFileAtPath:handler: 383
runModalForWindow: 272
NSFindPboard 361
stopModal 273, 274
NSFontPboard 361
NSApplication 139, 143, 160, 198,
NSGeneralPboard 361
504
NSInteger 69
NSApplicationSupportDirectory 196
NSInvocation 370
NSApplicationTerminateReply 198
NSInvocationOperation 351
NSArray 80, 176
initWithTarget:
arrayWithObjects: 81
selector:object: 354
objectAtIndex: 81, 107
Menu Item 270
MetaWeblog-API 293
Methode 27
Microsoft 267
Mitteilung 154
Mode 229
Model Key Path 216, 238
Model-View-Controller 139
Multithreading 350
511
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 511
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
NSKeyedArchiver 370
NSLayoutManager 265
NSLocalizedString 419, 501
NSLog() 246
NSMakePoint 397
NSManagedContext
insertObject: 204
NSManagedObject 174, 177, 226
awakeFromInsert 226, 227
NSManagedObjectContext 174, 409,
413
addObject: 235
objectWithID: 235
NSManagedObjectModel 174, 409
fetchRequestFromTemplateWithName:
substitutionVariables: 207
NSMutableArray 81
insertObject:atIndex: 81
removeLastObject 82
NSMutableAttributedString 266
addAttribute:value:range: 267
NSMutableDictionary 84
setObject:forKey: 84
NSMutableString 79
addObject: 82
appendString: 79
insertString:atIndex: 79
UTF8String 80
NSMutableURLRequest 289
NSNetwork 311
NSNoSelectionMarker 313
NSNotificationCenter 388, 504
keyboardWasShown: 446
NSNumber 77
compare: 78, 92
floatValue 77
integerValue 77, 84
numberWithFloat: 77
numberWithInteger: 83
NSObject 42, 115, 118, 146, 152
performSelectorOnMainThread:withObject:
waitUntilDone: 355
NSObjectController 213
NSOKButton 380
NSOpenPanel 377
runModalForTypes: 379
setAllowsMultipleSelection: 378
setCanChooseDirectories: 378
NSOperation 351
NSOperationQueue 292, 340, 349,
351
addOperation: 355
new 352
NSOrderedAscending 92
NSOrderedDescending 92
NSOrderedSame 92
NSOSStatusErrorDomain 322
NSPageLayout 340
NSPanel 229, 267, 280
NSPasteboard 272, 359
availableTypeFromArray: 364
dataForType: 362
declareTypes:owner: 369
setData:forType: 369
NSPDFPboardType 361
NSPersistentStore 175
NSPersistentStoreCoordinator 175,
196, 409
NSPopUpButton 28
NSPredicate 185
NSPreferencesGeneral 170
NSPrintInfo 340
sharedPrinterInfo 347
sharedPrintInfo 340
NSPrintOperation 340
runOperation 340
runOperationModal
ForWindow:delegate:
didRunSelector:contextInfo: 347
NSPrintViewOperation 347
printOperationWithView:printInfo: 347
NSProgressIndicator 28, 309, 313
Display When Stopped 314
Spining 314
startAnimation: 315
stopAnimation: 315
NSRange 267, 363
NSRect 341
NSRemoveTemplate 170, 229
NSRTFPboardType 360
NSRulerPboard 361
NSSavePanel 377, 380
runModal 381
setAllowedFileTypes: 381
setRequiredFileType: 381
NSSearchPathForDirectoriesInDomains() 195
NSSet 176, 221
NSSortDescriptor 205, 237
512
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 512
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
initWithKey:ascending: 237
NSString 61, 78
initWithContentsOfURL: 292
initWithData:encoding: 291, 363
isEqualToString: 95
length 78
paragraphRangeForRange: 363
stringWithFormat: 61
stringWithUTF8String: 78, 119
substringWithRange: 363
UTF8String 79
NSStringPboardType 360, 363
NSTerminateCancel 261
NSTerminateNow 199, 262
NSText
copy: 366
NSTextField 38, 145
NSTextStorage 202, 265
addAttribute:value:range: 274
appendAttributedString: 202
NSTextView 222, 265
alignLeft: 266
scrollRangeToVisible: 202
selectedRange 272
setFont: 266
textStorage 202
underline: 266
NSTIFFPboardType 361
NSToolbar 27
NSTreeController 213
NSUInteger 69
NSUndoManager 370
registerUndoWithTarget:
selector:object: 372
setActionName: 374
NSURL 197, 288
URLWithString: 273
NSURLConnection 289
connection:didFailWithError: 292
connection:didReceiveData: 292
connection:didReceiveResponse: 292
connectionDidFinishLoading: 292
sendSynchronousRequest:
returningResponse:error: 290
NSURLHTTPResponse 289
NSURLRequest 289
cachePolicy: 289
requestWithURL: 289
timeoutInterval: 289
NSURLResponse 289
NSUserDefaultController 240
NSUserDefaults 162, 453
registerDefaults: 164, 165
setObject:forKey: 167
standardUserDefaults 165
stringForKey: 166
synchronize 167
NSUserDomainMask 196
NSUserFullName() 457
NSValue 397
valueWithPoint: 397
NSView 28, 158, 340
Undo 371
NSWindow 27, 156, 280
makeKeyAndOrderFront: 171
windowDidBecomeKey: 165
windowDidResignKey: 165
NSWindowController 282, 283, 405
initWithMainFrameURL: 284
showWindow: 285
NULL 324
Null-Zeichen 72
O
objc_startCollectorThread() 128
objectID 235
Objective-C 25, 51
Objective-C class 34
Objective-C Garbage Collection 168
Objective-C NSWindowController
subclass 282
Objekt 25
Allozieren 118
Initialisieren 118
Observer 141
opacity 386, 389
openDocument: 378
OpenGL 387
Operation 25
Operator 54
Outlet 44, 146, 160
P
Pal. Label 169
Panel
orderOut: 273
Parameter 116
paste: 366
513
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 513
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
pboard 359
PDF 339
PDFKit 143
persistentStoreCoordinator 409
Polymorphie 28
pool 132
Portable Operating System Interface 504
POSIX 277, 504
PostScript 339
Predicate 184
Preferences. . . 155
PreferenceSpecifiers 455
Prepares Content 216, 229
Preprocessor Macros 247
presentError: 262
print: 341
printf() 60, 61
Programmcode 64
Project Builder 17
Property 123
Property List Editor 162, 317
Protokoll 140, 300
Provisioning Profile 469
Proxy 288
PSGroupSpecifier 455
PSTextFieldSpecifier 455
pt 347
Push Button 40
puts() 91
PyObjC 483
Python 65, 68, 127, 483
Q
Quartz 504
QuartzCore 387
QuickLook 280
R
Rückgabewert 116, 259
readonly 125
Received Actions 146
Reference Counting 113, 127
Register 64
release 129
Release When Closed 157
remove: 224
Resize 157
Responder Chain 366
Responder-Kette 365
respondsToSelector: 141
retain 129
return 62, 93, 97
Rich-Text-Format 267
rightBarButtonItem 421
Root View Controller 411
Root.plist 454
Root.strings 454
RTF 360
Ruby 25, 65, 68, 127, 486
Ruby on Rails 487
RubyCocoa 486
runModal 263
S
Safari 278, 341
saveDocumentAs: 380
scanf() 60, 61
Schlüsselwort 55
SecKeychainAddGenericPassword() 317, 322
SecKeychainFindGenericPassword() 318, 324
SecKeychainItemModifyAttributesAndData() 318
SecKeychainItemModifyAttributesAndData() 325
SecKeychainItemRef 318
Secure Text Field 157
Security Framework 318
selection 218
selector 159
self 119
Semikolon 53
Sent Actions 159
Separator Menu Item 270
Setter-Methode 123
settings 453
Settings Bundle 454
Shared User Defaults Controller 240
Sheet 268
short 69
Show Message Bubble 258
SIGABRT 252
Simulate Interface 282
Simulator - 3.0 Debug 417
514
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 514
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
Singleton 504
sleep() 350
Smalltalk-80 25
Software Development Kit 401, 504
Spinning Beachball 350
SQL 184, 504
SQLite 384, 409
Square Button 228
Stack 64
strlen() 322
struct 73
Structured Query Language 184, 504
super 119
switch 87, 91
Symbolleiste anpassen 169
syntax error 53
T
Tab Bar Application 408
Table Column 217
Table View 217
Target-Action 142
Text Field 38
TextEdit 267
TextView 222, 265
Thread 350, 504
thread safe 355
Timeout 290
Title 38
to-many-Beziehung 181
TODO 480
Toolbar Item Actions 169
Typecasting 70, 326
U
UIAlertView 458, 463
UIApplication 401, 404, 410
ActivityIndicatorVisible 462
UIApplicationDelegate 404
applicationDidReceiveMemoryWarning: 404
applicationDidFinishLaunching: 404
UIBarButtonItem 421
UIBarButtonSystemItemAdd 421
UIControl 440
UIDatePicker 439, 440
UIKeyboardBoundsUserInfoKey 448
UIKit 143, 401
UILabel 426
UINavigationController 405, 410
pushViewController:animated: 437
UITableView 405, 410, 412, 418
Cell 426
deleteRowsAtIndexPaths:withRowAnimation: 428
deselectRowAtIndexPath:animated: 465
numberOfSectionsInTableView: 433
reload 419
tableView:numberOfRowsInSection: 425,
433
UITableViewCell 426
bounds 435
contentView 435
indexPath 426
UITableViewCellAccessoryDisclosureIndicator 434
UITableViewCellEditingStyleDelete 428
UITableViewCellStyleSubtitle 426
UITableViewCellStyleValue2 434
UITableViewController 405, 412
UITableViewDataSource 424, 433
numberOfSectionsInTableView: 425
tableView:cellForRowAtIndexPath: 426
tableView:commitEditingStyle:
forRowAtIndexPath: 428
UITableViewDelegate 433, 465
tableView:didSelectRowAtIndexPath: 437,
450
tableView:heightForRowAtIndexPath: 434
UITextAlignmentCenter 436
UITextField 401, 439
UITextView 439, 441
UITextViewDelegate
textViewDidEndEditing: 448
UIView 401, 404, 410
UIViewController 404, 410, 411
viewDidAppear: 420
viewDidDisappear: 420
viewDidLoad 420
viewDidUnload 420
viewWillAppear: 420
viewWillDisappear: 420
UIViewController subclass 439
UIWindow 410
uncaught exception 484
Undo 371
unsigned char 69, 70
unsigned int 69
unsigned long 69
515
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check: äöüÄÖÜ.
S. 515
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
Index
unsigned short 69
URL Loading System 288, 349, 406
Use Core Data for storage 408
UTF-16 503
UTF-8 78, 322, 503
V
validateToolbarItem: 312
validateUserInterfaceItem: 364
Value with Pattern 239
valueForKey: 214
valueForKeyPath: 214
Variable
Definition 65
Global 67, 98
Lokal 65
Vererbung 28, 42, 481
Vergleichsoperator 54, 87
Version Control System 36
View 504
View XIB 429
viewWillAppear: 423
Visible At Launch 157, 268
void 99, 116
W
Web Services Framework 288, 294
WebKit 143, 278, 341
WebKit.h 283
WebObjects 152
WebPanelController 285
WebView 281, 388
documentView 347
frameView 347
initWithMainFrameURL: 283
loadHTMLString:baseURL: 345
mainFrame 347
setFrameLoadDelegate: 345
setMainFrameURL: 284
WebDocumentView 347
webView:didFinishLoadForFrame: 346
WebViewProgressFinishedNotification 388
WebViewProgressStartedNotification 388
while 101
Window 37, 149
Window-based Application 407
windowDidBecomeKey: 390
windowDidLoad 284, 388
windowDidResignKey: 390
windowWillClose: 391
windowWillReturnUndoManager: 371
With XIB for user interface 439
WordPress 293
Wrapper 317
Wrapping Label 395
X
Xcode 254, 475
Add Localization 499
Groups & Files 482
Lesezeichen 479
Make File Localizable 499
Model Browser 481
Organizer 470
Xerox 25
Xib 36, 504
Xib-Datei
Einbinden 280
XML-RPC 293, 460
xmlrpc.php 305
Y
YES 69
Z
Zoll 347
Zuweisungsoperator 54, 88
Zwischenablage 359
516
K. Surendorf und M. Hardt, Einstieg in Objective-C und Cocoa
Galileo Press, ISBN: 978-3-8362-1310-3
Layout: gp.cls, Version 3.2.005 (15th August 2009), (C) Dr. Daniel Lauer, Bonn
Mit TEX bearbeitet am 8. September 2009, 9:06 Uhr Umlaut-Check:
S. 516
Einstellungen: mit Marginalien – ohne Seitenrand – mit Taben – mit Kapitel-Intro – normal breit – Zoom auf 100.0%
äöüÄÖÜ.
Herunterladen
Explore flashcards