Miembros estáticos en Java: campos y métodos static

Pertenecer a la clase, no al objeto

La mayoría de los campos y métodos que has escrito hasta ahora pertenecen a objetos: cada vez que llamas a new, cada instancia obtiene su propia copia de los campos, y los métodos operan sobre el estado de ese objeto concreto. La palabra clave static da la vuelta a esto. Un miembro static pertenece a la clase en sí: hay una única copia, compartida por todas las instancias, y existe independientemente de si llegas a crear o no un objeto.

Esa única distinción explica los campos static, los métodos static, las constantes e incluso por qué main siempre es static.

Un campo static compartido

Un campo no estático le da a cada objeto su propio espacio. Un campo static le da a la clase un espacio que todos comparten. El ejemplo clásico es un contador que registra cuántos objetos se han creado:

class User {
    static int count = 0;     // un espacio compartido para toda la clase
    String name;              // uno por objeto

    User(String name) {
        this.name = name;
        count++;              // incrementa el contador compartido en cada construcción
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Ada");
        new User("Linus");
        new User("Grace");

        System.out.println("users created: " + User.count);
    }
}

Fíjate en que lees el contador como User.count, a través del nombre de la clase, porque el valor no pertenece a ningún User concreto. Cada name, en cambio, vive dentro de su propio objeto. Cambia count a través de cualquier instancia y todas las instancias verán el nuevo valor, porque solo existe uno.

Métodos static

Un método static también pertenece a la clase, así que lo llamas sobre la clase sin un objeto:

class MathUtils {
    static int square(int x) {
        return x * x;
    }

    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(7));
        System.out.println(MathUtils.max(3, 9));
    }
}

Este es exactamente el patrón que hay detrás de la biblioteca estándar: Math.max, Integer.parseInt, Arrays.sort y List.of son todos static: comportamiento utilitario que no necesita un objeto sobre el que operar. Recurre a un método static cuando el trabajo depende solo de sus argumentos, no de ningún estado propio de un objeto.

El gran tropiezo: static no puede ver instance

Un método static se ejecuta sin ningún objeto, así que no hay this. Eso significa que no puede acceder a campos de instancia ni llamar a métodos de instancia directamente: no hay un objeto concreto del que leerlos. Este es el error más común de los principiantes con static:

class Account {
    int balance = 100;          // campo de instancia

    static int show() {
        return balance;         // ERROR DE COMPILACIÓN: el campo no estático 'balance'
    }                           // no puede referenciarse desde un contexto estático
}

La solución es o bien convertir el método en un método de instancia (quitar static, para que tenga un this), o pasar el objeto explícitamente:

class Account {
    int balance = 100;

    static int show(Account a) {     // recibe el objeto como parámetro
        return a.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account();
        System.out.println(Account.show(a));
    }
}

La dirección inversa no da problemas: un método de instancia sí puede leer libremente campos static y llamar a métodos static, porque los datos compartidos a nivel de clase siempre existen.

Constantes con static final

Combina static con final y obtienes una constante: un único valor compartido que nunca puede cambiar. Por convención se nombran en UPPER_SNAKE_CASE:

class Circle {
    static final double PI = 3.14159265;

    double radius;

    Circle(double radius) { this.radius = radius; }

    double area() {
        return PI * radius * radius;   // método de instancia que usa una constante static
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%.2f%n", new Circle(2).area());
    }
}

static final es la forma idiomática de expresar "un valor fijo que pertenece al tipo": cosas como Integer.MAX_VALUE o Math.PI en la biblioteca estándar. Hacerlo static significa que no desperdicias una copia por objeto; hacerlo final significa que nadie puede reasignarlo.

Bloques inicializadores static

Un campo static sencillo puede inicializarse en línea. Cuando la configuración necesita lógica real —construir una tabla de búsqueda, leer configuración— usa un bloque static. Se ejecuta una vez, cuando la clase se carga por primera vez, antes de que exista cualquier objeto:

import java.util.HashMap;
import java.util.Map;

class Roman {
    static final Map<Character, Integer> VALUES = new HashMap<>();

    static {                       // se ejecuta una vez, al cargar la clase
        VALUES.put('I', 1);
        VALUES.put('V', 5);
        VALUES.put('X', 10);
        VALUES.put('L', 50);
    }

    static int valueOf(char c) {
        return VALUES.get(c);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Roman.valueOf('X') + Roman.valueOf('I'));
    }
}

El bloque se dispara una sola vez sin importar cuántas veces uses la clase, lo que lo convierte en el lugar adecuado para la configuración única que abarca toda la clase.

Cuándo usar static

Una regla práctica rápida:

• Usa un campo static solo para datos que estén realmente compartidos por todas las instancias: un contador, una caché, una constante. Si dos objetos pudieran razonablemente tener valores distintos, debería ser un campo de instancia.
• Usa un método static cuando el resultado depende solo de los argumentos, no del estado de ningún objeto (funciones de utilidad puras).
• Por defecto, usa miembros de instancia. Abusar de static convierte silenciosamente tu programa en un montón de estado global, difícil de probar y de razonar. static es la excepción, no el punto de partida.

Siguiente: Enums

Una constante static final está bien para un único valor fijo, pero cuando tienes un conjunto pequeño y fijo de valores relacionados —direcciones, días de la semana, estados de un pedido— Java tiene un tipo diseñado para ese propósito que es más seguro y expresivo que constantes dispersas. Ese es el enum, y es la siguiente página.