对于那些被标题吸引到这里的人：是的，你***可以***在你的枚举中定义你自己的方法。
如果你想知道如何调用你自己的非静态枚举方法，你可以用和其他非静态方法一样的方法--在定义/继承这种方法的类型的 instance 上调用它。
在枚举的情况下，这样的示例只是ENUM_VALUE本身。
所以你只需要YourEnum.YOUR_ENUM_VALUE.yourMethod(arguments)。
现在让我们从问题回到问题上来，其中一个解决方案可能是

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

现在Direction.NORTH.getOppositeDirection()将返回Direction.SOUTH。
这里有一个更“hacky”的方式来说明@jedwards注解，但它感觉不如第一种方法灵活，因为添加更多字段或更改它们的顺序将破坏我们的代码。

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

对于这样的小枚举，我发现最可读的解决方案是：

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

}

这是可行的：

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

创建一个抽象方法，并让你的每个枚举值覆盖它。因为你在创建它的时候知道了相反的情况，所以没有必要动态地生成或创建它。
虽然读起来不太好也许switch会更容易管理？

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

是的，我们一直都是这样做的，你返回的是一个静态的示例，而不是一个新的对象

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

枚举有一个静态值方法，该方法返回一个数组，该数组包含枚举的所有值（按声明顺序排列）。source
因为北得到1，东得到2，南得到3，西得到4;你可以创建一个简单的等式来得到相反的结果
（数值+2）% 4