Java-Variablentypen

In der Sprache Java müssen alle Variablen deklariert werden, bevor sie verwendet werden können.

Das grundlegende Format zum Deklarieren einer Variablen ist wie folgt:

type identifier [ = value][, identifier [= value] ...] ;

Formatbeschreibung:

  • type -- der Datentyp.
  • Bezeichner -- ist der Variablenname, und Kommas können verwendet werden,, um mehrere Variablen desselben Typs zu trennen und zu deklarieren.

Im Folgenden sind einige Beispiele für Variablendeklarationen aufgeführt. Beachten Sie, dass einige einen Initialisierungsprozess enthalten.

int a, b, c;         //Deklariere drei int-Ganzzahlen: a, b, c int d = 3, e = 4, f = 5; //Deklariere drei Ganzzahlen und weise Anfangswerte zu byte z = 22;         //Deklariere und initialisiere z String s = "example"; //Deklariere und initialisiere den String s double pi = 3.14159; //Deklarierte eine Gleitkommavariable mit doppelter Genauigkeit pi char x = 'x';        //Deklariere die Variable x mit dem Wert des Zeichens 'x'.

Die von der Java-Sprache unterstützten Variablentypen sind:

  • Lokale Variablen:Lokale Variablen sind Variablen, die innerhalb einer Methode, eines Konstruktors oder eines Blocks deklariert werden. Sie werden zerstört, wenn die Methode, der Konstruktor oder der Block, in denen sie deklariert wurden, die Ausführung beendet. Lokale Variablen müssen bei der Deklaration initialisiert werden; andernfalls tritt ein Kompilierungsfehler auf.

    public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

  • Instanzvariablen:Instanzvariablen werden in einer Klasse, aber außerhalb von Methoden, Konstruktoren oder Blöcken deklariert. Sie gehören zu Instanzen der Klasse, und jede Instanz der Klasse besitzt ihre eigene Kopie. Wenn sie nicht explizit initialisiert werden, erhalten Instanzvariablen Standardwerte (0 für numerische Typen, false für boolean, null für Objektreferenztypen).

    public class ExampleClass {
    int instanceVar; // 实例变量
}

  • Statische Variablen oder Klassenvariablen:Klassenvariablen sind Variablen, die mit dem Schlüsselwort static in einer Klasse deklariert werden. Sie gehören zur Klasse und nicht zu Instanzen. Alle Instanzen der Klasse teilen denselben Wert der Klassenvariable. Klassenvariablen werden initialisiert, wenn die Klasse geladen wird, und nur einmal initialisiert.

    public class ExampleClass {
    static int classVar; // 类变量
}

  • Parameter:Parameter sind Variablen in Methoden- oder Konstruktordeklarationen, die verwendet werden, um Werte zu empfangen, die beim Aufruf der Methode oder des Konstruktors übergeben werden. Der Gültigkeitsbereich von Parametervariablen ist auf die Methode beschränkt.

    public void exampleMethod(int parameterVar) {
    // 参数变量
    // ...
}

Das folgende Beispiel definiert eine ExampleTest-Klasse, die eine Instanzvariable instanceVar und eine statische Variable staticVar enthält.

In der Methode method() werden eine Parametervariable paramVar und eine lokale Variable localVar definiert. Innerhalb der Methode weisen wir den Wert der lokalen Variable der Instanzvariable zu, weisen den Wert der Parametervariable der statischen Variable zu und geben anschließend die Werte dieser Variablen aus.

In der Methode main() erstellen wir ein ExampleTest-Objekt und rufen dessen Methode method() auf.

Beispiel

public class ExampleTest { //Instanzvariable private int instanceVar; //Statische Variable private static int staticVar; public void method(int paramVar) { //Lokale Variable int localVar = 10; //Variablen verwenden instanceVar = localVar; staticVar = paramVar; System.out.println("Instanzvariable:" + instanceVar); System.out.println("Statische Variable:" + staticVar); System.out.println("Parametervariable:" + paramVar); System.out.println("Lokale Variable:" + localVar); } public static void main(String[] args) { ExampleTest v = new ExampleTest(); v.method(20); } }

Führen Sie den obigen Code aus, und die Ausgabe ist wie folgt:

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

Java-Parametervariablen

Parametervariablen in Java sind Variablen, die in Methoden oder Konstruktoren deklariert werden und dazu dienen, Werte zu empfangen, die an die Methode oder den Konstruktor übergeben werden. Parametervariablen ähneln lokalen Variablen, aber sie existieren nur, wenn die Methode oder der Konstruktor aufgerufen wird, und können nur innerhalb der Methode oder des Konstruktors verwendet werden.

Die Deklarationssyntax für eine Java-Methode ist wie folgt:

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
    // 方法体
}
  • parameterType -- steht für den Typ der Parametervariable.
  • parameterName -- steht für den Namen der Parametervariable.

