0Pricing
Java Academy · Aula

Campos e Constantes Estáticos

Use campos estáticos para estados compartilhados, constantes com static final e inicializadores estáticos.

Campos e Constantes Estáticos é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Campos estáticos e constantes

Os campos estáticos pertencem à classe, não às instâncias. Eles são compartilhados por todos os objetos da classe. As constantes combinam os modificadores estático e final para criar valores imutáveis no nível da classe.

Campos estáticos e de instância

Um campo de instância tem uma cópia separada por objeto. Um campo estático tem uma única cópia compartilhada por todos os objetos da classe.

class Counter {
    private static int totalCount = 0;  // shared across all instances
    private int instanceId;              // unique per instance

    Counter() {
        totalCount++;
        instanceId = totalCount;
    }

    static int getTotalCount() { return totalCount; }
    int getInstanceId()        { return instanceId; }
}

Counter c1 = new Counter();
Counter c2 = new Counter();
Counter c3 = new Counter();

System.out.println(Counter.getTotalCount()); // 3
System.out.println(c1.getInstanceId());       // 1
System.out.println(c3.getInstanceId());       // 3

Constantes com static final

Declare constantes como public static final. Por convenção, elas usam nomes no formato de palavras em maiúsculas separadas por sublinhados.

class MathConstants {
    public static final double PI      = 3.141592653589793;
    public static final double E       = 2.718281828459045;
    public static final double GOLDEN  = 1.618033988749895;
    public static final int    PRIMES[] = {2, 3, 5, 7, 11, 13};
}

// Access without an instance
System.out.println(MathConstants.PI);

// Constants on domain classes
class HttpStatus {
    public static final int OK        = 200;
    public static final int NOT_FOUND = 404;
    public static final int SERVER_ERR = 500;
}

Blocos de inicialização estáticos

Quando uma constante exige uma inicialização complexa, use um bloco de inicialização estático que seja executado uma vez quando a classe for carregada.

import java.util.*;

class Config {
    public static final Map<String, String> DEFAULTS;

    static {
        Map<String, String> map = new HashMap<>();
        map.put("timeout",  "30");
        map.put("maxRetry", "3");
        map.put("logLevel", "INFO");
        DEFAULTS = Collections.unmodifiableMap(map);
    }
}

System.out.println(Config.DEFAULTS.get("timeout")); // 30

Padrão de contador estático

Os campos estáticos são normalmente usados para gerar ID, contar métricas ou manter caches compartilhados.

import java.util.concurrent.atomic.AtomicLong;

class Order {
    private static final AtomicLong ID_SEQUENCE = new AtomicLong(1000);

    private final long id;
    private final String item;

    Order(String item) {
        this.id   = ID_SEQUENCE.getAndIncrement();
        this.item = item;
    }

    long getId()   { return id; }
    String getItem() { return item; }
}

Order o1 = new Order("Laptop");
Order o2 = new Order("Mouse");
System.out.println(o1.getId()); // 1000
System.out.println(o2.getId()); // 1001

Singleton por meio de campo estático

Um campo estático armazena a única instância de um Singleton. Use inicialização tardia para classes que talvez nem sempre sejam necessárias.

class DatabasePool {
    private static volatile DatabasePool instance;
    private final int maxConnections;

    private DatabasePool() { this.maxConnections = 20; }

    public static DatabasePool getInstance() {
        if (instance == null) {
            synchronized (DatabasePool.class) {
                if (instance == null)
                    instance = new DatabasePool();
            }
        }
        return instance;
    }

    public int getMaxConnections() { return maxConnections; }
}

System.out.println(DatabasePool.getInstance().getMaxConnections()); // 20

Importação estática

import static permite usar membros estáticos sem o prefixo do nome da classe — algo útil para constantes e métodos utilitários.

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;

// Without import static: Math.PI * Math.pow(r, 2)
double radius = 5.0;
double area = PI * pow(radius, 2);
System.out.printf("Area: %.2f%n", area); // 78.54

// Caution: overuse of static imports hurts readability
// Acceptable for: Math.*, Assert.* in tests, TimeUnit

Segurança de threads em campos estáticos

