Java >> Tutoriel Java >  >> Tag >> static

Mot-clé statique en Java

static

L'entrelacement des mots-clés avec des variables en Java joue un rôle important. Au total, il y a cinquante-sept mots clés en Java . Parmi eux, le mot-clé static joue un rôle essentiel dans la gestion de la mémoire. Les programmeurs l'utilisent avec divers autres éléments de programmation. Cet article parlera du mot clé statique en détail .

Qu'est-ce qu'un mot clé statique en Java ?

En Java, les membres statiques appartiennent à la classe plutôt qu'à leurs objets spécifiques. Cela signifie que vous pouvez accéder ou utiliser n'importe quel élément de programme déclaré statiquement sans création d'objet. Les programmeurs utilisent le mot-clé static avant la méthode, la variable et le nom de la classe.

Les programmeurs utilisent ce modificateur sans accès pour partager la même méthode ou variable d'une classe donnée. Pour créer un membre statique, faites précéder la déclaration du mot-clé static. Un autre fait important concernant les membres statiques est qu'une fois qu'un membre est déclaré statique, les programmeurs peuvent accéder à ces membres avant de créer l'objet de la classe.

Exemple

Voici un exemple simple montrant l'utilisation du mot-clé statique.

import java.lang.System.*;
class Main 
{ 
    // This is a Static method 
    static void staticmeth() 
    { 
        System.out.println(" We can create the static method without creating the object of the class. "); 
    } 
    // This is a normal method
    public void NormalMeth() {
        System.out.println(" This public method needs to be invoked by creating the object of the class. ");
    }

    public static void main(String[] args) 
    { 
        staticmeth(); 
        Main o1 = new Main();
        o1.NormalMeth();     
    } 
}

Ici, nous avons déclaré staticmeth() comme statique à l'intérieur duquel nous avons placé un message. Maintenant, dans le main() vous pouvez noter que, sans créer l'objet de classe, vous avez appelé la méthode statique. staticmeth() est utilisée avant de créer l'objet de la classe Main.

Variables statiques

Les variables statiques sont les variables qui ont une copie unique et sont globalement accessibles par n'importe quel objet. Les programmeurs déclarent les variables statiques en plaçant le mot-clé static suivi du nom de la variable. Toutes les instances de classe partagent cette variable afin que les données deviennent partageables avec toutes les classes. Nous pouvons créer des variables statiques au niveau de la classe uniquement.

Syntaxe 

static data_type variable_name;

Exemple

Voici un extrait de code montrant l'utilisation de variables statiques.

import java.lang.System.*;
class Main 
{ 
    // This is a Static method 
    static void staticmeth() 
    { 
        System.out.println(" We can create the static method without creating the object of the class. "); 
    } 
    // This is a normal method
    public void NormalMeth() {
        System.out.println(" This public method needs to be invoked by creating the object of the class. ");
    }

    public static void main(String[] args) 
    { 
        staticmeth(); 
        Main o1 = new Main();
        o1.NormalMeth();     
    } 
}

Dans le Stud class, nous avons créé un institut de variable statique de type String. Nous avons également un constructeur qui récupère le nom de l'étudiant et le numéro de matricule. Ensuite, nous imprimons la valeur de l'institut à partir de disp() méthode. Notez que, lorsque nous appelons le disp() méthode depuis main() , la valeur de l'institut reste la même partout.

Utilisation de variables statiques en Java

  • Les variables déclarées comme statiques sont communes à toutes les instances de classe.
  • Cela nous permet de créer une copie unique de la variable utilisée et partagée avec d'autres instances de classe.
  • Un programme Java initialise une variable statique avant la création de tout objet de classe.
  • Nous pouvons utiliser des variables statiques lorsque nous voulons avoir une variable qui illustre quelque chose sur la classe elle-même.
  • Lorsque nous avons besoin que la valeur d'une variable soit la même pour tous les objets de la classe, nous déclarons une variable statique.

Méthodes statiques

Nous pourrions avoir besoin de situations où nous devons effectuer certaines opérations qui ne dépendent d'aucune création d'instance de classe. Une telle situation nécessite la création d'une méthode statique. Un exemple courant de méthode statique en Java est le principal() .

