Detaillierte Erläuterung der Rolle und Verwendung statischer Variablen in Java

Statisch bedeutet „global“ oder „statisch“ und wird zum Ändern von Mitgliedsvariablen und Mitgliedsmethoden verwendet. Es kann auch einen statischen Codeblock bilden, es gibt jedoch kein Konzept für globale Variablen in der Java-Sprache.

Durch Static geänderte Mitgliedsvariablen und Mitgliedsmethoden sind unabhängig von Objekten der Klasse. Das heißt, es hängt nicht von einer bestimmten Instanz der Klasse ab und wird von allen Instanzen der Klasse gemeinsam genutzt.

Solange diese Klasse geladen ist, kann die Java Virtual Machine sie standardmäßig anhand des Klassennamens im Methodenbereich des Laufzeitdatenbereichs finden. Daher kann auf ein statisches Objekt zugegriffen werden, bevor eines seiner Objekte erstellt wird, ohne auf Objekte zu verweisen.

Mit public geänderte statische Mitgliedsvariablen und Mitgliedsmethoden sind im Wesentlichen globale Variablen und globale Methoden. Wenn ein Objekt seiner Klasse deklariert wird, wird keine Kopie der statischen Variablen generiert, sondern alle Instanzen der Klasse teilen sich gleiche statische Variable.

Statischen Variablen kann eine private Änderung vorangestellt werden, was darauf hinweist, dass diese Variable im statischen Codeblock der Klasse oder in anderen statischen Mitgliedsmethoden der Klasse verwendet werden kann (natürlich kann sie auch in nicht verwendet werden). -statische Mitgliedsmethoden - Unsinn), aber es ist wichtig, nicht direkt über den Klassennamen in anderen Klassen darauf zu verweisen. Tatsächlich müssen Sie verstehen, dass „privat“ eine Einschränkung der Zugriffsberechtigung bedeutet und „statisch“ bedeutet, dass es ohne Instanziierung verwendet werden kann, was viel einfacher zu verstehen ist. Der Effekt des Hinzufügens anderer Zugriffsberechtigungsschlüsselwörter vor dem statischen Schlüsselwort ist ebenfalls derselbe.

Statisch modifizierte Mitgliedsvariablen und Mitgliedsmethoden werden üblicherweise als statische Variablen und statische Methoden bezeichnet. Sie können direkt über den Klassennamen aufgerufen werden. Die Zugriffssyntax lautet:

Name der statischen Methode (Parameterliste...)

Name der statischen Variable

Ein mit Static modifizierter Codeblock stellt einen statischen Codeblock dar. Wenn die Java Virtual Machine (JVM) die Klasse lädt Codeblock wird ausgeführt (Sehr nützlich, haha).

1. Statische Variablen

Klassenmitgliedsvariablen können in zwei Typen eingeteilt werden, je nachdem, ob sie statisch sind: Die eine ist eine statische Variable, die als statische Variable oder Klassenvariable bezeichnet wird Variablen, die nicht statisch geändert werden, werden Instanzvariablen genannt.

Der Unterschied zwischen den beiden ist:

Für statische Variablen gibt es nur eine Kopie im Speicher (Speichereinsparung). Die JVM weist statischen Speicher nur einmal zu und vervollständigt die statische Variable während des Vorgangs Auf den Ladevorgang der Klasse kann direkt über den Klassennamen zugegriffen werden (praktisch), natürlich kann auch über Objekte darauf zugegriffen werden (dies wird jedoch nicht empfohlen).

Bei Instanzvariablen wird vor der Erstellung einer Instanz einmalig Speicher für die Instanzvariable zugewiesen. Instanzvariablen können mehrere Kopien im Speicher haben, ohne sich gegenseitig zu beeinflussen (flexibel).

Daher werden statische Variablen im Allgemeinen verwendet, wenn die folgenden zwei Funktionen implementiert werden müssen:

Beim Teilen von Werten zwischen Objekten

Wenn es bequem ist, auf Variablen zuzugreifen

