So richtest du einen Schreibschutz für deine Java Variablen ein
Stell dir vor:
- Du hast erfolgreich dein erstes Programm für die Personalabteilung aufgesetzt.
- Du hast deine ersten 1000 Datensätze schön sauber angelegt.
- Und nun kommt dein Kollege und überschreibt die Vornamen der ersten 100 Mitarbeitern.
Na schöne Sch….
Wie kann das passieren? Wie kann man das verhindern?
Du brauchst eigentlich nur deine Java Variablen mit einer klitzekleinen Eigenschaft versehen.
Na interessiert?
Dann lies diesen Beitrag.
Inhalt
Manche Eigenschaften deiner Java Objekte sollten geschützt sein
Und mit geschützt meine ich, dass diese Eigenschaften unveränderlich sein sollten.
Wenn du einmal einen Vornamen zuweist, dann bleibt der Vorname unveränderlich.
Ein Mitarbeiter wird wohl niemals seinen Vornamen ändern.
Genauso ist es beim Geburtsdatum oder beim Geschlecht.
Wobei letzteres sich ja doch noch einmal ändern könnte.
Und deshalb sollte deine Mitarbeiterverwaltungssoftware den Vornamen als schreibgeschützte Daten führen.
Du brauchst also eine weitere Eigenschaft, einen Schreibschutz, für die Instanzvariablen deiner Java Projekte.
Und wenn du möchtest, dass deine Instanzvariablen schreibgeschützt geführt werden, nutzt du dafür das Java Keyword final.
Dein Schreibschutz richtest du über das Keyword final ein
Wie jedes Java Keyword, wird auch final durch Eclipse farblich hervorgehoben.
Somit erkennst du es an der lila Farbe und dem Fettdruck.
Wie und wo setzt du nun dieses Keyword ein?
Du musst diese Eigenschaft bei der Deklaration einer Variablen setzen.
Das bedeutet:
Eine Instanzvariable wird in der Klassenebene deklariert.
Beim Beispiel einer Mitarbeiterverwaltung könnte das ganze so aussehen:
Die Klasse Personalakte
Auf dem Bild siehst du die Fehlermeldung neben der Deklaration.
Dies hat einen Grund:
Eine finale Variable hat keinen default-Wert.
Und das ergibt auch einen Sinn.
Stell dir vor du:
- deklarierst eine Variable,
- erstellst dann das Objekt,
- führst das Programm aus.
Was passiert dann?
- Das Objekt und die Variable werden erstellt.
- Der finalen Instanzvariablen wird ein default-Wert zugeordnet.
- Und dieser ist dann schreibgeschützt.
Das ist sicherlich nicht im Sinne des Erfinders, oder?
Deshalb solltest du der finalen Variablen bei der Deklaration gleich einen Wert zuweisen.
Und dieser Wert ist dann fixiert, unveränderlich und schreibgeschützt.
public class PersonalAkte {
String nachName;
final String vorName = "Mathias";
}In diesem Beispiel würde jedes neue Objekt der Klasse „PersonalAkte“ automatisch den Vornamen „Mathias“ bekommen.
Und dieser Vorname wäre schreibgeschützt und könnte nicht mehr verändert werden.
Bei dir in der Personalabteilung würden 1000 Mathias’e herumlaufen.
Mathias ist zwar ein schöner Name, aber….
Das Ganze ist doch auch irgendwie blöd, oder?
Lass mich dir eine flexiblere Variante zeigen.
So nutzt du den Schreibschutz gleich bei der Objekterstellung.
Einmal ganz kurz zum Ablauf.
- Du erstellst ein Objekt der Klasse „PersonalAkte“ über einen richtigen Konstruktor.
- Der Konstruktor erwartet, beim Aufruf, einen Vornamen und diesen weist du dann einmalig zu.
- Danach ist der Vorname schreibgeschützt.
Und so geht’s.
public class PersonalAkte {
String nachName;
final String vorName; //schreibgeschützter Vorname
PersonalAkte(String vorName) { //Konstruktor erwartet den Vornamen
this.vorName = vorName; //Zuweisung des Vornamens
}
public static void main(String[] args) { //main Methode
PersonalAkte muecke = new PersonalAkte("Mathias"); //Objekt der PersonalAkte wird angelegt
}
}Für finale Variablen kannst du keinen Setter anbieten
Schau dir das Bild an.
Ich habe für beide Instanzvariablen jeweils eine getter- und eine setter-Methode angeboten.
Du siehst, Eclipse gibt dir eine Fehlermeldung zurück.
Und zwar:
- wurde der setter der nicht-finalen Variablen „Nachname“ akzeptiert.
- der setter der finalen Variablen „Vorname“ aber nicht.
Warum?
Ja ganz einfach.
Durch den Setter kannst du den Wert der Instanzvariable ändern.
Dies ist schließlich der Grund, warum es den setter gibt.
Und eben diese nachträgliche Änderung, soll ja durch das Java Keyword final verhindert werden.
Somit ergibt es schon Sinn, dass dir Eclipse sofort den Fehler anzeigt.
Und natürlich kannst du dann diese Variable auch nur noch beschränkt in anderen Methoden nutzen
Die setter Methode ist ja lediglich Konstrukt, welches einer bestimmten Programmierkonvention entspricht.
Die setter Methode könntest du ja auch „weiseDenVorNamenZu“ nennen.
Und im Rumpf würdest du genau die gleiche Programmlogik des setters integrieren.
Dann wäre es ja genau die gleiche Methode, mit unterschiedlichen Namen.
Und auch hier hättest du keine Möglichkeit den Wert der Instanzvariablen zu ändern.
Das bedeutet:
Du kannst mit deinen Java Methoden nicht mehr den Wert der finalen Instanzvariablen verändern.
Einmal schreibgeschützt – immer schreibgeschützt.
So einfach ist das….
Für lokale Java Variablen kannst du ebenfalls einen Schreibschutz anbieten
Um es ganz einfach zu machen, zeige ich es einmal anhand eines neuen Beispiels.
Eine Klasse „Schreibschutz“ hat eine Methode, namens verdoppeln.
Diese Methode erwartet einen Wert und dieser wird verdoppelt.
Die Methode ist statisch. Somit muss ich kein Objekt erstellen, um diese aufzurufen.
public class SchreibSchutz {
static void verdoppele (int zahl) { //Methode erwartet Argument
zahl = 4; //das Argument wird durch die Zahl 4 ersetzt
System.out.println(zahl*2); //die Zahl vier wird verdoppelt und Ergebnis wird ausgegeben
}
public static void main(String[] args) {
verdoppele(5); //Ich übergebe eine 5
}
}Was passiert?
Na klar das Ergebnis ist 8. Die Zahl vier wurde verdoppelt.
Dabei spielt es keine Rolle mehr, welchen Wert du der Methode mitgibst.
Jeder Wert wird im Rumpf überschrieben.
Aber du kannst auch hier die lokalen Variable schreibgeschützt anbieten.
Und das machst du gleich bei der Deklaration der Variablen, also in der Parameterliste.
Falls du dann versuchst diese Variable innerhalb der Methode zu überschreiben, bekommst du wiederum die Fehlermeldung. (siehe Bild)
Also lösche die Zuweisung im Rumpf und alles ist in Ordnung.
Zusammenfassung:
- Um Variablen schreibgeschützt anzubieten, nutzt du das Java Keywort final.
- Dieses Schlüsselwort musst du direkt bei der Variablendeklaration einsetzen.
- Eine finale Variable hat keinen defauft-Wert.
Du musst ihr deshalb entweder einen Wert direkt bei der Deklaration zuweisen oder innerhalb des Konstruktors eine Zuweisung vornehmen. - Du kannst den Wert der Instanzvariablen dann auch nicht mehr durch Methoden ändern.
Du bietest deshalb auch keinen setter für schreibgeschützte Instanzvariablen an. - Möchtest du eine lokale Java Variable schreibgeschützt anbieten, weist du der Variablen das Java Schlüsselwort direkt in der Parameterliste zu.
Über den Autor
