attributo statico finale privato vs attributo finale privato

In Java, qual è la differenza tra:

private final static int NUMBER = 10;

e

private final int NUMBER = 10;

Entrambi sono privatee final, la differenza è l' staticattributo.

Cosa c'è di meglio? E perché?

In generale, staticsignifica "associato al tipo stesso, anziché a un'istanza del tipo".

Ciò significa che è possibile fare riferimento a una variabile statica senza aver mai creato un'istanza del tipo e qualsiasi codice che si riferisce alla variabile si riferisce agli stessi stessi dati. Confronta questo con una variabile di istanza: in tal caso, esiste una versione indipendente della variabile per istanza della classe. Quindi per esempio:

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

stampa 10: y.instanceVariablee x.instanceVariablesono separati, perché xe si yriferiscono a oggetti diversi.

Puoi fare riferimento a membri statici tramite riferimenti, anche se è una cattiva idea farlo. Se facessimo:

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

quindi verrebbero stampati 20 - c'è solo una variabile, non una per istanza. Sarebbe stato più chiaro scrivere questo come:

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

Ciò rende il comportamento molto più evidente. Gli IDE moderni di solito suggeriranno di cambiare il secondo elenco nel terzo.

Non c'è motivo di avere una dichiarazione in linea che inizializzi il valore come il seguente, poiché ogni istanza avrà il proprio NUMBERma sempre con lo stesso valore (è immutabile e inizializzata con un valore letterale). È lo stesso che avere una sola final staticvariabile per tutte le istanze.

private final int NUMBER = 10;

Pertanto, se non può cambiare, non ha senso avere una copia per istanza.

Ma ha senso se viene inizializzato in un costruttore come questo:

// 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;
}

Ora, per ogni istanza di MyClass, possiamo avere un valore diverso ma immutabile di number.

Per il finale , può essere assegnato diversi valori in fase di esecuzione quando inizializzato. Per esempio

Class Test{
  public final int a;
}

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

Pertanto ogni istanza ha un valore diverso del campo a .

Per il finale statico , tutte le istanze condividono lo stesso valore e non possono essere modificate dopo la prima inizializzazione.

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.

Una staticvariabile rimane in memoria per l'intera durata dell'applicazione e viene inizializzata durante il caricamento della classe. Una non staticvariabile viene inizializzata ogni volta che si costruisce un newoggetto. È generalmente meglio usare:

private static final int NUMBER = 10;

Perché? Ciò riduce il footprint di memoria per istanza. Probabilmente è anche favorevole per gli hit della cache. E ha senso: staticdovrebbe essere usato per cose condivise tra tutte le istanze (aka oggetti) di un certo tipo (aka class).

statico significa "associato alla classe"; senza di essa, la variabile è associata a ciascuna istanza della classe. Se è statico, significa che ne avrai solo uno in memoria; in caso contrario, ne avrai uno per ogni istanza che crei. statico significa che la variabile rimarrà in memoria fino a quando la classe sarà caricata; senza di essa, la variabile può essere gc'd quando è la sua istanza.

Leggendo le risposte non ho trovato alcun vero test davvero arrivare al punto. Ecco i miei 2 centesimi:

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

}

Risultati per il primo oggetto:

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

Risultati per il 2o oggetto:

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

Conclusione :

Come pensavo, Java fa la differenza tra primitivi e altri tipi. I tipi primitivi in ​​Java sono sempre "memorizzati nella cache", lo stesso per i letterali di stringhe (non i nuovi oggetti String), quindi nessuna differenza tra membri statici e non statici.

Tuttavia, esiste una duplicazione di memoria per i membri non statici se non sono istanze di tipo primitivo.

La modifica del valore di value Statico su 10 andrà anche oltre, poiché Java fornirà gli stessi indirizzi alle due variabili int.

Mentre le altre risposte sembrano chiarire che in genere non esiste alcun motivo per utilizzare costanti non statiche, non sono riuscito a trovare nessuno sottolineando che è possibile avere varie istanze con valori diversi sulle loro variabili costanti.

Considera il seguente esempio:

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

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

La creazione di tre istanze di TestClass stamperebbe tre volte lo stesso valore casuale, poiché un solo valore viene generato e memorizzato nella costante statica.

Tuttavia, quando provi invece il seguente esempio:

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

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

