atributo estático final privado vs atributo final privado

Em Java, qual é a diferença entre:

private final static int NUMBER = 10;

e

private final int NUMBER = 10;

Ambos são privatee final, a diferença é o staticatributo

O que é melhor? E porque?

Em geral, staticsignifica "associado ao próprio tipo , em vez de uma instância do tipo".

Isso significa que você pode fazer referência a uma variável estática sem nunca ter criado uma instância do tipo, e qualquer código referente à variável está se referindo exatamente aos mesmos dados. Compare isso com uma variável de instância: nesse caso, há uma versão independente da variável por instância da classe. Então, por exemplo:

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

imprime 10: y.instanceVariablee x.instanceVariablesão separados, porque xe yse referem a diferentes objetos.

Você pode consultar membros estáticos por meio de referências, embora seja uma má idéia fazer isso. Se nós fizemos:

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

então isso imprimiria 20 - há apenas uma variável, não uma por instância. Teria sido mais claro escrever isso como:

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

Isso torna o comportamento muito mais óbvio. Os IDEs modernos geralmente sugerem mudar a segunda lista para a terceira.

Não há razão para ter uma declaração embutida inicializando o valor da seguinte maneira, pois cada instância terá seu próprio, NUMBERmas sempre com o mesmo valor (é imutável e inicializado com um literal). É o mesmo que ter apenas uma final staticvariável para todas as instâncias.

private final int NUMBER = 10;

Portanto, se não puder mudar, não há sentido em ter uma cópia por instância.

Mas, faz sentido se for inicializado em um construtor 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;
}

Agora, para cada instância de MyClass, podemos ter um valor diferente, mas imutável de number.

Para final , podem ser atribuídos diferentes valores em tempo de execução quando inicializados. Por exemplo

Class Test{
  public final int a;
}

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

Assim, cada instância tem um valor diferente do campo a .

Para final estático , todas as instâncias compartilham o mesmo valor e não podem ser alteradas após a primeira inicialização.

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.

Uma staticvariável permanece na memória durante toda a vida útil do aplicativo e é inicializada durante o carregamento da classe. Uma não staticvariável está sendo inicializada cada vez que você constrói um newobjeto. Geralmente é melhor usar:

private static final int NUMBER = 10;

Por quê? Isso reduz o consumo de memória por instância. Possivelmente também é favorável para ocorrências de cache. E isso faz sentido: staticdeve ser usado para coisas que são compartilhadas em todas as instâncias (também conhecidas como objetos) de um determinado tipo (também conhecidas como class).

estática significa "associado à classe"; sem ela, a variável é associada a cada instância da classe. Se for estático, significa que você terá apenas um na memória; caso contrário, você terá um para cada instância que criar. estático significa que a variável permanecerá na memória enquanto a classe estiver carregada; sem ela, a variável pode ser alterada quando sua instância é.

Lendo as respostas, não encontrei nenhum teste real realmente chegando ao ponto. Aqui estão os meus 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 o primeiro 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 o 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

Conclusão:

Como eu pensei que o java faz a diferença entre tipos primitivos e outros. Tipos primitivos em Java são sempre "armazenados em cache", o mesmo para literais de strings (não novos objetos String), portanto, não há diferença entre membros estáticos e não estáticos.

No entanto, há uma duplicação de memória para membros não estáticos se eles não forem instância de um tipo primitivo.

Alterar o valor de valueStatic para 10 vai ainda mais longe, pois o Java fornecerá os mesmos endereços para as duas variáveis ​​int.

Embora as outras respostas pareçam deixar bem claro que geralmente não há razão para usar constantes não estáticas, não encontrei ninguém apontando que é possível ter várias instâncias com valores diferentes em suas variáveis ​​constantes.

Considere o seguinte exemplo:

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

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

Criar três instâncias do TestClass imprimiria o mesmo valor aleatório três vezes, uma vez que apenas um valor é gerado e armazenado na constante estática.

No entanto, ao tentar o seguinte exemplo:

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

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