Campos estáticos compartilhados entre threads exigem sincronização ou tipos atômicos para evitar condições de corrida.

import java.util.concurrent.atomic.*;

class RequestMetrics {
    private static final AtomicLong requestCount  = new AtomicLong(0);
    private static final AtomicLong totalLatencyMs = new AtomicLong(0);

    public static void record(long latencyMs) {
        requestCount.incrementAndGet();
        totalLatencyMs.addAndGet(latencyMs);
    }

    public static double averageLatency() {
        long count = requestCount.get();
        return count == 0 ? 0 : (double) totalLatencyMs.get() / count;
    }
}
RequestMetrics.record(45);
RequestMetrics.record(120);
System.out.println(RequestMetrics.averageLatency()); // 82.5

Armadilhas dos campos estáticos mutáveis

Campos estáticos mutáveis são perigosos: o estado global mutável é difícil de testar, não é seguro para threads sem os devidos cuidados e cria um acoplamento oculto entre classes.

// BAD: mutable static state
class GlobalConfig {
    public static String environment = "dev"; // mutable global!
}
// Any code anywhere can change GlobalConfig.environment
// Very hard to test, unexpected interactions

// BETTER: immutable constant
class GlobalConfig2 {
    public static final String ENVIRONMENT =
        System.getenv().getOrDefault("APP_ENV", "dev");
}

// BEST: inject via constructor (dependency injection)
class Service {
    private final String environment;
    Service(String environment) { this.environment = environment; }
}

Antipadrão de interface de constantes

Não é recomendável usar uma interface para armazenar constantes (o antipadrão "Interface de constantes"). Em vez disso, use uma classe com um construtor privado.

// BAD: constant interface — pollutes the namespace of implementing classes
interface FinancialConstants {
    double TAX_RATE = 0.08;  // implicitly public static final
}

// GOOD: utility class for constants
final class FinancialConstants2 {
    private FinancialConstants2() {} // prevent instantiation

    public static final double TAX_RATE  = 0.08;
    public static final double VAT_RATE  = 0.20;
    public static final int    MAX_ITEMS = 100;
}
System.out.println(FinancialConstants2.TAX_RATE); // 0.08

Prático: sinalizadores de funcionalidade com constantes

Uso de constantes booleanas estáticas e finais como sinalizadores de funcionalidade em tempo de compilação — o compilador JIT elimina os ramos inacessíveis.

class Features {
    public static final boolean ENABLE_ANALYTICS   = true;
    public static final boolean ENABLE_AI_SEARCH    = false;
    public static final boolean DEBUG_MODE          =
        "true".equals(System.getenv("DEBUG"));
}

// The JIT eliminates this if-block when ENABLE_AI_SEARCH is false:
if (Features.ENABLE_AI_SEARCH) {
    System.out.println("Running AI search...");
}

if (Features.DEBUG_MODE) {
    System.out.println("[DEBUG] Request received");
}

Verificação rápida

Qual é a diferença entre um campo estático e um campo de instância?

Recapitulação: campos estáticos e constantes

Principais conclusões:

  • Os campos estáticos pertencem à classe — uma única cópia compartilhada por todas as instâncias
  • Constantes: public static final em formato de palavras maiúsculas separadas por sublinhados
  • Use blocos de inicialização estáticos para constantes que exigem inicialização complexa
  • Prefira AtomicLong/AtomicInteger para campos estáticos mutáveis em código concorrente
  • Evite campos estáticos mutáveis — eles criam um estado global oculto difícil de testar
  • Use uma classe não instanciável (com construtor privado) para constantes, em vez de uma interface

Perguntas Frequentes

A aula “Campos e Constantes Estáticos” é grátis?

Sim — o texto completo de “Campos e Constantes Estáticos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Campos e Constantes Estáticos”?

Use campos estáticos para estados compartilhados, constantes com static final e inicializadores estáticos. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Campos e Constantes Estáticos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Regras de Sobrecarga de Métodos
  2. Parâmetros Varargs
  3. Campos e Constantes Estáticos
  4. Classes Utilitárias e Métodos de Fábrica Estáticos
← Voltar para Java Academy