Objektorientierung Teil 3 (Lernzielkontrolle zu Getter/Setter, Klassendesign, Enumerations) – Anwendungsentwickler-Podcast #45

Getter und Setter, ein vernünftiges Klassendesign und Enumerations sind die Themen der fünfundvierzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit meiner Lernzielkontrolle vertiefst du als IT-Azubi die Grundlagen der Objektorientierung. Über Getter und Setter steuerst du, wie auf Attribute zugegriffen wird, wobei du Werte berechnen oder vor dem Setzen prüfen kannst. Beim Klassendesign helfen dir klar abgegrenzte Aufgaben und sprechende Namen; außerdem sollten Methoden und Attribute eng zusammengehören und Abhängigkeiten gering bleiben. Enumerations legen erlaubte Werte als eigenen Datentyp fest, sodass dich der Compiler vor ungültigen Angaben schützt.

Kapitelmarken

  • [00:00:20] Themen der Lernzielkontrolle
  • [00:01:12] Getter und Setter als Zugriffsmethoden
  • [00:02:54] Lesezugriff und Schreibzugriff steuern
  • [00:03:54] Unveränderbare Objekte und Java-Strings
  • [00:05:16] Werte im Getter berechnen
  • [00:06:05] Werte im Setter prüfen
  • [00:07:19] Getter und Setter in deutschsprachigem Code benennen
  • [00:08:41] Klassendesign und Single Responsibility Principle
  • [00:10:40] Klassen wiederverwenden und Abhängigkeiten begrenzen
  • [00:12:25] Sprechende Klassennamen und Codevervollständigung
  • [00:15:19] Attribute zunächst privat halten
  • [00:15:41] Geringe Kopplung
  • [00:17:26] Hohe Kohärenz und Klassen aufteilen
  • [00:21:20] Enumerations für festgelegte Werte
  • [00:24:10] Aufzählungstypen und Typsicherheit
  • [00:26:19] Eigene Methoden in Java-Enums
  • [00:27:42] Unterstützung durch Compiler und IDE
  • [00:28:19] Ausblick auf Wirtschaftsfragen im Fachgespräch
  • [00:29:01] Shownotes und Literaturempfehlungen
  • [00:30:30] Handouts und Tipps für Präsentationen
  • [00:31:50] Kontakt und Newsletter

Probeabo bei Audible (Affiliate)

Inhalt

Getter und Setter

  • Wie steuert man den Zugriff auf Instanzvariablen?
    • Über dafür vorgesehene Methoden: Getter und Setter.
  • Was sind Getter und Setter?
    • Methoden zum Setzen und Lesen von Instanzvariablen.
  • Welchen Vorteil haben Setter im Vergleich zu public Attributen?
    • Man kann z.B. das Setzen ungültiger Werte verhindern.
  • Welchen Vorteil haben Getter im Vergleich zu public Attributen?
    • Man kann z.B. zusätzliche Berechnungen ausführen.

Klassendesign

  • Was sind die grundlegenden Regeln beim Schreiben von Klassen?
    • Eine Klasse sollte nur eine einzige Aufgabe haben (Single Responsibility Principle).
    • Sie sollte einen sprechenden Namen haben.
    • Sie sollte keine Attribute public machen (Geheimnisprinzip).
    • Sie sollte eine hohe Kohärenz aufweisen.
    • Sie sollte eine geringe Kopplung aufweisen.

Enumerations

  • Was ist eine Enumeration?
    • Ein Datentyp, der eine abgeschlossene Liste an Werten definiert.
  • Wann und warum sollte man Enumerations verwenden (und nicht Strings oder Integers)?
    • Wenn die Anzahl der erlaubten Werte begrenzt ist bekommt man durch eine Enumeration eine Art „Typsicherheit“.

Literaturempfehlungen

Links

Zusammenfassung

Getter und Setter

Wenn du Attribute als private deklarierst, bleiben die inneren Werte deiner Klasse nach außen verborgen. Über Methoden kannst du gezielt festlegen, wie andere Klassen darauf zugreifen dürfen. Ein Getter liest einen Wert, während ein Setter einen Wert setzt.

Dabei lässt sich der Zugriff für jede Richtung einzeln festlegen:

  • Mit einem öffentlichen Getter gibst du einen Wert zum Lesen frei. Welche Methoden ihn verändern dürfen, bestimmst du separat.
  • Ein Setter mit protected erlaubt abgeleiteten Klassen, den Wert zu setzen.
  • Über einen privaten Setter kann die Klasse selbst ihre Werte verändern.

Unveränderbare Objekte

Wenn mehrere Threads gleichzeitig denselben Wert verändern, können Probleme entstehen. Bei unveränderbaren Objekten, auf Englisch immutable objects, bleibt der Zustand nach dem Erzeugen erhalten.

In Java ist String ein Beispiel dafür. Bei einem Ausdruck wie text += "abc" entsteht ein neuer String mit dem ergänzten Inhalt. Der ursprüngliche String behält seinen Wert. Mit privaten Attributen und Gettern kannst du den Zugriff von außen auf das Lesen beschränken.

Logik in Zugriffsmethoden

Bei einer Klasse Person kann getAlter() das Alter aus dem gespeicherten Geburtsdatum und dem heutigen Datum berechnen. Dadurch brauchst du keinen zusätzlichen gespeicherten Alterswert.

Bevor ein Setter einen neuen Wert übernimmt, kann er prüfen, ob dieser gültig ist. Für ein Alter könnte beispielsweise der Bereich von 0 bis 200 gelten. Bei einem Wert außerhalb dieses Bereichs lässt sich eine Exception auslösen oder das Setzen ablehnen. Als Entwickler:in sorgst du dafür, dass dein Objekt in einem gültigen Zustand bleibt.

Namen für Getter und Setter

In meiner Praxis programmiere ich versicherungsinterne Software häufig auf Deutsch, weil sich Fachbegriffe so verständlich im Code ausdrücken lassen. Auch dabei behalte ich die Präfixe get und set bei, etwa in getKilometerstand(). Daran erkennst du die Rolle der Methode direkt. Eine passende deutsche Variante für get habe ich für mich bisher nicht gefunden.

Klassen entwerfen

Eine klar abgegrenzte Aufgabe

Beim Schreiben einer Klasse orientiere ich mich am Single Responsibility Principle. Die ursprüngliche Regel lautet: Eine Klasse sollte genau einen Grund haben, geändert zu werden. Häufig wird das als eine einzige Aufgabe oder Verantwortung beschrieben.

Wenn ein Dateimanager sowohl Dateien liest als auch schreibt, kann eine Änderung beim Schreiben versehentlich das Lesen beeinträchtigen. Durch getrennte Klassen bleiben die Aufgaben überschaubar. Du kannst eine solche Klasse außerdem leichter in einem anderen Programm einsetzen, weil sie nur die Abhängigkeiten ihrer eigenen Aufgabe mitbringt.

Gerade bei zusätzlichen Frameworks kann eine breit angelegte Klasse aufwendig werden: Für eine einzelne benötigte Funktion musst du dann möglicherweise weitere Bibliotheken einbinden und konfigurieren.

Sprechende Namen und private Attribute

Mit Namen wie Dateileser oder Dateischreiber wird die Aufgabe einer Klasse direkt erkennbar. Bezeichnungen wie Manager oder Utility lassen offen, was die Klasse genau macht.

Für eine spezielle Aufgabe darf der Name länger ausfallen. Aus meiner Praxis stammt etwa ein "blocksammelnder Datensatzschreiber". Beim Eingeben hilft dir die IDE: In Eclipse kannst du die Anfangsbuchstaben der einzelnen Wörter eingeben und den Namen mit Strg + Leertaste vervollständigen lassen.

Als Ausgangspunkt setze ich alle Attribute auf private. Anschließend entscheide ich einzeln, welche Werte über Zugriffsmethoden nach außen zugänglich werden.

Geringe Kopplung

Wenn deine Klasse andere Klassen oder Bibliotheken benötigt, bestehen Abhängigkeiten. Der Begriff Kopplung beschreibt diese Beziehungen. Mit jeder weiteren Abhängigkeit wird es aufwendiger, die Klasse an anderer Stelle einzusetzen; auch die Fehlersuche kann schwieriger werden. Eingebundene Bibliotheken können ihrerseits weitere Bibliotheken benötigen.

