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.
Podcast: Play in new window | Download (Duration: 33:26 — 14.8MB)
Abonnieren: Apple Podcasts | Spotify | RSS
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
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
publicAttributen?- Man kann z.B. das Setzen ungültiger Werte verhindern.
- Welchen Vorteil haben Getter im Vergleich zu
publicAttributen?- 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
publicmachen (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 oderIntegers)?- Wenn die Anzahl der erlaubten Werte begrenzt ist bekommt man durch eine Enumeration eine Art „Typsicherheit“.
Literaturempfehlungen
*
*
(direkt beim Rheinwerk-Verlag bestellen*)- Viele weitere „Regeln“ zum Schreiben von Klassen (oder auch grundsätzlich zur sauberen Programmierung) findest du in Clean Code*.
*
(direkt beim Rheinwerk-Verlag bestellen*)
Links
- Permalink zu dieser Podcast-Episode
- RSS-Feed des Podcasts
- ArticleS.UncleBob.PrinciplesOfOod
- The Single Responsibility Principle (PDF)
- Robert C. Martin – The Single Responsibility Principle. on Vimeo
- Strive for low coupling and high cohesion What does that even mean
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
protectederlaubt 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
Herzlich willkommen zum Anwendungsentwickler-Podcast,
dem Podcast rund um die Ausbildung zum Fachinformatiker für Anwendungsentwicklung.
In dieser Episode gibt es eine weitere Lernzielkontrolle zur Objektorientierung.
Viel Spaß!
Hallo und herzlich willkommen zur 45. Episode des Anwendungsentwickler-Podcasts.
Mein Name ist Stefan Macke und heute geht es weiter mit dem Thema Objektorientierung.
Ich setze meine Reihe der Lernzielkontrollen zum Thema fort und heute behandeln wir drei Themen auf einmal,
nämlich die Getter und Setter, dann noch das Klassendesign und zum Schluss auch nochmal ein paar Enumerations.
Das sind so ein paar Themen, die jetzt ein bisschen bunt zusammengewürfelt sind, aber ich hatte beim letzten Mal schon erklärt,
ich mache die Lernzielkontrolle ja so passend zu dem Java-Tutorial, was ich immer mit meinen Azubis und Studenten mache.
Und da ist das zufälligerweise jetzt die Reihenfolge, in der die das machen.
Irgendwann nach der ersten eigenen Klasse führe ich dann zum Beispiel die Enumerations ein und von daher passt das jetzt hier gerade rein.
Deswegen erzähle ich das heute. Es hat also keinen großen Zusammenhang zwischen Klassendesign und Enumeration.
Es passt einfach nur zeitlich ganz gut zusammen.
Okay, steigen wir direkt ein mit Gettern und Settern.
Beim letzten Mal hatten wir ja uns die Sichtbarkeitsmodifiziere angeschaut.
Die sorgen ja dafür, dass wir das Geheimnisprinzip umsetzen können,
nämlich dass die inneren Werte quasi unserer Klasse vor der Außenwelt verborgen bleiben.
Und heute wollen wir uns diesem Geheimnisprinzip nochmal ein bisschen weiter widmen,
denn diese inneren Werte sollen ja verborgen bleiben.
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.
Wenn wir zum Beispiel irgendwelche Werte, die so eine Klasse speichert, gar nicht abfragen könnten oder gar nicht setzen könnten,
ja was sollen wir dann mit der Klasse anstellen?
Die bringt uns dann ja nichts, weil wir gar nicht mit ihren Werten arbeiten können.
Deswegen müssen wir ja schon irgendwie da vielleicht mal dran kommen.
Und die Idee, wie man das jetzt macht, wie man das vernünftig macht in der Objektorientierung, ist,
dass wir eben nicht einfach die Attribute zum Beispiel public machen und somit durch jeden lesend aber auch schreibbar Zugreifer machen,
sondern wir verwenden ein paar Methoden, die den Zugriff etwas genauer steuern können.
Und diese Methoden nennt man Getter und Setter, je nachdem, was man mit ihnen macht.
Entweder man gettet, oh Gott, oh Gott, ganz schreckliches Deutsch.
Entweder man holt einen Wert von einem Objekt, das ist dann eben die Get-Methode, der Getter.
Oder man setzt einen Wert, das ist dann der Setter.
Deswegen heißen die Methoden so.
Und in der einfachsten Form machen die wirklich nichts weiter, als einen Wert zu setzen bzw. abzufragen.
Jetzt kann man sich natürlich dann fragen, ja, wofür brauche ich denn ein Getter und Setter,
wenn die sowieso einfach nur sowas machen, wie zum Beispiel this Punkt Kilometerstand gleich Kilometerstand,
bzw. der Getter für Kilometerstand einfach nur return Kilometerstand macht,
dann kann ich mir doch eigentlich auch die Getter und Setter sparen, oder nicht?
Oder ich könnte einfach direkt das Attribut public machen und habe ich ja das gleiche erreicht.
Aber das ist eben nicht der Fall, denn wenn ich Getter und Setter benutze,
kann ich zum einen steuern, welche Richtung erlaubt ist und welche nicht.
Ich kann ja zum Beispiel einen Getter implementieren, aber einen Setter nicht.
Damit kann ich also einschränken, dass geschrieben wird, aber das Lesen kann ich sehr wohl erlauben.
Oder ich könnte zum Beispiel auch die Sichtbarkeit der beiden Getter und Setter unterschiedlich gestalten.
Ich könnte zum Beispiel sagen, alle abgeleiteten Klassen, die dürfen setzen,
also mache ich den Setter zum Beispiel protected und den Getter mache ich public.
Den darf jeder benutzen.
Oder ich mache den Setter sogar private, dann kann nur die Klasse selber irgendwas setzen,
aber niemand anderes kann es halt mit irgendwelchen ungültigen Werten setzen oder sowas.
Das ist jetzt also erstmal die Einführung.
Getter und Setter sind nichts weiter als Methoden zum Lesen und Setzen von Instanzvariablen.
Mehr machen die eigentlich nicht.
Und was jetzt die Vorteile sind von Gettern und Settern,
den einen haben wir gerade angesprochen, ich kann also unterschiedliche Sichtbarkeit implementieren
oder ich muss die auch einfach gar nicht implementieren.
Ich könnte zum Beispiel sagen, den Getter biete ich an, aber den Setter nicht.
Das heißt, ich kann wirklich nur lesend auf das Objekt zugreifen und das ist vielleicht auch gar nicht schlecht.
Gerade wenn wir heutzutage dann denken, dass wir immer mehr parallele Software haben,
die also nebenläufig läuft, dann ist es gar nicht so schlecht,
wenn man bei Objekten bestimmte Werte gar nicht setzen kann.
Denn wenn mehrere Threads zum Beispiel parallel versuchen, einen Wert zu setzen,
dann kann es ganz schnell Probleme geben.
Und wenn wir unsere Klassen so modellieren, dass sie einfach rein lesbar sind
und wir gar nicht von draußen was setzen können,
dann haben wir da deutlich weniger Probleme, nämlich, um genau zu sein, eigentlich gar keine.
Deswegen kann es durchaus sinnvoll sein, Objekte so zu bauen,
dass man nur Attribute von ihnen lesen kann, aber nicht schreiben.
Das heißt dann auch, dass sie immutable sind auf Englisch, also unveränderbar.
Ein schönes Beispiel für so eine Klasse, von der man nur lesen kann,
sie aber nie wieder ändern kann, ist ganz einfach in Java der String.
Der String ist ein immutable Object, wenn man das auf Englisch mal formuliert.
Das bedeutet, sobald ich einen String verändere,
wird eigentlich nicht der Ursprungs-String tatsächlich im Speicher verändert,
sondern es wird immer, durch Java zumindest, sichergestellt, dass es einen neuen String gibt.
Wenn ich also sowas mache wie string plusgleich abc,
dann wird nicht der eigentliche String verändert,
sondern ich bekomme einen neuen String zurück, der eben den veränderten Wert enthält.
Aber der ursprüngliche String bleibt immer unverändert.
Und solche Dinge kann ich wunderbar programmieren in Objekte und Türen,
wenn ich einfach meine Attribute alle auf private setze und nur getter implementiere.
Dann habe ich nämlich sichergestellt, dass keiner von draußen die Werte ändern kann. Fertig.
So, jetzt müssen wir trotzdem noch überlegen, was für einen weiteren Vorteil getter und setter haben.
Das kann man jetzt mal ein bisschen aufteilen.
Die getter haben zusätzlich noch die Möglichkeit, weil es ja eine Methode ist, die ich da implementiere,
dass ich da eben Logik reinbauen kann.
Und ein Beispiel, was ich dann immer anführe, ist sowas wie,
ich habe einen Wert, den merkt sich das Objekt gar nicht, zum Beispiel in einer Instanzvariable,
sondern der wird erst zur Laufzeit berechnet.
Ganz einfaches Beispiel, ich habe eine Klasse Person und da habe ich eine Methode getAlter.
Jetzt kann sich die Person natürlich ihr Alter merken, aber sie kann es auch einfach zur Laufzeit berechnen.
Wenn zum Beispiel die Person das Geburtsdatum gespeichert hat,
kann ich einen getter fürs Alter anlegen, ohne dass diese Person sich das Alter merken muss.
Sie kann es einfach zur Laufzeit aus dem heutigen Datum und ihrem Geburtsdatum berechnen.
Das wäre ein Vorteil von gettern.
Das kann ich auf keinen Fall tun, wenn ich halt ein reines Attribut benutze, weil das keine Logik enthalten kann.
Das gleiche beim setter. Auch da kann ich Logik implementieren.
Und was wäre jetzt das klassische Beispiel da?
Ja, ich könnte prüfen, ob die Werte, die da gesetzt werden sollen, dann auch gültig sind.
Wir hatten beim letzten Mal schon gelernt, dass Objekte immer in einem gültigen Zustand sein sollen.
Und diese Aufgabe habe ich als Entwickler.
Ich muss mich darum kümmern.
Das heißt, ich muss einschränken, dass zum Beispiel von draußen niemand mein Objekt in einen ungültigen Zustand setzt.
Und das kann ich tun, indem ich setter programmiere.
Da kann ich dann zum Beispiel, bleiben wir vielleicht bei der Person und dem Alter,
so etwas implementieren, dass ein Alter ungültig ist, wenn es kleiner 0 ist.
Oder größer 200, wenn wir von Menschen sprechen.
Das heißt, da könnte ein setter also so aussehen, dass ich ein neues Alter reinbekomme als int
und als erstes geprüft wird, dass das Alter eben auch gültig ist.
Also, wenn das Alter kleiner ist als 0 oder größer als 200, meinetwegen,
dann wird halt eine Exception geworfen oder das Alter wird einfach nicht gesetzt oder wie auch immer,
was ich da halt machen will in meinem Programm.
Und diese Möglichkeit habe ich eben nicht, wenn ich das Attribut einfach public mache.
Also, kurz zusammengefasst, getter, da kann ich zur Laufzeit auch einfach was berechnen.
Dann spare ich mir das Speichern irgendwelcher Werte.
Und beim setter kann ich zusätzlich noch prüfen, ob die übergebenen Werte gültig sind
und damit sicherstellen, dass mein Objekt in einem gültigen Zustand bleibt.
Damit haben wir das Thema getter und setter eigentlich schon abgearbeitet.
Vielleicht noch eine Kleinigkeit aus der Praxis.
Bei uns ist es so, dass wir häufig die versicherungsinterne Software auf Deutsch programmieren,
weil es einfach zum Beispiel bestimmte Fachbegriffe nicht auf Englisch gibt,
beziehungsweise das nur zur Verwirrung beitragen würde, aber nicht zur Verständlichkeit des Codes,
wenn wir alles mögliche übersetzen würden auf Englisch.
Deswegen hat man dann, wenn man auf Deutsch programmiert oder auch in irgendeiner anderen Sprache,
immer das Problem, diese getter und setter zu benennen.
Denn es ist halt so schön etabliert, dass man sie halt get und set irgendwas nennt.
Aber dann kommt man halt auf solche Methodennamen wie zum Beispiel get-Kilometerstand.
Und das ist natürlich irgendwie von der Lesbarkeit her hässlich.
Da habe ich halt zwei Sprachen gemischt.
Ich persönlich würde die Methoden trotzdem mit get und set beginnen lassen,
denn eine deutsche Übersetzung habe ich noch nicht so richtig gefunden, die mir gut gefällt.
Man könnte zum Beispiel get mit gib übersetzen, aber das finde ich irgendwie doof.
Gib-Kilometerstand.
Oder sowas wie gib-Kilometerstand-zurück finde ich auch doof.
Ermittle-Kilometerstand finde ich auch blöd.
Das hört sich immer so an, als ob irgendwas berechnet wird.
Also das passt irgendwie nicht so richtig.
Set und setze würde vielleicht funktionieren.
Setze-Kilometerstand, okay.
Aber wenn das mit get irgendwie nicht so richtig hinhaut, also ich finde das irgendwie doof.
Und ich finde auch, dass man irgendwie den Methoden ansehen sollte, dass es getter und setter sind.
Deswegen, meiner Meinung nach, sollte man die trotzdem get und set nennen
und dann halt eben mit dem deutschen, beziehungsweise in welcher Sprache man auch immer arbeitet, Wort dann dahinter.
So, jetzt kommen wir mal ein bisschen weg vom konkreten Code, getter, setter, Methoden, Attribute und so weiter
und werden mal ein bisschen abstrakter.
Das nächste Thema ist nämlich das Klassendesign.
Und da habe ich einfach mal eine Frage aufgeschrieben.
Was sind denn so ein paar grundlegende Regeln beim Schreiben von Klassen?
Worauf sollte ich vielleicht achten, wenn ich Objekte irgendwie programmiere?
Was soll ich mal bei meinen Klassen machen und was nicht?
Und das Erste, was ich immer anführe, ist, dass eine Klasse nur eine einzige Aufgabe haben sollte.
Das nennt man auf Englisch auch gerne das Single Responsibility Principle.
Das heißt, die Klasse hat nur eine Zuständigkeit, eine Verantwortung.
Und das ist deswegen eine tolle Regel, weil ich so immer weiß, wo ich etwas ändern muss.
Stellen wir uns mal eine Klasse vor, die nicht nur eine einzige Aufgabe hat.
Ganz blöd, sowas wie ein Dateileser, der auch gleichzeitig was schreiben soll.
Also nennen wir ihn mal Dateimanager.
Das ist übrigens gleich schon mal ein super Beispiel für einen schlechten Klassennamen.
Denn wenn ich solche Wörter benutze, die völlig nichtssagend sind, wie zum Beispiel Manager oder Verwalter.
Oder am besten noch Utility. Das ist noch das Schlimmste.
Wenn ich so eine Klasse sehe, dann weiß ich schon, die macht mehr als eine Sache.
Und stellen wir uns mal so einen Dateimanager vor, der also lesen und schreiben kann.
Dann können wir uns jetzt mal vorstellen, wenn ich jetzt irgendwo einen Bug habe, zum Beispiel beim Schreiben einer Datei.
Die Datei wird nicht richtig geschlossen, meinetwegen.
Und ich muss diesen Bug fixen, dann fixe ich das in der Klasse Dateimanager.
Bei diesem Bugfixing kann es aber durchaus sein, dass ich einen Fehler mache.
Und am Ende meines Bugfixings, das eigentlich den Fehler beheben soll, habe ich einen Bug eingebaut.
Und zwar in die andere Funktion, nämlich in das Dateilesen.
Obwohl ich daran eigentlich gar nichts machen wollte.
Das passiert nur dann, wenn diese Klasse mehr als eine Aufgabe hat.
Und das war jetzt ein triviales Beispiel.
Stellen wir uns mal eine komplexe Klasse vor, wo es nicht so ein- und ausmäßig genau getrennt ist.
Sondern vielleicht wirklich irgendwie eine Businessklasse, wo wirklich viele verschiedene Dinge drin sind.
Dann ist es vielleicht gar nicht so einfach zu sehen, ob ich vielleicht was kaputt gemacht habe.
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.
Und welche anderen Funktionen jetzt auf einmal nicht mehr funktionieren.
Also, das ist ganz doof.
Außerdem erhöht das die Wiederverwendbarkeit, wenn eine Klasse nur eine Aufgabe hat.
Dann kann ich die nämlich einfach nehmen und vielleicht mit anderen Klassen zusammenstöpseln, um eine neue Funktionalität zu bauen.
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.
Denken wir mal beim Dateileser.
Vielleicht eine Klasse, die sowohl den Input-Stream als auch den Output-Stream benötigt, weil sie ja beides machen muss.
Lesen und Schreiben.
Das heißt, sie hat auch mehr Abhängigkeiten.
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.
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?
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.
Weil ich das wirklich einfach gar nicht brauche und weil vielleicht mein Programm gar nicht darauf ausgelegt ist, damit irgendwie arbeiten zu können.
Beziehungsweise ich habe mehr Arbeit vielleicht als vorher, weil ich diese ganzen Abhängigkeiten zusätzlich noch konfigurieren muss.
Input-Output-Stream war jetzt ein schlechtes Beispiel.
Das ist in Java sowieso überall mit drin.
Aber denken wir an eine komplexere Klasse, wo vielleicht noch irgendwelche Frameworks eingebaut sind.
Da braucht halt mein Dateileser auf einmal noch das Apache-irgendwas-Framework dazu, obwohl das eigentlich nur fürs Schreiben von Dateien benutzt wird.
Und auf einmal muss ich dieses Apache-Framework auch benutzen, obwohl ich eigentlich diese ganze Funktionalität überhaupt nicht brauche.
Also das macht das Ganze unnötig kompliziert, fehleranfällig und einfach komplex. Das wollen wir nicht.
Deswegen eine einzige Aufgabe für eine Klasse.
Die Originaldefinition von dem Single Responsibility Principle lautet übrigens, dass eine Klasse nur einen Grund haben sollte für eine Änderung.
Landläufig sagt man allerdings auch, sie soll nur eine Aufgabe haben.
Aber das ist eigentlich der genaue Hintergrund.
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.
So, nächster Punkt auf meiner Liste wäre dann, sie sollte einen sprechenden Namen haben.
Also eben genau nicht sowas wie Dateimanager, der einfach alles macht, sondern es soll ganz konkret sagen, was diese Klasse macht.
In meinem Beispiel würde ich sowas haben wie Dateileser oder Dateischreiber oder meinetwegen auch Auto, wenn es ein Auto repräsentiert.
Aber vielleicht kann man das auch noch ein bisschen einschränken.
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.
Das kann man etwas auch übertreiben, sage ich mal. Das sieht man auch in Java zum Beispiel.
Dann habe ich dann die Abstract Syntax Context Factory Implementation oder irgendwas.
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.
Aber nur, um mal einfach zu zeigen, wie lang so ein Klassenname dann werden kann.
Dann habe ich mal ein Beispiel aus der Praxis, das ich selber programmiert habe.
Das war der Block sammelnde Datensatz Schreiber.
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.
Das heißt, das ist ein wirklich sehr spezieller Name und es gibt zum Beispiel auch den Datensatz sammelnden Datensatz Verarbeiter.
Um das zu erklären, was das Ding macht, will ich jetzt nicht so weit ausholen hier.
Aber nur, um zu zeigen, die Namen können also sehr speziell sein und werden durchaus auch ein bisschen länger.
Aber das macht auch nichts, denn kein Mensch muss die eintippen.
Das können wir alles durch IntelliSense in C-Sharp zum Beispiel oder in Eclipse mit der Kodevervollständigung hinbekommen.
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.
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.
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.
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.
Wenn ich jetzt einfach mein Beispiel jetzt gerade einen Datensatz Verarbeiter gehabt hätte, dann wüsste ich nicht, was er tut.
Da muss ich in den Code reingucken, um zu verstehen, was macht er denn jetzt genau.
Und wahrscheinlich macht er auch noch ganz ganz viele Sachen auf einmal, denn ein Verarbeiter, der wird wohl alles mögliche tun.
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.
Der Verarbeiter wird wahrscheinlich alles auf einmal tun.
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.
Gut, dann hatte ich beim letzten Mal schon gesagt, eine ganz einfache Daumenregel beim Klassendesign, alle Attribute erst mal private machen.
Also ich habe in meiner Praxis selten Beispiele für wirkliche Public Attribute, wo man es nicht hätte anders machen können.
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.
So, jetzt kommen noch zwei Fachbegriffe, die man dann auch gerne mal in der möglichen Prüfung zum Beispiel erklären kann.
Und zwar sollten vernünftige Klassen eine hohe Kohärenz aufweisen und eine geringe Kopplung.
Was heißt das jetzt? Die Kopplung ist vielleicht einfacher zu erklären, das hatten wir gerade schon so ein bisschen, Abhängigkeit.
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.
Und je höher diese Kopplung ist, d.h. je mehr Abhängigkeiten ich habe, umso komplizierter wird es, diese Klasse zu benutzen.
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.
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.
Das ist blöd. Das ist nicht nur blöd, weil es aufwendig ist, sondern es ist halt auch schwierig bei der Fehlersuche.
Wenn dann irgendwas nicht funktioniert, dann kriege ich halt einen Stacktrace, der 7000 Zeilen lang ist, weil irgendwo in irgendeinem Framework irgendwas schiefgelaufen ist.
Also blöd. Wollen wir nicht.
D.h. ich kann die Klasse nicht gut wiederverwenden, wenn ich so eine hohe Kopplung habe.
Deswegen sollten meine Klassen eine geringe Kopplung haben.
Am besten verwendet eine Klasse gar keine anderen Klassen.
Das wäre super, dann kann ich sie nämlich perfekt wiederverwenden.
Ich kann sie einfach nehmen und sie ist direkt lauffähig.
Allerdings, ganz ehrlich gesagt, in so einem normalen objektorientierten System wird das sehr selten vorkommen, denn die Klassen sollen ja miteinander arbeiten.
Also von daher ist es natürlich nicht schlimm, wenn eine Klasse eine Abhängigkeit auf eine andere hat.
Das ist sogar eher der Normalzustand.
Aber cool wäre natürlich, wenn sie gar keine Abhängigkeit hätte.
Denn wie gesagt, dann kann ich sie direkt nehmen und so wiederverwenden, ohne irgendwelche Abhängigkeiten.
Ja, der zweite Begriff, den ich gesagt habe, das war die hohe Kohärenz.
Also bei der Kopplung wollen wir eine möglichst geringe haben.
Bei der Kohärenz wollen wir eine möglichst hohe haben.
Was ist denn jetzt die Kohärenz?
Die Kohärenz bedeutet einfach nur den Grad der Verwendung der Attribute einer Klasse durch ihre Methoden.
Als Beispiel, wenn eine Klasse eine Methode hat und ein Attribut und diese eine Methode benutzt auch das eine Attribut,
dann haben wir eine sehr gute Kohärenz, weil alle Methoden der Klasse alle Attribute der Klasse benutzen.
Das ist in den meisten Klassen allerdings nicht der Fall.
Ich habe zum Beispiel mein Auto, da habe ich den Kilometerstand und auch die Türen als Objekte drin.
Dann werden wahrscheinlich in den wenigsten Fällen die Methoden beide Attribute benutzen.
Also zum Beispiel meinen Kilometerstand und meine List of Tür oder wie auch immer.
Wenn ich zum Beispiel fahre, wird der Kilometerstand verändert, aber sicherlich nicht die Tür geöffnet.
Wenn ich die Tür öffne, wird aber nicht der Kilometerstand verändert.
Das heißt, wenn ich zwei Methoden habe, sowas wie fahre und öffne Türen,
dann werden diese beiden Methoden jeweils nur ein Attribut benutzen der Klasse und nicht beide.
Das heißt, ich habe eine geringere Kohärenz.
Das heißt, meine Methoden und meine Attribute gehören eigentlich nicht so richtig zusammen.
Wir haben ja schon gelernt, die Kapselung in der Objektorientierung ist ja so ein tolles Prinzip.
Sie bedeutet nämlich, dass die Attribute und die zugehörigen Methoden in einer Klasse gekapselt sind.
Aber wenn jetzt die Attribute und die Methoden eigentlich gar nicht so richtig zusammenarbeiten,
weil die Hälfte der Methoden nur die andere Hälfte der Attribute benutzt,
dann haben wir eigentlich irgendwas geschaffen, was gar nicht so richtig zusammengehört.
Und dann haben wir eine geringe Kohärenz und das wollen wir eben gerade nicht.
Also eine perfekte Klasse mit der perfekten Kohärenz hätten wir dann,
wenn jede Methode einer Klasse jedes Attribut einer Klasse benutzt.
Das wäre super.
Ist in den meisten Fällen allerdings genau wie die geringe Kopplung in der Praxis sehr selten anzutreffen.
weil wir einfach durchaus Attribute zu abstrakten Klassen zusammenbauen, also
nicht abstrakt im Sinne von abstract, sondern einfach zu einer, zu diesem
abstrakten Konzept einer Klasse zusammenbauen, die einfach vielleicht
nicht immer was miteinander zu tun haben. Wie gesagt, Auto, Kilometerstand und die
Türen, die gehören halt zu einem Auto, aber ich werde sie in den seltensten
Fällen gemeinsam manipulieren. Deswegen ist das also durchaus in Ordnung, wenn wir
Klassen haben, die nicht zu 100 Prozent kohärent sind, aber wir sollten halt
versuchen, dass wir es hinkriegen, dass wir möglichst alle Methoden, alle
Attribute benutzen. Andersherum, wenn wir feststellen, dass
Attribute unserer Klasse kaum genutzt werden oder sagen wir mal, ich habe zehn
Methoden und ein Attribut wird nur in zwei dieser Methoden benutzt, dann wäre
das zum Beispiel ein Indiz dafür, dass wir die Klasse vielleicht auseinanderziehen
müssen, nämlich diese beiden Attribute, die irgendwie zusammen manipuliert werden
von einer Methode, die müssen vielleicht in eine andere Klasse, damit wir dann zwei
einzelne Klassen haben, die jeweils eine kleinere Aufgabe haben, dafür aber auch
eine höhere Kohärenz. Da sind wir dann wieder beim Single Responsibility
Principle. Also wenn ich eine Klasse habe mit vielen Methoden und vielen
Attributen, aber die ganzen Methoden nutzen alle immer nur ein oder zwei
Attribute, dann habe ich eine geringe Kohärenz und das kann darauf hindeuten,
dass die Klasse zu viel macht und dass ich sie auseinanderziehen muss, um wieder
kleine Klassen zu haben mit hoher Kohärenz. So, das waren meine Regeln zum
Klassendesign. Wenn du noch ein paar mehr hast, dann gerne hier damit. Schreibt mir
gerne Kommentar zu der Podcast Episode da drunter. Da bin ich sehr gerne offen für
weitere Anregungen. Es gibt sicherlich noch ganz viele andere Sachen, die ich
zum Beispiel nicht erwähnt habe, wie zum Beispiel die Solid Prinzipien. Da kann
ich noch vier andere Sachen rausziehen, die ich auf meine Klassen anwenden kann,
aber wir sind ja hier jetzt gerade in der Lernzielkontrolle, sage ich mal, zu
Beginn der Programmierung und da will ich jetzt nicht so sehr schon in die
Tiefen der Objektorientierung abtauchen. Ich denke mal, mit den paar Regeln, die ich
jetzt genannt habe, kann man schon ganz gut einsteigen. Vor allem kann man die
auch gut kontrollieren. Man sieht das auch als Anfänger leicht, ob die Klasse,
die man programmiert hat, diesen Regeln folgt oder nicht. Gut, dann kommen wir jetzt
mal zu dem dritten Thema für heute, nämlich den Enumerations und das hat
jetzt erstmal rein gar nichts eigentlich mit den anderen beiden Themen zu tun, mit
den Gettern und Zettern und dem Klassendesign, aber es passt halt in
meinem Tutorial ganz gut rein, denn die Enumerations lösen ein paar nette
Probleme, die man auch gleich zu Beginn der Programmierung häufig hat.
Ich gehe mal kurz ein Beispiel durch in meinem Tutorial. Da geht es um eine
Klasse Hund, die man programmieren soll. Ich wollte jetzt nicht zum 90. Mal das
Auto nehmen, wobei, ehrlich gesagt, ich nehme das Auto als Einführung und die
Hund-Aufgabe ist dann das, was die Leute selber programmieren sollen. Auf jeden Fall
programmiere ich da einen Hund und der Hund hat ein Lieblingsessen. Ein
Lieblingsessen, zum Beispiel Knochen oder Futter oder Kuchen oder was auch
immer und jetzt kann man dieses Lieblingsessen in so einer Klasse
natürlich einfach als String speichern. Da kann ich natürlich alles Mögliche
da eingeben, da kann ich dem Hund aber auch als Lieblingsessen nicht
Knochen setzen, sondern zum Beispiel Knachen, weil ich mich leider vertippt
habe. Das heißt, dann ist das Lieblingsessen des Hundes auf einmal
kein gültiges Essen mehr, sondern ein String mit einem Rechtschreibfehler
drin und das wäre natürlich ungünstig. Noch schlimmer, ich habe vielleicht eine
Anwendung, die mit Kalenderdaten arbeitet, mit Datumsangaben und so was
und dann muss ich da einen Wochentag angeben. Wochentage kann es eigentlich
nur von 1 bis 7 geben. Sonntag bis Freitag, Sonntag bis Samstag
beziehungsweise Montag bis Sonntag, je nachdem, wie man anfängt zu zählen und dann
habe ich vielleicht die Idee, dass ich meine Wochentage entweder durchnummeriere
als Integerspeicher oder ich mache es noch schlimmer als String und kann da
auch wieder irgendwas eingeben. Was passiert denn dann, wenn ich mich bei
den Werten vertippe und auf einmal nicht Montag, sondern Maantag im Kalender
steht? Das wäre doof. Im einfachsten Fall wäre es nur doof, im schlimmsten Fall
stürzt die Anwendung ab oder produziert Schrott. Das soll natürlich nicht
passieren. Das kann sowohl dann vorkommen, wenn ich
Strings benutze, aber auch bei allen anderen Datentypen, die wir schon
kennengelernt haben, zum Beispiel beim Integer. Wenn ich einen Datentyp, der
eigentlich gar nicht zu dem Datentyp passt, den ich da benutze, abbilden will,
dann habe ich ein Problem. Also der Kern des Ganzen ist, wenn ich in meiner Klasse
ein Attribut abbilden möchte, was eine fix definierte Liste an Werten nur
erlaubt, Beispiel Wochentage, da gibt es genau sieben, da gibt es nicht einen
mehr und auch nicht einen weniger. Monate, da gibt es genau zwölf und nicht mehr
oder weniger. Lieblingsessen ist vielleicht in meiner Hundeanwendung
auch eine abzählbare Liste. Sage ich jetzt einfach mal so, ist in der Praxis
vielleicht nicht der Fall, aber in unserer Applikation könnte es ja sein,
dass der Hund halt nur Knochen, Kuchen und Hähnchen haben darf und sonst nichts,
weil unsere tolle Hundepension nur diese drei Sachen anbietet meinetwegen.
Dann wäre es halt doof, wenn der Hundebesitzer eintragen kann, mein Hund
mag gerne Zigaretten. Das ist sowohl für den Hund ungesund, als auch die
Hundepension kann es nicht anbieten. Also wäre blöd, wenn das in der
Applikation ginge. Deswegen müssen wir doch eigentlich irgendwie festlegen
können, dass eben nur eine definierte Anzahl an Werten erlaubt ist und das
kann ich tun, indem ich einen eigenen Datentyp dafür baue und das wäre eine
Enumeration. Wie der Name auf Englisch schon sagt, das ist einfach eine
Aufzählung. Eine Enumeration ist also ein Aufzählungstyp und in diesem Typ
kann ich einfach eine Liste an erlaubten Werten festlegen. Ich könnte
mir also zum Beispiel eine Enumeration vorstellen mit dem Namen Tag oder besser
Wochentag. Machen wir es mal so. Und dieser Wochentag hat sieben Konstanten, die
definiert werden, nämlich Montag, Dienstag, Sonntag. Und ich kann jetzt dann
in meinem Code sowas machen wie wochentag.montag und dann kann ich auch
nicht sowas eingeben wie manntag, denn das, was ich da gerade produziert habe,
ist eine typsichere Auflistung. Wenn ich mit einer Enumeration arbeite, kann ich
keine anderen Werte mehr benutzen an dieser Stelle, außer denen, die in der
Enumeration definiert sind. Das heißt, es verhindert zum einen
Rechtschreibfehler oder sonst was oder einfach auch illegale Werte, wie zum
Beispiel, das Alter ist jetzt schlecht, so ein Alter einer Person würde ich auf
keinen Fall als Enumeration abbilden, aber nennen wir mal Wochentag.
Wochentag hatte ich vorher als int definiert, meinetwegen. Dann hindert mich
ja niemand daran, wenn ich irgendwo eine Methode habe, wo ein int-Parameter
reingegeben wird, dass ich da einfach mal 97 eingebe. Aber was soll 97 für einen
Wochentag sein? Den gibt es nicht. Es ist nur erlaubt, meinetwegen, von 0 bis 6.
Das kann ich aber weder an der Methodensignatur sehen, da steht einfach
nur int-Wochentag, aber ich weiß gar nicht, was ist denn jetzt welcher
Wochentag? Ist 1 der Sonntag oder ist 1 der Montag? Weiß ich nicht. Und was
passiert, wenn ich 97 zum Beispiel eingebe? Wird die Applikation das
irgendwie händeln oder gibt es dann einen Abbruch oder kriege ich dann
irgendwie Fehler? Ja, das wäre ungünstig. Kann ich nicht sehen an der
Signatur der Methode. Wenn ich stattdessen einen Wochentag als
Enumeration da reingebe, dann weiß ich, oh, ich darf nur Werte aus dieser
vordefinierten Liste benutzen und ich kann auch, das würde der Compiler dann
sicherstellen, gar keinen anderen Wert mehr reingeben. Das heißt, ich kann nicht
einfach 97 da reingeben oder Montag oder was auch immer. Ich kann nur
Wochentag Punkt und dann die sieben Werte, die Wochentag definiert, dort
reingeben. Genau dafür finde ich Enumerations sehr schön, denn wenn ich
eine definierte Liste an Werten habe, von der auch nicht irgendwie abgewichen
werden darf, dann definiere ich mit einem Enumeration dazu. Und das Schöne in Java im
Speziellen ist, dass Enumerations nichts weiter sind als im Prinzip Klassen, wenn
man so will. Die Syntax ist sehr ähnlich zu einer Klasse. Ich mache nicht Class
Wochentag zum Beispiel, sondern Enum Wochentag, aber in Java hat so ein Enum
wirklich die Eigenschaften einer Klasse. Ich kann da also auch Methoden rein
programmieren und das benötigt man häufig, um zum Beispiel so Konvertierungen
zu machen. Wenn ich meinetwegen Eingaben vom Benutzer entgegennehme, angenommen ich
habe ein Registrierungsformular für meine Hundepension und dann kann der
Hundebesitzer sowas eingeben wie, was ist denn mein Lieblingsessen oder
beziehungsweise das Lieblingsessen des Hundes und dann gibt er da halt Knochen
ein. Dann habe ich den Knochen natürlich als String aus dem Formular. Ich
brauche aber in meiner Anwendung vielleicht diese Enumeration-Value und da kann es
natürlich sinnvoll sein, dass ich direkt in der Klasse Lieblingsessen, meinetwegen,
eine Funktion bereitstelle, wie konvertiere String zu Lieblingsessen und
dann gebe ich den String da rein und kriege das Lieblingsessen da raus. Wo soll
ich das sonst hinpacken als in die Enumeration selbst? Und das geht in Java
ohne Probleme. Da kann ich einfach ein paar Methoden in diese Enum reinpacken.
Also, das letzte Thema für heute wäre damit abgeschlossen. Enumerations, wann
benutze ich die? Eine Enumeration ist ein Datentyp, der quasi eine abgeschlossene
Liste an Werten definiert und die benutze ich immer dann, wenn meine Liste
der Werte eben begrenzt werden soll und ich mir keine Fehler einfangen will,
weil ich irgendwie nicht kontrollieren kann, was mir denn da so für Werte
reingegeben werden von draußen, zum Beispiel Strings, Integers, was auch immer.
Und ich bekomme dadurch quasi so eine Art Typ-Sicherheit, nicht nur so eine
Art, sondern der Compiler im Falle von Java und C-Sharp allerdings dann auch,
der prüft eben, ob das, was ich da reingebe, auch wirklich ein erlaubter
Wert ist oder nicht. Und wenn das kein erlaubter Wert ist, dann lässt sich das
Programm nicht kompilieren. Also, der Compiler ist auf meiner Seite, er
unterstützt mich jetzt, außerdem unterstützt mich natürlich auch meine
IDE. Wenn der da Wochentag findet, Eclipse zum Beispiel, dann schlägt er mir
automatisch schon die sieben Werte vor, die es gibt und erlaubt mir da nicht alle
möglichen Eingaben. So, damit wäre ich für heute durch mit dem Thema oder mit
den Themen Getter, Setter, Klassendesign und Animulations, wild zusammengewürfelt.
In der nächsten Woche mache ich mal eine Episode nicht mehr zu Lernzeilenkontrolle,
sondern zu was anderem Spannenden. Ich weiß, dass gerade aktuell wieder die
mündlichen Prüfungen laufen. Wahrscheinlich, wenn die Episode rauskommen,
sind schon die meisten vorbei. Aber das kann ich jetzt leider nicht so gezielt
steuern. Aber ich habe schon seit langem aufgeschoben, die Episode rund um die
häufigsten Wirtschaftsfragen im Fachgespräch. Ich weiß, dass einige
Azubis drauf brennen, die endlich zu hören, denn die Wirtschaft ist jetzt für
die meisten Azubis nicht unbedingt das Lieblingsthema. Und mal so ein paar Themen
zu vertiefen tut, glaube ich, Not an der Stelle. Deswegen meine Fortführung der
Reihe der häufigen Fragen im Fachgespräch beim nächsten Mal. Wenn du
dir die Shownotes zu dieser Episode anschauen willst, wo zum Beispiel einige
interessante Links hinterlegt sind, gerade auch zum Single Responsibility
Principle und auch zu der Kohärenz und der Kopplung noch mal ein super Artikel,
der das noch mal sehr schön erklärt, dann geh doch einfach auf
anwendungsentwicklerpodcast.de slash 45, also 4 und 5, die beiden Ziffern, um zu
dieser 45. Episode die Shownotes, die Links und die Literaturempfehlungen
anzuschauen. Literaturempfehlungen, wie eigentlich immer bei den LZKs, sind
wieder die Einführung in Java, beziehungsweise die Java-Insel aus dem
Rheinwerk-Verlag. Aber zu dieser Episode ganz konkret empfehle ich dir auch
Clean Code von Bob Martin. Von dem habe ich auch einen super Artikel verlinkt,
wo er das Single Responsibility Principle erklärt. Der gilt quasi so, ja, wie soll
man sagen, nicht als der Erfinder dieser Prinzipien, aber er war so der erste, der
mal schön auf den Punkt zusammengefasst hat und aufgeschrieben hat. Und in Clean
Code, das ist eigentlich so meine Programmiererbibel, die gehe ich jetzt
auch bei meinen Azubis noch mal einmal durch und werde das auch selber noch mal
lesen, weil es schon ein paar Jahre her ist, dass ich das getan habe. Und da
stehen so viele knackige, prägnante und praxisnahe Tipps einfach drin für die
Programmierung, auch egal in welcher Programmiersprache oder welchem Paradigmen
man unterwegs ist, dass ich das einfach unbedingt empfehlen kann. Gerade zu dem
großen Bereich Klassendesign, wo ich jetzt nur, sag ich mal, so oberflächlich ein
paar Regeln vorgestellt habe, kann man aus dem Buch noch einiges rausziehen.
Gerade auch für Anfänger. Das ist wirklich für Programmierer jeglicher
Couleur geeignet und deswegen ist das für diese Episode meine absolute
Leseempfehlung. Wenn du schon auf der Seite bist, dann schau dir doch noch mal
zwei Artikel an. Letzte Woche habe ich nämlich auf der Seite noch einen etwas
umfangreicheren Artikel zum Thema Handouts bei der Projektpräsentation
geschrieben. Kurze Zusammenfassung. Lass das Handout weg. Es ist Schrott. Warum?
Kannst du im Blog nachlesen. Und mein Link der Woche beim letzten Mal war eine
schöne Liste mit Tipps rund um die Gestaltung professioneller Präsentationen
vom Lead-Designer von TED. Ich weiß nicht, ob du TED schon kennst.
TED.com. T-E-D. Ja, wie der Film mit den Bären, den ich jetzt aber nicht meine,
sondern Technology Entertainment Design heißt es, glaube ich. Oder Technology
Education Design. Ich weiß es selber nicht. Auf jeden Fall TED.com. Da gibt es
einen Haufen an super geilen Präsentationen, die alle maximal 17
Minuten lang sind und damit kann man sich den ganzen Tag zudröhnen und
wirklich coole, interessante, spannende Wirtschaftsthemen, Technikthemen, alles
mögliche, sich anschauen auf Weltklasseniveau. Und der Lead-Designer
von dieser Non-Profit-Organisation, die dahinter steht, hat ein paar coole Tipps
gegeben, wie man wirklich anspruchsvolle, nicht anspruchsvolle, ansprechende
Präsentationen gestaltet. Und ich denke, da kann man auch als Prüfling ganz viel
rausziehen. Deswegen habe ich es letzte Woche verlinkt. Schau doch mal rein.
Vielleicht sind auch für dich noch ein paar nette Tipps dabei, wenn du irgendwann
mal was präsentieren musst. Könnte ja durchaus mal vorkommen. Dann würde ich
mich wie immer über jegliches Feedback freuen, zur Episode, zum Podcast,
egal wie du mich erreichen willst. Du kannst es tun unter www.anwendungsentwicklerpodcast.de
und dann iTunes, Stitcher, Facebook, Twitter, Xing. Das kannst du
alles dahinter schreiben und landest dann auf der entsprechenden Seite, um mit
mir in Kontakt zu treten. Du kannst mir auch eine Mail schreiben unter mail
at www.anwendungsentwicklerpodcast.de. Und zum Schluss, wenn du möchtest, trag dich
doch in meinen Newsletter ein unter www.anwendungsentwicklerpodcast.de. Mein Gott, ich
brauche eine kürzere Domain. Da kannst du den Newsletter abonnieren. Du
kannst es aber auch direkt auf der Startseite. Es ist überall im Menü verlinkt und
bekommst damit einmal die Woche alle Neuigkeiten von der Website und
bekommst auch gleich Zugriff auf meine Artefakte rund um die Projektarbeit,
nämlich drei Checklisten für den Projektantrag, die Projektdoku und die
Projektpräsentation. Und außerdem gibt es auch die Links der Woche, nicht erst
Freitag, sondern schon am Montag vorab. Und du kannst auch, wenn du mit mir in
Kontakt treten willst, einfach auf die Mails antworten. Das fände ich natürlich
besonders toll, denn ich mache das hier ja nicht zum Spaß, obwohl doch eigentlich
macht es Spaß. Aber ich möchte natürlich auch ein bisschen Feedback haben von meinen
Hörern, ob ich hier das Richtige erzähle oder nicht. Also wenn du irgendwas zu
sagen hast, dann scheue dich nicht und spreche mich einfach an.
Ja, damit mache ich dann mal Schluss für heute. Nächste Woche, wie gesagt, geht es
dann um die Wirtschaftsfragen im Fachgespräch. Bis dahin sage ich vielen,
vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!
Untertitel der Amara.org-Community









Neueste Kommentare