O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Cocoa-Programmierung

Book Description

Mit dem Apple Framework Cocoa können mächtige und gleichzeitig ausgesprochen ansprechende Applikationen für die Mac OS X-Plattform, für das iPhone und für das iPad erstellt werden.

Mit Cocoa-Programmierung lernt der Leser den cleveren Einsatz des Apple-Entwicklungswerkzeuges, um eigene Interfaces zu erstellen, den Code zu schreiben und das passende Datenmodell dafür zu entwerfen.

Das Buch führt den Leser auch in das Objective-C 2.0-Konzept ein und erläutert, wie es mit der Cococa-Entwicklung zusammenhängt.

Table of Contents

  1. Cocoa-Programmierung: Der schnelle Einstieg für Entwickler
  2. 1. Einführung
    1. 1.1 Wir ziehen ein
    2. 1.2 Die Sprache erlernen
    3. 1.3 Die Tools installieren
    4. 1.4 Die Frameworks erkunden
    5. 1.5 In diesem Buch
  3. 2. Vorhandenes nutzen
    1. 2.1 Ein Projekt in Xcode anlegen
    2. 2.2 Das Aussehen mit dem Interface Builder entwickeln
    3. 2.3 Das Interface mit dem Cocoa Simulator testen
    4. 2.4 Das Interface fertigstellen
    5. 2.5 Die Komponenten verknüpfen
      1. Den Web-View verknüpfen
      2. Den Browser im Simulator testen
    6. 2.6 Den Build korrigieren
    7. 2.7 Ihren Browser weitergeben
    8. 2.8 Übung: Und jetzt das Ganze noch mal von vorne
    9. 2.9 Die .nib-Datei
      1. Das Dokumentenfenster
      2. Die XML-Darstellung der .nib-Datei
  4. 3. Methoden und Parameter
    1. 3.1 Nachrichten ohne Argumente senden
    2. 3.2 Die Dokumentation lesen
    3. 3.3 Methoden mit Argumenten
    4. 3.4 Dynamische Bindung
    5. 3.5 Probleme beim Senden von Nachrichten
    6. 3.6 Verlinkung auf sich selbst
    7. 3.7 Übung: Mehrere Verbindungen
  5. 4. Klassen und Objekte
    1. 4.1 „Hallo, Welt!“
    2. 4.2 Logging von Ausgaben an die Konsole
    3. 4.3 Eine vorhandene Klasse nutzen
    4. 4.4 Code refaktorieren
    5. 4.5 Eine neue Klasse erzeugen
    6. 4.6 Eine Klassenmethode erzeugen und nutzen
    7. 4.7 Ein neues Objekt erzeugen
    8. 4.8 Nochmalige Refaktorierung
    9. 4.9 Objekte initialisieren
    10. 4.10 Logging von Objekten
    11. 4.11 Übung: Zusätzliche Initialisierung
    12. 4.12 Lösung: Zusätzliche Initialisierung
  6. 5. Instanzvariablen und Eigenschaften
    1. 5.1 Zeiger
    2. 5.2 Mit Nicht-Objekten arbeiten
    3. 5.3 Getter und Setter
    4. 5.4 Akzessoren in Eigenschaften umwandeln
    5. 5.5 Punktnotation
    6. 5.6 Eigenschaftsattribute
    7. 5.7 Übung: Eigenschaften hinzufügen
    8. 5.8 Lösung: Eigenschaften hinzufügen
    9. 5.9 Instanzvariablen entfernen
  7. 6. Speicher
    1. 6.1 Reference Counting
    2. 6.2 Lecks mit dem Clang Static Analyzer aufspüren
    3. 6.3 Das Speicherleck unter Mac OS X beheben
    4. 6.4 Eigenschaften und Garbage Collection
    5. 6.5 Eine Taschenlampe entwickeln
    6. 6.6 Lecks mit Instruments aufspüren
    7. 6.7 Das Speicherleck auf dem iPhone beheben
    8. 6.8 Zombies nutzen
    9. 6.9 Aufräumen in dealloc
    10. 6.10 Retain und Release in einem Setter
    11. 6.11 Der Autorelease-Pool
    12. 6.12 Bequemlichkeitskonstruktoren verwenden
    13. 6.13 Übung: Erzeugen und Nutzen eines Bequemlichkeitskonstruktors
    14. 6.14 Lösung: Erzeugen und Nutzen eines Bequemlichkeitskonstruktors
  8. 7. Outlets und Aktionen
    1. 7.1 Das große Ganze
    2. 7.2 Ein Outlet benutzen
    3. 7.3 Übung: Ein Outlet erzeugen und benutzen
    4. 7.4 Lösung: Ein Outlet erzeugen und benutzen
    5. 7.5 Eine Aktion deklarieren
    6. 7.6 Die Aktion verknüpfen und implementieren
    7. 7.7 Übung: Den Button verstecken
    8. 7.8 Lösung: Den Button verstecken
    9. 7.9 Übung: Das Interface umschalten
    10. 7.10 Lösung: Das Interface umschalten
    11. 7.11 Ein weiteres Outlet hinzufügen
    12. 7.12 Selektoren aus Strings erzeugen
  9. 8. Einen Controller entwickeln
    1. 8.1 Wie wir Objekte erzeugt haben
    2. 8.2 Eine Controller-Klasse entwickeln
    3. 8.3 Eine Instanz unseres Controllers in IB erzeugen
    4. 8.4 Ein Outlet und eine Aktion deklarieren
    5. 8.5 Vorwärtsdeklaration
    6. 8.6 Den Controller verknüpfen
    7. 8.7 Das Laden der vorigen Seite implementieren
    8. 8.8 Übung: Den Controller fertigstellen
    9. 8.9 Lösung: Den Controller fertigstellen
    10. 8.10 awakeFromNib
    11. 8.11 Die Buttons aktivieren und deaktivieren
    12. 8.12 Korrekturen nötig
  10. 9. Anpassungen mit Delegates
    1. 9.1 Delegates verstehen
    2. 9.2 Das Standardverhalten eines Fensters
    3. 9.3 Ein roter Hintergrund
    4. 9.4 Übung: Grüner Hintergrund
    5. 9.5 Lösung: Grüner Hintergrund
    6. 9.6 Application-Delegate
    7. 9.7 Delegates für ihren Web-View
    8. 9.8 Den Titel des Fensters setzen
    9. 9.9 Übung: URL aktualisieren und Buttons setzen
      1. Tipp 1
      2. Tipp 2
    10. 9.10 Lösung: URL aktualisieren und Buttons setzen
    11. 9.11 Aufräumen
    12. 9.12 Übung: Eine Fortschrittsanzeige einbinden
    13. 9.13 Lösung: Eine Fortschrittsanzeige einbinden
  11. 10. Unseren Browser für das iPhone anpassen
    1. 10.1 Das iPhone-Projekt anlegen
    2. 10.2 Das Aussehen unseres Browsers entwickeln
    3. 10.3 Einschränkungen des WebView
    4. 10.4 Eine Webseite beim Start laden
    5. 10.5 Das Textfeld im IB einstellen
    6. 10.6 Den Textfeld-Delegate nutzen
    7. 10.7 Ein dritter Delegate zur Implementierung der Buttons
    8. 10.8 Übung: Eine Aktivitätsanzeige einfügen
    9. 10.9 Lösung: Eine Aktivitätsanzeige einfügen
    10. 10.10 Organisation mit Pragma Marks
  12. 11. Notifikationen absetzen und abfangen
    1. 11.1 Übung: Ein Modell aufbauen
    2. 11.2 Lösung: Ein Modell aufbauen
    3. 11.3 Für Notifikationen registrieren
    4. 11.4 Auf Workspace-Aktivitäten reagieren
    5. 11.5 Am Controller festhalten
    6. 11.6 Übung: Für Notifikationen registrieren
    7. 11.7 Lösung: Für Notifikationen registrieren
    8. 11.8 Notifikationen absetzen
    9. 11.9 Übung: Eigene Notifikationen empfangen
    10. 11.10 Lösung: Eigene Notifikationen empfangen
  13. 12. Protokolle für die Delegation entwickeln
    1. 12.1 Übung: Den Delegate erzeugen und festlegen
    2. 12.2 Lösung: Den Delegate erzeugen und festlegen
    3. 12.3 Ein Protokoll entwickeln und benutzen
    4. 12.4 Methoden verlangen
    5. 12.5 RespondsToSelector
    6. 12.6 Übung: Delegate-Methoden aufrufen
    7. 12.7 Lösung: Delegate-Methoden aufrufen
    8. 12.8 Übung: Aufräumen
    9. 12.9 Lösung: Aufräumen
  14. 13. Mit Dictionaries arbeiten
    1. 13.1 Ein Blick auf userinfo
    2. 13.2 Aus einem Dictionary lesen
    3. 13.3 Übung: Den Namen ausgeben
    4. 13.4 Lösung: Den Namen ausgeben
    5. 13.5 Die Redundanz reduzieren
    6. 13.6 Ein Dictionary zur Flusskontrolle nutzen
    7. 13.7 Einträge mit einem mutablen Dictionary einfügen und entfernen
    8. 13.8 Übung: Ein Icon hinzufügen
    9. 13.9 Ein Icon hinzufügen
  15. 14. Mehrere Nibs
    1. 14.1 Methoden, Objekte und Nibs
    2. 14.2 Nibs aufteilen
    3. 14.3 Die Ausgliederung des Views vorbereiten
    4. 14.4 Das View-Nib anlegen
    5. 14.5 Eine .nib-Datei integrieren
      1. Alternatives Ende
    6. 14.6 Der File’s Owner
    7. 14.7 Übung: Den View laden
    8. 14.8 Lösung: Den View laden
    9. 14.9 Das Window-Nib anlegen
    10. 14.10 Das Window-Nib laden
    11. 14.11 Das Fenster präsentieren
    12. 14.12 Übung: View und Modell verknüpfen
    13. 14.13 Lösung: View und Modell verknüpfen
  16. 15. Eigene Views entwickeln
    1. 15.1 Einen eigenen View anlegen
    2. 15.2 Formen in einem eigenen View zeichnen
    3. 15.3 Übung: Die Pinselfarbe ändern
    4. 15.4 Lösung: Die Pinselfarbe ändern
    5. 15.5 Grafiken zeichnen
    6. 15.6 Text zeichnen
  17. 16. Daten in einer Tabelle darstellen
    1. 16.1 Tabellen und Datenquellen
    2. 16.2 Übung: Eine einfache Datenquelle implementieren
    3. 16.3 Lösung: Eine einfache Datenquelle implementieren
    4. 16.4 Übung: Eine Datenquelle einführen
    5. 16.5 Lösung: Eine Datenquelle einführen
    6. 16.6 Zellen basierend auf Spaltenüberschriften füllen
    7. 16.7 Spaltenbezeichner als Schlüssel
    8. 16.8 Ausblick auf bevorstehende Knüller
    9. 16.9 Übung: Zeilen einfügen und löschen
    10. 16.10 Lösung: Zeilen einfügen und löschen
    11. 16.11 Zeilen manuell entfernen
  18. 17. Daten auf Festplatte speichern
    1. 17.1 Während der laufenden Anwendung speichern
    2. 17.2 Wo man Support-Dateien ablegt
    3. 17.3 Speichern in einer Plist
    4. 17.4 Eine Plist einlesen
    5. 17.5 Ein Archiv auf Festplatte speichern
    6. 17.6 Einstellungen lesen und verwenden
    7. 17.7 Die „Werkseinstellungen“ festlegen
    8. 17.8 Das Setzen der Benutzereinstellungen vorbereiten
    9. 17.9 Das Nib für das Einstellungsfenster
    10. 17.10 Das Einstellungsfenster aktivieren
  19. 18. Views wechseln
    1. 18.1 Mit Radiobuttons arbeiten
    2. 18.2 Einstellungen für den Start-View einfügen
    3. 18.3 Übung: Den richtigen View laden
    4. 18.4 Übung: Den richtigen View laden
    5. 18.5 „Magic Numbers“ eliminieren
    6. 18.6 Die Menüleiste anpassen
    7. 18.7 Das Hauptfenster verschieben
    8. 18.8 Übung: Views wechseln (weitgehend)
    9. 18.9 Lösung: Views wechseln (weitgehend)
    10. 18.10 Lazy Initialization
  20. 19. Key Value Coding
    1. 19.1 Objekte wie Dictionaries behandeln
    2. 19.2 Variablen mit KVC abrufen
    3. 19.3 Undefinierte Schlüssel
    4. 19.4 Übung: Variablen setzen per KVC
    5. 19.5 Lösung: Variablen setzen per KVC
    6. 19.6 KVC und Dictionaries
    7. 19.7 Schlüsselpfade für die Navigation in einer Klassenhierarchie
    8. 19.8 Übung: Tabellen füllen mit KVC
    9. 19.9 Lösung: Tabellen füllen mit KVC
    10. 19.10 Arrays und KVC
  21. 20. Key Value Observing
    1. 20.1 Codefreie Verbindungen
    2. 20.2 Ein Target/Action-Zähler
    3. 20.3 Einen Observer einführen
    4. 20.4 Als Observer registrieren
    5. 20.5 Änderungen observierbar machen
    6. 20.6 Die Änderungen überwachen
    7. 20.7 Übung: Einen zweiten Observer einfügen
    8. 20.8 Lösung: Einen zweiten Observer einfügen
    9. 20.9 Die unschöne Lösung
    10. 20.10 Methoden wählen mit KVC
    11. 20.11 Ein Observer-Objekt implementieren
    12. 20.12 Abhängige Variablen aktualisieren
  22. 21. Cocoa-Bindungen
    1. 21.1 Modell und View für unseren Zähler mit Bindungen
    2. 21.2 Den NSObjectController aufbauen und verknüpfen
      1. Den Controller verbinden
      2. Die Schlüssel wählen
      3. Eine Komponente binden
    3. 21.3 Weitere Objekte binden
    4. 21.4 Zahlenformatierer
    5. 21.5 Übung: Zwei Zähler mit Bindungen verknüpfen
    6. 21.6 Lösung: Zwei Zähler mit Bindungen verknüpfen
    7. 21.7 Das Modell unseres Bücherregal-Beispiels
    8. 21.8 Den View für unser Bücherregal entwickeln
    9. 21.9 Bindung mit dem NSArrayController
      1. Den Inhalt des Arrays festlegen
      2. Den Controller mit seinem Array verbinden
      3. Die Tabellenspalten konfigurieren
      4. Die Buttons verknüpfen
    10. 21.10 Das große Finale
  23. 22. Core Data
    1. 22.1 Entitäten und Attribute
    2. 22.2 Das Core Data-Widget nutzen
    3. 22.3 Der Managed Object-Kontext
    4. 22.4 Die Persistenzschicht
    5. 22.5 Relationen
    6. 22.6 Die Löschregel einer Relation wählen
    7. 22.7 Den View aktualisieren
    8. 22.8 Abhängigkeiten verwalten
    9. 22.9 Übung: Autoren hinzufügen und löschen
    10. 22.10 Sortieren
    11. 22.11 Elemente filtern
    12. 22.12 Den Sortierdeskriptor programmieren
  24. 23. Kategorien
    1. 23.1 Beschränkungen überwinden
    2. 23.2 Eine Kategorie anlegen
    3. 23.3 Sicherheitshinweise zu Kategorien
    4. 23.4 Private Methoden in Klassenerweiterungen
    5. 23.5 Übung: Eigenschaften über Klassenerweiterungen erweitern
    6. 23.6 Lösung: Eigenschaften über Klassenerweiterungen erweitern
    7. 23.7 Kategorien und Core Data
    8. 23.8 Generierte Klassen in Core Data
    9. 23.9 Auf Eigenschaften zugreifen
    10. 23.10 Klassendateien aus Entitäten neu generieren
  25. 24. Blöcke
    1. 24.1 Die Notwendigkeit von Blöcken in Wrappern
    2. 24.2 Einen Block deklarieren
    3. 24.3 Blöcke in Wrappern nutzen
    4. 24.4 Werte abfangen
    5. 24.5 Blöcke und Kollektionen
    6. 24.6 Blöcke deklarieren, definieren und benutzen
    7. 24.7 Die Verwendung von __block
    8. 24.8 Aufräumen mit typedef
    9. 24.9 Übung: Blöcke in Callbacks benutzen
    10. 24.10 Lösung: Blöcke in Callbacks nutzen
  26. 25. Operationen und ihre Queues
    1. 25.1 Den Ball rotieren lassen
    2. 25.2 Operationen aufrufen
    3. 25.3 Blockoperationen
    4. 25.4 Interaktion mit der Queue und Operationen
    5. 25.5 Eigene NSOperations
    6. 25.6 Von Operation-Queues zu Dispatch-Queues
  27. 26. Dispatch-Queues
    1. 26.1 Wann man Dispatch-Queues nutzt
    2. 26.2 Eine kurze Queue-Übersicht
    3. 26.3 Unser Fraktal zeichnen
    4. 26.4 Ohne Dispatch-Queues arbeiten
    5. 26.5 Die Haupt-Queue
    6. 26.6 Globale nebenläufige (concurrent) Queues
    7. 26.7 Synchronisation über die Haupt-Queue
    8. 26.8 Private Dispatch-Queues
    9. 26.9 Synchrone Tasks
  28. 27. Frisch ans Werk
    1. 27.1 Was ist mit ...
    2. 27.2 Wie geht es weiter?
    3. 27.3 Danksagungen
    4. 27.4 Widmung
  29. Stichwortverzeichnis