À quoi sert le mot-clé statique ?

Aujourd'hui, nous allons principalement découvrir le mot-clé static en langage Java.

La signification et les scénarios d'utilisation du mot-clé statique

static est l'un des 50 mots-clés de Java. Le mot clé static peut être utilisé pour modifier des blocs de code pour représenter des blocs de code statiques, des variables membres modifiées pour représenter des variables membres statiques globales et des méthodes modifiées pour représenter des méthodes statiques. (Remarque : les classes ordinaires ne peuvent pas être modifiées, à l'exception des classes internes. Pourquoi ?)

class A {
	static {
		System.out.println("A : 静态代码块");
	}
	
	static int i ;  // 静态变量
	
	static void method() {
		System.out.println("A: 静态方法");
	}
}

En bref, le contenu modifié par le mot-clé static est statique.

Statique est relatif à dynamique. Dynamique signifie que lorsqu'un programme Java est exécuté sur la JVM, la JVM créera dynamiquement des objets et stockera des objets (allouer de la mémoire) en fonction des besoins du programme après la mission de l'objet. est terminé, l'objet sera détruit par le recycleur de déchets, c'est-à-dire que le recyclage de la mémoire est géré uniformément par la JVM et alloué à d'autres objets nouvellement créés. Cela signifie qu'avant l'exécution du programme Java, la JVM allouera de l'espace à la classe chargée ; stockez le contenu modifié par le mot-clé statique, tel que les variables membres statiques, les classes Java sont chargées dans la JVM et la JVM stockera la classe et ses variables membres statiques dans la zone de méthode. par threads et GC se produit rarement, donc le contenu modifié par le mot clé static est Il est partagé globalement et l'espace de stockage ne sera alloué qu'une seule fois.

Ainsi, lorsqu'un contenu de la classe n'appartient pas à l'objet, mais est partagé par l'objet et appartient à la classe, vous pouvez envisager de le modifier avec le mot-clé static.

Le rôle du mot-clé static

1 Bloc de code modifié

Le bloc de code modifié avec le mot-clé static dans la classe est appelé code statique, et vice versa Les blocs de code qui ne sont pas modifiés avec le mot-clé static sont appelés blocs de code d'instance.

Le bloc de code d'instance sera exécuté au fur et à mesure de la création de l'objet, c'est-à-dire que chaque objet aura son propre bloc de code d'instance, ce qui signifie que le résultat de l'exécution du bloc de code d'instance affectera le contenu du bloc de code d'instance actuel. l'objet et changera avec l'objet. est détruit et disparaît (recyclage de la mémoire) ; et le bloc de code statique est le bloc de code qui est exécuté lorsque la classe Java est chargée dans la mémoire JVM puisque le chargement de la classe n'a lieu qu'une seule fois. Lors du fonctionnement de la JVM, le bloc de code statique ne sera exécuté qu'une seule fois.

Étant donné que la fonction principale du bloc de code statique est d'effectuer un travail d'initialisation complexe, le bloc de code statique est stocké dans la zone de méthode suivant la classe sous la forme que le résultat de l'exécution du bloc de code statique est stocké dans la zone méthode, c'est-à-dire l'initialisation La quantité est stockée dans la zone méthode et partagée par les threads.

2 Modifier les variables membres

Les variables membres modifiées avec le mot clé static dans la classe sont appelées variables membres statiques, car static ne peut pas modifier les variables locales (pourquoi ?), donc les variables membres statiques peuvent également être appelé est une variable statique. Les variables statiques sont similaires aux blocs de code. Lorsque la classe est chargée dans la mémoire JVM, la JVM place les variables statiques dans la zone de méthode et alloue de la mémoire, qui est également partagée par les threads. Le formulaire d'accès est : nom de classe. nom de membre statique.

public class StaticTest {
	public static void main(String[] args) {
		System.out.println(D.i);
		System.out.println(new D().i);
	}
}
class D {
	static {
		i = 2;
		System.out.println("D : 静态代码块1");
	}
	static int i;
}

Les variables statiques sont stockées dans les informations de classe et peuvent être partagées entre les threads, donc bien sûr, elles appartiennent également à chaque objet de la classe, donc les variables statiques sont accessibles via des objets, mais le compilateur ne prend pas en charge cela Faites-le et un avertissement sera donné.

Remarque :

L'ordre de chargement des variables statiques d'une classe et des blocs de code statiques de la classe. La classe chargera d'abord les variables statiques, puis chargera les blocs de code statiques. Cependant, lorsqu'il existe plusieurs variables statiques et plusieurs blocs de code, ils seront chargés dans l'ordre dans lequel ils sont écrits.

