Why Enum constructor is called only once in REST class?

Question

I’m learning REST by going thru this tutorial. It first runs: ClientAllOrders(), which creates 5 orders. Then it runs: ClientDeleteById(), which deletes orders 2 and 4. Then it runs ClientAllOrders(), and gets all orders except for orders 2, 4. It creates orders here:

Tutorial Delete Example

public enum OrderService {
    Instance;
    private Map<Integer, Order> orders = new HashMap<>();

    OrderService() {
        Instant instant = OffsetDateTime.now().toInstant();
        for (int i = 1; i <= 5; i++) {
            Order order = new Order();
            order.setId(i);
            order.setItem("item " + i);
            order.setQty((int) (1 + Math.random() * 100));
            long millis = instant.minus(Period.ofDays(i))
                                 .toEpochMilli();
            order.setOrderDate(new Date(millis));
            orders.put(i, order);
        }
    }
//---
}

These are the GET and DELETE methods:

@Path("/orders")
@Produces({MediaType.APPLICATION_XML, MediaType.TEXT_PLAIN})
public class OrderResource {

@GET
    public Collection<Order> getOrders() {
        return OrderService.Instance.getAllOrders();
    }

    @DELETE
    @Path("{id}")
    public boolean deleteOrderById(@PathParam("id") int id) {
        return OrderService.Instance.deleteOrderById(id);
    }
//…
}

Unless I stop/start the server or deploy a new war, the OrderService.constructor is called only ones, no matter how many times getOrders() or deleteOrderById() are called. The OrderService.constructor is called only when the OrderService.Instance object is null, but why all the OrderService.Instance objects in OrderResource class refer to the same object – hence the OrderService.Instance is null only when one of the methods in OrderResource is called for the first time and all subsequent calls, refer to the same object which is not null anymore, considering the OrderService is not a Singleton and the constructor is not private.

Answer 1

An enumeration is at heart a type that explicitly lists the values that something of that type can take. For example. enum E { fee, foe, fie. fum } says that a variable of type E can have one of the 4 given values, and no other.

Each possible value needs to be, and is, constructed only once.

Your enum lists exactly one possible value, 'Instance'. This one value is constructed exactly once - resulting in a total of one constructor calls.

Your OrderService constructor is very strange, since what it does appears to be unconnected with the enumeration at all. The constructor is called to construct the value of 'Instance', and yet it's doing nothing related to that.

I think perhaps you're fundamentally misunderstanding the nature of an enumeration. Consider this hackneyed example:

    enum Colour { RED; BLUE; GREEN; }

The constructor here is implicit. RED is constructed; BLUE is constructed; GREEN is constructed. All of this is prior to any use of Colour.

What we're now discussing is the equivalent of wondering why there is only one RED.

Answer 2

Short answer is that enums are implicitly static and as Andy Turner says in his comment therefore initilized only once. See this great article for details. For details see the rest.

Citating beforementioned article (see chapter 1.2. Java enum declaration), if you have an enum like:

public enum Direction {
    EAST, WEST, NORTH, SOUTH;
}

Logically, each enum is an instance of enum type itself. So given enum can be seen as below declaration. JVM internally adds ordinal and value methods to this class which we can call while working with enum.

final class Direction extends Enum<Direction>  {
    public final static Direction EAST = new Direction();
    public final static Direction WEST = new Direction();
    public final static Direction NORTH = new Direction();
    public final static Direction SOUTH = new Direction();
}