Syntaxe

static method_name()

Toute méthode statique appartient à une classe et non à l'objet. De plus, nous n'avons pas besoin de créer l'objet de classe pour invoquer la méthode statique. Une méthode statique est capable d'accéder aux données membres statiques et de modifier leur valeur.

Exemple

Voici un extrait de code montrant la création et l'utilisation de la méthode statique.

import java.lang.System.*;
import java.util.*;

class Main 
{ 
    // This is a Static method 
    static void staticmeth() 
    { 
        System.out.println(" This is a static method without creating the object of the class. "); 
    } 
    // This is a normal method
    public void NormalMeth() {
        System.out.println(" This is a public method which requires invoking by creating the object of the class. ");
    }

// main() started from here
    public static void main(String[] args) 
    { 
// static method invoked before the creation of object
        staticmeth(); 
        Main o1 = new Main();
        o1.NormalMeth();     
    } 
}

Ici, nous avons déclaré staticmeth() comme statique à l'intérieur duquel nous avons placé un message. Maintenant, depuis le main() les programmeurs peuvent appeler la méthode statique sans créer l'objet de classe. staticmeth() est utilisée avant de créer l'objet du Main.

Utilisation de la méthode statique en Java

  • Lorsque nous voulons placer un code ou une opération qui ne dépend d'aucune création d'objet, les programmeurs doivent placer le code dans la variable statique.
  • On déclare une méthode 'static' lorsque nous voulons partager un code particulier avec toutes les autres méthodes d'instance.
  • Lorsque nous voulons modifier ou remplacer la définition de notre méthode, nous utilisons la méthode statique.
  • Si nous souhaitons écrire des classes utilitaires dont la fonctionnalité doit rester la même tout au long de l'exécution du programme, la méthode statique vient à la rescousse.

Bloc statique

Pour utiliser des variables statiques dans un programme, nous avons parfois besoin de les initialiser. Les programmeurs utilisent le bloc statique pour initialiser les variables statiques. Les blocs statiques sont exécutés au début une fois lorsque le programme charge la classe.

Exemple : 

import java.lang.System.*;
import java.util.*;
class Main
{ 
    // declaring static variable 
    static int x = 10; 
    static int y;
      
    // creating static block 
    static { 
        System.out.println( " This is a static block. \n " ); 
        x = 12;
        y = x / 3; 
    } 
  
    public static void main(String[] args) 
    { 
        // instance of the class not created
       System.out.println(" This is executed from main. ");       
       // accessing the static variables from main()
       System.out.println(" Printing the value of x : "+ x); 
       System.out.println(" Printing the value of y : " + y); 
    } 
}

Nous avons créé une classe Main et déclaré la variable de type entier statique x . Ensuite, nous avons créé un bloc statique en plaçant simplement le mot-clé static avec les accolades où nous avons montré la sortie et effectué certaines opérations. Notez que nous n'avons pas à créer d'instance de classe dans main() , le bloc statique est toujours exécuté au début. De plus, nous pouvons accéder aux valeurs de bloc statiques de n'importe où dans le programme, comme indiqué en imprimant dans main() .

Utiliser le bloc statique en Java

  • Cela aide à initialiser le membre de données statiques.
  • Si nous souhaitons exécuter ou stocker une valeur dans une variable avant l'exécution de main() , c'est-à-dire qu'au moment du chargement de la classe, le bloc statique vient à la rescousse.

Classe statique

Java permet aux programmeurs de définir une classe dans une autre classe. C'est ce qu'on appelle l'imbrication des classes. Il permet aux programmeurs de regrouper les opérations logiques en différentes classes en gardant à l'esprit l'utilisation de l'encapsulation. L'imbrication des classes apporte également de la lisibilité, et le code devient facile à maintenir. Elles sont appelées classes imbriquées non statiques ou classes internes.

Syntaxe de classe imbriquée non statique

class Outer_Class
{
....
class Nested_Inner_Class
{
....
}
}

