Apps für iOS 10 professionell entwickeln

Sauberen Code schreiben mit Swift 3 und Objective-C. Stabile Apps für iPhone und iPad programmieren. Techniken & Methoden von Grund auf verstehen
 
 
Hanser (Verlag)
  • erschienen am 16. Januar 2017
  • |
  • 808 Seiten
 
E-Book | ePUB mit Wasserzeichen-DRM | Systemvoraussetzungen
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-45250-3 (ISBN)
 
Mit Swift 3 und Objective-C professionelle Apps entwickeln - das Praxisbuch für alle iOS-Entwickler
Diese komplett überarbeitete und aktualisierte Neuauflage bietet Ihnen einen vollständigen Überblick über alle wichtigen Methoden und Techniken der iOS 10-Programmierung. Thomas Sillmann zeigt Ihnen, wie Sie auf einer sauberen Code-Basis zukunftsfähige Apps für iPhone, iPad und Apple Watch entwickeln.

Entwickeln, warten und erweitern Sie Ihre eigenen, mobilen Anwendungen
Sie lernen Swift 3 und Objective-C von Grund auf kennen und erfahren alles Wissenswerte über die Grundlagen der iOS-Entwicklung sowie die Entwicklungsumgebung Xcode. Darauf aufbauend beschäftigen Sie sich mit zentralen Themen der iOS-Programmierung wie MVC-Pattern, View-Controller und Views sowie Datenhaltung.

Um fortgeschrittene Bereiche wie Local und Push Notifications und alle verfügbaren Arten von Extensions geht es in den folgenden Kapiteln. Abgerundet wird das Buch durch die Themen Unit-, UI- und Performance-Tests, Versionierung mit Git sowie der Arbeit im Team mit dem Xcode-Server. Schließlich veröffentlichen Sie im App Store eigene professionelle Anwendungen für iPhone, iPad und Apple Watch.

Extra: E-Book inside
Systemvoraussetzungen für E-Book inside: Internet-Verbindung und Adobe-Reader oder Ebook-Reader bzw. Adobe Digital Editions.
1., aktualisierte und erweiterte Auflage
  • Deutsch
  • München
  • |
  • Deutschland
  • 18,80 MB
