atributo estático final privado vs atributo final privado

En Java, ¿cuál es la diferencia entre:

private final static int NUMBER = 10;

y

private final int NUMBER = 10;

Ambos son privatey final, la diferencia es el staticatributo.

¿Que es mejor? ¿Y por qué?

En general, staticsignifica "asociado con el tipo en sí mismo, en lugar de una instancia del tipo".

Eso significa que puede hacer referencia a una variable estática sin haber creado instancias del tipo, y cualquier código que se refiera a la variable se refiere a los mismos datos exactos. Compare esto con una variable de instancia: en ese caso, hay una versión independiente de la variable por instancia de la clase. Así por ejemplo:

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

imprime 10: y.instanceVariableyx.instanceVariable están separados, porque xy se yrefieren a diferentes objetos.

Usted puede referencia a miembros estáticos a través de referencias, aunque es una mala idea hacerlo. Si lo hiciéramos:

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

entonces eso imprimiría 20: solo hay una variable, no una por instancia. Hubiera sido más claro escribir esto como:

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

Eso hace que el comportamiento sea mucho más obvio. Los IDEs modernos generalmente sugerirán cambiar la segunda lista a la tercera.

No hay ninguna razón para tener una declaración en línea que inicialice el valor de la siguiente manera, ya que cada instancia tendrá la suya NUMBERpero siempre con el mismo valor (es inmutable e inicializada con un literal). Es lo mismo que tener solo una final staticvariable para todas las instancias.

private final int NUMBER = 10;

Por lo tanto, si no puede cambiar, no tiene sentido tener una copia por instancia.

Pero, tiene sentido si se inicializa en un constructor como este:

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

Ahora, para cada instancia de MyClass, podemos tener un valor diferente pero inmutable de number.

Para finalizar , se le pueden asignar diferentes valores en tiempo de ejecución cuando se inicializa. Por ejemplo

Class Test{
  public final int a;
}

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

Por lo tanto, cada instancia tiene un valor diferente del campo a .

Para la final estática , todas las instancias comparten el mismo valor y no pueden modificarse después de la primera inicialización.

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 staticvariable permanece en la memoria durante toda la vida útil de la aplicación y se inicializa durante la carga de clases. Una staticvariable no se inicializa cada vez que construye un newobjeto. Generalmente es mejor usar:

private static final int NUMBER = 10;

¿Por qué? Esto reduce la huella de memoria por instancia. Posiblemente también sea favorable para los éxitos de caché. Y tiene sentido: staticdebe usarse para cosas que se comparten en todas las instancias (también conocidas como objetos) de cierto tipo (también conocido como class).

estático significa "asociado con la clase"; sin ella, la variable está asociada con cada instancia de la clase. Si es estático, eso significa que solo tendrá uno en la memoria; si no, tendrá uno para cada instancia que cree. static significa que la variable permanecerá en la memoria mientras se cargue la clase; sin ella, la variable puede ser gc cuando su instancia es.

Leyendo las respuestas no encontré ninguna prueba real que realmente llegara al punto. Aquí están mis 2 centavos:

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

}

Resultados para el primer objeto:

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

Resultados para el segundo objeto:

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

Conclusión

Como pensé, Java hace la diferencia entre primitivos y otros tipos. Los tipos primitivos en Java siempre están "almacenados en caché", lo mismo para cadenas literales (no nuevos objetos de cadena), por lo que no hay diferencia entre miembros estáticos y no estáticos.

Sin embargo, hay una duplicación de memoria para miembros no estáticos si no son instancias de un tipo primitivo.

Cambiar el valor de valueStatic a 10 incluso irá más allá, ya que Java dará las mismas direcciones a las dos variables int.

Si bien las otras respuestas parecen dejar bastante claro que generalmente no hay razón para usar constantes no estáticas, no pude encontrar a nadie señalando que es posible tener varias instancias con diferentes valores en sus variables constantes.

Considere el siguiente ejemplo:

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

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

La creación de tres instancias de TestClass imprimiría el mismo valor aleatorio tres veces, ya que solo se genera un valor y se almacena en la constante estática.

