Skip to main content

Über das kurze Leben einer lokalen Variablen

Lass uns über die Lebensdauer einer lokalen Variablen sprechen.

Warum ausgerechnet die Lebensdauer?

Alle Java Variablen, unterscheiden sich in folgenden Punkten:

  • wo diese deklariert werden können,
  • wie du diese aufrufen kannst,
  • welchen Bereich diese abdecken,
  • und Ihre Lebensdauer

Und eine lokale Java Variable hat eine relativ kurze Lebensdauer.

Schauen wir uns zuerst Klassen- und Instanzvariablen an.

Wo kannst du diese deklarieren?
Diese beiden Variablentypen kannst du in jeder Klasse, im Klassenrumpf deklarieren.

Was bedeutet das jetzt für Dich?
Du kannst eine Klassen- oder Instanzvariable nicht in einer Methode oder in einem Konstruktor deklarieren.


public class LokaleVariable {
int lebensDauer;//Instanzvariable


void bestimmeLebensdauer(){
int lebensDauer;//lokale Variable
static int lebensZeit;//geht gar nicht
}
static int lebensZeit;//statische Variable
}

Sobald du eine Variable in einer Methode oder einem Konstruktor anlegst, ist diese lokal.

Das bedeutet auch, dass jedes Objekt, jede erzeugte Variable innerhalb der main-Methode lokal ist.


public class LokaleVariable {
int lebensDauer;//Instanzvariable


void bestimmeLebensdauer(){
int lebensDauer;//lokale Variable
static int lebensZeit;//geht gar nicht
}
static int lebensZeit;//statische Variable

public static void main (String [] args) {
LokaleVariable lokal = new LokaleVariable ();//lokale Variable
}
}

Was heißt das jetzt?
Der Name sagt es. Lokal bedeutet örtlich gebunden.
Die Variable existiert außerhalb der Methode bzw. außerhalb des Konstruktors nicht mehr.

Aber dabei richtet sich das ganze Konzept eigentlich nicht an Methoden oder Konstruktoren aus.
Es richtet sich an den Codeblöcken aus.

Denn eine Methode beginnt mit einer öffnenden Klammer und endet mit einer schließenden.
Und genau dazwischen spielt sich das Leben von lokalen Variablen ab.

Jede lokale Java Variable muss einen Wert haben.

Ohne diesen kann sie nicht existieren.

Das bedeutet für dich.
Du musst dieser Variablen immer einen Wert zuweisen.
Ohne diesen bekommst du eine Fehlermeldung.


public class LokaleVariable {


static void bestimmeLebensdauer(){
int lebensDauer;//lokale Variable
System.out.println(lebensDauer);//dies führt zu einer Fehlermeldung
}
public static void main (String [] args) {
bestimmeLebensdauer();
}
}

Du kannst den Wert innerhalb des Codeblockes aber jederzeit überschreiben.


public class LokaleVariable {


static void bestimmeLebensdauer(){
int lebensDauer = 1;//lokale Variable und Zuweisung
lebensDauer = lebensDauer +55;//neue Zuweisung der lokalen Variablen
System.out.println(lebensDauer);//jetzt läuft's
}
public static void main (String [] args) {
bestimmeLebensdauer();
}
}


Lokale Java Variablen leben innerhalb einer Hierarchie.

Wenn du mehrere Codeblöcke hast, kannst du mehrere gleiche Variablen anlegen.

Ein Beispiel wäre eine bedingte Anweisung.

Hier hast du verschiedene Blöcke (if Block und else Block).

Wenn du jetzt eine lokale Variable außerhalb des Blockes deklarierst, lebt diese auch im if Block.
Und natürlich auch im else Block.

Ganz logisch, denn diese Variable lebt innerhalb des Methodenblockes.

public class LokaleVariable {
 
 static void bestimmeLebensdauer() {
 int lebensDauer = 1;// lokale Variable wird erstellt
 if (lebensDauer>0) {
 System.out.println("Die Lebensdaauer beträgt "+lebensDauer);
 }
 else {
 System.out.println("Die Lebensdauer ist kleiner null. Sie beträgt "+lebensDauer);
 }
 
 } //lokale Variable wird zerstört
 
 public static void main(String[] args) {
 bestimmeLebensdauer();
}
}

Wenn du aber diese Variable innerhalb des if Blockes deklarierst.
Ja dann wird sie am Ende des Blockes zerstört.

Du kannst somit diese Java Variable außerhalb des Blockes nicht nutzen.

public class LokaleVariable {
 
