Can an Interface have fields? Why or why not?
Fields in Interfaces
The answer is language-specific. In Java, interface fields are implicitly public, static and final, so they represent constants rather than per-object mutable state. Java interfaces cannot define ordinary instance fields. In C#, interfaces traditionally did not contain instance fields either; newer language features have expanded what interfaces can express, but they still are not a mechanism for storing ordinary per-instance object state. If an abstraction needs mutable instance state, an abstract class or composition is generally more appropriate.
- 1
Java interface fields are implicitly public, static and final.
- 2
They are constants, not per-object mutable state.
- 3
Interfaces are primarily contracts rather than state containers.
- 4
C# interface capabilities differ by language version, but interfaces are not intended as ordinary instance-state holders.
- 5
Use a class or abstract class when shared instance state is part of the abstraction.
Scenario Questions
0-2 years experience
- 1We need a logger interface that provides a default log level. How would you declare that constant, and can you add a regular field to the interface?
- 2If you accidentally write a non‑static field inside an interface, what compile‑time error do you see and why?
- 3When a class implements an interface with a constant, can the class assign a different value to that constant?
2-5 years experience
- 1Your team moved several services to share a common interface that contains a static field for a configuration flag. At runtime all services see the same flag value even though you expected per‑service overrides. Explain why this happened and how you would fix it.
- 2During a code review you notice an interface that declares a mutable field to hold state. The code compiles but fails when multiple implementations run concurrently. Walk through why this design is problematic and suggest a better approach.
- 3After adding a new constant to a widely used interface, some modules start throwing NoSuchFieldError at startup. What could cause this and how would you resolve it?
5-8 years experience
- 1In a large microservice platform you want a common contract for data serialization. Discuss the trade‑offs of putting version numbers as static fields in the interface versus using an enum or external configuration.
- 2Your plugin framework defines extension points as interfaces. Some plugins need per‑instance configuration. Explain why adding fields to the interface is a bad idea and propose a redesign that supports configuration without breaking existing plugins.
- 3When migrating a legacy codebase from Java 7 to Java 11, you consider converting abstract classes with protected fields into interfaces with default methods and static fields. What risks does this introduce regarding field semantics and binary compatibility?
8+ years experience
- 1Several teams propose using Java interfaces with static fields to store schema metadata for a language‑agnostic service definition. Evaluate the long‑term maintenance, cross‑language compatibility, and versioning implications of this approach versus a dedicated schema registry.
- 2A cross‑team initiative wants to enforce that all public APIs expose only constants via interfaces, eliminating separate utility classes. Discuss the potential impact on modularity, binary compatibility, and future evolution of the platform.
- 3During a platform‑wide refactor you need to replace a set of constant‑heavy interfaces with a centralized configuration service. Outline a migration strategy that minimizes disruption and ensures existing code that relied on interface fields continues to function.
Follow-up Questions
- What would happen if you tried to assign a value to a non‑static field in an interface?
- Can an implementing class change the value of a constant defined in an interface?
- How do default methods interact with interface fields?