Calling enum's method

Question

I have the following enum:

 enum Days{
    TODAY{
        @Override
        public Date getLowerBound(){
            another();             //1
            currentUpperBound();   //2
            return null;
        }

        @Override
        public Date another() {
            return null;
        }
    };

    public abstract Date getLowerBound();

    public abstract Date another();

    private Date currentUpperBound(){
        return null;
    }
}

Why does //2 causes compile-time error with

Cannot make a static reference to the non-static method 
currentUpperBound() from the type Days

But //1 compiles fine? Both methods are non-static. I can't see any problem... Maybe it has something to do with Eclipse?

UPDATE: As @Florian Schaetz noticed in the comment, if we declare the method having static private modifier it will work fine. Why?

Answer 1

I suggest making currentUpperBounds() protected instead of private. Another solution would be to prefix your call with super., which also works:

@Override
public Date getLowerBound(){
   another();
   super.currentUpperBound();
   return null;
}

Alternatively, TODAY also works:

@Override
public Date getLowerBound(){
   another();
   TODAY.currentUpperBound();
   return null;
}

Mick Mnemonic mentioned the excellent answer in this duplicate, which explains it pretty nicely.

Answer 2

TL;DR

Solution to your problem

I suggest making the currentUpperBound() method protected.

Why?

You should consider each value of your enum as an anonymous subclass of Days. Moreover, since the enum must guarantee each of its value is unique (so that you can test equality with == for instance), it is stored as a static final field (hence also the habit of naming enum values with capital letters.

Understanding the enum behind the scene

Code equivalence

To show some code on how an enum works¹:

public enum MyEnum {
    JESSE {
       @Override
       public void sayMyName() {
           System.out.println("Pinkman");
       }
    }, WALTER;

    public void sayMyName() {
        System.out.println("Heisenberg");
    }

    private void unreachableMethod() {
        // try again
    }
}

is (almost) equivalent to:

public class MyEnum {
    private static final MyEnum JESSE = new MyEnum() {
       @Override
       public void sayMyName() {
           System.out.println("Pinkman");
       }
    };
    private static final MyEnum WALTER = new MyEnum();

    public void sayMyName() {
        System.out.println("Heisenberg");
    }

    private void unreachableMethod() {
        // try again
    }
}

When you write it this way, some things become much easier to understand:

- why == works for testing enum equality

Only one pointer per value. Object's equals(Object) is perfect here as it tests only that.

- why you can inherit methods from MyEnum or access private static ones, but not private non-static methods

• The values are stored as static fields so they cannot access instance context.
• The value inherit MyEnum so anything accessible through legacy is visible to them.

Why did I say that is was almost equivalent?

There are some additional controls embedded within the enum mechanism.

For instance, the switch is able to tell whether you had a case for each value for an enum: try testing only some values and not defining a default, the compiler will raise a warning. This would be impossible if you were simply using an abstract class with constants.

The values() method also shows things are more evolved than my simple example, but I think this helps understanding.

---

_{¹ based on my understanding of the JSL}

Answer 3

You can either declare the currentUpperBound method as abstract and implement it in your instances, or leave it implemented.

In both cases, you should declare it with a non-private access modifier.

The compiler error message here is quite confusing. It assumes currentUpperBound should be static, which would grant you access from the instances even if the method is declared as private.