Is there any speed/efficiency benefit to setting a class' instance variables in a constructor rather than in their declaration if they'll have a "default" value?

Question

For instance:

public class Foo {
    private int bar = 42;

    Foo() {}
}

vs

public class Foo {
    private int bar;

    Foo() {
        bar = 42;
    }
}

Is there any cost/benefit between the two methods? The only way I could see it making a difference is in a scenario like this (where you're setting a value twice for the second constructor):

public class Foo {
    private int bar = 42;

    Foo() {}

    Foo(int in) {
        bar = in;
    }
}

vs (where either way you're only setting it once)

public class Foo {
    private int bar;

    Foo() {
        this(42);
    }

    Foo(int in) {
        bar = in;
    }
}

Am I missing something? Is there any inherent value in doing it one way or the other?

<EDIT> Ok, I realize these are functionaly equivalent, What's I'm trying to figure out is if there are any significant processing costs associated with one over the other. Seems like it should be negligable, at best, but I'd like confirmation of my suspicions. </EDIT>

<EDIT2> I also realize that manually setting them eliminates the possibility of initilization logic. That's why I chose such simple examples. I edited the question text to reflect that what I'm interested in is efficiency. </EDIT2>

Answer 1

The two methods are equivalent. With that said, I'll add two things:

1. This tends to be more of an issue with final variables because obviously you can only set them once as you do in your third snippet; and
2. Try to chain your constructors together.

On (2) I think this is a better version:

public class Foo {
    private int bar;

    Foo() {
        this(42);
    }

    Foo(int in) {
        bar = in;
    }
}

By chaining constructors you can get default defaults in a nice DRY (don't repeat yourself) kind of way, particularly when dealing with several parameters that could have default arguments, various allowed types of parameters and non-trivial initialization. Ideally only one or maybe two of your constructors should have significant logic in them. The rest should just chain to another constructor.

If you want to make the class immutable (as Josh Bloch says, favour immutability) then:

public class Foo {
    private final int bar;

    Foo() {
        this(42);
    }

    Foo(int in) {
        bar = in;
    }
}

Lastly it might be worth making 42 a static final constant (private or public, as appropriate).

Answer 2

personally I prefer the first way as it is clearer what the value of the var is initially.

Answer 3

The main risk of setting fields to default values in a constructor is when people start adding multiple constructors and don't keep the fields consistent.

My own (unscientific) experience with legacy Java code is that if there are more than two constructors and more than two fields, 80% of the time something would not be correctly initialized.

Answer 4

There are advantages to initializing variables in the constructor. Sometimes initialization requires logic and that cannot be done if the variable's value is set as in your first example. The points that others have made about maintainability are valid however.

But Java provides us with the initializer block. Initializer blocks are copied into every constructor by the compiler. So if you are worried about the constructors being inconsistent then you can do this:

 public class Foo {
   private int bar;

   //initializer block
   {
      //initializing code here
   }

   Foo() {

   }
 }

The second option that you have is to chain the constructors as described by cletus.