How to handle Java default constructor parameters of type array? (Without static factory methods or builder patterns)

Question

Is there any method, other than through static factory methods or builder patterns, to handle default constructor parameters of type array?

There is plenty of fruitful discussion here regarding how to do this with builder patterns and static factory methods, and there are plenty of other examples out there of how to handle various constructors of varying parameter count, but all these patterns appear to include only parameters of simple type (e.g. int, double, etc.), which I have no problem getting to work. I am trying to have a default parameter of type array, and am unable to achieve this with the standard constructor setup.

It tried a few approaches to this and they all result in errors of some kind, so I am searching for an alternative, still making use of a constructor pattern. The first approach:

public class MyClass{

    double[] mWeights;

    public MyClass(){
        double[] weights = {1, 1, 1}
        this(weights);
    }

    public MyClass(double[] weights){
        this.mWeights = weights
    }
}

but this results in an error:

Call to 'this()' must be first statement in constructor body

Alternatively, I tried:

public class MyClass{

    double[] mWeights = new double[] {1, 1, 1};  

    public ActionDistribution(){
        this(mWeights); 
    }  

    public ActionDistribution(double[] weights){  
        this.mWeights = weights;
    }
}

but this results in an error:

Cannot reference 'MyClass.mWeights' before supertype constructor has been called.

Lastly, I tried:

public class MyClass{

    double[] Mweights;  

    public ActionDistribution(){
        this({1, 1, 1}); 
    }  

    public ActionDistribution(double[] weights){  
        this.mWeights = weights;
    }
}

but this results in the error:

Array initializer is not allowed here

Any ideas as to how I can set up a constructor to handle a default array without the use of static factory methods or builder patterns? Bonus points if you have a solution that works for any generic type (and not just arrays), and even more points for explaining why this is possible for simpler data types and not arrays.

Edit: In case it is not clear, in a working form of the code above, I am hoping to later call

MyClass myClass = new MyClass();

and have it result in a myClass object with a field myClass.mWeights of value {1, 1, 1}

Answer 1

You most likely want to use new double[] { ... } syntax:

class MyClass{

    public MyClass(){
        this(new double[] { 1, 1, 1});
    }

    public MyClass(double[] weights){
        this.mWeights = weights;
    }
}

The array creation syntax is explained in §JLS 15.10.1. Array Creation Expressions. As per §10.6. Array Initializers:

An array initializer may be specified in a field declaration (§8.3, §9.3) or local variable declaration (§14.4), or as part of an array creation expression (§15.10.1), to create an array and provide some initial values.

In your case you are not assigning a field or a local variable so you can't use array initializer shorthand. Method (and constructor) parameters require full array creation syntax.

Answer 2

You can use .. syntax as well:

public class MyClass {

    double[] mWeights;

    public MyClass(double... mWeights) {
        mWeights = mWeights;
    }
    public MyClass(){
        this(1, 2, 3);
    }

}

Answer 3

You could just use your second approach an leave your constructor empty instead:

public class MyClass {

    double[] mWeights = new double[] {1, 1, 1};  

    public ActionDistribution(){}  

    public ActionDistribution(double[] weights){  
        this.mWeights = weights;
    }
}

Ititializing your class with the default empty constructor will leave your weights as you initialized them in your Class field with {1, 1, 1}.