Java enum values

As has been explained, don't rely on underlying implementations. Instead, design your enum to store this sort of information under your control. Imagine you have three commands to send to some embedded controller, done by writing a bit pattern to a register. You want to use enums to give you a high-level representation of the commands, but at some point you need those pesky bit patterns:

public enum EmbeddedControllerCommand {

    FOO(0x001), BAR(0x010), BAZ(0x100);

    private int bitPattern = 0;

    EmbeddedControllerCommand(int bitPattern) {
        this.bitPattern = bitPattern;
    }

    public int getBitPattern() {
        return this.bitPattern;
    }

}

Just call EmbeddedControllerCommand.FOO.getBitPattern() to get the command pattern for the FOO command.

in Java Enums do have integer reference that Java calls ordinal. For example you can do yourEnumVariable.ordinal() to get the int number of the enum variable. The numbers are assigned in a way that first in the list gets number 0, second number 1 and so on.

However in your case it sounds like you should not be concerned about what is the internal representation of enums. You should decide on what kind of protocol you will use to transfer information. After that you can think of how to transfer enum values. You'll probably have to anyway build some mapping classes for the protocol to map from Java to the protocol.

If you refer to the Enum JavaDoc you can read that the Enum.ordinal() method returns a numeric constant value which is determined by the order of the Enum declarations in the class file.

For example, consider these enum constants in alphabetical order:

public enum Fruit{
    APPLE, // APPLE.ordinal()  == 0
    ORANGE;// ORANGE.ordinal() == 1
    PEAR,  // PEAR.ordinal()   == 2
}

But if we add BANANA in its alphabetical position, see how the values would change, breaking any code that relies on them:

public enum Fruit{
    APPLE, // APPLE.ordinal()  == 0
    BANANA,// BANANA.ordinal() == 1
    ORANGE;// ORANGE.ordinal() == 2
    PEAR,  // PEAR.ordinal()   == 3
}

This means that, so long as you're using the same version of the source code, you can rely on the underlying value being the same, and can use it for situations where there are no other options. I say no other options because by making your code dependent on the order of the enums, it makes the code more fragile, whereas if you aren't relying on the ordinal value you can reorder existing or insert new enum constants at will.

Now, would you accept a mild scolding for not reading the JavaDocs thoroughly before post? :)

You should not rely the pre-assinged value of enum given by Java compiler. Different language has different scheme to deal with enum. In Java, enum can be treated like a class and objects (not exactly for the same purpose) so you can create a constructor in your enum and initialize the enum to the value you want. Here is a fairly clear examples:

http://download.oracle.com/javase/tutorial/java/javaOO/enum.html