Da Klassen in einem objektorientierten System zusammenarbeiten, gehören Abhängigkeiten zum Alltag. Halte sie möglichst gering, damit sich deine Klassen leichter wiederverwenden lassen.

Hohe Kohärenz

Wie eng Methoden und Attribute einer Klasse zusammenarbeiten, beschreibe ich hier als Kohärenz. Eine hohe Kohärenz liegt vor, wenn die Methoden die Attribute der Klasse umfassend verwenden.

Bei einer Klasse Auto verändert die Methode zum Fahren beispielsweise den Kilometerstand. Eine Methode zum Öffnen der Türen arbeitet mit den Türobjekten. Dass diese Methoden jeweils unterschiedliche Attribute ansprechen, passt zum abgebildeten Konzept.

Wenn bei einer großen Klasse einzelne Gruppen von Methoden jeweils nur wenige Attribute bearbeiten, kann das auf mehrere Aufgaben hinweisen. Dann lohnt es sich zu prüfen, ob du diese Gruppen in eigene, kleinere Klassen aufteilen kannst. So hängt die Kohärenz mit dem Single Responsibility Principle zusammen.

Enumerations

Wenn ein Attribut nur Werte aus einer festgelegten Liste annehmen darf, kannst du dafür eine Enumeration, kurz enum, anlegen. Dieser Aufzählungstyp definiert die erlaubten Werte als Konstanten.

Für Wochentage lässt sich beispielsweise ein Typ Wochentag mit sieben Konstanten festlegen. Im Code greifst du dann auf einen Wert wie Wochentag.MONTAG zu. Auch das Lieblingsessen eines Hundes kann als Enumeration abgebildet werden, wenn deine Anwendung dafür eine feste Auswahl vorgibt.

Typsicher arbeiten

Bei einem frei eingegebenen String können Tippfehler auftreten. Ein Integer erlaubt Werte außerhalb des vorgesehenen Bereichs und verrät außerdem wenig darüber, welche Zahl welchen Wochentag bezeichnet.

Mit einem Enum-Typ in der Methodensignatur wird sichtbar, welche Werte erwartet werden. Der Java-Compiler prüft den Typ und weist unzulässige Angaben zurück. Deine IDE kann dir die definierten Konstanten beim Schreiben des Codes vorschlagen.

Methoden in Java-Enums

Java-Enumerations besitzen Eigenschaften von Klassen und können eigene Methoden enthalten. Wenn du aus einem Formular einen String erhältst, kannst du beispielsweise direkt im Enum eine Methode bereitstellen, die daraus den passenden Enum-Wert ermittelt.

Literatur und weitere Inhalte

Unter anwendungsentwicklerpodcast.de/45 findest du meine Shownotes mit weiterführenden Links zum Single Responsibility Principle sowie zu Kohärenz und Kopplung.

Als Literatur empfehle ich dir die Einführung in Java beziehungsweise die Java-Insel aus dem Rheinwerk-Verlag. Für das Klassendesign kommt Clean Code von Bob Martin hinzu, das praxisnahe Tipps auch für Programmieranfänger:innen enthält.

Auf meiner Website verweise ich außerdem auf meinen Artikel zu Handouts bei der Projektpräsentation, in dem ich empfehle, das Handout wegzulassen. Ein weiterer verlinkter Beitrag enthält Tipps des TED-Lead-Designers für ansprechende Präsentationen.

Mit meinem Newsletter erhältst du wöchentlich Neuigkeiten der Website und Zugriff auf Checklisten rund um deine Projektarbeit. Die Links der Woche kommen bereits montags. Du kannst auf die E-Mails antworten, um mir Feedback zu geben. Für die nächste Episode plane ich häufige Wirtschaftsfragen im Fachgespräch.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:01] Herzlich willkommen zum Anwendungsentwickler-Podcast,

[0:04] dem Podcast rund um die Ausbildung zum Fachinformatiker für Anwendungsentwicklung.

[0:09] In dieser Episode gibt es eine weitere Lernzielkontrolle zur Objektorientierung.

[0:13] Viel Spaß!

[0:20] Hallo und herzlich willkommen zur 45. Episode des Anwendungsentwickler-Podcasts.

[0:26] Mein Name ist Stefan Macke und heute geht es weiter mit dem Thema Objektorientierung.

[0:31] Ich setze meine Reihe der Lernzielkontrollen zum Thema fort und heute behandeln wir drei Themen auf einmal,

[0:37] nämlich die Getter und Setter, dann noch das Klassendesign und zum Schluss auch nochmal ein paar Enumerations.

[0:43] Das sind so ein paar Themen, die jetzt ein bisschen bunt zusammengewürfelt sind, aber ich hatte beim letzten Mal schon erklärt,

[0:48] ich mache die Lernzielkontrolle ja so passend zu dem Java-Tutorial, was ich immer mit meinen Azubis und Studenten mache.

[0:54] Und da ist das zufälligerweise jetzt die Reihenfolge, in der die das machen.

[0:57] Irgendwann nach der ersten eigenen Klasse führe ich dann zum Beispiel die Enumerations ein und von daher passt das jetzt hier gerade rein.

[1:03] Deswegen erzähle ich das heute. Es hat also keinen großen Zusammenhang zwischen Klassendesign und Enumeration.

[1:09] Es passt einfach nur zeitlich ganz gut zusammen.

[1:12] Okay, steigen wir direkt ein mit Gettern und Settern.

[1:14] Beim letzten Mal hatten wir ja uns die Sichtbarkeitsmodifiziere angeschaut.

[1:17] Die sorgen ja dafür, dass wir das Geheimnisprinzip umsetzen können,

[1:21] nämlich dass die inneren Werte quasi unserer Klasse vor der Außenwelt verborgen bleiben.

[1:26] Und heute wollen wir uns diesem Geheimnisprinzip nochmal ein bisschen weiter widmen,

[1:30] denn diese inneren Werte sollen ja verborgen bleiben.

[1:33] Das ist ja schön, aber wenn wir auch gar nicht da dran kommen könnten von draußen, dann hätten sie ja keinen Wert für uns.

[1:39] Wenn wir zum Beispiel irgendwelche Werte, die so eine Klasse speichert, gar nicht abfragen könnten oder gar nicht setzen könnten,

[1:44] ja was sollen wir dann mit der Klasse anstellen?

[1:46] Die bringt uns dann ja nichts, weil wir gar nicht mit ihren Werten arbeiten können.

[1:49] Deswegen müssen wir ja schon irgendwie da vielleicht mal dran kommen.

[1:52] Und die Idee, wie man das jetzt macht, wie man das vernünftig macht in der Objektorientierung, ist,

[1:57] dass wir eben nicht einfach die Attribute zum Beispiel public machen und somit durch jeden lesend aber auch schreibbar Zugreifer machen,

[2:04] sondern wir verwenden ein paar Methoden, die den Zugriff etwas genauer steuern können.

[2:09] Und diese Methoden nennt man Getter und Setter, je nachdem, was man mit ihnen macht.

[2:14] Entweder man gettet, oh Gott, oh Gott, ganz schreckliches Deutsch.

[2:17] Entweder man holt einen Wert von einem Objekt, das ist dann eben die Get-Methode, der Getter.

[2:23] Oder man setzt einen Wert, das ist dann der Setter.

[2:26] Deswegen heißen die Methoden so.

[2:28] Und in der einfachsten Form machen die wirklich nichts weiter, als einen Wert zu setzen bzw. abzufragen.

[2:33] Jetzt kann man sich natürlich dann fragen, ja, wofür brauche ich denn ein Getter und Setter,

[2:36] wenn die sowieso einfach nur sowas machen, wie zum Beispiel this Punkt Kilometerstand gleich Kilometerstand,

[2:42] bzw. der Getter für Kilometerstand einfach nur return Kilometerstand macht,

[2:46] dann kann ich mir doch eigentlich auch die Getter und Setter sparen, oder nicht?

[2:50] Oder ich könnte einfach direkt das Attribut public machen und habe ich ja das gleiche erreicht.

[2:54] Aber das ist eben nicht der Fall, denn wenn ich Getter und Setter benutze,

