Sintaxis básica de Kotlin

Los archivos Kotlin usan.ktcomo extensión.

Declaración de paquete

El comienzo de un archivo de código generalmente es la declaración del paquete:

package com.ejemplo.main

import java.util.*

fun test() {}
class Ejemplo {}

Los archivos fuente de Kotlin no necesitan directorios y paquetes coincidentes; los archivos fuente pueden colocarse en cualquier directorio.

En el ejemplo anterior, el nombre completo de `test()` es `com.ejemplo.main.test`, y el nombre completo de `Ejemplo` es `com.ejemplo.main.Ejemplo`.

Si no se especifica ningún paquete, el valor predeterminado es eldefaultpaquete.

Importaciones predeterminadas

Hay varios paquetes que se importan de forma predeterminada en cada archivo Kotlin:

  • kotlin.*
  • kotlin.annotation.*
  • kotlin.collections.*
  • kotlin.comparisons.*
  • kotlin.io.*
  • kotlin.ranges.*
  • kotlin.sequences.*
  • kotlin.text.*

Definición de funciones

La definición de funciones utiliza la palabra clave `fun`, y el formato de los parámetros es: `parámetro : tipo`

fun sum(a: Int, b: Int): Int {   // Int 参数,返回值 Int
    return a + b
}

Con una expresión como cuerpo de la función, el tipo de retorno se infiere automáticamente:

fun sum(a: Int, b: Int) = a + b

public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型

Funciones sin valor de retorno (similar a `void` en Java):

fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}


// 如果是返回 Unit类型,则可以省略(对于public方法也是这样):
public fun printSum(a: Int, b: Int) { 
    print(a + b)
}

Funciones con parámetros de longitud variable

Los parámetros variables de una función pueden marcarse con lavarargpalabra clave:

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}

// 测试
fun main(args: Array<String>) {
    vars(1,2,3,4,5)  // 输出12345
}

lambda (función anónima)

Ejemplo de uso de una expresión lambda:

// 测试
fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
    println(sumLambda(1,2))  // 输出 3
}

Definición de constantes y variables

Definición de variables mutables: palabra clave `var`

var <标识符> : <类型> = <初始化值>

Definición de variables inmutables: palabra clave `val`, variables que solo pueden asignarse una vez (similar a las variables modificadas con `final` en Java)

val <标识符> : <类型> = <初始化值>

Tanto las constantes como las variables pueden no tener un valor de inicialización, pero deben inicializarse antes de ser referenciadas.

El compilador admite la inferencia automática de tipos, es decir, al declarar no es necesario especificar el tipo; el compilador lo determina.

val a: Int = 1
val b = 1       // 系统自动推断变量类型为Int
val c: Int      // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值


var x = 5        // 系统自动推断变量类型为Int
x += 1           // 变量可修改

Comentarios

Kotlin admite comentarios de una sola línea y de varias líneas, como en el siguiente ejemplo:

// Este es un comentario de una sola línea

A diferencia de Java, los comentarios de bloque en Kotlin permiten el anidamiento.


Plantillas de cadenas

`$` representa un nombre de variable o un valor de variable

`$varName` representa el valor de la variable

`${varName.fun()}` representa el valor de retorno del método de la variable:

var a = 1
// 模板中的简单名称:
val s1 = "a is $a" 

a = 2
// 模板中的任意表达式:
val s2 = "${s1.replace("is", "was")}, but now is $a"

Mecanismo de verificación de NULL

El diseño de seguridad nula de Kotlin, para los parámetros declarados como anulables, requiere una verificación de nulos al usarlos. Hay dos formas de manejarlo: agregar `!!` después del campo para lanzar una excepción de nulo como en Java; la otra es agregar `?` después del campo para no hacer ningún procesamiento y devolver el valornullo se combina con?:para realizar la verificación de nulos

//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

Cuando una referencia puede ser un valor `null`, la declaración de tipo correspondiente debe marcarse explícitamente como anulable.

Cuando el contenido de la cadena en `str` no es un entero, se devuelve `null`:

fun parseInt(str: String): Int? {
  // ...
}

El siguiente ejemplo demuestra cómo usar una función cuyo valor de retorno puede ser `null`:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // 直接使用 `x * y` 会导致错误, 因为它们可能为 null
    if (x != null && y != null) {
        // 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
        println(x * y)
    }
    else {
        println("'$arg1' or '$arg2' is not a number")
    }    
}

fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}

O bien:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    
    // ...
    if (x == null) {
        println("Wrong number format in arg1: '$arg1'")
        return
    }
    if (y == null) {
        println("Wrong number format in arg2: '$arg2'")
        return
    }

    // 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
    println(x * y)
}

fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("99", "b")
}

Detección de tipos y conversión automática de tipos

Podemos usar elisoperador para detectar si un objeto es una instancia de un tipo especificado (similar a la palabra clave `instanceof` en Java).

if (obj is Type) {
    // 如果 obj 是 Type 类型,则可以直接使用 Type 类型的属性和方法
} else {
    // 处理其他类型情况
}

CuandoisCuando la verificación es exitosa, Kotlin automáticamenteobjlo considerará como el tipo especificado; por lo tanto,ifdentro de la rama de la sentencia no se necesita realizar una conversión de tipo explícita. Esto se llamaconversión inteligente de tipos。

Ejemplo

fun main() {
    val obj: Any = "Hello, Kotlin"

    if (obj is String) {
`println("longitud de la cadena: ${obj.length}")` // aquí `obj` se ha convertido inteligentemente a `String`
    } else {
`println("no es del tipo cadena")`
    }
}

En este ejemplo, siobjSíStringtipo,isel operador devuelvetrue, Kotlin loobjreconocerá comoString, de modo que se puede acceder directamente aStringlas propiedades y métodos del tipo.

Más aplicaciones:

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // 做过类型判断以后,obj会被系统自动转换为String类型
    return obj.length 
  }

  //在这里还有一种方法,与Java中instanceof不同,使用!is
  // if (obj !is String){
  //   // XXX
  // }

  // 这里的obj仍然是Any类型的引用
  return null
}

O

fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null
  // 在这个分支中, `obj` 的类型会被自动转换为 `String`
  return obj.length
}

Incluso también se puede

fun getStringLength(obj: Any): Int? {
  // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
  if (obj is String && obj.length > 0)
    return obj.length
  return null
}

Rangos

Las expresiones de rango se forman mediante la función `rangeTo`, que tiene la forma de operador..`..`, complementada con `in` y `!in`.

Los rangos se definen para cualquier tipo comparable, pero para los tipos nativos enteros tienen una implementación optimizada. A continuación se muestran algunos ejemplos de uso de rangos:

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

if (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}

// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”


// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

Prueba del ejemplo

fun main(args: Array<String>) {
    print("循环输出:")
    for (i in 1..4) print(i) // 输出“1234”
    println("\n----------------")
    print("设置步长:")
    for (i in 1..4 step 2) print(i) // 输出“13”
    println("\n----------------")
    print("使用 downTo:")
    for (i in 4 downTo 1 step 2) print(i) // 输出“42”
    println("\n----------------")
    print("使用 until:")
    // 使用 until 函数排除结束元素
    for (i in 1 until 4) {   // i in [1, 4) 排除了 4
        print(i)
    }
    println("\n----------------")
}

Resultado de salida:

循环输出:1234
----------------
设置步长:13
----------------
使用 downTo:42
----------------
使用 until:123
----------------
Otras extensiones