Warum sollte man in Java Getters und Setters verwenden?
Ich lerne gerade Java programmieren und verstehe den Sinn von Getters und Setters nicht wirklich. Was ist der Vorteil daran, Getters und Setters zu verwenden anstatt einfach direkt Objekten bestimmte Attribute zu zuweisen?
4 Antworten
ich erkläre es dir leicht aber oberflächlich.
wenn dus wirklich verstehen sollst guck unter der antwort nach:
sollte man eigentlich nicht.
es geht darum, dass die eigenschaften eines objekts normalerweise auf private gestellt werden um datenkapselung zu gewährleisten.
mit getter/setter kannst du dann trotzdem falls du musst auf die eigenschaften eines objekts zugreifen.
der vorteil ist auch, dass du zusätzliche logik über die getter/setter einbauen kannst bevor du auf das objekt zugreifst.
wenn jemand dir sagt du sollst für jede eigenschaft einer klasse ein getter/setter hinzufügen hat der keine ahnung von java und oop nicht verstanden
---------------------------------------------------------------------------------------------
ich versuchs dir leicht aber tiefgründig zu erklären:
ein prinzip bei oop ist datenkapselung.
es geht darum dass teile eines programms möglichst alleinstehend entwickelt werden, also modular. diese programmteile sollten nichts von einander wissen. deshalb setzt man im regelfall die eigenschaften eines objekts auf private.
das signalisiert dem programmierer, die daten/logik sind intern. diese können dadurch auch nicht von anderen programmteilen manipuliert werden können.
auf der anderen seite müssen programmteile jedoch mit anderen programmteile interagieren um ein brauchbares programm hinzukriegen. deshalb gehts jetzt rüber in das thema API Design
kurze analogie:
wenn du eine webseite benutzt dann benutzt du ja nicht direkt den server im hintergrund. der server bietet dir eine (hoffentlich) schöne seite mit der du bestimmte funktionen des servers nutzen kannst. direkten zugriff auf den server hast du aber nicht. das heißt du kannst jetzt nicht die webseite nach deinem belieben ändern oder so, sondern der server schränkt dich in deiner funktion ein.
in dieser analogie ist der server ein programmteil mit internen logik/daten und die webseite ist die API/schnittstelle die dir bereitgestellt wird um mit dem server zu arbeiten.
api design bedeutet, du schreibst dein programmteil so gezielt, dass du die nötige logik/ressourcen für andere programmteile über sogenannte öffentliche schnittstellen bietest.
mit der öffentlichen schnittstelle kannst du einen programmierer anleiten wie er dein programmteil richtig nutzt.
in java übersetzt sind:
- interne logik -> private methoden -> verhalten
- interne daten -> private felder -> attribute
- programmteil -> klasse
getter und setter sind öffentliche schnittstellen um auf interne daten innerhalb einer klasse zuzugreifen
der große vorteil durch modularisierung: weniger spaghetticode. heißt also wenn du ein programmteil veränderst, heißt das nicht unbedingt du musst den rest des programms verändern
In einen getter und settter kann man noch etwas anderes reinschreiben. Das kann man dann auch leichter aktualisieren, z.B. wenn ich den Typ des Attributes ändere oder sonst die Weise mit der es gespeichert ist, genügt es den getter und setter zu aktualisieren, sodass sie wieder mit dem Attribut kompatibel sind und immer noch das gleiche wie vorher zurückgeben. Sonst müsste man jede Stelle ändern, wo im Programm auf das Attribut zugegriffen wird. Man kann auch Logs reinschreiben. Das kann nützlich für Debugging sein.
Wenn ein Attribut nicht geändert werden soll, kann man es auf private stellen und es mit einem getter auslesen. Solche Fehler könnten passieren, dass man ausversehen etwas ändert.
Es gibt einige gute Gründe, warum man in Java Getters und Setters verwenden sollte:
- Encapsulation: Getters und Setters ermöglichen es, den Zugriff auf bestimmte Membervariablen einer Klasse zu kontrollieren. Sie ermöglichen es, den Zugriff auf diese Variablen zu beschränken, indem sie eine Schicht zwischen dem Zugriff auf die Variablen und dem tatsächlichen Zugriff erstellen. Dies kann dazu beitragen, die Integrität der Daten in einer Klasse zu gewährleisten.
- Flexibilität: Getters und Setters ermöglichen es, dass Änderungen an der Implementierung von Membervariablen ohne Auswirkungen auf den Rest des Programms vorgenommen werden können. Dies bedeutet, dass man die Membervariablen einer Klasse ändern kann, ohne dass andere Teile des Programms angepasst werden müssen.
- Lesbarkeit: Getters und Setters können dazu beitragen, den Code lesbarer zu machen, indem sie dafür sorgen, dass der Zugriff auf Membervariablen in einer konsistenten und einfach verständlichen Weise erfolgt.
- Erweiterbarkeit: Getters und Setters ermöglichen es, dass man später neue Funktionalität hinzufügen kann, ohne den Rest des Codes anzupassen. Zum Beispiel könnte man später eine Validierung der Werte hinzufügen, die über Setters gesetzt werden, ohne dass der Rest des Programms angepasst werden muss.
Nun Getters und Setters sollte man in dem Sinne denke ich auch eher selten verwenden. Meist sollte man eher ein Verhalten beschreiben. Was für Variablen dabei auf welchen Wert gesetzt werden, dieses Wissen sollte der Aufrufer in den meisten Fällen gar nicht wissen.
Der Vorteil generell Methoden zu verwenden, anstatt direkten Zugriff, ist natürlich das man auch gleich Verhalten daran koppeln kann. Unterliegende Datenstrukturen ändern kann, Eingaben validieren kann, Caching hinzufügen kann und, und, und.