Re: Using an enum in a constructor

From:

Daniel Pitts <googlegroupie@coloraura.com>

Newsgroups:

comp.lang.java.programmer

Date:

Thu, 20 Sep 2007 21:59:56 -0000

Message-ID:

<1190325596.833143.320920@i13g2000prf.googlegroups.com>

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 {
}