1. Concatenación de cadenas
java:
String firstName = "Amit";String lastName = "Shekhar";String message = "My name is: "+ firstName + " " + lastName;
kotlin
val firstName = "Amit"val lastName = "Shekhar"val message = "My name is: $firstName $lastName"
2. Nueva línea
• Java
String text = "First Line\n" +
"Second Line\n" +
"Third Line";
• Kotlin
val text = """ |First Line |Second Line |Third
3. Expresiones ternarias
• Java
String text = x > 5 ? "x > 5" : "x <= 5";
• Kotlin
val text = if (x > 5)
"x > 5"
else "x <= 5"
4. Operadores
• java
final int andResult = a & b;final int orResult = a | b;final int xorResult = a ^ b;finalintrightShift=a>>2;finalintleftShift =a<<2;finalintunsignedRightShift = a >>> 2;
• Kotlin
val andResult = a and bval orResult = a or bval xorResult = a xor bval rightShift = a shr 2val leftShift = a shl 2val unsignedRightShift = a ushr 2
5. Tipo sentencia y conversión (declarativa)
• Java
if (object instanceof Car) {
Car car = (Car) object;}
• Kotlin
if (object is Car) {var car = object as Car}
6. Juicio de tipo y conversión (implícito)
• Java
if (object instanceof Car) {
Car car = (Car) object;
}
• Kotlin
if (object is Car) {
var car = object // 聪明的转换
}
7. Plantilla de cadena
Kotlin 中引入了字符串模版，方便字符串的拼接，可以用$符号拼接变量和表达式
/** kotlin 字符串模版，可以用$符号拼接变量和表达式* */fun testString2() { val strings = arrayListOf("abc", "efd", "gfg")
println("First content is $strings")
println("First content is ${strings[0]}")
println("First content is ${if (strings.size > 0) strings[0] else "null"}")
/** Kotlin 中，美元符号$是特殊字符，在字符串中不能直接显示，必须经过转义，方法 1 是用反斜杠， 方法二是${'$'}* */fun testString3() {
println("First content is \$strings")
println("First content is ${'$'}strings")
}
8. Tres citas
public void testString1() {
String str1 = "abc";
String str2 = "line1\n" +
"line2\n" +
"line3";
String js = "function myFunction()\n" +
"{\n" +
" document.getElementById(\"demo\").innerHTML=\"My First
JavaScript Function\";\n" +
"}";
System.out.println(str1);
System.out.println(str2);
System.out.println(js);
}
/** kotlin 对字符串的加强，三个引号"""中可以包含换行、反斜杠等等特殊字符* */fun testString() {
val str1 = "abc"
val str2 = """line1\n line2 line3 """ val js = """ function myFunction()
{ document.getElementById("demo").innerHTML="My First JavaScript
kotlin 除了有单个双引号的字符串，还对字符串的加强，引入了三个引号，"""中可以包含换
行、反斜杠等等特殊字符:
Function";
} """.trimIndent()
println(str1)
println(str2)
println(js)
}
9. La instrucción let simplifica el acceso a pares de objetos anulables
• prototipo de función let:
inline fun <T, R> T.let(block: (T) -> R): R = block(this)
• La función let toma por defecto el objeto actual como el parámetro it del cierre, y el valor devuelto es la última línea de la función, o
se especifica return.
El código anterior también se puede ejecutar con la sentencia ?.let, como se muestra a continuación:
/* * A través de la sentencia let, después de ?.let, si está vacía, no habrá operación, y solo cuando no esté vacía ,
se ejecutará el siguiente let operar* */
user?.let {
it.name
it.age
it.toString()
}
A través de la instrucción let, después de ?.let, si está vacío, no habrá operación, y solo cuando no esté vacío, se ejecutará la
operación después de let.
10.¿Operador Elvis?: simplificar el manejo de valores nulos
Si el valor puede estar vacío, el manejo de valores nulos puede ser engorroso, como este:
/** Manejo de valores nulos* */
fun testElvis(input: String?, user: User?) {
val a: Int?
if (input == null) {
a = -1
} else {
a = input?.length
}
if (user == null) {
var newOne = User()
newOne.save()
} else {
user.save()
}
}
El operador Elvis ?: puede simplificar las operaciones anteriores. El símbolo ?: solo realizará el siguiente procesamiento cuando el lado izquierdo del símbolo esté vacío, y no habrá
operación si no está vacío. Justo lo contrario de ?.let, por ejemplo, podemos usar dos líneas de código para simplificar la operación anterior:
/** * Elvis operator?: Simplifica el manejo de valores nulos*/
fun testElvis2(input: String?, user: User?) {
val b = input?.length ?: -1;
user?.save() ?: User().save()
}
11. Tipos anulables y no anulables
En Java, hay excepciones verificadas y excepciones no verificadas. NullPointerException es una excepción no verificada, lo que significa que NullPointerException no necesita ser capturada explícitamente. A menudo, durante el tiempo de ejecución, el programa puede informar una NullPointerException y luego bloquearla. Kotlin es una excepción eficiente y lenguaje seguro, intenta detectar el problema del puntero nulo explícitamente en la etapa de compilación y mantiene el problema en la etapa de compilación, lo que hace que el programa sea más robusto.
• Los tipos en Kotlin se dividen en tipos que aceptan valores NULL y tipos que no aceptan valores NULL, a través de ? El representante puede estar vacío, sin? Representa no anulable
fun testNullType() {
val a: String = "aa"
/* * a 是非空类型，下面的给 a 赋值为 null 将会编译不通过 * */
// a = null
a.length
/* * ？声明是可空类型，可以赋值为 null * */
var b: String? = "bb"
b = null
/* * b 是可空类型，直接访问可空类型将编译不通过，需要通过?.或者!!.来访问 * */
// b.length
b?.length
b!!.length
}
• Para un tipo que no acepta valores NULL: si asigna directamente un objeto que posiblemente acepta valores NULL a un tipo que no acepta valores NULL, fallará
en tiempo de compilación
• Para un tipo que acepta valores NULL: ¿Pasa? Declare que el acceso directo no se puede compilar al acceder a este tipo, y debe
pasar ?. o !!.
o ?. Esto significa que si el tipo está vacío, devolverá nulo y no se realizarán operaciones posteriores. no vacío,
devolverá Irá a acceder al método o propiedad correspondiente
o!!.. Significa que si el tipo está vacío, se lanzará una NullPointerException, y si no está vacío,
se accederá , por lo tanto, esto solo se usa en muy pocos escenarios específicos. El símbolo
significa que el programa no maneja este caso de excepción, y lanzará
NullPointerException como código Java. Y el siguiente código no debe aparecer en el código, lo que hará que el código sea
poco legible y si hay una excepción de puntero nulo, no podemos averiguar de inmediato dónde está vacío:
/* * 不推荐这样的写法：链式的连续用!!. * */
val user = User()
user!!.name!!.subSequence(0,5)!!.length
Correspondiente a un tipo anulable, cada acceso a él debe traer ?.juicio
val user: User? = User()
/* * 每次访问都用用?.判断 * */
user?.name
user?.age
user?.toString()
但这样多了很多代码，kotlin 做了一些优化，
/* * 或者提前判断是否为空，如果不为空在这个分支里会自动转化为非空类型就可以直接访问了
* */
if (user != null) {
user.name
user.age
user.toString()
}
Use if para juzgar si el tipo está vacío de antemano. Si no está vacío, se convertirá automáticamente en un tipo no vacío en esta rama y se puede acceder directamente.