Enum == static ?

Hi
I'm learning Enum...
And I have a question: each component of an Enum is static ?
For example, in:
enum State { INIT, ACTIVE; State() {} }
State.INIT and State.ACTIVE can be considered as:
static final State INIT = new State(); and static final State ACTIVE = new State();
In this case, a state machine pattern in a StateFullObject can be specified using the Enum...
but only if the state behavior is common to all instances of StateFullObject
or if StateFullObject is itself a Singleton pattern ...
Isn't it ?
Regards
Ludovic

And I have a question: each component of an Enum is
static ?Yes.
In this case, a state machine pattern in a
StateFullObject can be specified using the Enum...
but only if the state behavior is common to all
instances of StateFullObject
or if StateFullObject is itself a Singleton patternYes.

Similar Messages

Typesafe Enums

I do not use J2SE 5.0, and I need to use an enumerator-like construct. My original code was:
// Constants to be used with runnersOnBase
public static final short RUNNER_ON_FIRST = 1;
public static final short RUNNER_ON_SECOND = 2;
public static final short RUNNER_ON_THIRD = 4;Obviously this is not a great practice, so I decided to try typesafe enums, which are explained here: http://java.sun.com/developer/Books/shiftintojava/page1.html#replaceenums
The problem I'm having comes from the fact that, in my program, I can add the integer constants together. Is there a similar way to do that with typesafe enums, and if so, how should the enum class be set up? Thanks a lot. Take care.

