How to call an empty constructor from another?

Question

I have some code like so:

public class Foo {
    private int x;

    public Foo() {
    }

    public Foo(int x) {
        try {
            //do some initialisation stuff like:
            this.x = x;
        }
        catch(Exception ge){
            //call empty constructor not possible
            //this();
            //this.EMPTY();
            //Foo();
        }
    }

    public static final Foo EMPTY = new Foo();
}

I'd like to know if it is possible to achieve something such as this (I know that calling another constructor must be the first statement in the constructor). I have looked around here on SO but haven't found anything as such, leading me to believe that perhaps, I ought to handle the error logic in the instantiating method.

What are you trying to achieve? i.e. why would you want to call an empty constructor? — Oliver Charlesworth, Jun 25 '17 at 11:24
No you can only call another constructor as *first* call in the constructor. — Willem Van Onsem, Jun 25 '17 at 11:25
@OliverCharlesworth I wanted to return an empty object, if object initialisation fails. That way I could simplify error checking code in the initialisation method — Dark Star1, Jun 25 '17 at 11:40
@DarkStar1 - In that case why don't you just do nothing in your `catch` block? (That said, it feels like you should probably be propagating an exception on failure, rather than silently doing something different than the caller expected). — Oliver Charlesworth, Jun 25 '17 at 11:45
The constructor with an argument has already done the equivalent of `this()` at the very beginning, so you don't need to do it again. — Lew Bloch, Jun 25 '17 at 16:12

c0der · Answer 1 · 2017-06-25T13:22:44.803

Just change the execution order :

public class Foo {

    Integer i;
    public Foo() {
        System.out.println("Empty constructor invoked");
    }

    public Foo(Integer i) {

        this(); //can be omitted

        try {
            System.out.println("i initialized to : "+i.toString());

        } catch (Exception ex) {

            System.out.println("i NOT initialized ");
        }
    }


    public static void main(String[] args) {

        new Foo(); //prints: Empty constructor invoked

        new Foo(5);//prints: Empty constructor invoked
                   //prints: i initialized to : 5

        new Foo(null);//prints: Empty constructor invoked
                   //prints: i NOT initialized 
    }
}

The only problem with that approach is that if in the `try` section he initialise 2 or more members. The exception can happen in the middle leaving some of the members with default values and some with overwritten values. — Roee Gavirel, Jun 26 '17 at 13:10

StuartLC · Accepted Answer · 2017-07-03T14:43:03.203

In general, it isn't great practice to call code which could throw in a constructor, and worse then suppress the exception from the caller altogether. However, what you could do is refactor your code so that you move the 'default' initialization of the parameterless constructor into a helper method, which you can then call from your exception handler in the second constructor:

public class Foo {
    private int x;

    public Foo() {
      doDefaultInitialize();
    }

    public Foo(int x) {
        try {
          // dodgy code which could throw
        }
        catch(Exception ge){
          doDefaultInitialize();        
        }
    }

    private void doDefaultInitialize() {
       // Fallback initialization goes here
       x = 42;
    }
}

Roee Gavirel · Answer 3 · 2017-06-26T13:12:08.433

As you said

calling another constructor must be the first statement in the constructor

There are 2 solution I usually use when I need this behavior:

Make an init function and call it from both places:

public class Foo {
    private int x;

    public Foo() {
        init();
    }

    public Foo(int x) {
        try {
            //do some initialisation stuff like:
            this.x = x;
        }
        catch(Exception ge){
            init();
        }
    }

    private init() {
        //Do the default initialization here...
    }

    public static final Foo EMPTY = new Foo();
}

Make a static function to initialize the object and return it.

public class Foo {
    private int x;

    private Foo() {
        this.x = 42;
    }

    private Foo(int x) throws Exception {
        //do some initialization stuff like:
        this.x = x;
    }

    public static Foo getNewInstance(int x) {
        try {
            return new Foo(x);
        } catch (Exception e) {
            return new Foo();
        }
    }

    public static final Foo EMPTY = getNewInstance();
}

Why do they need to do all that? They already have what they asked for without doing a darned thing. — Lew Bloch, Jun 25 '17 at 16:13
Ha? If they had what they required they wouldn't have to ask about it here. — Roee Gavirel, Jun 26 '17 at 06:34

score 1 · Answer 4 · answered Jun 25 '17 at 11:55

Just do nothing in the catch block in the constructor. It should work as you want. However, do have a look at this try-catch-in-constructor-recommended-practice for choosing the right approach to your problem.

Also, if you are doing any default initializations, then follow the approach mentioned by @StuartLC

How to call an empty constructor from another?

4 Answers4