🟢 Junior Level

Yes, you can! Records support static fields and methods. This is the only way to add something to a Record beyond canonical components.

public record User(String name, int age) {
    // ✅ Static field
    public static final int MAX_AGE = 150;

    // ✅ Static method
    public static User anonymous() {
        return new User("Anonymous", 0);
    }
}

// Usage
User.MAX_AGE;  // 150
User.anonymous();  // User[name=Anonymous, age=0]

You cannot:

• ❌ Instance fields (non-static)
• ✅ Only static fields

---

🟡 Middle Level

How it works

Static fields and methods:

public record Color(int r, int g, int b) {
    // ✅ Static constants
    public static final Color RED = new Color(255, 0, 0);
    public static final Color GREEN = new Color(0, 255, 0);
    public static final Color BLUE = new Color(0, 0, 255);

    // ✅ Static factory method
    public static Color fromHex(String hex) {
        int r = Integer.parseInt(hex.substring(1, 3), 16);
        int g = Integer.parseInt(hex.substring(3, 5), 16);
        int b = Integer.parseInt(hex.substring(5, 7), 16);
        return new Color(r, g, b);
    }

    // ✅ Static counter
    private static final AtomicLong COUNTER = new AtomicLong(0);

    public Color {
        COUNTER.incrementAndGet();
    }

    public static long count() {
        return COUNTER.get();
    }
}

Common Mistakes

1. Trying to add instance field:

   public record User(String name) {
    // ❌ Instance field — compilation error
    private int mutableField = 0;
   
    // ✅ Only static
    private static int counter = 0;
   }
   

2. Mutable static fields:

   public record Config() {
    // ⚠️ Dangerous — mutable static state
    public static Map<String, String> settings = new HashMap<>();
   
    // ✅ Better — immutable
    public static final Map<String, String> DEFAULTS = Map.of(
        "locale", "en",
        "timezone", "UTC"
    );
   }
   

Practical Application

1. Constants:

public record Money(BigDecimal amount, Currency currency) {
    public static final Money ZERO_USD = new Money(BigDecimal.ZERO, Currency.USD);
    public static final Money ZERO_EUR = new Money(BigDecimal.ZERO, Currency.EUR);
}

2. Factory methods:

public record Range(int min, int max) {
    public static Range fromString(String str) {
        String[] parts = str.split("-");
        return new Range(Integer.parseInt(parts[0]), Integer.parseInt(parts[1]));
    }

    public static Range of(int value) {
        return new Range(value, value);
    }
}

---

🔴 Senior Level

Internal Implementation

Static fields in Record:

// Static fields are stored in the class, not in instances
// No effect on:
// - Instance size
// - equals() and hashCode() (not considered in static)
// - toString() (doesn't include static)
// - Serialization

Restrictions:

• Static fields are not part of canonical constructor
• Static methods cannot access instance fields
• Static initialization happens at class loading

Architectural Trade-offs

Static fields vs separate utilities:

Approach	Pros	Cons
Static in Record	Logic next to data	Record becomes “fatter”
Separate class	Clean separation	More files

Edge Cases

1. Static initialization with dependencies:

public record Currency(String code, String symbol) {
    public static final Map<String, Currency> REGISTRY;

    static {
        REGISTRY = Map.of(
            "USD", new Currency("USD", "$"),
            "EUR", new Currency("EUR", "€"),
            "GBP", new Currency("GBP", "£")
        );
    }

    public static Currency of(String code) {
        return REGISTRY.get(code.toUpperCase());
    }
}

2. Thread-safe static state:

public record IdGenerator(String prefix) {
    private static final AtomicLong SEQUENCE = new AtomicLong(0);

    public static String generate(IdGenerator gen) {
        return gen.prefix + "-" + SEQUENCE.incrementAndGet();
    }
}

Performance

Static fields:
- Zero overhead per instance
- Initialization at class loading
- Thread-safe initialization (JLS 12.4)

Production Experience

Constants and factories:

public record HttpStatus(int code, String reason) {
    public static final HttpStatus OK = new HttpStatus(200, "OK");
    public static final HttpStatus CREATED = new HttpStatus(201, "Created");
    public static final HttpStatus NOT_FOUND = new HttpStatus(404, "Not Found");
    public static final HttpStatus SERVER_ERROR = new HttpStatus(500, "Server Error");

    public static HttpStatus fromCode(int code) {
        return switch (code) {
            case 200 -> OK;
            case 201 -> CREATED;
            case 404 -> NOT_FOUND;
            case 500 -> SERVER_ERROR;
            default -> new HttpStatus(code, "Unknown");
        };
    }
}

Best Practices

// ✅ Static constants
public record Role(String name) {
    public static final Role ADMIN = new Role("ADMIN");
    public static final Role USER = new Role("USER");
    public static final Role GUEST = new Role("GUEST");
}

// ✅ Static factories
public record Pagination(int page, int size) {
    public static Pagination first() {
        return new Pagination(1, 20);
    }
}

// ❌ Mutable static state
// ❌ Static fields that change after initialization

---

🎯 Interview Cheat Sheet

Must know:

• Record supports static fields and static methods — this is the only way to add something beyond canonical components
• Static fields don’t participate in equals(), hashCode(), toString(), canonical constructor
• Static constants: public static final Money ZERO_USD = ...
• Static factory methods: public static User anonymous() { ... }
• Static counters via AtomicLong for tracking instance creation
• Mutable static state — anti-pattern (thread safety problems)

Common follow-up questions:

• Can you add instance field to Record? — No, only static fields are allowed
• Do static fields affect equals/hashCode? — No, only canonical components are considered
• Can you create Record with Registry pattern? — Yes, static Map for storing instances
• Can you add static initialization block? — Yes, static { } block works as usual

Red flags (DO NOT say):

• ❌ “Static fields participate in hashCode” — hashCode is only from canonical components
• ❌ “Instance field can be added as private” — Any instance field — compilation error
• ❌ “Mutable static state is a good idea” — Thread safety and predictability suffer
• ❌ “Static method can access instance fields” — Static context has no access to instance

Related topics:

• [[1. What is Record in Java and since which version are they available]]
• [[4. Can you add additional methods to a Record]]
• [[6. Can you override constructor in Record]]
• [[9. Are Record fields final]]