Quelle est l’utilisation d’une variable statique privée en Java?

Si une variable est déclarée comme public static varName; , alors je peux y accéder depuis n’importe où sous ClassName.varName . Je suis également conscient que les membres statiques sont partagés par toutes les instances d’une classe et ne sont pas réalloués dans chaque instance.

private static varName; une variable en tant que nom private static varName; différent de déclarer une variable private varName; ?

Dans les deux cas, il est impossible d’accéder à ClassName.varName ou à ClassName.varName à partir de toute autre classe.

Est-ce que le fait de déclarer la variable comme statique lui donne d’autres propriétés spéciales?

Bien sûr, on peut y accéder en tant que ClassName.var_name , mais seulement depuis l’intérieur de la classe dans laquelle il est défini – c’est parce qu’il est private .

public static variables public static ou public static private static sont souvent utilisées pour les constantes. Par exemple, beaucoup de gens n’aiment pas “coder en dur” les constantes dans leur code; ils aiment créer une variable private static public static ou private static avec un nom significatif et l’utiliser dans leur code, ce qui devrait rendre le code plus lisible. (Vous devez également rendre ces constantes final ).

Par exemple:

 public class Example { private final static Ssortingng JDBC_URL = "jdbc:mysql://localhost/shopdb"; private final static Ssortingng JDBC_USERNAME = "username"; private final static Ssortingng JDBC_PASSWORD = "password"; public static void main(Ssortingng[] args) { Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USERNAME, JDBC_PASSWORD); // ... } } 

Que vous le rendiez public ou private dépend si vous voulez que les variables soient visibles en dehors de la classe ou non.

Les variables statiques ont une valeur unique pour toutes les instances d’une classe.

Si vous deviez faire quelque chose comme:

 public class Person { private static int numberOfEyes; private Ssortingng name; } 

et puis vous vouliez changer de nom, ça va, mon nom rest le même. Si, cependant, vous vouliez le changer pour avoir 17 yeux, alors tout le monde aurait 17 yeux.

Les variables statiques privées sont utiles de la même manière que les variables d’instance privées sont utiles: elles stockent l’état auquel on accède uniquement par code dans la même classe. L’accessibilité (privée / publique / etc) et la nature d’instance / statique de la variable sont des concepts entièrement orthogonaux.

Je voudrais éviter de penser que les variables statiques sont partagées entre «toutes les instances» de la classe – cela suggère qu’il doit y avoir au moins une instance pour que l’état soit présent. Non – une variable statique est associée au type lui-même au lieu de toute instance du type.

Donc, chaque fois que vous voulez un état associé au type plutôt qu’à une instance particulière, et que vous souhaitez garder cet état privé (autorisant peut-être un access contrôlé via des propriétés, par exemple), il est logique d’avoir une variable statique privée.

En passant, je recommande fortement que le seul type de variables que vous rendez public (ou même non privé) soit des constantes – des variables finales statiques de types immuables. Tout le rest devrait être privé pour séparer API et implémentation (entre autres choses).

Eh bien, private static variables private static peuvent être utilisées pour partager des données entre des instances de cette classe. Bien que vous ayez raison, nous ne pouvons pas accéder aux variables private static utilisant des constructions telles que ClassName.member ou ClassName.member mais le membre sera toujours visible à partir des méthodes de cette classe ou des instances de cette classe. Donc, en effet, les instances de cette classe pourront toujours se référer au membre.

Vous avez raison, les variables statiques publiques sont utilisées sans créer d’instance de la classe mais les variables statiques privées ne le sont pas. La principale différence entre eux et où j’utilise les variables statiques privées est lorsque vous devez utiliser une variable dans une fonction statique. Pour les fonctions statiques, vous ne pouvez utiliser que des variables statiques, vous les rendez donc privées pour ne pas y accéder à partir d’autres classes. C’est le seul cas pour lequel j’utilise un statique privé.

Voici un exemple:

 Class test { public static Ssortingng name = "AA"; private static Ssortingng age; public static void setAge(Ssortingng yourAge) { //here if the age variable is not static you will get an error that you cannot access non static variables from static procedures so you have to make it static and private to not be accessed from other classes age = yourAge; } } 

Quelle est l’utilisation d’une variable de classe statique privée?

Disons que vous avez une classe de livre de bibliothèque. Chaque fois que vous créez un nouveau livre, vous voulez lui atsortingbuer un identifiant unique. Une façon est de commencer simplement à 0 et d’incrémenter le numéro d’identification. Mais, comment tous les autres livres connaissent-ils le dernier numéro d’identification créé? Simple, enregistrez-le en tant que variable statique. Les clients ont-ils besoin de savoir que le numéro d’identification interne est pour chaque livre? Non, cette information est privée.

 public class Book { private static int numBooks = 0; private int id; public Ssortingng name; Book(Ssortingng name) { id = numBooks++; this.name = name; } } 

Ceci est un exemple artificiel, mais je suis sûr que vous pouvez facilement penser aux cas où vous souhaitez que toutes les instances de classe aient access à des informations communes qui doivent restr confidentielles pour tout le monde. Ou même si vous ne le pouvez pas, la bonne pratique de programmation consiste à rendre les choses aussi privées que possible. Que se passe-t-il si vous avez accidentellement rendu ce champ numérique public, même si les utilisateurs du livre n’étaient pas censés faire quoi que ce soit avec. Ensuite, quelqu’un pourrait changer le nombre de livres sans créer un nouveau livre.

Très sournois!

private static varName; une variable en tant que nom private static varName; différent de déclarer une variable private varName; ?

Oui, les deux sont différents. Et la première est appelée class variable car elle contient une valeur unique pour cette class tandis que l’autre est appelée instance variable car elle peut contenir différentes valeurs pour différentes instances(Objects) . Le premier est créé une seule fois dans jvm et un autre est créé une fois par instance, c’est-à-dire que si vous avez 10 instances, vous aurez 10 private varName; dans jvm.

Est-ce que le fait de déclarer la variable comme static lui donne d’autres propriétés spéciales?

Oui, les variables statiques ont des propriétés différentes des variables d’instance normales. J’ai déjà mentionné quelques exemples et voyons-en quelques-uns: class variables ( class variables instance déclarées statiques) sont accessibles directement en utilisant le nom de classe comme ClassName.varName . Et tout object de cette classe peut accéder et modifier sa valeur contrairement aux variables d’instance auxquelles seuls les objects respectifs accèdent. Les variables de classe peuvent être utilisées dans les méthodes statiques.

Quelle est l’utilisation d’une private static variable en Java?

Logiquement, private static variable n’est pas différente de public static variable mais la première vous donne plus de contrôle. IMO, vous pouvez littéralement remplacer public static variable par private static variable à l’aide des méthodes getter et setter public static .

Un domaine largement utilisé de private static variable est l’implémentation du modèle Singleton simple dans lequel vous n’aurez qu’une seule instance de cette classe dans le monde entier. Ici, static identifiant static joue un rôle crucial pour que cette instance unique soit accessible par le monde extérieur (bien sûr, la méthode de getter statique publique joue également un rôle principal).

 public class Singleton { private static Singleton singletonInstance = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return Singleton.singletonInstance; } } 

Une autre perspective:

  1. Une classe et son instance sont deux choses différentes à l’exécution. Une information de classe est “partagée” par toutes les instances de cette classe.
  2. Les variables de classe non statiques appartiennent à des instances et la variable statique appartient à la classe.
  3. Tout comme une variable d’instance peut être privée ou publique, les variables statiques peuvent également être privées ou publiques.

Le mot-clé privé utilisera la variable access dans la classe et restra statique dans le sens où nous pouvons accéder à la variable en méthode statique également, mais la variable de référence ne peut pas accéder en méthode statique.

Lorsque, dans une méthode statique, vous utilisez une variable, la variable doit également être statique, par exemple:

 private static int a=0; public static void testMethod() { a=1; } 

Les variables statiques sont les variables communes à toutes les instances d’une classe. Si une instance le change, la valeur de la variable statique sera mise à jour pour toutes les autres instances.

Pour certains, cela a plus de sens s’ils le voient dans deux langues différentes, alors j’ai écrit un exemple en Java et PHP sur ma page où j’explique certains de ces modificateurs. Vous pensez peut-être mal à cela.

Vous devriez regarder mes exemples si cela n’a pas de sens ci-dessous. Allez ici http://www.siteconsortium.com/h/D0000D.php

L’essentiel est que c’est à peu près exactement ce qu’il dit. C’est une variable membre statique qui est privée. Par exemple, si vous souhaitez créer un object Singleton, pourquoi voudriez-vous rendre la variable SingletonExample.instance publique? Si vous aviez une personne qui utilisait la classe, elle pourrait facilement remplacer la valeur.

C’est tout ce que c’est.


     classe publique SingletonExample {
       Instance SingletonExample statique privée = null;
       private int int valeur = 0;
       SingletonExample privé () {
         ++ this.value;
       }
       public statique SingletonExample getInstance () {
         if (instance! = null)
         retour d'instance;
         synchronisé (SingletonExample.class) {
         instance = new SingletonExample ();
         retour d'instance;
         }
       }
       public void printValue () {
         System.out.print (this.value);
       }

       main statique vide statique (Ssortingng [] args) {
         SingletonExample instance = getInstance ();
         instance.printValue ();
         instance = getInstance ();
         instance.printValue ();
          }
     }

Si vous utilisez des variables statiques privées dans votre classe, les classes Static Inner de votre classe peuvent atteindre vos variables. Cela convient parfaitement à la sécurité du contexte.

Si une variable est définie comme statique publique, elle peut être accédée via son nom de classe à partir de n’importe quelle classe.

Les fonctions sont généralement définies comme étant statiques publiques, accessibles uniquement en appelant le nom de la classe d’implémentation.

Un très bon exemple est la méthode sleep() en classe Thread

 Thread.sleep(2500); 

Si une variable est définie comme étant statique, on ne peut y accéder que dans cette classe, donc aucun nom de classe n’est requirejs ou vous pouvez toujours utiliser le nom de la classe (jusqu’à vous). La différence entre private var_name et private static var_name est que les variables statiques privées ne sont accessibles que par des méthodes statiques de la classe alors que les variables privées sont accessibles par toute méthode de cette classe (sauf les méthodes statiques)

Un très bon exemple en est la définition des connexions de firebase database ou des constantes qui nécessitent de déclarer des variables comme statiques privés.

Un autre exemple courant est

 private static int numberOfCars=10; public static int returnNumber(){ return numberOfCars; } 

Je suis nouveau sur Java, mais une des façons d’utiliser les variables statiques, comme je suppose que beaucoup de gens le font, est de compter le nombre d’instances de la classe. par exemple:

 public Class Company { private static int numCompanies; public static int getNumCompanies(){ return numCompanies; } } 

Ensuite, vous pouvez sysout:

 Company.getNumCompanies(); 

Vous pouvez également accéder à numCompanies à partir de chaque instance de la classe (ce que je ne comprends pas tout à fait), mais cela ne se fera pas de manière “statique”. Je ne sais pas si c’est la meilleure pratique ou non, mais cela a du sens pour moi.

*) Si une variable est déclarée comme privée, elle n’est pas visible en dehors de la classe.

*) Si une variable est déclarée comme statique, alors la valeur de la variable est la même pour toutes les instances et nous n’avons pas besoin de créer un object pour appeler cette variable. Nous pouvons appeler cette variable simplement