Beim Aufruf einer Methode müssen wir Werte an die Parametervariablen übergeben; diese Werte können Konstanten, Variablen oder Ausdrücke sein.

Es gibt zwei Möglichkeiten, Werte an Methodenparametervariablen zu übergeben:Übergabe per WertundÜbergabe per Referenz。

  • Übergabe per Wert:Wenn eine Methode aufgerufen wird, wird eine Kopie des tatsächlichen Parameterwerts übergeben. Wenn der Parametervariablen ein neuer Wert zugewiesen wird, wird nur der Wert der Kopie geändert, und der ursprüngliche Wert wird nicht beeinflusst. Primitive Datentypen in Java verwenden die Übergabe per Wert, um Parameterwerte zu übergeben.

  • Übergabe per Referenz:Wenn eine Methode aufgerufen wird, wird eine Referenz (d. h. die Speicheradresse) auf den tatsächlichen Parameter übergeben. Wenn der Parametervariablen ein neuer Wert zugewiesen wird, wird der Inhalt des ursprünglichen Werts geändert. Objekttypen in Java verwenden die Übergabe per Referenz, um Werte von Parametervariablen zu übergeben.

Das Folgende ist ein einfaches Beispiel, das die Verwendung von Methodenparametervariablen demonstriert:

Beispiel

public class ExampleTest {
    public static void main(String[] args) {
        int a = 10, b = 20;
        swap(a, b); // Aufruf der swap-Methode
        System.out.println("a = " + a + ", b = " + b); // Die Werte von a und b ausgeben
    }
   
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
}

Führen Sie den obigen Code aus, und die Ausgabe ist wie folgt:

a = 10, b = 20

Lokale Variablen in Java

Lokale Variablen in Java sind Variablen, die innerhalb einer Methode, eines Konstruktors oder eines Anweisungsblocks deklariert werden, und ihr Gültigkeitsbereich ist auf den Codeblock beschränkt, in dem sie deklariert sind.

Die Deklarationssyntax für lokale Variablen ist:

type variableName;
  • type -- steht für den Typ der Variable.
  • variableName -- steht für den Namen der Variable.

Beschreibung:

  • Gültigkeitsbereich: Der Gültigkeitsbereich einer lokalen Variablen ist auf die Methode, den Konstruktor oder den Codeblock beschränkt, in dem sie deklariert ist. Sobald der Codeausführungsfluss diesen Gültigkeitsbereich verlässt, ist die lokale Variable nicht mehr zugänglich.

  • Lebenszyklus: Der Lebenszyklus einer lokalen Variablen beginnt, wenn sie deklariert wird, und endet, wenn die Methode, der Konstruktor oder der Codeblock abgeschlossen ist. Danach wird die lokale Variable durch die Garbage Collection eingesammelt.

  • Initialisierung: Lokale Variablen müssen vor der Verwendung initialisiert werden. Wenn sie nicht initialisiert werden, meldet der Compiler einen Fehler. Java stellt keine Standardwerte für lokale Variablen bereit.

  • Deklaration: Lokale Variablen werden am Anfang einer Methode oder eines Codeblocks deklariert. Bei der Deklaration können Sie den Datentyp angeben, gefolgt vom Variablennamen, zum Beispiel:int count;。

  • Zuweisung: Einer lokalen Variablen muss nach der Deklaration ein Wert zugewiesen werden, bevor sie in der Methode verwendet werden kann. Die Zuweisung kann eine direkte Zuweisung sein oder über einen Methodenaufruf oder Ausdruck erfolgen.

  • Einschränkungen: Auf lokale Variablen kann nicht direkt von anderen Methoden der Klasse zugegriffen werden; sie sind privat für die Methode oder den Codeblock, in dem sie deklariert sind.

  • Speicherverwaltung: Lokale Variablen werden auf dem Stack der Java Virtual Machine (JVM) gespeichert, im Gegensatz zu Instanzvariablen oder Objekten, die auf dem Heap gespeichert werden.

  • Garbage Collection: Da der Lebenszyklus lokaler Variablen strikt auf die Ausführung einer Methode oder eines Codeblocks beschränkt ist, werden sie nach Beendigung der Ausführung der Methode oder des Codeblocks nicht mehr referenziert. Daher gibt der Garbage Collector der JVM den von ihnen belegten Speicher automatisch frei.

  • Wiederverwendung: Namen lokaler Variablen können in verschiedenen Methoden oder Codeblöcken wiederverwendet werden, da ihr Gültigkeitsbereich lokal ist und keine Namenskonflikte verursacht.

  • Parameter und Rückgabewerte: Methodenparameter können als eine besondere Art lokaler Variable betrachtet werden. Sie werden beim Aufruf der Methode initialisiert, und ihr Lebenszyklus endet, nachdem die Methode zurückkehrt.