class D {
	static {
		i = 2;
		System.out.println("D : 静态代码块1");
	}
	static {
		i = 6;
		System.out.println("D : 静态代码块2");
	}
	static int i;
}

Vous pouvez réfléchir aux résultats de l'opération.

Les variables statiques n'ont pas besoin d'être explicitement initialisées et la JVM leur donnera par défaut les valeurs par défaut correspondantes. Par exemple, le type de données de base byte est 0, short est 0, char est u0000, int est 0, long est 0L, float est 0.0f, double est 0.0d, boolean est false et le type de référence est uniformément nul.

Étant donné que les variables statiques sont partagées dans la mémoire JVM et peuvent être modifiées, leur accès entraînera des problèmes de sécurité des threads (pendant que le thread A est en train de réécrire, le thread B obtient sa valeur, alors ce qui est obtenu est la valeur avant la valeur de modification ou valeur modifiée ? ), vous devez donc envisager le multithreading lorsque vous utilisez des variables statiques. Si vous pouvez vous assurer que les variables statiques sont immuables, vous pouvez utiliser le mot-clé final ensemble pour éviter les problèmes de sécurité des threads ; sinon, vous devez utiliser la synchronisation pour éviter les problèmes de sécurité des threads, comme son utilisation avec le mot-clé volatile.

Le mot-clé static ne peut pas modifier les variables locales, y compris les méthodes d'instance et les méthodes statiques, sinon il violerait l'intention initiale du mot-clé static - le partage.

3 Méthodes modifiées

Les méthodes modifiées avec le mot clé static sont appelées méthodes statiques, sinon elles sont appelées méthodes d'instance. Appelée via le nom de la classe.nom de la méthode, mais il convient de noter que les méthodes statiques peuvent appeler directement des variables statiques et d'autres méthodes statiques de la classe, mais ne peuvent pas appeler directement des variables membres et des méthodes d'instance (sauf si elles sont appelées via des objets).

class D {
	static {
		i = 2;
		System.out.println("D : 静态代码块");
	}
	static final int i;
	int j;
	
	static void method() {
		System.out.println(i);
		System.out.println(new D().j);
		
		method1();
		new D().method2();
	}
	
	static void method1() {
		System.out.println(i);
	}
	void method2() {
		System.out.println(i);
	}
}

Remarque : étant donné que les méthodes d'instance d'une classe nécessitent des appels d'objet pour y accéder et que les méthodes statiques sont accessibles directement via le nom de la classe, comment une classe commence-t-elle à s'exécuter sans prendre en compte le serveur de déploiement ? La plus grande possibilité est de démarrer Java via "nom de classe. méthode statique", et je définis tellement de méthodes statiques, comment la JVM connaît-elle l'entrée principale ?

Peut-être avez-vous pensé à la méthode principale.

Oui, la méthode main est définie par la spécification Java comme l'entrée principale de la classe Java. Le fonctionnement des classes Java est lancé par la méthode main :

 public static void main(String[] args) {
	for (String arg : args) {   // 参数由外部定义
		System.out.println(arg);
	}}

但注意main并不是Java关键字，它只是一个规定的程序入口的方法名字；另外main方法可以重载。

注意：static关键字虽然不能修饰普通类，但可以用static关键字修饰内部类使其变成静态内部类。static关键字本身的含义就是共享，而Java类加载到JVM内存的方法区，也是线程共享的，所以没必要用static关键字修饰普通类。

4 静态导入

在用import导入包或者类时，可以用static修饰包名或者类，表示静态导入。静态导入可以与动态导入放在一起比较来加深理解。

动态导入是当你程序运行时需要new一个不在此包中的类的对象时，才会根据全路径类名加载类；而静态导入则是随着类的加载而加载静态导入的类，所以它是提前导入的。

public class StaticTest {
	static void method1() {
		System.out.println("static method1");
	}
	
	static void method2() {
		System.out.println("static method2");
	}
}

静态导入：

import static com.starry.staticImport.StaticTest.method1;

public class Client {
	public static void main(String[] args) {
		method1();   // 
		StaticTest.method2();
	}
}

注意method1()是静态导入，所以可以不需要通过类名访问；而method2()没有导入，则需要通过类名调用。那么什么时候需要静态导入呢？

静态导入常用于静态方法以及含有静态方法的类，枚举类等的导入，可以在编译阶段确定导入类的信息或者方法信息。

static关键字的缺点

封装是Java类的三大特性之一，也是面向对象的主要特性。因为不需要通过对象，而直接通过类就能访问类的属性和方法，这有点破坏类的封装性；所以除了Utils类，代码中应该尽量少用static关键字修饰变量和方法

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!