Em termos laymans, o que ‘static’ significa em Java?

Foi-me dito várias definições para isso, olhei na Wikipedia, mas como iniciante em Java ainda não tenho certeza do que isso significa. Alguém fluente em Java e idiota?

static significa que a variável ou método marcado como tal está disponível no nível da class. Em outras palavras, você não precisa criar uma instância da class para acessá-la.

public class Foo { public static void doStuff(){ // does stuff } } 

Então, ao invés de criar uma instância do Foo e então chamar o doStuff assim:

 Foo f = new Foo(); f.doStuff(); 

Você acabou de chamar o método diretamente contra a class, assim:

 Foo.doStuff(); 

Em termos muito leigos, a class é um molde e o object é a cópia feita com esse molde. Estática pertence ao molde e pode ser acessado diretamente sem fazer qualquer cópia, daí o exemplo acima

A palavra-chave estática pode ser usada de várias maneiras diferentes em Java e, em quase todos os casos, é um modificador, o que significa que a coisa que está modificando é utilizável sem uma ocorrência de object delimitadora .

Java é uma linguagem orientada a objects e, por padrão, a maioria dos códigos que você escreve requer uma instância do object a ser usado.

 public class SomeObject { public int someField; public void someMethod() { }; public Class SomeInnerClass { }; } 

Para usar someField, someMethod ou SomeInnerClass , primeiro tenho que criar uma instância de SomeObject .

 public class SomeOtherObject { public void doSomeStuff() { SomeObject anInstance = new SomeObject(); anInstance.someField = 7; anInstance.someMethod(); //Non-static inner classs are usually not created outside of the //class instance so you don't normally see this syntax SomeInnerClass blah = anInstance.new SomeInnerClass(); } } 

Se eu declarar essas coisas estáticas, elas não requerem uma instância delimitadora .

 public class SomeObjectWithStaticStuff { public static int someField; public static void someMethod() { }; public static Class SomeInnerClass { }; } public class SomeOtherObject { public void doSomeStuff() { SomeObjectWithStaticStuff.someField = 7; SomeObjectWithStaticStuff.someMethod(); SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass(); //Or you can also do this if your imports are correct SomeInnerClass blah2 = new SomeInnerClass(); } } 

Declarar algo estático tem várias implicações.

Primeiro, só pode haver um valor de um campo estático em toda a sua aplicação .

 public class SomeOtherObject { public void doSomeStuff() { //Two objects, two different values SomeObject instanceOne = new SomeObject(); SomeObject instanceTwo = new SomeObject(); instanceOne.someField = 7; instanceTwo.someField = 10; //Static object, only ever one value SomeObjectWithStaticStuff.someField = 7; SomeObjectWithStaticStuff.someField = 10; //Redefines the above set } } 

A segunda questão é que methods estáticos e classs internas não podem acessar campos no object delimitador (já que não há um).

 public class SomeObjectWithStaticStuff { private int nonStaticField; private void nonStaticMethod() { }; public static void someStaticMethod() { nonStaticField = 7; //Not allowed this.nonStaticField = 7; //Not allowed, can never use *this* in static nonStaticMethod(); //Not allowed super.someSuperMethod(); //Not allowed, can never use *super* in static } public static class SomeStaticInnerClass { public void doStuff() { someStaticField = 7; //Not allowed nonStaticMethod(); //Not allowed someStaticMethod(); //This is ok } } } 

A palavra-chave estática também pode ser aplicada a interfaces internas, annotations e enums.

public class SomeObject {public interface estática SomeInterface {}; public static @interface SomeAnnotation {}; enum estático público SomeEnum {}; }

Em todos esses casos, a palavra-chave é redundante e não tem efeito. Interfaces, annotations e enums são estáticas por padrão porque nunca têm relação com uma class interna.

Isso apenas descreve o que a palavra-chave faz. Não descreve se o uso da palavra-chave é uma má ideia ou não. Isso pode ser abordado com mais detalhes em outras perguntas, como Usar muitos methods estáticos é algo ruim?

Existem também alguns usos menos comuns da palavra-chave estática. Existem importações estáticas que permitem usar tipos estáticos (incluindo interfaces, annotations e enums não redundantemente marcados como static) não qualificados.

 //SomeStaticThing.java public class SomeStaticThing { public static int StaticCounterOne = 0; } //SomeOtherStaticThing.java public class SomeOtherStaticThing { public static int StaticCounterTwo = 0; } //SomeOtherClass.java import static some.package.SomeStaticThing.*; import some.package.SomeOtherStaticThing.*; public class SomeOtherClass { public void doStuff() { StaticCounterOne++; //Ok StaticCounterTwo++; //Not ok SomeOtherStaticThing.StaticCounterTwo++; //Ok } } 

Por fim, existem inicializadores estáticos, que são blocos de código que são executados quando a class é carregada pela primeira vez (o que ocorre geralmente antes de uma class ser instanciada pela primeira vez em um aplicativo) e (como methods estáticos) não pode acessar campos não estáticos ou methods.

 public class SomeObject { private static int x; static { x = 7; } } 

Desculpas se isso entrar em mais detalhes do que o necessário, me pediram para mover essa resposta aqui de outra pergunta em que o detalhe era um pouco mais apropriado.

Outro ótimo exemplo de quando os atributos e operações estáticos são usados ​​quando você deseja aplicar o padrão de design do Singleton . Em suma, o padrão de design Singleton garante que um e apenas um object de uma determinada class seja construído durante a vida útil do seu sistema. Para garantir que apenas um object seja construído, as implementações típicas do padrão Singleton mantêm uma referência estática interna à única instância de object permitida, e o access a essa instância é controlado usando uma operação static .

Além do que @inkedmn apontou, um membro estático está no nível de class. Portanto, o referido membro é carregado na memory pela JVM uma vez para essa class (quando a class é carregada). Ou seja, não há n instâncias de um membro estático carregado para n instâncias da class à qual ele pertence.

Os pontos acima estão corretos e quero adicionar alguns pontos mais importantes sobre a palavra-chave estática.

Internamente, o que acontece quando você está usando uma palavra-chave estática é armazenada na memory permanente (que está na memory heap ), sabemos que existem dois tipos de memory: memory de pilha (memory temporária) e memory de heap (memory permanente), Se você não estiver usando a palavra chave estática, armazenará na memory temporária que está na memory da pilha (ou você pode chamá-la como memory volátil ).

então você terá uma dúvida de qual é o uso desse direito ???

exemplo : static int a = 10; (1 programa)

só agora eu disse que se você usar a palavra-chave estática para variables ou para o método, ela será armazenada na memory permanente .

então eu declarei a mesma variável com a palavra-chave estática em outro programa com valor diferente.

exemplo : static int a = 20; (2 programa)

a variável ‘a’ é armazenada na memory heap pelo programa 1.a mesma variável estática ‘a’ é encontrada no programa 2, no momento em que ela não cria novamente uma variável ‘a’ na memory heap em vez de apenas replace o valor de um a 10 para 20 .

Em geral, ele criará novamente a variável ‘a’ na memory da pilha (memory temporária) se você não declarar ‘a’ como variável estática.

No geral, posso dizer que, se usarmos palavra-chave estática
1. nós podemos economizar memory
2. nós podemos evitar duplicatas
3. Não há necessidade de criar o object em ordem para acessar a variável estática com a ajuda do nome da class, você pode acessá-lo.