The Elvis operatorįrequently in programming we want to use a specific property of a nullable variable, so we check first to ensure that it isn't null. Since the function println can handle null values, a call to println(s?.length) is safe and will print either the length of the string or the word "null". The type of s?.length is Int?, so after calling s?.length, the compiler checks that Int? is used safely. However, a call to s?.length will return s.length if s is not null otherwise it will return null. If s is nullable, and if the compiler can't verify that s is not null at the point where s is dereferenced, then a call to s.length will be flagged as a compile-time error. Println(s1.length) // will never throw NPE Var s2: String? = "abc" // s2 is nullable Var s1: String = "abc" // s1 is not nullable So, for example, in Kotlin, a variable of type String can never be null, but a variable of type String? (note ? suffix) can. The Kotlin type system distinguishes between references that can hold null values (nullable references) and those that can't, and the compiler will verify consistent usage of variables of each type. More than any other language I have used, Kotlin greatly reduces occurrences of the dreaded NullPointerException. Other than we are declaring a variable rather than a function (per your example) the reasoning why it compiles is identical.One of the major design goals of Kotlin was to eliminate, or at least greatly reduce problems associated with null references. You might be able to argue that the compiler should warn you that this code is probably incorrect (its a strange way to intentionally throw an NPE), however it is valid Kotlin.
Merging the lines together gives you: var z : ResponseEntity = null!! This is valid code from a compilation standpoint, however at runtime it will fail with a NullPointerException, there is nothing unusual about this. When you use the !! operator you are instructing the compiler that the returned type isn't nullable, therefore variable y is of type: ResponseEntity Variable x has been defined be of type: ResponseEntity? Say you have the code: var x : ResponseEntity? = null Your !! operator is then telling the compiler to add a runtime cast to: ResponseEntityįrom a compilation standpoint this is valid Kotlin, however at runtime it will always throw an NPE. The compiler is acting as if null has a type of: ResponseEntity?
0 kommentar(er)