Les programmeurs peuvent définir une classe imbriquée statique en utilisant le mot-clé static avec la classe imbriquée. La création d'une classe imbriquée statique rend l'objet de classe interne fermement uni à l'objet de classe externe. Une classe imbriquée statique ne pourra atteindre aucun membre de données ou méthode non statique. Ce n'est qu'en utilisant le nom de classe externe que la classe imbriquée statique peut accéder aux membres de classe non statiques.

Syntaxe de classe imbriquée statique

class Outer_Class
{
....
static class Nested_Inner_Class
{
....
}
}

Exemple de classe imbriquée (non statique) 

import java.lang.System.*;
import java.util.*;
class Outer_Class {
   // inner class
   class Inner_Class {
      public void disp() {
         System.out.println(" The inner class is called ");
      }
   }  
   // Accessing the inner class
   void disp_InnerClass() {
      Inner_Class in = new Inner_Class();
      in.disp();
   }
}   
public class Main {
   public static void main(String args[]) {
      // Instantiating outer class for invoking
      Outer_Class out = new Outer_Class();
      out.disp_InnerClass();
   }
}

Dans ce programme, nous avons créé deux classes imbriquées qui ne sont pas statiques par nature. Pour accéder à la méthode ou à n'importe quel membre de la classe interne, nous pouvons simplement l'appeler en utilisant l'objet de la classe externe comme indiqué dans ces deux lignes

Outer_Class out = new Outer_Class();
out.disp_InnerClass();

Exemple de classe imbriquée statique 

import java.lang.System.*;
import java.util.*;
// Outer class created
class Main 
    {  
    static int numb = 30;  
 
  // Inner class created with Static keyword
    static class InnerMain 
    {  
        void result() 
        {
            System.out.println(" Value is: " + numb);
        }  
    }  
  
  public static void main (String args[]) {  
  Main.InnerMain o1 = new Main.InnerMain();  
  o1.result();  
  }  
}

Dans ce programme, nous avons créé deux classes imbriquées où la classe interne est déclarée comme statique. Maintenant, si vous essayez d'accéder au result() méthode ou tout membre déclaré dans la classe interne à partir de l'objet de classe externe, vous aurez des difficultés à y accéder directement. Pour accéder aux membres de classe imbriqués statiques, vous devez les invoquer en appelant la classe externe suivie de l'opérateur point, puis la classe interne, puis créer l'objet comme indiqué :

Main.InnerMain o1 = new Main.InnerMain();

Maintenant, en utilisant cet objet, vous pouvez accéder aux membres de la classe imbriquée statique :o1.result();

Utiliser la classe statique en Java

  • Nous pouvons instancier une classe statique sans instancier aucun autre objet de classe.
  • Les programmeurs peuvent implémenter la sécurité des membres de classe à l'aide de la déclaration de classe imbriquée statique. C'est parce que vous ne pouvez pas créer l'instance d'une classe interne sans créer l'instance de la classe externe.
  • Encore une fois, les classes internes statiques peuvent aider à rendre votre programme concis et gérable.
  • Si nous voulons préserver l'encapsulation dans notre programme, les classes statiques sont les meilleures. C'est parce qu'ils ne peuvent pas accéder aux membres non statiques.
  • La classe statique aide à regrouper les classes.

Différence entre les classes imbriquées statiques et non statiques en Java

  • Une classe imbriquée statique peut atteindre ou utiliser directement les membres statiques de la classe externe. Mais pour utiliser les membres de la classe externe, la création d'un objet de classe externe est indispensable.
  • Une classe imbriquée statique ne nécessite pas de référence à la classe externe, alors qu'une classe imbriquée non statique en nécessite une.
  • La déclaration de classe imbriquée statique nécessite le mot-clé static dans la classe interne, alors qu'une classe imbriquée non statique ne nécessite aucune déclaration statique.

Conclusion

Le mot clé static joue un rôle important dans l'environnement de programmation Java. Les programmeurs peuvent l'utiliser avec des variables, des méthodes, des blocs et des classes. La classe statique aide à accéder au membre principal de la classe englobante avec une référence d'objet. Si vous savez comment utiliser correctement le mot-clé statique avec tous les différents éléments de programmation, vous pouvez en bénéficier.


Balise Java