Using a Switch-Case with an enum that has string values, in Java?

In my application, I receive a response that has hard-coded values it can be.
I have created an enum with those responses as so:

enum ResponseCode {
    APPROVED("AP"),
    REJECTED("RJ"),
    ...;

    private final String code;

    private ResponseCode(String code) {
        this.code = code;
    }
}

I would handle a response differently depending on which code I receive. I thought of using a switch-case to solve this problem.

String response = functionThatReturnsString(); // Could be "AP" or "RJ" etc.

switch(response) {
case ResponseCode.APPROVED:
    // Response handling here
    break;
...
}

However, I get the error Type mismatch: cannot convert from ResponseCode to String

Is there a way to get around this? Or is there a better way to do this?

You are switching on a String, but you are using ResponseCode as the cases, which doesn't make sense. A String can never match a ResponseCode.

There are multiple ways around this. Instead of an enum, you can use static final constants:

final class ResponseCode {
    private ResponseCode() {}
    public static final String APPROVED = "AP";
    public static final String REJECTED = "RJ";
}

switch (someResponseCode) {
    case ResponseCode.APPROVED -> { ... }
    case ResponseCode.REJECTED -> { ... }
    // remember to handle the case of not matching any response code!
    default -> { ... }
}

Alternatively, write a method that converts Strings to your enum:

public static ResponseCode fromString(String s) {
    return switch (s) {
        case "AP" -> APPROVED;
        case "RJ" -> REJECTED;
        default -> null;
    };
    // or: Arrays.stream(ResponseCode.values()).filter(x -> x.code.equals(s)).findFirst().orElse(null);
}

Note that you can remove the code field, if you don't need it for anything else.

Then you can switch like this:

switch (ResponseCode.fromString(someResponseCode)) {
    case APPROVED -> { ... }
    case REJECTED -> { ... }
    // remember to handle the case of not matching any response code!
    case null -> { ... }
}

Convert your String to a ResponseCode:

ResponseCode rc= ResponseCode.valueOf(response);

then switch on that value:

switch (rc) {
  case APPROVED:
    // Response handling here
    break;
...
}

You should probably also handle the case where the String can't be converted to an enum value.

You can use the enum directly:

ResponseCode responseCode = ...

switch(responseCode) {
case APPROVED:
    // Response handling here
    break;
...
}