atributo estático final privado vs atributo final privado

305

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é?

RUMANIA_ingeniero
fuente
62
private static static -> crea esta variable solo una vez. final privado -> crea esta variable para cada objeto. Primero se ahorra memoria, anímate.
user1923551
44
final staticsignifica que esta variable es una constante y solo se asocia con la clase misma, es decir, "una variable constante por clase", mientras que finalsignifica "una variable constante por instancia". Como resultado, no puede poner una final staticvariable en el constructor de la clase ya que el constructor involucra una nueva instancia . (Puede probarlo usted mismo y obtendrá un error)
LittleLittleQ
1
Por "no se puede poner una variable estática final en el constructor de la clase" quiero decir que uno no puede inicializar una final staticvariable en el constructor, la única forma es usar un inicializador estático :)
LittleLittleQ
2
@ user1923551 El efecto se invierte para cosas que solo se necesitan durante un tiempo limitado en aplicaciones grandes, en aplicaciones con poca memoria o cuando se usa un singleton. Tener cosas estáticas en cada clase reservará una porción (enorme) de memoria para cosas que no son necesarias. También puede ser una pérdida de memoria declarar objetos finales estáticos o colecciones.
HopefulHelpful

Respuestas:

309

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.

Jon Skeet
fuente
10
Hasta que las enumeraciones estuvieron disponibles en Java 5, el final estático era la forma habitual de declarar constantes.
Vineet Reynolds
22
@Vineet: las finales estáticas siguen siendo la forma de declarar constantes primitivas, a menos que tenga un número enumerado de ellas =)
Chii
@Matthew: Potencialmente. No para una constante, sino para algún valor lógicamente relacionado con la instancia. No es que me gusten los solteros de todos modos.
Jon Skeet
1
Una pregunta radical. ¿Merece la pena utilizar private finalmás private static finalde exprimir / recuperación que poca memoria de la clase? Digamos para el calculatordispositivo con ram limitado pero con muchos recursos de CPU.
Gana Myo Htet el
1
@WinMyoHtet: si usa un campo estático, solo hay uno en total. Si usa un campo de instancia, hay uno por instancia. Usar un campo estático será mejor a menos que no tenga ninguna instancia, en cuyo caso es inútil de todos modos.
Jon Skeet
38

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.
lucas
fuente
90
¡Esto no se compilará! A una variable final se le debe asignar un valor o tener un valor asignado en sus constructores. Esta respuesta sería correcta si se dieran 2 constructores, y cada uno asignara 'a' a un valor diferente.
MattC
14
Confirmando, esto no se compilará. Como se expresó anteriormente, las variables de instancia final deben instanciarse antes de que finalice el constructor, y las variables de clase final deben instanciarse antes de que se haya creado la clase (puede usar un bloque estático). ¿Por qué esto tiene tantos votos a favor?
Rudi Kershaw
mattc como señaló, no se puede asignar a una variable final después de la creación de ese objeto - de hecho, ni siquiera se puede crear un objeto sin dar valores a sus variables finales ...
jamesdeath123
En caso de que alguien tropiece con esto, siga la respuesta de MattC.
Faz
Esto es lo que creo que el OP estaba preguntando, había olvidado que a las finales se les puede asignar un valor en la instanciación si no se proporcionó uno en la declaración.
Salsero69
34

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

Martijn Courteaux
fuente
También se crea una variable estática en tiempo de ejecución. Por lo tanto, puede usar dicha variable o método antes de crear el objeto.
bobby
13
Por convención de codificación de Java, el nombre de una variable final estática debe estar todo en mayúscula.
starblue
@ Martijn Courteaux, ¿qué tal una situación en la que una clase se utilizará una vez durante la vida útil de la aplicación? private final intserá eliminado de la memoria cuando la instancia será GC'ed mientras private static final intque permanecerá en la memoria durante toda la vida útil de esa aplicación. ¿Qué sugieres en el escenario anterior?
MANN
@MANN: Esto es muy teórico. Literalmente no hay un escenario de caso de uso útil para eso. Esto podría ser beneficioso si tiene como 50000 int vars en una clase. Incluso en este caso, esto ahorraría 200kb de memoria. Como estamos hablando de Java, esto parece totalmente irrelevante. En el caso de dispositivos críticos para la memoria, un compilador decente de C o C ++ alinearía siempre esos valores enteros, eliminando la necesidad de liberar memoria por completo.
Martijn Courteaux
17

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.

duffymo
fuente
Las variables de instancia se obtienen cada vez que mueren todas las referencias / objetos, ¿verdad?
Ruchir Baronia
Las instancias son gc'd, pero las estadísticas están asociadas a clases, no a instancias. Mientras la clase permanezca en la memoria, podrá hacer referencia a sus instancias y métodos estáticos públicos. Esos entran en perm gen (o lo que sea su equivalente JDK 8) y no son gc'd.
duffymo
Incorrecto. Si tiene una referencia a una instancia en la memoria, puede acceder a sus métodos e instancias disponibles. El resto está mal. No comprende la diferencia entre una clase y sus instancias.
duffymo
13

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.

StackHola
fuente
2
El autoboxing del 'int' -> Integer está causando confusión aquí. Está viendo que el autoboxing de algunos valores int (pequeños) conduce al mismo objeto Integer.
dkneller
@StackHola @dkneller De hecho, el autoboxing es un detalle muy importante que sucede aquí. La firma es ObjectUtils.identityToString(Object). (Además, Java no tiene pase por referencia de todos modos). Una prueba realmente útil sería asignar dos objetos y cambiar el valor de una public final int FOO = 10variable usando reflexiones Java de manera forzada. Luego verifique si el otro objeto también ha cambiado su valor.
Martijn Courteaux
11

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.

Michiel
fuente
2

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
Novitzky
fuente
2

¡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

Anónimo
fuente
Esto no es una respuesta :(
Sanjaya Pandey
2

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);
BlondCode
fuente
Tenía un enlace aquí para una comparación detallada. Lo siento chicos, supongo que esto ha sido moderado.
BlondCode
El enlace está de vuelta. Un editor lo había sacado como muerto. Parece estar en vivo ahora.
Erick G. Hagstrom
2

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.

Adrian
fuente
¿Podría explicar cuál es mejor y por qué?
Daniel
2

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

    }

}
Vaibs
fuente
1

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.

DigitalRoss
fuente
1

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.

NarekOnLine
fuente
1

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
san242
fuente
0

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.

Omar Al-Ithawi
fuente
0

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.

Sanjay
fuente
1
Los métodos estáticos no serían necesarios para acceder a las variables estáticas. Creo que está pensando en "acceder a las variables de instancia desde métodos estáticos" (no permitido).
ataulm
0

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?

rommel
fuente
1
Por favor, no solo repita, lo que otras respuestas ya han cubierto.
usuario desconocido
0

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 )

Tsasaa
fuente
0

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.

Warren Jennings-LightningStor
fuente
0

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

Hashem Khaled
fuente
-1

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.");
    }
}
Centeno
fuente
1
Seguro que es una respuesta para esta pregunta?
mikus
-2

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.

Uzma Nasir
fuente