[2:58] kann ich zum einen steuern, welche Richtung erlaubt ist und welche nicht.

[3:01] Ich kann ja zum Beispiel einen Getter implementieren, aber einen Setter nicht.

[3:05] Damit kann ich also einschränken, dass geschrieben wird, aber das Lesen kann ich sehr wohl erlauben.

[3:09] Oder ich könnte zum Beispiel auch die Sichtbarkeit der beiden Getter und Setter unterschiedlich gestalten.

[3:14] Ich könnte zum Beispiel sagen, alle abgeleiteten Klassen, die dürfen setzen,

[3:17] also mache ich den Setter zum Beispiel protected und den Getter mache ich public.

[3:21] Den darf jeder benutzen.

[3:23] Oder ich mache den Setter sogar private, dann kann nur die Klasse selber irgendwas setzen,

[3:26] aber niemand anderes kann es halt mit irgendwelchen ungültigen Werten setzen oder sowas.

[3:31] Das ist jetzt also erstmal die Einführung.

[3:33] Getter und Setter sind nichts weiter als Methoden zum Lesen und Setzen von Instanzvariablen.

[3:37] Mehr machen die eigentlich nicht.

[3:38] Und was jetzt die Vorteile sind von Gettern und Settern,

[3:41] den einen haben wir gerade angesprochen, ich kann also unterschiedliche Sichtbarkeit implementieren

[3:45] oder ich muss die auch einfach gar nicht implementieren.

[3:47] Ich könnte zum Beispiel sagen, den Getter biete ich an, aber den Setter nicht.

[3:50] Das heißt, ich kann wirklich nur lesend auf das Objekt zugreifen und das ist vielleicht auch gar nicht schlecht.

[3:54] Gerade wenn wir heutzutage dann denken, dass wir immer mehr parallele Software haben,

[3:58] die also nebenläufig läuft, dann ist es gar nicht so schlecht,

[4:01] wenn man bei Objekten bestimmte Werte gar nicht setzen kann.

[4:03] Denn wenn mehrere Threads zum Beispiel parallel versuchen, einen Wert zu setzen,

[4:06] dann kann es ganz schnell Probleme geben.

[4:08] Und wenn wir unsere Klassen so modellieren, dass sie einfach rein lesbar sind

[4:11] und wir gar nicht von draußen was setzen können,

[4:13] dann haben wir da deutlich weniger Probleme, nämlich, um genau zu sein, eigentlich gar keine.

[4:17] Deswegen kann es durchaus sinnvoll sein, Objekte so zu bauen,

[4:20] dass man nur Attribute von ihnen lesen kann, aber nicht schreiben.

[4:23] Das heißt dann auch, dass sie immutable sind auf Englisch, also unveränderbar.

[4:28] Ein schönes Beispiel für so eine Klasse, von der man nur lesen kann,

[4:31] sie aber nie wieder ändern kann, ist ganz einfach in Java der String.

[4:35] Der String ist ein immutable Object, wenn man das auf Englisch mal formuliert.

[4:39] Das bedeutet, sobald ich einen String verändere,

[4:42] wird eigentlich nicht der Ursprungs-String tatsächlich im Speicher verändert,

[4:45] sondern es wird immer, durch Java zumindest, sichergestellt, dass es einen neuen String gibt.

[4:50] Wenn ich also sowas mache wie string plusgleich abc,

[4:54] dann wird nicht der eigentliche String verändert,

[4:57] sondern ich bekomme einen neuen String zurück, der eben den veränderten Wert enthält.

[5:01] Aber der ursprüngliche String bleibt immer unverändert.

[5:05] Und solche Dinge kann ich wunderbar programmieren in Objekte und Türen,

[5:08] wenn ich einfach meine Attribute alle auf private setze und nur getter implementiere.

[5:12] Dann habe ich nämlich sichergestellt, dass keiner von draußen die Werte ändern kann. Fertig.

[5:16] So, jetzt müssen wir trotzdem noch überlegen, was für einen weiteren Vorteil getter und setter haben.

[5:20] Das kann man jetzt mal ein bisschen aufteilen.

[5:22] Die getter haben zusätzlich noch die Möglichkeit, weil es ja eine Methode ist, die ich da implementiere,

[5:26] dass ich da eben Logik reinbauen kann.

[5:28] Und ein Beispiel, was ich dann immer anführe, ist sowas wie,

[5:31] ich habe einen Wert, den merkt sich das Objekt gar nicht, zum Beispiel in einer Instanzvariable,

[5:35] sondern der wird erst zur Laufzeit berechnet.

[5:37] Ganz einfaches Beispiel, ich habe eine Klasse Person und da habe ich eine Methode getAlter.

[5:42] Jetzt kann sich die Person natürlich ihr Alter merken, aber sie kann es auch einfach zur Laufzeit berechnen.

[5:46] Wenn zum Beispiel die Person das Geburtsdatum gespeichert hat,

[5:49] kann ich einen getter fürs Alter anlegen, ohne dass diese Person sich das Alter merken muss.

[5:54] Sie kann es einfach zur Laufzeit aus dem heutigen Datum und ihrem Geburtsdatum berechnen.

[5:58] Das wäre ein Vorteil von gettern.

[6:00] Das kann ich auf keinen Fall tun, wenn ich halt ein reines Attribut benutze, weil das keine Logik enthalten kann.

[6:05] Das gleiche beim setter. Auch da kann ich Logik implementieren.

[6:08] Und was wäre jetzt das klassische Beispiel da?

[6:10] Ja, ich könnte prüfen, ob die Werte, die da gesetzt werden sollen, dann auch gültig sind.

[6:14] Wir hatten beim letzten Mal schon gelernt, dass Objekte immer in einem gültigen Zustand sein sollen.

[6:18] Und diese Aufgabe habe ich als Entwickler.

[6:20] Ich muss mich darum kümmern.

[6:22] Das heißt, ich muss einschränken, dass zum Beispiel von draußen niemand mein Objekt in einen ungültigen Zustand setzt.

[6:27] Und das kann ich tun, indem ich setter programmiere.

[6:29] Da kann ich dann zum Beispiel, bleiben wir vielleicht bei der Person und dem Alter,

[6:32] so etwas implementieren, dass ein Alter ungültig ist, wenn es kleiner 0 ist.

[6:36] Oder größer 200, wenn wir von Menschen sprechen.

[6:39] Das heißt, da könnte ein setter also so aussehen, dass ich ein neues Alter reinbekomme als int

[6:44] und als erstes geprüft wird, dass das Alter eben auch gültig ist.

[6:47] Also, wenn das Alter kleiner ist als 0 oder größer als 200, meinetwegen,

[6:51] dann wird halt eine Exception geworfen oder das Alter wird einfach nicht gesetzt oder wie auch immer,

[6:54] was ich da halt machen will in meinem Programm.

[6:56] Und diese Möglichkeit habe ich eben nicht, wenn ich das Attribut einfach public mache.

[7:00] Also, kurz zusammengefasst, getter, da kann ich zur Laufzeit auch einfach was berechnen.

[7:04] Dann spare ich mir das Speichern irgendwelcher Werte.

[7:07] Und beim setter kann ich zusätzlich noch prüfen, ob die übergebenen Werte gültig sind

[7:11] und damit sicherstellen, dass mein Objekt in einem gültigen Zustand bleibt.

[7:16] Damit haben wir das Thema getter und setter eigentlich schon abgearbeitet.

[7:19] Vielleicht noch eine Kleinigkeit aus der Praxis.

[7:21] Bei uns ist es so, dass wir häufig die versicherungsinterne Software auf Deutsch programmieren,

[7:26] weil es einfach zum Beispiel bestimmte Fachbegriffe nicht auf Englisch gibt,

[7:29] beziehungsweise das nur zur Verwirrung beitragen würde, aber nicht zur Verständlichkeit des Codes,

[7:33] wenn wir alles mögliche übersetzen würden auf Englisch.

[7:35] Deswegen hat man dann, wenn man auf Deutsch programmiert oder auch in irgendeiner anderen Sprache,

[7:39] immer das Problem, diese getter und setter zu benennen.

[7:41] Denn es ist halt so schön etabliert, dass man sie halt get und set irgendwas nennt.