nom de classe.variablename;

La variable statique privée sera également partagée dans la sous-classe. Si vous avez changé dans une sous-classe et que l’autre sous-classe obtiendra la valeur modifiée, dans ce cas, elle pourrait ne pas correspondre à vos attentes.

 public class PrivateStatic { private static int var = 10; public void setVar(int newVal) { var = newVal; } public int getVar() { return var; } public static void main(Ssortingng... args) { PrivateStatic p1 = new Sub1(); System.out.println(PrivateStatic.var); p1.setVar(200); PrivateStatic p2 = new Sub2(); System.out.println(p2.getVar()); } } class Sub1 extends PrivateStatic { } class Sub2 extends PrivateStatic { } 

Les variables ThreadLocal sont généralement implémentées en tant que statique privé. De cette façon, ils ne sont pas liés à la classe et chaque thread a sa propre référence à son propre object “threadLocal”.

Dans l’exemple suivant, eye est modifié par PersonB, tandis que leg rest le même. En effet, une variable privée se copie elle-même dans la méthode, de sorte que sa valeur d’origine rest la même; alors qu’une valeur statique privée ne contient qu’une seule copie pour toutes les méthodes à partager, la modification de sa valeur modifie sa valeur d’origine.

 public class test { private static int eye=2; private int leg=3; public test (int eyes, int legs){ eye = eyes; leg=leg; } public test (){ } public void print(){ System.out.println(eye); System.out.println(leg); } public static void main(Ssortingng[] args){ test PersonA = new test(); test PersonB = new test(14,8); PersonA.print(); } 

}

> 14 3