Sin embargo, al intentar el siguiente ejemplo en su lugar:

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

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

Crear tres instancias de TestClass ahora imprimiría tres valores aleatorios diferentes, porque cada instancia tiene su propio valor constante generado aleatoriamente.

No puedo pensar en ninguna situación en la que sería realmente útil tener diferentes valores constantes en diferentes instancias, pero espero que esto ayude a señalar que existe una clara diferencia entre las finales estáticas y no estáticas.

Como ya dijo Jon, una variable estática, también conocida como variable de clase, es una variable que existe en todas las instancias de una clase.

Encontré un ejemplo de esto aquí :

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

La salida del programa se da a continuación:

Como podemos ver en este ejemplo, cada objeto tiene su propia copia de la variable de clase.

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

¡De las pruebas que he hecho, las variables finales estáticas no son lo mismo que las variables finales (no estáticas)! ¡Las variables finales (no estáticas) pueden diferir de un objeto a otro! ¡Pero eso es solo si la inicialización se realiza dentro del constructor! (Si no se inicializa desde el constructor, entonces es solo un desperdicio de memoria, ya que crea variables finales para cada objeto que se crea que no se puede alterar).

Por ejemplo:

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

    }
}

Lo que aparece en la pantalla es:

Acerca del objeto: A @ addbf1 Final: 14 Final estático: 5

Acerca del objeto: A @ 530daa Final: 21 Final estático: 5

Estudiante anónimo de 1er año de TI, Grecia

Además de la respuesta de Jon, si usa static final, se comportará como una especie de "definición". Una vez que compila la clase que la usa, estará en el archivo compilado .class quemado. Mira mi hilo al respecto aquí .

Para su objetivo principal: si no usa el NÚMERO de manera diferente en las diferentes instancias de la clase, le aconsejaría que use el final y el estático. (Solo debe tener en cuenta que no debe copiar archivos de clase compilados sin considerar posibles problemas como el que describe mi estudio de caso. La mayoría de los casos esto no ocurre, no se preocupe :))

Para mostrarle cómo usar diferentes valores en instancias, verifique este código:

public class JustFinalAttr {
  public final int Number;

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

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

Aquí están mis dos centavos:

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

Ejemplo:

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 clave es que las variables y funciones pueden devolver valores diferentes. Por lo tanto, las variables finales pueden asignarse con valores diferentes.

Otro ejemplo simple para entender el uso de variables estáticas, estáticas finales y finales. Los comentarios de código tienen la explicación adecuada.

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

    }

}

muy poco y estático

No hay mucha diferencia ya que ambas son constantes. Para la mayoría de los objetos de datos de clase, estático significaría algo asociado con la clase misma, ya que solo hay una copia, sin importar cuántos objetos se crearon con nuevos.

Como es una constante, es posible que no se almacene en la clase o en una instancia, pero el compilador aún no le permitirá acceder a objetos de instancia desde un método estático, incluso si sabe cuáles serían. La existencia de la API de reflexión también puede requerir un trabajo inútil si no la hace estática.

Dado que una variable en una clase se declara como final Y se inicializa en el mismo comando, no hay absolutamente ninguna razón para no declararla como estática, ya que tendrá el mismo valor sin importar la instancia. Por lo tanto, todas las instancias pueden compartir la misma dirección de memoria para un valor, lo que ahorra tiempo de procesamiento al eliminar la necesidad de crear una nueva variable para cada instancia y ahorrar memoria al compartir 1 dirección común.

El final estático privado se considerará como constante y solo se puede acceder a la constante dentro de esta clase. Dado que, incluida la palabra clave static, el valor será constante para todos los objetos de la clase.

El valor de la variable final privada será como constante por objeto.

Puede consultar java.lang.String o buscar el ejemplo a continuación.

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

//Salida:

10
40
20

El estático es el mismo miembro en todas las instancias de clase y la clase misma.
El no estático es uno para cada instancia (objeto), por lo que en su caso exacto es un desperdicio de memoria si no pone estático.

