Could an enum be used as a class?

I was reading through the Java Oracle Tutorials, and I saw an example of enum in use:

public enum Planet {
MERCURY (3.303e+23, 2.4397e6),
VENUS   (4.869e+24, 6.0518e6),
EARTH   (5.976e+24, 6.37814e6),
MARS    (6.421e+23, 3.3972e6),
JUPITER (1.9e+27,   7.1492e7),
SATURN  (5.688e+26, 6.0268e7),
URANUS  (8.686e+25, 2.5559e7),
NEPTUNE (1.024e+26, 2.4746e7);
private final double mass;   // in kilograms
private final double radius; // in meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
private double mass() { return mass; }
private double radius() { return radius; }
// universal gravitational constant  (m3 kg-1 s-2)
public static final double G = 6.67300E-11;
double surfaceGravity() {
return G * mass / (radius * radius);
}
double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
public static void main(String[] args) {
if (args.length != 1) {
System.err.println("Usage: java Planet <earth_weight>");
System.exit(-1);
}
double earthWeight = Double.parseDouble(args[0]);
double mass = earthWeight/EARTH.surfaceGravity();
for (Planet p : Planet.values())
System.out.printf("Your weight on %s is %f%n",
p, p.surfaceWeight(mass));
}
}

I always thought that enums were sets of related constants that were usually used outside of a class, but this example shows enum being used as if it was a class, with its own methods and constructors. I know that it is an enum because of the "enum" in the class declaration. Could an enum be used like a class? What is the difference between a class and an enum if they are this similar? What are some good uses for enums that act like a standard class?

Thanks

An enum is very like a normal class, except that instances are defined at compile time and are guaranteed to be singletons, and they may not extend anything.

However, they can:

• have instance fields, that may be final or not (although in conventional usage they are immutable, it is not required)
• have class (static) fields (although they must be declared after the instances)
• have getters/setters for fields
• have constructors (just not public ones)
• implement interfaces
• be decorated with annotations

The enum keyword is a language construct that essentially creates a (final) class which extends java.lang.Enum and forces you to define the (possibly empty) set of all named instances upfront, inside the enum definition.
So the answer is definitely yes; actually, you can't really use it in any other way.

Even if you don't add any logic to it, it will still be class:

enum Day { SUNDAY, MONDAY... }

This already provides you with static methods like Day.valueOf() and instance methods such as like Day.SUNDAY.ordinal(), name() or compareTo().

If you want to use enum as a class, you can use it in below way.

public class Weather {
public enum Season {
WINTER,
SPRING,
SUMMER,
FALL
}
private final Season season;
private static final List < Weather > listWeather = new ArrayList < Weather > ();
private Weather(Season season) {
this.season = season;
}
public Season getSeason() {
return season;
}
static {
for (Season season: Season.values()) {
listWeather.add(new Weather(season));
}
}
public static ArrayList < Weather > getWeatherList() {
return listWeather;
}
public String toString() {
return season;
}
}

The main difference between an enum and a standard class is in the restrictions: All instances of an enum must be declared at compile time; all fields must be final and the class cannot be extended.