attribut statique final privé vs attribut final privé

En Java, quelle est la différence entre:

private final static int NUMBER = 10;

et

private final int NUMBER = 10;

Les deux sont privateet final, la différence est l' staticattribut.

Ce qui est mieux? Et pourquoi?

En général, staticsignifie «associé au type lui-même, plutôt qu'à une instance du type».

Cela signifie que vous pouvez référencer une variable statique sans avoir jamais créé d'instances du type, et tout code faisant référence à la variable fait exactement référence aux mêmes données. Comparez cela avec une variable d'instance: dans ce cas, il existe une version indépendante de la variable par instance de la classe. Ainsi, par exemple:

Test x = new Test();
Test y = new Test();
x.instanceVariable = 10;
y.instanceVariable = 20;
System.out.println(x.instanceVariable);

imprime 10: y.instanceVariableet x.instanceVariablesont séparés, car xet se yréfèrent à différents objets.

Vous pouvez faire référence à des membres statiques via des références, bien que ce soit une mauvaise idée de le faire. Si nous l'avons fait:

Test x = new Test();
Test y = new Test();
x.staticVariable = 10;
y.staticVariable = 20;
System.out.println(x.staticVariable);

alors cela afficherait 20 - il n'y a qu'une seule variable, pas une par instance. Il aurait été plus clair d'écrire ceci comme:

Test x = new Test();
Test y = new Test();
Test.staticVariable = 10;
Test.staticVariable = 20;
System.out.println(Test.staticVariable);

Cela rend le comportement beaucoup plus évident. Les IDE modernes suggèrent généralement de changer la deuxième liste en troisième.

Il n'y a aucune raison d'avoir une déclaration inline initialisant la valeur comme la suivante, car chaque instance aura sa propre NUMBERmais toujours avec la même valeur (est immuable et initialisée avec un littéral). C'est la même chose que d'avoir une seule final staticvariable pour toutes les instances.

private final int NUMBER = 10;

Par conséquent, s'il ne peut pas changer, il est inutile d'avoir une copie par instance.

Mais, cela a du sens si est initialisé dans un constructeur comme celui-ci:

// No initialization when is declared
private final int number;

public MyClass(int n) {
   // The variable can be assigned in the constructor, but then
   // not modified later.
   number = n;
}

Maintenant, pour chaque instance de MyClass, nous pouvons avoir une valeur différente mais immuable de number.

Pour la finale , il peut être attribué différentes valeurs lors de l'exécution lors de l'initialisation. Par exemple

Class Test{
  public final int a;
}

Test t1  = new Test();
t1.a = 10;
Test t2  = new Test();
t2.a = 20; //fixed

Ainsi, chaque instance a une valeur différente du champ a .

Pour la finale statique , toutes les instances partagent la même valeur et ne peuvent pas être modifiées après la première initialisation.

Class TestStatic{
      public static final int a;
}

TestStatic t1  = new TestStatic();
t1.a = 10;
TestStatic t2  = new TestStatic();
t1.a = 20;   // ERROR, CAN'T BE ALTERED AFTER THE FIRST INITIALIZATION.

Une staticvariable reste en mémoire pendant toute la durée de vie de l'application et est initialisée pendant le chargement de la classe. Une non staticvariable est initialisée à chaque fois que vous construisez un newobjet. Il est généralement préférable d'utiliser:

private static final int NUMBER = 10;

Pourquoi? Cela réduit l'empreinte mémoire par instance. Il est peut-être également favorable aux occurrences de cache. Et cela a juste du sens: staticdevrait être utilisé pour les choses qui sont partagées entre toutes les instances (aka objets) d'un certain type (aka class).

statique signifie "associé à la classe"; sans elle, la variable est associée à chaque instance de la classe. S'il est statique, cela signifie que vous n'en aurez qu'un en mémoire; sinon, vous en aurez un pour chaque instance que vous créez. statique signifie que la variable restera en mémoire aussi longtemps que la classe sera chargée; sans elle, la variable peut être gc'd lorsque son instance l'est.

