is there a way of making default values in a class, so passing those variables are optional in a constructor?

in ActionScript you would do something like:

Code:

myClass {
...
myClass (int x, int y, boolean doIt = true) {
....
}
}
 

so you would have the option of declaring:
dot = new myClass (1,2);
or
dot = new myClass (1,2, false);


i know that you can declare the class twice, without the addittional value, but it looks really messy if you've got a lot of variables floating around, and a lot of doubling up of code:

Code:

myClass {
...
myClass (int x, int y, boolean doIt = true) {
....
}
myClass (int x, int y) {
....
}
}
 

is there a neater way of doing this?

Code:

myClass {
  int x;
  int y;
  int doIt = true;
  myClass(int _x, int _y, boolean _doIt) {
    this(_x, _y);
    doIt = _doIt;
  }
  myClass(int x, int y) {
    x = _x;
    y = _y;
    // doIt has default value defined in declaration
  }
} 

Java relies on function overloading/polymorphism, so has no optional parameters. The resulting code is heavy, so we usually offer a limited number of similar functions...
Another way is just to set fields after object creation, directly or with setters (setX(5)).

If you make your "setter" methods return the object reference (instead of being void), you can chain the object creation with setting. I don't know if this is "good practice", but it seems to work, and may be handy in situations where you want a new object "right here right now" (eg in the middle of some expression, as an argument to some other method, etc).

Code:

void setup() {
  Doer doer = new Doer().x(20).y(30).doIt(false);
  println("doer.x: " + doer.x);
  println("doer.y: " + doer.y);
  println("doer.doIt: " + doer.doIt);
}

class Doer {
  int x; // Default 0
  int y; // Default 0
  boolean doIt = true; // Default true
  
  // Setters
  Doer x(int x) {
    this.x = x;
    return this;
  }
  Doer y(int y) {
    this.y = y;
    return this;
  }
  Doer doIt(boolean doIt) {
    this.doIt = doIt;
    return this;
  }
} 

Note that Java allows the same identifier to be used for a data member and method name(s), so "doIt" is separate to "doIt()".

If it is usual to specify x,y values at construction time, it makes sense to specify a constructor that accepts those parameters. You could still do this:

Code:

Doer doer = new Doer(22,33).doIt(false); 

Also note that having multiple method calls is (likely) to have a performance impact compared to a single "dedicated" constructor that does everything you want in one go, so avoid doing this kind of thing in performance-critical code.

-spxl

ah thanks subpixel. that's exactly what i needed. and an interesting way of doing things.
PhilLo's way works. but what i was trying to get at was not having to use them in the constructor, so you only neatly declaring what you need.

Not as neat as ActionScript, but does the job, thanks.
And not that I'm a far of ActionScript - exact opposite, in fact.


cheers