Swift 2 lernen

Protokolle definieren Eigenschaften

LinkedIn Learning kostenlos und unverbindlich testen!

Jetzt testen Alle Abonnements anzeigen
Protokolle sind Grundgerüst-Definitionen dessen, was eine Klasse mindestens umfassen muss. Solche Vorgaben dienen dazu, dass Funktionen und Methoden verlässliche Instanzen übernehmen.
09:47

Transkript

Protokolle bieten ein weiteres, spannendes Sprachmerkmal von Swift, und wie wir Klassen schaffen, die bestimmten Protokollen entsprechen, schauen wir uns hier gemeinsam in diesem Video an. Also Protokolle, da soll es drum gehen, und wir machen uns da einen kleinen Playground, und sind dann bereit für dieses Thema. Protokolle sollen aufzählen, was eine bestimmte Klasse für ihre Objekte zur Verfügung stellen muss. So etwas wie ein Vertrag, der bitte zu erfüllen wäre. Dazu gibt es dann in Swift das Schlüsselwort protocol, und wir können dann sagen, zum Beispiel machen wir ein Protokoll für ein Fahrzeug Was wollen wir denn mit unserem Fahrzeug machen können? Wir brauchen also Funktionen: Gut, wir sollten unser Fahrzeug irgendwie starten können, wir sollten unser Fahrzeug auch irgendwie wieder stoppen können, und idealerweise sollte ein Fahrzeug auch fahren können. Na, das wären jetzt quasi Funktionen, die jedes Objekt einer Klasse leisten muss, die verspricht, das Protokoll Fahrzeug zu implementieren. Klingt furchtbar kompliziert, schauen wir uns aber gleich an. Kann ich denn nur Methoden in so einem Protokoll definieren? Nein, wir dürfen auch Variablen vorschreiben, ich muss also auch sagen dürfen, unser Fahrzeug braucht eine Farbe, und das wäre ein String, allerdings mit einer Verschärfung hier, ich will nur eine Farbe lesen können. mit Setter dürfte ich sie auch schreiben, hier wollen wir uns aber mal auf einen Getter beschränken, das heißt, eine Klasse, die das Protokoll Fahrzeug implementiert, muss eine Farbe zur Verfügung stellen, ohne dass man von außen diese Farbe auch setzen kann. Ja, wie implementiert man denn dann so ein Protokoll? Dann machen wir uns doch hier jetzt ein Auto, (lacht), und unser Auto verspricht, das Protokoll Fahrzeug zu implementieren. Schon in dem Moment haut uns der Compiler auf die Finger und sagt, Tja, lieber Entwickler, alles was du machst, aber dein Typ Auto, das ist nicht konform zu dem Protokoll Fahrzeug. Ja, da hat er auch völlig Recht, denn ich muss ja wirklich die Funktionen jetzt hier auch implementieren. Ja, das heißt, hier machen wir dann ein starten rein, ich brauche die Funktion stoppen, und wir sehen, wie schön uns die Code-Completion jetzt auch hilft, ich brauche die Funktion fahren, ja, unser Fahrzeug fährt dann wie verrückt durch die Gegend, (lacht), und wir haben natürlich noch die Farbe zu machen, das heißt, wir brauchen hier unsere Farbe als String, die hat aber nur einen Getter, also sagen wir Return "rot". So, an dieser Stelle haben wir also das Protokoll erfüllt, und unser Auto kann jetzt hier quasi all diese Sachen bedienen. Dann sagen wir hier rein, Auto Starten, Auto Stoppen, und unser Auto Fährt, und die Farbe ist rot, Machen wir uns noch eine andere Klasse, wie wäre es mit einem Motorrad? Und auch ein Motorrad darf versprechen hier, dieses Protokoll Fahrzeug zu implementieren, und dementsprechend haben wir hier das Motorrad drin, und unser Motorrad ist dann meinetwegen blau, und wir werden jetzt sehen, wozu wir das Ganze brauchen. Wir schreiben uns also eine Funktion Testfahrt, und sagen, diese Funktion braucht etwas, nämlich ein Fahrzeug, und das ist jetzt irgendein Objekt einer Klasse, die das Protokoll Fahrzeug implementiert. Dass wir das hier noch einmal schön sehen, ich ziehe das dann mal hier nach ganz oben, Wir wollen also eine Funktion Testfahrt haben, wissen aber nicht, bekomme ich ein Auto, bekomme ich ein Motorrad, bekomme ich einen Jet-Ski, man weiß es doch nicht, also kann unsere Testfahrt sagen, ich brauche nur ein Fahrzeug. und damit weiß die Funktion, okay, das, was ich auch immer hier bekomme, ich kann es starten, stoppen, und ich kann damit fahren. Also wollen wir das Ganze dann hier auch simulieren, dass wir sagen: println("die Farbe vom Fahrzeug ist") und wir geben sie aus, von dem Fahrzeug die Farbe, denn die muss uns jetzt laut Protokoll zur Verfügung stehen, ja, und dann können wir schon losgehen, und sagen "Fahrzeug, bitte starten", "Fahrzeug, bitte durch die Gegend fahren", ist ja eine Testfahrt, und "Fahrzeug, bitte stoppen", nachdem wir fertig sind. Also basierend auf einem Protokoll kann ich natürlich Funktionalität schaffen, später im Programm habe ich verschiedene Klassen, die versprechen, so ein Protokoll zu implementieren, und dann darf ich auch hergehen und sagen, okay, in unserem Programm gibt es Variablen, wie ein Auto, und das wäre dann tatsächlich so ein Auto, was wir uns da unten eingebaut haben, und damit wir hier keine Fehler bekommen, sollten wir dann das auch unterhalb unseres kleinen Testprogrämmchens anlegen, weil wir ja da oben erst unser Auto definieren. Wir machen uns ein Motorrad, auch das haben wir ja schon hier vorgesehen, und dann dürfen wir sagen, jetzt mache ich eine Testfahrt, und übergebe das Auto, wir machen eine Testfahrt, und ich übergebe auch gerne das Motorrad. Und wenn wir uns unser Projekt dann gemeinsam anschauen, dann sehen wir, das Auto war rot, das Motorrad ist blau, und hätten wir hier nicht nur für unseren Playground gearbeitet, sondern das Ganze wirklich in printlines gepackt, was ich gerade einmal tun werde, printline hier diesen Text, und das auch schnell für die anderen Ausgaben eingepackt, dann sehen wir, wenn unser Playground läuft, die Farbe vom Fahrzeug ist rot, wir können das Auto starten, das Auto fährt, das Auto stoppen, dann die Farbe vom Fahrzeug ist blau, das ist wohl unser Motorrad, und auch das können wir starten, fahren und stoppen. Also das ist die Stärke von Protokollen, man definiert tatsächlich Eigenschaften und Variablen, und dann können eben Klassen versprechen, dieses Protokoll zu implementieren, und dementsprechend darf ich auf dem Protokoll selber schon Code schreiben, weil ich weiß an dieser Stelle nur, egal, was ich kriege, es hat eine Farbe, ich kann es starten, ich kann damit fahren, ich kann es stoppen, mehr muss ich auch hier nicht wissen, und ob ich zur Laufzeit tatsächlich ein Auto, ein Motorrad, ein Fahrrad oder einen Jet-Ski bekomme, spielt wirklich keine Rolle. Protokolle sind also ganz ganz wichtig, um schönen, modularen, wartbaren Code zu schreiben. Wie wäre es, wenn jetzt ein Motorrad eine Unterklasse von einem Auto wäre? Dann würde man hier das tatsächlich so formulieren können: sprich, man sagt das Motorrad wäre ein Auto, und über eine Kommaliste könnten dann beliebige Protokolle auch noch geführt werden, allerdings passt das Ganze ja hier jetzt in unseren Kontext nicht hinein, das heißt, auch ein Motorrad ist eine Top-Level-Class, und sie verspricht eben, das Protokoll Fahrzeug zu implementieren.

Swift 2 lernen

Erkunden Sie die wichtigsten Sprachmerkmale von Swift und ihre modernen Eigenschaften wie Generics, Extensions, Tupels und Optionals.

4 Std. 2 min (30 Videos)
Derzeit sind keine Feedbacks vorhanden...

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!