Programmieren lernen: Swift von A bis Z

Wir schreiben unser erstes kleines Programm, das uns Hallo, Welt ausgibt

Wir lernen Variablen und Konstanten kennen und schauen uns den Unterschied an

Wir lernen wie wir Typen in Swift implizit und explizit deklarieren können

Wir arbeiten mit den neu kennengelernten Typen und kombinieren Werte

Wir lernen die beiden Typen Array und Dictionary kennen und beginnen mit der grundlegenden Syntax

Wir arbeiten weiter mit Array und Dictionary und ersetzen, löschen und fügen Werte hinzu

Wir schauen uns kurz die Möglichkeit an optionale Variablen ohne Initialwert zu deklarieren

Wir wiederholen den Zuweisungsoperator und die arithmetischen Operatoren und lernen den Rest Operator kennen

Wir lernen den Erhöhungs- und Verminderungsoperator kennen, außerdem den unären Operator

Wir lernen zusammengesetzte Operatoren und Vergleichsoperatoren kennen

Wir beginnen mit dem Control Flow, indem wir uns if-Statements anschauen

Wir schauen uns die einfachste Art einer for-Schleife an

Wir lernen die for-in-Schleife kennen und wenden unser neues Wissen in Übungsaufgaben an

Übunsaufgaben in Textform

Ausführliche Lösungen der Übungsaufgaben aus der vorausgehenden Lektion

Wir lernen die while-Schleife kennen

Der letzte grundlegende Teil des Control Flows - das switch-Statement

Wir lernen den ternären und den nil koaleszierenden Operator kennen

Als letzte Operatoren lernen wir Bereichsoperatoren und logische Operatoren kennen

Wir wenden unser Wissen in einem praktischen Beispiel an

Übungsaufgaben zum selbst lösen

Übunsaufgaben in Textform

Ausführliche Musterlösung der Übungsaufgaben

Wir fangen damit an uns mit Funktionen in Swift zu beschäftigen, indem wir unsere erste eigene Funktion definieren.

Wir erweitern unsere erste Funktion und lernen außerdem Funktionstypen ohne Parameter und Rückgabewerte kennen.

Wir lernen, wie wir Funktionen mit mehreren Rückgabewerten definieren können und wie wir dann auf die einzelnen Werte aus der Rückgabe zugreifen können.

Wir lernen einen Standardwert für Funktionsparameter zu implementieren. Außerdem lernen wir den variadischen Parameter kennen.

Wir schauen uns an, wie wir Parameter als Variablen definieren können. Außerdem lernen wir wir den speziellen inout Parameter kennen.

Wir lernen Funktionstypen kennen und wie wir sie für verschiedene Dinge benutzen können.

Wir lernen die Definition einer Closure und wie sie sich von Funktionen unterscheiden. Dazu machen wir ein kurzes Beispiel und erstellen eine Closure als Argument für eine Methode.

Wir schauen uns an, wie wir die Closure aus der vorhergehenden Lektion weiter vereinfachen können. Dabei lernen wir neues über Standardparameter von Closures.

Wir lernen Trailing Closures kennen, die uns dabei helfen, lange Closures übersichtlicher zu gestalten.

Wir schauen uns an, wie Closures und Funktionen Werte erfassen und speichern können.

Wir lernen Enumerations kennen, und definieren mit ihrer Hilfe unseren ersten eigenen Typen in Swift.

Wir lernen wie wir Enumerations zugehörige Typen hinzufügen können, was uns ermöglicht noch effektiver mit ihnen arbeiten zu können.

Im Gegensatz zu zugehörigen Werten können wir Enumerations auch Raw Values hinzufügen und schauen uns das mal genau an.

Als letzter Teil zu Enumerations schauen wir uns rekursive Enumerations an und benutzen sie, um ein arithmetisches Problem zu lösen.

Wir lernen Klassen und Structures kennen, die es uns ermöglichen weitere eigene Typen in Swift zu kreieren.

Wir arbeiten weiter mit Klassen und Structs indem wir Properties definieren

Wir lernen den Unterschied zwischen Value Types (Structs) und Reference Types (Klassen) kennen

Wir lernen den identisch-Operator kennen und überlegen wann wir Klassen und Structs benutzen sollten

Wir beginnen damit uns Properties genauer anzuschauen und wiederholen nochmals Stored Properties

