Re: final fields of an enum that refer to

From:

Daniel Pitts <newsgroup.spamfilter@virtualinfinity.net>

Newsgroups:

comp.lang.java.programmer

Date:

Mon, 25 Aug 2008 08:02:33 -0700

Message-ID:

<48b2c9c7$0$23502$7836cce5@newsrazor.net>

Andreas Leitgeb wrote:

Joshua Cranmer <Pidgeot18@verizon.invalid> wrote:

Andreas Leitgeb wrote:

enum Thing {
T1, T2;
final Thing mate;
}
What could I do, to make T2 "final"ly the mate of T1
and vice versa ?

Strictly speaking, having each store a final Object reference to each
other is impossible, since a final variable is only set at construction,
and an object has to be created before it can be referred to. [1]

Hmm, damn, I feared so :-(

1. Make the mate a String. Because of the way enums work, you get the
same effect if you do |Thing.valueOf(mate)|.

Yes, String, or index into values()...

2. If you drop finality, you can still initialize in the constructor.

Ah, yes, that's an alternative that occurred to me after writing my
post. I also hoped that javac could be tricked into initializing another
Thing's final ref as well as this's, but that (of course) didn't work.

3. A less agreeable one, IMO. You can use some form of static-time
initialization, either manually setting the variables (ew?) or using a
map of some sort.

That's my current fallback-approach. In my case, the index of each
Thing's mate can be calculated from Thing's ordinal(), and I've already
got a loop over all Things in the static initializer, so I just non-
final'ed the ref and added initialization of that ref into the loop.

4. As you mentioned, you can also do abstract methods, but that seems
rather burdensome for such a feature.

Indeed :-) With my 40 Thing-instances, it would also be very verbose.

I could think of a few changes in the implementation of enum-
initialization that would allow for forward-references, but I
guess, forward-references among enum-instances are not considered
valuable enough to justify any changes at all.

I think that the best designed approach is to externalize the relationships:

enum Thing {
   T1,
   T2;
   private static final Map<Thing, Thing> mates;
   static {
       final Map<Thing, Thing> matesMap = new EnumMap<Thing, Thing>();
       matesMap.put(t1, t2);
       matesMap.put(t2, t1);
       mates = Collections.unmodifiableMap(matesMap);
   }

   public Thing mate() { return mates.get(this); }
}

assert T1.mate() == T2;
assert T2.mate() == T1;

This removes cyclic dependencies from your design, and externalizes the
configuration of mate.
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>