attribut statique final privé vs attribut final privé


305

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?


62
private final static -> créez cette variable une seule fois. final privé -> créer cette variable pour chaque objet. Tout d'abord, vous économisez de la mémoire, allez-y.
user1923551

4
final staticsignifie que cette variable est une constante et ne s'associe qu'à la classe elle-même, c'est-à-dire "une variable constante par classe" tandis que finalsignifie "une variable constante par instance". Par conséquent, vous ne pouvez pas mettre une final staticvariable dans le constructeur de la classe car le constructeur implique dans une nouvelle instance . (Vous pouvez l'essayer vous-même et vous obtiendrez une erreur)
LittleLittleQ

1
Par "ne peut pas mettre une variable statique finale dans le constructeur de la classe", je veux dire qu'on ne peut pas initialiser une final staticvariable dans le constructeur, la seule façon est d'utiliser un initialiseur statique :)
LittleLittleQ

2
@ user1923551 L'effet est inversé pour les éléments qui ne sont nécessaires que pendant une durée limitée dans les grandes applications, dans les applications à mémoire limitée ou lors de l'utilisation d'un singleton. Avoir des choses statiques dans chaque classe réservera un (énorme) morceau de mémoire pour les choses qui ne sont pas nécessaires. Il peut également s'agir d'une fuite de mémoire pour déclarer des objets ou des collections finales statiques.
Espérons que ce sera

Réponses:


309

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.


10
Jusqu'à ce que les énumérations soient disponibles dans Java 5, la finale statique était la manière habituelle de déclarer des constantes.
Vineet Reynolds

22
@Vineet: les finales statiques sont toujours le moyen de déclarer des constantes primitives, sauf si vous en avez un nombre énuméré =)
Chii

@Matthew: Potentiellement. Pas pour une constante, mais pour une valeur liée à une instance logique. Pas que j'aime beaucoup les singletons de toute façon.
Jon Skeet

1
Une question radicale. Vaut-il la peine d'utiliser private finalplus private static finalpour extraire / récupérer ce peu de mémoire de la classe? Disons pour le calculatorpériphérique avec un ram limité mais beaucoup de ressources CPU.
Gagnez Myo Htet le

1
@WinMyoHtet: Si vous utilisez un champ statique, il n'y a que l' un au total. Si vous utilisez un champ d'instance, il y en a un par instance. L'utilisation d'un champ statique va être meilleure à moins que vous n'ayez aucune instance, auquel cas elle est de toute façon inutile.
Jon Skeet

38

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.

90
Cela ne se compilera pas! Une variable finale doit soit recevoir une valeur, soit avoir une valeur assignée dans ses constructeurs. Cette réponse serait correcte si 2 constructeurs étaient donnés, chacun attribuant «a» à une valeur différente.
MattC

14
Confirmant, cela ne se compilera pas. Comme indiqué ci-dessus, les variables d'instance finales doivent être instanciées avant la fin du constructeur et les variables de classe finales doivent être instanciées avant la création de la classe (vous pouvez utiliser un bloc statique). Pourquoi cela a-t-il eu autant de votes positifs?
Rudi Kershaw

comme MattC l'a souligné, vous ne pouvez pas attribuer à une variable finale après avoir créé cet objet - en fait, vous ne pouvez même pas créer un objet sans donner des valeurs à ses variables finales ...
jamesdeath123

Juste au cas où quelqu'un trébucherait à ce sujet, veuillez suivre la réponse de MattC.
Faz

C'est ce que je pense que le PO demandait, j'avais oublié que les finales peuvent se voir attribuer une valeur à l'instanciation si elle n'était pas fournie lors de la déclaration.
Salsero69

34

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).


une variable statique est également créée lors de l'exécution. Par conséquent, vous pouvez utiliser ladite variable ou méthode avant la création de l'objet.
bobby

13
Par convention de codage Java, le nom d'une variable finale statique doit être entièrement en majuscules.
starblue

@Martijn Courteaux, que diriez-vous d'une situation où une classe sera utilisée une fois pendant la durée de vie de l'application! private final intsera supprimé de la mémoire lorsque l'instance sera GC'ed alors private static final intqu'il restera en mémoire pendant toute la durée de vie de cette application. Que proposez-vous dans le scénario ci-dessus?
MANN

@MANN: C'est très théorique. Il n'y a littéralement aucun scénario de cas d'utilisation utile pour cela. Cela pourrait être bénéfique si vous avez comme 50000 vars int dans une classe. Même dans ce cas, cela économiserait jusqu'à 200 Ko de mémoire. Puisque nous parlons de Java, cela semble totalement hors de propos. Dans le cas de périphériques critiques en mémoire, un compilateur C ou C ++ décent alignerait toujours ces valeurs entières, éliminant ainsi le besoin de libérer complètement de la mémoire.
Martijn Courteaux

17

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.


Les variables d'instance sont gcdées à chaque fois que toutes les références / objets y meurent, non?
Ruchir Baronia

Les instances sont gc'd, mais les statiques sont associées aux classes, pas aux instances. Tant que la classe reste en mémoire, vous pourrez vous référer à ses instances et méthodes statiques publiques. Celles-ci vont dans perm gen (ou quel que soit son équivalent JDK 8) et ne sont pas gc'd.
duffymo

Faux. Si vous avez une référence à une instance en mémoire, vous pouvez accéder à ses méthodes et instances disponibles. Le reste est faux. Vous ne comprenez pas la différence entre une classe et ses instances.
duffymo

13

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.


2
Autoboxing du 'int' -> Entier crée de la confusion ici. Vous voyez que l'autoboxing de certaines (petites) valeurs int conduit au même objet Integer.
dkneller

@StackHola @dkneller En effet, l'autoboxing est un détail très important qui se produit ici. La signature est ObjectUtils.identityToString(Object). (De plus, Java n'a aucun passage par référence de toute façon). Un véritable test utile serait d'allouer deux objets et de modifier la valeur d'une public final int FOO = 10variable à l'aide de réflexions Java de manière forcée. Vérifiez ensuite si l'autre objet a également changé sa valeur.
Martijn Courteaux le

11

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.


2

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

2

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


ceci n'est pas une réponse :(
Sanjaya Pandey

2

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);

J'avais un lien ici pour une comparaison détaillée. Je suis désolé les gars, cela a été modéré je suppose.
BlondCode

Le lien est de retour. Un éditeur l'avait retiré comme mort. Il semble être en direct maintenant.
Erick G.Hagstrom

2

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.


Pourriez-vous expliquer ce qui est le mieux et pourquoi?
Daniel

2

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);

    }

}

1

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.


1

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.


1

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

0

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.


0

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.


1
Les méthodes statiques ne seraient pas nécessaires pour accéder aux variables statiques - je pense que vous pensez à "accéder aux variables d'instance à partir des méthodes statiques" (non autorisé).
ataulm

0

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?


1
Veuillez ne pas répéter ce que les autres réponses ont déjà couvert.
utilisateur inconnu

0

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 ).


0

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.


0

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


-1

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.");
    }
}

1
sûr que c'est une réponse à cette question?
mikus

-2

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.