在Java中运行时在两个枚举类之间切换

我有两个枚举类：

public enum dog{
    Sound("barks"),
    Eat("meat"),
    Drink("water");
    private String attribute;
    private dog (String attribute){
        this.attribute = attribute; }

    public String returnAttribute(){
        return attribute;}
}

及

我想在运行时在两个枚举之间动态切换，就像它是一个对象一样（我知道它不是）。因此，我会根据“条件”为狗或猫分配一个枚举“holder”，然后获得属性值，即enumholder.Sound.returnAttribute

---

如果是狗，它将返回“吠叫”，如果是猫，它将返回“喵喵”。可能吗

简单的答案是否定的。看

使用类和继承代替枚举。要完成您正在寻找的任务，您需要三个类，

动物

，

猫

，和

狗

class Animal {
     public String getSound() {
         return "Animal sound";
     }
     // Other mehtods...
}
class Cat extends Animal {
     @Override
     public String getSound() {
         return "Meow";
     }
     // Other mehtods...
}
class Dog extends Animal {
     @Override
     public String getSound() {
         return "Bark";
     }
     // Other mehtods...
}

您可以使用这些类来获得所需的功能

public class Main {
     public static void main(String[] args) {
          Animal a = new Cat();
          System.out.println(a.getSound());
          a = new Dog();
          System.out.println(a.getSound());
     }
}

---

你似乎只是在寻找普通的物体。为什么需要

enum

s

class AnimalType {
    String sound, eat, drink;
}

// in some method somewhere
AnimalType cat = new AnimalType();
cat.sound = "meows";
cat.eat = "fish";
cat.drink = "milk";

AnimalType dog = new AnimalType();
dog.sound = "barks";
dog.eat = "meat";
dog.drink = "water";

// then use either cat or dog

---

在我看来，似乎您应该将其建模为枚举继承的接口—这些方法将成为您当前作为成员建模的方法。比如：

interface Animal {
    String getFood();
    int getNumberOfLegs();
}

enum Dog implements Animal {
    POODLE, 
    GOLDEN_RETRIEVER;

    public String getFood() {
        return "dog food";
    }

    public int getNumberOfLegs() {
        return 4;
    }
}

enum Bird implements Animal {
    CANARY("seed"),
    EAGLE("meat");

    private final String food;

    Bird(String food) {
        this.food = food;
    }

    public String getFood() {
        return food;
    }

    public int getNumberOfLegs() {
        return 2;
    }
} 

然后，您可以将狗或猫分配给

动物

变量，它将正常工作：

Animal animal;
animal = Bird.CANARY;
assertEquals("seed", animal.getFood());
animal = Dog.POODLE;
assertEquals(4, animal.getNumberOfLegs());

这具有enum（固定的实例集，JVM确定何时构建它们）的所有优点，同时还能够以不同的方式对待不同的动物集。

如果您想使用enum，您应该这样做：

public enum AnimalTraits {
    DOG(/*sound*/"barks",
        /*eat  */"meat",
        /*drink*/"water"),
    CAT(/*sound*/"meows",
        /*eat  */"fish",
        /*drink*/"milk");

    private final String sound;
    private final String eat;
    private final String drink;

    private AnimalTraits(String sound, String eat, String drink) {
        this.sound = sound;
        this.eat = eat;
        this.drink = drink;
    }
    public String getSound() {
        return this.sound;
    }
    public String getEat() {
        return this.eat;
    }
    public String getDrink() {
        return this.drink;
    }
}

---

野兽的本性。很接近，但我只需要将enum鸟视为一个对象，而不是金丝雀。

public enum AnimalTraits {
    DOG(/*sound*/"barks",
        /*eat  */"meat",
        /*drink*/"water"),
    CAT(/*sound*/"meows",
        /*eat  */"fish",
        /*drink*/"milk");

    private final String sound;
    private final String eat;
    private final String drink;

    private AnimalTraits(String sound, String eat, String drink) {
        this.sound = sound;
        this.eat = eat;
        this.drink = drink;
    }
    public String getSound() {
        return this.sound;
    }
    public String getEat() {
        return this.eat;
    }
    public String getDrink() {
        return this.drink;
    }
}