Syntaxe de base de Kotlin

Les fichiers Kotlin se terminent par.ktcomme suffixe.

Déclaration de package

Le début d'un fichier de code est généralement une déclaration de package :

package com.example.main

import java.util.*

fun test() {}
class Example {}

Les fichiers source Kotlin ne nécessitent pas de répertoire et de package correspondants ; les fichiers source peuvent être placés dans n'importe quel répertoire de fichiers.

Dans l'exemple ci-dessus, le nom complet de test() est com.example.main.test, et le nom complet de Example est com.example.main.Example.

Si aucun package n'est spécifié, il utilise par défaut ledefaultpackage.

Imports par défaut

Plusieurs packages sont importés par défaut dans chaque fichier Kotlin :

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

Définition de fonction

Les définitions de fonction utilisent le mot-clé fun, et le format des paramètres est : paramètre : type

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

Une expression comme corps de fonction, avec le type de retour inféré automatiquement :

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

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

Une fonction sans valeur de retour (semblable à 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)
}

Fonction à paramètre de longueur variable

Les paramètres de longueur variable d'une fonction peuvent être marqués avec le mot-clévararg:

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

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

lambda (fonction anonyme)

Exemple d'utilisation d'une expression lambda :

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

Définition de constantes et de variables

Définition de variable mutable : mot-clé var

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

Définition de variable immuable : mot-clé val, une variable qui ne peut être affectée qu'une seule fois (semblable à une variable modifiée par final en Java)

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

Les constantes et les variables peuvent être sans valeur initiale, mais elles doivent être initialisées avant d'être référencées.

Le compilateur prend en charge l'inférence de type automatique, c'est-à-dire que lors de la déclaration, vous pouvez omettre le type et laisser le compilateur l'inférer.

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


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

Commentaires

Kotlin prend en charge les commentaires sur une ligne et sur plusieurs lignes, comme le montre l'exemple suivant :

// This is a single-line comment

/* This is a multi-line
   block comment. */

Contrairement à Java, les commentaires de bloc dans Kotlin autorisent l'imbrication.

Modèles de chaînes

$ représente un nom de variable ou une valeur de variable

$varName représente la valeur de la variable

${varName.fun()} représente la valeur de retour de la méthode de la variable :

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

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

Mécanisme de vérification de NULL

La conception null-safe de Kotlin exige une gestion de vérification de null lors de l'utilisation de paramètres déclarés comme nullables. Il existe deux méthodes de gestion : ajouter !! après le champ lance une exception null comme en Java ; l'autre façon consiste à ajouter ? après le champ, ce qui peut être laissé non géré et la valeur de retour estnullou avec?:pour la gestion de vérification de null.

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

Lorsqu'une référence peut être null, la déclaration de type correspondante doit être explicitement marquée comme nullable.

Lorsque la chaîne dans str n'est pas un entier, elle renvoie null :

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

L'exemple suivant montre comment utiliser une fonction dont la valeur de retour peut être 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")
}

Ou :

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")
}

Vérification de type et conversion automatique de type

Nous pouvons utiliser l'opérateurispour vérifier si un objet est une instance d'un type spécifié (semblable au mot-clé instanceof en Java).

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

QuandisLorsque la vérification réussit, Kotlin automatiquementobjle traite comme le type spécifié, donc dansifla branche de l'instruction, il n'est pas nécessaire d'effectuer explicitement une conversion de type. C'est ce qu'on appellela conversion de type intelligente.。

Dans cet exemple, siobjOuiStringtype,isl'opérateur renvoietrue, Kotlinobjle reconnaîtra commeString, donc il peut accéder directementStringaux propriétés et méthodes du type.

Plus d'applications :

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
}

Or

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

Vous pouvez même

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

Intervalles

Les expressions d'intervalle sont formées par la forme d'opérateur..de la fonction rangeTo, complétées par in et !in.

Les intervalles sont définis pour tout type comparable, mais pour les types primitifs entiers, ils ont une implémentation optimisée. Voici quelques exemples d'utilisation des intervalles :

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)
}

Exemple de test

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----------------")
}

Résultat de sortie :

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