Criar três instâncias do TestClass agora imprimiria três valores aleatórios diferentes, porque cada instância tem seu próprio valor constante gerado aleatoriamente.

Não consigo pensar em nenhuma situação em que seria realmente útil ter valores constantes diferentes em diferentes instâncias, mas espero que isso ajude a ressaltar que há uma clara diferença entre finais estáticos e não estáticos.

Como já disse Jon, uma variável estática, também conhecida como variável de classe, é uma variável que existe entre instâncias de uma classe.

Encontrei um exemplo disso aqui :

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

A saída do programa é dada abaixo:

Como podemos ver neste exemplo, cada objeto tem sua própria cópia da variável 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

Dos testes que fiz, as variáveis ​​finais estáticas não são as mesmas com as variáveis ​​finais (não estáticas)! Variáveis ​​finais (não estáticas) podem diferir de objeto para objeto !!! Mas isso é apenas se a inicialização for feita dentro do construtor! (Se não for inicializado pelo construtor, será apenas um desperdício de memória, pois cria variáveis ​​finais para cada objeto criado que não pode ser alterado.)

Por exemplo:

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

    }
}

O que aparece na tela é:

Sobre o objeto: A @ addbf1 Final: 14 Final estático: 5

Sobre o objeto: A @ 530daa Final: 21 Final estático: 5

Anônimo 1º ano estudante de TI, Grécia

Além da resposta de Jon, se você usar final estático, ele se comportará como uma espécie de "definição". Depois de compilar a classe que a utiliza, ela estará no arquivo .class compilado gravado. Confira meu tópico aqui .

Para seu objetivo principal: Se você não usar o NÚMERO de maneira diferente nas diferentes instâncias da classe, aconselho o uso final e estático. (Lembre-se de não copiar arquivos de classe compilados sem considerar possíveis problemas como o que meu estudo de caso descreve. Na maioria dos casos, isso não ocorre, não se preocupe :))

Para mostrar como usar valores diferentes nas instâncias, verifique este código:

public class JustFinalAttr {
  public final int Number;

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

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

Aqui estão meus dois centavos:

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

Exemplo:

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

A chave é que variáveis ​​e funções podem retornar valores diferentes. Portanto, variáveis ​​finais podem ser atribuídas com valores diferentes.

Apenas outro exemplo simples para entender o uso de variáveis ​​estáticas, finais estáticas e finais. Os comentários do código têm a explicação adequada.

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

    }

}

muito pouco e estático

Não há muita diferença, pois ambas são constantes. Para a maioria dos objetos de dados da classe, estático significaria algo associado à própria classe, havendo apenas uma cópia, independentemente de quantos objetos foram criados com o novo.

Como é uma constante, ele pode não ser realmente armazenado na classe ou em uma instância, mas o compilador ainda não permitirá que você acesse objetos da instância a partir de um método estático, mesmo que saiba quais seriam. A existência da API de reflexão também pode exigir algum trabalho inútil se você não a tornar estática.

Como uma variável em uma classe é declarada como final AND inicializada no mesmo comando, não há absolutamente nenhuma razão para não declarar como estática, pois ela terá o mesmo valor, independentemente da instância. Portanto, todas as instâncias podem compartilhar o mesmo endereço de memória para um valor, economizando tempo de processamento, eliminando a necessidade de criar uma nova variável para cada instância e economizando memória compartilhando um endereço comum.

final estático privado será considerado constante e a constante pode ser acessada somente nesta classe. Como a palavra-chave estática está incluída, o valor será constante para todos os objetos da classe.

O valor da variável final privada será como constante por objeto.

Você pode consultar o java.lang.String ou procurar o exemplo abaixo.

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

//Resultado:

10
40
20

O estático é o mesmo membro em todas as instâncias da classe e na própria classe.
O não estático é um para cada instância (objeto); portanto, no seu caso exato , é um desperdício de memória se você não colocar estática.

