如何获得在Java中实现特定接口的正确枚举？

Question

I have the following interface:

public interface Moon {
    // Enums can not extend any class in Java,
    // thus I am implementing an interface
    double getMass();
    double getDiameter();
}

that is implemented by my enums (I omitted the constructor and methods implementation)

public enum Saturn implements Moon {
    ATLAS(30.2, 6.6),
    PAN(28.2, 4.95);

    private double Diameter;
    private double Mass;

    // constructor and methods implementation
}

and similarly enums for other planets:

public enum Mars implements Moon {
    PHOBOS(22.2, 1.08),
    DEIMOS(12.6, 2);

    private double Diameter;
    private double Mass;

    // constructor and methods implementation
}

---

Question

Having two strings:

String planetName = "Mars";
String moonName = "PHOBOS";

How can I obtain the particular enum in a smart way?

In the case of only one enum class it is a simple use of the valueOf method, but how can I check all enums that implement a particular interface?

Moon something = <??planetName??>.valueOf(moonName);

Answer 1

You can use a mapping of planet names to related enum types, and use that to perform a lookup.

For example, using a map (there are surely alternative approaches):

Map<String, Class<? extends Enum>> planetMoonTypes = new HashMap<>();

planetMoonTypes.put("Saturn", Saturn.class);
planetMoonTypes.put("Mars", Mars.class);

With such a map, you can lookup the "PHOBOS" value using:

Moon phobos = (Moon) Enum.valueOf(planetMoonTypes.get("Mars"), "PHOBOS");

The above will return Mars.PHOBOS

---

EDIT: Regarding the ability to add non-Moon enums. You can encapsulate the map and force proper bounds. For example, the following uses a method for that:

class MoonRegistry {

    private final Map<String, Class<? extends Enum>> 
              planetMoonTypes = new HashMap<>();

    {
        this.registerEnum("Saturn", Saturn.class);
        this.registerEnum("Mars", Mars.class);
    }

    public <T extends Enum<T> & Moon> void registerEnum(
            String planetName, Class<T> cls) {
        this.planetMoonTypes.put(planetName, cls);
    }

    public Moon findByPlanetAndName(String planet, String name) {
        return (Moon) Enum.valueOf(this.planetMoonTypes.get(planet), name);
    }
}

Again, this solution cannot be fully type-safe because there are multiple enum subtypes (as you can see, the raw Enum type is in the type of the instance field). But if this is properly encapsulated and your code uses no raw types outside this class, you can ensure that only enum types implementing Moon are added.

Answer 2

If you really want it to be dynamic, you could achieve this using Reflection, event if I don't recommend it. You could either

• Get all the classes that implement Moon , iterate on them and check if they have an instance called PHOBOS.
• Get the class Mars by its name dynamically and look for the instance. One drawback is that if you move the class Mars to another package, it will break.
• Get all the classes of your package , keep the one named Mars which implements Moon and look for the instance. This is kind of overkill.

Answer 3

I suspect you have a weakness in your design that is causing you to look for complex ways to obtain the enum instance you need. Having a separate enum for each planet probably doesn't make a lot of sense when they are all unique moons. Better to rethink the design a bit. Something like:

interface Body {
    double getMass();
    double getDiameter();
}

enum Planet implements Body {
    MERCURY, VENUS...
}

enum Moon implements Body {
    ATLAS, PHOBOS, DEIMOS...

    public Planet getPlanet();
}

That way it's easy to get planets or moons by name. Or get all the moons of a planet with:

Arrays.stream(Moon.values())
    .filter(m -> m.getPlanet().equals(this))
    ...

Answer 4

If all your enums are in the same package, then this solution could work.

String planetName = "Mars";
String moonName = "PHOBOS";

try {
    Moon moons[] = (Moon[]) Class.forName("your_package_name" + planetName).getEnumConstants();

    // The following line is not really needed, but I've added it as an 
    // illustration as to what you could do with the moons[]
    Moon planet = Arrays.stream(moons).filter(i -> i.toString().equals(moonName))
                          .findFirst().orElse(null);

} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

Answer 5

Consider using an extra enum Plantes with its moons assigned as an enum property like this

public enum Planets {
    MARS(Mars.values()), SATURN(Saturn.values());

    private final Enum<?>[] Moons;

    private Planets(final Enum<?>[] Moons) {
        this.Moons = Moons;
    }

    public Moon getMoon(final String moon) {
        return (Moon) Arrays
                .stream(this.Moons)
                .filter(e -> e.name().equals(moon))
                .findFirst()
                .get();
    }
}

It takes the Moons from the already defined enums and assigned it to an enum for each planet. There is also a getMoon() (function valueOf() is already used by enum itself), which searches for a moon.

You can use it like this:

    // Outputs 22.2
    System.out.println("" + Planets.valueOf("MARS").getMoon("PHOBOS").getDiameter());