978-3-446-45250-3 (9783446452503)
3446452508 (3446452508)
weitere Ausgaben werden ermittelt
Thomas Sillmann ist leidenschaftlicher iOS-App-Entwickler, Trainer und Autor. Mit seiner Begeisterung für das Schreiben hat er bereits drei sehr erfolgreiche Fachbücher und auch einige Kurzgeschichten veröffentlicht. Thomas lebt und arbeitet in Aschaffenburg.
1 - Inhalt [Seite 8]
2 - Vorwort [Seite 22]
3 - Danksagung [Seite 26]
4 - 1 Über iOS [Seite 28]
4.1 - 1.1 Was ist iOS? [Seite 28]
4.1.1 - 1.1.1 iOS und macOS [Seite 29]
4.1.2 - 1.1.2 Besonderheiten der iOS-Plattform [Seite 30]
4.2 - 1.2 iOS für Entwickler [Seite 31]
4.2.1 - 1.2.1 Hardware für Entwickler [Seite 31]
4.2.2 - 1.2.2 Software für Entwickler [Seite 33]
4.2.3 - 1.2.3 Das Apple Developer Program [Seite 33]
4.3 - 1.3 Der Aufbau von iOS [Seite 35]
4.3.1 - 1.3.1 Die vier Schichten von iOS [Seite 35]
4.4 - 1.4 Die perfekte iOS-App [Seite 37]
4.4.1 - 1.4.1 iOS Human Interface Guidelines [Seite 38]
5 - 2 Die (bisherige) Programmiersprache - Objective-C [Seite 40]
5.1 - 2.1 Über Objective-C und objektorientierte Programmierung [Seite 40]
5.2 - 2.2 Grundlagen der Programmierung [Seite 41]
5.2.1 - 2.2.1 Objekte [Seite 41]
5.2.2 - 2.2.2 Primitive Datentypen [Seite 41]
5.2.3 - 2.2.3 Variablen [Seite 42]
5.2.4 - 2.2.4 Operatoren [Seite 44]
5.2.5 - 2.2.5 Abfragen und Schleifen [Seite 44]
5.2.6 - 2.2.6 Kommentare [Seite 49]
5.3 - 2.3 Aufbau einer Klasse [Seite 50]
5.3.1 - 2.3.1 Die Header-Datei [Seite 50]
5.3.2 - 2.3.2 Die Implementation-Datei [Seite 52]
5.3.3 - 2.3.3 Los geht's: Unsere erste Klasse! [Seite 53]
5.4 - 2.4 Methoden [Seite 57]
5.4.1 - 2.4.1 Aufbau von Methoden [Seite 57]
5.4.2 - 2.4.2 Methoden in Header- und Implementation-Dateien einer Klasse [Seite 59]
5.4.3 - 2.4.3 Implementierung von Methoden [Seite 61]
5.4.4 - 2.4.4 Methoden aufrufen [Seite 63]
5.4.5 - 2.4.5 Klassen- und Instanzmethoden [Seite 64]
5.5 - 2.5 Instanzvariablen [Seite 65]
5.6 - 2.6 Properties [Seite 67]
5.6.1 - 2.6.1 Aufbau einer Property [Seite 67]
5.6.2 - 2.6.2 Die Punktnotation [Seite 69]
5.6.3 - 2.6.3 Optionen [Seite 70]
5.6.4 - 2.6.4 Direktzugriff auf Properties [Seite 72]
5.6.5 - 2.6.5 Setter und Getter überschreiben [Seite 74]
5.7 - 2.7 Konstanten [Seite 76]
5.7.1 - 2.7.1 Deklaration von Konstanten [Seite 77]
5.8 - 2.8 Namenskonventionen [Seite 78]
5.8.1 - 2.8.1 Klassen [Seite 78]
5.8.2 - 2.8.2 Methoden [Seite 78]
5.8.3 - 2.8.3 Properties [Seite 79]
5.9 - 2.9 Strukturen [Seite 79]
5.9.1 - 2.9.1 enum [Seite 79]
5.9.2 - 2.9.2 typedef [Seite 80]
5.10 - 2.10 Initialisierung von Objekten [Seite 81]
5.10.1 - 2.10.1 alloc und init [Seite 82]
5.10.2 - 2.10.2 Zeiger [Seite 84]
5.11 - 2.11 init im Detail [Seite 85]
5.11.1 - 2.11.1 Erstellen eigener init-Methoden [Seite 87]
5.11.2 - 2.11.2 Designated Initializer [Seite 88]
5.12 - 2.12 Vererbung [Seite 90]
5.12.1 - 2.12.1 Methoden der Superklasse überschreiben [Seite 92]
5.13 - 2.13 Kategorien [Seite 94]
5.13.1 - 2.13.1 Aufbau von Kategorien [Seite 94]
5.13.2 - 2.13.2 Kategorien in Xcode erstellen [Seite 95]
5.13.3 - 2.13.3 Verwenden von Kategorien [Seite 97]
5.14 - 2.14 Erweiterungen [Seite 97]
5.14.1 - 2.14.1 Aufbau von Erweiterungen [Seite 98]
5.14.2 - 2.14.2 Erweiterungen innerhalb der Implementation-Datei [Seite 98]
5.14.3 - 2.14.3 Erweiterungen in Xcode erstellen [Seite 99]
5.15 - 2.15 Protokolle [Seite 100]
5.15.1 - 2.15.1 Aufbau von Protokollen [Seite 101]
5.15.2 - 2.15.2 Zuweisen eines Protokolls zu einer Klasse [Seite 102]
5.15.3 - 2.15.3 Vererbung in Protokollen [Seite 103]
5.15.4 - 2.15.4 Protokolle in Xcode erstellen [Seite 103]
5.16 - 2.16 #import und @class [Seite 105]
5.16.1 - 2.16.1 #import [Seite 105]
5.16.2 - 2.16.2 @class [Seite 106]
5.17 - 2.17 Blöcke [Seite 107]
5.17.1 - 2.17.1 Was sind Blöcke? [Seite 108]
5.17.2 - 2.17.2 Aufbau eines Blocks [Seite 108]
5.17.3 - 2.17.3 Zuweisen eines Blocks zu einer Variablen [Seite 109]
5.17.4 - 2.17.4 Nutzen eines Blocks als Parameter einer Methode [Seite 110]
5.17.5 - 2.17.5 Blöcke als Properties [Seite 112]
5.17.6 - 2.17.6 Blockvariablen [Seite 112]
5.17.7 - 2.17.7 Globale Blöcke [Seite 113]
5.18 - 2.18 Singletons [Seite 114]
6 - 3 Der Neue im Club - Swift [Seite 116]
6.1 - 3.1 Programmierst du noch oder swifst du schon? [Seite 116]
6.1.1 - 3.1.1 Über Swift [Seite 116]
6.1.2 - 3.1.2 Voraussetzungen zur Nutzung von Swift [Seite 117]
6.1.3 - 3.1.3 Swift und Objective-C [Seite 117]
6.1.4 - 3.1.4 Playgrounds [Seite 118]
6.2 - 3.2 Grundlagen der Programmierung [Seite 120]
6.2.1 - 3.2.1 Swift Standard Library und Fundamental Types [Seite 120]
6.2.2 - 3.2.2 Variablen und Konstanten [Seite 122]
6.2.3 - 3.2.3 Operatoren [Seite 124]
6.2.4 - 3.2.4 Abfragen und Schleifen [Seite 125]
6.2.5 - 3.2.5 Kommentare [Seite 132]
6.2.6 - 3.2.6 print [Seite 133]
6.3 - 3.3 Fundamental Types und Swift Standard Library im Detail [Seite 135]
6.3.1 - 3.3.1 Strings [Seite 135]
6.3.2 - 3.3.2 Arrays [Seite 138]
6.3.3 - 3.3.3 Dictionaries [Seite 143]
6.3.4 - 3.3.4 Any und AnyObject [Seite 147]
6.4 - 3.4 Aufbau einer Klasse [Seite 147]
6.4.1 - 3.4.1 Erstellen einer Instanz einer Klasse [Seite 150]
6.4.2 - 3.4.2 Zugriff auf Eigenschaften einer Klasse [Seite 150]
6.5 - 3.5 Methoden [Seite 151]
6.5.1 - 3.5.1 Methoden mit Rückgabewert [Seite 152]
6.5.2 - 3.5.2 Methoden mit Parametern [Seite 153]
6.5.3 - 3.5.3 Local und External Parameter Names [Seite 156]
6.5.4 - 3.5.4 Methodennamen in Swift [Seite 158]
6.5.5 - 3.5.5 Aufruf von Methoden einer Klasse [Seite 159]
6.5.6 - 3.5.6 Zugriff auf andere Eigenschaften und Methoden einer Klasse [Seite 160]
6.5.7 - 3.5.7 Klassen- und Instanzmethoden [Seite 161]
6.5.8 - 3.5.8 Verändern von Parametern einer Methode mittels inout [Seite 163]
6.6 - 3.6 Closures [Seite 164]
6.6.1 - 3.6.1 Closures als Variablen und Konstanten [Seite 166]
6.6.2 - 3.6.2 Closures als Parameter für Methoden [Seite 167]
6.6.3 - 3.6.3 Kurzschreibweise für Closures als Parameter von Methoden [Seite 170]
6.7 - 3.7 Properties [Seite 173]
6.7.1 - 3.7.1 Computed Properties [Seite 174]
6.7.2 - 3.7.2 Property Observers [Seite 177]
6.7.3 - 3.7.3 Type Properties [Seite 178]
6.8 - 3.8 Vererbung [Seite 179]
6.8.1 - 3.8.1 Überschreiben von Eigenschaften und Methoden der Superklasse [Seite 181]
6.8.2 - 3.8.2 Zugriff auf Eigenschaften und Methoden der Superklasse [Seite 182]
6.9 - 3.9 Optionals [Seite 183]
6.9.1 - 3.9.1 Deklaration von Optionals [Seite 183]
6.9.2 - 3.9.2 Zugriff auf Optionals [Seite 184]
6.10 - 3.10 Initialisierung [Seite 187]
6.10.1 - 3.10.1 Schreiben von Initializern [Seite 188]
6.10.2 - 3.10.2 Designated und Convenience Initializer [Seite 193]
6.10.3 - 3.10.3 Initializer und Vererbung [Seite 194]
6.10.4 - 3.10.4 Deinitialisierung [Seite 196]
6.11 - 3.11 Type Casting [Seite 197]
6.11.1 - 3.11.1 Typ prüfen [Seite 197]
6.11.2 - 3.11.2 Downcasting [Seite 199]
6.12 - 3.12 Enumerations [Seite 201]
6.12.1 - 3.12.1 Zusätzliche Werte in Membern einer Enumeration speichern [Seite 202]
6.13 - 3.13 Structures [Seite 204]
6.14 - 3.14 Generics [Seite 205]
6.14.1 - 3.14.1 Generic Function [Seite 207]
6.14.2 - 3.14.2 Generic Type [Seite 209]
6.15 - 3.15 Error Handling Model [Seite 211]
6.16 - 3.16 Extensions [Seite 214]
6.17 - 3.17 Protocols [Seite 215]
6.17.1 - 3.17.1 Protocol Type [Seite 216]
6.18 - 3.18 Access Control [Seite 218]
7 - 4 Grundlagen der iOS-Entwicklung [Seite 220]
7.1 - 4.1 Foundation-Framework [Seite 220]
7.1.1 - 4.1.1 Die wichtigsten Klassen aus dem Foundation-Framework und ihre Funktionen [Seite 221]
7.2 - 4.2 UIKit-Framework [Seite 226]
7.3 - 4.3 Speicherverwaltung [Seite 226]
7.4 - 4.4 Besonderheiten von Objective-C [Seite 230]
7.4.1 - 4.4.1 Kurzschreibweisen zum Erstellen von Objekten [Seite 230]
7.4.2 - 4.4.2 Vergleichen der Werte von verschiedenen Objekten [Seite 233]
7.4.3 - 4.4.3 Schlüsselwörter zum Zusammenspiel mit Optionals [Seite 234]
7.5 - 4.5 Besonderheiten von Swift [Seite 235]
7.5.1 - 4.5.1 Zusammenspiel zwischen Fundamental Types und Foundation-Framework-Klassen [Seite 235]
7.5.2 - 4.5.2 Playgrounds im Detail [Seite 235]
7.6 - 4.6 ObjectiveC und Swift vereint [Seite 239]
7.6.1 - 4.6.1 ObjectiveC-Code in Swift verwenden [Seite 240]
7.6.2 - 4.6.2 Swift-Code in Objective-C verwenden [Seite 241]
7.7 - 4.7 NSError [Seite 241]
7.7.1 - 4.7.1 Eigene Methode mit NSError-Parameter erstellen [Seite 243]
7.8 - 4.8 Dokumentation [Seite 244]
7.8.1 - 4.8.1 Besonderheiten bei Methoden [Seite 245]
7.8.2 - 4.8.2 Doxygen-Dokumentation in Xcode [Seite 247]
7.9 - 4.9 Nebenläufigkeit mit Grand Central Dispatch [Seite 248]
7.9.1 - 4.9.1 Parallel laufenden Code erstellen [Seite 249]
7.10 - 4.10 Grundlegende Struktur einer App [Seite 251]
7.10.1 - 4.10.1 main.m [Seite 251]
7.10.2 - 4.10.2 Info.plist [Seite 252]
7.10.3 - 4.10.3 App Delegate [Seite 252]
7.11 - 4.11 Lebenszyklus einer iOS-App [Seite 253]
7.11.1 - 4.11.1 Start einer App [Seite 253]
7.11.2 - 4.11.2 Lebenszyklus einer App [Seite 254]
7.11.3 - 4.11.3 Die Methoden des App Delegate [Seite 255]
7.11.4 - 4.11.4 Start der App [Seite 256]
7.12 - 4.12 Tipps für die tägliche Arbeit [Seite 258]
7.12.1 - 4.12.1 Die netten Kleinigkeiten .?.?. [Seite 258]
7.12.2 - 4.12.2 Fast Enumeration in ObjectiveC [Seite 259]
7.12.3 - 4.12.3 Type Casting in ObjectiveC [Seite 259]
7.12.4 - 4.12.4 Xcode-Beispielprojekte [Seite 260]
8 - 5 Die Entwicklungsumgebung - Xcode [Seite 262]
8.1 - 5.1 Willkommen bei Xcode! [Seite 262]
8.1.1 - 5.1.1 Was ist Xcode? [Seite 263]
8.1.2 - 5.1.2 Interface Builder und Xcode - endlich vereint! [Seite 263]
8.2 - 5.2 Arbeiten mit Xcode [Seite 264]
8.2.1 - 5.2.1 Dateien und Formate eines Xcode-Projekts [Seite 264]
8.2.2 - 5.2.2 Umgang mit Dateien und Ordnern in Xcode [Seite 269]
8.3 - 5.3 Der Aufbau von Xcode [Seite 272]
8.3.1 - 5.3.1 Die Toolbar [Seite 272]
8.3.2 - 5.3.2 Die Navigation Area [Seite 274]
8.3.3 - 5.3.3 Die Editor Area [Seite 277]
8.3.4 - 5.3.4 Die Utilities Area [Seite 279]
8.3.5 - 5.3.5 Die Debug Area [Seite 280]
8.4 - 5.4 Einstellungen in Xcode [Seite 281]
8.4.1 - 5.4.1 Anpassen von Xcode [Seite 281]
8.4.2 - 5.4.2 General [Seite 281]
8.4.3 - 5.4.3 Accounts [Seite 282]
8.4.4 - 5.4.4 Behaviors [Seite 283]
8.4.5 - 5.4.5 Navigation [Seite 283]
8.4.6 - 5.4.6 Fonts & Colors [Seite 284]
8.4.7 - 5.4.7 Text Editing [Seite 285]
8.4.8 - 5.4.8 Key Bindings [Seite 285]
8.4.9 - 5.4.9 Source Control [Seite 286]
8.4.10 - 5.4.10 Components [Seite 287]
8.4.11 - 5.4.11 Locations [Seite 287]
8.5 - 5.5 Projekteinstellungen [Seite 288]
8.5.1 - 5.5.1 Grundlagen [Seite 288]
8.5.2 - 5.5.2 Einstellungen am Projekt [Seite 290]
8.5.3 - 5.5.3 Einstellungen am Target [Seite 293]
8.5.4 - 5.5.4 Einstellungen am Scheme [Seite 299]
8.6 - 5.6 Grafiken und Asset-Bundles [Seite 302]
8.7 - 5.7 Lokalisierung mit Localizable.strings [Seite 304]
8.7.1 - 5.7.1 Grundlagen [Seite 304]
8.7.2 - 5.7.2 NSLocalizedString [Seite 304]
8.7.3 - 5.7.3 Erstellen der Localizable.strings-Datei [Seite 305]
8.7.4 - 5.7.4 Localized String mit Parameter [Seite 307]
8.7.5 - 5.7.5 Alle Localized Strings automatisch auslesen [Seite 308]
8.8 - 5.8 Der iOS-Simulator [Seite 309]
8.8.1 - 5.8.1 Grundlagen [Seite 309]
8.8.2 - 5.8.2 Funktionen und Möglichkeiten des Simulators [Seite 309]
8.8.3 - 5.8.3 Performance und Einschränkungen des Simulators [Seite 313]
8.9 - 5.9 Dokumentation [Seite 313]
8.9.1 - 5.9.1 Nichts geht über die Dokumentation! [Seite 313]
8.9.2 - 5.9.2 Das Documentation-Window [Seite 316]
8.9.3 - 5.9.3 Direktes Aufrufen der Dokumentation aus Xcode heraus [Seite 319]
8.10 - 5.10 Devices [Seite 320]
8.11 - 5.11 Organizer [Seite 322]
8.12 - 5.12 Debugging in Xcode [Seite 325]
8.12.1 - 5.12.1 Was ist Debugging? [Seite 325]
8.12.2 - 5.12.2 Die Debug Area [Seite 325]
8.12.3 - 5.12.3 Die Arbeit mit dem Debugger - NSLog und Breakpoints [Seite 326]
8.12.4 - 5.12.4 Debug Navigator [Seite 335]
8.13 - 5.13 Refactoring [Seite 336]
8.13.1 - 5.13.1 Grundlagen [Seite 336]
8.13.2 - 5.13.2 Refactoring-Funktionen in Xcode [Seite 337]
8.14 - 5.14 Instruments [Seite 340]
8.14.1 - 5.14.1 Über Instruments [Seite 340]
8.14.2 - 5.14.2 Nächste Schritte [Seite 343]
8.15 - 5.15 Tipps für die tägliche Arbeit [Seite 343]
8.15.1 - 5.15.1 Man lernt immer was dazu! [Seite 343]
8.15.2 - 5.15.2 Code Snippets [Seite 344]
8.15.3 - 5.15.3 Open Quickly [Seite 345]
8.15.4 - 5.15.4 Caller einer Methode feststellen [Seite 346]
8.15.5 - 5.15.5 Speicherorte für Ordner und Dateien ändern [Seite 347]
8.15.6 - 5.15.6 Shortcuts für die Navigation Area [Seite 347]
8.15.7 - 5.15.7 Run Without Building [Seite 348]
8.15.8 - 5.15.8 Clean Build [Seite 349]
9 - 6 MVC - Model-View-Controller [Seite 350]
9.1 - 6.1 MVC .?.?. was? [Seite 350]
9.2 - 6.2 MVC in der Praxis [Seite 352]
9.3 - 6.3 Kommunikation zwischen Model und Controller [Seite 352]
9.3.1 - 6.3.1 Key-Value-Observing [Seite 353]
9.3.2 - 6.3.2 Notifications [Seite 359]
9.4 - 6.4 Kommunikation zwischen View und Controller [Seite 362]
9.4.1 - 6.4.1 Target-Action [Seite 362]
9.4.2 - 6.4.2 Delegation [Seite 364]
10 - 7 Die Vielfalt der (View-)Controller [Seite 366]
10.1 - 7.1 Alles beginnt mit einem View-Controller .?.?. [Seite 366]
10.2 - 7.2 UIViewController - die Mutter aller View-Controller [Seite 368]
10.2.1 - 7.2.1 Wichtige Methoden von UIViewController [Seite 370]
10.2.2 - 7.2.2 UIView - fester Bestandteil eines jeden UIViewControllers [Seite 372]
10.3 - 7.3 View-Controller-Hierarchien [Seite 373]
10.4 - 7.4 View-Controller erstellen mit dem Interface Builder [Seite 375]
10.4.1 - 7.4.1 View-Controller mit NIB-File [Seite 376]
10.5 - 7.5 Storyboards [Seite 406]
10.5.1 - 7.5.1 Über Storyboards [Seite 406]
10.5.2 - 7.5.2 Das Storyboard-Projekt [Seite 407]
10.5.3 - 7.5.3 Die Klasse UIStoryboard [Seite 417]
10.5.4 - 7.5.4 Segues [Seite 419]
10.5.5 - 7.5.5 Zugriff über den App Delegate [Seite 422]
10.5.6 - 7.5.6 Quo vadis - Storyboard oder NIB-File? [Seite 423]
10.6 - 7.6 Auto Layout [Seite 424]
10.6.1 - 7.6.1 Setzen und Konfigurieren von Constraints [Seite 424]
10.6.2 - 7.6.2 Constraints bearbeiten und weiter anpassen [Seite 426]
10.6.3 - 7.6.3 "Optimale" Constraints automatisch setzen lassen [Seite 428]
10.7 - 7.7 UIViewController und seine Subklassen [Seite 429]
10.7.1 - 7.7.1 UINavigationController [Seite 430]
10.7.2 - 7.7.2 UITabBarController [Seite 436]
10.7.3 - 7.7.3 UITableViewController [Seite 440]
10.7.4 - 7.7.4 UICollectionViewController [Seite 447]
10.7.5 - 7.7.5 UISplitViewController [Seite 448]
11 - 8 Views erstellen und gestalten [Seite 452]
11.1 - 8.1 Über Views in iOS [Seite 452]
11.2 - 8.2 UIView - die Mutter aller Views [Seite 452]
11.3 - 8.3 Arbeiten mit UIView [Seite 453]
11.3.1 - 8.3.1 Programmatisches Erstellen einer UIView [Seite 453]
11.3.2 - 8.3.2 View-Hierarchien [Seite 455]
11.3.3 - 8.3.3 Weiterführendes zu UIView [Seite 459]
11.4 - 8.4 Views erstellen mit dem Interface Builder [Seite 460]
11.4.1 - 8.4.1 Grundlagen [Seite 460]
11.4.2 - 8.4.2 View-Klasse mit NIB-File erstellen [Seite 461]
11.4.3 - 8.4.3 Beliebiges NIB-File laden und verwenden [Seite 465]
11.4.4 - 8.4.4 NIB-File nachträglich erstellen [Seite 466]
11.4.5 - 8.4.5 Unterschiedliche NIB-Files für iPhone und iPad erstellen [Seite 468]
11.5 - 8.5 Die wichtigsten Views und ihre Funktionen [Seite 470]
11.5.1 - 8.5.1 Grundlagen [Seite 470]
11.5.2 - 8.5.2 UILabel [Seite 470]
11.5.3 - 8.5.3 UIButton [Seite 470]
11.5.4 - 8.5.4 UISwitch [Seite 471]
11.5.5 - 8.5.5 UISegmentedControl [Seite 471]
11.5.6 - 8.5.6 UITextField [Seite 471]
11.5.7 - 8.5.7 UIImageView [Seite 472]
11.5.8 - 8.5.8 UIPickerView [Seite 472]
11.5.9 - 8.5.9 UIDatePicker [Seite 473]
11.5.10 - 8.5.10 UIWebView [Seite 473]
11.5.11 - 8.5.11 UIMapView [Seite 474]
11.5.12 - 8.5.12 UIScrollView [Seite 474]
11.5.13 - 8.5.13 UITextView [Seite 475]
11.5.14 - 8.5.14 UITableView [Seite 476]
11.5.15 - 8.5.15 UICollectionView [Seite 476]
11.5.16 - 8.5.16 Wichtig und unerlässlich: die Dokumentation! [Seite 476]
11.5.17 - 8.5.17 Views und der Interface Builder [Seite 477]
11.6 - 8.6 Die Grundlage gut gestalteter Views [Seite 477]
12 - 9 Das Model und die Datenhaltung [Seite 480]
12.1 - 9.1 Die Logik Ihrer App [Seite 480]
12.2 - 9.2 Benutzereinstellungen sichern und nutzen [Seite 481]
12.2.1 - 9.2.1 Über UserDefaults [Seite 481]
12.2.2 - 9.2.2 Standardeinstellungen festlegen [Seite 484]
12.3 - 9.3 Zugriff auf das Dateisystem [Seite 484]
12.3.1 - 9.3.1 Das Dateisystem von iOS [Seite 484]
12.3.2 - 9.3.2 FileManager [Seite 486]
12.3.3 - 9.3.3 File-Sharing-Funktion nutzen [Seite 493]
12.4 - 9.4 Core Data [Seite 494]
12.4.1 - 9.4.1 Datenbankverwaltung mit Core Data [Seite 494]
12.4.2 - 9.4.2 Wie funktioniert Core Data? [Seite 495]
12.4.3 - 9.4.3 Die Klassen und Bestandteile von Core Data [Seite 496]
12.4.4 - 9.4.4 Aufbau eines Standard-Core Data Stacks [Seite 497]
12.4.5 - 9.4.5 Der Core Data-Editor [Seite 500]
12.4.6 - 9.4.6 Erstellen eines neuen Managed-Objects [Seite 508]
12.4.7 - 9.4.7 Löschen eines Managed-Objects [Seite 509]
12.4.8 - 9.4.8 Laden von Managed-Objects [Seite 509]
12.4.9 - 9.4.9 Was kommt als Nächstes? [Seite 511]
13 - 10 Local und Push Notifications [Seite 512]
13.1 - 10.1 Was sind Notifications? [Seite 512]
13.2 - 10.2 Registrieren von Notification Types [Seite 514]
13.3 - 10.3 Registrieren von Notification Categories und Actions [Seite 518]
13.3.1 - 10.3.1 Erstellen einer Action [Seite 518]
13.3.2 - 10.3.2 Erstellen einer Kategorie [Seite 520]
13.3.3 - 10.3.3 Registrieren von Kategorien [Seite 522]
13.3.4 - 10.3.4 Reagieren auf eine Action [Seite 523]
13.4 - 10.4 Local Notifications [Seite 525]
13.4.1 - 10.4.1 Konfiguration des Alerts [Seite 525]
13.4.2 - 10.4.2 Konfiguration des Sounds [Seite 527]
13.4.3 - 10.4.3 Konfiguration des Badge Values [Seite 528]
13.4.4 - 10.4.4 Konfiguration von Audio, Bildern und Videos [Seite 528]
13.4.5 - 10.4.5 Speichern zusätzlicher Informationen in einer Local Notification [Seite 530]
13.4.6 - 10.4.6 Festlegen des Ausführungsereignisses [Seite 531]
13.4.7 - 10.4.7 Erstellen von Notification Requests [Seite 535]
13.4.8 - 10.4.8 Registrieren von Local Notifications im System [Seite 536]
13.4.9 - 10.4.9 Abbrechen bereits registrierter Local Notifications [Seite 537]
13.4.10 - 10.4.10 Reagieren auf den Erhalt einer Notification bei aktiver App [Seite 537]
13.5 - 10.5 Push Notifications [Seite 539]
13.5.1 - 10.5.1 Versand von Push Notifications [Seite 540]
13.5.2 - 10.5.2 Erstellen einer Push Notification [Seite 544]
13.5.3 - 10.5.3 Quality of Service [Seite 547]
14 - 11 Extensions [Seite 548]
14.1 - 11.1 Verfügbare Typen von Extensions [Seite 548]
14.2 - 11.2 Erstellen von Extensions in Xcode [Seite 551]
14.3 - 11.3 Funktionsweise einer Extension [Seite 554]
14.4 - 11.4 Wichtige Klassen und Objekte [Seite 555]
14.5 - 11.5 Unterstützte Dateitypen für Share- und Action-Extensions festlegen [Seite 556]
14.6 - 11.6 Action Extension [Seite 557]
14.6.1 - 11.6.1 Action mit User Interface [Seite 557]
14.6.2 - 11.6.2 Action ohne User Interface [Seite 558]
14.7 - 11.7 Content Blocker Extension [Seite 559]
14.7.1 - 11.7.1 Konfiguration eines Content Blockers [Seite 560]
14.7.2 - 11.7.2 Aktualisieren eines Content Blockers [Seite 563]
14.7.3 - 11.7.3 Die Klasse ContentBlockerRequestHandler [Seite 563]
14.8 - 11.8 Custom Keyboard [Seite 564]
14.8.1 - 11.8.1 Erstellen eines Custom Keyboards [Seite 564]
14.8.2 - 11.8.2 Arbeit mit der Klasse UIInputViewController [Seite 565]
14.8.3 - 11.8.3 Bearbeiten und Setzen von Text [Seite 567]
14.8.4 - 11.8.4 Mehrsprachige Keyboards [Seite 568]
14.9 - 11.9 Document Provider [Seite 568]
14.9.1 - 11.9.1 Document Provider-Extension [Seite 569]
14.9.2 - 11.9.2 File Provider [Seite 572]
14.9.3 - 11.9.3 Document Provider aufrufen [Seite 574]
14.10 - 11.10 iMessage Extension [Seite 576]
14.10.1 - 11.10.1 Aufbau und Funktionsweise der iMessage Extension [Seite 576]
14.10.2 - 11.10.2 Entwicklung einer iMessage Extension [Seite 580]
14.11 - 11.11 Intents Extension [Seite 591]
14.11.1 - 11.11.1 Domains und Intents [Seite 592]
14.11.2 - 11.11.2 Bestandteile einer Intents Extension [Seite 593]
14.11.3 - 11.11.3 Funktionsweise einer Intents Extension [Seite 594]
14.11.4 - 11.11.4 Übersicht über verfügbare Intents [Seite 603]
14.11.5 - 11.11.5 Voraussetzungen zur Verwendung von Siri in einer Intents Extension [Seite 605]
14.11.6 - 11.11.6 Erweitern von Siris Vokabular [Seite 608]
14.11.7 - 11.11.7 Testen einer Intents Extension [Seite 614]
14.12 - 11.12 Intents UI Extension [Seite 615]
14.12.1 - 11.12.1 Vorbereitung der Intents UI Extension [Seite 616]
14.12.2 - 11.12.2 Konfiguration des View-Controllers [Seite 617]
14.12.3 - 11.12.3 Default-Layout bei Maps und Messaging deaktivieren [Seite 619]
14.13 - 11.13 Notification Content Extension [Seite 619]
14.13.1 - 11.13.1 UNNotificationContentExtension [Seite 619]
14.13.2 - 11.13.2 Konfiguration der Info.plist-Datei [Seite 621]
14.14 - 11.14 Notification Service Extension [Seite 622]
14.15 - 11.15 Photo Editing Extension [Seite 623]
14.15.1 - 11.15.1 Festlegen der unterstützten Typen zur Bearbeitung [Seite 627]
14.16 - 11.16 Share Extension [Seite 628]
14.17 - 11.17 Shared Links Extension [Seite 629]
14.17.1 - 11.17.1 Erstellen eines NSExtensionItem [Seite 630]
14.17.2 - 11.17.2 NSExtensionItem als Shared Link bereitstellen [Seite 631]
14.18 - 11.18 Sticker Pack Extension [Seite 632]
14.18.1 - 11.18.1 Erstellen einer Sticker Pack Extension [Seite 633]
14.18.2 - 11.18.2 Komplexere Sticker Pack Extensions erstellen [Seite 637]
14.19 - 11.19 Today Extension [Seite 639]
14.19.1 - 11.19.1 Today Extension testen [Seite 641]
14.20 - 11.20 Watch App [Seite 642]
14.21 - 11.21 App Groups [Seite 642]
14.21.1 - 11.21.1 Registrieren einer App Group im Apple Developer Portal [Seite 643]
14.21.2 - 11.21.2 Registrieren einer App Group innerhalb einer App [Seite 644]
14.21.3 - 11.21.3 Zugriff auf eine App Group [Seite 645]
15 - 12 App-Entwicklung für die Apple Watch [Seite 648]
15.1 - 12.1 Apples neues großes Ding: Die Apple Watch [Seite 648]
15.2 - 12.2 Möglichkeiten, Einschränkungen, Unterschiede [Seite 649]
15.3 - 12.3 Das WatchKit SDK [Seite 651]
15.3.1 - 12.3.1 WKInterfaceController [Seite 652]
15.3.2 - 12.3.2 WKInterfaceObject [Seite 652]
15.3.3 - 12.3.3 WKExtensionDelegate [Seite 653]
15.3.4 - 12.3.4 Weitere Klassen [Seite 653]
15.4 - 12.4 Aufbau und Funktionsweise von Apple Watch-Apps [Seite 654]
15.4.1 - 12.4.1 iPhone-App [Seite 654]
15.4.2 - 12.4.2 WatchKit Extension [Seite 654]
15.4.3 - 12.4.3 WatchKit App [Seite 655]
15.4.4 - 12.4.4 Verbindung von WatchKit Extension und WatchKit App [Seite 655]
15.4.5 - 12.4.5 Notification Scene [Seite 655]
15.4.6 - 12.4.6 Complications [Seite 656]
15.5 - 12.5 Erstellen einer WatchKit App mitsamt WatchKit Extension [Seite 656]
15.5.1 - 12.5.1 Dateien der WatchKit Extension [Seite 659]
15.5.2 - 12.5.2 Dateien der WatchKit App [Seite 660]
15.5.3 - 12.5.3 Ausführen und Testen der Apple Watch-App [Seite 661]
15.6 - 12.6 Lebenszyklus einer WatchKit App [Seite 662]
15.7 - 12.7 Der WKInterfaceController im Detail [Seite 664]
15.7.1 - 12.7.1 Initialisierung [Seite 664]
15.7.2 - 12.7.2 Activation Events [Seite 666]
15.7.3 - 12.7.3 Setzen des Titels [Seite 666]
15.7.4 - 12.7.4 Ein- und Ausblenden von Interface-Controllern [Seite 667]
15.7.5 - 12.7.5 Umsetzen eines Navigation Stacks [Seite 669]
15.7.6 - 12.7.6 Reaktion auf Storyboard-Events [Seite 670]
15.7.7 - 12.7.7 Weitere Attribute [Seite 671]
15.7.8 - 12.7.8 Weitere Funktionen von WKInterfaceController [Seite 672]
15.8 - 12.8 Arbeiten mit dem Interface-Storyboard einer WatchKit App [Seite 672]
15.8.1 - 12.8.1 Erstellen und Konfigurieren eines WKInterfaceController [Seite 673]
15.8.2 - 12.8.2 Hinzufügen und Konfigurieren von Interface-Elementen [Seite 675]
15.8.3 - 12.8.3 Positionierung und Anordnung von Interface-Elementen [Seite 676]
15.8.4 - 12.8.4 Ändern der Größe von Interface-Elementen [Seite 676]
15.8.5 - 12.8.5 Unterschiedliche Konfigurationen für verschiedene Apple Watch-Größen [Seite 678]
15.8.6 - 12.8.6 Gruppierung von Interface-Elementen mittels WKInterfaceGroup [Seite 680]
15.8.7 - 12.8.7 Verbindung von Storyboard und Code [Seite 682]
15.8.8 - 12.8.8 Zusammenfassen mehrerer Interface-Controller zu einem page-based Interface [Seite 686]
15.8.9 - 12.8.9 Erstellen und Konfigurieren von Segues [Seite 686]
15.9 - 12.9 Erstellen von Tabellen [Seite 689]
15.9.1 - 12.9.1 Hinzufügen einer Tabelle im Storyboard [Seite 689]
15.9.2 - 12.9.2 Konfiguration einer Zelle [Seite 690]
15.9.3 - 12.9.3 Konfiguration einer Tabelle [Seite 694]
15.9.4 - 12.9.4 Verwenden verschiedener Zellen in einer Tabelle [Seite 696]
15.9.5 - 12.9.5 Zellen hinzufügen und entfernen [Seite 699]
15.9.6 - 12.9.6 Direkt zu einer bestimmten Zelle scrollen [Seite 700]
15.9.7 - 12.9.7 Aktuelle Anzahl an Zellen auslesen [Seite 700]
15.9.8 - 12.9.8 Auf die Auswahl einer Zelle reagieren [Seite 701]
15.9.9 - 12.9.9 Segues von Zellen einer Tabelle über das Storyboard konfigurieren [Seite 702]
15.10 - 12.10 Erstellen von Menüs [Seite 703]
15.10.1 - 12.10.1 Erstellen eines Menüs im Storyboard [Seite 704]
15.10.2 - 12.10.2 Erstellen eines Menüs im Code [Seite 708]
15.10.3 - 12.10.3 Fazit: Menüerstellung im Storyboard oder im Code? [Seite 710]
15.10.4 - 12.10.4 Mischen von Menüpunkten aus Storyboard und Code [Seite 711]
15.11 - 12.11 Eingabe von Text [Seite 711]
15.12 - 12.12 Notification Scene [Seite 713]
15.12.1 - 12.12.1 Short-Look und Long-Look Interface [Seite 714]
15.12.2 - 12.12.2 Long-Look Interface im Detail [Seite 715]
15.12.3 - 12.12.3 Erstellen eigener Notification Scenes [Seite 716]
15.12.4 - 12.12.4 Testen einer Notification Scene [Seite 724]
15.13 - 12.13 Complications [Seite 724]
15.13.1 - 12.13.1 Was sind Complications? [Seite 725]
15.13.2 - 12.13.2 Das ClockKit Framework [Seite 725]
15.13.3 - 12.13.3 Aufbau und Bestandteile von Complications [Seite 725]
15.13.4 - 12.13.4 Vorbereiten des eigenen Projekts [Seite 729]
15.13.5 - 12.13.5 Entwicklung einer Complication [Seite 731]
15.13.6 - 12.13.6 Bereitstellen der Complication mittels CLKComplicationDataSource [Seite 736]
15.14 - 12.14 Kommunikation und Datenaustausch zwischen iOS und watchOS [Seite 739]
15.14.1 - 12.14.1 Watch Connectivity [Seite 740]
15.15 - 12.15 Was sonst noch zu sagen und zu beachten ist [Seite 745]
16 - 13 Tests [Seite 748]
16.1 - 13.1 Unit-Tests [Seite 748]
16.1.1 - 13.1.1 Aufbau und Funktionsweise von Unit-Tests [Seite 753]
16.1.2 - 13.1.2 Aufbau einer Test-Case-Klasse [Seite 755]
16.1.3 - 13.1.3 Neue Test-Case-Klasse erstellen [Seite 757]
16.1.4 - 13.1.4 Ausführen von Unit-Tests [Seite 759]
16.1.5 - 13.1.5 Was sollte ich eigentlich testen? [Seite 761]
16.2 - 13.2 Performance-Tests [Seite 761]
16.3 - 13.3 UI-Tests [Seite 763]
16.3.1 - 13.3.1 Klassen für UI-Tests [Seite 764]
16.3.2 - 13.3.2 Aufbau von UI-Test-Klassen [Seite 767]
16.3.3 - 13.3.3 Automatisches Erstellen von UI-Tests [Seite 767]
16.3.4 - 13.3.4 Einsatz von UI-Tests [Seite 768]
16.4 - 13.4 Test-Driven Development [Seite 768]
17 - 14 Versionierung [Seite 770]
17.1 - 14.1 Über Versionskontrolle [Seite 770]
17.2 - 14.2 Basisfunktionen und -begriffe von Git [Seite 771]
17.2.1 - 14.2.1 Begriffe [Seite 771]
17.2.2 - 14.2.2 Funktionen [Seite 771]
17.3 - 14.3 Source Control in Xcode [Seite 773]
17.4 - 14.4 Version Editor und Source Control [Seite 777]
18 - 15 Veröffentlichung im App Store [Seite 780]
18.1 - 15.1 Zertifikate, Provisioning Profiles und Ihre App [Seite 780]
18.1.1 - 15.1.1 Certificates, IDs & Profiles [Seite 782]
18.1.2 - 15.1.2 Erstellen von?.?.?. [Seite 784]
18.2 - 15.2 Testen auf dem eigenen Endgerät [Seite 797]
18.2.1 - 15.2.1 Setzen des Teams [Seite 797]
18.2.2 - 15.2.2 Auswahl Ihres iOS-Geräts [Seite 797]
18.3 - 15.3 iTunes Connect und Veröffentlichung im App Store [Seite 799]
18.3.1 - 15.3.1 Vorbereiten der App in iTunes Connect [Seite 801]
18.3.2 - 15.3.2 Upload der App in den App Store [Seite 804]
18.3.3 - 15.3.3 Wie geht es weiter? [Seite 805]
19 - Index [Seite 806]

Dateiformat: EPUB
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie eine Lese-Software, die das Dateiformat EPUB verarbeiten kann: z.B. Adobe Digital Editions oder FBReader - beide kostenlos (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat EPUB ist sehr gut für Romane und Sachbücher geeignet - also für "fließenden" Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

36,99 €
inkl. 19% MwSt.
Download / Einzel-Lizenz
ePUB mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
Hinweis: Die Auswahl des von Ihnen gewünschten Dateiformats und des Kopierschutzes erfolgt erst im System des E-Book Anbieters
E-Book bestellen

Unsere Web-Seiten verwenden Cookies. Mit der Nutzung dieser Web-Seiten erklären Sie sich damit einverstanden. Mehr Informationen finden Sie in unserem Datenschutzhinweis. Ok