Le mot-clé statique en Java est principalement utilisé pour la gestion de la mémoire. Le mot-clé static en Java est utilisé pour partager la même variable ou méthode d'une classe donnée. Les utilisateurs peuvent appliquer des mots-clés statiques avec des variables, des méthodes, des blocs et des classes imbriquées. Le mot-clé static appartient à la classe plutôt qu'à une instance de la classe. Le mot-clé static est utilisé pour une variable constante ou une méthode identique pour chaque instance d'une classe.
Le statique Le mot-clé est un modificateur de non-accès en Java qui s'applique aux éléments suivants :
- Blocs
- Variables
- Méthodes
- Des classes
Note: Pour créer un membre statique (bloc, variable, méthode, classe imbriquée), faites précéder sa déclaration du mot-clé statique .
Caractéristiques du mot-clé statique :
Voici quelques caractéristiques du mot-clé static en Java :
- Allocation de mémoire partagée : les variables et méthodes statiques se voient allouer de l'espace mémoire une seule fois lors de l'exécution du programme. Cet espace mémoire est partagé entre toutes les instances de la classe, ce qui rend les membres statiques utiles pour maintenir l'état global ou les fonctionnalités partagées. Accessible sans instanciation d'objet : les membres statiques sont accessibles sans qu'il soit nécessaire de créer une instance de la classe. Cela les rend utiles pour fournir des fonctions utilitaires et des constantes pouvant être utilisées dans l’ensemble du programme. Associé à la classe, pas aux objets : les membres statiques sont associés à la classe et non aux objets individuels. Cela signifie que les modifications apportées à un membre statique sont reflétées dans toutes les instances de la classe et que vous pouvez accéder aux membres statiques en utilisant le nom de la classe plutôt qu'une référence d'objet. Impossible d'accéder aux membres non statiques : les méthodes et variables statiques ne peuvent pas accéder aux membres non statiques d'une classe, car elles ne sont associées à aucune instance particulière de la classe. Peut être surchargé, mais pas remplacé : Les méthodes statiques peuvent être surchargées, ce qui signifie que vous pouvez définir plusieurs méthodes avec le même nom mais des paramètres différents. Cependant, ils ne peuvent pas être remplacés, car ils sont associés à la classe plutôt qu'à une instance particulière de la classe.
Lorsqu'un membre est déclaré statique, il est accessible avant la création des objets de sa classe et sans référence à aucun objet. Par exemple, dans le programme Java ci-dessous, nous accédons à la méthode statique m1() sans créer aucun objet du Test classe.
Java
// Java program to demonstrate that a static member> // can be accessed before instantiating a class> class> Test> {> >// static method> >static> void> m1()> >{> >System.out.println(>'from m1'>);> >}> >public> static> void> main(String[] args)> >{> >// calling m1 without creating> >// any object of class Test> >m1();> >}> }> |
>
>Sortir
from m1>
Blocs statiques
Si vous devez effectuer le calcul afin d'initialiser votre variables statiques , vous pouvez déclarer un bloc statique qui sera exécuté exactement une fois, lors du premier chargement de la classe.
Considérez le programme Java suivant démontrant l'utilisation de blocs statiques.
Java
// Java program to demonstrate use of static blocks> class> Test> {> >// static variable> >static> int> a =>10>;> >static> int> b;> > >// static block> >static> {> >System.out.println(>'Static block initialized.'>);> >b = a *>4>;> >}> >public> static> void> main(String[] args)> >{> >System.out.println(>'from main'>);> >System.out.println(>'Value of a : '>+a);> >System.out.println(>'Value of b : '>+b);> >}> }> |
>
>Sortir
Static block initialized. from main Value of a : 10 Value of b : 40>
Pour un article détaillé sur les blocs statiques, voir blocs statiques
Variables statiques
Lorsqu'une variable est déclarée statique, une seule copie de la variable est créée et partagée entre tous les objets au niveau de la classe. Les variables statiques sont essentiellement des variables globales. Toutes les instances de la classe partagent la même variable statique.
Points importants pour les variables statiques :
- Nous pouvons créer des variables statiques uniquement au niveau de la classe. Vois ici
- Le bloc statique et les variables statiques sont exécutés dans l'ordre dans lequel ils sont présents dans un programme.
Vous trouverez ci-dessous le programme Java permettant de démontrer que le bloc statique et les variables statiques sont exécutés dans l'ordre dans lequel ils sont présents dans un programme.
Java
// Java program to demonstrate execution> // of static blocks and variables> class> Test> {> >// static variable> >static> int> a = m1();> > >// static block> >static> {> >System.out.println(>'Inside static block'>);> >}> > >// static method> >static> int> m1() {> >System.out.println(>'from m1'>);> >return> 20>;> >}> > >// static method(main !!)> >public> static> void> main(String[] args)> >{> >System.out.println(>'Value of a : '>+a);> >System.out.println(>'from main'>);> >}> }> |
>
>Sortir
jframe
from m1 Inside static block Value of a : 20 from main>
Méthodes statiques
Lorsqu'une méthode est déclarée avec le statique mot-clé, elle est connue sous le nom de méthode statique. L'exemple le plus courant de méthode statique est la principal( ) méthode. Comme indiqué ci-dessus, tout membre statique est accessible avant la création des objets de sa classe et sans référence à aucun objet. Les méthodes déclarées comme statiques ont plusieurs restrictions :
- Ils ne peuvent appeler directement que d’autres méthodes statiques.
- Ils ne peuvent accéder directement qu’aux données statiques.
- Ils ne peuvent pas faire référence à ce ou super de quelque manière que.
Vous trouverez ci-dessous le programme Java pour démontrer les restrictions sur les méthodes statiques.
Java
// Java program to demonstrate restriction on static methods> class> Test> {> >// static variable> >static> int> a =>10>;> > >// instance variable> >int> b =>20>;> > >// static method> >static> void> m1()> >{> >a =>20>;> >System.out.println(>'from m1'>);> > >// Cannot make a static reference to the non-static field b> >b =>10>;>// compilation error> > >// Cannot make a static reference to the> >// non-static method m2() from the type Test> >m2();>// compilation error> > >// Cannot use super in a static context> >System.out.println(>super>.a);>// compiler error> >}> > >// instance method> >void> m2()> >{> >System.out.println(>'from m2'>);> >}> > > > >public> static> void> main(String[] args)> >{> >// main method> >}> }> |
>
Codes couleurs Java
>
Sortir:
prog.java:18: error: non-static variable b cannot be referenced from a static context b = 10; // compilation error ^ prog.java:22: error: non-static method m2() cannot be referenced from a static context m2(); // compilation error ^ prog.java:25: error: non-static variable super cannot be referenced from a static context System.out.println(super.a); // compiler error ^ prog.java:25: error: cannot find symbol System.out.println(super.a); // compiler error ^ symbol: variable a 4 errors>
Quand utiliser des variables et des méthodes statiques ?
Utilisez la variable statique pour la propriété commune à tous les objets. Par exemple, dans la classe Étudiant, tous les étudiants partagent le même nom d’université. Utilisez des méthodes statiques pour modifier les variables statiques.
Considérons le programme Java suivant, qui illustre l'utilisation de statique mots-clés avec variables et méthodes.
Java
// A java program to demonstrate use of> // static keyword with methods and variables> // Student class> class> Student {> >String name;> >int> rollNo;> >// static variable> >static> String cllgName;> >// static counter to set unique roll no> >static> int> counter =>0>;> >public> Student(String name)> >{> >this>.name = name;> >this>.rollNo = setRollNo();> >}> >// getting unique rollNo> >// through static variable(counter)> >static> int> setRollNo()> >{> >counter++;> >return> counter;> >}> >// static method> >static> void> setCllg(String name) { cllgName = name; }> >// instance method> >void> getStudentInfo()> >{> >System.out.println(>'name : '> +>this>.name);> >System.out.println(>'rollNo : '> +>this>.rollNo);> >// accessing static variable> >System.out.println(>'cllgName : '> + cllgName);> >}> }> // Driver class> public> class> StaticDemo {> >public> static> void> main(String[] args)> >{> >// calling static method> >// without instantiating Student class> >Student.setCllg(>'XYZ'>);> >Student s1 =>new> Student(>'Alice'>);> >Student s2 =>new> Student(>'Bob'>);> >s1.getStudentInfo();> >s2.getStudentInfo();> >}> }> |
>
>Sortir
name : Alice rollNo : 1 cllgName : XYZ name : Bob rollNo : 2 cllgName : XYZ>
Classes statiques
Un cours peut être fait statique seulement s'il s'agit d'une classe imbriquée. Nous ne pouvons pas déclarer une classe de niveau supérieur avec un modificateur statique mais pouvons déclarer des classes imbriquées comme statiques. Ces types de classes sont appelés classes statiques imbriquées. La classe statique imbriquée n'a pas besoin d'une référence de classe externe. Dans ce cas, une classe statique ne peut pas accéder aux membres non statiques de la classe externe.
Note: Pour la classe imbriquée statique, consultez un classe imbriquée statique en Java
Mise en œuvre:
Java
// A java program to demonstrate use> // of static keyword with Classes> import> java.io.*;> public> class> GFG {> >private> static> String str =>'techcodeview.com'>;> >// Static class> >static> class> MyNestedClass {> > >// non-static method> >public> void> disp(){> >System.out.println(str);> >}> >}> > >public> static> void> main(String args[])> >{> >GFG.MyNestedClass obj> >=>new> GFG.MyNestedClass();> >obj.disp();> >}> }> |
>
>Sortir
techcodeview.com>
Voici un exemple de programme Java qui démontre l'utilisation du mot-clé static :
Java
public> class> ExampleClass {> >public> static> int> count =>0>;> >public> int> id;> >public> ExampleClass() {> >count++;> >id = count;> >}> >public> static> void> printCount() {> >System.out.println(>'Number of instances: '> + count);> >}> >public> void> printId() {> >System.out.println(>'Instance ID: '> + id);> >}> >public> static> void> main(String[] args) {> >ExampleClass e1 =>new> ExampleClass();> >ExampleClass e2 =>new> ExampleClass();> >ExampleClass e3 =>new> ExampleClass();> >e1.printId();> >e2.printId();> >e3.printId();> >ExampleClass.printCount();> >}> }> |
>
>Sortir
Instance ID: 1 Instance ID: 2 Instance ID: 3 Number of instances: 3>
Avantages :
- Efficacité de la mémoire : les membres statiques se voient allouer de la mémoire une seule fois lors de l'exécution du programme, ce qui peut entraîner des économies de mémoire importantes pour les programmes volumineux. Performances améliorées : étant donné que les membres statiques sont associés à la classe plutôt qu'à des instances individuelles, ils sont accessibles plus rapidement et plus efficacement que les membres non statiques. Accessibilité globale : les membres statiques sont accessibles depuis n'importe où dans le programme, qu'une instance de la classe ait été créée ou non. Encapsulation de méthodes utilitaires : les méthodes statiques peuvent être utilisées pour encapsuler des fonctions utilitaires qui ne nécessitent aucune information d'état d'un objet. Cela peut améliorer l'organisation du code et faciliter la réutilisation des fonctions utilitaires dans plusieurs classes. Constantes : les variables finales statiques peuvent être utilisées pour définir des constantes partagées dans l'ensemble du programme. Fonctionnalité au niveau de la classe : les méthodes statiques peuvent être utilisées pour définir des fonctionnalités au niveau de la classe qui ne nécessitent aucune information d'état d'un objet, comme les méthodes d'usine ou les fonctions d'assistance.
Dans l’ensemble, le mot-clé static est un outil puissant qui peut vous aider à améliorer l’efficacité et l’organisation de vos programmes Java.