从 Kotlin 调用用 Java 编写的方法时如何实现空安全，该方法引发异常？

Question

I am trying to rewrite a class with Kotlin in a Java product. Our Java product has custom exceptions written like this:

public class AppError {
    public static void exit(int res_code) {
        throw new AppException(res_code);
    }
    ...
}

public class AppException extends RuntimeException {
    private int res_code = CommonResCode.ERROR;

    public AppException() { super(); }

    public AppException(int res_code) {
        super();
        this.res_code = res_code;
    }
}

So in the existing code, there are codes like:

int point = null;
point = someMap.get("foo")
if (point == null) {
    AppError.exit(THE_GIVEN_PARAMETER_IS_INVALID_CODE)
}

I want to rewrite this code with something like the Kotlin's

val point: Int = someMap.getOrElse("foo", { AppError.exit(...) })
// or
val point: Int = someMap["foo"] ?: AppError.exit(...)

But since the exit method is seen as returning Unit , Kotlin says that point is both Int and Unit and suggests me to define point as Any . What can I do to avoid this? (other than doing the same as the Java code?)

Edit

Since the code logically always throws an exception, I thought casting may be the simple way:

val point: Int = someMap.getOrElse("foo", { AppError.exit(...) }) as Int

Is this correct? Or should I avoid doing this?

Answer 1

Well, the method is returning void (the Unit in Kotlin). Or rather, the method is never returning "normally" at all. It never finishes, because it always throws an exception.

AFAIK, there's nothing built-in which allows the use of custom exceptions. You could however create a new helper method similar to Java's Objects.requireNonNull or Kotlin's !! ( sure operator ):

static <T> T requireOrThrow(final T value, final Supplier<Throwable> exceptionSupplier) {
    // be aware of boxing of primitive types
    if (value == null) throw exceptionSupplier.get();
    return value;
}

This can then be used from your Java …

int point = requireOrThrow(someMap.get("foo"), () -> new AppException(THE_GIVEN_PARAMETER_IS_INVALID_CODE));

… and Kotlin code, which should simplify both

val point: Int = requireOrThrow(someMap["foo"], { AppException(THE_GIVEN_PARAMETER_IS_INVALID_CODE) });

Answer 2

In Kotlin you can write val point: Int = someMap["foo"] ?: error(ERROR_MESSAGE) because error function returns Nothing .

So to make val point: Int = someMap["foo"] ?: AppError.exit(...) compile, you should make AppError.exit(...) return Nothing .

Unfortunately, only Kotlin functions can return Nothing , but there are still a few solutions to your problem:

1 . Make AppError.exit(...) return JNothing :

public class AppError {
    public static JNothing exit(int res_code) {
        throw new AppException(res_code);
    }
}

Where JNothing is:

public final class JNothing {
    private JNothing() {}
}

JNothing to Nothing converter:

operator fun JNothing.invoke(): Nothing {
    error("Illegal JNothing instance was created [$this]")
}

Use case:

val point: Int = someMap["foo"] ?: AppError.exit(code)()

2 . Create KAppError.exit() wrapper of AppError.exit() which returns Nothing :

object KAppError {
    fun exit(res_code: Int): Nothing = mustThrow {
        AppError.exit(res_code)
    }
}

Where mustThrow is:

@PublishedApi
internal const val EXCEPTION_HAS_NOT_BEEN_THROWN = "Exception was expected, but it hasn't been thrown!"

inline fun mustThrow(block: () -> Unit): Nothing {
    block()
    error(EXCEPTION_HAS_NOT_BEEN_THROWN)
}

Use cases:

val point: Int = someMap["foo"] ?: KAppError.exit(code)
val point1: Int = someMap["foo"] ?: mustThrow { AppError.exit(code) }

3 . Make AppError.exit() return whatever is required:

public class AppError {
    public static <Nothing> Nothing exit(int res_code) {
        throw new AppException(res_code);
    }
}

Use case:

val point: Int = someMap["foo"] ?: AppError.exit(code)

4 . Make AppError.exit() return exception instead of throwing it:

public class AppError {
    public static AppException exit(int res_code) {
        return new AppException(res_code);
    }
}

Use case:

val point: Int = someMap["foo"] ?: throw AppError.exit(code)

Answer 3

You can write a helper method in Kotlin which returns Nothing to indicate it never returns:

object AppErrorK {
    fun exit(res_code: Int): Nothing {
        AppError.exit(res_code)
        // will never actually be reached, but makes Kotlin accept the correct return type
        throw Exception()
    }
}

Then things like

someMap["foo"] ?: AppErrorK.exit(...)

will work.