La creazione di tre istanze di TestClass ora stamperebbe tre diversi valori casuali, poiché ogni istanza ha il proprio valore costante generato casualmente.

Non riesco a pensare a nessuna situazione in cui sarebbe davvero utile avere valori costanti diversi su istanze diverse, ma spero che questo aiuti a sottolineare che esiste una chiara differenza tra finali statiche e non statiche.

Come già detto Jon, una variabile statica, definita anche variabile di classe, è una variabile che esiste tra le istanze di una classe.

Ho trovato un esempio di questo qui :

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

L'output del programma è riportato di seguito:

Come possiamo vedere in questo esempio, ogni oggetto ha la sua copia della variabile di 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

Dai test che ho effettuato, le variabili finali statiche non sono le stesse delle variabili finali (non statiche)! Le variabili finali (non statiche) possono differire da oggetto a oggetto !!! Ma questo è solo se l'inizializzazione viene effettuata all'interno del costruttore! (Se non è inizializzato dal costruttore, è solo uno spreco di memoria in quanto crea variabili finali per ogni oggetto creato che non può essere modificato.)

Per esempio:

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

    }
}

Ciò che appare sullo schermo è:

Informazioni sull'oggetto: A @ addbf1 Finale: 14 Finale statico: 5

Informazioni sull'oggetto: A @ 530daa Final: 21 Statico Final: 5

Studente informatico anonimo del 1 ° anno, Grecia

Inoltre, alla risposta di Jon, se usi un finale statico, si comporterà come una sorta di "definizione". Una volta compilata la classe che la utilizza, sarà nel file .class compilato bruciato. Controllare il mio thread su di esso qui .

Per il tuo obiettivo principale: se non usi NUMBER in modo diverso nelle diverse istanze della classe, ti consiglio di usare final e static. (Devi solo tenere a mente di non copiare i file di classe compilati senza considerare possibili problemi come quello che descrive il mio caso di studio. La maggior parte dei casi non si verifica, non ti preoccupare :))

Per mostrarti come usare valori diversi nelle istanze controlla questo codice:

public class JustFinalAttr {
  public final int Number;

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

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

Ecco i miei due centesimi:

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

Esempio:

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 chiave è che le variabili e le funzioni possono restituire valori diversi, pertanto le variabili finali possono essere assegnate con valori diversi.

Solo un altro semplice esempio per capire l'uso di variabili finali statiche, statiche, finali. I commenti sul codice hanno la spiegazione corretta.

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

    }

}

molto poco e statico

Non c'è molta differenza in quanto sono entrambe costanti. Per la maggior parte degli oggetti dati di classe, statico significherebbe qualcosa associato alla classe stessa, essendo presente una sola copia, indipendentemente dal numero di oggetti creati con nuovi.

Poiché è una costante, potrebbe non essere effettivamente memorizzata nella classe o in un'istanza, ma il compilatore non ti consentirà comunque di accedere agli oggetti di istanza da un metodo statico, anche se sa quali sarebbero. L'esistenza dell'API di riflessione potrebbe anche richiedere del lavoro inutile se non lo si rende statico.

Poiché una variabile in una classe viene dichiarata come definitiva E inizializzata nello stesso comando, non vi è assolutamente alcun motivo per non dichiararla come statica, poiché avrà lo stesso valore indipendentemente dall'istanza. Pertanto, tutte le istanze possono condividere lo stesso indirizzo di memoria per un valore, risparmiando così tempo di elaborazione eliminando la necessità di creare una nuova variabile per ogni istanza e risparmiando memoria condividendo 1 indirizzo comune.

il finale statico privato sarà considerato costante e sarà possibile accedere alla costante solo all'interno di questa classe. Poiché, inclusa la parola chiave static, il valore sarà costante per tutti gli oggetti della classe.

il valore della variabile finale privata sarà come costante per oggetto.

Puoi fare riferimento a java.lang.String o cercare l'esempio di seguito.

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

//Produzione:

10
40
20

Quello statico è lo stesso membro su tutte le istanze della classe e sulla classe stessa.
Il non statico è uno per ogni istanza (oggetto), quindi nel tuo caso esatto è uno spreco di memoria se non metti statico.

Se si contrassegna questa variabile come statica, quindi, come noto, occorrerebbero metodi statici per accedere nuovamente a questi valori, ciò sarà utile se si pensa già di utilizzare queste variabili solo in metodi statici. Se è così, questo sarebbe il migliore.

