Was ist Java-Statik?

1. Statische Methode

Statische Methode wird im Allgemeinen als statische Methode bezeichnet, da die statische Methode von keiner abhängt Objekt Es kann darauf zugegriffen werden, daher gibt es für statische Methoden kein This, da es an kein Objekt angehängt ist. Da es kein Objekt gibt, gibt es auch kein This. Und aufgrund dieser Funktion kann in statischen Methoden nicht auf nicht statische Mitgliedsvariablen und nicht statische Mitgliedsmethoden der Klasse zugegriffen werden, da nicht statische Mitgliedsmethoden/-variablen auf bestimmte Objekte angewiesen sind, bevor sie aufgerufen werden können.

Es sollte jedoch beachtet werden, dass in statischen Methoden zwar nicht auf nicht-statische Mitgliedsmethoden und nicht-statische Mitgliedsvariablen zugegriffen werden kann, in nicht-statischen Mitgliedsmethoden jedoch auf statische Mitgliedsmethoden/-variablen zugegriffen werden kann. Ein einfaches Beispiel:

Da im obigen Code die print2-Methode unabhängig vom Objekt existiert, kann sie direkt über den Klassennamen aufgerufen werden. Wenn in statischen Methoden auf nicht statische Methoden/Variablen zugegriffen werden kann, dann gibt es in der Hauptmethode die folgende Anweisung:

MyObject.print2();

Zu diesem Zeitpunkt sind keine Objekte vorhanden und str2 existiert nicht überhaupt, also wird es einen Konflikt geben. Das Gleiche gilt für Methoden. Da Sie nicht vorhersagen können, ob in der print1-Methode auf nicht statische Mitgliedsvariablen zugegriffen wird, ist der Zugriff auf nicht statische Mitgliedsmethoden auch in statischen Mitgliedsmethoden verboten.

Was nicht-statische Mitgliedsmethoden betrifft, gibt es offensichtlich keine Einschränkung für den Zugriff auf statische Mitgliedsmethoden/-variablen.

Wenn Sie also eine Methode aufrufen möchten, ohne ein Objekt zu erstellen, können Sie diese Methode auf statisch setzen. Unsere gebräuchlichste statische Methode ist die Hauptmethode. Warum die Hauptmethode statisch sein muss, ist jetzt klar. Da das Programm beim Ausführen der Hauptmethode keine Objekte erstellt, kann nur über den Klassennamen darauf zugegriffen werden.

Denken Sie auch daran, ob der Konstruktor eine statische Methode ist, siehe: http://blog.csdn.net/qq_17864929/article/details/48006835

2. Statische Variablen

Statische Variablen werden auch als statische Variablen bezeichnet. Der Unterschied zwischen statischen Variablen und nicht statischen Variablen besteht darin, dass statische Variablen von allen Objekten gemeinsam genutzt werden nur eine im Speicher. Die Kopie wird [im Methodenbereich gespeichert] und nur dann initialisiert, wenn die Klasse zum ersten Mal geladen wird [die Initialisierungsorte statischer Variablen mit final und ohne final sind unterschiedlich]. Nicht statische Variablen gehören Objekten und werden beim Erstellen des Objekts initialisiert. Es gibt mehrere Kopien, und die Kopien, die jedem Objekt gehören, wirken sich nicht gegenseitig aus.

Die Initialisierungsreihenfolge statischer Mitgliedsvariablen wird in der definierten Reihenfolge initialisiert.

3. Statischer Codeblock

Das Schlüsselwort static spielt auch eine Schlüsselrolle bei der Bildung statischer Codeblöcke zur Optimierung der Programmleistung. Ein statischer Block kann an einer beliebigen Stelle in einer Klasse platziert werden, und eine Klasse kann mehrere statische Blöcke enthalten. Wenn eine Klasse zum ersten Mal geladen wird, wird jeder statische Block in der Reihenfolge der statischen Blöcke ausgeführt und nur einmal ausgeführt [gemäß dem Klassenladeprinzip wird jede Klasse einmal mithilfe der übergeordneten Delegationsladung geladen].

Initialisierungssequenz statischer Codeblock> Konstruktionscodeblock> Warum statischer Block zur Optimierung der Programmleistung verwendet werden kann, liegt an seinen Eigenschaften: Er wird nur geladen, wenn die Klasse geladen wird einmal ausgeführt. Schauen wir uns ein Beispiel an:

public class Client {
{//构造代码块
System.out.println("执行构造代码块");
}
}

