En termes simples, que signifie «statique» en Java?

On m’a dit plusieurs définitions pour cela, regardé sur Wikipedia, mais en tant que débutant à Java je ne suis toujours pas sûr de ce que cela signifie. Quelqu’un parle couramment Java et idiot?

static signifie que la variable ou la méthode marquée comme telle est disponible au niveau de la classe. En d’autres termes, vous n’avez pas besoin de créer une instance de la classe pour y accéder.

public class Foo { public static void doStuff(){ // does stuff } } 

Donc, au lieu de créer une instance de Foo et d’appeler ensuite doStuff comme ceci:

 Foo f = new Foo(); f.doStuff(); 

Vous appelez simplement la méthode directement contre la classe, comme ceci:

 Foo.doStuff(); 

En termes très simples, la classe est un moule et l’object est la copie réalisée avec ce moule. Statique appartient au moule et peut être accédé directement sans faire de copie, d’où l’exemple ci-dessus

Le mot-clé statique peut être utilisé de différentes manières en Java et dans presque tous les cas, il s’agit d’un modificateur, ce qui signifie que la chose qu’il modifie est utilisable sans instance d’object englobant .

Java est un langage orienté object et, par défaut, la plupart du code que vous écrivez nécessite une instance de l’object à utiliser.

 public class SomeObject { public int someField; public void someMethod() { }; public Class SomeInnerClass { }; } 

Pour utiliser someField, someMethod ou SomeInnerClass, je dois d’abord créer une instance de SomeObject .

 public class SomeOtherObject { public void doSomeStuff() { SomeObject anInstance = new SomeObject(); anInstance.someField = 7; anInstance.someMethod(); //Non-static inner classes are usually not created outside of the //class instance so you don't normally see this syntax SomeInnerClass blah = anInstance.new SomeInnerClass(); } } 

Si je déclare ces choses statiques, elles ne nécessitent pas d’instance englobante .

 public class SomeObjectWithStaticStuff { public static int someField; public static void someMethod() { }; public static Class SomeInnerClass { }; } public class SomeOtherObject { public void doSomeStuff() { SomeObjectWithStaticStuff.someField = 7; SomeObjectWithStaticStuff.someMethod(); SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass(); //Or you can also do this if your imports are correct SomeInnerClass blah2 = new SomeInnerClass(); } } 

Déclarer quelque chose de statique a plusieurs implications.

Tout d’abord, il ne peut y avoir qu’une seule valeur d’un champ statique dans toute votre application .

 public class SomeOtherObject { public void doSomeStuff() { //Two objects, two different values SomeObject instanceOne = new SomeObject(); SomeObject instanceTwo = new SomeObject(); instanceOne.someField = 7; instanceTwo.someField = 10; //Static object, only ever one value SomeObjectWithStaticStuff.someField = 7; SomeObjectWithStaticStuff.someField = 10; //Redefines the above set } } 

Le deuxième problème est que les méthodes statiques et les classes internes ne peuvent pas accéder aux champs de l’object englobant (puisqu’il n’y en a pas).

 public class SomeObjectWithStaticStuff { private int nonStaticField; private void nonStaticMethod() { }; public static void someStaticMethod() { nonStaticField = 7; //Not allowed this.nonStaticField = 7; //Not allowed, can never use *this* in static nonStaticMethod(); //Not allowed super.someSuperMethod(); //Not allowed, can never use *super* in static } public static class SomeStaticInnerClass { public void doStuff() { someStaticField = 7; //Not allowed nonStaticMethod(); //Not allowed someStaticMethod(); //This is ok } } } 

Le mot-clé statique peut également être appliqué aux interfaces internes, aux annotations et aux énumérations.

classe publique SomeObject {interface statique publique SomeInterface {}; public static @interface SomeAnnotation {}; public static enum SomeEnum {}; }

Dans tous ces cas, le mot clé est redondant et n’a aucun effet. Les interfaces, annotations et énumérations sont statiques par défaut car elles n’ont jamais de relation avec une classe interne.

Cela décrit simplement ce qu’ils font avec les mots-clés. Il ne décrit pas si l’utilisation du mot clé est une mauvaise idée ou non. Cela peut être couvert plus en détail dans d’autres questions telles que l’ utilisation de nombreuses méthodes statiques est-elle une mauvaise chose?

Il existe également quelques utilisations moins courantes du mot-clé static. Il y a des importations statiques qui vous permettent d’utiliser des types statiques (y compris des interfaces, des annotations et des énumérations non marquées statiquement statiques) non qualifiés.