　2 , Statische Methoden

Statische Methoden können direkt über den Klassennamen aufgerufen werden, und jede Instanz kann ebenfalls aufgerufen werden,

Daher können die Schlüsselwörter this und super nicht verwendet werden In statischen Methoden kann nicht direkt auf die zugehörige Klasse zugegriffen werden. Instanzvariablen und Instanzmethoden (d. h. Mitgliedsvariablen und Mitgliedsmethoden ohne Statik) können nur auf statische Mitgliedsvariablen und Mitgliedsmethoden der Klasse zugreifen, zu der sie gehören.

Weil Instanzmitglieder bestimmten Objekten zugeordnet sind! Das muss man verstehen und verstehen, nicht auswendig lernen! ! !

Da statische Methoden unabhängig von Instanzen sind, müssen statische Methoden implementiert werden und dürfen nicht abstrakt sein.

Um beispielsweise den Methodenaufruf zu erleichtern, sind alle Methoden in der Math-Klasse in der Java-API statisch, und statische Methoden innerhalb allgemeiner Klassen sind auch für andere Klassen praktisch, um diese Methode aufzurufen.

Statische Methode ist eine spezielle Art von Methode innerhalb einer Klasse. Die entsprechende Methode wird nur bei Bedarf als statisch deklariert. Methoden innerhalb einer Klasse sind im Allgemeinen nicht statisch

3. statischer Codeblock

Ein statischer Codeblock wird auch als statischer Codeblock in einer Klasse bezeichnet, der von Klassenmitgliedern unabhängig ist und an keiner Stelle platziert werden kann. JVM lädt die Klasse. Diese statischen Codeblöcke werden ausgeführt. Wenn mehrere statische Codeblöcke vorhanden sind, führt die JVM sie in der Reihenfolge aus, in der sie in der Klasse erscheinen. Zum Beispiel:

public class Test5 {   
private static int a;   
private int b;   
 
static{   
Test5.a=3;   
System.out.println(a);   
Test5 t=new Test5();   
t.f();   
t.b=1000;   
System.out.println(t.b);   
}   
static{   
Test5.a=4;   
System.out.println(a);   
}   
public static void main(String[] args) {   
// TODO 自动生成方法存根   
}   
static{   
Test5.a=5;   
System.out.println(a);   
}   
public void f(){   
System.out.println("hhahhahah");   
}   
}

Ausführungsergebnisse:

3
hhahhahah
1000
4
5

Mithilfe statischer Codeblöcke können Sie einigen statischen Variablen Werte zuweisen. Schauen Sie sich zum Schluss diese Beispiele an Alle verfügen über eine statische Hauptmethode, sodass die JVM sie beim Ausführen der Hauptmethode direkt aufrufen kann, ohne eine Instanz zu erstellen.

　　4、static和final一块用表示什么

　　static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！

　　对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

　　对于方法，表示不可覆盖，并且可以通过类名直接访问。

　　有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

　　声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：

它们仅能调用其他的static 方法。

它们只能访问static数据。

它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。

　　如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：

// Demonstrate static variables，methods，and blocks.   
 
class UseStatic {   
static int a = 3;   
static int b;   
 
static void meth(int x) {   
System.out.println("x = " + x);   
System.out.println("a = " + a);   
System.out.println("b = " + b);   
}   
 
static {   
System.out.println("Static block initialized.");   
b = a * 4;   
}   
 
public static void main(String args[]) {   
meth(42);   
}   
}

一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

　　注意：在一个static 方法中引用任何实例变量都是非法的。

　　下面是该程序的输出：

Static block initialized.
x = 42
a = 3
b = 12

在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：

classname.method( )

这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

　　下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo {   
static int a = 42;   
static int b = 99;   
static void callme() {   
 
System.out.println("a = " + a);   
}   
}   
 
class StaticByName {   
 
public static void main(String args[]) {   
StaticDemo.callme();   
System.out.println("b = " + StaticDemo.b);   
}   
}

下面是该程序的输出：

a = 42
b = 99

static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的。