Membros Estáticos em Java: O Modificador static

Em Java, os membros de uma classe (seus campos e métodos) podem pertencer a um objeto individual ou à própria classe como um todo. Quando um membro pertence à classe, ele é chamado de estático e é compartilhado por todas as instâncias daquela classe. Para declarar esses membros, utiliza-se a palavra-chave static.

O método main, ponto de entrada de qualquer aplicação Java, é um exemplo clássico de um membro estático:

public static void main(String[] args) {
    // ...
}

Campos Estáticos: Variáveis de Classe

A diferença fundamental entre um campo de instância (normal) e um campo estático é como a memória é alocada:

• Campo de Instância (não estático): Uma nova cópia deste campo é criada para cada objeto instanciado. Ele armazena o estado individual de cada objeto.
• Campo Estático: Existe apenas uma cópia deste campo, que é compartilhada por todos os objetos daquela classe. Ele armazena um estado que pertence à classe como um todo, e não a um objeto específico.

Vamos ver um exemplo com um contador de objetos:

public class Program {
    public static void main(String[] args) {
        System.out.println("Valor inicial do contador: " + Person.counter); // Acessando diretamente pela classe

        Person tom = new Person();
        Person bob = new Person();

        tom.displayId();    // Id: 1
        bob.displayId();    // Id: 2

        System.out.println("Valor do contador após criar 2 objetos: " + Person.counter); // Valor é 3

        // Modificando o campo estático diretamente
        Person.counter = 8;

        Person sam = new Person();
        sam.displayId();    // Id: 8
    }
}

class Person {
    private int id; // Campo de instância
    static int counter = 1; // Campo estático (variável de classe)

    Person() {
        // Usa o valor atual do contador e depois o incrementa
        this.id = counter++;
    }

    public void displayId() {
        System.out.printf("Id: %d\n", this.id);
    }
}

Na classe Person, o campo counter é estático. Ele é compartilhado por todos os objetos Person. Cada vez que um novo objeto é criado, o construtor incrementa este contador único. Como counter pertence à classe, podemos acessá-lo e modificá-lo diretamente através do nome da classe (Person.counter), sem precisar de uma instância.

A saída do programa será:

Valor inicial do contador: 1
Id: 1
Id: 2
Valor do contador após criar 2 objetos: 3
Id: 8

Constantes Estáticas

É muito comum que constantes (campos final) sejam também static. Isso cria um valor único e imutável que é compartilhado por toda a aplicação e pode ser acessado de forma conveniente através da classe.

class MathConstants {
    public static final double PI = 3.14159;
}

public class Program {
    public static void main(String[] args) {
        double radius = 10.0;
        // Acessamos a constante PI diretamente através da classe
        double area = MathConstants.PI * radius * radius;
        System.out.printf("Área do círculo: %f\n", area);
    }
}

A constante System.out, que usamos o tempo todo, é um excelente exemplo de um campo static final.

Blocos de Inicialização Estáticos

Assim como existem blocos de inicialização de instância, também existem blocos de inicialização estáticos. Eles são usados para inicializar campos estáticos ou para executar uma ação única que precisa acontecer quando a classe é carregada pela primeira vez na memória.

• Um bloco estático é executado apenas uma vez: quando a classe é carregada pela JVM.
• Sua execução acontece antes da criação de qualquer objeto da classe e antes de qualquer acesso a membros estáticos.

public class Program {
    public static void main(String[] args) {
        System.out.println("Iniciando o main...");
        Person tom = new Person();
        Person bob = new Person();

        tom.displayId();    // Id: 105
        bob.displayId();    // Id: 106
    }
}

class Person {
    private int id;
    static int counter;

    // Bloco de inicialização estático
    static {
        counter = 105;
        System.out.println("Bloco estático executado!");
    }

    Person() {
        this.id = counter++;
        System.out.println("Construtor executado.");
    }

    public void displayId(){

        System.out.printf("Id: %d \n", id);
    }
}

A saída deste programa demonstra a ordem de execução:

Bloco estático executado!
Iniciando o main...
Construtor executado.
Construtor executado.
Id: 105
Id: 106

Note como o bloco estático é executado antes de tudo, assim que a classe Person é necessária pela primeira vez.

Métodos Estáticos

Métodos estáticos também pertencem à classe como um todo, e não a uma instância específica. Eles são chamados diretamente através do nome da classe.

A principal regra de um método estático é:

Um método estático só pode acessar outros membros estáticos (campos ou métodos) da mesma classe. Ele não pode acessar membros de instância (não estáticos), pois não está associado a nenhum objeto específico e, portanto, não tem acesso à palavra-chave this.

Vamos refatorar nosso exemplo para proteger o contador e acessá-lo através de um método estático:

public class Program {
    public static void main(String[] args) {
        Person.displayCounter();    // Counter: 1

        Person tom = new Person();
        Person bob = new Person();

        Person.displayCounter();    // Counter: 3
    }
}

class Person {
    private int id;
    private static int counter = 1;

    Person() {
        this.id = counter++;
    }

    // Método estático
    public static void displayCounter() {
        System.out.printf("Counter: %d\n", counter);
        // A linha abaixo causaria um erro de compilação:
        // System.out.println(this.id); // Erro: 'this' não pode ser usado em um contexto estático.
    }
}

Agora, o campo counter é private, e seu valor só pode ser lido através do método público displayCounter().

Métodos são geralmente definidos como estáticos quando sua lógica não depende do estado de um objeto específico. Classes utilitárias, como a classe Math do Java, são um exemplo perfeito.

class Operation {
    // Este método não depende de nenhum estado de objeto.
    // Ele opera apenas com os parâmetros que recebe.
    static int sum(int x, int y) {
        return x + y;
    }

    static int subtract(int x, int y) {
        return x - y;
    }
}

public class Program {
    public static void main(String[] args) {
        int total = Operation.sum(45, 23);
        System.out.println(total); // 68
    }
}

Faria pouco sentido criar um objeto new Operation() apenas para chamar o método sum(), já que o método não usa nenhum dado do objeto. Torná-lo estático é a abordagem correta e mais eficiente.

📝 Exercícios

Tarefa

Descrição: Crie uma classe utilitária chamada ConversorTemperatura com um método estático celsiusParaFahrenheit. Este método deve receber um valor em graus Celsius e retornar o valor correspondente em Fahrenheit.

Fórmula: Fahrenheit = (Celsius * 9/5) + 32

Código inicial:

public class Main {
    public static void main(String[] args) {
        double tempCelsius = 25.0;

        // Chame o método estático para fazer a conversão.
        double tempFahrenheit = 0; // Substitua 0 pela chamada do método

        System.out.println(tempCelsius + "°C equivale a " + tempFahrenheit + "°F");
        // O resultado esperado é: 25.0°C equivale a 77.0°F
    }
}

// Crie a classe utilitária ConversorTemperatura aqui.
// Ela deve conter um método estático celsiusParaFahrenheit.

public class Main {
    public static void main(String[] args) {
        double tempCelsius = 25.0;

        // Chamamos o método estático diretamente através do nome da classe.
        double tempFahrenheit = ConversorTemperatura.celsiusParaFahrenheit(tempCelsius);

        System.out.println(tempCelsius + "°C equivale a " + tempFahrenheit + "°F");
    }
}

class ConversorTemperatura {
    // Método estático, pois não depende de nenhum estado de objeto.
    public static double celsiusParaFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32;
    }
}