[7:45] Aber dann kommt man halt auf solche Methodennamen wie zum Beispiel get-Kilometerstand.

[7:49] Und das ist natürlich irgendwie von der Lesbarkeit her hässlich.

[7:52] Da habe ich halt zwei Sprachen gemischt.

[7:54] Ich persönlich würde die Methoden trotzdem mit get und set beginnen lassen,

[7:58] denn eine deutsche Übersetzung habe ich noch nicht so richtig gefunden, die mir gut gefällt.

[8:02] Man könnte zum Beispiel get mit gib übersetzen, aber das finde ich irgendwie doof.

[8:07] Gib-Kilometerstand.

[8:09] Oder sowas wie gib-Kilometerstand-zurück finde ich auch doof.

[8:13] Ermittle-Kilometerstand finde ich auch blöd.

[8:15] Das hört sich immer so an, als ob irgendwas berechnet wird.

[8:17] Also das passt irgendwie nicht so richtig.

[8:19] Set und setze würde vielleicht funktionieren.

[8:21] Setze-Kilometerstand, okay.

[8:23] Aber wenn das mit get irgendwie nicht so richtig hinhaut, also ich finde das irgendwie doof.

[8:27] Und ich finde auch, dass man irgendwie den Methoden ansehen sollte, dass es getter und setter sind.

[8:32] Deswegen, meiner Meinung nach, sollte man die trotzdem get und set nennen

[8:35] und dann halt eben mit dem deutschen, beziehungsweise in welcher Sprache man auch immer arbeitet, Wort dann dahinter.

[8:41] So, jetzt kommen wir mal ein bisschen weg vom konkreten Code, getter, setter, Methoden, Attribute und so weiter

[8:46] und werden mal ein bisschen abstrakter.

[8:48] Das nächste Thema ist nämlich das Klassendesign.

[8:51] Und da habe ich einfach mal eine Frage aufgeschrieben.

[8:53] Was sind denn so ein paar grundlegende Regeln beim Schreiben von Klassen?

[8:57] Worauf sollte ich vielleicht achten, wenn ich Objekte irgendwie programmiere?

[9:00] Was soll ich mal bei meinen Klassen machen und was nicht?

[9:03] Und das Erste, was ich immer anführe, ist, dass eine Klasse nur eine einzige Aufgabe haben sollte.

[9:08] Das nennt man auf Englisch auch gerne das Single Responsibility Principle.

[9:12] Das heißt, die Klasse hat nur eine Zuständigkeit, eine Verantwortung.

[9:16] Und das ist deswegen eine tolle Regel, weil ich so immer weiß, wo ich etwas ändern muss.

[9:21] Stellen wir uns mal eine Klasse vor, die nicht nur eine einzige Aufgabe hat.

[9:24] Ganz blöd, sowas wie ein Dateileser, der auch gleichzeitig was schreiben soll.

[9:28] Also nennen wir ihn mal Dateimanager.

[9:31] Das ist übrigens gleich schon mal ein super Beispiel für einen schlechten Klassennamen.

[9:34] Denn wenn ich solche Wörter benutze, die völlig nichtssagend sind, wie zum Beispiel Manager oder Verwalter.

[9:39] Oder am besten noch Utility. Das ist noch das Schlimmste.

[9:43] Wenn ich so eine Klasse sehe, dann weiß ich schon, die macht mehr als eine Sache.

[9:46] Und stellen wir uns mal so einen Dateimanager vor, der also lesen und schreiben kann.

[9:50] Dann können wir uns jetzt mal vorstellen, wenn ich jetzt irgendwo einen Bug habe, zum Beispiel beim Schreiben einer Datei.

[9:54] Die Datei wird nicht richtig geschlossen, meinetwegen.

[9:56] Und ich muss diesen Bug fixen, dann fixe ich das in der Klasse Dateimanager.

[10:00] Bei diesem Bugfixing kann es aber durchaus sein, dass ich einen Fehler mache.

[10:03] Und am Ende meines Bugfixings, das eigentlich den Fehler beheben soll, habe ich einen Bug eingebaut.

[10:07] Und zwar in die andere Funktion, nämlich in das Dateilesen.

[10:10] Obwohl ich daran eigentlich gar nichts machen wollte.

[10:12] Das passiert nur dann, wenn diese Klasse mehr als eine Aufgabe hat.

[10:15] Und das war jetzt ein triviales Beispiel.

[10:17] Stellen wir uns mal eine komplexe Klasse vor, wo es nicht so ein- und ausmäßig genau getrennt ist.

[10:22] Sondern vielleicht wirklich irgendwie eine Businessklasse, wo wirklich viele verschiedene Dinge drin sind.

[10:26] Dann ist es vielleicht gar nicht so einfach zu sehen, ob ich vielleicht was kaputt gemacht habe.

[10:30] Wenn die Klasse 97 Methoden hat und ich in einer was ändere, dann weiß ich vielleicht gar nicht, wo die alle aufgerufen wird, die Methode.

[10:36] Und welche anderen Funktionen jetzt auf einmal nicht mehr funktionieren.

[10:38] Also, das ist ganz doof.

[10:40] Außerdem erhöht das die Wiederverwendbarkeit, wenn eine Klasse nur eine Aufgabe hat.

[10:43] Dann kann ich die nämlich einfach nehmen und vielleicht mit anderen Klassen zusammenstöpseln, um eine neue Funktionalität zu bauen.

[10:48] Wenn eine Klasse aber sehr viele Aufgaben hat und vielleicht auch noch sehr viele Abhängigkeiten hat, um die alle überhaupt erledigen zu können.

[10:54] Denken wir mal beim Dateileser.

[10:56] Vielleicht eine Klasse, die sowohl den Input-Stream als auch den Output-Stream benötigt, weil sie ja beides machen muss.

[11:02] Lesen und Schreiben.

[11:03] Das heißt, sie hat auch mehr Abhängigkeiten.

[11:05] Und wenn ich jetzt diese Klasse irgendwo anders wiederverwenden will, dann hole ich mir diese ganzen Abhängigkeiten auch mit in mein Programm rein, obwohl ich sie gar nicht brauche.

[11:11] Wenn ich eine Klasse brauche, die eigentlich nur was liest, warum habe ich dann auf einmal eine Abhängigkeit auf einen Output-Stream zum Beispiel?

[11:18] Das ist unnötig. Und das ist nicht nur unnötig, sondern führt vielleicht auch zu Problemen, weil ich diese Abhängigkeit gar nicht als Laufen bekomme in meinem Programm.

[11:24] Weil ich das wirklich einfach gar nicht brauche und weil vielleicht mein Programm gar nicht darauf ausgelegt ist, damit irgendwie arbeiten zu können.

[11:29] Beziehungsweise ich habe mehr Arbeit vielleicht als vorher, weil ich diese ganzen Abhängigkeiten zusätzlich noch konfigurieren muss.

[11:35] Input-Output-Stream war jetzt ein schlechtes Beispiel.

[11:37] Das ist in Java sowieso überall mit drin.

[11:39] Aber denken wir an eine komplexere Klasse, wo vielleicht noch irgendwelche Frameworks eingebaut sind.

[11:44] Da braucht halt mein Dateileser auf einmal noch das Apache-irgendwas-Framework dazu, obwohl das eigentlich nur fürs Schreiben von Dateien benutzt wird.

[11:51] Und auf einmal muss ich dieses Apache-Framework auch benutzen, obwohl ich eigentlich diese ganze Funktionalität überhaupt nicht brauche.

[11:57] Also das macht das Ganze unnötig kompliziert, fehleranfällig und einfach komplex. Das wollen wir nicht.

[12:02] Deswegen eine einzige Aufgabe für eine Klasse.

[12:05] Die Originaldefinition von dem Single Responsibility Principle lautet übrigens, dass eine Klasse nur einen Grund haben sollte für eine Änderung.

[12:13] Landläufig sagt man allerdings auch, sie soll nur eine Aufgabe haben.

[12:16] Aber das ist eigentlich der genaue Hintergrund.

[12:18] Es soll nur einen einzigen Grund geben, warum ich an dieser Klasse rumdoktore, nämlich wenn ich ihre einzige Funktion ändern will, die sie hat.

