Default constructor vs. inline field initialization

java

best-practices

performance

initialization

byAnton Shumikhin·Feb 4, 2025

Choose inline field initialization for simplicity and when values don't depend on constructor inputs; it establishes field values right at declaration:

class MyClass {
    // As constant as gravity
    private int number = 42; 
    private String message = "Hello, World!";
}

For default constructor, choose it for conditional or computed values and when initialization logic is required:

class MyClass {
    private int number;
    private String message;

    public MyClass() {
        number = new Random().nextInt(100); // Because life is random
        message = "Hello, StackOverflow users!";
    }
}

Inline initialization: a quick way for constants or immutable fields, while constructors provide control for complex cases.

Starter’s guide: Field initializers vs constructors

Inline field initializers are executed before constructor bodies - they're like the early bird catching the worm. So, they come handy to set initial values furthermore they ensure that fields have a default value even if the constructor does not initialize them.

But life isn't always simple, and neither is initialization. For complex initialization that depends on arguments or requires some logic like calling a method, you can't beat a good old constructor.

Driving code design: Constructors for the win

When working with a class with multiple constructors, you'll find times where common initialization logic has to be included. Maintaining DRY (Don't Repeat Yourself) principles here is akin to finding a parking space in a busy city - golden.

class MyClass {
    private int number;
    private String message;

    public MyClass() {
        this(42, "So long, and thanks for all the fish"); //Douglas Adams fans, assemble!
    }

    public MyClass(int number, String message) {
        this.number = number;
        this.message = message;
    }
}

In contrast, inline initializers can be the peacekeepers of your codebase. By declaring default values at field declaration, they simplify the code nicely by keeping all the initialization logic in one place, making your code as easy to read as your favorite book.

The inheritance scene: Choose wisely

Initialization methods can make a significant difference in a class hierarchy like deciding whether to use stairs or an elevator in a multi-floor building. Using field initializers in a superclass ensures that fields have default values. However, constructors provide an extension point for subclasses to add extra logic or even override these values.

So, whether you're passing down a precious family heirloom or just trying to figure out what private fields should get, take a moment to evaluate the effect of your chosen initialization method.

Performance and Initialization: A delicate dance

Contrary to popular belief, constructors and inline field initializers aren't carbon copies of each other when it comes to performance. The complexity inherent in constructors can bring in some overhead - it's like being an over-achiever during a sprint, you might get a bit winded.

class MyClass {
    // Fast, furious, and efficient
    private long timestamp = System.currentTimeMillis(); 
}

For fields that just need to be awake and alert without any heavy lifting, inline initializers can make your code a lean, mean, efficient machine.

The do’s and don'ts of Java initialization

Use inline initializers when you desire:

The simplicity of immutable fields: 'final' variables that aren't going anywhere.
The convenience of shared constants: Think universal laws like gravity.

Constructors are your friends when:

Immutable state is the need of the hour: Once set in the constructor, fields can chill and won't change.
You're dealing with complex operations: Think about tasks that need heavy computation and logic.

Be mindful of potential traps:

Don't stir up confusion by level-mixing: Keep complex initialization logic in constructors and simple ones inline.
Don't be Mr./Ms./Mx. Redundant: Initializing a field in both places might fly, but why do that when you can fly higher?

explain-codes / Java / Default constructor vs. inline field initialization

Linked

Should I initialize variable within constructor or outside constructor



Initialize class fields in constructor or at declaration?



Java Constructor Inheritance



Constructor in an Interface?



How do I call one constructor from another in Java?

