La différence entre les méthodes statiques Java et les méthodes non statiques

La différence entre les méthodes statiques Java et les méthodes non statiques

1. méthode)

Comme les variables membres statiques, elles appartiennent à la classe elle-même. Elles sont chargées en mémoire lorsque la classe est chargée et ne sont pas automatiquement détruites. Elles resteront en mémoire jusqu'à ce que la JVM soit chargée. fermé;

2. Méthode non statique

Également connue sous le nom de méthode d'instanciation, elle appartient à l'objet instance. La mémoire sera allouée après l'instanciation et doit être référencée via un objet instance. instance de la classe. Lorsque l'objet instance est recyclé par la JVM, il disparaît également

La différence entre les méthodes statiques et les méthodes d'instance

1. Vie cycle

Le cycle de vie d'une méthode statique commence lorsque le processus est créé et se termine lorsque le processus se termine. Par conséquent, la méthode statique est globale et parcourt l'ensemble du processus. Le cycle de vie de la méthode d'instance commence à partir de l'instanciation de l'objet et se poursuit jusqu'à la fin du processus. L'objet instancié se termine après avoir été désenregistré et recyclé

Le cycle de vie de la méthode d'instance est donc plus court que celui de la méthode d'instance. cycle de vie de la méthode statique. C'est aussi la raison pour laquelle les méthodes statiques ne peuvent pas être appelées dans les méthodes d'instance

Lors de l'appel d'une méthode statique en externe, vous pouvez utiliser la méthode "nom de classe. nom de méthode" ou la méthode "objet. nom de méthode", ce qui signifie que lors de l'appel d'une méthode statique, il n'est pas nécessaire de créer un objet

Les méthodes d'instance ne peuvent utiliser que le "object.method name method"

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

Le programme suivant utilise deux formulaires pour appeler des méthodes statiques.

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

Lorsque des méthodes statiques accèdent aux membres de cette classe, elles ne sont autorisées à accéder qu'aux membres statiques (c'est-à-dire aux variables statiques et aux méthodes statiques) et non Accédez aux variables membres d'instance et aux méthodes d'instance ; les méthodes d'instance n'ont pas cette restriction

Les variables membres d'instance appartiennent à un certain objet, et l'objet n'existe pas nécessairement lorsque la méthode statique est exécutée de la même manière, si la méthode statique est autorisée ; Si la méthode accède à la méthode membre de l'instance, elle peut accéder indirectement à la variable membre de l'instance, elle ne peut donc pas accéder à la méthode membre de l'instance. Pour la même raison, le mot-clé this

//-----------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();  //正确，可以调用静态方法
}
}

Lorsqu'un fichier de classe est chargé dans la JVM par ClassLoader, les instructions de la méthode sont enregistrées dans la pile. À ce stade, il n'y a aucune donnée dans la zone Heap. . Ensuite, le technicien du programme commence à exécuter l'instruction. S'il s'agit d'une méthode statique, le code d'instruction est exécuté directement en séquence. Bien entendu, le code d'instruction ne peut pas accéder à la zone de données Heapshuju à ce moment-là ; La méthode d'instance a un paramètre entrant implicite, le paramètre qui lui est donné par la JVM. Ce paramètre est l'adresse mémoire de l'objet d'instance dans la pile, afin que la méthode d'instance puisse trouver ses propres données dans le tas. être instancié avant l'appel, allouer les données dans le tas et transmettre le pointeur mémoire dans la pile à la méthode d'instance via les paramètres implicites de la JVM. Si vous l'appelez directement sans l'instancier, une erreur sera signalée car le paramètre implicite n'a aucune valeur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!