isBornBoomer wird verwendet, um zu bestimmen, ob die Person zwischen 1946 und 1964 geboren wurde. Jedes Mal, wenn isBornBoomer aufgerufen wird, werden zwei Objekte, startDate und BirthDate, generiert, was zu einer Verschwendung von führt Wenn Sie es so ändern, ist es tatsächlich effizienter, statische Codeblöcke einmal in den Speicher zu laden:

class Person{
private Date birthDate;
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
Date startDate = Date.valueOf("1946");
Date endDate = Date.valueOf("1964");
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}

Daher sind oft nur einige Initialisierungsvorgänge erforderlich Einmal ausgeführte Befehle werden in einem statischen Codeblock platziert.

4. Statische innere Klassen

Statische innere Klassen werden an dieser Stelle nicht separat geschrieben. Wir können unser Verständnis statischer innerer Klassen vertiefen, indem wir sie mit gewöhnlichen inneren Klassen vergleichen :

Warum innere Klassen verwenden?

1. Interne Klassen werden im Allgemeinen nur von ihren externen Klassen verwendet. [Ein gutes Beispiel für die Verwendung durch externe Klassen ist, dass es einen internen Klasseneintrag in der Hashmap-Sammlung gibt, der zur Verwendung in Hashmap-Speicher konvertiert wird ]

2. Die innere Klasse bietet ein Fenster in die äußere Klasse. Die innere Klasse hat einen Verweis auf die äußere Klasse, sodass die innere Klasse direkt auf die Eigenschaften der äußeren Klasse zugreifen kann >3. Dies ist auch der attraktivste Grund, warum jede innere Klasse eine Schnittstelle unabhängig erben kann, unabhängig davon, ob die äußere Klasse eine Schnittstelle geerbt hat. Daher machen innere Klassen die Lösung der Mehrfachvererbung vollständiger.

Eine innerhalb einer Klasse definierte Klasse wird als innere Klasse bezeichnet, und eine Klasse, die eine innere Klasse enthält, wird als äußere Klasse bezeichnet. Innere Klassen können Zugriffsbeschränkungen wie öffentlich, geschützt, privat usw. deklarieren, sie können als abstrakt deklariert werden, damit andere innere Klassen oder externe Klassen erben und erweitern können, oder sie können als statisch oder endgültig deklariert werden oder sie können bestimmte Schnittstellen implementieren.

外部类按常规的类访问方式（以对象的方式）使用内部 类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性，外部类访问内部类，需要创建对象访问；有一点需要注意，内部类不能访问外部类所在的局部变量，只能访问final修饰的局部变量。

在方法内定义内部类时，如果内部类调用了方法中的变量，那么该变量必须申明为final类型，百思不得其解，后来想到应该是生命周期的原因，因为方法内定义的变量是局部变量，离开该方法，变量就失去了作用，也就会自动被消除，而内部类却不会离开它所在方法就失去作用，它有更广的生命周期。

（1）创建实例

OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new，内部类
AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身，静态内部类

（2）内部类中的this

内部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。

（3）外部类访问内部类

内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。外部类对象通过‘外部类名.this.xxx’的形式访问内部类的属性与方法。如：

System.out.println("Print in inner Outer.index=" + pouter.this.index);
System.out.println("Print in inner Inner.index=" + this.index);

（4）内部类向上转型

内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。如果内部类是private的，只可以被它的外部类问，从而完全隐藏实现的细节。

（5）方法内的类

方法内创建的类（注意方法中也能定义类），不能加访问修饰符。另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被事先编译了。

（6）静态内部类

定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

通常称为嵌套类，当内部类是static时，意味着：

[1]要创建嵌套类的对象，并不需要其外围类的对象；