Se você marcar esta variável como estática, então, como você sabe, exigiria métodos estáticos para acessar novamente esses valores, isso será útil se você já pensa em usar essas variáveis ​​apenas em métodos estáticos. Se é assim, então seria o melhor.

No entanto, você pode tornar a variável agora pública, já que ninguém pode modificá-la como "System.out", mas depende novamente de suas intenções e do que você deseja alcançar.

Digamos que, se a classe não tiver mais de uma instância, qual será a memória que mais terá:

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

Eu entendi que estático se referirá ao tipo de classe com apenas uma cópia na memória e não estático estará em um novo local de memória para cada variável de instância. No entanto, internamente, se apenas compararmos uma instância da mesma classe (ou seja, mais de uma instância não seria criada), haverá alguma sobrecarga em termos de espaço usado por 1 variável final estática?

A variável estática pertence à classe (o que significa que todos os objetos compartilham essa variável). Variável não estática pertence 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 você pode ver no exemplo acima, para "final int" podemos atribuir nossa variável para cada instância (objeto) da classe; no entanto, para "static final int", devemos atribuir uma variável na classe (a variável estática pertence à classe )

Se você usar estático, o valor da variável será o mesmo em todas as suas instâncias, se alterado em uma instância, as outras também serão alteradas.

Final: uma vez que uma variável final é atribuída, ela sempre contém o mesmo valor. onde a variável é estática ou não estática: será apenas uma variável para todas as instâncias inicializadas uma vez na Memória

Isso pode ajudar

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

A palavra-chave "Static" cria a propriedade variável da classe em vez de instâncias individuais da classe. Haverá uma cópia dessa variável que é compartilhada entre todas as instâncias dessa classe. Qualquer alteração no estado da variável estática será refletida em todas as instâncias. Adicione final ao static e obteremos uma variável que foi inicializada de uma vez por todas no tempo de carregamento da classe e não pode ser alterada posteriormente por nenhuma instância da classe. Variáveis ​​finais estáticas precisam ser inicializadas no momento da declaração; caso contrário, temos um erro de tempo de compilação. No que diz respeito ao campo de instância privada, ele se refere à propriedade / estado de um objeto / instância de uma classe. Cada instância / objeto da classe terá sua própria cópia da variável de instância. Quando a variável de instância é declarada final, significa que não podemos alterar seu valor para esta instância. Para isso, precisamos inicializar a variável final na declaração ou no construtor. Se isso não for feito em nenhuma delas, o erro em tempo de compilação será exibido. Uma vez inicializado, se você tentar reatribuir um valor, receberá um erro de tempo de compilação. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. Para isso, precisamos inicializar a variável final na declaração ou no construtor. Se isso não for feito em nenhuma delas, o erro em tempo de compilação será exibido. Uma vez inicializado, se você tentar reatribuir um valor, receberá um erro de tempo de compilação. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. Para isso, precisamos inicializar a variável final na declaração ou no construtor. Se isso não for feito em nenhuma delas, o erro em tempo de compilação será exibido. Uma vez inicializado, se você tentar reatribuir um valor, receberá um erro de tempo de compilação. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. Se não for feito em nenhum deles, o erro de tempo de compilação será exibido. Uma vez inicializado, se você tentar reatribuir um valor, receberá um erro de tempo de compilação. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. Se não for feito em nenhum deles, o erro de tempo de compilação será exibido. Uma vez inicializado, se você tentar reatribuir um valor, receberá um erro de tempo de compilação. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. Use variáveis ​​finais estáticas nas quais os dados serão compartilhados em todas as instâncias da classe e você deseja que os dados sejam somente leitura. Use a variável final da instância se desejar representar alguns dados que pertencem a cada instância individual da classe, mas uma vez armazenado não pode ser alterado. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto. O uso da palavra-chave estática e da instância depende das suas necessidades de design e do que esses dados representam no domínio. Se os dados forem usados ​​nas instâncias da classe, não haverá necessidade de referências individuais de cópias / memória para cada objeto.