what is static keyword java
Ce didacticiel explique le mot-clé statique en Java et son utilisation dans les variables, méthodes, blocs et classes. Indique également la différence entre les membres statiques et non statiques:
Java prend en charge divers types de déclarations pour indiquer la portée et le comportement de ses variables, méthodes, classes, etc. Par exemple, le mot-clé final, scellé, statique, etc. Toutes ces déclarations ont une signification particulière lorsqu'elles sont utilisées dans le programme Java.
Nous explorerons tous ces mots-clés au fil de ce didacticiel. Ici, nous discuterons des détails de l'un des mots-clés les plus importants de Java, à savoir «statique».
Ce que vous apprendrez:
- Mot-clé statique en Java
- Conclusion
Mot-clé statique en Java
Un membre d'un programme Java peut être déclaré comme statique à l'aide du mot-clé «static» précédant sa déclaration / définition. Lorsqu'un membre est déclaré statique, cela signifie essentiellement que le membre est partagé par toutes les instances d'une classe sans faire de copies de par instance.
Ainsi, static est un modificateur sans classe utilisé en Java et peut être appliqué aux membres suivants:
- Variables
- Méthodes
- Blocs
- Classes (plus spécifiquement, classes imbriquées)
Lorsqu'un membre est déclaré statique, il est alors accessible sans utiliser d'objet. Cela signifie qu'avant qu'une classe ne soit instanciée, le membre statique est actif et accessible. Contrairement à d'autres membres de classe non statiques qui cessent d'exister lorsque l'objet de la classe sort de la portée, le membre statique est toujours évidemment actif.
Variable statique en Java
Une variable membre d'une classe déclarée comme statique est appelée variable statique. Elle est également appelée «variable de classe». Une fois que la variable est déclarée statique, la mémoire n'est allouée qu'une seule fois et non à chaque fois qu'une classe est instanciée. Par conséquent, vous pouvez accéder à la variable statique sans référence à un objet.
Le programme Java suivant décrit l'utilisation des variables statiques:
class Main { // static variables a and b static int a = 10; static int b; static void printStatic() { a = a /2; b = a; System.out.println('printStatic::Value of a : '+a + ' Value of b : '+b); } public static void main(String() args) { printStatic(); b = a*5; a++; System.out.println('main::Value of a : '+a + ' Value of b : '+b); } } Production:
Dans le programme ci-dessus, nous avons deux variables statiques, à savoir a et b. Nous modifions ces variables dans une fonction «printStatic» ainsi que dans «main». Notez que les valeurs de ces variables statiques sont conservées dans les fonctions même lorsque la portée de la fonction se termine. La sortie affiche les valeurs des variables dans deux fonctions.
Pourquoi avons-nous besoin de variables statiques et où sont-elles utiles?
Les variables statiques sont les plus utiles dans les applications qui ont besoin de compteurs. Comme vous le savez, les compteurs donneront des valeurs erronées s'ils sont déclarés comme des variables normales.
Par exemple, si vous avez une variable normale définie comme compteur dans une application qui a une classe, dites voiture. Ensuite, chaque fois que nous créons un objet voiture, la variable de compteur normale sera initialisée avec chaque instance. Mais si nous avons une variable de compteur en tant que variable statique ou de classe, elle ne s'initialise qu'une seule fois lorsque la classe est créée.
Plus tard, avec chaque instance de la classe, ce compteur sera incrémenté de un. Ceci est différent de la variable normale dans laquelle à chaque instance, le compteur sera incrémenté mais la valeur du compteur sera toujours 1.
Par conséquent, même si vous créez une centaine d'objets de la classe voiture, le compteur en tant que variable normale aura toujours la valeur 1 alors qu'avec une variable statique, il affichera le compte correct de 100.
Ci-dessous, un autre exemple de compteurs statiques en Java:
class Counter { static int count=0;//will get memory only once and retain its value Counter() { count++;//incrementing the value of static variable System.out.println(count); } } class Main { public static void main(String args()) { System.out.println('Values of static counter:'); Counter c1=new Counter(); Counter c2=new Counter(); Counter c3=new Counter(); } } Production:
Le fonctionnement de la variable statique est évident dans le programme ci-dessus. Nous avons déclaré le nombre de variables statiques avec la valeur initiale = 0. Ensuite, dans le constructeur de la classe, nous incrémentons la variable statique.
Dans la fonction principale, nous créons trois objets du compteur de classe. La sortie affiche la valeur de la variable statique à chaque fois que l'objet compteur est créé. Nous voyons qu'avec chaque objet créé, la valeur de la variable statique existante est incrémentée et non réinitialisée.
Méthode statique Java
Une méthode en Java est statique lorsqu'elle est précédée du mot-clé «statique».
Certains points dont vous devez vous souvenir à propos de la méthode statique comprennent:
liste de contiguïté de graphe c ++
- Une méthode statique appartient à la classe par rapport aux autres méthodes non statiques qui sont appelées à l'aide de l'instance d'une classe.
- Pour appeler une méthode statique, vous n’avez pas besoin d’un objet de classe.
- Les membres de données statiques de la classe sont accessibles à la méthode statique. La méthode statique peut même modifier les valeurs du membre de données statique.
- Une méthode statique ne peut pas faire référence à des membres «this» ou «super». Même si une méthode statique tente de les référencer, ce sera une erreur du compilateur.
- Tout comme les données statiques, la méthode statique peut également appeler d'autres méthodes statiques.
- Une méthode statique ne peut pas faire référence à des membres de données ou des variables non statiques et ne peut pas non plus appeler des méthodes non statiques.
Le programme suivant montre l'implémentation de la méthode statique en Java:
class Main { // static method static void static_method() { System.out.println('Static method in Java...called without any object'); } public static void main(String() args) { static_method(); } } Production:
Ceci est une simple illustration. Nous définissons une méthode statique qui imprime simplement un message. Ensuite, dans la fonction principale, la méthode statique est appelée sans objet ni instance de classe.
Un autre exemple d'implémentation de mot-clé statique en Java.
class Main { // static variable static int count_static = 5; // instance variable int b = 10; // static method static void printStatic() { count_static = 20; System.out.println('static method printStatic'); // b = 20; // compilation error 'error: non-static variable b cannot be referenced from a static context' //inst_print(); // compilation error 'non-static method inst_print() cannot be referenced from a static //context' //System.out.println(super.count_static); // compiler error 'non-static variable super cannot be //referenced from a static context' } // instance method void inst_print() { System.out.println('instance method inst_print'); } public static void main(String() args) { printStatic(); } } Dans le programme ci-dessus, comme vous pouvez le voir, nous avons deux méthodes. La méthode printStatic est une méthode statique tandis que inst_print est une méthode d'instance. Nous avons également deux variables, static_count est une variable statique et b est une variable d'instance.
Dans la méthode statique - printStatic, nous affichons d'abord un message, puis nous essayons de changer la valeur de la variable d'instance b et appelons également la méthode non statique.
Ensuite, nous essayons d'utiliser le mot clé 'super'.
b = 20;
inst_print ();
System.out.println (super.count_static);
Lorsque nous exécutons le programme avec les lignes ci-dessus, nous obtenons des erreurs de compilation pour l'utilisation de variables d'instance, l'appel de méthodes non statiques et la référence à super dans un contexte statique. Telles sont les limites de la méthode statique.
Lorsque nous commentons les trois lignes ci-dessus, alors seulement le programme ci-dessus fonctionne bien et produit la sortie suivante.
Production:
Surcharge et remplacement de la méthode statique
Comme vous le savez tous, la surcharge et le remplacement sont les caractéristiques de OOPS et ils aident au polymorphisme. La surcharge peut être classée comme un polymorphisme à la compilation dans lequel vous pouvez avoir des méthodes avec le même nom mais des listes de paramètres différentes.
Le remplacement est une caractéristique du polymorphisme d'exécution et dans ce cas, la méthode de la classe de base est remplacée dans la classe dérivée de sorte que la signature de la méthode ou le prototype est le même mais la définition diffère.
Voyons comment la surcharge et le remplacement affectent la classe statique en Java.
Surcharge
Vous pouvez surcharger une méthode statique en Java avec différentes listes de paramètres mais avec le même nom.
Le programme suivant montre la surcharge:
public class Main { public static void static_method() { System.out.println('static_method called '); } public static void static_method(String msg) { System.out.println('static_method(string) called with ' + msg); } public static void main(String args()) { static_method(); static_method('Hello, World!!'); } } Production:
Ce programme a deux méthodes statiques avec le même nom «static_method» mais une liste d’arguments différente. La première méthode ne prend aucun argument et la deuxième méthode prend un argument de chaîne.
Un point à noter est que vous ne pouvez pas surcharger la méthode simplement en fonction du mot-clé «statique». Par exemple, si vous avez une méthode d'instance «somme» et si vous définissez une autre méthode «somme» et la déclarez comme statique, alors cela ne fonctionnera pas. Cette tentative de surcharge basée sur un mot-clé «statique» va entraîner un échec de compilation.
Primordial
Comme les méthodes statiques sont appelées sans aucun objet de la classe, même si vous avez une méthode statique avec la même signature dans la classe dérivée, elle ne sera pas remplacée. En effet, il n'y a pas de polymorphisme à l'exécution sans instance.
Par conséquent, vous ne pouvez pas remplacer une méthode statique. Mais s'il y a une méthode statique avec la même signature dans la classe dérivée, alors la méthode à appeler ne dépend pas des objets au moment de l'exécution mais dépend du compilateur.
Vous devez noter que bien que les méthodes statiques ne puissent pas être remplacées, le langage Java ne donne aucune erreur de compilation lorsque vous avez une méthode dans la classe dérivée avec la même signature qu'une méthode de classe de base.
La mise en œuvre suivante prouve ce point.
classBase_Class { // Static method in base class which will be hidden in substatic_displayclass public static void static_display() { System.out.println('Base_Class::static_display'); } } classDerived_Class extends Base_Class { public static void static_display() { System.out.println('Derived_Class::static_display'); } } public class Main { public static void main(String args( )) { Base_Class obj1 = new Base_Class(); Base_Class obj2 = new Derived_Class(); Derived_Class obj3 = new Derived_Class(); obj1.static_display(); obj2.static_display(); obj3.static_display(); } } Production:
Dans le programme ci-dessus, vous pouvez voir que la méthode statique appelée ne dépend pas de l'objet sur lequel pointe le pointeur. En effet, les objets ne sont pas du tout utilisés avec des méthodes statiques.
Bloc statique en Java
Tout comme vous avez des blocs fonctionnels dans des langages de programmation comme C ++, C #, etc. en Java également, il existe un bloc spécial appelé bloc «statique» qui comprend généralement un bloc de code lié aux données statiques.
Ce bloc statique est exécuté au moment où le premier objet de la classe est créé (précisément au moment du chargement de la classe) ou lorsque le membre statique à l'intérieur du bloc est utilisé.
Le programme suivant montre l'utilisation d'un bloc statique.
class Main { static int sum = 0; static int val1 = 5; static int val2; // static block static { sum = val1 + val2; System.out.println('In static block, val1: ' + val1 + ' val2: '+ val2 + ' sum:' + sum); val2 = val1 * 3; sum = val1 + val2; } public static void main(String() args) { System.out.println('In main function, val1: ' + val1 + ' val2: '+ val2 + ' sum:' + sum); } } Production:
Questions et réponses d'entretien SQL pour les testeurs
Notez l'ordre d'exécution des instructions dans le programme ci-dessus. Le contenu du bloc statique est exécuté en premier, suivi du programme principal. Les variables statiques sum et val1 ont des valeurs initiales tandis que val2 n'est pas initialisé (il vaut 0 par défaut). Ensuite, dans le bloc statique, val2 ne reçoit toujours pas de valeur et sa valeur est donc affichée comme 0.
La variable val2 reçoit une valeur après impression dans le bloc statique et la somme est recalculée. Par conséquent, dans la fonction principale, nous obtenons différentes valeurs de somme et val2.
Si vous spécifiez un constructeur, le contenu du bloc statique est exécuté avant même le constructeur. Les blocs statiques sont principalement utilisés pour initialiser les membres statiques de la classe et d'autres initialisations liées aux membres statiques.
Classe statique Java
En Java, vous avez des blocs statiques, des méthodes statiques et même des variables statiques. Il est donc évident que vous pouvez également avoir des classes statiques. En Java, il est possible d'avoir une classe dans une autre classe et cela s'appelle une classe imbriquée. La classe qui entoure la classe imbriquée est appelée la classe Outer.
En Java, bien que vous puissiez déclarer une classe imbriquée comme statique, il n'est pas possible d'avoir la classe externe comme statique.
Explorons maintenant les classes imbriquées statiques en Java.
Classe imbriquée statique en Java
Comme déjà mentionné, vous pouvez avoir une classe imbriquée en Java déclarée comme statique. La classe imbriquée statique diffère de la classe imbriquée non statique (classe interne) dans certains aspects, comme indiqué ci-dessous.
Contrairement à la classe imbriquée non statique, la classe statique imbriquée n'a pas besoin d'une référence de classe externe.
Une classe imbriquée statique peut accéder uniquement aux membres statiques de la classe externe par rapport aux classes non statiques qui peuvent accéder aux membres statiques et non statiques de la classe externe.
Un exemple de classe imbriquée statique est donné ci-dessous.
class Main{ private static String str = 'SoftwareTestingHelp'; //Static nested class static class NestedClass{ //non-static method public void display() { System.out.println('Static string in OuterClass: ' + str); } } public static void main(String args()) { Main.NestedClassobj = new Main.NestedClass(); obj.display(); } } Production:
Dans le programme ci-dessus, vous voyez que la classe imbriquée statique peut accéder à la variable statique (chaîne) à partir de la classe externe.
Importation statique en Java
Comme vous le savez, nous incluons généralement divers packages et fonctionnalités prédéfinies dans le programme Java en utilisant la directive «import». L'utilisation du mot static avec la directive import vous permet d'utiliser la fonctionnalité de classe sans utiliser le nom de classe.
Exemple:
questions et réponses d'entretien de testeur qa
import static java.lang.System.*; class Main { public static void main(String() args) { //here we import System class using static, hence we can directly use functionality out.println('demonstrating static import'); } } Production:
Dans ce programme, nous utilisons l'importation statique pour la classe java.lang.System.
Remarque: Dans la fonction principale, nous venons d'utiliser out.println pour afficher le message.
Bien que la fonction d'importation statique rende le code plus concis et plus lisible, elle crée parfois une ambiguïté, en particulier lorsque certains packages ont les mêmes fonctions. Par conséquent, l'importation statique ne doit être utilisée que lorsque cela est extrêmement nécessaire.
Statique vs non statique
Laissez-nous discuter des principales différences entre les membres statiques et non statiques de Java.
Vous trouverez ci-dessous les différences entre Variables statiques et non statiques .
| Variables statiques | Variables non statiques |
|---|---|
| Il est accessible uniquement en utilisant le nom de la classe. | Nécessite des objets d'une classe pour y accéder. |
| Sont accessibles à la fois aux méthodes statiques et non statiques. | Sont accessibles uniquement aux méthodes non statiques. |
| Une mémoire pour variable statique n'est allouée qu'une seule fois par classe. | Une mémoire pour les variables non statiques est allouée par objet. |
| Partagé par tous les objets de la classe. | Une copie de variable par objet est faite. |
| A une portée globale et est disponible pour toutes les méthodes et blocs. | A une portée locale et est visible par les objets de la classe. |
Ci-dessous, la différence entre les méthodes statiques et non statiques .
| Méthodes statiques | Méthodes non statiques |
|---|---|
| Une méthode qui est précédée d'un mot clé statique et est disponible au niveau de la classe. | Une méthode non précédée d'un mot-clé statique et disponible pour chacune des instances de la classe. |
| Prend en charge la compilation ou la liaison anticipée. | Prend en charge la liaison d'exécution ou dynamique. |
| Peut accéder uniquement aux données statiques membres de sa classe et de toute autre classe. | Peut accéder aux membres statiques et non statiques de la classe et d'autres classes. |
| Les méthodes statiques ne peuvent pas être remplacées. | Peut être remplacé. |
| La mémoire n'est allouée qu'une seule fois. Par conséquent, la mémoire utilisée est moindre. | La consommation de mémoire est plus importante car la mémoire est allouée chaque fois que la méthode est appelée. |
Statique vs finale
Static et Final sont deux mots-clés en Java qui peuvent donner une signification particulière à l'entité avec laquelle il est utilisé. Par exemple, lorsqu'une variable est déclarée comme statique, elle devient une variable de classe accessible sans référence à l'objet.
De même, lorsqu'une variable est déclarée comme finale, elle devient immuable, c'est-à-dire une constante.
Faisons un tableau de certaines des principales différences entre les mots clés statiques et finaux en Java.
| Statique | Final |
|---|---|
| Un membre de données statique (classe imbriquée, variable ou méthode) est un membre de données précédé d'un mot clé statique et est accessible sans objet. | Le mot-clé final peut être appliqué à une variable, une méthode, une classe, etc. et impose des restrictions aux entités. |
| Pas obligatoire pour initialiser la variable statique avec une valeur lors de la déclaration. | Il est nécessaire que la variable finale soit initialisée à une valeur au moment de la déclaration |
| Vous pouvez réinitialiser les variables statiques. | Impossible de réinitialiser les variables finales. |
| Les méthodes statiques sont celles qui ne peuvent accéder qu'aux membres statiques. | Les méthodes finales sont les méthodes qui ne peuvent pas être héritées / remplacées. |
| Les classes statiques sont des classes dont les objets ne peuvent pas être créés. | Les classes finales sont des classes qui ne peuvent pas être héritées. |
Questions fréquemment posées
Q # 1) La classe Java peut-elle être statique?
Répondre: Oui, une classe en Java peut être statique, à condition qu'elle ne soit pas la classe externe. Cela signifie que seules les classes imbriquées en Java peuvent être statiques.
Q # 2) Quand dois-je utiliser Static en Java?
Répondre: Chaque fois que vous voulez un membre de données dans votre programme qui doit conserver sa valeur à travers les objets, vous devez utiliser static. Par exemple, un compteur. Une méthode peut être déclarée statique lorsque vous ne souhaitez pas l'invoquer à l'aide d'un objet.
Q # 3) Une classe statique peut-elle avoir un constructeur?
Répondre: Oui, une classe statique peut avoir un constructeur et son objectif est uniquement d'initialiser les membres de données statiques. Il ne sera appelé que pour la première fois lors de l'accès aux données membres. Il ne sera pas appelé pour un accès ultérieur.
Q # 4) Quelle est l'utilisation de Static Constructor?
Répondre: En général, le constructeur est utilisé pour initialiser les membres de données statiques. Il est également utilisé pour effectuer des opérations / actions qui ne doivent être effectuées qu'une seule fois.
Q # 5) Les méthodes statiques sont-elles héritées en Java?
Répondre: Oui, les méthodes statiques en Java sont héritées mais ne sont pas remplacées.
Conclusion
Dans ce didacticiel, nous avons discuté en détail du mot-clé statique de Java ainsi que de son utilisation dans les membres de données, les méthodes, les blocs et les classes. Le mot clé static est un mot clé utilisé pour indiquer le niveau de classe ou la portée globale.
Vous n'avez pas besoin d'accéder aux membres statiques à l'aide d'instances de la classe. Vous pouvez accéder directement aux membres de données statiques à l'aide du nom de classe. Nous avons également discuté des principales différences entre les membres statiques et non statiques ainsi que les mots-clés statiques et finaux.
Dans nos rubriques suivantes, nous explorerons plus de mots-clés et leur signification en langage Java.
lecture recommandée
- Statique en C ++
- Tutoriel sur l'interface Java et la classe abstraite avec des exemples
- Déploiement Java: création et exécution d'un fichier JAR Java
- Machine virtuelle Java: comment JVM aide à exécuter une application Java
- Concepts C #: Constructeur, Destructeur, Classe statique, Struct & Enum
- Modificateurs d'accès en Java - Tutoriel avec des exemples
- Tutoriel de réflexion Java avec des exemples
- Introduction au langage de programmation Java - Tutoriel vidéo