palavra-chave static em Java

Tutoriais

Java

A palavra-chave static em Java é amplamente utilizada na programação em Java. A palavra-chave static 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.

A palavra-chave static em Java

O static em Java pode ser usado em cinco casos, como mostrado na imagem abaixo. Vamos discutir quatro deles aqui, o quinto foi introduzido no Java 8 e já foi discutido em mudanças na interface do Java 8.

Variável estática Java

Pode-se 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 Objeto/instância da classe. Como as variáveis estáticas são compartilhadas entre todas as instâncias de Objeto, elas não são seguras para threads. Geralmente, 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.nomeDaVariável
```
    //Exemplo de variável estática
    private static int contador;
    public static String str;
    public static final String USUARIO_DB = "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, 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 de invólucro (Wrapper classes) em Java e classes utilitárias 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 as mudanças nas interfaces do 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 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");
        // só pode acessar variáveis e métodos estáticos
        str="Teste";
        setCount(2);
    }
```
Classe Estática Java

Podemos 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 todo o uso da palavra-chave static em Java em um programa de exemplo. StaticExample.java

package com.journaldev.misc;

public class StaticExample {

    //bloco static
    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 static 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 para 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 de 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 de nível superior normais
        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);
    }
    
}

A saída 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 static é executado primeiro e apenas uma vez assim que a classe é carregada na memória. As outras saídas são autoexplicativas.

Importação estática em Java

Normalmente, acessamos membros estáticos usando a referência da classe. A partir do Java 1.5, podemos usar a importação estática do Java para evitar a referência da classe. Abaixo está um exemplo simples de importação estática em 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 pelo 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 usar isso apenas quando estamos usando a variável estática de uma classe várias vezes, não é bom para a legibilidade. Atualização: Recentemente, criei um vídeo para explicar a palavra-chave estática em Java. Você pode assisti-lo abaixo. https://www.youtube.com/watch?v=2e-l1vb_fwM

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

A palavra-chave static em Java

Variável estática Java

Método estático Java

Bloco estático Java

Classe Estática Java

Importação estática em Java