[12:25] So, nächster Punkt auf meiner Liste wäre dann, sie sollte einen sprechenden Namen haben.

[12:31] Also eben genau nicht sowas wie Dateimanager, der einfach alles macht, sondern es soll ganz konkret sagen, was diese Klasse macht.

[12:40] In meinem Beispiel würde ich sowas haben wie Dateileser oder Dateischreiber oder meinetwegen auch Auto, wenn es ein Auto repräsentiert.

[12:48] Aber vielleicht kann man das auch noch ein bisschen einschränken.

[12:50] Also es spricht nichts dagegen, dass man den Namen einer Klasse durchaus auch etwas länger macht, um spezieller auszudrücken, was diese Klasse tut.

[12:58] Das kann man etwas auch übertreiben, sage ich mal. Das sieht man auch in Java zum Beispiel.

[13:02] Dann habe ich dann die Abstract Syntax Context Factory Implementation oder irgendwas.

[13:08] Okay, das war ein völlig ausgedachtes Beispiel. Das wird es in der Praxis so nie geben und es war auch völlig sinnfrei, was ich gerade gesagt habe.

[13:13] Aber nur, um mal einfach zu zeigen, wie lang so ein Klassenname dann werden kann.

[13:16] Dann habe ich mal ein Beispiel aus der Praxis, das ich selber programmiert habe.

[13:20] Das war der Block sammelnde Datensatz Schreiber.

[13:24] Das war also ein Schreiber und zwar hat er einen Datensatz geschrieben und der hat nicht einfach so eingeschrieben, sondern er hat bestimmte Blöcke gesammelt.

[13:34] Das heißt, das ist ein wirklich sehr spezieller Name und es gibt zum Beispiel auch den Datensatz sammelnden Datensatz Verarbeiter.

[13:42] Um das zu erklären, was das Ding macht, will ich jetzt nicht so weit ausholen hier.

[13:46] Aber nur, um zu zeigen, die Namen können also sehr speziell sein und werden durchaus auch ein bisschen länger.

[13:50] Aber das macht auch nichts, denn kein Mensch muss die eintippen.

[13:53] Das können wir alles durch IntelliSense in C-Sharp zum Beispiel oder in Eclipse mit der Kodevervollständigung hinbekommen.

[13:59] Wenn ich zum Beispiel solche komischen langen Klassennamen habe, dann kann ich ganz üblicherweise in Eclipse zum Beispiel einfach, indem ich die Anfangsbuchstaben der neuen Wörter eingebe und dann STRG Leertaste drücke, mir den gesamten Namen vervollständigen.

[14:12] Also zum Beispiel bei meinem Block sammelnden Datensatz Verarbeiter, dann gebe ich einfach BSDV ein, drücke STRG Leertaste und schwupp steht da der Block sammelnde Datensatz Verarbeiter.

[14:25] Also da muss ich mir nicht eben die Gedanken machen, dass ich ewig viel tippen muss, sondern das macht eigentlich meine IDI für mich sowieso von alleine.

[14:33] Umso besser ist es aber, wenn ich mir diese Klasse angucke, dass ich halt am Namen sofort ablesen kann, was da los ist und ich eben nicht noch überlegen muss.

[14:40] Wenn ich jetzt einfach mein Beispiel jetzt gerade einen Datensatz Verarbeiter gehabt hätte, dann wüsste ich nicht, was er tut.

[14:46] Da muss ich in den Code reingucken, um zu verstehen, was macht er denn jetzt genau.

[14:50] Und wahrscheinlich macht er auch noch ganz ganz viele Sachen auf einmal, denn ein Verarbeiter, der wird wohl alles mögliche tun.

[14:56] Ein Schreiber, da ist es klar, der schreibt das Ding, der liest das aber nicht ein oder verarbeitet das noch oder was auch immer der da macht.

[15:03] Der Verarbeiter wird wahrscheinlich alles auf einmal tun.

[15:05] Also sprechender Name, nicht möglichst lang, wir wollen jetzt auch nicht da irgendwie Zeichen schinden, sondern der Name soll einfach sprechend sein und üblicherweise wird er halt etwas länger, um eben spezieller sein zu können.

[15:19] Gut, dann hatte ich beim letzten Mal schon gesagt, eine ganz einfache Daumenregel beim Klassendesign, alle Attribute erst mal private machen.

[15:25] Also ich habe in meiner Praxis selten Beispiele für wirkliche Public Attribute, wo man es nicht hätte anders machen können.

[15:32] Also ich mache erst mal alles private und entscheide dann selektiv, welche Attribute vielleicht über Getter und Setter, wie wir heute jetzt gelernt haben, dann nach draußen hin preisgegeben werden.

[15:41] So, jetzt kommen noch zwei Fachbegriffe, die man dann auch gerne mal in der möglichen Prüfung zum Beispiel erklären kann.

[15:47] Und zwar sollten vernünftige Klassen eine hohe Kohärenz aufweisen und eine geringe Kopplung.

[15:55] Was heißt das jetzt? Die Kopplung ist vielleicht einfacher zu erklären, das hatten wir gerade schon so ein bisschen, Abhängigkeit.

[16:00] Wenn meine Klasse, die zum Beispiel aufs Dateisystem zugreift, irgendeine Apache-Tralala-Bibliothek dafür benutzt, dann ist meine Klasse abhängig von diesem externen Paket, von dieser Bibliothek, die ich da eingebunden habe.

[16:12] Und je höher diese Kopplung ist, d.h. je mehr Abhängigkeiten ich habe, umso komplizierter wird es, diese Klasse zu benutzen.

[16:18] Wie gerade, ich möchte jetzt meinen Dateimanager benutzen, muss aber erst mal 37 JAR-Dateien aus dem Internet runterladen, damit überhaupt meine kleine Klasse läuft, denn die hat halt so viele Abhängigkeiten.

[16:28] Und das Problem bei den Abhängigkeiten ist, die Abhängigkeiten können wieder Abhängigkeiten haben und wieder und wieder, d.h. am Ende muss ich mir 130 Dateien runterladen, nur um eine winzige Klasse zu benutzen.

[16:38] Das ist blöd. Das ist nicht nur blöd, weil es aufwendig ist, sondern es ist halt auch schwierig bei der Fehlersuche.

[16:42] Wenn dann irgendwas nicht funktioniert, dann kriege ich halt einen Stacktrace, der 7000 Zeilen lang ist, weil irgendwo in irgendeinem Framework irgendwas schiefgelaufen ist.

[16:49] Also blöd. Wollen wir nicht.

[16:51] D.h. ich kann die Klasse nicht gut wiederverwenden, wenn ich so eine hohe Kopplung habe.

[16:55] Deswegen sollten meine Klassen eine geringe Kopplung haben.

[16:58] Am besten verwendet eine Klasse gar keine anderen Klassen.

[17:01] Das wäre super, dann kann ich sie nämlich perfekt wiederverwenden.

[17:03] Ich kann sie einfach nehmen und sie ist direkt lauffähig.

[17:06] Allerdings, ganz ehrlich gesagt, in so einem normalen objektorientierten System wird das sehr selten vorkommen, denn die Klassen sollen ja miteinander arbeiten.

[17:13] Also von daher ist es natürlich nicht schlimm, wenn eine Klasse eine Abhängigkeit auf eine andere hat.

[17:17] Das ist sogar eher der Normalzustand.

[17:19] Aber cool wäre natürlich, wenn sie gar keine Abhängigkeit hätte.

[17:21] Denn wie gesagt, dann kann ich sie direkt nehmen und so wiederverwenden, ohne irgendwelche Abhängigkeiten.

[17:26] Ja, der zweite Begriff, den ich gesagt habe, das war die hohe Kohärenz.

[17:30] Also bei der Kopplung wollen wir eine möglichst geringe haben.

[17:32] Bei der Kohärenz wollen wir eine möglichst hohe haben.

[17:35] Was ist denn jetzt die Kohärenz?

[17:37] Die Kohärenz bedeutet einfach nur den Grad der Verwendung der Attribute einer Klasse durch ihre Methoden.

[17:44] Als Beispiel, wenn eine Klasse eine Methode hat und ein Attribut und diese eine Methode benutzt auch das eine Attribut,

