你需要让你的枚举实现一个公共接口，如下所示：

import java.util.*;

public class Zoo {
    private static final Map<String, ZooAnimal> animals;

    static {
        Map<String, ZooAnimal> tmp = new HashMap<>();
        tmp.put("CHEETAH", Cat.CHEETAH);
        tmp.put("LION", Cat.LION);
        tmp.put("PANTHER", Cat.PANTHER);
        tmp.put("TIGER", Cat.TIGER);
        tmp.put("HAWK", Bird.HAWK);
        tmp.put("OSTRICH", Bird.OSTRICH);
        tmp.put("OWL", Bird.OWL);
        animals = Collections.unmodifiableMap(tmp);
    }

    public static void main(String[] args) {
        ZooAnimal animal = animals.get("PANTHER");
        if (animal != null && animal instanceof Cat) {
            // A panther is a cat
            System.out.printf("A %s is a cat%n", animal.getName().toLowerCase());
        }
    }

    private interface ZooAnimal {
        String getName();
    }

    public enum Cat implements ZooAnimal {
        CHEETAH, LION, PANTHER, TIGER;

        @Override
        public String getName() {
            return this.name();
        }
    };

    public enum Bird implements ZooAnimal {
        HAWK, OSTRICH, OWL;

        @Override
        public String getName() {
            return this.name();
        }
    };
}

如果你想要这些值，你可以使用通用的Enum类：

import java.util.*;

public class Zoo {
    private static final Map<String, Class<? extends Enum<?>>> animals;

    static {
        Map<String, Class<? extends Enum<?>>> tmp = new HashMap<>();
        tmp.put("BIRD", Bird.class);
        tmp.put("CAT", Cat.class);
        animals = Collections.unmodifiableMap(tmp);
    }

    public static void main(String[] args) {
        Class<? extends Enum<?>> animal = animals.get("CAT");
        // Print the values
        for (Enum<?> c : animal.getEnumConstants()) {
            System.out.println(c.name()); // CHEETAH, LION, PANTHER, TIGER
        }
    }

    public enum Cat {
        CHEETAH, LION, PANTHER, TIGER;
    };

    public enum Bird {
        HAWK, OSTRICH, OWL;
    };
}

• 更新我的答案，因为问题更新了更多的解释。

我将提供另一种方法，向Enum添加另一个维度来指示Animal类型，在这种情况下，您不需要转换为多个Enum：

public enum AnimalType 
{
    BIRD, CAT;
}
public enum Animal 
{
    CHEETAH(AnimalType.CAT, "Cheetah"),
    LION(AnimalType.CAT, "Lion"),
    HAWK(AnimalType.BIRD, "Hawk"),
    OWL(AnimalType.BIRD, "Owl");
 
    private AnimalType type;
    private String name;
 
    Animal(AnimalType type, String name) {
        this.type = type;
        this.name = name;
    }
 
    public String getName() {
        return name;
    }

    public AnimalType getType() {
        return type;
    }

    public static Optional<Animal> fromName(String name) {
        return Arrays.stream(Animal.values())
            .filter(a -> a.name.equals(name))
            .findFirst();
    }

    public static List<Animal> fromType(AnimalType type) {
        return Arrays.stream(Animal.values())
            .filter(a -> a.type == type))
            .collect(Collectors.toList());
    }
}

似乎没有一个确切的解决方案，你正在寻找实现。
本质上，我认为既然一个 enum 被认为是一个 static 对象，你就不能把静态引用转换成一个新的对象。
您必须使用 Class 类型。
而且，在这种情况下，最好只使用 Enum 类。
下面是一个关于使用 enums 的Java反射的教程，用于此特定需求。

• Examining Enums (The Java™ Tutorials > The Reflection API > Arrays and Enumerated Types)*。

因为你知道你的map值将是 enum 对象，你可以使用 Enum#valueOf 方法来获得一个值。
如果你想要一个值列表，类似于 values 方法，你可以使用一个 Enum 数组，并利用 Class#getEnumConstants。

Map<String, Class<? extends Enum>> map = new HashMap<>();
map.put("Animal", Animal.class);
map.put("Bird", Bird.class);
for (Enum value : map.get("Animal").getEnumConstants()) 
    System.out.println(value.name());

我通过反思找到了解决办法。它可以是这样的

Map<String, Class<? extends Enum<?>>> errorCodes = errorCodeMap.getErrorCodeMap();
            Class<? extends Enum<?>> enumClass = errorCodes.get(code.substring(0, 1));
            Enum<?>[] enumConstants = enumClass.getEnumConstants();
            Class<?> actualEnumClass = enumConstants[0].getDeclaringClass();
            StringBuilder errorCode = new StringBuilder().append(prefix).append(code);
            Enum<?> errorEnum = Enum.valueOf(actualEnumClass.asSubclass(Enum.class), errorCode.toString());