Wir lernen die speziellen lazy Properties kennen

Wir lernen Computed Properties kennen

Wir lernen Property Observer kennen, mit denen wir auf Änderungen an Properties reagieren können

Wir lernen den Unterschied zwischen Instanz und Typ Properties

Wir lernen Methoden kennen

Wir lernen die Property self kennen und wann und warum wir sie brauchen

Wir lernen den Unterschied zwischen Instanz und Typ Methoden

Wir lernen Subscripts kennen, die uns einen einfachen Zugriff mit eckigen Klammern ermöglichen

Wir lernen die Vererbung bei Klassen kennen

Wir fangen an uns mit Initialisierung zu beschäftigen

Wir wiederholen kurz den Standard Initializer und den Memberwise Initializer

Wir lernen den Unterschied zwischen Designated und Convenience Initializern

Wir lernen die Kette der Initialisierung mit den Sicherheitschecks kennen

Wir schauen uns die Delegation der Initializer genau an

Wir machen eine kurze praktische Wiederholung zu Initializern

Wir lernen die Failable Initializer kennen

Wir schauen uns die Delegation mit Failable Initializers an

Wir schließen das Kapitel Initialisierung mit required Initializers ab

Wir schauen uns die Deinitialisierung an, die nur bei Klassen verfügbar ist

Wir lernen das Automatic Reference Counting von Swift kennen

Wir lernen das Problem der Strong Reference Cycles kennen und eine Möglichkeit es zu lösen

Wir lernen das Schlüsselwort unowned kennen und wie wir damit Strong Reference Cycles vermeiden können

Wir lernen das Optional Chaining kennen

Wir lernen die Fehlerbehandlung in Swift kennen

Wir beginnen mit einem Beispiel zur Fehlerbehandlung

Wir lernen do-catch-Statements zur Fehlerbehandlung kennen

Wir lernen, wie wir Fehler optional behandeln können

Wir lernen Type Casting und die is und as Operatoren kennen

Wir lernen die Typen AnyObject und Any kennen

Wir lernen wie wir Typen ineinander verschachteln können

Wir lernen Extensions kennen und wie wir Typen erweitern können

Wir fügen Methoden mithilfe von Extensions hinzu

Wir lernen Protokolle kennen

Wir lernen Methoden in Protokolle zu implementieren

Wir lernen wie wir Protokolle als Typen verwenden können

Wir lernen das Delegieren mit Protokollen kennen

Wir lernen wie wir Extensions mit Protokollen verbinden können

Wir schauen uns die Vererbung bei Protokollen an

Wir lernen die Protocol Composition kennen, die Typen zu mehreren Protokollen konform macht

Wir schauen uns an wie wir Protokolle mit Extensions erweitern können

Wir lernen das Prinzip von Generics kennen

Wir lernen Generic Types kennen

Wir lernen Einschränkungen für unsere Generics - Type Constraints

Wir lernen Associated Types bei Protokollen kennen

Wir lernen mit dem where-Schlüsselwort eine weitere Form der Einschränkung bei Generics

Wir lernen die Bitwisen NOT, AND, OR und XOR Operatoren kennen

Wir lernen die Bitwisen Shift Operatoren kennen

Wir lernen Overflow kennen, außerdem Assoziativität und Präzedenz von Operatoren

Wir lernen das Überladen von bestehenden Operatoren kennen

Wir lernen eigene Operatoren zu erstellen

Wir legen unser erstes Projekt an und lernen die Struktur kennen

Wir erstellen eine eigene Klasse für unser Spiel

Wir schauen uns den Spielablauf an und schreiben eine Gameover Bedingung

Wir verbessern die Optik und den Ablauf unseres Spiels

Wir werfen nochmals kurz einen Blick auf Autolayout und wiederholen einige Dinge dazu

Wir lernen den UINavigationController kennen, mit dem wir leicht in unserer App navigieren können, mithilfe einer Navigationsbar

Wir lernen mehr über unsere Navigation und wie wir sie effektiv nutzen können

Wir lernen das UITableView kennen und implementieren es zunächst statisch

Wir vertiefen unsere Kenntnisse über das UITableView und passen es an unsere Vorstellungen an

Wir lernen das UICollectionView kennen und implementieren zunächst eine Standardvariante

