是否有可能使用Enum常量作爲Java中的可實例化類的模板？

Question

對不起，如果我的問題有點不清楚;我發現找到措辭有點難。我花了幾個小時在Eclipse中搞定，巡航JavaDoc和Google，以及SO。我學到了很多，但沒有找到答案。

我想什麼，能夠做的就是定義一個枚舉，如：

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; 
    } 
} 

，然後在一些其他類的其他一些方法，能夠做到這一點：

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

（此時shorn的值爲false）;

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

（shorn == true）

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

（shorn == false）

很顯然，這不是做什麼，我在這裏所做的最好的方式，但是這不是問題的關鍵。我知道我可以爲枚舉常量指定行爲，但這並不能使它們作爲不同的實例進行多次實例化。我希望能夠使用不同的訪問器方法創建不同實例變量（以及不同的實例變量的數量/類型）的各種枚舉常量的多個實例（或副本），然後我可以執行這些操作（改變實例變量）不用修改枚舉常量。

我得到的是枚舉常量被設計爲不可變的。這與我的想法不衝突;我希望每個枚舉常量表示一個可變類的不可變定義。

Answer 1

你可以做這樣的事情：

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()); 
}