getting Enum constant

[Gangreen]

I have the following enum.

**
 * An enum to represent types of mechanics.
 * 
 * @author 
 * @version 1.0
 */
public enum Mechanics {
    ISOLATION(0),
    COMPOUND(1);
 
    /**
     * Variable to hold the value of the mechanics.
     */
    private final int mechanics;
 
    /**
     * Constructor to create a mechanics
     * 
     * @variable    newMechanics
     *                 The value of the new mechanics
     */
    Mechanics (int newMechanics) {
        this.mechanics = newMechanics;
    }
 
    /**
     * An inspector method that returns the value of the calling operation.
     * 
     * @return     the value of the calling mechanics.
     *             | result >= 0 && result < 2
     */
     public int getValue(){
         return mechanics;
     }
 
     /**
      * A method to check whether the value of a given mechanics
      * matches that of this mechanics
      * 
      * @variable    other
      *             The mechanics to be compared with this mechanics
      */
     public boolean equals(Mechanics other){
         return this.getValue() == other.getValue();
     }
}

Now, I also have objects, which have a property that is a constant of this Enum. (isolation or compound). Now I am searching for a way of saving these objects (to textfiles), and loading them.

Which means that the property of the object which is the enum should be saved in a way (i guess using the associated int) that is simple.

Also I should be able to load this enum again. However I do not know how to do this, since a constructor of an enum is private, and the method that loads does not know wether the 0 or 1 stands for isolation or compound.

How can I do this, without using switch-like things? I have much larger enums then the one I showed here.

Thanks

[BigDaddyLH]

Your enum is over-engineered ;-)

The following in sufficient:

public enum Mechanics {ISOLATION, COMPOUND};

There is no need to define a "value" property as you did. Enum defines a property ordinal that does the same thing. Enum also overrides toString, equals, hashCode and clone correctly. Enums implements Serializable and Comparable as well.

To save and restore an enum, you can convert it to a String and back:

String s = m1.name(); //or m1.toString();
Mechanics m2 = Mechanics.valueOf(s);

or convert it to its ordinal and back:

int ord = m1.ordinal();
Mechanics m2 = Mechanics.values()[ord];

As mentioned, enums are serializable so you could save and restore objects with enum fields that way, but java beans can be persisted with XMLEncoder/Decoder as well:

public class SaveMe {
    private Mechanics mech;
    private int another;
 
    public SaveMe() {
    }
 
    public SaveMe(Mechanics mech, int another) {
        setMechanics(mech);
        setAnother(another);
    }
 
    public void setMechanics(Mechanics mech) {
        this.mech = mech;
    }
 
    public Mechanics getMechanics() {
        return mech;
    }
 
    public void setAnother(int another) {
        this.another = another;
    }
 
    public int getAnother() {
        return another;
    }
 
    public String toString() {
        return String.format("[mech=%s, another=%d]",
            getMechanics(), getAnother());
    }
}

import java.beans.*;
import java.io.*;
 
public class EnumTest {
    public static void main(String[] args)  throws IOException {
        testParse();
        testIO();
    }
 
    static void testParse() {
        String[] input = {"ISOLATION","COMPOUND"};
        for(String s : input) {
            Mechanics m = Mechanics.valueOf(s);
            System.out.format("%s --> %s, with ordinal %d%n", s, m, m.ordinal());
        }
    }
 
    static void testIO() throws IOException {
        File file = new File("test.xml");
 
        XMLEncoder e = new XMLEncoder(
            new BufferedOutputStream(
                new FileOutputStream(file)));
        e.writeObject(new SaveMe(Mechanics.COMPOUND, 17));
        e.close();
 
        XMLDecoder d = new XMLDecoder(
            new BufferedInputStream(
            new FileInputStream(file)));
        Object result = d.readObject();
        d.close();
        System.out.println(result);
    }
}

The method testIO create the file test.xml:

<?xml version="1.0" encoding="UTF-8"?> 
<java version="1.6.0" class="java.beans.XMLDecoder"> 
 <object class="SaveMe"> 
  <void property="another"> 
   <int>17</int> 
  </void> 
  <void property="mechanics"> 
   <object class="Mechanics" method="valueOf"> 
    <string>COMPOUND</string> 
   </object> 
  </void> 
 </object> 
</java> 
 

Conclusion: enums are simpler and easier to use than you first thought!

[Gangreen]

I see. Damn I thought they weren't that easy.

Thanx for everything!

[BigDaddyLH]

ps.

There are times when it makes sense to add methods (even polymorphic methods) to an enumerated type, Check out the Planet and Operation examples:

[http://java.sun.com/j2se/1.5.0/docs/guide/language/enums.html]