Beispiel

Das folgende ist ein einfaches Beispiel, das die Verwendung lokaler Variablen demonstriert:

Beispiel

public class LocalVariablesExample {
    public static void main(String[] args) {
        int a = 10; // Deklaration und Initialisierung der lokalen Variable a
        int b;     // Deklaration der lokalen Variable b
        b = 20;    // Initialisierung der lokalen Variable b
       
        System.out.println("a = " + a);
        System.out.println("b = " + b);
       
        // Wenn eine lokale Variable vor der Verwendung nicht initialisiert wird, meldet der Compiler einen Fehler
        // int c;
        // System.out.println("c = " + c);
    }
}

Im obigen Beispiel haben wir zwei lokale Variablen a und b deklariert und initialisiert und dann ihre Werte ausgegeben. Beachten Sie, dass der Compiler einen Fehler meldet, wenn Sie eine lokale Variable nicht vor ihrer Verwendung initialisieren.

Im folgenden Beispiel ist age eine lokale Variable, die in der Methode pupAge() definiert ist, und ihr Gültigkeitsbereich ist auf diese Methode beschränkt:

package com.example.test; public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("Das Alter des Welpen ist:" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

Das Kompilierungs- und Ausführungsergebnis des obigen Beispiels ist wie folgt:

小狗的年龄是: 7

Im folgenden Beispiel wird die Variable age nicht initialisiert, daher tritt ein Kompilierungsfehler auf:

package com.example.test; public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("Das Alter des Welpen ist:" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

Das Kompilierungs- und Ausführungsergebnis des obigen Beispiels ist wie folgt:

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Membervariablen (Instanzvariablen)

  • Membervariablen werden in einer Klasse deklariert, aber außerhalb von Methoden, Konstruktoren und Anweisungsblöcken.
  • Wenn ein Objekt instanziiert wird, wird der Wert jeder Membervariable entsprechend festgelegt.
  • Membervariablen werden erstellt, wenn das Objekt erstellt wird, und zerstört, wenn das Objekt zerstört wird.
  • Die Werte von Membervariablen sollten von mindestens einer Methode, einem Konstruktor oder einem Anweisungsblock referenziert werden, damit externer Code über diese Mittel Informationen zu Instanzvariablen erhalten kann.
  • Membervariablen können vor oder nach ihrer Verwendung deklariert werden.
  • Zugriffsmodifikatoren können Membervariablen modifizieren.
  • Membervariablen sind für Methoden, Konstruktoren oder Anweisungsblöcke innerhalb der Klasse sichtbar. Im Allgemeinen sollten Membervariablen auf private gesetzt werden. Durch die Verwendung von Zugriffsmodifikatoren können Membervariablen für Unterklassen sichtbar gemacht werden.
  • Membervariablen haben Standardwerte. Der Standardwert für numerische Variablen ist 0, für boolean-Variablen ist false und für Variablen vom Referenztyp ist null. Der Wert einer Variablen kann zum Zeitpunkt der Deklaration oder im Konstruktor angegeben werden.
  • Auf Membervariablen kann direkt über den Variablennamen zugegriffen werden. In statischen Methoden und anderen Klassen sollten Sie jedoch den vollqualifizierten Namen verwenden:ObjectReference.VariableName。

Die Deklarationssyntax für Membervariablen ist:

accessModifier type variableName;
  • accessModifier -- Gibt den Zugriffsmodifikator an, der public, protected, private oder die Standardzugriffsebene (d. h. kein explizit angegebener Zugriffsmodifikator) sein kann.
  • type -- Gibt den Typ der Variablen an.
  • variableName -- Gibt den Namen der Variablen an.

Im Gegensatz zu lokalen Variablen werden die Werte von Membervariablen bei der Erstellung des Objekts zugewiesen. Selbst wenn sie nicht initialisiert werden, erhalten sie Standardwerte. Zum Beispiel haben Variablen vom Typ int standardmäßig den Wert 0, und Variablen vom Typ boolean standardmäßig den Wert false.

Auf Membervariablen kann über ein Objekt oder über den Klassennamen zugegriffen werden (wenn es sich um statische Membervariablen handelt). Wenn Membervariablen nicht explizit initialisiert werden, erhalten sie Standardwerte. Sie können Membervariablen in Konstruktoren oder anderen Methoden initialisieren oder über ein Objekt oder einen Klassennamen auf sie zugreifen, um ihre Werte festzulegen.

Beispiel

Im folgenden Beispiel deklarieren wir zwei Membervariablen a und b und greifen auf sie zu und setzen sie. Beachten Sie, dass wir über ein Objekt auf Membervariablen zugreifen können und dass wir auch über den Klassennamen auf statische Membervariablen zugreifen können.

Beispiel

public class ExampleTest {
      private int a; // Private Membervariable a
      public String b = "Hello"; // Öffentliche Mitgliedsvariable b
     
      public static void main(String[] args) {
         ExampleTest obj = new ExampleTest(); // Objekt erstellen
         
          obj.a = 10; // Auf Mitgliedsvariable a zugreifen und ihren Wert auf 10 setzen
          System.out.println("a = " + obj.a);
         
          obj.b = "World"; // Auf Mitgliedsvariable b zugreifen und ihren Wert auf "World" setzen
          System.out.println("b = " + obj.b);
      }
  }

Das obige Beispiel wird kompiliert und ausgeführt und liefert das folgende Ergebnis:

a = 10
b = World

Im folgenden Beispiel deklarieren wir zwei Mitgliedsvariablen name und salary, greifen auf sie zu und setzen sie.

Code der Datei Employee.java:

import java.io.*; public class Employee{ //Diese Mitgliedsvariable ist für Unterklassen sichtbar public String name; //Private Variable, nur in dieser Klasse sichtbar private double salary; //Weise name im Konstruktor einen Wert zu public Employee (String empName){ name = empName; } //Wert von salary setzen public void setSalary(double empSal){ salary = empSal; } //Informationen ausgeben public void printEmp(){ System.out.println("Name:" + name ); System.out.println("Gehalt:" + salary); } public static void main(String[] args){ Employee empOne = new Employee("EXAMPLE"); empOne.setSalary(1000.0); empOne.printEmp(); } }

Das obige Beispiel wird kompiliert und ausgeführt und liefert das folgende Ergebnis:

$ javac Employee.java 
$ java Employee
名字 : EXAMPLE
薪水 : 1000.0

Klassenvariablen (statische Variablen)

Eine statische Variable in Java ist eine Variable, die in einer Klasse definiert ist. Sie ist mit der Klasse und nicht mit Instanzen verknüpft. Das heißt, egal wie viele Klasseninstanzen erstellt werden, es gibt nur eine Kopie der statischen Variable im Speicher, die von allen Instanzen gemeinsam genutzt wird.

Statische Variablen werden erstellt, wenn die Klasse geladen wird, und existieren während der gesamten Programmausführung.

Definitionsmethode

Die Art und Weise, eine statische Variable zu definieren, besteht darin, dasstaticSchlüsselwort zu verwenden, um die Variable zu modifizieren, die auch üblicherweise Klassenvariable genannt wird.

Im folgenden Beispiel definieren wir eine statische Variablecountmit einem Anfangswert von 0:

Beispiel

public class MyClass {
    public static int count = 0;
    // Weitere Membervariablen und Methoden
}

Zugriffsmöglichkeit

Da statische Variablen mit der Klasse verbunden sind, kann man über den Klassennamen auf statische Variablen zugreifen, und man kann auch über den Instanznamen auf statische Variablen zugreifen.

Beispiel

MyClass.count = 10; // Zugriff über den Klassennamen
MyClass obj = new MyClass();
obj.count = 20; // Zugriff über den Instanznamen

Lebenszyklus

Die Lebensdauer statischer Variablen entspricht der Lebensdauer des Programms. Das heißt, sie werden beim Laden der Klasse erzeugt und existieren während der gesamten Programmausführung und werden erst zerstört, wenn das Programm endet. Daher können statische Variablen verwendet werden, um Daten zu speichern, die das gesamte Programm benötigt, wie Konfigurationsinformationen, globale Variablen usw.

Zeitpunkt der Initialisierung

Statische Variablen werden beim Laden der Klasse initialisiert, und ihre Initialisierungsreihenfolge hängt von der Definitionsreihenfolge ab.

Wenn eine statische Variable von einer anderen statischen Variable abhängt, muss sie nach der anderen definiert werden.

Beispiel

public class MyClass {
    public static int count1 = 0;
    public static int count2 = count1 + 1;
    // Weitere Membervariablen und Methoden
}

Im obigen Beispiel muss count1 vor count2 initialisiert werden; andernfalls tritt ein Kompilierungsfehler auf.

Der Unterschied zwischen Konstanten und statischen Variablen

Konstanten sind ebenfalls mit der Klasse verknüpft, aber sie sind Variablen, die mit dem Schlüsselwort final modifiziert werden, und sobald sie zugewiesen wurden, können sie nicht mehr geändert werden. Im Gegensatz zu statischen Variablen wird der Wert einer Konstante zur Kompilierungszeit bestimmt, während der Wert einer statischen Variablen zur Laufzeit geändert werden kann. Darüber hinaus werden Konstanten normalerweise zum Speichern fester Werte verwendet, wie mathematische Konstanten, Konfigurationsinformationen usw., während statische Variablen normalerweise zum Speichern veränderbarer Daten verwendet werden, wie Zähler, globaler Zustand usw.

Zusammenfassend sind statische Variablen Variablen, die mit der Klasse verknüpft sind, mit Einzigartigkeit und gemeinsamer Nutzung. Sie können verwendet werden, um Daten zu speichern, die das gesamte Programm benötigt, aber es sollte auf den Initialisierungszeitpunkt und den Unterschied zu Konstanten geachtet werden.

Zugriffsmodifizierer für statische Variablen

Der Zugriffsmodifizierer für statische Variablen kann public, protected, private oder der Standard-Zugriffsmodifizierer sein (d. h., keinen Zugriffsmodifizierer zu schreiben).

Es ist zu beachten, dass die Zugriffsberechtigung von statischen Variablen sich von der von Instanzvariablen unterscheidet, weil statische Variablen mit der Klasse verknüpft sind und nicht von einer Instanz abhängen.

Thread-Sicherheit von statischen Variablen

Statische Variablen in Java gehören zur Klasse, nicht zu Objektinstanzen. Daher muss ihre Thread-Sicherheit berücksichtigt werden, wenn mehrere Threads gleichzeitig auf eine Klasse zugreifen, die statische Variablen enthält.

Statische Variablen haben nur eine Kopie im Speicher, die von allen Instanzen gemeinsam genutzt wird. Wenn daher ein Thread den Wert einer statischen Variablen ändert, sehen andere Threads beim Zugriff auf diese statische Variable ebenfalls den geänderten Wert. Dies kann zu Nebenläufigkeitsproblemen führen, weil mehrere Threads die statische Variable gleichzeitig ändern können, was zu unbestimmten Ergebnissen oder Problemen mit der Datenkonsistenz führt.

Um die Thread-Sicherheit von statischen Variablen zu gewährleisten, sind geeignete Synchronisationsmaßnahmen erforderlich, wie Synchronisationsmechanismen, atomare Klassen oder das Schlüsselwort volatile, damit die Werte statischer Variablen in einer Multithread-Umgebung korrekt gelesen und geändert werden können.

Namenskonventionen für statische Variablen

Die Namenskonvention für statische Variablen (auch Klassenvariablen genannt) folgt üblicherweise camelCase und verwendet üblicherweise alle Großbuchstaben mit Unterstrichen zwischen den Wörtern und sollte explizit mit dem Schlüsselwort static gekennzeichnet werden.

  • Verwende camelCase:Die Benennung statischer Variablen sollte camelCase verwenden, das heißt, der erste Buchstabe ist klein und der erste Buchstabe jedes nachfolgenden Wortes ist groß. Zum Beispiel:myStaticVariable。

  • Alle Großbuchstaben:Statische Variablen verwenden üblicherweise alle Großbuchstaben mit Unterstrichen zwischen den Wörtern. Dies wird "Upper Snake Case" genannt. Zum Beispiel:MY_STATIC_VARIABLE。

  • Beschreibend:Variablennamen sollten aussagekräftig sein und den Zweck der Variable klar ausdrücken. Vermeiden Sie die Verwendung einzelner Zeichen oder Abkürzungen ohne klare Bedeutung.

  • Vermeiden Sie Abkürzungen:Versuchen Sie, Abkürzungen zu vermeiden, um die Lesbarkeit des Codes zu verbessern. Wenn die Verwendung von Abkürzungen notwendig ist, stellen Sie sicher, dass sie weithin verstanden werden, und erklären Sie sie in Kommentaren.

Beispiel

public class MyClass {
    // Verwende camelCase
    public static int myStaticVariable;

    // Verwende Upper Snake Case
    public static final int MAX_SIZE = 100;

    // Vermeiden Sie Abkürzungen
    public static final String employeeName;

    // Beschreibende Variablennamen
    public static double defaultInterestRate;
}

Verwendungsszenarien für statische Variablen

Statische Variablen werden häufig in den folgenden Szenarien verwendet:

  • Speichern von globalem Zustand oder Konfigurationsinformationen
  • Zähler oder statistische Informationen
  • Zwischenspeichern von Daten oder gemeinsam genutzten Ressourcen
  • Konstanten oder Methoden in Hilfsklassen
  • Instanzvariablen im Singleton-Muster

Beispiel

Das folgende Beispiel definiert eine AppConfig-Klasse, die drei statische Variablen enthält: APP_NAME, APP_VERSION und DATABASE_URL, die verwendet werden, um den Anwendungsnamen, die Version und die Datenbankverbindungs-URL zu speichern. Diese Variablen sind alle als final deklariert, was bedeutet, dass sie unveränderliche Konstanten sind.

In der main()-Methode geben wir die Werte dieser statischen Variablen aus.

Code der Datei AppConfig.java:

public class AppConfig { public static final String APP_NAME = "MyApp"; public static final String APP_VERSION = "1.0.0"; public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb"; public static void main(String[] args) { System.out.println("Anwendungsname: " + AppConfig.APP_NAME); System.out.println("Anwendungsversion: " + AppConfig.APP_VERSION); System.out.println("Datenbank-URL: " + AppConfig.DATABASE_URL); } }

Das obige Beispiel wird kompiliert und ausgeführt und liefert das folgende Ergebnis:

Application name: MyApp
Application version: 1.0.0
Database URL: jdbc:mysql://localhost:3306/mydb

Es ist zu sehen, dass die in diesen statischen Variablen gespeicherten globalen Konfigurationsinformationen im gesamten Programm verwendet werden können und nicht geändert werden. Dieses Beispiel veranschaulicht eine weitere häufige Anwendung statischer Variablen, mit der wir bequem globale Konfigurationsinformationen speichern oder andere Daten implementieren können, die global gemeinsam genutzt werden müssen.

Das folgende Beispiel definiert eine Klasse Counter, die eine statische Variable count enthält, mit der aufgezeichnet wird, wie viele Counter-Objekte erstellt wurden.

Immer wenn ein neues Objekt erstellt wird, erhöht der Konstruktor den Zähler um eins. Die statische Methode getCount() wird verwendet, um den aktuellen Zählerwert abzurufen.

In der Methode main() erstellen wir drei Counter-Objekte und geben den Zählerwert aus.

Code der Datei Counter.java:

public class Counter { private static int count = 0; public Counter() { count++; } public static int getCount() { return count; } public static void main(String[] args) { Counter c1 = new Counter(); Counter c2 = new Counter(); Counter c3 = new Counter(); System.out.println("Anzahl der bisher erstellten Objekte:" + Counter.getCount()); } }

Das obige Beispiel wird kompiliert und ausgeführt und liefert das folgende Ergebnis:

目前为止创建的对象数: 3

Man kann sehen, dass der Zähler aufzeichnet, dass drei Objekte erstellt wurden. Dieses Beispiel zeigt eine einfache Anwendung statischer Variablen, mit denen wir die Anzahl der Objekterstellungen leicht zählen oder andere Daten erfassen können, die global gemeinsam genutzt werden müssen.

In diesem Kapitel haben wir die Java-Variablentypen kennengelernt. Im nächsten Kapitel werden wir die Verwendung von Java-Modifizierern vorstellen.

Weitere Erweiterungen