 static void bestimmeLebensdauer() {
 int lebensDauer = -1;// lokale Variable lebensDauer wird erstellt
 if (lebensDauer>0) {
 int lebensVerlaengerung=20;// lokale Variable lebensVerlaengerung wird erstellt
 System.out.println("Die Lebensdauer beträgt "+lebensDauer+lebensVerlaengerung);
 }// lokale Variable lebensVerlaengerung wird zerstört
 else {
 System.out.println("Die Lebensdauer ist kleiner null. Sie beträgt "+lebensDauer+lebensVerlaengerung);
 }
 
 } //lokale Variable lebensDauer wird zerstört
 
 public static void main(String[] args) {
 bestimmeLebensdauer();
}
}

Du siehst, dass du die lokale Variable „lebensVerlaengerung“ im else-Block nicht nutzen kannst.

Lokale Java Variablen befinden sich auch in der Parameterliste.

Egal ob im Konstruktor oder in einer Methode.
Sobald eine Parameterliste existiert und dieser werden Argumente übergeben, sind diese immer lokal.

Das bedeutet:
Du übergibst beim Aufruf der Methode oder des Konstruktors ein Argument.
Innerhalb des Rumpfes existiert dieses Argument als lokale Variable.

Außerhalb des Rumpfes ist diese nicht verfügbar.

Wozu brauchst du lokale Variablen. Wieso erst anlegen und dann zerstören?

Es geht um Speicherplatz.

Eine Instanzvariable existiert solange, bis das Objekt zerstört wird.
Eine Klassenvariable existiert über die komplette Laufzeit des Programmes.

Und da kommt schon ein bisschen Speicherplatz zusammen.

Und dann gibt es doch noch Variablen für spezielle Nebenrechnung.
Du kannst dir das als eine Art Schmierblatt vorstellen.

Und sollen diese alle ewig existieren?
Nein. Es ist doch eigentlich ganz gut, wenn Variablen nachdem diese nicht mehr gebraucht werden, zerstört werden.

Und genau für diese Nebenrechnungen innerhalb von Methoden brauchst du diese Variablen.

Jetzt ist dieses Konzept eigentlich richtig cool, aber….

Lokale Variablen haben einen langen Schatten.

Denn lokale Variablen überschatten Instanz- und Klassenvariablen.

Das Prinzip oder Phänomen nennt sich Shadowing.

Was passiert hier mysteriöses?
Angenommen du deklarierst eine Instanzvariable „geschwindigkeit“.

Und jetzt schreibst du eine Methode „beschleunige“.

Und in dieser Methode möchtest du mit dieser Instanzvariablen arbeiten.
Dann kannst du diese Variable ganz normal nutzen.

public class LokaleVariable {
 int geschwindigkeit;
 
 void beschleunige(){
 geschwindigkeit=geschwindigkeit+15;//Instanzvariable wird erhöht
 System.out.println(geschwindigkeit);
 }
 
 public static void main(String[] args) {
 LokaleVariable lokal =new LokaleVariable();//Objekt lokal wird erstellt
 lokal.beschleunige();//Gibt die neue Geschwindigkeiit des Objektes zurück
}
}

Was allerdings viele Anfänger häufig tun, ist das….

public class LokaleVariable {
 int geschwindigkeit;
 
 void beschleunige(){
 int geschwindigkeit=0;//neue lokale Variable geschwindigkeit wird erstellt
geschwindigkeit=geschwindigkeit+15;//Zugriff auf die lokale Variable
 System.out.println(geschwindigkeit);//Konsolenausgabe der lokalen Variable
 }
 
 public static void main(String[] args) {
 LokaleVariable lokal =new LokaleVariable();//Objekt lokal wird erstellt
 lokal.beschleunige();//Gibt die Geschwindigkeit der lokalen Variablen zurück 
 System.out.println(lokal.geschwindigkeit);//der Wert der Instanzvariablen
}
}

Sie deklarieren eine neue lokale Variable und nennen diese „geschwindigkeit“.
Und eigentlich hoffen sie, auf die Instanzvariable zuzugreifen.

Aber dies passiert eben nicht.

Es existiert jetzt innerhalb der Methode eine neue Variable mit dem gleichen Namen.

Da diese lediglich lokal ist, meckert Java auch nicht.
Aber wenn du jetzt etwas mit dieser Variablen anstellst, solltest du stets wissen, dass du lediglich die lokale Variable ansprichst.

Und außerhalb dieser Methode ist sie zerstört.

Zusammenfassung:

  • Lokale Variablen existieren nur innerhalb des Codeblockes, in welchem sie deklariert worden.
  • Lokale Variablen müssen einen Wert zugewiesen bekommen.
  • Eine Lokale Java Variable kann für Nebenrechnungen innerhalb von Methoden oder Konstruktoren genutzt werden.

Was sagst du?
Hat dir der Beitrag gefallen?
Vielleicht hast du Lust einen Kommentar zu hinterlassen.
Nutze dafür das entsprechende Feld unter diesem Beitrag.


Ähnliche Beiträge

Die drei Bestandteile aller Java Klassen

Java Klassen Bestandteile