[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；

嵌 套类与普通的内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段， 也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这 个类中定义静态的成员变量与成员方法。

另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的 对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于 该类的对象，更不属于其他外部类的对象。

（7）内部类标识符

每个类会产生一个.class文件，文件名即为类名。同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。

代码具体：

public class OutClassTest 
{
static int a;
int b;
public static void test() {
System.out.println("outer class static function");
}
public static void main(String[] args) {
// new一个外部类
OutClassTest oc1 = new OutClassTest();
// 通过外部类的对象new一个非静态的内部类
OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
// 调用非静态内部类的方法
System.out.println(no_static_inner.getKey());
// 调用静态内部类的静态变量
System.out.println(OutClassTest.InnerStaticClass.static_value);
// 不依赖于外部类实例,直接实例化内部静态类
OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
// 调用静态内部类的非静态方法
System.out.println(inner.getValue());
// 调用内部静态类的静态方法
System.out.println(OutClassTest.InnerStaticClass.getMessage());
}
private class InnerClass {
// 只有在静态内部类中才能够声明或定义静态成员
// private static String tt = "0";
private int flag = 0;
public InnerClass() {
// 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量
System.out.println("InnerClass create a:" + a);
System.out.println("InnerClass create b:" + b);
System.out.println("InnerClass create flag:" + flag);
//
System.out.println("InnerClass call outer static function");
// 调用外部类的静态方法
test();
}
public  String getKey() {
return "no-static-inner";
}
}
private static class InnerStaticClass {
// 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
private static String static_value = "0";
private int flag = 0;
public InnerStaticClass() {
System.out.println("InnerClass create a:" + a);
            // 静态内部类不能够访问外部类的非静态成员
            // System.out.println("InnerClass create b:" + b);
            System.out.println("InnerStaticClass flag is " + flag);
            System.out.println("InnerStaticClass tt is " + static_value);
        }
        public int getValue() {
            // 静态内部类访问外部类的静态方法
            test();
            return 1;
        }
        public static String getMessage() {
            return "static-inner";
        }
    }
    public OutClassTest() {
        // new一个非静态的内部类
        InnerClass ic = new InnerClass();
        System.out.println("OuterClass create");
    }
}

有就是类名ClassName后面多了个.* ，意思是导入这个类里的静态方法。当然，也可以只导入某个静态方法，只要把 .* 换成静态方法名就行了。然后在这个类中，就可以直接用方法名调用静态方法，而不必用ClassName.方法名 的方式来调用。

好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便

example：

在Java 5中，import语句得到了增强，以便提供甚至更加强大的减少击键次数功能，虽然一些人争议说这是以可读性为代价的。这种新的特性成为静态导入。当你想使用static成员时，可以使用静态导入（在API中的类和你自己的类上，都可以使用该特性）。下面是静态导入前后的代码实例：

在静态导入之前：

public class TestStatic {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.toHexString(42));
}
}

在静态导入之后：

import static java.lang.System.out;
import static java.lang.Integer.*;
public class TestStaticImport {
public static void main(String[] args) {
out.println(MAX_VALUE);
out.println(toHexString(42));
}
}

让我们看一下使用静态导入特性的代码中将发生什么：

1. Obwohl diese Funktion oft als „statischer Import“ bezeichnet wird, muss die Syntax statisch importieren sein, gefolgt vom vollständig qualifizierten Namen des statischen Mitglieds, das Sie importieren möchten, oder einem Platzhalterzeichen. In diesem Beispiel führen wir einen statischen Import für das Out-Objekt der Systemklasse durch.

2. In diesem Beispiel möchten wir möglicherweise mehrere statische Mitglieder der Klasse java.lang.Integer verwenden. Diese statische Importanweisung verwendet Platzhalter, um zu sagen: „Ich möchte einen statischen Import für alle statischen Mitglieder dieser Klasse durchführen.“

3. Jetzt sehen wir endlich die Vorteile der statischen Importfunktion! Wir müssen System nicht in System.out.println eingeben. Sehr gut! Außerdem müssen wir Integer nicht in Integer.MAX_VALUE eingeben. In dieser Codezeile können wir also eine Verknüpfung für eine statische Methode und eine Konstante verwenden.

4. Abschließend führen wir weitere Verknüpfungsoperationen durch, dieses Mal für Methoden der Integer-Klasse.

Wir äußern uns schon etwas sarkastisch zu dieser Funktion, aber wir sind nicht allein. Wir glauben nicht, dass das Einsparen einiger Tastenanschläge die Lesbarkeit des Codes erschwert, aber viele Entwickler haben darum gebeten, ihn zur Sprache hinzuzufügen.

Im Folgenden sind einige Prinzipien für die Verwendung des statischen Imports aufgeführt:

Sie müssen statischen Import und nicht statischen Import sagen.

Vorsicht vor mehrdeutig benannten statischen Elementen. Wenn Sie beispielsweise statische Importe für die Integer-Klasse und die Long-Klasse durchführen, führt der Verweis auf MAX_VALUE zu einem Compilerfehler, da sowohl Integer als auch Long eine MAX_VALUE-Konstante haben und Java nicht weiß, auf welchen MAX_VALUE Sie verweisen.

Sie können statische Importe für statische Objektreferenzen, Konstanten (denken Sie daran, sie sind statisch oder endgültig) und statische Methoden durchführen.

Viele Java-Schulungsvideos, alle auf der chinesischen PHP-Website, willkommen zum Online-Lernen!

Das obige ist der detaillierte Inhalt vonWas ist Java-Statik?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!