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 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 *(direkt beim
Rheinwerk-Verlag bestellen*) *(direkt beim Rheinwerk-Verlag
bestellen*) Viele weitere "Regeln" zum Schreiben von Klassen (oder
auch grundsätzlich zur sauberen Programmierung) findest du in Clean
Code*. * 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 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äse
Kommentare (0)
Melde dich an, um einen Kommentar zu schreiben.