En lisant les réponses, je n'ai trouvé aucun véritable test qui allait vraiment au fait. Voici mes 2 cents:

public class ConstTest
{

    private final int         value             = 10;
    private static final int  valueStatic       = 20;
    private final File        valueObject       = new File("");
    private static final File valueObjectStatic = new File("");

    public void printAddresses() {


        System.out.println("final int address " +
                ObjectUtils.identityToString(value));
        System.out.println("final static int address " +
                ObjectUtils.identityToString(valueStatic));
        System.out.println("final file address " + 
                ObjectUtils.identityToString(valueObject));
        System.out.println("final static file address " + 
                ObjectUtils.identityToString(valueObjectStatic));
    }


    public static void main(final String args[]) {


        final ConstTest firstObj = new ConstTest();
        final ConstTest sndObj = new ConstTest();

        firstObj.printAdresses();
        sndObj.printAdresses();
    }

}

Résultats pour le premier objet:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@6c22c95b
final static file address java.io.File@5fd1acd3

Résultats pour le 2ème objet:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@3ea981ca
final static file address java.io.File@5fd1acd3

Conclusion :

Comme je le pensais, java fait une différence entre les types primitifs et les autres. Les types primitifs en Java sont toujours "mis en cache", de même pour les chaînes de caractères littéraux (pas les nouveaux objets String), donc aucune différence entre les membres statiques et non statiques.

Cependant, il existe une duplication de mémoire pour les membres non statiques s'ils ne sont pas des instances de type primitif.

Changer la valeur de valueStatic à 10 ira même plus loin car Java donnera les mêmes adresses aux deux variables int.

Bien que les autres réponses semblent indiquer clairement qu'il n'y a généralement aucune raison d'utiliser des constantes non statiques, je n'ai trouvé personne soulignant qu'il est possible d'avoir diverses instances avec des valeurs différentes sur leurs variables constantes.

Prenons l'exemple suivant:

public class TestClass {
    private final static double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

La création de trois instances de TestClass imprimerait la même valeur aléatoire trois fois, car une seule valeur est générée et stockée dans la constante statique.

Cependant, lorsque vous essayez plutôt l'exemple suivant:

public class TestClass {
    private final double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

La création de trois instances de TestClass afficherait désormais trois valeurs aléatoires différentes, car chaque instance a sa propre valeur constante générée de manière aléatoire.

Je ne peux penser à aucune situation où il serait vraiment utile d'avoir différentes valeurs constantes sur différentes instances, mais j'espère que cela aidera à souligner qu'il y a une nette différence entre les finales statiques et non statiques.

Comme Jon l'a déjà dit, une variable statique, également appelée variable de classe, est une variable qui existe entre les instances d'une classe.

J'en ai trouvé un exemple ici :

public class StaticVariable
{
  static int noOfInstances;
  StaticVariable()
  {
    noOfInstances++;
  }
  public static void main(String[] args)
  {
    StaticVariable sv1 = new StaticVariable();
    System.out.println("No. of instances for sv1 : " + sv1.noOfInstances);

    StaticVariable sv2 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for st2 : "  + sv2.noOfInstances);

    StaticVariable sv3 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for sv2 : "  + sv2.noOfInstances);
    System.out.println("No. of instances for sv3 : "  + sv3.noOfInstances);
  }
}

Les résultats du programme sont donnés ci-dessous:

Comme nous pouvons le voir dans cet exemple, chaque objet a sa propre copie de la variable de classe.

C:\java>java StaticVariable
No. of instances for sv1 : 1
No. of instances for sv1 : 2
No. of instances for st2 : 2
No. of instances for sv1 : 3
No. of instances for sv2 : 3
No. of instances for sv3 : 3

D'après les tests que j'ai faits, les variables finales statiques ne sont pas les mêmes que les variables finales (non statiques)! Les variables finales (non statiques) peuvent différer d'un objet à l'autre !!! Mais ce n'est que si l'initialisation est faite dans le constructeur! (S'il n'est pas initialisé à partir du constructeur, ce n'est qu'un gaspillage de mémoire car il crée des variables finales pour chaque objet créé qui ne peut pas être modifié.)

Par exemple:

class A
{
    final int f;
    static final int sf = 5;

