Java code that makes use of conventional enumerated sorts is problematic. Java 5 gave us a greater various within the type of typesafe enums. On this article, I introduce you to enumerated sorts and typesafe enums, present you easy methods to declare a typesafe enum and use it in a swap assertion, and talk about customizing a typesafe enum by including knowledge and behaviors. I wrap up the article by exploring the java.lang.Enum<E extends Enum<E>> class.
Obtain the supply code for examples on this Java 101 tutorial. Created by Jeff Friesen for JavaWorld/InfoWorld.
From enumerated sorts to typesafe enums
An enumerated kind specifies a set of associated constants as its values. Examples embody every week of days, the usual north/south/east/west compass instructions, a foreign money’s coin denominations, and a lexical analyzer’s token sorts.
Enumerated sorts have historically been carried out as sequences of integer constants, which is demonstrated by the next set of path constants:
static ultimate int DIR_NORTH = zero; static ultimate int DIR_WEST = 1; static ultimate int DIR_EAST = 2; static ultimate int DIR_SOUTH = Three;
There are a number of issues with this method:
- Lack of kind security: As a result of an enumerated kind fixed is simply an integer, any integer will be specified the place the fixed is required. Moreover, addition, subtraction, and different math operations will be carried out on these constants; for instance,
(DIR_NORTH + DIR_EAST) / DIR_SOUTH), which is meaningless. - Namespace not current: An enumerated kind’s constants should be prefixed with some sort of (hopefully) distinctive identifier (e.g.,
DIR_) to forestall collisions with one other enumerated kind’s constants. - Brittleness: As a result of enumerated kind constants are compiled into class recordsdata the place their literal values are saved (in fixed swimming pools), altering a relentless’s worth requires that these class recordsdata and people utility class recordsdata that rely upon them be rebuilt. In any other case, undefined conduct will happen at runtime.
- Lack of understanding: When a relentless is printed, its integer worth outputs. This output tells you nothing about what the integer worth represents. It doesn’t even determine the enumerated kind to which the fixed belongs.
You might keep away from the “lack of kind security” and “lack of expertise” issues through the use of java.lang.String constants. For instance, you would possibly specify static ultimate String DIR_NORTH = "NORTH";. Though the fixed worth is extra significant, String-based constants nonetheless undergo from “namespace not current” and brittleness issues. Additionally, in contrast to integer comparisons, you can’t evaluate string values with the == and != operators (which solely evaluate references).
These issues precipitated builders to invent a class-based various referred to as Typesafe Enum. This sample has been extensively described and critiqued. Joshua Bloch launched the sample in Merchandise 21 of his Efficient Java Programming Language Information (Addison-Wesley, 2001) and famous that it has some issues; specifically that it’s awkward to mixture typesafe enum constants into units, and that enumeration constants can’t be utilized in swap statements.
Take into account the next instance of the typesafe enum sample. The Go well with class exhibits the way you would possibly use the class-based various to introduce an enumerated kind that describes the 4 card fits (golf equipment, diamonds, hearts, and spades):
public ultimate class Go well with // Shouldn't be capable of subclass Go well with. public static ultimate Go well with CLUBS = new Go well with(); public static ultimate Go well with DIAMONDS = new Go well with(); public static ultimate Go well with HEARTS = new Go well with(); public static ultimate Go well with SPADES = new Go well with(); non-public Go well with() // Shouldn't be capable of introduce further constants.
To make use of this class, you’ll introduce a Go well with variable and assign it to certainly one of Go well with’s constants, as follows:
Go well with swimsuit = Go well with.DIAMONDS;
You would possibly then wish to interrogate swimsuit in a swap assertion like this one:
swap (swimsuit)
case Go well with.CLUBS : System.out.println("golf equipment"); break;
case Go well with.DIAMONDS: System.out.println("diamonds"); break;
case Go well with.HEARTS : System.out.println("hearts"); break;
case Go well with.SPADES : System.out.println("spades");
Nevertheless, when the Java compiler encounters Go well with.CLUBS, it reviews an error stating that a fixed expression is required. You would possibly attempt to tackle the issue as follows:
swap (swimsuit)
Nevertheless, when the compiler encounters CLUBS, it’s going to report an error stating that it was unable to search out the image. And even in case you positioned Go well with in a bundle, imported the bundle, and statically imported these constants, the compiler would complain that it can not convert Go well with to int when encountering swimsuit in swap(swimsuit). Concerning every case, the compiler would additionally report that a fixed expression is required.
Java doesn’t help the Typesafe Enum sample with swap statements. Nevertheless, it did introduce the typesafe enum language function to encapsulate the sample’s advantages whereas resolving its points, and this function does help swap.
Declaring a typesafe enum and utilizing it in a swap assertion
A easy typesafe enum declaration in Java code seems like its counterparts within the C, C++, and C# languages:
enum Path NORTH, WEST, EAST, SOUTH
This declaration makes use of the key phrase enum to introduce Path as a typesafe enum (a particular sort of class), wherein arbitrary strategies will be added and arbitrary interfaces will be carried out. The NORTH, WEST, EAST, and SOUTH enum constants are carried out as constant-specific class our bodies that outline nameless courses extending the enclosing Path class.
Path and different typesafe enums lengthen Enum<E extends Enum<E>> and inherit varied strategies, together with values(), toString(), and compareTo(), from this class. We’ll discover Enum later on this article.
Itemizing 1 declares the aforementioned enum and makes use of it in a swap assertion. It additionally exhibits easy methods to evaluate two enum constants, to find out which fixed comes earlier than the opposite fixed.
Itemizing 1: TEDemo.java (model 1)
public class TEDemo
{
enum Path NORTH, WEST, EAST, SOUTH
public static void predominant(String[] args)
for (int i = zero; i < Path.values().size; i++)
System.out.println(Path.NORTH.compareTo(Path.SOUTH));
}
Itemizing 1 declares the Path typesafe enum and iterates over its fixed members, which values() returns. For every worth, the swap assertion (enhanced to help typesafe enums) chooses the case that corresponds to the worth of d and outputs an acceptable message. (You don’t prefix an enum fixed, e.g., NORTH, with its enum kind.) Lastly, Itemizing 1 evaluates Path.NORTH.compareTo(Path.SOUTH) to find out if NORTH comes earlier than SOUTH.
Compile the supply code as follows:
javac TEDemo.java
Run the compiled utility as follows:
java TEDemo
It’s best to observe the next output:
NORTH Transfer north WEST Transfer west EAST Transfer east SOUTH Transfer south -Three
The output reveals that the inherited toString() methodology returns the title of the enum fixed, and that NORTH comes earlier than SOUTH in a comparability of those enum constants.
Including knowledge and behaviors to a typesafe enum
You’ll be able to add knowledge (within the type of fields) and behaviors (within the type of strategies) to a typesafe enum. For instance, suppose you might want to introduce an enum for Canadian cash, and that this class should present the means to return the variety of nickels, dimes, quarters, or contained in an arbitrary variety of pennies. Itemizing 2 exhibits you easy methods to accomplish this job.
Itemizing 2: TEDemo.java (model 2)
enum Coin
NICKEL(5), // constants should seem first
DIME(10),
QUARTER(25),
DOLLAR(100); // the semicolon is required
non-public ultimate int valueInPennies;
Coin(int valueInPennies)
this.valueInPennies = valueInPennies;
int toCoins(int pennies)
return pennies / valueInPennies;
public class TEDemo
Itemizing 2 first declares a Coin enum. A listing of parameterized constants identifies 4 sorts of cash. The argument handed to every fixed represents the variety of pennies that the coin represents.
The argument handed to every fixed is definitely handed to the Coin(int valueInPennies) constructor, which saves the argument within the valuesInPennies occasion area. This variable is accessed from throughout the toCoins() occasion methodology. It divides into the variety of pennies handed to toCoin()’s pennies parameter, and this methodology returns the end result, which occurs to be the variety of cash within the financial denomination described by the Coin fixed.
At this level, you’ve found which you could declare occasion fields, constructors, and occasion strategies in a typesafe enum. In spite of everything, a typesafe enum is actually a particular sort of Java class.
The TEDemo class’s predominant() methodology first verifies that a single command-line argument has been specified. This argument is transformed to an integer by calling the java.lang.Integer class’s parseInt() methodology, which parses the worth of its string argument into an integer (or throws an exception when invalid enter is detected). I’ll have extra to say about Integer and its cousin courses in a future Java 101 article.
Transferring ahead, predominant() iterates over Coin’s constants. As a result of these constants are saved in a Coin[] array, predominant() evaluates Coin.values().size to find out the size of this array. For every iteration of loop index i, predominant() evaluates Coin.values()[i] to entry the Coin fixed. It invokes every of toCoins() and toString() on this fixed, which additional proves that Coin is a particular sort of class.
Compile the supply code as follows:
javac TEDemo.java
Run the compiled utility as follows:
java TEDemo 198
It’s best to observe the next output:
198 pennies incorporates 39 nickels 198 pennies incorporates 19 dimes 198 pennies incorporates 7 quarters 198 pennies incorporates 1
Exploring the Enum<E extends Enum<E>> class
The Java compiler considers enum to be syntactic sugar. Upon encountering a typesafe enum declaration, it generates a category whose title is specified by the declaration. This class subclasses the summary Enum<E extends Enum<E>> class, which serves as the bottom class for all typesafe enums.
Enum’s formal kind parameter listing seems ghastly, however it’s not that arduous to know. For instance, within the context of Coin extends Enum<Coin>, you’ll interpret this formal kind parameter listing as follows:
- Any subclass of
Enumshould provide an precise kind argument toEnum. For instance,Coin’s header specifiesEnum<Coin>. - The precise kind argument should be a subclass of
Enum. For instance,Coinis a subclass ofEnum. - A subclass of
Enum(comparable toCoin) should comply with the idiom that it provides its personal title (Coin) as an precise kind argument.
Look at Enum’s Java documentation and also you’ll uncover that it overrides java.lang.Object‘s clone(), equals(), finalize(), hashCode(), and toString() strategies. Apart from toString(), all of those overriding strategies are declared ultimate in order that they can’t be overridden in a subclass:
clone()is overridden to forestall constants from being cloned so that there’s by no means a couple of copy of a relentless; in any other case, constants couldn’t be in contrast through==and!=.equals()is overridden to check constants through their references. Constants with the identical identities (==) should have the identical contents (equals()), and totally different identities indicate totally different contents.finalize()is overridden to make sure that constants can’t be finalized.hashCode()is overridden as a result ofequals()is overridden.toString()is overridden to return the fixed’s title.
Enum additionally supplies its personal strategies. These strategies embody the ultimate compareTo() (Enum implements the java.lang.Comparable<T> interface), getDeclaringClass(), title(), and ordinal() strategies:
