Rhino schreef:

Indeed.

Now, would it be possible to set up other enums to

I don´t think you can do this sort of hard-linking two enums together,
but you could define mass() to return something of type Mass, and in the
initialisation of Earth tell it to return Mass.EARTH_MASS.

Why would you want to have anything to do with those numbers?  Although
they are used by the JVM internally, there is absolutely no to access
them.  And how do you see this connected to Mass?

What DO you want to do?

 And, maybe more importantly, would it be a

Doesn´t seem like a good idea, but you are really unclear.

H.

=================================================
I was going to intersperse my followups within your post, just like you did
to mine, but my newsreader isn't co-operating by putting >> in front of my
original words and > in front of your reply....

I'm sorry to be so unclear; like I said, I'm still strugging with the
terminology. Let me try explaining it a bit differently.

Okay, let's say we have an array called Planet and it looks like this (I'll
just use the inner planets to minimize typing):
Object[][] Planet = {
   {"Mercury", 3.303e+23, 2.4397e6, 0},
   {"Venus",  4.869e+24, 6.0518e6, 0},
   {"Earth",  5.976e+24, 6.37814e6, 1},
   {"Mars", 6.421e+23, 3.3972e6, 1}
   };

In this array, the first column contains a planet name, the second column
contains the mass of the planet, the third column contains the radius of the
planet, and the fourth column contains the number of natural satellites that
the planet has.

If I want to know the number of satellites for the planet Mars, I can get it
via this: Planet[3][3]. But the meanings of the '3's in the subscripts are
not terribly obvious to someone looking at the code; no one would have any
way of knowing the _meaning_ of the fourth row or the fourth column of the
array.

I'd much rather be able to reference the number of satellies for a planet
with syntax that demonstrates a knowledge of the nature of the data, i.e.
the first column contains the planet's name, the fourth column is the number
of satellites, etc. To my way of thinking, this array has (implied) column
names and those column names comprise an enum consisting of the values NAME,
MASS, RADIUS, and SATELLITES. Also, the individual rows of the array can be
uniquely identified by the planet name which is therefore an implied enum
too, consisting of the values Mercury, Venus, Earth and Mars.

I'm not sure how the syntax should look but I'm picturing something that has
words from enums in place of numeric subscripts, something like this:
Planet["Mars"][SATELLITES], which means 'the number-of-satellites value from
the row of the array Planet whose key (first column value) is "Mars"'.

Again, this syntax is probably not entirely appropriate for maintaining
consistentcy with other syntax  in Java but it gives the flavour I am
looking for.

I would also like to be able to use variables so that it would be possible
to loop through the array and list the number of satellites for each planet
without using a numeric subscript. Something like:

for (String name, int satellites : Planet) {
   System.out.println("Planet " + name + " has " + Planet[NAME][SATELLITES]
+ " satellites.");
}

Sorry, I know that won't compile as it is. I'm not trying to make a firm
proposal on what the syntax should be, I'm just trying to convey the flavour
of what I'd like to do.

It seems to me that Enums are the vital ingredient in making this work but I
may be perverting them beyond their intended use. Or maybe there is a much
better way to do this without using Enums at all.

I'm just looking for some feedback on whether the concept I'm exploring even
makes sense and, if it does, how could I accomplish it with typesafe enums?

Rhino

Yeah, I'm not having a lot of luck articulating my wishes in a way that
seems clear even to me, let alone anyone else ;-)

Yes, that's right!

I didn't put it very well, did I? ;-) It obviously makes no sense to have an
enumerations that contains all the values possible for a planetary mass. I
should have made it clearer that I wanted to enumerate the _properties_ of a
planet. Those would be relatively few, such as mass and radius, and would
lend themselves better to an enum.

Then I want to use the names of the properties to access the actual values
so that I can say something like Planet.EARTH.MASS to get the mass of the
Earth.

I *think* you're on the right track but....

I got several errors when I tried to compile the PlanetMeasure class in
Eclipse. Frankly, I'm somewhat confused by what you're doing (not surprising
since I've asked an unclear question!) that it wasn't obvious to me why
these errors were arising. I took a guess and found that the following
compiled fine, although I don't know if it changes the intent of your
code....

===============================================
public enum PlanetMeasure {

   RADIUS {
       public double of(Planet planet) {
           return planet.radius();
       }
   },
   MASS {
       public double of(Planet planet) {
           return planet.mass();
       }
   },
   ;
   public abstract double of(Planet planet);

   static void printPlanetMeasure(Planet planet, PlanetMeasure property) {
       System.out.println("The " + property + " of " + planet + " is " +
property.of(planet));
   }
}
================================================

Now, even if I've made reasonable alterations in the code, I'm not quite
clear how to use what you've done; how/where do I specify the _values_ of
the mass and radius for each of my planets so that I can get them back out
again with the of() method?

If you can help me understand what you've done so far, I might be able to
work out the rest on my own....

Rhino