Enum Behavior and Interface Contracts in Java SE 25
Review constant-specific enum behavior, interface implementation, varargs, JavaBean conventions, and bytecode.
What is a constant-specific enum class body?
Answer: It is an optional body attached to an individual enum constant. It implicitly defines an anonymous subclass of the enum and can override eligible instance methods to give that constant specialized behavior. Constructor arguments alone are sufficient when constants differ only in data.
public class CoffeeChoices { enum CoffeeSize { BIG(8), HUGE(10), OVERWHELMING(16) { @Override String lidCode() { return "A"; } }; private final int ounces; CoffeeSize(int ounces) { this.ounces = ounces; } int ounces() { return ounces; } String lidCode() { return "B"; } } public static void main(String[] args) { for (CoffeeSize size : CoffeeSize.values()) { System.out.println(size + " " + size.ounces() + " " + size.lidCode()); } } }The output is BIG 8 B, HUGE 10 B, and OVERWHELMING 16 A. The last constant overrides behavior while all constants share the enum's field and constructor logic. Do not write a separate source subclass extending the enum.
Can an interface extend another interface?
Answer: Yes, and it can extend several interfaces. The declaration uses extends, not implements. Classes use implements to declare interface contracts.
The reason is the language's type-declaration rules, not a claim that interfaces cannot contain implementations. Modern interfaces can have default, static, and private methods. Inherited method conflicts may require explicit resolution, and an interface can add obligations that its eventual concrete implementations must satisfy.
Must an implementing class redeclare every method from an interface?
Answer: No. A concrete class must have implementations for all outstanding abstract obligations, but it may inherit them from a superclass or inherit appropriate interface default methods. An abstract implementing class can leave obligations unresolved.
Private and static interface methods are not abstract obligations for implementing classes. An implementation of a public interface method must be public and have compatible return and checked-exception declarations. Conflicting defaults or incompatible signatures can require an override or make the combination impossible.
Why can a final singleton reference still contain a mutable list?
Answer: Final prevents the reference from being reassigned; it does not freeze the referenced object's fields or collections. A final INSTANCE reference can therefore refer to a service whose providers list changes over time.
That does not automatically make the service thread-safe. Shared mutation needs synchronization or a suitable concurrent design. Use generics for the list, restrict direct access, and return a safe view or snapshot if callers must not mutate it. A final reference is not evidence that the whole object is immutable.
What do the three dots in String... strings mean?
Answer: They declare a variable-arity String parameter. Inside the method, strings is a String array. The caller can supply zero or more String arguments or an existing String array.
There can be only one varargs parameter and it must be last. A declaration taking String... and one taking String[] cannot coexist as distinct overloads with otherwise identical signatures. A call with null can be ambiguous in intent, so use an explicit cast when distinguishing a null array from one null element.
Can a static method access an instance field?
Answer: Yes, through an explicit compatible object reference and subject to access rules. It has no implicit this, so it cannot access an instance field as though a receiver were automatically available.
A static method can obtain the receiver from a parameter, a newly constructed object, or another accessible reference. Static membership does not imply synchronization or special private-access bypasses. Prefer naming the class when accessing static members to make the distinction visible.
What advantages do enums have over unrelated integer constants?
Answer: An enum gives a domain its own type, meaningful names, and a fixed set of declared values. A Season parameter rejects arbitrary integers and unrelated enum types at compile time. Constants can also carry fields and behavior.
Integer constants can be inlined into client code, so changing their values may leave separately compiled clients using old values. Simply reordering declarations without changing explicit values is not itself the problem. Enums also require evolution care: adding a constant can affect exhaustive switches, and ordinal should not be used as a stable external identifier.
Must every method in a JavaBean start with get, set, is, add, or remove?
Answer: No. These prefixes belong to particular discovery conventions, not all methods in the class. A property commonly uses getName and setName; a primitive boolean getter can use isEnabled. Event registration commonly uses addXListener and removeXListener.
The conventional setter prefix is set, not _set. A bean can have ordinary business methods with other names, and explicit BeanInfo can describe properties or events. Legal Java naming and framework discovery conventions are separate questions.
Are enum declarations prohibited inside methods in Java SE 25?
Answer: No. Local enum declarations are legal in permitted block contexts, including method bodies. They are implicitly static and cannot capture enclosing local variables or an enclosing instance as an ordinary local inner class can.
Enums are also legal as interface members. Their remaining restrictions still apply: no enum type parameters, no explicit superclass other than the implicit Enum relationship, and no ordinary new expressions constructing additional constants. The old local-enum prohibition must not be carried forward into Java 25 guidance.
What is Java bytecode?
Answer: It is the JVM instruction format used in the Code attributes of class files. A class file also contains metadata such as type information and a constant pool. Javac normally translates Java source into this JVM-oriented representation.
A JVM may interpret bytecode, compile it to native machine code, or use a combination of execution strategies. It is inaccurate to require every instruction to be translated in one particular way. Portability still depends on compatible class-file versions, APIs, and any native dependencies used by the program.
References: Enum bodies, Interfaces, Local types, and Class-file format.