Si marca esta variable como estática, entonces, como sabe, necesitaría métodos estáticos para acceder nuevamente a estos valores, esto será útil si ya piensa en usar estas variables solo en métodos estáticos. Si esto es así, entonces este sería el mejor.

Sin embargo, ahora puede hacer que la variable sea pública, ya que nadie puede modificarla como "System.out", nuevamente depende de sus intenciones y de lo que desea lograr.

Digamos que si la clase no tendrá más de una instancia, entonces cuál toma más memoria:

ID int final estático privado = 250; o privado int int ID = 250;

He entendido que estática se referirá al tipo de clase con solo una copia en la memoria y no estática estará en una nueva ubicación de memoria para cada variable de instancia. Sin embargo, internamente si solo comparamos 1 instancia de la misma clase (es decir, no se crearía más de 1 instancia), ¿hay alguna sobrecarga en términos de espacio utilizado por 1 variable final estática?

La variable estática pertenece a la clase (lo que significa que todos los objetos comparten esa variable). La variable no estática pertenece a cada objeto.

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

Como puede ver en el ejemplo anterior, para "final int" podemos asignar nuestra variable para cada instancia (objeto) de la clase, sin embargo para "static final int", debemos asignar una variable en la clase (la variable estática pertenece a la clase )

Si usa estática, el valor de la variable será el mismo en todas sus instancias, si se cambia en una instancia, las demás también lo harán.

Final: una vez que se ha asignado una variable final, siempre contiene el mismo valor. donde la variable sea estática o no estática: será solo una variable para todas las instancias inicializadas una vez en la Memoria

Esto puede ayudar

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 palabra clave "Estática" convierte la propiedad variable de la clase en lugar de las instancias individuales de la clase. Habrá una copia de esa variable que se compartirá entre todas las instancias de esa clase. Cualquier cambio en el estado de la variable estática se reflejará en todas las instancias. Agregue final a static y obtenemos una variable que se ha inicializado de una vez por todas en el momento de carga de la clase y que ninguna instancia de la clase puede cambiar más tarde. Las variables finales estáticas deben inicializarse en el momento de la declaración; de lo contrario, tenemos un error de tiempo de compilación. En lo que respecta al campo de instancia privada, se refiere a la propiedad / estado de un objeto / instancia de una clase. Cada instancia / objeto de la clase tendrá su propia copia de la variable de instancia. Cuando la variable de instancia se declara final, significa que no podemos cambiar su valor para esta instancia. Para esto, necesitamos inicializar la variable final ya sea en la declaración o en el constructor. Si no se hace en ninguno de ellos, se mostrará el error de tiempo de compilación. Una vez inicializado, si intenta reasignar un valor, obtendrá un error de tiempo de compilación. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. Para esto, necesitamos inicializar la variable final ya sea en la declaración o en el constructor. Si no se hace en ninguno de ellos, se mostrará el error de tiempo de compilación. Una vez inicializado, si intenta reasignar un valor, obtendrá un error de tiempo de compilación. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. Para esto, necesitamos inicializar la variable final ya sea en la declaración o en el constructor. Si no se hace en ninguno de ellos, se mostrará el error de tiempo de compilación. Una vez inicializado, si intenta reasignar un valor, obtendrá un error de tiempo de compilación. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. Si no se hace en ninguno de ellos, se mostrará el error de tiempo de compilación. Una vez inicializado, si intenta reasignar un valor, obtendrá un error de tiempo de compilación. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. Si no se hace en ninguno de ellos, se mostrará el error de tiempo de compilación. Una vez inicializado, si intenta reasignar un valor, obtendrá un error de tiempo de compilación. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. Utilice variables finales estáticas donde los datos se compartirán en todas las instancias de la clase y desea que los datos sean de solo lectura. Utilice la variable final de instancia si desea representar algunos datos que pertenecen a cada instancia individual de la clase pero una vez almacenado no se puede cambiar. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto. El uso de palabras clave estáticas y de instancia depende de sus necesidades de diseño y de lo que representan esos datos en el dominio. Si los datos se utilizan en las instancias de clase, no hay necesidad de copias individuales / referencias de memoria para cada objeto.