Mot-clé statique en java

Tutoriels

Java

Le mot-clé statique en Java est largement utilisé dans la programmation Java. Le mot-clé statique Java est utilisé pour créer une variable de niveau de classe en Java. Les variables et méthodes statiques font partie de la classe, pas des instances de la classe.

mot-clé statique en Java

Java statique Le mot-clé peut être utilisé dans cinq cas comme le montre l’image ci-dessous. Nous en discuterons quatre ici, le cinquième a été introduit dans Java 8 et a été discuté dans les modifications d’interface de Java 8.

Variable statique Java

Nous pouvons utiliser le mot-clé static avec une variable de niveau de classe. Une variable statique est une variable de classe et n’appartient pas à l’objet/instance de la classe. Comme les variables statiques sont partagées entre toutes les instances de l’objet, elles ne sont pas sûres pour le thread. Généralement, les variables statiques sont utilisées avec le mot-clé final pour les ressources communes ou les constantes qui peuvent être utilisées par tous les objets. Si la variable statique n’est pas privée, nous pouvons y accéder avec NomDeLaClasse.nomDeLaVariable
```
    //exemple de variable statique
    private static int count;
    public static String str;
    public static final String DB_USER = "monutilisateur";
```
Méthode statique Java

Tout comme une variable statique, une méthode statique appartient à la classe et non aux instances de classe. Une méthode statique peut accéder uniquement aux variables statiques de la classe et invoquer uniquement les méthodes statiques de la classe. Habituellement, les méthodes statiques sont des méthodes utilitaires que nous voulons exposer pour être utilisées par d’autres classes sans avoir besoin de créer une instance. Par exemple, la classe Collections. Les classes d’enveloppe Java et les classes utilitaires contiennent beaucoup de méthodes statiques. La méthode main() qui est le point d’entrée d’un programme Java lui-même est une méthode statique.
```
    // Exemple de méthode statique
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    // Méthode utilitaire statique
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }
```
À partir de Java 8, nous pouvons également avoir des méthodes statiques dans les interfaces. Pour plus de détails, veuillez lire les modifications de l’interface Java 8.
Bloc statique Java

Le bloc statique Java est le groupe d’instructions qui est exécuté lorsque la classe est chargée en mémoire par Java ClassLoader. Le bloc statique est utilisé pour initialiser les variables statiques de la classe. Principalement, il est utilisé pour créer des ressources statiques lorsque la classe est chargée. Nous ne pouvons pas accéder aux variables non statiques dans le bloc statique. Nous pouvons avoir plusieurs blocs statiques dans une classe, bien que cela n’ait pas beaucoup de sens. Le code du bloc statique est exécuté une seule fois lorsque la classe est chargée en mémoire.
```
    static{
        // peut être utilisé pour initialiser des ressources lorsque la classe est chargée
        System.out.println("Bloc statique d'exemple");
        // peut accéder uniquement aux variables et méthodes statiques
        str="Test";
        setCount(2);
    }
```
Classe statique Java

Nous pouvons utiliser le mot-clé statique avec des classes imbriquées. Le mot-clé statique ne peut pas être utilisé avec des classes de niveau supérieur. Une classe imbriquée statique est identique à toute autre classe de niveau supérieur et est imbriquée uniquement pour des raisons de commodité d’emballage. Lire: Classes imbriquées Java

Voyons tous les usages du mot-clé static en Java dans un programme exemple. StaticExample.java

package com.journaldev.misc;

public class StaticExample {

    //bloc static
    static{
        //peut être utilisé pour initialiser les ressources lorsque la classe est chargée
        System.out.println("StaticExample static block");
        //peut accéder uniquement aux variables et méthodes statiques
        str="Test";
        setCount(2);
    }
    
    //plusieurs blocs static dans la même classe
    static{
        System.out.println("StaticExample static block2");
    }
    
    //exemple de variable statique
    private static int count; //kept private to control its value through setter
    public static String str;
    
    public int getCount() {
        return count;
    }

    //exemple de méthode statique
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    //méthode utilitaire statique
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }

    //exemple de classe statique - utilisée uniquement pour la commodité de l'emballage
    public static class MyStaticClass{
        public int count;
        
    }

}

Voyons comment utiliser une variable, une méthode statique et une classe statique dans un programme de test. TestStatic.java

package com.journaldev.misc;

public class TestStatic {

    public static void main(String[] args) {
        StaticExample.setCount(5);
        
        //les variables statiques non privées peuvent être accessibles avec le nom de classe
        StaticExample.str = "abc";
        StaticExample se = new StaticExample();
        System.out.println(se.getCount());
        //les variables statiques de classe et d'instance sont identiques
        System.out.println(StaticExample.str +" is same as "+se.str);
        System.out.println(StaticExample.str == se.str);
        
        //les classes imbriquées statiques sont comme des classes de niveau supérieur normales
        StaticExample.MyStaticClass myStaticClass = new StaticExample.MyStaticClass();
        myStaticClass.count=10;
        
        StaticExample.MyStaticClass myStaticClass1 = new StaticExample.MyStaticClass();
        myStaticClass1.count=20;
        
        System.out.println(myStaticClass.count);
        System.out.println(myStaticClass1.count);
    }
    
}

La sortie du programme exemple ci-dessus avec le mot-clé static en Java est :

StaticExample static block
StaticExample static block2
5
abc is same as abc
true
10
20

Remarquez que le code du bloc static est exécuté en premier et une seule fois dès que la classe est chargée en mémoire. Les autres sorties sont explicites d’elles-mêmes.

Importation statique Java

Normalement, nous accédons aux membres statiques en utilisant la référence de la classe, à partir de Java 1.5, nous pouvons utiliser l’importation statique Java pour éviter la référence de classe. Voici un exemple simple d’importation statique Java.

package com.journaldev.test;

public class A {

	public static int MAX = 1000;
	
	public static void foo(){
		System.out.println("foo static method");
	}
}

package com.journaldev.test;

import static com.journaldev.test.A.MAX;
import static com.journaldev.test.A.foo;

public class B {

	public static void main(String args[]){
		System.out.println(MAX); //normally A.MAX
		foo(); // normally A.foo()
	}
}

Remarquez les déclarations d’importation, pour l’importation statique nous devons utiliser import static suivi du membre statique entièrement classifié d’une classe. Pour importer tous les membres statiques d’une classe, nous pouvons utiliser * comme dans import static com.journaldev.test.A.*;. Nous devrions l’utiliser uniquement lorsque nous utilisons la variable statique d’une classe plusieurs fois, ce n’est pas bon pour la lisibilité. Update: J’ai récemment créé une vidéo pour expliquer le mot-clé statique en java, vous devriez la regarder ci-dessous. https://www.youtube.com/watch?v=2e-l1vb\_fwM

Source:
https://www.digitalocean.com/community/tutorials/static-keyword-in-java

mot-clé statique en Java

Variable statique Java

Méthode statique Java

Bloc statique Java

Classe statique Java

Importation statique Java