 //SomeStaticThing.java public class SomeStaticThing { public static int StaticCounterOne = 0; } //SomeOtherStaticThing.java public class SomeOtherStaticThing { public static int StaticCounterTwo = 0; } //SomeOtherClass.java import static some.package.SomeStaticThing.*; import some.package.SomeOtherStaticThing.*; public class SomeOtherClass { public void doStuff() { StaticCounterOne++; //Ok StaticCounterTwo++; //Not ok SomeOtherStaticThing.StaticCounterTwo++; //Ok } } 

Enfin, il existe des initialiseurs statiques qui sont des blocs de code qui sont exécutés lors du premier chargement de la classe ( généralement juste avant l’instanciation d’une classe pour la première fois dans une application) et qui, comme les méthodes statiques, ne peuvent pas accéder aux champs non statiques ou méthodes.

 public class SomeObject { private static int x; static { x = 7; } } 

Excuses si cela va plus en détail que nécessaire, on m’a demandé de déplacer cette réponse ici d’une autre question où le détail était un peu plus approprié.

Un autre bon exemple de l’utilisation d’atsortingbuts et d’opérations statiques lorsque vous souhaitez appliquer le modèle de conception Singleton . En bref, le modèle de conception Singleton garantit qu’un seul et même object d’une classe particulière est construit pendant la durée de vie de votre système. pour s’assurer qu’un seul object est jamais construit, les implémentations typiques du modèle Singleton conservent une référence statique interne à l’instance d’object autorisée unique et l’access à cette instance est contrôlé à l’aide d’une opération static

En plus de ce que @inkedmn a souligné, un membre statique est au niveau de la classe. Par conséquent, ledit membre est chargé en mémoire par la machine virtuelle Java une fois pour cette classe (lorsque la classe est chargée). En d’autres termes, il n’y a pas d’instance d’un membre statique chargé pour n instances de la classe à laquelle il appartient.

Les points ci-dessus sont corrects et je veux append quelques points plus importants sur le mot-clé Static.

En interne, ce qui se passe lorsque vous utilisez un mot-clé statique est qu’il stockera dans la mémoire permanente (c’est-à-dire dans la mémoire du tas ), nous soaps qu’il existe deux types de mémoire: la mémoire temporaire et la mémoire permanente. Si vous n’utilisez pas de mot-clé statique, vous stockerez dans la mémoire temporaire qui se trouve dans la mémoire de la stack (ou vous pouvez l’appeler en tant que mémoire volatile ).

alors vous aurez un doute sur l’utilisation de ce droit ???

exemple : statique int a = 10; (1 programme)

tout à l’heure, j’ai dit que si vous utilisez un mot-clé statique pour les variables ou pour la méthode, celle-ci sera stockée dans la mémoire permanente .

J’ai donc déclaré la même variable avec le mot-clé static dans un autre programme avec une valeur différente.

exemple : statique int a = 20; (programme 2)

la variable ‘a’ est stockée dans la mémoire heap par le programme 1. la même variable statique ‘a’ se trouve dans le programme 2 à ce moment-là, elle ne créera plus une variable ‘a’ de 10 à 20 .

En général, il créera une fois de plus la variable “a” dans la mémoire de la stack (mémoire temporaire) si vous ne déclarez pas “a” comme variable statique.

Globalement, je peux dire que si nous utilisons un mot-clé statique
1.nous pouvons économiser de la mémoire
2.nous pouvons éviter les doublons
3. Pas besoin de créer un object pour accéder à une variable statique à l’aide du nom de classe auquel vous pouvez accéder.