Java ist eine objektorientierte Programmiersprache. Was heißt das? Ja… Anscheinend hat es etwas mit Objekten zu tun. Also was ist ein Objekt? Ein Objekt ist ein bestimmtes Konstrukt im Programm. Bauen wir ein Spiel. Ein Grafik-Adventure. Du kennst das. Ein Held wird in eine bestimmte Spielwelt hinein gesteckt. Der Held muss mit bestimmten Personen sprechen. […]

So nutzt du das Java Keyword public

Java Keyword public

Java Programme bestehen aus Java Klassen. Und der Zugriff auf eine Java Klasse sollte nach außen immer gewährleistet sein. Was bedeutet das? Du solltest in jeder Klasse die Möglichkeit haben, ein Objekt einer anderen Klasse anzulegen. Gerade durch diese Möglichkeit macht doch das ganze Klassenkonstrukt erst Sinn.

Von Java Klassen zum Java Programm – Der Programmstart

Java Klassen ausführen

In den letzten Beiträgen hast du gelernt, wie Java Klassen erstellt werden und aufgebaut sind. In diesem Beitrag geht es um den Programmstart. Ich will dir zeigen, was nötig ist, dass du ein Java Programm ausführen kannst. Und ich zeige dir außerdem, wie du eine Startklasse in einem x-beliebigen Javaprogramm anlegst. Wie auch schon zuvor, […]

So lassen sich aus Java Klassen Instanzen erstellen

Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen. Im Einführungsbeispiel hast du bereits gelernt, wie du: Instanzvariablen bzw. Attribute anlegst Wie du aus einer normalen Java Klasse eine Programmstart Klasse machst In diesem Artikel erfährst du: Was Objekte bzw. Instanzen sind. Wie sich Objekte zusammensetzen. Wo und wie du Instanzen aus Java Klassen […]

Eine Java Konsoleneingabe machst du über den Scanner

Es wird Zeit für die erste Java Konsoleneingabe. Und diese Eingaben machst du über den Java Scanner. Was ist das? Der Scanner ist eine vorgefertigte Java Klasse, welche Java mit seiner API anbietet. Das heißt du musst nichts selbst erschaffen. Du musst nur wissen, wie du darauf zugreifst. Erst einmal musst du einen Scanner anlegen. […]

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]

Der Aufbau von Java Klassen

Java Klassen Aufbau

Jedes Java Programm besteht aus Java Klassen. Doch wie sind diese aufgebaut? Wie setzt sich die Struktur zusammen? Wo befinden sich Klassen hierarchisch? Was kommt in die Klassen rein und wie wird es integriert? Das sind die Fragen, welche ich in diesem Artikel beantworten werde. Doch bevor wir bei den Klassen ansetzen, müssen wir eine […]

So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen.

Java Arrays verrechnen

Wie kann man Werte aus zwei oder mehreren Java Arrays miteinander verrechnen? Zum Beispiel: Du möchtest alle Werte des ersten Arrays mit allen Werten des zweiten Arrays addieren Oder du möchtest die Summe aus beiden Arrays wissen und erst dann diese miteinander addieren. Was erwartet dich in diesem Beitrag? Zuerst werde ich dir zeigen, wie […]

Java Methoden mit variabler Argumentenanzahl – VarArgs

Java Methoden mit variabler Argumentenanzahl VarArgs

Du kennst das noch. Kopfrechnen und zwar auf Zeit. So etwas ist das Standardprogramm in den Schulklassen 1 bis 5. Irgendwann, in Klasse 6 oder 7, kommt der Taschenrechner ins Spiel und Kopfrechnen ist aus dem Schulalltag gestrichen. Schade eigentlich. Dabei kann man diese Disziplin auch wunderbar in kleinen Spielen unterbringen. Ich erinnere mich noch: […]

Java Objekte leben auf dem Heap

Java-Objekte-Heap

Java hat eine interne Speicherverwaltung. Eigentlich ist es nicht nur eine. Es sind mehrere.   Uns interessieren nur zwei. Methoden und lokale Variablen werden auf dem Stack verwaltet. Und die Speicherverwaltung für Java Objekte und den Instanzvariablen findet auf dem Heap statt.   Ja wieso braucht Java eigentlich zwei Speichersysteme?   Es ist ganz einfach. […]

Java Übung 17: Char-Zeichen mit For-Schleife

Java Übung Char Zeichen For Schleife

In dieser Java Übung werden wir uns die Zeichen des Character Datentypen näher anschauen. Die einzelnen Zeichen sollen auf der Konsole ausgegeben werden. Und wie? Das ganze sollst du mit einer For Schleife machen. Erstelle deshalb eine Klasse „CharZeichen“. In dieser Klasse implementierst du dann eine Klassenmethode, namens „gibZeichen“. Und im Methodenrumpf durchläuft eine For-Schleife […]