java - 有没有办法强制子类声明枚举并以抽象方式从父类(super class)引用它？

Question

我有两个类Apple和Lemon我想在游戏中编程。这两个类之间共享许多功能，例如 draw(Graphics g)和setColor(Color color) .

public class Apple {
    public enum Color {
        Red, Green;
    }

    private Color color;
    private Sprite[] sprites;

    public Apple() {
        color = Color.Red;
        sprites = loadSprites("apple.png"); // [0]=redSprite, [1]=greenSprite
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public void draw(Graphics g) {
        sprite[color.ordinal()].draw(g);
    }
}

public class Lemon {
    public enum Color {
        Yellow, Green;
    }

    private Color color;
    private Sprite[] sprites;

    public Lemon() {
        color = Color.Yellow;
        sprites = loadSprites("lemon.png"); // [0]=yellowSprite, [1]=greenSprite
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public void draw(Graphics g) {
        sprite[color.ordinal()].draw(g);
    }
}

因为两者都是 Fruit并共享类似的功能，我创建了一个 abstract父类(super class)可以扩展并强制尽可能多的工作进入父类(super class)。

public abstract class Fruit {
    private Sprite[] sprites;
    private Color color;

    protected Fruit(String filepath, Color colorDefault) {
        sprites = loadSprites(filepath);
        color = colorDefault;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public void draw(Graphics g) {
        sprites[color.ordinal()].draw(g);
    }
}

public class Apple {
    public enum Color {
        Red, Green;
    }

    public Apple() {
        super("apple.png", Color.Red);
    }
}

public class Lemon {
    public enum Color {
        Yellow, Green;
    }

    public Lemon() {
        super("lemon.png", Color.Yellow);
    }
}

不幸的是，由于有 2 个独立的 Color 枚举，这不太有效。我可以创建一个共享 Color枚举，但这会导致这两种情况都允许传入无效颜色，并且对于某些子类顺序是不可能的(即，如果绿色在苹果中是第一，在柠檬中是第二)。

public enum Color { // this seems hacky
    Green(2), // Valid for both
    Red(1), // Only valid for apple
    yellow(1); // Only valid for lemon

    private int position;

    public Color(int position) {
        this.position = position;
    }

    @Override
    public int ordinal() {
        return position;
    }
}

我尝试让它们共享一个类似的界面，但这仍然允许它们传递彼此的无效颜色。

理想情况下，我希望子类本身声明有效的枚举值并强制它们声明 Color枚举。将枚举设置为 abstract看起来应该可以，但在java中似乎不允许。

public abstract class Fruit {
    private Sprite[] sprites;
    private Color color;

    public abstract enum Color; // not allowed

    protected Fruit(String filepath, Color colorDefault) {
        sprites = loadSprites(filepath);
        color = colorDefault;
    }

    public void setColor(Color color) {
        this.color = color;
    }
}

我希望能够像这样创建和设置这些对象，同时将 setter 保留在父类(super class)中。

Apple apple = new Apple();
apple.setColor(Apple.Color.Green);

Lemon lemon = new Lemon();
lemon.setColor(Lemon.Color.Yellow);

有什么办法可以做到这一点，还是我被迫重写 setColor(Color color)方法并记住添加 Color枚举在我的所有 Fruit子类？

tl;博士我想将具有类特定枚举参数的函数移动到父类(super class)中，并强制子类定义枚举。这可以在 Java 中实现吗？或者我是否被迫记住在所有子类中自己这样做？

Answer 1

在这种情况下，泛型可以成为你的 friend :

public static class Fruit<C extends Enum<C>> {
    protected C color;

    public void setColor(C color) {
        this.color = color;
    }

}

public static class Apple extends Fruit<Apple.Color> {
    public enum Color {
        Red, Green;
    }

    public Apple() {
        setColor(Color.Red);
    }

}

public static class Lemon extends Fruit<Lemon.Color>{
    public enum Color {
        Yellow, Green;
    }

    public Lemon() {
        setColor(Color.Yellow);
    }

}