Wir vertiefen unsere Kenntnisse über das UICollectionView und erstellen eine eigene Cell Subklasse

Wir lernen mehr über Autolayout und wie wir Elemente richtig platzieren

Wir lernen das UIPickerView kennen und implementieren es in unserer App

Wir lernen UITextFields kennen und wie wir auf den Input reagieren können

Wir lernen den UIImagePicker kennen und damit die Kamera und Zugriff auf die Bilder in unserem Handy

Wir testen unsere App auf einem iPhone und sprechen über Unterschiede zwischen Gerät und Simulator

Wir lernen die MapKit und CoreLocation Frameworks kennen

Wir vertiefen die Kenntnisse über die beiden Frameworks und tracken unsere Position auf einer Karte

Wir lernen den UIPageViewController kennen und wie wir ihn benutzen können um mit Swipes Views zu wechseln

Wir stellen euch eine Musterlösung für den DetailViewController vor

Vorschau für die Tic Tac Toe App

Wir beginnen mit dem Layout unserer Tic Tac Toe App

Wir implementieren den Spielablauf für unser Tic Tac Toe Spiel

Wir benutzen unsere neuen Kenntnisse für Multiplayer Spiele und implementieren eine Mehrspielerlösung für die Simon Says App

Vorschau für die Soundboard App

Wir gestalten das Layout für unser Drumpad

Wir lernen das AVFoundation Framework kennen, das wir für Audio in unseren Apps benötigen

Wir lernen den AVAudioRecorder kennen und können eigene Sounds für unser Drumpad aufnehmen

Wir benutzen unsere neuen Kenntnisse über In-App Audio um Sounds in unsere Simon Says App zu integrieren

Vorschau für die Quiz App

Wir legen das Projekt an und nehmen grundlegende Einstellungen vor

Wir gestalten das Layout für unser Quiz

Wir verbessern unser Quiz Layout um eine tolle User Experience zu ermöglichen

Wir lernen, wie wir statische Ressourcen in unserer App verwenden können und benutzen dafür plists

Wir implementieren die Logik unseres Quizzes

Wir implementieren einen Countdown Timer und Highscores

Vorschau für das SpriteKit Spiel

Wir lernen das SpriteKit Framework allgemein kennen

Wir lernen alles über die Klassen SKView und SKScene

Wir lernen die SKNode Klasse kennen

Wir lernen die Klasse SKSpriteNode kennen

Wir lernen wie wir Physics in unserem Spiel verwenden können

Wir vertiefen unsere Kenntnisse über SKPhysics

Wir erstellen uns eigene Subklassen von SKNode um erweiterte Funktionalität für unser Spiel bereitzustellen

Wir bringen endlich Bewegung in unsere App

Wir implementieren die Gegner in unser Spiel

Wir lernen, wie wir unseren Helden bei Tap springen lassen können

Wir implementieren Münzen und Punkte die wir sammeln können

Wir arbeiten weiter an den Gegnern in unserem Spiel

Wir benutzen NSUserDefaults um bestimmte Werte persistent zu speichern

Wir lernen verschiedene Möglichkeiten der Animation kennen

Wir erstellen uns einen eigenen Button für eine SpriteKit App

Wir beginnen mit der Entwicklung unseren In-Game Stores

Wir stellen unseren In-Game Store fertig und können dann Upgrades kaufen

Als letzten Schritt integrieren wir unsere Upgrades ins Spiel, sodass wir sie auch benutzen können

Vorschau für die Foodie App

Wir lernen das Core Data Framework kennen und speichern Werte und rufen sie wieder ab

Wir erstellen uns eine eigene Klasse für Core Data um leichter damit arbeiten zu können

Wir implementieren den AddViewController, mit dem wir neue Einträge hinzufügen können

Wir implementieren den BrowseViewController, mit dem wir alle unsere Einträge anschauen können

Wir erstellen ein Custom Layout für UICollectionView für unseren FavoritesViewController

Wir implementieren den DetailViewController und arbeiten mit NSPredicates zum Filtern der Ergebnisse

Wir benutzen die Maps App zum Navigieren zu unseren Restaurants

Wir lernen, wir wir bestehende Einträge in Core Data bearbeiten und entsprechend updaten können

Wir stellen euch die Musterlösung für die Gallerie und die Zufallsfunktion vor