Puoi comunque rendere la variabile ora pubblica poiché nessuno può modificarla come "System.out", dipende ancora dalle tue intenzioni e da ciò che vuoi ottenere.

Diciamo se la classe non avrà mai più di un'istanza, quindi quale occuperà più memoria:

ID int finale privato statico = 250; o ID int finale privato = 250;

Ho capito che static farà riferimento al tipo di classe con una sola copia in memoria e non static sarà in una nuova posizione di memoria per ogni variabile di istanza. Tuttavia internamente se confrontiamo mai 1 istanza della stessa classe di sempre (cioè non si creerebbe più di 1 istanza), allora c'è un sovraccarico in termini di spazio utilizzato da 1 variabile finale statica?

La variabile statica appartiene alla classe (il che significa che tutti gli oggetti condividono quella variabile). La variabile non statica appartiene a ciascun oggetto.

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

Come puoi vedere nell'esempio sopra, per "int finale" possiamo assegnare la nostra variabile per ogni istanza (oggetto) della classe, tuttavia per "int finale statico", dovremmo assegnare una variabile nella classe (la variabile statica appartiene alla classe ).

Se si utilizza static, il valore della variabile sarà lo stesso in tutte le istanze, se modificato in un'istanza anche le altre cambieranno.

Finale: una volta assegnata una variabile finale, contiene sempre lo stesso valore. ovunque la variabile sia statica o non statica: sarà solo una variabile per tutte le istanze inizializzate una volta in memoria

Questo potrebbe aiutare

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

La parola chiave "statica" rende la proprietà variabile della classe anziché singole istanze della classe. Ci sarà una copia di quella variabile condivisa tra tutte le istanze di quella classe. Qualsiasi cambiamento nello stato della variabile statica si rifletterà su tutte le istanze. Aggiungi final a static e otteniamo una variabile che è stata inizializzata una volta per tutte al momento del caricamento della classe e che non può essere modificata in seguito da nessuna istanza della classe. Le variabili finali statiche devono essere inizializzate al momento della dichiarazione, altrimenti abbiamo un errore di tempo di compilazione. Per quanto riguarda il campo dell'istanza privata, si riferisce alla proprietà / stato di un oggetto / istanza di una classe. Ogni istanza / oggetto della classe avrà la propria copia della variabile di istanza. Quando la variabile di istanza viene dichiarata finale, significa che non possiamo cambiare il suo valore per questa istanza. Per questo abbiamo bisogno di inizializzare la variabile finale o alla dichiarazione o nel costruttore. Se non viene fatto in nessuna di esse, verrà mostrato l'errore di compilazione. Una volta inizializzato, se si tenta di riassegnare un valore si otterrà un errore di tempo di compilazione. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. Per questo abbiamo bisogno di inizializzare la variabile finale o alla dichiarazione o nel costruttore. Se non viene fatto in nessuna di esse, verrà mostrato l'errore di compilazione. Una volta inizializzato, se si tenta di riassegnare un valore si otterrà un errore di tempo di compilazione. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. Per questo abbiamo bisogno di inizializzare la variabile finale o alla dichiarazione o nel costruttore. Se non viene fatto in nessuna di esse, verrà mostrato l'errore di compilazione. Una volta inizializzato, se si tenta di riassegnare un valore si otterrà un errore di tempo di compilazione. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. Se non viene eseguito in nessuno dei due, verrà visualizzato l'errore di compilazione. Una volta inizializzato, se si tenta di riassegnare un valore si otterrà un errore di tempo di compilazione. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. Se non viene eseguito in nessuno dei due, verrà visualizzato l'errore di compilazione. Una volta inizializzato, se si tenta di riassegnare un valore si otterrà un errore di tempo di compilazione. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. Utilizzare variabili finali statiche in cui i dati verranno condivisi tra tutte le istanze della classe e si desidera che i dati siano di sola lettura. Utilizzare la variabile finale dell'istanza se si desidera rappresentare alcuni dati che appartengono a ciascuna singola istanza della classe ma una volta memorizzato non può essere modificato. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto. L'uso di parole chiave statiche e di istanza dipende dalle esigenze di progettazione e da ciò che tali dati rappresentano nel dominio. Se i dati vengono utilizzati tra le istanze della classe, non sono necessari riferimenti singoli di copie / memoria per ciascun oggetto.