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

La différence entre les méthodes statiques et les méthodes d'instance se reflète principalement sous deux aspects :

Lors de l'appel de méthodes statiques en externe, vous pouvez utiliser "class nom" .Nom de la méthode", vous pouvez également utiliser la méthode "Nom de l'objet.Nom de la méthode". Les méthodes d'instance n'ont que cette dernière méthode. En d’autres termes, l’appel de méthodes statiques ne nécessite pas la création d’un objet.

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 de membre statiques et aux méthodes statiques), mais ne sont pas autorisées à accéder aux membres d'instance. les variables et les méthodes d'instance ; les méthodes d'instance n'ont pas cette restriction.

Les exemples suivants illustrent cette différence.

1. Appeler une instance de méthode statique

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.

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

Le programme est autorisé à appeler des méthodes statiques deux fois. Le résultat du programme est le suivant :

This is a static method.This is a static method.

Il est autorisé à appeler des méthodes statiques sans créer d'objet. La manière Java de réduire les appels des programmeurs. Elle élimine la difficulté d'utiliser certaines méthodes courantes et permet aux programmeurs d'utiliser des méthodes de la manière traditionnelle d'utiliser les fonctions en langage C.

2. Exemple de méthode statique accédant aux variables membres

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

Cet exemple peut en fait être résumé en une phrase : les méthodes statiques ne peuvent accéder qu'aux membres statiques, et les méthodes d'instance peuvent accéder aux membres statiques et d'instance. La raison pour laquelle les méthodes statiques ne sont pas autorisées à accéder aux variables membres d'instance est que les variables membres d'instance appartiennent à un certain objet et que l'objet n'existe pas nécessairement lorsqu'une méthode statique est exécutée.

De même, étant donné que les méthodes d'instance peuvent accéder aux variables membres d'instance, si une méthode statique est autorisée à appeler des méthodes d'instance, elle sera indirectement autorisée à utiliser des variables membres d'instance, elle ne pourra donc pas appeler de méthodes d'instance. Pour la même raison, le mot clé this ne peut pas être utilisé dans les méthodes statiques. La méthode

main() est une méthode statique typique. Elle suit également les règles des méthodes statiques générales, elle peut donc être appelée par le système avant de créer un objet.

Tutoriel recommandé : Tutoriel Java

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!