Mehr über die Sichtbarkeit von Variablen

„Der Professor kommt einfach nicht aus seinem Trott heraus. Alte Lehrer, die das Unterrichten gewohnt sind, sind immer so. Er kann dir nichts sagen, was du nicht auch in Büchern finden kannst. Man lernt nicht schwimmen, indem man sich Vorlesungen über das Schwimmen anhört. Vorlesungen sind nur dann nützlich, wenn du mit dem Thema vertraut sind und fast so viel weißt wie dein Professor.“

„Trotzdem sind seine Lektionen nützlich.“

„Klar. Ich meine, wir hoffen, dass sie es sind. Je mehr Sichtweisen du zu einem Thema hörst, desto näher kommst du der Wahrheit. Wenn du nur eine hörst, kannst du die nur glauben oder nicht glauben. Okay, zurück zum Wesentlichen.“

„Schauen wir uns ein Bild an, das ich dir schon mal gezeigt habe.“

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. Eine in einer Methode deklarierte Variable existiert (ist sichtbar) vom Beginn ihrer Deklaration bis zum Ende der Methode.

2. Eine in einem Codeblock deklarierte Variable existiert bis zum Ende des Codeblocks.

3. Die Parameter einer Methode existieren, bis die Methode zurückkehrt.

4. Variablen in einem Objekt existieren während der gesamten Lebensdauer des Objekts, das sie enthält. Ihre Sichtbarkeit wird auch durch spezielle Zugriffsmodifikatoren geregelt.

5. (Klassen-)Variablen mit dem Modifikator static existieren während der gesamten Laufzeit des Programms. Ihre Sichtbarkeit wird auch durch Zugriffsmodifikatoren definiert.“

„Right. Ich erinnere mich an dieses Bild.“

„Prima. Ich möchte dich an einige wichtige Punkte erinnern.“

„Alle Variablen, die innerhalb von Methoden deklariert wurden, existieren (sind sichtbar) ab dem Zeitpunkt, zu dem sie deklariert wurden, bis zum Ende der Methode (Beispiel 1).“

„Wenn eine Variable in einem Codeblock deklariert wird, existiert sie bis zum Ende des Codeblocks (Beispiel 2).“

„Wenn eine Variable ein Methodenparameter ist, existiert sie (ist sichtbar) im gesamten Rumpf der Methode (Beispiel 3).“

„Wenn eine Variable eine Instanzvariable ist (Beispiel 4), dann ist sie mit einem bestimmten Objekt verknüpft und existiert, solange das Objekt existiert. Wenn kein Objekt existiert, dann gibt es auch keine Instanzen der Variable. Du kannst von allen Methoden der Klasse aus auf die Variable zugreifen (d.h. die Variable ist sichtbar), unabhängig davon, ob sie davor oder danach deklariert wurden. Für jedes Objekt wird eine neue Variable angelegt. Sie ist unabhängig von anderen Objekten. Du kannst nicht über static-Methoden auf eine Instanzvariable zugreifen.“

„Wenn eine Variable als static deklariert, d.h. mit dem Schlüsselwort static gekennzeichnet ist, existiert sie, solange ihre Klasse existiert. Die JVM lädt eine Klasse in der Regel bei ihrer ersten Verwendung in den Speicher. Das ist auch der Zeitpunkt, zudem static-Variablen initialisiert werden.“

„Das obige Beispiel deklariert die Klasse Katze, die vier Variablen besitzt: a, b, s (nicht-statische Variablen) und anzahl (eine statische Variable). Wenn wir mehrere Objekte dieser Klasse erstellen (z.B. drei), wird jedes von ihnen seine eigenen Instanzen der nicht-statischen Variablen der Klasse enthalten. Eine static-Variable wird von allen Objekten einer Klasse gemeinsam genutzt. Technisch gesehen befindet sie sich nicht einmal in diesen Objekten, da sie schon existierte, bevor irgendwelche Katze-Objekte erstellt wurden.“

„Hier zeige ich dir, was passiert, wenn wir eine Variable s als static deklarieren:“

„Okay. Ich glaube, jetzt verstehe ich es.“

„Kann man Variablen mit dem gleichen Namen deklarieren?“

„Nicht innerhalb einer Methode. Alle innerhalb einer Methode deklarierten Variablen müssen eindeutige Namen haben. Die Argumente einer Methode werden auch als lokale Variablen betrachtet.“

„Was ist mit Member-Variablen?“

„Member-Variablen müssen ebenfalls für jede Klasse eindeutig sein.“

„Aber es gibt eine Ausnahme: Die Namen von lokalen Variablen und Member-Variablen können identisch sein.&#34

„Wenn wir eine solche Variable ändern, welche der beiden identisch benannten Variablen wird denn dann geändert?“

„Wenn es in unserem Code mehrere sichtbare (zugängliche) Variablen gibt – zum Beispiel eine Instanzvariable und eine lokale Variable – wird auf die lokale Variable zugegriffen.“

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

„Dieser Code deklariert zwei anzahl-Variablen. Zeile 3 deklariert eine Instanzvariable und Zeile 8 eine lokale Variable.“

„Jetzt zeige ich dir, was passiert, wenn die Methode ausfuehren ausgeführt wird:“

„In Zeile 7 greifen wir auf die Instanzvariable zu und weisen ihr den Wert 15 zu.“

„In Zeile 8 deklarieren (erstellen) wir eine neue lokale Variable: count. Dies maskiert die Instanzvariable. Die lokale Variable ist ab diesem Zeitpunkt das, was der gesamte nachfolgende Code in der Methode sehen wird (worauf er zugreifen wird).“

„Alles klar.“

„Die lokale Variable maskiert die Instanzvariable. Mit anderen Worten: Die lokale Variable ist diejenige, auf die zugegriffen wird. Du kannst aber auch auf die Instanzvariable zugreifen. Das ist nur etwas komplizierter.“

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

„Was kannst du mir noch über statische Methoden und statische Variablen erzählen?“

„Statische Methoden und Variablen sind nicht mit Objekten der Klasse verknüpft, sondern mit der Klasse selbst. Wenn wir zehn Variablen-Objekte erstellen (siehe das Beispiel am Anfang dieses Levels), erhalten wir zehn instanzVariable-Variablen (eine für jedes Objekt) und nur eine gemeinsame (statische) Variable TEXT.“

„Ich habe eine Frage.“

„Was ist der Unterschied zwischen statischen und nicht-statischen Methoden?“

„Sehen wir uns an, wie eine nicht-statische Methode funktioniert:“

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

„Wenn du eine Methode mit <Objekt> Punkt <Methodenname> aufrufst, rufst du tatsächlich eine Klassenmethode auf und übergibst das jeweilige Objekt als ersten Parameter. Innerhalb der Methode wird das Objekt ‚this‘ genannt. Alle Operationen in der Methode werden mit diesem Objekt und seinen Daten durchgeführt.“

„Wow! So funktioniert das Ganze also!“

„Und so funktioniert eine statische Methode.“

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

„Wenn du eine statische Methode aufrufst, wird kein Objekt an sie übergeben. Mit anderen Worten: ‚this‘ ist gleich null. Deshalb kann eine statische Methode nicht auf nicht-statische Variablen und Methoden zugreifen (da sie kein ‚this‘ besitzt, das sie an diese Methoden übergeben könnte).“

„Hmmm. Ich glaube, das verstehe ich. Zumindest ein bisschen.“

„Und hier kommt Onkel Diego... und seine Aufgaben.“