    A(int num)
    {
        this.f = num;
    }

    void show()
    {
        System.out.printf("About Object: %s\n Final: %d\n Static Final: %d\n\n", this.toString(), this.f, sf);
    }

    public static void main(String[] args)
    {
        A ob1 = new A(14);
        ob1.show();

        A ob2 = new A(21);
        ob2.show();

    }
}

Ce qui apparaît à l'écran est:

A propos de l'objet: A @ addbf1 Finale: 14 Finale statique: 5

A propos de l'objet: A @ 530daa Finale: 21 Finale statique: 5

Étudiant anonyme de 1ère année en informatique, Grèce

En plus de la réponse de Jon si vous utilisez une finale statique, elle se comportera comme une sorte de "définition". Une fois que vous avez compilé la classe qui l'utilise, elle sera dans le fichier compilé .class brûlé. Consultez mon fil à ce sujet ici .

Pour votre objectif principal: si vous n'utilisez pas le NUMÉRO différemment dans les différentes instances de la classe, je vous conseille d'utiliser final et statique. (Vous devez juste garder à l'esprit de ne pas copier les fichiers de classe compilés sans tenir compte des problèmes possibles comme celui décrit dans mon étude de cas. La plupart des cas, cela ne se produit pas, ne vous inquiétez pas :))

Pour vous montrer comment utiliser différentes valeurs dans les instances, vérifiez ce code:

public class JustFinalAttr {
  public final int Number;

  public JustFinalAttr(int a){
    Number=a;
  }
}

...System.out.println(new JustFinalAttr(4).Number);

Voici mes deux cents:

final           String CENT_1 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";
final   static  String CENT_2 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";

Exemple:

package test;

public class Test {

    final long OBJECT_ID = new Random().nextLong();
    final static long CLASSS_ID = new Random().nextLong();

    public static void main(String[] args) {
        Test[] test = new Test[5];
        for (int i = 0; i < test.length; i++){
            test[i] = new Test();
            System.out.println("Class id: "+test[i].CLASSS_ID);//<- Always the same value
            System.out.println("Object id: "+test[i].OBJECT_ID);//<- Always different
        }
    }
}

La clé est que les variables et les fonctions peuvent renvoyer des valeurs différentes.Par conséquent, les variables finales peuvent être affectées avec des valeurs différentes.

Juste un autre exemple simple pour comprendre l'utilisation des variables statiques, statiques finales, finales. Les commentaires de code ont l'explication appropriée.

public class City {

    // base price that is always same for all objects[For all cities].
    private static double iphone_base_price = 10000;

    // this is total price = iphone_base_price+iphone_diff;
    private double iphone_citi_price;

    // extra price added to iphone_base_price. It is constant per city. Every
    // city has its own difference defined,
    private final double iphone_diff;

    private String cityName = "";

    // static final will be accessible everywhere within the class but cant be
    // changed once initialized.
    private static final String countryName = "India";

    public City(String cityName, double iphone_diff) {
        super();
        this.iphone_diff = iphone_diff;
        iphone_citi_price = iphone_base_price + iphone_diff;
        this.cityName = cityName;

    }

    /**
     * get phone price
     * 
     * @return
     */
    private double getPrice() {

        return iphone_citi_price;
    }

    /**
     * Get city name
     * 
     * @return
     */
    private String getCityName() {

        return cityName;
    }

    public static void main(String[] args) {

        // 300 is the
        City newyork = new City("Newyork", 300);
        System.out.println(newyork.getPrice() + "  " + newyork.getCityName());

        City california = new City("California", 800);
        System.out.println(california.getPrice() + "  " + california.getCityName());

        // We cant write below statement as a final variable can not be
        // reassigned
        // california.iphone_diff=1000; //************************

        // base price is defined for a class and not per instances.
        // For any number of object creation, static variable's value would be the same
        // for all instances until and unless changed.
        // Also it is accessible anywhere inside a class.
        iphone_base_price = 9000;

        City delhi = new City("delhi", 400);
        System.out.println(delhi.getPrice() + "  " + delhi.getCityName());

        City moscow = new City("delhi", 500);
        System.out.println(moscow.getPrice() + "  " + moscow.getCityName());

        // Here countryName is accessible as it is static but we can not change it as it is final as well. 
        //Something are meant to be accessible with no permission to modify it. 
        //Try un-commenting below statements
        System.out.println(countryName);

        // countryName="INDIA";
        // System.out.println(countryName);

    }

}

très peu et statique

Il n'y a pas beaucoup de différence car ce sont deux constantes. Pour la plupart des objets de données de classe, statique signifierait quelque chose associé à la classe elle-même, il n'y a qu'une seule copie, peu importe le nombre d'objets créés avec new.

Puisqu'il s'agit d'une constante, elle peut ne pas être réellement stockée dans la classe ou dans une instance, mais le compilateur ne vous permettra toujours pas d'accéder aux objets d'instance à partir d'une méthode statique, même s'il sait ce qu'ils seraient. L'existence de l'API de réflexion peut également nécessiter un travail inutile si vous ne la rendez pas statique.

Puisqu'une variable dans une classe est déclarée comme finale ET initialisée dans la même commande, il n'y a absolument aucune raison de ne pas la déclarer comme statique, car elle aura la même valeur quelle que soit l'instance. Ainsi, toutes les instances peuvent partager la même adresse mémoire pour une valeur, économisant ainsi du temps de traitement en éliminant le besoin de créer une nouvelle variable pour chaque instance et en économisant de la mémoire en partageant 1 adresse commune.

La finale statique privée sera considérée comme constante et la constante n'est accessible que dans cette classe. Depuis, le mot-clé statique inclus, la valeur sera constante pour tous les objets de la classe.

la valeur de la variable finale privée sera comme constante par objet.

Vous pouvez faire référence à java.lang.String ou rechercher l'exemple ci-dessous.

public final class Foo
{

    private final int i;
    private static final int j=20;

    public Foo(int val){
        this.i=val;
    }

    public static void main(String[] args) {
        Foo foo1= new Foo(10);

        Foo foo2= new Foo(40);

        System.out.println(foo1.i);
        System.out.println(foo2.i);
        System.out.println(check.j);
    }
}

//Production:

10
40
20

Le statique est le même membre sur toutes les instances de classe et la classe elle-même.
Le non statique est un pour chaque instance (objet), donc dans votre cas précis, c'est un gaspillage de mémoire si vous ne mettez pas de statique.

Si vous marquez cette variable comme statique, comme vous le savez, vous aurez besoin de méthodes statiques pour accéder à nouveau à ces valeurs, cela sera utile si vous pensez déjà à utiliser ces variables uniquement dans des méthodes statiques. S'il en est ainsi, ce serait le meilleur.

Vous pouvez cependant rendre la variable maintenant publique car personne ne peut la modifier comme "System.out", cela dépend encore une fois de vos intentions et de ce que vous voulez réaliser.

Disons que si la classe n'aura jamais plus d'une instance, alors laquelle prendra plus de mémoire:

ID int statique final privé = 250; ou ID int. final privé = 250;

J'ai compris que statique fera référence au type de classe avec une seule copie en mémoire et non statique sera dans un nouvel emplacement mémoire pour chaque variable d'instance. Cependant, en interne, si nous comparons une seule instance de la même classe (c'est-à-dire que plus d'une instance ne serait pas créée), y a-t-il des frais généraux en termes d'espace utilisé par 1 variable finale statique?

La variable statique appartient à la classe (ce qui signifie que tous les objets partagent cette variable). La variable non statique appartient à chaque objet.

public class ExperimentFinal {

private final int a;
private static final int b = 999; 

public ExperimentFinal(int a) {
    super();
    this.a = a;
}
public int getA() {
    return a;
}
public int getB() {
    return b;
}
public void print(int a, int b) {
    System.out.println("final int: " + a + " \nstatic final int: " + b);
}
public static void main(String[] args) {
    ExperimentFinal test = new ExperimentFinal(9);
    test.print(test.getA(), test.getB());
} }

Comme vous pouvez le voir ci-dessus, pour "final int" nous pouvons assigner notre variable pour chaque instance (objet) de la classe, cependant pour "static final int", nous devons assigner une variable dans la classe (la variable statique appartient à la classe ).

Si vous utilisez statique, la valeur de la variable sera la même dans toutes vos instances, si elle est modifiée dans une instance, les autres changeront également.

Final: Une fois qu'une variable finale a été affectée, elle contient toujours la même valeur. partout où la variable est statique ou non statique: ce ne sera qu'une variable pour toutes les instances initialisées une fois en mémoire

Cela pourrait aider

public class LengthDemo {
public static void main(String[] args) {
    Rectangle box = new Rectangle();
    System.out.println("Sending the value 10.0 "
            + "to the setLength method.");
    box.setLength(10.0);
    System.out.println("Done.");
    }
}

Le mot clé "statique" crée la propriété variable de la classe plutôt que des instances individuelles de la classe. Il y aura une copie de cette variable qui sera partagée entre toutes les instances de cette classe. Tout changement dans l'état de la variable statique sera répercuté sur toutes les instances. Ajoutez final à static et nous obtenons une variable qui a été initialisée une fois pour toutes au moment du chargement de la classe et qui ne peut être modifiée ultérieurement par aucune instance de la classe. Les variables finales statiques doivent être initialisées au moment de la déclaration, sinon nous avons une erreur de temps de compilation. En ce qui concerne le champ d'instance privé, il se réfère à la propriété / état d'un objet / instance d'une classe. Chaque instance / objet de la classe aura sa propre copie de la variable d'instance. Lorsque la variable d'instance est déclarée finale, cela signifie que nous ne pouvons pas modifier sa valeur pour cette instance. Pour cela, nous devons initialiser la variable finale à la déclaration ou dans le constructeur.Si ce n'est fait dans aucun des deux, l'erreur de compilation s'affichera. Une fois initialisé, si vous essayez de réaffecter une valeur, vous obtiendrez une erreur de temps de compilation. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter des données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. Pour cela, nous devons initialiser la variable finale à la déclaration ou dans le constructeur.Si ce n'est fait dans aucun des deux, l'erreur de compilation s'affichera. Une fois initialisé, si vous essayez de réaffecter une valeur, vous obtiendrez une erreur de temps de compilation. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter des données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. Pour cela, nous devons initialiser la variable finale à la déclaration ou dans le constructeur.Si ce n'est fait dans aucun des deux, l'erreur de compilation s'affichera. Une fois initialisé, si vous essayez de réaffecter une valeur, vous obtiendrez une erreur de temps de compilation. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter des données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. Si ce n'est pas fait dans l'un d'eux, une erreur de temps de compilation s'affichera. Une fois initialisé, si vous essayez de réaffecter une valeur, vous obtiendrez une erreur de temps de compilation. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter des données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. Si ce n'est pas fait dans l'un d'eux, une erreur de temps de compilation s'affichera. Une fois initialisé, si vous essayez de réaffecter une valeur, vous obtiendrez une erreur de temps de compilation. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter des données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter certaines données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. Utilisez des variables finales statiques dans lesquelles les données seront partagées entre toutes les instances de la classe et vous souhaitez que les données soient en lecture seule.Utilisez la variable finale d'instance si vous souhaitez représenter certaines données qui appartiennent à chaque instance individuelle de la classe, mais une fois stockés ne peuvent pas être modifiés. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet. L'utilisation de mots clés statiques et d'instances dépend de vos besoins de conception et de ce que ces données représentent dans le domaine. Si les données sont utilisées dans les instances de classe, il n'est pas nécessaire de disposer de copies / références de mémoire individuelles pour chaque objet.