Java-Aufzählungsmethoden - Rückgabe der Aufzählung in entgegengesetzter Richtung

Ich möchte eine Aufzählungsrichtung deklarieren, die eine Methode hat, die die entgegengesetzte Richtung zurückgibt (das Folgende ist syntaktisch nicht korrekt, dh Aufzählungen können nicht instanziiert werden, aber es veranschaulicht meinen Punkt). Ist das in Java möglich?

Hier ist der Code:

public enum Direction {

     NORTH(1),
     SOUTH(-1),
     EAST(-2),
     WEST(2);

     Direction(int code){
          this.code=code;
     }
     protected int code;
     public int getCode() {
           return this.code;
     }
     static Direction getOppositeDirection(Direction d){
           return new Direction(d.getCode() * -1);
     }
}

Für diejenigen, die hier nach Titel gelockt werden: Ja, Sie können Ihre eigenen Methoden in Ihrer Aufzählung definieren. Wenn Sie sich fragen, wie Sie eine solche nicht statische Methode aufrufen sollen, gehen Sie genauso vor wie bei jeder anderen nicht statischen Methode - Sie rufen sie bei einer Instanz des Typs auf, der diese Methode definiert oder erbt. Bei Aufzählungen sind solche Instanzen einfach ENUM_CONSTANTs.

Alles was Sie brauchen ist EnumType.ENUM_CONSTANT.methodName(arguments).

Kehren wir nun von Frage zu Problem zurück. Eine der Lösungen könnte sein

public enum Direction {

    NORTH, SOUTH, EAST, WEST;

    private Direction opposite;

    static {
        NORTH.opposite = SOUTH;
        SOUTH.opposite = NORTH;
        EAST.opposite = WEST;
        WEST.opposite = EAST;
    }

    public Direction getOppositeDirection() {
        return opposite;
    }

}

Jetzt Direction.NORTH.getOppositeDirection()wird zurückkehren Direction.SOUTH.

Hier ist etwas "hackiger", um @ jedwards Kommentar zu veranschaulichen , aber es fühlt sich nicht so flexibel an wie der erste Ansatz, da das Hinzufügen weiterer Felder oder das Ändern ihrer Reihenfolge unseren Code beschädigen wird.

public enum Direction {
    NORTH, EAST, SOUTH, WEST;

    // cached values to avoid recreating such array each time method is called
    private static final Direction[] VALUES = values();

    public Direction getOppositeDirection() {
        return VALUES[(ordinal() + 2) % 4]; 
    }
}

Für eine kleine Aufzählung wie diese finde ich die am besten lesbare Lösung:

public enum Direction {

    NORTH {
        @Override
        public Direction getOppositeDirection() {
            return SOUTH;
        }
    }, 
    SOUTH {
        @Override
        public Direction getOppositeDirection() {
            return NORTH;
        }
    },
    EAST {
        @Override
        public Direction getOppositeDirection() {
            return WEST;
        }
    },
    WEST {
        @Override
        public Direction getOppositeDirection() {
            return EAST;
        }
    };


    public abstract Direction getOppositeDirection();

}

Das funktioniert:

public enum Direction {
    NORTH, SOUTH, EAST, WEST;

    public Direction oppose() {
        switch(this) {
            case NORTH: return SOUTH;
            case SOUTH: return NORTH;
            case EAST:  return WEST;
            case WEST:  return EAST;
        }
        throw new RuntimeException("Case not implemented");
    }
}

Erstellen Sie eine abstrakte Methode und lassen Sie sie von jedem Ihrer Aufzählungswerte überschreiben. Da Sie beim Erstellen das Gegenteil kennen, müssen Sie es nicht dynamisch generieren oder erstellen.

Es liest sich aber nicht gut; vielleicht switchwäre ein überschaubarer?

public enum Direction {
    NORTH(1) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.SOUTH;
        }
    },
    SOUTH(-1) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.NORTH;
        }
    },
    EAST(-2) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.WEST;
        }
    },
    WEST(2) {
        @Override
        public Direction getOppositeDirection() {
            return Direction.EAST;
        }
    };

    Direction(int code){
        this.code=code;
    }
    protected int code;

    public int getCode() {
        return this.code;
    }

    public abstract Direction getOppositeDirection();
}

Ja, wir machen es die ganze Zeit. Sie geben eine statische Instanz anstelle eines neuen Objekts zurück

 static Direction getOppositeDirection(Direction d){
       Direction result = null;
       if (d != null){
           int newCode = -d.getCode();
           for (Direction direction : Direction.values()){
               if (d.getCode() == newCode){
                   result = direction;
               }
           }
       }
       return result;
 }

public enum Direction {
    NORTH, EAST, SOUTH, WEST;

    public Direction getOppositeDirection(){
        return Direction.values()[(this.ordinal() + 2) % 4];
    }
}

Aufzählungen haben eine statische Wertemethode, die ein Array zurückgibt, das alle Werte der Aufzählung in der Reihenfolge enthält, in der sie deklariert sind. Quelle

da NORTH 1 bekommt, bekommt EAST 2, SOUTH 3, WEST 4; Sie können eine einfache Gleichung erstellen, um die entgegengesetzte zu erhalten:

(Wert + 2)% 4