Force an object field to having only certain values which are inherited from parent class

I have abstract class Pet with abstract method feed(...). The method must take only on of certain three types of food (DRY, WET or RAW). These can be String type as I use them only as indicators in SWITCH in later logic. Also I have two subclasses Cat and Dog. They implement the feed(...) method from Pet. The closest I came to, is using ENUM:
Pet.java:

public abstract class Pet {

    public enum FoodType {
        DRY,
        WET,
        RAW;
    }

    public abstract void feed(FoodType foodType);
}

Cat.java:

public class Cat extends Pet {

    public void feed(FoodType foodType) {
        switch (foodType) {
            case DRY:
                System.out.println("Feeding this cat dry food.");
                break;
            case RAW:
                System.out.println("Feeding this cat raw food.");
                break;
            case WET:
                System.out.println("Feeding this cat wet food.");
                break;
        }
    }
}

Dog.java:

public class Dog extends Pet {

    public void feed(FoodType foodType) {
        // implementation similar to feed() in Cat.
    }
}

App.java:

import pets.Dog;
import pets.Pet;

public class App {

    public static void main(String[] args) {
        Dog dog01 = new Dog();
        dog01.feed(Pet.FoodType.DRY);
    }
}

But I don't like that, since ENUMS are static by default FoodType can be accessed from anywhere in project. Without creating a Cat or Dog object, i can call Pet.FoodType.DRY from anywhere. Preferebly it should be associated only with an object that inherits from Pet, eg:

Dog dog01 = new Dog();
dog01.FoodType.DRY; // do smth with this

This is happening because you have declared FoodType as public. Please replace that with protected and this issue will be resolved.

protected enum FoodType

Alternatively to resolve this issue probably we can implement that as business logic

public abstract class Pet {
protected String[] foodType = new String[]{"RAW","DRY","WET"};
protected final String RAW_FOOD_TYPE = "RAW";
protected final String DRY_FOOD_TYPE = "DRY";
protected final String WET_FOOD_TYPE = "WET";
public abstract void feed(String foodType);
public String getRawFoodType()
{
return RAW_FOOD_TYPE;
}
public String getDryFoodType()
{
return DRY_FOOD_TYPE;
}
public String getWetFoodType()
{
return WET_FOOD_TYPE;
}
}
public class Cat extends Pet {
public void feed(String foodType) 
{
if(foodType.equals(DRY_FOOD_TYPE))
{
System.out.println("Feeding this cat dry food.");
}
else if(foodType.equals(RAW_FOOD_TYPE))
{
System.out.println("Feeding this cat raw food.");
}
else if(foodType.equals(WET_FOOD_TYPE))
{
System.out.println("Feeding this cat wet food.");
}
else
{
throw new RuntimeException("Invalid foodtype");
}
}
}
public class App {
public static void main(String[] args) {
Cat cat01 = new Cat();
cat01.feed(cat01.getDryFoodType());
}
}
```
</details>
# 答案2
**得分**: 0
通常在实践中，将枚举类型声明为公共（public）是可以的。但是回答你的问题，通过稍微修改结构是可以实现的。在这里，这些常量可以作为 ```enum``` 或者 ```private final string```，两者都可以。
以枚举类型为例，将其声明为受保护（protected）。然后在 ```Pet``` 类内部创建一个方法，该方法将返回枚举值，实际上就是将其封装在一个 getter 中。
```java
public FoodType getFoodType(String foodTypeStr){
return FoodType.valueOf(foodTypeStr);
}
```
这将确保只有子类的实例变量可以调用它。因此，你可以这样做：
```java
dog01.feed(dog01.getFoodType("DRY"));
```
如果需要的话，这可以被设置为受保护的，并在子类中进行覆盖。
<details>
<summary>英文:</summary>
So usally it should be fine to have public enum in practise for this. But to answer your question yes it is possible by modifying the structure a bit. So the constants here could be as ```enum``` or as ```private final string``` both would be fine. 
Taking this case for enum, declare it as protected. Then create a method which will return the enum value inside the ```Pet``` class itself , which is essentially wrapping this in a getter. 
```
public FoodType getFoodType(String foodTypeStr){
return FoodType.valueOf(foodTypeStr);
}
```
This will make sure only instance variables of child classes can invoke it. Hence you can do something like this, 
```
dog01.feed(dog01.getFoodType(&quot;DRY&quot;));
```
This can be made protected and ovveriden in child if needed.
</details>