[17:51] dann haben wir eine sehr gute Kohärenz, weil alle Methoden der Klasse alle Attribute der Klasse benutzen.

[17:58] Das ist in den meisten Klassen allerdings nicht der Fall.

[18:00] Ich habe zum Beispiel mein Auto, da habe ich den Kilometerstand und auch die Türen als Objekte drin.

[18:07] Dann werden wahrscheinlich in den wenigsten Fällen die Methoden beide Attribute benutzen.

[18:11] Also zum Beispiel meinen Kilometerstand und meine List of Tür oder wie auch immer.

[18:16] Wenn ich zum Beispiel fahre, wird der Kilometerstand verändert, aber sicherlich nicht die Tür geöffnet.

[18:20] Wenn ich die Tür öffne, wird aber nicht der Kilometerstand verändert.

[18:23] Das heißt, wenn ich zwei Methoden habe, sowas wie fahre und öffne Türen,

[18:27] dann werden diese beiden Methoden jeweils nur ein Attribut benutzen der Klasse und nicht beide.

[18:32] Das heißt, ich habe eine geringere Kohärenz.

[18:35] Das heißt, meine Methoden und meine Attribute gehören eigentlich nicht so richtig zusammen.

[18:39] Wir haben ja schon gelernt, die Kapselung in der Objektorientierung ist ja so ein tolles Prinzip.

[18:44] Sie bedeutet nämlich, dass die Attribute und die zugehörigen Methoden in einer Klasse gekapselt sind.

[18:50] Aber wenn jetzt die Attribute und die Methoden eigentlich gar nicht so richtig zusammenarbeiten,

[18:54] weil die Hälfte der Methoden nur die andere Hälfte der Attribute benutzt,

[18:57] dann haben wir eigentlich irgendwas geschaffen, was gar nicht so richtig zusammengehört.

[19:01] Und dann haben wir eine geringe Kohärenz und das wollen wir eben gerade nicht.

[19:05] Also eine perfekte Klasse mit der perfekten Kohärenz hätten wir dann,

[19:10] wenn jede Methode einer Klasse jedes Attribut einer Klasse benutzt.

[19:14] Das wäre super.

[19:15] Ist in den meisten Fällen allerdings genau wie die geringe Kopplung in der Praxis sehr selten anzutreffen.

[19:21] weil wir einfach durchaus Attribute zu abstrakten Klassen zusammenbauen, also

[19:26] nicht abstrakt im Sinne von abstract, sondern einfach zu einer, zu diesem

[19:29] abstrakten Konzept einer Klasse zusammenbauen, die einfach vielleicht

[19:32] nicht immer was miteinander zu tun haben. Wie gesagt, Auto, Kilometerstand und die

[19:36] Türen, die gehören halt zu einem Auto, aber ich werde sie in den seltensten

[19:40] Fällen gemeinsam manipulieren. Deswegen ist das also durchaus in Ordnung, wenn wir

[19:44] Klassen haben, die nicht zu 100 Prozent kohärent sind, aber wir sollten halt

[19:47] versuchen, dass wir es hinkriegen, dass wir möglichst alle Methoden, alle

[19:51] Attribute benutzen. Andersherum, wenn wir feststellen, dass

[19:56] Attribute unserer Klasse kaum genutzt werden oder sagen wir mal, ich habe zehn

[20:00] Methoden und ein Attribut wird nur in zwei dieser Methoden benutzt, dann wäre

[20:04] das zum Beispiel ein Indiz dafür, dass wir die Klasse vielleicht auseinanderziehen

[20:07] müssen, nämlich diese beiden Attribute, die irgendwie zusammen manipuliert werden

[20:10] von einer Methode, die müssen vielleicht in eine andere Klasse, damit wir dann zwei

[20:14] einzelne Klassen haben, die jeweils eine kleinere Aufgabe haben, dafür aber auch

[20:19] eine höhere Kohärenz. Da sind wir dann wieder beim Single Responsibility

[20:22] Principle. Also wenn ich eine Klasse habe mit vielen Methoden und vielen

[20:25] Attributen, aber die ganzen Methoden nutzen alle immer nur ein oder zwei

[20:28] Attribute, dann habe ich eine geringe Kohärenz und das kann darauf hindeuten,

[20:32] dass die Klasse zu viel macht und dass ich sie auseinanderziehen muss, um wieder

[20:36] kleine Klassen zu haben mit hoher Kohärenz. So, das waren meine Regeln zum

[20:41] Klassendesign. Wenn du noch ein paar mehr hast, dann gerne hier damit. Schreibt mir

[20:45] gerne Kommentar zu der Podcast Episode da drunter. Da bin ich sehr gerne offen für

[20:49] weitere Anregungen. Es gibt sicherlich noch ganz viele andere Sachen, die ich

[20:53] zum Beispiel nicht erwähnt habe, wie zum Beispiel die Solid Prinzipien. Da kann

[20:56] ich noch vier andere Sachen rausziehen, die ich auf meine Klassen anwenden kann,

[20:58] aber wir sind ja hier jetzt gerade in der Lernzielkontrolle, sage ich mal, zu

[21:01] Beginn der Programmierung und da will ich jetzt nicht so sehr schon in die

[21:05] Tiefen der Objektorientierung abtauchen. Ich denke mal, mit den paar Regeln, die ich

[21:09] jetzt genannt habe, kann man schon ganz gut einsteigen. Vor allem kann man die

[21:12] auch gut kontrollieren. Man sieht das auch als Anfänger leicht, ob die Klasse,

[21:16] die man programmiert hat, diesen Regeln folgt oder nicht. Gut, dann kommen wir jetzt

[21:20] mal zu dem dritten Thema für heute, nämlich den Enumerations und das hat

[21:23] jetzt erstmal rein gar nichts eigentlich mit den anderen beiden Themen zu tun, mit

[21:26] den Gettern und Zettern und dem Klassendesign, aber es passt halt in

[21:30] meinem Tutorial ganz gut rein, denn die Enumerations lösen ein paar nette

[21:35] Probleme, die man auch gleich zu Beginn der Programmierung häufig hat.

[21:38] Ich gehe mal kurz ein Beispiel durch in meinem Tutorial. Da geht es um eine

[21:43] Klasse Hund, die man programmieren soll. Ich wollte jetzt nicht zum 90. Mal das

[21:47] Auto nehmen, wobei, ehrlich gesagt, ich nehme das Auto als Einführung und die

[21:50] Hund-Aufgabe ist dann das, was die Leute selber programmieren sollen. Auf jeden Fall

[21:54] programmiere ich da einen Hund und der Hund hat ein Lieblingsessen. Ein

[21:58] Lieblingsessen, zum Beispiel Knochen oder Futter oder Kuchen oder was auch

[22:02] immer und jetzt kann man dieses Lieblingsessen in so einer Klasse

[22:06] natürlich einfach als String speichern. Da kann ich natürlich alles Mögliche

[22:09] da eingeben, da kann ich dem Hund aber auch als Lieblingsessen nicht

[22:12] Knochen setzen, sondern zum Beispiel Knachen, weil ich mich leider vertippt

[22:16] habe. Das heißt, dann ist das Lieblingsessen des Hundes auf einmal

[22:19] kein gültiges Essen mehr, sondern ein String mit einem Rechtschreibfehler

[22:22] drin und das wäre natürlich ungünstig. Noch schlimmer, ich habe vielleicht eine

[22:25] Anwendung, die mit Kalenderdaten arbeitet, mit Datumsangaben und so was

[22:29] und dann muss ich da einen Wochentag angeben. Wochentage kann es eigentlich

[22:32] nur von 1 bis 7 geben. Sonntag bis Freitag, Sonntag bis Samstag

[22:35] beziehungsweise Montag bis Sonntag, je nachdem, wie man anfängt zu zählen und dann

[22:39] habe ich vielleicht die Idee, dass ich meine Wochentage entweder durchnummeriere

[22:42] als Integerspeicher oder ich mache es noch schlimmer als String und kann da

[22:46] auch wieder irgendwas eingeben. Was passiert denn dann, wenn ich mich bei

[22:48] den Werten vertippe und auf einmal nicht Montag, sondern Maantag im Kalender

[22:52] steht? Das wäre doof. Im einfachsten Fall wäre es nur doof, im schlimmsten Fall

