是否可以使用枚举常量作为Java中可实例化类的模板？

对不起，如果我的问题有点不清楚；我发现要找到措辞有点难。我花了好几个小时在Eclipse上闲逛，浏览JavaDoc和Google，等等。我学到了很多，但没有找到答案

我希望能够定义一个枚举，例如：

public enum Animals {
    Cow,
    Chicken,
    Sheep,
    Horse;
}

并让每个枚举常量定义一个非本地类的可实例化类。下面的方法行吗？如果没有，原因是什么

在某些文件中：

abstract public class Animal {

    private String nameString;

    public String getName() {
        return nameString;
    }

}

另一方面：

public enum Animals {

    Cow ((new Animal() {
        private boolean hasMilk;
        {
            nameString = "Cow";
            hasMilk = false;
        }
        public boolean hasMilk() {
            return hasMilk;
        }
    }).getClass()),

    Chicken ((new Animal() {
        private boolean hasFeathers;
        {
            nameString = "Chicken";
            hasFeathers = true;
        }
        public boolean hasFeathers() {
            return hasFeathers;
        }
    }).getClass()),

    Sheep ((new Animal() {
        private boolean isShorn;
        {
            nameString = "Cow";
            isShorn = false;
        }
        public boolean isShorn() {
            return isShorn;
        }
        public void Shear() {
            isShorn = true;
        }
    }).getClass()),

    Horse ((new Animal() {
        {
            nameString = "Cow";
        }
    }).getClass());


    private Class<? extends Animal> animalClass;

    private Animals(Class<? extends Animal> a) {
        animalClass = a;
    }

    public Class<? extends Animal> getAnimalClass() {
        return animalClass;
    }
}

（此时，

shorn

的值为

false

）

（

shorn==true

）

（

shorn==false

）

显然，这不是我在这里所做的最好的方式，但这不是重点。我知道我可以为枚举常量指定行为，但这并不能使它们作为不同的实例倍增实例化。我希望能够使用不同的访问器方法，使用不同的实例变量（以及不同数量/类型的实例变量）创建不同枚举常量的多个实例（或副本），然后我可以在不修改枚举常量的情况下对其执行操作（更改实例变量）

---

我知道枚举常量被设计成不可变的。这与我的想法并不冲突；我希望每个枚举常量表示可变类的不可变定义。

您可以执行以下操作：

public enum AnimalType {
    COW {
        @Override
        public Animal createNew() {
            return new Cow();
        }
    },
    HORSE {
        @Override
        public Animal createNew() {
            return new Horse();
        }
    };

    public abstract Animal createNew();
}

public abstract class Animal {
    private final AnimalType type;
    private final String nameString;

    public Animal(final AnimalType type, final String nameString) {
        super();
        this.type = type;
        this.nameString = nameString;
    }

    public String getName() {
        return nameString;
    }

    public AnimalType getType() {
        return type;
    }
}

public class Horse extends Animal {
    public Horse() {
        super(AnimalType.HORSE, "Horse");
    }
}

public class Cow extends Animal {
    private boolean milk;

    public Cow() {
        super(AnimalType.COW, "Cow");
    }

    public boolean hasMilk() {
        return milk;
    }

    public void setMilk(final boolean milk) {
        this.milk = milk;
    }
}

@Test
public void testEnum() {
    Cow cow = (Cow) AnimalType.COW.createNew();
    Horse horse = (Horse) AnimalType.HORSE.createNew();

    System.out.println("cow  : " + cow.getType() + ", has milk: " + cow.hasMilk());
    System.out.println("horse: " + horse.getType());
}

---

谢谢据我所知，你的解决方案可以达到我想要的最终结果，但感觉不是很令人满意。有可能我要求的是一种实际上并不存在的语言特性。有一点相关，我有没有理由不把动物声明中的所有动物子类声明为嵌套类？这类事情（并将类定义分组为枚举常量）吸引了我的组织方面。

farmAnimal.shear();
shorn = farmAnimal.isShorn();

farmAnimal = Animals.Sheep.getAnimalClass().newInstance();
shorn = farmAnimal.isShorn();

public enum AnimalType {
    COW {
        @Override
        public Animal createNew() {
            return new Cow();
        }
    },
    HORSE {
        @Override
        public Animal createNew() {
            return new Horse();
        }
    };

    public abstract Animal createNew();
}

public abstract class Animal {
    private final AnimalType type;
    private final String nameString;

    public Animal(final AnimalType type, final String nameString) {
        super();
        this.type = type;
        this.nameString = nameString;
    }

    public String getName() {
        return nameString;
    }

    public AnimalType getType() {
        return type;
    }
}

public class Horse extends Animal {
    public Horse() {
        super(AnimalType.HORSE, "Horse");
    }
}

public class Cow extends Animal {
    private boolean milk;

    public Cow() {
        super(AnimalType.COW, "Cow");
    }

    public boolean hasMilk() {
        return milk;
    }

    public void setMilk(final boolean milk) {
        this.milk = milk;
    }
}

@Test
public void testEnum() {
    Cow cow = (Cow) AnimalType.COW.createNew();
    Horse horse = (Horse) AnimalType.HORSE.createNew();

    System.out.println("cow  : " + cow.getType() + ", has milk: " + cow.hasMilk());
    System.out.println("horse: " + horse.getType());
}