Detaillierte Erläuterung des Unterschieds zwischen statischen Java-Methoden und Instanzmethoden

Der Unterschied zwischen statischen Methoden und Instanzmethoden spiegelt sich hauptsächlich in zwei Aspekten wider:

Beim externen Aufruf statischer Methoden können Sie „Klassenname.Methodenname“ oder „Objekt“name.Methode verwenden Name". Instanzmethoden verfügen nur über die letztere Methode. Mit anderen Worten: Für den Aufruf statischer Methoden ist keine Erstellung eines Objekts erforderlich.

Wenn statische Methoden auf Mitglieder dieser Klasse zugreifen, dürfen sie nur auf statische Mitglieder (d. h. statische Mitgliedsvariablen und statische Methoden) zugreifen, nicht jedoch auf Instanzmitgliedsvariablen und Instanzmethoden Methoden haben diese Grenze nicht.

Die folgenden Beispiele veranschaulichen diesen Unterschied.

1. Beispiel für den Aufruf statischer Methoden

//-----------hasStaticMethod.java-----------------
public class hasStaticMethod{
//定义一个静态方法
public static void callMe(){
　　System.out.println("This is a static method.");
}
}

Das folgende Programm verwendet zwei Formen, um statische Methoden aufzurufen.

//-----------invokeStaticMethod.java-----------------
public class invokeStaticMethod{
　　public static void main(String args[]){
　　hasStaticMethod.callMe(); //不创建对象，直接调用静态方法 
　　hasStaticMethod oa = new hasStaticMethod();  //创建一个对象
　　oa.callMe();   //利用对象来调用静态方法
}
}

Das Programm ruft die statische Methode zweimal auf, beide sind zulässig. Die Ausgabe des Programms ist wie folgt:
Dies ist eine statische Methode.Dies ist eine statische Methode .

Das Ermöglichen des Aufrufs statischer Methoden ohne Erstellen eines Objekts ist für Java eine Möglichkeit, die Probleme für Programmierer beim Aufrufen bestimmter gängiger Methoden zu verringern und es Programmierern zu ermöglichen, Methoden auf die herkömmliche Art und Weise der Verwendung von Funktionen zu verwenden in C-Sprache. Ein typisches Beispiel ist die Verwendung von „Math.ramdon()“ in einigen früheren Programmen, um Zufallszahlen zu erhalten.
Ein weiterer typischer Vertreter ist das Array-Verarbeitungstool Arrays

2. Beispiel für statischen Methodenzugriff auf Mitgliedsvariablen

//-----------accessMember.java-----------------
class accessMember{
private static int sa; //定义一个静态成员变量
private int ia; //定义一个实例成员变量
//下面定义一个静态方法
static void statMethod(){
　　int i = 0;  //正确，可以有自己的局部变量sa = 10; 
　　//正确，静态方法可以使用静态变量
　　otherStat();
　　//正确，可以调用静态方法
　　ia = 20;  //错误，不能使用实例变量
　　insMethod(); //错误，不能调用实例方法
}
static void otherStat(){}
//下面定义一个实例方法
void insMethod(){
　　int i = 0;  //正确，可以有自己的局部变量
　　sa = 15;  //正确，可以使用静态变量
　　ia = 30;  //正确，可以使用实例变量
　　statMethod();  //正确，可以调用静态方法
}
}

Dieses Beispiel lässt sich tatsächlich in einem Satz zusammenfassen: Statische Methoden können nur auf statische Mitglieder zugreifen, und Instanzmethoden können auf statische und Instanzmitglieder zugreifen. Der Grund, warum statische Methoden nicht auf Instanzmitgliedsvariablen zugreifen dürfen, liegt darin, dass Instanzmitgliedsvariablen zu einem bestimmten Objekt gehören und das Objekt nicht unbedingt vorhanden ist, wenn eine statische Methode ausgeführt wird. Da Instanzmethoden auf Instanzmitgliedsvariablen zugreifen können, darf eine statische Methode, wenn sie Instanzmethoden aufrufen darf, indirekt auch Instanzmitgliedsvariablen verwenden, sodass sie keine Instanzmethoden aufrufen kann. Aus dem gleichen Grund kann das Schlüsselwort this nicht in statischen Methoden verwendet werden. Die Methode

main() ist eine typische statische Methode. Sie folgt auch den Regeln allgemeiner statischer Methoden, sodass sie vom System aufgerufen werden kann, bevor ein Objekt erstellt wird.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt. Ich hoffe auch, dass jeder die PHP-Chinesisch-Website unterstützt.

Ausführlichere Erläuterungen zu den Unterschieden zwischen statischen Java-Methoden und Instanzmethoden finden Sie auf der chinesischen PHP-Website!