Quelles sont les différences entre un Java enum et une classe avec un constructeur privé? [dupliquer]

pour répondre à la question: essentiellement, il n'y a pas de différence entre les deux approches. Cependant, enum construct vous fournit quelques méthodes supplémentaires de support comme values() , valueOf() , etc. que vous devez écrire vous-même avec l'approche de classe-avec-un-constructeur privé.

Mais oui, J'aime Comment Java enums sont la plupart du temps comme toutes les autres classes en Java, ils peuvent avoir des champs, des comportements, etc. Mais pour moi ce qui sépare les énums de la plaine les classes est l'idée que les enums sont des classes/types dont les instances/membres sont prédéterminés. Contrairement aux classes habituelles où vous pouvez créer n'importe quel nombre d'instances à partir de, enums limitent la création aux instances connues. Oui, comme vous l'avez illustré, vous pouvez également le faire avec des classes avec des constructeurs privés, mais enums juste rendre cela plus intuitif.

jetez un oeil à cette page de blog , il décrit comment Java enum s sont compilés dans bytecode. Vous verrez qu'il y a un petit ajout par rapport à votre second échantillon de code, qui est un tableau d'objets Direction appelé VALUES . Ce tableau contient toutes les valeurs possibles pour votre enum, donc vous ne pourrez pas faire

new Direction(2, 2)

(par exemple en utilisant la réflexion) et ensuite utiliser comme une valeur valide Direction .

de Plus, comme @Eng.Fouad explique correctement, vous n'avez pas values() , valueOf() et ordinal() .

comme les gens ont souligné vous perdez values() , valueOf() et ordinal() . Vous pouvez reproduire ce comportement assez facilement en utilisant une combinaison d'un Map et un List .

public class Direction {

    public static final Direction UP = build("UP", 0, -1);
    public static final Direction DOWN = build("DOWN", 0, 1);
    public static final Direction LEFT = build("LEFT", -1, 0);
    public static final Direction RIGHT = build("RIGHT", 1, 0);
    private static final Map<String, Direction> VALUES_MAP = new LinkedHashMap<>();
    private static final List<Direction> VALUES_LIST = new ArrayList<>();
    private final int x;
    private final int y;
    private final String name;

    public Direction(int x, int y, String name) {
        this.x = x;
        this.y = y;
        this.name = name;
    }

    private static Direction build(final String name, final int x, final int y) {
        final Direction direction = new Direction(x, y, name);
        VALUES_MAP.put(name, direction);
        VALUES_LIST.add(direction);
        return direction;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public static Direction[] values() {
        return VALUES_LIST.toArray(new Direction[VALUES_LIST.size()]);
    }

    public static Direction valueOf(final String direction) {
        if (direction == null) {
            throw new NullPointerException();
        }
        final Direction dir = VALUES_MAP.get(direction);
        if (dir == null) {
            throw new IllegalArgumentException();
        }
        return dir;
    }

    public int ordinal() {
        return VALUES_LIST.indexOf(this);
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 29 * hash + name.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Direction other = (Direction) obj;
        return name.equals(other.name);
    }

    @Override
    public String toString() {
        return name;
    }
}

Comme vous pouvez le voir, le code devient très maladroit, très rapidement.

Je ne suis pas sûr qu'il y ait un moyen de répliquer une déclaration switch avec cette classe; donc vous perdrez cela.

la principale différence est que la classe enum s'étend implicitement à la classe Enum<E extends Enum<E>> . Cela conduit à cela:

1. enum objets ont des méthodes telles que name() et ordinal()
2. enum les objets ont spécial toString() , hashCode() , equals() et compareTo() implémentations
3. enum les objets sont appropriés pour l'opérateur switch .
Direction

toutes les mentions ci-dessus ne s'appliquent pas à votre version de la classe Direction . C'est le "sens" de la différence.