Aquí hay un ejemplo para saber Usar "cuando" con objetos arbitrarios,

VehicleParts es una clase de enumeración con cuatro tipos.

mix es un método que acepta dos tipos de clase VehicleParts.

setOf(p1, p2) - La expresión puede producir cualquier objeto

setOf es una función de biblioteca estándar de Kotlin que crea Set que contiene los objetos.

Un conjunto es una colección para la que no importa el orden de los elementos. Kotlin puede combinar diferentes tipos para obtener múltiples valores.

Cuando paso VehicleParts.TWO y VehicleParts.WHEEL, obtengo "Bicycle". Cuando paso VehicleParts.FOUR y VehicleParts.WHEEL, obtengo "Car".

Código de muestra,

 enum class VehicleParts { TWO, WHEEL, FOUR, MULTI } fun mix(p1: VehicleParts, p2: VehicleParts) = when (setOf(p1, p2)) { setOf(VehicleParts.TWO, VehicleParts.WHEEL) -> "Bicycle" setOf(VehicleParts.FOUR, VehicleParts.WHEEL) -> "Car" setOf(VehicleParts.MULTI, VehicleParts.WHEEL) -> "Train" else -> throw Exception("Dirty Parts") } println(mix(VehicleParts.TWO,VehicleParts.WHEEL))

Solo usa la palabra clave when . Si quieres hacer un bucle, puedes hacerlo así:

 var option = "" var num = "" while(option != "3") { println("Choose one of the options below:\n" + "1 - Hello World\n" + "2 - Your number\n" + "3 - Exit") option = readLine().toString() // equivalent to switch case in Java // when (option) { "1" -> { println("Hello World!\n") } "2" -> { println("Enter a number: ") num = readLine().toString() println("Your number is: " + num + "\n") } "3" -> { println("\nClosing program...") } else -> { println("\nInvalid option!\n") } } }

La caja del interruptor es muy flexible en kotlin.

 when(x){ 2 -> println("This is 2") 3,4,5,6,7,8 -> println("When x is any number from 3,4,5,6,7,8") in 9..15 -> println("When x is something from 9 to 15") //if you want to perform some action in 20..25 -> { val action = "Perform some action" println(action) } else -> println("When x does not belong to any of the above case") }

Podrías hacer esto:

 when (x) { 1 -> print("x == 1") 2 -> print("x == 2") else -> { // Note the block print("x is neither 1 nor 2") } }

extraído de la ayuda oficial

Cuando Expresión

when reemplaza al operador de cambio de lenguajes tipo C. En la forma más simple se ve así

 when (x) { 1 -> print("x == 1") 2 -> print("x == 2") else -> { // Note the block print("x is neither 1 nor 2") } }

when coincide con su argumento contra todas las ramas secuencialmente hasta que se satisface alguna condición de rama. when puede usarse como una expresión o como una declaración. Si se usa como expresión, el valor de la rama satisfecha se convierte en el valor de la expresión general. Si se usa como declaración, los valores de las ramas individuales se ignoran. (Al igual que con if , cada rama puede ser un bloque y su valor es el valor de la última expresión del bloque).

De https://kotlinlang.org/docs/reference/control-flow.html#when-expression

switch en Java es efectivo when está en Kotlin. La sintaxis, sin embargo, es diferente.

 when(field){ condition -> println("Single call"); conditionalCall(field) -> { print("Blocks"); println(" take multiple lines"); } else -> { println("default"); } }

He aquí un ejemplo de diferentes usos:

 // This is used in the example; this could obviously be any enum. enum class SomeEnum{ A, B, C } fun something(x: String, y: Int, z: SomeEnum) : Int{ when(x){ "something" -> { println("You get the idea") } else -> { println("`else` in Kotlin`when` blocks are `default` in Java `switch` blocks") } } when(y){ 1 -> println("This works with pretty much anything too") 2 -> println("When blocks don't technically need the variable either.") } when { x.equals("something", true) -> println("These can also be used as shorter if-statements") x.equals("else", true) -> println("These call `equals` by default") } println("And, like with other blocks, you can add `return` in front to make it return values when conditions are met. ") return when(z){ SomeEnum.A -> 0 SomeEnum.B -> 1 SomeEnum.C -> 2 } }

La mayoría de estos se compilan para switch , excepto when { ... } , que se compila en una serie de declaraciones if.

Pero para la mayoría de los usos, si usa when(field) , se compila en un switch(field) .

Sin embargo, quiero señalar que switch(5) con un montón de ramas es solo una pérdida de tiempo. 5 es siempre 5. Si usa switch , declaraciones if o cualquier otro operador lógico, debe usar una variable. No estoy seguro de si el código es solo un ejemplo aleatorio o si es un código real. Lo señalo por si es esto último.

 val operator = '+' val a = 6 val b = 8 val res = when (operator) { '+' -> a + b '-' -> a - b '*' -> a * b '/' -> a / b else -> 0 } println(res);

Usamos el siguiente código para condiciones comunes

 val operator = '+' val a = 6 val b = 8 val res = when (operator) { '+', '-' -> a - b '*', '/' -> a / b else -> 0 } println(res);

when define una expresión condicional con múltiples ramas. Es similar a la instrucción switch en lenguajes tipo C. Su forma simple se ve así.

 when (x) { 1 -> print("x == 1") 2 -> print("x == 2") else -> { // Note the block print("x is neither 1 nor 2") } }

when coincide con su argumento contra todas las ramas secuencialmente hasta que se satisface alguna condición de rama.

when puede usarse como una expresión o como una declaración. Si se usa como expresión, el valor de la primera rama coincidente se convierte en el valor de la expresión general. Si se usa como declaración, los valores de las ramas individuales se ignoran. Al igual que con if, cada rama puede ser un bloque y su valor es el valor de la última expresión del bloque.

 import java.util.* fun main(args: Array<String>){ println("Hello World"); println("Calculator App"); val scan=Scanner(System.`in`); println(""" please choose Your Selection to perform press 1 for addition press 2 for substraction press 3 for multipication press 4 for divider press 5 for divisible """); val opt:Int=scan.nextInt(); println("Enter first Value"); val v1=scan.nextInt(); println("Enter Second Value"); val v2=scan.nextInt(); when(opt){ 1->{ println(sum(v1,v2)); } 2->{ println(sub(v1,v2)); } 3->{ println(mul(v1,v2)); } 4->{ println(quotient(v1,v2)); } 5->{ println(reminder(v1,v2)); } else->{ println("Wrong Input"); } } } fun sum(n1:Int,n2:Int):Int{ return n1+n2; } fun sub(n1:Int, n2:Int):Int{ return n1-n2; } fun mul(n1:Int ,n2:Int):Int{ return n1*n2; } fun quotient(n1:Int, n2:Int):Int{ return n1/n2; } fun reminder(n1:Int, n2:Int):Int{ return n1%n2; }