The problem I'm having comes from the fact that, in
my program, I can add the integer constants together.
Is there a similar way to do that with typesafe
enums, and if so, how should the enum class be set
up? Thanks a lot. Take care.Something like
public class Enum {
private static Map enums;
public static Enum A = new Enum();
public static Enum B = new Enum();
public static Enum C = new Enum();
static {
   enums.add( Integer.valueOf( 0 ), A );
   enums.add( Integer.valueOf( 0 ), B );
   enums.add( Integer.valueOf( 0 ), C );
public static Enum add( Enum a, Enum b ) {
   int av = enums.get( a );
   int bv = enums.get( b );
   Enum value = enums.get( Integer.valueOf( av + bv ) );
//   if( value == null ) throw some exception maybe?
   return value;
}maybe?

Having trouble with AdjustmentListener

(i hope i have the right forum for this) So code is worth a thousand words, so here it is.
class theColorProgram extends JFrame
JPanel colorViewer;
public theColorProgram()
     this.colorViewer = new JPanel();
     this.colorViewer.setBackground(new Color(00, 00, 00));
public void adjustColorViewer(int value, colorSaturation.primaryColor color)
     green = this.colorViewer.getBackground().getGreen();
public static void main(String [] args)
theColorProgram window = new theColorProgram();
class colorSaturation extends JPanel
public static enum primaryColor{RED, GREEN, BLUE}
private class scrollerChange implements AdjustmentListener
public void adjustmentValueChanged(AdjustmentEvent event)
          colorSaturation.this.addjustSaturationLabel(event.getValue());
          //theColorsProgram.adjustColorViewer(event.getValue(), this.color);
colorSaturation.primaryColor color;
JLabel saturation;
JPanel saturationbg;
public colorSaturation(colorSaturation.primaryColor color)
     this.saturationbg = new JPanel();
     this.saturation = new JLabel("00 / 000");
     this.saturationbg.add(this.saturation);
public void addjustSaturationLabel(int value)
     if(value < 128)
     this.saturation.setForeground(Color.white);
     else
     this.saturation.setForeground(Color.black);
I tried to remove as much of it as possible while leaving my problem. I can't figure out how to have the commented line of code work. I cant nest the other classes with the enum (static content in non static). please help?

theColorProgram.java:270: not an enclosing class: theColorProgram
          theColorProgram.this.adjustColorViewer(event.getValue(), this.color);
and adjustColorViewer, is not static (nor intended to be), i need the adjustment to be called on the instance of the class containing the scroll bars. Also tried imbeding in the classes that hold the scrollbars, but it contains an enum and I recieve another error about static enum in non static content.

Q: new language features and JVM 1.4

I just finished reading Joshua Bloch's article on new Java language feature and am looking forward to their introduction.
Will programs compiled using the new features (generics, enhanced for, autoboxing, enums, static imports, and metadata) still run under a JVM 1.4?
I understand that a program that uses new gizmos from Swing, etc. will NOT run, but how about these language features?
Thanks, Ralph

Objects you would like to use in the new for loop syntax must be >instances of the Iterable interface which will be added to the >java.lang package. The Collection interface will extend Iterable. This >will allow arbitrary type to be used in the new for loop without
having to extends Collection. ah ok, why is this needed over doing plain syntactical transformations at compile-time e.g.
for( o : myarray ){
code
goes to
for(int i=0; i<myarray.length; i++){
Object o = myarray<i>;
code
or
for( o : myCollection ){
code
goes to
for(Iterator i = myCollection.iterator(); i.hasNext(); ){
Object o = i.next();
code
(I don't see why typing the element holder couldn't be automated too?)
asjf

Using static .values() method of Enum in Generic Class

Hi *,
I tried to do the following:
public class AClass<E extends Enum<E> > {
     public AClass() {
          E[] values = E.values(); // this DOESN'T work
          for (E e : values) { /* do something */ }
}This is not possible. But how can I access all Enum constants if I use
an Enum type parameter in a Generic class?
Thanks for your help ;-) Stephan

Here's a possible workaround. The generic class isn't adding much in this case; I originally wrote it as a static method that you simply passed the class to:
public class Test21
public static enum TestEnum { A, B, C };
public static class AClass<E extends Enum<E>>
    private Class<E> clazz;
    public AClass(Class<E> _clazz)
    { clazz = _clazz; }
    public Class<E> getClazz()
    { return clazz; }
    public void printConstants()
      for (E e : clazz.getEnumConstants())
        System.out.println(e.toString());
public static void main(String[] argv)
    AClass<TestEnum> a = new AClass<TestEnum>(TestEnum.class);
    a.printConstants();
}

Why is this static import of an Enum not working?

I get the error:
State.java:3: cannot find symbol
symbol: class Command
import static Command.*;
^
/** FIRST CLASS **/
import static Command.*;
public enum State
     Authorization( new Command[] { USER, PASS, APOP, QUIT } ),
     Transaction( new Command[] { STAT, LIST, RETR, DELE, NOOP, RSET, UIDL, TOP, QUIT } ),
     Update( new Command[] { QUIT } );
     private Command[] allowedCommands;
     State(Command[] allowedCommands)
          this.allowedCommands = allowedCommands;
     //Rest is elided...
/** SECOND CLASS **/
public enum Command
     USER, PASS, APOP, QUIT, STAT, LIST, RETR, DELE, NOOP, RSET, TOP, UIDL;
}

DrClap wrote:
You forgot to include the name of the package which the Command enum is in. Your import statement should look like this:
import static package.Command.*where "package" is the name of the package.Yes, I was just testing something with the enums before putting it back into my classes with packages. So the test had no packages. When I retried it in my classes (with packages) it worked. Thanks!
If Java (i.e. the JVM) is going to have restrictions on things working without packages, why allow not using them at all? Shouldn't it just require packages instead of undocumented and inconsistent restrictions?

Alpha compuler cant compile enums or static imports?!?

Pardon me if this is the wrong place to ask this question but I couldnt find any forums specific to CAP program members:
When trying to compile enums and static imports that work with the public prototype compiler, I get the following errors:
C:\dev\hcj\tiger\src>c:\j2sdk1.5.0\bin\javac -version oreilly/hcj/tiger/*.java
javac 1.5.0-beta
oreilly/hcj/tiger/EnumAttach.java:18: 'class' or 'interface' expected
public abstract enum EnumAttach {
                ^
oreilly/hcj/tiger/EnumAttach.java:35: 'class' or 'interface' expected
^
oreilly/hcj/tiger/ErrorLevel.java:20: 'class' or 'interface' expected
public enum ErrorLevel {
       ^
oreilly/hcj/tiger/ErrorLevel.java:31: 'class' or 'interface' expected
^
oreilly/hcj/tiger/ForEach.java:49: ';' expected
                for (String person: importantPeople) {
                                  ^
oreilly/hcj/tiger/ForEach.java:55: illegal start of expression
        ^
oreilly/hcj/tiger/ForEach.java:81: ';' expected
                for (String person: people) {
                                  ^
oreilly/hcj/tiger/ForEach.java:87: illegal start of expression
        ^
oreilly/hcj/tiger/StaticImports.java:15: <identifier> expected
import static StatusColors.*;
       ^
oreilly/hcj/tiger/StaticImports.java:15: '.' expected
import static StatusColors.*;
                            ^
oreilly/hcj/tiger/StaticImports.java:16: <identifier> expected
import static java.lang.Math.*.
       ^
oreilly/hcj/tiger/StaticImports.java:21: '.' expected
public class StaticImports {
       ^
12 errorsIs there something I am doing wrong or is this known bug?

Use the compiler flag -source 1.5

Enum vs static final String

I was going to use static final Strings as enumerated constants in my application, but would like to see if I should be using enums instead.
In terms of efficiency, if I have, say, 5 enumerated elements, will only one copy of the enumerated element be in memory, like a static final String? So regardless of how many times I refer to it, all references point to the same instance (I'm not sure if what I just said even makes sense in the context of enums, but perhaps you could clarify).
Are there any reasons why for enumerated constants that are known at development time, why static final Strings (or static final anything, for that matter) should be used instead of enums if you're using JDK 1.5?
Thanks.

In terms of efficiency, if I have, say, 5 enumerated elements, will only one copy of
the enumerated element be in memory, like a static final String?I don't know if it addesses your concerns, but the the Java Language Specification says this about enums: "It is a compile-time error to attempt to explicitly instantiate an enum type (�15.9.1). The final clone method in Enum ensures that enum constants can never be cloned, and the special treatment by the serialization mechanism ensures that duplicate instances are never created as a result of deserialization. Reflective instantiation of enum types is prohibited. Together, these four things ensure that no instances of an enum type exist beyond those defined by the enum constants." (http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.9)
As for the problems of memory usage, how big are these strings anyway?
The advantages of using enums over static final strings are discussed in the "technotes" accompanying 1.5 http://java.sun.com/javase/6/docs/technotes/guides/language/enums.html They list the following as problems with the static final "antipattern"
* It is not typesafe (methods that expect one of your constants can be sent any old string)
* There is no name space - so you must continually be sure that your constants don't have names that may be confused
* Brittleness. Your strings will be compiled into the clients that use them. Then later you add a new constant...
� * Printed values will be uninformative. Perhaps less of a problem for Strings, but, still, simply printing the string will leave its semantic significance obscure.

Sun's demo using enum doesn't seem to work for me

I'm trying to run a demo from the Sun website, http://java.sun.com/docs/books/tutorial/java/nutsandbolts/switch.html, which includes the enum statement:
public class SwitchEnumDemo {
    public enum Month { JANUARY, FEBRUARY, MARCH, APRIL,
                        MAY, JUNE, JULY, AUGUST, SEPTEMBER,
                        OCTOBER, NOVEMBER, DECEMBER }
    public static void main(String[] args) {
        Month month = Month.FEBRUARY;
        int year = 2000;
        int numDays = 0;
        switch (month) {
            case JANUARY:
                // etc etc ...
        System.out.println("Number of Days = " + numDays);
}However, copying-and-pasting the code into NetBeans, I get an error on the enum declaration stating: '';' expected. Warning: as of release 1.5, 'enum' is a keyword and may not be used as an identifier'. Well... I know that. Isn't that why I'm using it in the first place? Or am I confused?
I'm using NeBeans 5.0 on Java 1.5.0_06.
Any advice?
Question 2: Once I get this thing working, is there any way I can get the month as an input from the user, without needing a long block stating
if (input = "January") month = Month.JANUARY;
else if (input = "Feburary") month = Month.FEBURARY;
//etc etcThat is, can the string representation of a month be somehow kept within the enumerated Month itself, and that be used to check the user's input?
Thanks for any advice!

However, copying-and-pasting the code into NetBeans,
I get an error on the enum declaration stating:
'';' expected. Warning: as of release 1.5, 'enum'
is a keyword and may not be used as an
identifier'. Well... I know that. Isn't
that why I'm using it in the first place? Or am I
confused?
I'm using NeBeans 5.0 on Java 1.5.0_06.I can't say for sure about that; it seems very odd. However, I do know that my IDE will warn me about those sorts of things if I configure my project for pre-1.5 operation. It allows me to say a project is for Java 1.4 even if I'm using a 1.5 JVM and will mention things like that so that forward compatibility can be considered. I don't suppose this could be the case with your situation?
You might want to search for all instances of "enum" in your code, though, because it's hard to imagine the one instance which appears in the snippet you posted causing problems.
Question 2: Once I get this thing working, is there
any way I can get the month as an input from the
user, without needing a long block stating{snip}
Well, in this case you can just do
for (Month m : Month.values())
    if (m.toString().equalsIgnoreCase(input))
        month = m;
        break;
}or you can build a Map<String,Month> if you're looking for case-sensitive comparison.
In general, however, you can put pretty much anything into an enum:
public enum SomeEnum
    A(0),
    B(0),
    C(1),
    D(0),
    E(2);
    private int value;
    SomeEnum(int value)
        this.value = value;
    public int getValue()
        return value;
// the following is perfectly legal
SomeEnum e = methodThatReturnsSomeEnum();
System.out.println(e.getValue());and you could use that to put some form of identifier in the enumeration object. I have a class around here somewhere which uses an enum to enumerate the operators in an expression parser; the Operator enum constructor accepts an int specifying the operator precedence.

What's the deal with enums?

Hello,
I'm trying to familiarise myself with the new Java features that project Tiger (Java 1.5) will introduce. I come from a C++ programming background. I very briefly studied enums whilst I learned C++ and never used them in my programs, so I was, quite frankly, relieved when I learned that Java didn't support them.
But now it does.
I'm wondering, from a software design and engineering perspective, what benefit enums will add to the Java language and software engineering in general. I have read some pleas and arguments for enums. As I understand those arguments, proponents feel that minor ledgibility improvements to switch statements (which some OO programmers don't use on the basis that it weakens the object-orientedness through its goto-esque break statements) necessitate the addition of a whole other structure.
Out of curiosity, wouldn't it be more advantageous for Sun to put their efforts into supporting constant strings in switches in addition to primitive data types if people are so concerned with clarity?
I fail to understand what enums will do that constant string arrays or constant values cannot. I would like to think that Sun wouldn't add C++ features unless if there was a reason to do so, so I believe that there are good reasons to introduce this feature.
Please help clarify this confusion.
Thank you!

Comments on the previous posting inline. Note: I'll go off on a few tangents, but try to always return to the issue of enums. The fact that I go off on tangents (related initially to an enum type example) should show that enums help eliminate numerous problems.
Fair enough, but wouldn't this accomplish the same thing in
a slightly wordier wayPretty much. But you still have the validation code in there yourself:
currentDirection = ( direction > 0 && direction < 5 ? direction : 0 );People can still accidentally enter an invalid value, and it won't get caught by the compiler. So, I could call set(Compass.WEST) and hope/expect that is equivalent to set(Direction.LEFT). This will only occur if both Compass.WEST and Direction.LEFT are the same int value. If they are not, then we are in trouble. Worse, still if Compass.WEST and Direction.RIGHT are the same value, the code will compile, and run without any illegal value flagging, but our traveller will go off in the wrong direction.
Error handling tangent: Given the implementation, the error handling is not performed in set, rather the illegal value is captured as a zero, which must be dealt with at a later time - say in a switch statement that calls get. This is not a good idea - it increases the "distance" between the error occuring (bad call to set) and the error being detected (if xInt != 0). The larger the distance, the harder debugging is. If you throw an exception in set the bug is immediately flagged. With enums, none of this should be necessary.
Implementation tangent: set, get and currentDirection are static. This is not a good idea - it only allows one direction. If you have multiple travellers, each would have a Direction object, but (sticking with constants) UP, etc. would still be static.
I keep the switch statement in my enum workaround, but I believe that
the second reply suggested that enum could altogether eliminate the
use for switch statements. How exactly would it do that?enum in its simplest form would not remove switch. However, using an extension of the type-safe enum idiom (i.e. the current Java approach to enums), you can embed direction specific logic in each of the "enum" members. If I understand the enum-spec correcly, this will also be possible with the Java 1.5 enum language facility.
So, for an example, sticking with the domain: Consider a class Location, with x and y elements, and a Direction. The non-OO, non-enum approach would be as follows:
class Location {
    int x,y;
    void move (final int direction) {
        switch (direction) {
            case UP:
                --y;
                break;
            case DOWN:
                ++y;
                break;
            case LEFT;
                --x;
                break;
            case RIGHT:
                ++x;
                break;
            default;
                throw new RuntimeException("Invalid direction " + direction);
class Direction {
    public static final int UP = 1;
    public static final int DOWN = 2;
    public static final int LEFT = 3;
    public static final int RIGHT = 4;
}Note that I've deliberately been loose with my visibility. All logic is in Location, and Direction is dumb. If we go with a type safe-enum idiom, we get:
class Location {
    int x,y;
    void move (final Direction direction) {
        if (direction == Direction.UP) {
            --y;
        } else if (direction == Direction.DOWN) {
            ++y;
        } else if (direction == Direction.LEFT) {
            --x;
        } else if (direction == Direction.RIGHT) {
            ++x;
        } else { // direction is null
            throw new NullPointerException("null direction");
class Direction {
    public static final Direction UP = new Direction();
    public static final Direction DOWN = new Direction();
    public static final Direction LEFT = new Direction();
    public static final Direction RIGHT = new Direction();
    private Direction () {} // the ctor is private to limit instances
}This code is a rewrite of the int approach, but is "type-safe". We've moved from switch to if as we can't switch on object references. Note: there is still error handling code, as you're not "null-safe" (I don't know what the Java 1.5 spec says about this)
Little else has changed - the responsibilities are still the same. We can address this by going OO, which removes the if (formerly a switch) statement, but does couple the classes.
class Location {
    int x,y;
    void move (final Direction direction) {
        direction.move(this);
class Direction {
    private final int xOffset, yOffset;
    private Direction (final int xOffset, final int yOffset) {
        this.xOffset = xOffset;
        this.yOffset = yOffset;
    public static final Direction UP = new Direction(0,1);
    public static final Direction DOWN = new Direction(0,-1);
    public static final Direction LEFT = new Direction(-1,0);
    public static final Direction RIGHT = new Direction(1,0);
    void move(final Location location) {
        location.x += xOffset;
        location.y += yOffset;
}This removes any conditional logic, embedding (constructor parameterised) logic within Direction. It also eliminates the "null-safe" check, as direction.move(this) will throw an NPE if a null is passed.
Also, I've read some things saying that enum reduces 'boilerplate'
code. What exactly does that and 'boilerplate' mean?The Direction class is an example of the type-safe enum approach currently used in Java. It has been enhanced with logic for movement. Even if I dropped this logic, there is still functionality worth adding to the Direction class - a toString method that returns one of "UP", "DOWN", etc (shown next); a way to serialize the object and retain reference equality - you have to write a readResolve method (not shown).
class Direction {
    private final String name;
    private Direction (final String name) {
        this.name = name;
    public static final Direction UP = new Direction("UP");
    public static final Direction DOWN = new Direction("DOWN");
    public static final Direction LEFT = new Direction("LEFT");
    public static final Direction RIGHT = new Direction("RIGHT");
    public String toString() {
        return name;
}Once you've written this code for one type-safe enum, you've written them for them all. You copy-cut-paste, and rename the class/elements. All this code is predictable. It is "boiler plate". Now, if you gave me a compiler that generated all this code for me, when I present it with
enum Direction {UP, DOWN, LEFT, RIGHT}; then I've got something that reduces my boiler plate code to zip.... Enter the Java 1.5 compiler.

What's the best way to use an enum to validate statuses

I am trying to write and use an enum to represent a status code and validate status code values. Ultimately the input data from another system and the database will be 1 or 2 i.e.the indexes and the java code will use the LIVE and CANCELLED when referring to the status. The code I have written
public class TestEntityStatus {
     private static EntityStatusImpl es;
     public static void main(final String args[]){
                es = new EntityStatusImpl();
                es.setStatusCode("1"); // valid test
                es.setStatusCode("3"); // invalid test
}The EntityStatusImpl class:
public class EntityStatusImpl {
    private String statusCode;
    public EntityStatusImpl() {
    public final String getStatusCode() {
        return statusCode;
    public final void setStatusCode(final String statusCode) {
         String allStsIndexesAsRegExpr = "[";                                                                                 //
            EntityStatus allStatuses [] = EntityStatus.values();                                                     // would like to
            for(EntityStatus e : allStatuses)                                                                                // put this code
                allStsIndexesAsRegExpr = allStsIndexesAsRegExpr + e.getStatusCode();   // in the enum
            allStsIndexesAsRegExpr = allStsIndexesAsRegExpr + "]";                                        // EntityStatus
            System.out.println(" allStsIndexesAsRegExpr = " + allStsIndexesAsRegExpr);           //
             if (statusCode.matches(allStsIndexesAsRegExpr)) {
                 this.statusCode = statusCode;
             else {
                  throw new IllegalArgumentException("Entity status " + statusCode + " is invalid");
}The EntityStatus enum has a method "getAllIndexesAsRegex" which I would like to call. However, my understanding of enums is preventing me from doing so.
If I declared an EntityStatus, I expected that I would be able to get all of the indexes back as follows in
EntityStatus x;
x.getAllIndexesAsRegex();
Instead I have to copied the code from the enum into the setStatusCode method above, where it works but does not seem to be in the right place.
public enum EntityStatus {
                 LIVE(1), CANCELLED(2);
                 private int index;
             private EntityStatus(int index) {
                 this.index = index;
              public int getStatusCode(){
                       return index;
              public String getAllIndexesAsRegex(){
                   String output = "[";
                   PromiseStatus allStatuses [] = PromiseStatus.values();
                   for(PromiseStatus p : allStatuses)
                        output = output + p.getStatusCode();
                   output = output + "]";
                   return output;
     }The java tutorial doesn't seem to throw much light on this type of application of enums for me, neither does Herbert Schilt's excellent book on Java 5.
Can anyone spot any flaws in my logic or suggest better ways of achieving this?

If you want to ensure type safety and retrict the user to a range of values it seems to me you are over complicating
the implementation. Simply change your Impl class accessor and mutator methods to accept and return the enum
type respectively. For example:
private EntityStatus entityStatus;
public EntityStatus getEntityStatus()
   return entityStatus;
public void setEntityStatus(EntityStatus entityStatus)
if (entityStatus == null)
    throw new IllegalArgumentException("Invalid entity status!");
this.entityStatus = entityStatus;
}The one downside is that you are retrieving the actual underlying enum values from external source systems which you need to map back to your
enum types. Unfortunately the Enum class does not have a method that will return what you need (the valueOf method returns the enum type
based on the enum name). However you can provide a method in your enum class that will map the external source values to the enum. Below is
one such implemetation.
import java.util.HashMap;
import java.util.Map;
public enum EntityStatus
LIVE("1"),
CANCELLED("2");
private String statusCode;
private static Map<String,EntityStatus> enumMap = new HashMap<String,EntityStatus>(EntityStatus.values().length);
static
    enumMap.put(LIVE.getStatusCode(),LIVE);
    enumMap.put(CANCELLED.getStatusCode(),CANCELLED);
private EntityStatus(String statusCode)
    this.statusCode = statusCode;
public String getStatusCode()
    return statusCode;
public static synchronized EntityStatus deriveObject(String statusCode)
    return enumMap.get(statusCode);
}Below is a usage example:
public static void main(String args[])
    EntityStatus status1 = EntityStatus.deriveObject("1");
    EntityStatus status2 = EntityStatus.deriveObject("2");
    EntityStatus status3 = EntityStatus.deriveObject("3");
    System.out.println(status1);
    System.out.println(status2);
    System.out.println(status3);
}

Using enum's from one class in another?

heya,
I have two classes, Predator and Simulation, and Predator has an public enum 'target' inside it.
Simulation needs to use a switch statement based on target (Simulation contains a list of Predators, and I'm returning type target to Simulation), but I am getting errors when compiling the two classes from the commandline (for some weird reason, it works fine in Eclipse - both classes are in a package 'lepidoptera', which I originally thoguht was the issue).
Errors are like (5 of these):
Simulation.java:64: an enum switch case label must be the unqualified name of an enumeration constant
                case (mimic):Any ideas?
Thanks,
Victor

This works for moi:
public class Predator {
    public enum Target {SEITAN, TOFU, TEMPEH}
public class Simulation {
    public static String f(Predator.Target target) {
        switch(target) {
            case SEITAN:
                return "yuck";
            case TOFU:
                return "ugh";
            case TEMPEH:
                return "crikey";
            default:
                return "nuts";
    public static void main(String[] args) {
        System.out.println(f(Predator.Target.SEITAN));
        System.out.println(f(Predator.Target.TOFU));
        System.out.println(f(Predator.Target.TEMPEH));
}And do you know that an enum can be a top level class? In other
words, that you can create the one-line file Target.java:
public enum Target {SEITAN, TOFU, TEMPEH}

Automatic generation of enum members from name Strings

I have a program in which I read information about Target objects from a text file. I store some of this information as an enum property of the target.
}else if (itemKey.equalsIgnoreCase( "type")) {
currentTarget.descriptor= itemValue;
currentTarget.type = Target.getTargetType(currentTarget.descriptor);And elsewhere in the program I do the file reading and assignment of instance variables:
class Target{
enum TargetType {COUGH_DROP, RICE_CRACKER, PEPTO_BISMOL,UNDETERMINED};
String descriptor;
TargetType type;
returns the target' s type as specified by a descriptor
public static TargetType getTargetType (String descriptorString) {
if (descriptorString.equals( "rice cracker")) {
return (TargetType.RICE_CRACKER);
} else if (descriptorString.equals ("cough drop")){
return (TargetType.COUGH_DROP);
} else if (descriptorString.equals ("Pepto-Bismol")){
return (TargetType.PEPTO_BISMOL);
} else {
return (TargetType.UNDETERMINED);
} I would like to be able to automatically generate the members of the TargetType enum from a list of strings as opposed to needing a method such as getTargetType above. Is this possible?
Regards,
Joe
PS: I completely apologize for the appearance of the code above. I have no idea why this editor removed my indentation and added HTML markers. (I copied the code from a text editor, pasted into this editor, selected the code sections and clicked on the code button )
PPS I now see that after a couple of switches between preview and rich text in the HTML markers have disappeared. WTF?

I'm very curious to understand why one would like to create enum constants at run time? How can therse enums be used in the code that is not created at runtime? What are you really trying to achieve
I know you marked your question as answered, but... you may have a look at the code below. It is a very very simple example of how to map real life descriptions (at runtime) to pre-existing enums. I didn't test it, but for all I know it should just work. Does this solve the problem that you are experiencing?
import java.util.HashSet;
import java.util.Set;
public enum TargetType {
    RICE_CRACKER("C:/Descriptions/RiceCrackers.txt"),
    COUGH_DROP("C:/Descriptions/CouphDrops.txt"),
    PEPTO_BISMOL("C:/Descriptions/PeptoBismol.txt"),
    UNDETERMINED("C:/Descriptions/Empty.txt"),
    public static TargetType getType(String description) {
     for (TargetType targetType : TargetType.values()) {
         if (targetType.contains(description)) {
          return targetType;
     return UNDETERMINED;
    private final String fileName;
    private Set<String> descriptions = null;
    private TargetType(String fileName) {
     this.fileName = fileName;
    private boolean contains(String description) {
     if (descriptions == null) {
         descriptions = new HashSet<String>();
          * Populate descriptions from fileName.
     return descriptions.contains(description);
}Piet

Enum property editor not rendering

I am trying to get a simple Enum property editor to work for my custom component but I keep getting an error: "Failed to load/render Property Editor"
The component XML is:
<input-parameter hidden="false" name="level" required="true" title="Log Level" type="org.apache.log4j.Level">
          <default-value>
        </default-value>
      <property-editor editor-id="com.adobe.idp.dsc.propertyeditor.system.Enum" />
</input-parameter>
<class-path>
      libs/log4j.jar
   </class-path>
Log4j.jar is in the component package and in the component class path
I have tried the com.adobe.idp.dsc.propertyeditor.system.Enum Class as described in the docs here: http://help.adobe.com/en_US/livecycle/9.0/programLC/help/index.htm?content=001419.html
I also tried using com.adobe.idp.dsc.propertyeditor.system.EnumPropertyEditorComponent as described here: http://help.adobe.com/en_US/livecycle/9.0/programLC/help/index.htm?content=001379.html
Both give the same error. I even tried using my own Enum class insteasd of org.apache.log4j.Level and referencing that, but still get the same error.
Any ideas would be helpful - thanks
(Adobe LiveCycle Workbench ES2
Version: 9.0.0.1.20100511.1.236086)

Ok after some playing about and changing random things, I seem to have figured it out.
- org.apache.log4j.Level is not an Enum class, it is a collection of static vars.
- I refactored my own Enum class to remove everything but the Enumeration values (no constructor, methods or construction parameters)
- I used com.adobe.idp.dsc.propertyeditor.system.Enum and not com.adobe.idp.dsc.propertyeditor.system.EnumPropertyEditorComponent
- I added my Enum class to the <export-packages> XML parameter
Hope this helps someone else with the same issues

Java regular expressions using enum

Hi,
i have created an enum called MONTHS and would like to include it in a pattern. Can somebody give me a hint on how to do that? Should i do it manually (by creating a string like [Jan,Feb...]) or is there a better way?
Thanks

It works by iterating the months and getting a string: months= "Jan|Feb|..." and then appending it to the pattern string. For example:
    public static String getMonthsShortStringList()
        String sList="";
        for (MONTH_SHORT c: MONTH_SHORT.values())
            sList+=c.toString()+'|';
        String newS=sList.substring(0,sList.length()-1);
        return newS;
    }//getMonthsShortStringList
and then...
String months=DateConsts.getMonthsShortStringList(); //get a months disjunctive list
Pattern pattern1=Pattern.compile("("+months+")");
Matcher matcher1=pattern1.matcher((CharSequence)s);
boolean found1=matcher1.find();Is there an alternative to this?

Enum == static ?

Similar Messages

Maybe you are looking for