palavra-chave static em java

Tutoriais

Java

palavra-chave estática em Java é usada com frequência na programação Java. A palavra-chave estática em Java é usada para criar uma variável de nível de classe em Java. Variáveis e métodos estáticos fazem parte da classe, não das instâncias da classe.

palavra-chave estática em Java

Java estático palavra-chave pode ser usada em cinco casos, como mostrado na imagem abaixo. Vamos discutir quatro deles aqui, o quinto foi introduzido no Java 8 e foi discutido em alterações na interface do Java 8.

Variável estática Java

Podemos usar a palavra-chave static com uma variável de nível de classe. Uma variável estática é uma variável de classe e não pertence a um objeto/instância da classe. Como as variáveis estáticas são compartilhadas entre todas as instâncias do objeto, elas não são seguras para threads. Geralmente, as variáveis estáticas são usadas com a palavra-chave final para recursos comuns ou constantes que podem ser usadas por todos os objetos. Se a variável estática não for privada, podemos acessá-la com NomeDaClasse.nomeDaVariavel
```
// Exemplo de variável estática
    private static int contagem;
    public static String str;
    public static final String USUARIO_BD = "meuusuario";
```
Método estático Java

Assim como variáveis estáticas, métodos estáticos pertencem à classe e não às instâncias da classe. Um método estático pode acessar apenas variáveis estáticas da classe e invocar apenas métodos estáticos da classe. Geralmente, os métodos estáticos são métodos utilitários que desejamos expor para serem usados por outras classes sem a necessidade de criar uma instância. Por exemplo, a classe Collections. As classes utilitárias e de invólucro Java contêm muitos métodos estáticos. O método main(), que é o ponto de entrada de um programa Java, também é um método estático.
```
// Exemplo de método estático
public static void setCount(int count) {
    if(count > 0)
    StaticExample.count = count;
}

// Método utilitário estático
public static int addInts(int i, int...js){
    int sum=i;
    for(int x : js) sum+=x;
    return sum;
}
```
A partir do Java 8, também podemos ter métodos estáticos em interfaces. Para mais detalhes, por favor, leia Alterações na interface Java 8.
Bloco estático Java

O bloco estático Java é o conjunto de instruções que é executado quando a classe é carregada na memória pelo Java ClassLoader. O bloco estático é usado para inicializar as variáveis estáticas da classe. Na maioria das vezes, é utilizado para criar recursos estáticos quando a classe é carregada. Não podemos acessar variáveis não estáticas no bloco estático. Podemos ter vários blocos estáticos em uma classe, embora isso não faça muito sentido. O código do bloco estático é executado apenas uma vez quando a classe é carregada na memória.
```
    static{
        // pode ser usado para inicializar recursos quando a classe é carregada
        System.out.println("Bloco estático de exemplo");
        // pode acessar apenas variáveis e métodos estáticos
        str="Teste";
        setCount(2);
    }
```
Classe Estática do Java

Pode-se usar a palavra-chave estática com classes aninhadas. A palavra-chave estática não pode ser usada com classes de nível superior. Uma classe aninhada estática é igual a qualquer outra classe de nível superior e é aninhada apenas por conveniência de empacotamento. Leia: Classes Aninhadas em Java

Vamos ver todos os usos da palavra-chave static em Java em um programa de exemplo. StaticExample.java

package com.journaldev.misc;

public class StaticExample {

    //bloco estático
    static{
        //pode ser usado para inicializar recursos quando a classe é carregada
        System.out.println("StaticExample static block");
        //pode acessar apenas variáveis e métodos estáticos
        str="Test";
        setCount(2);
    }
    
    //múltiplos blocos estáticos na mesma classe
    static{
        System.out.println("StaticExample static block2");
    }
    
    //exemplo de variável estática
    private static int count; //kept private to control its value through setter
    public static String str;
    
    public int getCount() {
        return count;
    }

    //exemplo de método estático
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    //método utilitário estático
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }

    //exemplo de classe estática - usado apenas por conveniência de empacotamento
    public static class MyStaticClass{
        public int count;
        
    }

}

Vamos ver como usar variável estática, método e classe estática em um programa de teste. TestStatic.java

package com.journaldev.misc;

public class TestStatic {

    public static void main(String[] args) {
        StaticExample.setCount(5);
        
        //variáveis estáticas não privadas podem ser acessadas com o nome da classe
        StaticExample.str = "abc";
        StaticExample se = new StaticExample();
        System.out.println(se.getCount());
        //variáveis estáticas de classe e instância são iguais
        System.out.println(StaticExample.str +" is same as "+se.str);
        System.out.println(StaticExample.str == se.str);
        
        //classes aninhadas estáticas são como classes normais de nível superior
        StaticExample.MyStaticClass myStaticClass = new StaticExample.MyStaticClass();
        myStaticClass.count=10;
        
        StaticExample.MyStaticClass myStaticClass1 = new StaticExample.MyStaticClass();
        myStaticClass1.count=20;
        
        System.out.println(myStaticClass.count);
        System.out.println(myStaticClass1.count);
    }
    
}

O resultado do exemplo de programa Java acima com a palavra-chave static é:

StaticExample static block
StaticExample static block2
5
abc is same as abc
true
10
20

Observe que o código do bloco estático é executado primeiro e apenas uma vez assim que a classe é carregada na memória. Os outros resultados são autoexplicativos.

Importação estática em Java

Normalmente acessamos membros estáticos usando a referência de Classe, a partir do Java 1.5 podemos usar a importação estática java para evitar a referência de classe. Abaixo está um exemplo simples de importação estática Java.

package com.journaldev.test;

public class A {

	public static int MAX = 1000;
	
	public static void foo(){
		System.out.println("foo static method");
	}
}

package com.journaldev.test;

import static com.journaldev.test.A.MAX;
import static com.journaldev.test.A.foo;

public class B {

	public static void main(String args[]){
		System.out.println(MAX); //normally A.MAX
		foo(); // normally A.foo()
	}
}

Observe as declarações de importação, para importação estática devemos usar import static seguido do membro estático totalmente classificado de uma classe. Para importar todos os membros estáticos de uma classe, podemos usar * como em import static com.journaldev.test.A.*;. Devemos usá-lo apenas quando estamos usando a variável estática de uma classe várias vezes, não é bom para legibilidade. Atualização: Recentemente criei um vídeo para explicar a palavra-chave estática em java, você deve assistir abaixo. https://www.youtube.com/watch?v=2e-l1vb_fwM

Source:
https://www.digitalocean.com/community/tutorials/static-keyword-in-java

palavra-chave estática em Java

Variável estática Java

Método estático Java

Bloco estático Java

Classe Estática do Java

Importação estática em Java