Que fait le mot-clé ‘static’ dans une classe?

Pour être précis, j’essayais ce code:

package hello; public class Hello { Clock clock = new Clock(); public static void main(Ssortingng args[]) { clock.sayTime(); } } 

Mais il a donné l’erreur

Impossible d’accéder au champ non statique dans la principale de la méthode statique

J’ai donc changé la déclaration de l’ clock à ceci:

 static Clock clock = new Clock(); 

Et ça a marché. Que signifie mettre ce mot clé avant la déclaration? Que fera-t-il exactement et / ou limitera-t-il ce qui peut être fait à cet object?

static membres static appartiennent à la classe au lieu d’une instance spécifique.

Cela signifie qu’une seule instance d’un champ static existe [1] même si vous créez un million d’instances de la classe ou si vous n’en créez pas. Il sera partagé par toutes les instances.

Les méthodes static n’appartenant pas non plus à une instance spécifique, elles ne peuvent pas faire référence à des membres d’instance (comment savez-vous à quelle instance Hello class vous souhaitez vous référer?). static membres static ne peuvent se référer qu’à static membres static . Les membres d’instance peuvent, bien sûr, accéder static membres static .

Remarque: Bien sûr, static membres static peuvent accéder aux membres d’instance via une référence d’object .

Exemple:

 public class Example { private static boolean staticField; private boolean instanceField; public static void main(Ssortingng[] args) { // a static method can access static fields staticField = true; // a static method can access instance fields through an object reference Example instance = new Example(); instance.instanceField = true; } 

[1]: En fonction des caractéristiques d’exécution, il peut s’agir d’une fonction par ClassLoader, AppDomain ou thread, mais cela n’est pas le cas.

Cela signifie qu’il n’ya qu’une seule instance de «clock» dans Hello, pas une pour chaque instance distincte de la classe «Hello», ou plus encore, cela signifie qu’il y aura une référence «clock» commune à toutes les instances de la classe “Hello”.

Donc, si vous deviez faire un “nouveau Hello” n’importe où dans votre code: A- dans le premier scénario (avant le changement, sans utiliser “static”), cela créerait une nouvelle horloge chaque fois qu’un “nouveau Hello” est appelé, mais B- dans le second scénario (après le changement, en utilisant “static”), chaque instance “new Hello” partagera et utilisera toujours la référence initiale et la même référence “d’horloge” créée en premier.

À moins que vous n’ayez besoin d’une “horloge” quelque part en dehors de la chaîne principale, cela fonctionnerait tout aussi bien:

 package hello; public class Hello { public static void main(Ssortingng args[]) { Clock clock=new Clock(); clock.sayTime(); } } 

Le mot-clé static signifie que quelque chose (un champ, une méthode ou une classe nestede) est lié au type plutôt qu’à une instance particulière du type. Ainsi, par exemple, on appelle Math.sin(...) sans aucune instance de la classe Math et vous ne pouvez en effet pas créer une instance de la classe Math .

Pour plus d’informations, consultez le bit correspondant au didacticiel Java d’Oracle .


Sidenote

Java vous permet malheureusement d’accéder aux membres statiques comme s’ils étaient membres d’une instance, par exemple

 // Bad code! Thread.currentThread().sleep(5000); someOtherThread.sleep(5000); 

Cela donne l’ impression que sleep est une méthode d’instance, mais c’est en fait une méthode statique: elle fait toujours dormir le thread en cours. Il est préférable de préciser ceci dans le code d’appel:

 // Clearer Thread.sleep(5000); 

Le mot-clé static en Java signifie que la variable ou la fonction est partagée entre toutes les instances de cette classe car elle appartient au type et non aux objects eux-mêmes.

Donc, si vous avez une variable: private static int i = 0; et vous l’incrémentez ( i++ ) dans une instance, la modification sera reflétée dans toutes les instances. i vais maintenant être 1 dans tous les cas.

Les méthodes statiques peuvent être utilisées sans instancier un object.

Utilisation de base des membres statiques …

 public class Hello { // value / method public static Ssortingng staticValue; public Ssortingng nonStaticValue; } class A { Hello hello = new Hello(); hello.staticValue = "abc"; hello.nonStaticValue = "xyz"; } class B { Hello hello2 = new Hello(); // here staticValue = "abc" hello2.staticValue; // will have value of "abc" hello2.nonStaticValue; // will have value of null } 

C’est ainsi que vous pouvez partager des valeurs dans tous les membres de la classe sans envoyer d’instance de classe Hello à une autre classe. Et en statique, vous n’avez pas besoin de créer d’instance de classe.

 Hello hello = new Hello(); hello.staticValue = "abc"; 

Vous pouvez simplement appeler des valeurs ou des méthodes statiques par nom de classe:

 Hello.staticValue = "abc"; 

Statique signifie que vous n’avez pas besoin de créer une instance de la classe pour utiliser les méthodes ou les variables associées à la classe. Dans votre exemple, vous pouvez appeler:

 Hello.main(new Ssortingng[]()) //main(...) is declared as a static function in the Hello class 

directement, au lieu de:

 Hello h = new Hello(); h.main(new Ssortingng[]()); //main(...) is a non-static function linked with the "h" variable 

De l’intérieur d’une méthode statique (qui appartient à une classe), vous ne pouvez accéder à aucun membre qui n’est pas statique, car leurs valeurs dépendent de votre instanciation de la classe. Un object d’horloge non statique, qui est un membre d’instance, aurait une valeur / référence différente pour chaque instance de votre classe Hello et, par conséquent, vous ne pouvez pas y accéder depuis la partie statique de la classe.

Statique en Java:

Statique est un modificateur de non-access. Le mot clé static appartient à la classe que l’instance de la classe. peut être utilisé pour attacher une variable ou une méthode à une classe.

Le mot-clé statique PEUT être utilisé avec:

Méthode

Variable

Classe nestede dans une autre classe

Bloc d’initialisation

Ne peut pas être utilisé avec:

Classe (non nested)

Constructeur

Interfaces

Méthode Classe interne locale (différence puis classe nestede)

Méthodes de classe interne

Variables d’instance

Variables locales

Exemple:

Imaginons l’exemple suivant qui a une variable d’instance nommée count qui est incrémentée dans le constructeur:

 package pkg; class StaticExample { int count = 0;// will get memory when instance is created StaticExample() { count++; System.out.println(count); } public static void main(Ssortingng args[]) { StaticExample c1 = new StaticExample(); StaticExample c2 = new StaticExample(); StaticExample c3 = new StaticExample(); } } 

Sortie:

1 1 1

Comme la variable d’instance obtient la mémoire au moment de la création de l’object, chaque object aura la copie de la variable d’instance, si elle est incrémentée, elle ne sera pas réfléchie par les autres objects.

Maintenant, si nous modifions le nombre de variables de l’instance en un statique, le programme produira une sortie différente:

 package pkg; class StaticExample { static int count = 0;// will get memory when instance is created StaticExample() { count++; System.out.println(count); } public static void main(Ssortingng args[]) { StaticExample c1 = new StaticExample(); StaticExample c2 = new StaticExample(); StaticExample c3 = new StaticExample(); } } 

Sortie:

1 2 3

Dans ce cas, la variable statique n’obtiendra la mémoire qu’une fois, si un object modifie la valeur de la variable statique, elle conservera sa valeur.

Statique avec Final:

La variable globale déclarée comme finale et statique rest inchangée pour toute l’exécution. Parce que, les membres statiques sont stockés dans la mémoire de classe et ils ne sont chargés qu’une seule fois dans toute l’exécution. Ils sont communs à tous les objects de la classe. Si vous déclarez les variables statiques comme définitives, aucun des objects ne peut changer leur valeur car elle est finale. Par conséquent, les variables déclarées comme finales et statiques sont parfois appelées constantes. Tous les champs des interfaces sont appelés constantes, car ils sont définitifs et statiques par défaut.

entrer la description de l'image ici

Ressource photo: Final Static

Cette discussion a jusqu’ici ignoré les considérations de classloader. Ssortingctement parlant, les champs statiques Java sont partagés entre toutes les instances d’une classe pour un chargeur de classes donné.

Pour append aux réponses existantes, laissez-moi essayer avec une photo:

Un taux d’intérêt de 2% est appliqué à TOUS les comptes d’épargne. C’est donc statique .

Un équilibre doit être individuel , donc ce n’est pas statique.

entrer la description de l'image ici

Un champ peut être affecté à la classe ou à une instance d’une classe. Par défaut, les champs sont des variables d’instance. En utilisant static le champ devient une variable de classe, il n’y a donc qu’une seule clock . Si vous apportez des modifications à un endroit, il est visible partout. Les variables d’instance sont modifiées indépendamment les unes des autres.

En Java, le mot-clé static peut être simplement considéré comme indiquant ce qui suit:

“sans considération ou relation avec un cas particulier”

Si vous pensez à la static de cette manière, il devient plus facile de comprendre son utilisation dans les différents contextes dans lesquels elle est rencontrée:

  • Un champ static est un champ qui appartient à la classe plutôt qu’à une instance particulière

  • Une méthode static est une méthode qui n’en a aucune idée; il est défini sur la classe et ne connaît aucune instance particulière de cette classe à moins qu’une référence lui soit transmise

  • Une classe membre static est une classe nestede sans aucune notion ou connaissance d’une instance de sa classe englobante (à moins qu’une référence à une instance de classe englobante ne lui soit transmise)

Statique fait du membre d’horloge un membre de classe au lieu d’un membre d’instance. Sans le mot-clé statique, vous devez créer une instance de la classe Hello (qui possède une variable membre d’horloge), par exemple

 Hello hello = new Hello(); hello.clock.sayTime(); 

Les méthodes statiques n’utilisent aucune variable d’instance de la classe dans laquelle elles sont définies. Vous trouverez une très bonne explication de la différence sur cette page.

J’ai développé un goût pour les méthodes statiques (seulement si possible) dans les classes “helper”.

La classe appelante n’a pas besoin de créer une autre variable membre (instance) de la classe auxiliaire. Vous appelez simplement les méthodes de la classe d’assistance. De plus, la classe d’assistance est améliorée car vous n’avez plus besoin d’un constructeur et vous n’avez besoin d’aucune variable membre (instance).

Il y a probablement d’autres avantages.

Le mot clé static est utilisé pour désigner un champ ou une méthode appartenant à la classe elle-même et non à l’instance. En utilisant votre code, si l’object Clock est statique, toutes les instances de la classe Hello partageront ce membre de données Clock (champ) en commun. Si vous le rendez non statique, chaque instance individuelle de Hello peut avoir un champ d’ Clock unique.

Le problème est que vous avez ajouté une méthode principale à votre classe Hello afin que vous puissiez exécuter le code. Le problème ici est que la méthode principale est statique et qu’elle ne peut donc pas faire référence à des champs ou à des méthodes non statiques. Vous pouvez résoudre ce problème de deux manières:

  1. Rendez tous les champs et méthodes de la classe Hello statiques afin qu’ils puissent être référencés dans la méthode principale . Ce n’est vraiment pas une bonne chose à faire (ou la mauvaise raison pour faire un champ et / ou une méthode statique)
  2. Créez une instance de votre classe Hello dans la méthode principale et accédez à tous ses champs et méthodes comme prévu.

Pour vous, cela signifie la modification suivante de votre code:

 package hello; public class Hello { private Clock clock = new Clock(); public Clock getClock() { return clock; } public static void main(Ssortingng args[]) { Hello hello = new Hello(); hello.getClock().sayTime(); } } 

Peut également penser à des membres statiques ne disposant pas d’un pointeur “this”. Ils sont partagés entre toutes les instances.

Comprendre les concepts statiques

 public class StaticPractise1 { public static void main(Ssortingng[] args) { StaticPractise2 staticPractise2 = new StaticPractise2(); staticPractise2.printUddhav(); //true StaticPractise2.printUddhav(); /* false, because printUddhav() is although inside StaticPractise2, but it is where exactly depends on PC program counter on runtime. */ StaticPractise2.printUddhavsStatic1(); //true staticPractise2.printUddhavsStatic1(); /*false, because, when staticPractise2 is blueprinted, it tracks everything other than static things and it organizes in its own heap. So, class static methods, object can't reference */ } } 

Seconde classe

 public class StaticPractise2 { public static void printUddhavsStatic1() { System.out.println("Uddhav"); } public void printUddhav() { System.out.println("Uddhav"); } } 

main() est une méthode statique qui comporte deux ressortingctions fondamentales:

  1. La méthode statique ne peut pas utiliser un membre de données non statique ou appeler directement une méthode non statique.
  2. this() et super() ne peuvent pas être utilisés dans un contexte statique.

     class A { int a = 40; //non static public static void main(Ssortingng args[]) { System.out.println(a); } } 

Sortie: erreur de compilation

Variables statiques Accessible uniquement dans les méthodes statiques, donc lorsque nous déclarons les variables statiques, ces méthodes getter et setter seront des méthodes statiques

méthodes statiques est un niveau de classe, nous pouvons accéder en utilisant le nom de la classe

Voici un exemple pour les variables statiques Getters et Setters:

 public class Static { private static Ssortingng owner; private static int rent; private Ssortingng car; public Ssortingng getCar() { return car; } public void setCar(Ssortingng car) { this.car = car; } public static int getRent() { return rent; } public static void setRent(int rent) { Static.rent = rent; } public static Ssortingng getOwner() { return owner; } public static void setOwner(Ssortingng owner) { Static.owner = owner; } } 

Lors de l’exécution, certains projets chargent tout d’abord des objects statiques (variables, méthodes, blocs ..).

Lorsque vous exécutez ce projet, la méthode principale se charge en premier. Parce que sa static method Ensuite, il regarde l’object "a" object .Mais l’object n’est pas encore défini. Parce que ce n’est pas statique. Alors viens comme cette erreur.