All 15 Interfaces & Abstract Classes questions
More in Interfaces & Abstract Classes
What is the fundamental difference between an interface and an abstract class in Java, and when would you choose one over the other? How do default methods (introduced in Java 8) let an interface provide a method implementation, and what problem were they specifically introduced to solve? What are static methods on an interface, and how do they differ from default methods in terms of inheritance and typical use case? How would you use an abstract class to implement the Template Method pattern, defining a fixed algorithm skeleton with some steps left abstract for subclasses to fill in? Can an interface extend multiple other interfaces simultaneously, and how does this differ from a class's single-inheritance restriction for abstract/concrete classes? What is the purpose of declaring an abstract class with a protected constructor, and how does this pattern communicate the class's intended usage to other developers? How would you implement the 'mixin' pattern in Java using default methods on an interface, letting a class gain reusable behavior without traditional inheritance? How would you use an abstract class's constructor to enforce that certain validation or initialization logic always runs for every subclass, something an interface (lacking constructors entirely) cannot provide? How is the 'diamond problem' (a class implementing two interfaces with conflicting default methods) resolved in Java, and what rule determines which default method 'wins' or whether the compiler requires explicit resolution? What are private methods on an interface (introduced in Java 9), and what specific problem do they solve regarding code duplication between multiple default methods?
Advertisement
Back to results for “OOP & Classes”
Java › Interfaces & Abstract Classes

Can an interface declare instance fields, and if so, what implicit modifiers are automatically applied to any field declared in an interface?

Beginner

Answer

Any field declared in an interface is implicitly public, static, and final, regardless of whether these modifiers are explicitly written -- meaning an interface cannot have genuine per-instance mutable state (every field is effectively a shared, immutable constant), which is a key structural distinction from an abstract class, whose fields are ordinary instance fields with whatever access modifier and mutability you choose to declare.
public interface Constants {
    int MAX_RETRIES = 3;  // implicitly public static final, even without writing those modifiers
    String DEFAULT_NAME = "Guest";
}

// Equivalent to explicitly writing:
// public static final int MAX_RETRIES = 3;

System.out.println(Constants.MAX_RETRIES);  // accessed like a static field, since that's exactly what it is
Real-world example A library defining a set of shared configuration constants in an interface relies on the automatic public-static-final treatment, meaning every implementing class (and any other code referencing the interface directly) sees the exact same single, immutable, shared constant values rather than each implementation getting its own independently mutable copy.

Common follow-ups: Why did the language designers choose to make interface fields implicitly constants rather than allowing genuine mutable instance state?;Is declaring constants in an interface (rather than a dedicated final utility class) still considered good practice today?

Java Fundamentals: Syntax Data Types & Operators;OOP & Classes
All 15 Interfaces & Abstract Classes questions