Re: Using an enum in a constructor
On Sep 20, 2:34 pm, Wojtek <nowh...@a.com> wrote:
Daniel Pitts wrote :
On Sep 20, 1:33 pm, Wojtek <nowh...@a.com> wrote:
Given the following:
---------------------------------
public class Foo
{
private static final int DEFAULT_LENGTH = 30;
private Type ivType;
private int ivLength;
public enum Type
{
OTHER,
FIXED,
VARIABLE;
}
public Foo(Type type)
{
this(type,DEFAULT_LENGTH);
}
public Foo(Type.VARIABLE varType, int length)
{
this(varType,length);
}
private Foo(Type type, int length)
{
super();
ivType = type;
ivLength = length;
}}
---------------------------------
The compiler complains that Type.VARIABLE cannot be used. Obviously
what I want is that if the Type is VARIABLE, then I want the length in
the constructor, otherwise I will use the default length.
And yes I know I can have a constructor that only takes (int length)
and then assume that the Type is VARIABLE. That is not the point here.
--
Wojtek :-)
Try using the Static Factory approach instead
public class Foo {
enum Type {
a, b, c
}
private Foo(Type type, int length) {
// ...
}
public static Foo createVariable(int length) {
return new Foo(Type.a, length);
}
public static Foo createSomething(Type type) {
return new Foo(type, DEFAULT_LENGTH;
}
public sattic Foo createSomething(Type type, int length) {
return new Foo(type, length);
}
}
This is the same as having a constructor which takes just (int length).
I still need to make an assumption that type is VARIABLE.
--
Wojtek :-)
Its not an assumption, its explicit by the name of the method
"createVariable"!
In general though, if you have a "Type" token, you might be going
about your solution the wrong way. Have you considered using a more
polymorphic approach?
abstract class Foo {
}
class VariableFoo extends Foo {
}
class OtherFoo extends Foo {
}
etc...
That way, the "Type" of foo, is actually the *type* of foo! (Go
figure).
Or, if the Type can change over time, use the State pattern (same
idea, just wrapper)
class Foo {
FooType type;
public Foo(FooType type) {}
}
abstract class FooType {
}
class FooVariable extends FooType {
FooVariable(int length) {}
}
class FooOther extends FooType {
}