Java – Object constructors with dynamic parameter lists

constructorsjavamethodsobjectparameters

I had a quick question and I was hoping someone could help me figure this out. I'm new to Java and I'm trying to learn about classes and objects and I see you can call parameters in the constructor of the class. Such as:

public class PairOfDice {
    public int[] dice = new int[2];     //Create an array of length 2 to hold the value of each die
    PairOfDice(int die1, int die2){     //Constructor
        dice[0] = die1;                 //Assign first parameter to the first die
        dice[1] = die2;                 //Assign second parameter to the second die
    }
}

But I'm wondering if it's at all possible to tell a constructor (or any method for that matter) to expect an arbitrary number of parameters. Such as:

public class SetOfDice {
    SetOfDice(int numberOfDice /*Further parameters*/){     //Constructor
        public int[] dice = new int[numberOfDice];          //Create an array with a length based on the value of the first parameter
        for(int counter = 0; counter < numberOfDice ; counter++) {
            //Insert loop here for populating array with the rest of the parameters
        }
    }
}

I'm guessing its not but I want to be sure. Can anyone give me some insight on whether something like this is possible? And if not, let me know if there's a better means to go about getting this result?

Best Answer

What you are looking for in Java is called 'varargs' (https://docs.oracle.com/javase/8/docs/technotes/guides/language/varargs.html)

For your example you would probably want your constructor signature to be

SetOfDice(int numDice, int... values)

Then you probably want some sort of sanity check to make sure that the number of dice equals the length of the values array. A vararg parameter is just treated as an array of said type.

Then just copy the contents of the array into a new copy.

Sorry for the lack of linking, I have no clue how to format from my phone.

Related Solutions

PHP – Best Methods for Function Parameter Validation

The general solutions to this problem are type safety (so that values are valid by construction) and encapsulation (so that values cannot be invalidated after construction). If your inputs and outputs have meaningful types, then the constructors of those types can enforce the properties you want. If validation is centralised, you don’t have to repeat it.

Let’s talk in pseudocode for a moment. As a contrived example, consider a function area(w, h) that computes the area of a rectangle. If you type the function as:

int area(int w, int h)

Then there is no guarantee that any of the invariants hold:

w and h are lengths
Being lengths, they must be non-negative
The result is an area

To enforce input constraints, you can always add validation to the function body:

int area(int w, int h) {
    assert(w >= 0);
    assert(h >= 0);
    return w * h;
}

Not only is this cumbersome, but it remains the responsibility of the caller to validate the result. If we use types that represent our units:

Area area(Length w, Length h) {
    return w * h;
}

Then nobody can give us a Volume when we expected a Length, and since a length cannot be negative, we don’t need to check for that.

PHP doesn’t enforce types statically, but you can prevent the construction of invalid objects by throwing exceptions from constructors that receive invalid inputs, and using immutable objects or accessors to prevent later invalidation.

Varargs vs Lists – Which to Use in Java Constructors and Methods

You're overthinking the problem. You want to use a list (array or some other iterable) for your arguments when it's likely the consumer of your function would already have things in a list. You want to use variable arguments when you might want to call a function with a different number of arguments.

A classic example of when you should use varargs is C's printf(). Using varargs makes sense here because, in the general case, there's no reason to put a bunch of arbitrary values in a list just to print something. A good example of where you'd probably want a list is a sum() where you're probably operating on a bunch of related values that would likely be stashed away together.

It's not something you need to be dogmatic about or have rules for. Use some common sense and write code that people can follow & doesn't force you to jump through arbitrary hoops.

Best Answer

Related Solutions

PHP – Best Methods for Function Parameter Validation

Varargs vs Lists – Which to Use in Java Constructors and Methods

Related Topic