[22:56] stürzt die Anwendung ab oder produziert Schrott. Das soll natürlich nicht

[23:00] passieren. Das kann sowohl dann vorkommen, wenn ich

[23:02] Strings benutze, aber auch bei allen anderen Datentypen, die wir schon

[23:05] kennengelernt haben, zum Beispiel beim Integer. Wenn ich einen Datentyp, der

[23:08] eigentlich gar nicht zu dem Datentyp passt, den ich da benutze, abbilden will,

[23:12] dann habe ich ein Problem. Also der Kern des Ganzen ist, wenn ich in meiner Klasse

[23:17] ein Attribut abbilden möchte, was eine fix definierte Liste an Werten nur

[23:22] erlaubt, Beispiel Wochentage, da gibt es genau sieben, da gibt es nicht einen

[23:26] mehr und auch nicht einen weniger. Monate, da gibt es genau zwölf und nicht mehr

[23:30] oder weniger. Lieblingsessen ist vielleicht in meiner Hundeanwendung

[23:34] auch eine abzählbare Liste. Sage ich jetzt einfach mal so, ist in der Praxis

[23:38] vielleicht nicht der Fall, aber in unserer Applikation könnte es ja sein,

[23:41] dass der Hund halt nur Knochen, Kuchen und Hähnchen haben darf und sonst nichts,

[23:45] weil unsere tolle Hundepension nur diese drei Sachen anbietet meinetwegen.

[23:48] Dann wäre es halt doof, wenn der Hundebesitzer eintragen kann, mein Hund

[23:51] mag gerne Zigaretten. Das ist sowohl für den Hund ungesund, als auch die

[23:55] Hundepension kann es nicht anbieten. Also wäre blöd, wenn das in der

[23:58] Applikation ginge. Deswegen müssen wir doch eigentlich irgendwie festlegen

[24:01] können, dass eben nur eine definierte Anzahl an Werten erlaubt ist und das

[24:06] kann ich tun, indem ich einen eigenen Datentyp dafür baue und das wäre eine

[24:10] Enumeration. Wie der Name auf Englisch schon sagt, das ist einfach eine

[24:13] Aufzählung. Eine Enumeration ist also ein Aufzählungstyp und in diesem Typ

[24:18] kann ich einfach eine Liste an erlaubten Werten festlegen. Ich könnte

[24:22] mir also zum Beispiel eine Enumeration vorstellen mit dem Namen Tag oder besser

[24:26] Wochentag. Machen wir es mal so. Und dieser Wochentag hat sieben Konstanten, die

[24:31] definiert werden, nämlich Montag, Dienstag, Sonntag. Und ich kann jetzt dann

[24:34] in meinem Code sowas machen wie wochentag.montag und dann kann ich auch

[24:40] nicht sowas eingeben wie manntag, denn das, was ich da gerade produziert habe,

[24:43] ist eine typsichere Auflistung. Wenn ich mit einer Enumeration arbeite, kann ich

[24:48] keine anderen Werte mehr benutzen an dieser Stelle, außer denen, die in der

[24:52] Enumeration definiert sind. Das heißt, es verhindert zum einen

[24:57] Rechtschreibfehler oder sonst was oder einfach auch illegale Werte, wie zum

[25:01] Beispiel, das Alter ist jetzt schlecht, so ein Alter einer Person würde ich auf

[25:04] keinen Fall als Enumeration abbilden, aber nennen wir mal Wochentag.

[25:08] Wochentag hatte ich vorher als int definiert, meinetwegen. Dann hindert mich

[25:11] ja niemand daran, wenn ich irgendwo eine Methode habe, wo ein int-Parameter

[25:14] reingegeben wird, dass ich da einfach mal 97 eingebe. Aber was soll 97 für einen

[25:19] Wochentag sein? Den gibt es nicht. Es ist nur erlaubt, meinetwegen, von 0 bis 6.

[25:23] Das kann ich aber weder an der Methodensignatur sehen, da steht einfach

[25:26] nur int-Wochentag, aber ich weiß gar nicht, was ist denn jetzt welcher

[25:30] Wochentag? Ist 1 der Sonntag oder ist 1 der Montag? Weiß ich nicht. Und was

[25:34] passiert, wenn ich 97 zum Beispiel eingebe? Wird die Applikation das

[25:39] irgendwie händeln oder gibt es dann einen Abbruch oder kriege ich dann

[25:42] irgendwie Fehler? Ja, das wäre ungünstig. Kann ich nicht sehen an der

[25:45] Signatur der Methode. Wenn ich stattdessen einen Wochentag als

[25:48] Enumeration da reingebe, dann weiß ich, oh, ich darf nur Werte aus dieser

[25:52] vordefinierten Liste benutzen und ich kann auch, das würde der Compiler dann

[25:56] sicherstellen, gar keinen anderen Wert mehr reingeben. Das heißt, ich kann nicht

[25:58] einfach 97 da reingeben oder Montag oder was auch immer. Ich kann nur

[26:03] Wochentag Punkt und dann die sieben Werte, die Wochentag definiert, dort

[26:07] reingeben. Genau dafür finde ich Enumerations sehr schön, denn wenn ich

[26:10] eine definierte Liste an Werten habe, von der auch nicht irgendwie abgewichen

[26:14] werden darf, dann definiere ich mit einem Enumeration dazu. Und das Schöne in Java im

[26:19] Speziellen ist, dass Enumerations nichts weiter sind als im Prinzip Klassen, wenn

[26:22] man so will. Die Syntax ist sehr ähnlich zu einer Klasse. Ich mache nicht Class

[26:26] Wochentag zum Beispiel, sondern Enum Wochentag, aber in Java hat so ein Enum

[26:32] wirklich die Eigenschaften einer Klasse. Ich kann da also auch Methoden rein

[26:34] programmieren und das benötigt man häufig, um zum Beispiel so Konvertierungen

[26:38] zu machen. Wenn ich meinetwegen Eingaben vom Benutzer entgegennehme, angenommen ich

[26:42] habe ein Registrierungsformular für meine Hundepension und dann kann der

[26:46] Hundebesitzer sowas eingeben wie, was ist denn mein Lieblingsessen oder

[26:49] beziehungsweise das Lieblingsessen des Hundes und dann gibt er da halt Knochen

[26:52] ein. Dann habe ich den Knochen natürlich als String aus dem Formular. Ich

[26:55] brauche aber in meiner Anwendung vielleicht diese Enumeration-Value und da kann es

[26:59] natürlich sinnvoll sein, dass ich direkt in der Klasse Lieblingsessen, meinetwegen,

[27:03] eine Funktion bereitstelle, wie konvertiere String zu Lieblingsessen und

[27:08] dann gebe ich den String da rein und kriege das Lieblingsessen da raus. Wo soll

[27:11] ich das sonst hinpacken als in die Enumeration selbst? Und das geht in Java

[27:14] ohne Probleme. Da kann ich einfach ein paar Methoden in diese Enum reinpacken.

[27:18] Also, das letzte Thema für heute wäre damit abgeschlossen. Enumerations, wann

[27:23] benutze ich die? Eine Enumeration ist ein Datentyp, der quasi eine abgeschlossene

[27:27] Liste an Werten definiert und die benutze ich immer dann, wenn meine Liste

[27:31] der Werte eben begrenzt werden soll und ich mir keine Fehler einfangen will,

[27:36] weil ich irgendwie nicht kontrollieren kann, was mir denn da so für Werte

[27:39] reingegeben werden von draußen, zum Beispiel Strings, Integers, was auch immer.

[27:42] Und ich bekomme dadurch quasi so eine Art Typ-Sicherheit, nicht nur so eine

[27:46] Art, sondern der Compiler im Falle von Java und C-Sharp allerdings dann auch,

[27:49] der prüft eben, ob das, was ich da reingebe, auch wirklich ein erlaubter

[27:52] Wert ist oder nicht. Und wenn das kein erlaubter Wert ist, dann lässt sich das

[27:56] Programm nicht kompilieren. Also, der Compiler ist auf meiner Seite, er

[27:59] unterstützt mich jetzt, außerdem unterstützt mich natürlich auch meine

[28:02] IDE. Wenn der da Wochentag findet, Eclipse zum Beispiel, dann schlägt er mir

[28:05] automatisch schon die sieben Werte vor, die es gibt und erlaubt mir da nicht alle

[28:08] möglichen Eingaben. So, damit wäre ich für heute durch mit dem Thema oder mit

[28:14] den Themen Getter, Setter, Klassendesign und Animulations, wild zusammengewürfelt.

[28:19] In der nächsten Woche mache ich mal eine Episode nicht mehr zu Lernzeilenkontrolle,

[28:23] sondern zu was anderem Spannenden. Ich weiß, dass gerade aktuell wieder die

[28:27] mündlichen Prüfungen laufen. Wahrscheinlich, wenn die Episode rauskommen,

[28:30] sind schon die meisten vorbei. Aber das kann ich jetzt leider nicht so gezielt

[28:33] steuern. Aber ich habe schon seit langem aufgeschoben, die Episode rund um die

[28:38] häufigsten Wirtschaftsfragen im Fachgespräch. Ich weiß, dass einige

[28:42] Azubis drauf brennen, die endlich zu hören, denn die Wirtschaft ist jetzt für

[28:47] die meisten Azubis nicht unbedingt das Lieblingsthema. Und mal so ein paar Themen

[28:51] zu vertiefen tut, glaube ich, Not an der Stelle. Deswegen meine Fortführung der

[28:56] Reihe der häufigen Fragen im Fachgespräch beim nächsten Mal. Wenn du

[29:01] dir die Shownotes zu dieser Episode anschauen willst, wo zum Beispiel einige

[29:04] interessante Links hinterlegt sind, gerade auch zum Single Responsibility

[29:08] Principle und auch zu der Kohärenz und der Kopplung noch mal ein super Artikel,

[29:13] der das noch mal sehr schön erklärt, dann geh doch einfach auf

[29:16] anwendungsentwicklerpodcast.de slash 45, also 4 und 5, die beiden Ziffern, um zu

[29:22] dieser 45. Episode die Shownotes, die Links und die Literaturempfehlungen

[29:25] anzuschauen. Literaturempfehlungen, wie eigentlich immer bei den LZKs, sind

[29:29] wieder die Einführung in Java, beziehungsweise die Java-Insel aus dem

[29:33] Rheinwerk-Verlag. Aber zu dieser Episode ganz konkret empfehle ich dir auch

[29:37] Clean Code von Bob Martin. Von dem habe ich auch einen super Artikel verlinkt,

[29:41] wo er das Single Responsibility Principle erklärt. Der gilt quasi so, ja, wie soll

[29:45] man sagen, nicht als der Erfinder dieser Prinzipien, aber er war so der erste, der

[29:49] mal schön auf den Punkt zusammengefasst hat und aufgeschrieben hat. Und in Clean

[29:53] Code, das ist eigentlich so meine Programmiererbibel, die gehe ich jetzt

[29:56] auch bei meinen Azubis noch mal einmal durch und werde das auch selber noch mal

[29:59] lesen, weil es schon ein paar Jahre her ist, dass ich das getan habe. Und da

[30:02] stehen so viele knackige, prägnante und praxisnahe Tipps einfach drin für die

[30:08] Programmierung, auch egal in welcher Programmiersprache oder welchem Paradigmen

[30:11] man unterwegs ist, dass ich das einfach unbedingt empfehlen kann. Gerade zu dem

[30:15] großen Bereich Klassendesign, wo ich jetzt nur, sag ich mal, so oberflächlich ein

[30:19] paar Regeln vorgestellt habe, kann man aus dem Buch noch einiges rausziehen.

[30:22] Gerade auch für Anfänger. Das ist wirklich für Programmierer jeglicher

[30:26] Couleur geeignet und deswegen ist das für diese Episode meine absolute

[30:30] Leseempfehlung. Wenn du schon auf der Seite bist, dann schau dir doch noch mal

[30:35] zwei Artikel an. Letzte Woche habe ich nämlich auf der Seite noch einen etwas

[30:39] umfangreicheren Artikel zum Thema Handouts bei der Projektpräsentation

[30:43] geschrieben. Kurze Zusammenfassung. Lass das Handout weg. Es ist Schrott. Warum?

[30:48] Kannst du im Blog nachlesen. Und mein Link der Woche beim letzten Mal war eine

[30:52] schöne Liste mit Tipps rund um die Gestaltung professioneller Präsentationen

[30:56] vom Lead-Designer von TED. Ich weiß nicht, ob du TED schon kennst.

[31:00] TED.com. T-E-D. Ja, wie der Film mit den Bären, den ich jetzt aber nicht meine,

[31:04] sondern Technology Entertainment Design heißt es, glaube ich. Oder Technology

[31:09] Education Design. Ich weiß es selber nicht. Auf jeden Fall TED.com. Da gibt es

[31:13] einen Haufen an super geilen Präsentationen, die alle maximal 17

[31:17] Minuten lang sind und damit kann man sich den ganzen Tag zudröhnen und

[31:21] wirklich coole, interessante, spannende Wirtschaftsthemen, Technikthemen, alles

[31:24] mögliche, sich anschauen auf Weltklasseniveau. Und der Lead-Designer

[31:28] von dieser Non-Profit-Organisation, die dahinter steht, hat ein paar coole Tipps

[31:34] gegeben, wie man wirklich anspruchsvolle, nicht anspruchsvolle, ansprechende

[31:37] Präsentationen gestaltet. Und ich denke, da kann man auch als Prüfling ganz viel

[31:40] rausziehen. Deswegen habe ich es letzte Woche verlinkt. Schau doch mal rein.

[31:43] Vielleicht sind auch für dich noch ein paar nette Tipps dabei, wenn du irgendwann

[31:47] mal was präsentieren musst. Könnte ja durchaus mal vorkommen. Dann würde ich

[31:50] mich wie immer über jegliches Feedback freuen, zur Episode, zum Podcast,

[31:54] egal wie du mich erreichen willst. Du kannst es tun unter www.anwendungsentwicklerpodcast.de

[31:58] und dann iTunes, Stitcher, Facebook, Twitter, Xing. Das kannst du

[32:03] alles dahinter schreiben und landest dann auf der entsprechenden Seite, um mit

[32:06] mir in Kontakt zu treten. Du kannst mir auch eine Mail schreiben unter mail

[32:09] at www.anwendungsentwicklerpodcast.de. Und zum Schluss, wenn du möchtest, trag dich

[32:14] doch in meinen Newsletter ein unter www.anwendungsentwicklerpodcast.de. Mein Gott, ich

[32:18] brauche eine kürzere Domain. Da kannst du den Newsletter abonnieren. Du

[32:22] kannst es aber auch direkt auf der Startseite. Es ist überall im Menü verlinkt und

[32:26] bekommst damit einmal die Woche alle Neuigkeiten von der Website und

[32:31] bekommst auch gleich Zugriff auf meine Artefakte rund um die Projektarbeit,

[32:35] nämlich drei Checklisten für den Projektantrag, die Projektdoku und die

[32:38] Projektpräsentation. Und außerdem gibt es auch die Links der Woche, nicht erst

[32:43] Freitag, sondern schon am Montag vorab. Und du kannst auch, wenn du mit mir in

[32:47] Kontakt treten willst, einfach auf die Mails antworten. Das fände ich natürlich

[32:50] besonders toll, denn ich mache das hier ja nicht zum Spaß, obwohl doch eigentlich

[32:54] macht es Spaß. Aber ich möchte natürlich auch ein bisschen Feedback haben von meinen

[32:56] Hörern, ob ich hier das Richtige erzähle oder nicht. Also wenn du irgendwas zu

[32:59] sagen hast, dann scheue dich nicht und spreche mich einfach an.

[33:02] Ja, damit mache ich dann mal Schluss für heute. Nächste Woche, wie gesagt, geht es

[33:07] dann um die Wirtschaftsfragen im Fachgespräch. Bis dahin sage ich vielen,

[33:11] vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!

[33:20] Untertitel der Amara.org-Community

Polyglot Clean Code Developer
About the Author
Ausbildungsleiter für Fachinformatiker:innen Anwendungsentwicklung, IHK-Prüfer und ehemaliger Hochschuldozent für Programmierung und Software-Engineering.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert