Tutoriel Kotlin pour les développeurs Android (3)

Introduction

Dans un didacticiel Kotlin pour les développeurs Android (b) , nous avons parlé de la base essentielle de Kotlin, à savoir Kotlin dans les types de données de base , les tableaux et la collecte des trois points de connaissance.

Dans cette section, parlons des deux points de connaissance des méthodes dans les expressions Kotlin et Lambda .

Deuxièmement, la méthode Kotlin

Les objets sont les plus importants en Java, et les méthodes sont les plus importantes dans Kotlin. Dans Kotlin, les méthodes peuvent être directement définies dans des fichiers, et n'ont pas nécessairement besoin d'être définies dans des classes.

2.1, déclaration de méthode

Le format de base d'une méthode dans Kotlin est le suivant:

Implémentation de code spécifique

fun plus(a: Int, b: Int): Int {
    
    
    return a + b
}

2.1.1, méthodes des membres de classe

Comment écrire les méthodes membres d'une classe

class Person {
    
    
   	// 成员方法
    fun test1() {
    
    
        println("成员方法")
    }
}

Comment appeler des méthodes membres

fun main() {
    
    
    Person().test1()
}

2.1.2, méthode de classe (méthode statique)

Il n'y a pas de mot-clé statique dans Kotlin, mais nous pouvons utiliser l'objet compagnon (l'objet compagnon de Kotlin) pour atteindre l'objectif de la méthode de classe.

Comment écrire des méthodes statiques

class Person {
    
    
    companion object {
    
    
        fun test2() {
    
    
            println("companion object 实现类方法")
        }
    }
}

Appel de méthode statique

 Person.test2()

2.1.3, classe statique

Dans Kotlin, si nous voulons implémenter une classe d'outils util, nous pouvons utiliser object pour créer une classe statique Les méthodes de la classe static sont toutes des méthodes statiques.

Comment écrire des classes statiques

object NumUtil {
    
    
    fun double(num: Int): Int {
    
    
        return num * 2
    }
}

Invocation de méthodes dans des classes statiques

println("umUtil.double(2): ${NumUtil.double(2)}")

2.1.4, méthode d'expression unique

Lorsque la méthode renvoie une seule expression, vous pouvez omettre les accolades et spécifier le corps du code après le signe =.

Méthode d'expression unique

fun double(x: Int): Int = x * 2

2.2. Paramètres de la méthode

2.2.1, paramètres par défaut

Dans Kotlin, vous pouvez définir certains paramètres par défaut pour la méthode et utiliser les valeurs de paramètre par défaut lorsque les paramètres correspondants sont omis. Par rapport à Java, cela peut réduire le nombre de surcharges.

Écriture des paramètres par défaut

// off 的默认值就是 0， len 的默认值就是 b.size
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    
    

}

2.2.2, nombre variable de paramètres

En Java, utilisez ... (comme String ...) pour définir les paramètres de type variable. Dans Kotlin, les modificateurs vararg sont utilisés pour marquer les paramètres afin d'obtenir des paramètres variables.

Écriture de paramètres variables

// 通过 vararg 修饰
fun append(vararg str: Char): String {
    
    
    val result = StringBuffer()
    for (char in str) {
    
    
        result.append(char)
    }

    return result.toString()
}

Appel de méthode de paramètre variable

println(append('h', 'e', 'l', 'l', 'o'))

2.3, portée de la méthode

Dans Kotlin, les méthodes peuvent être déclarées au niveau supérieur du fichier, ce qui signifie que vous n'avez pas besoin de créer une classe pour stocker une méthode comme en Java.

En plus des méthodes de niveau supérieur, les méthodes de Kotlin peuvent également être déclarées dans la portée locale, en tant que méthodes membres et méthodes d'extension.

2.3.1, méthode locale

Écriture de méthode locale

fun rand(): Int {
    
    
	// 局部方法
    fun square(v: Int): Int {
    
    
        return v * v
    }
	
	// 生成 0 到 100 的随机数（包括0、100）
    val v1 = (0..100).random()
    return square(v1)
}

Appel de méthode locale

println(rand())

Trois, expression Lambda

Java a commencé à prendre en charge les expressions Lambda dans Java 8. À l'heure actuelle, la syntaxe Lambda a été largement utilisée en Java. Les expressions Lambda peuvent être comprises comme une sorte de sucre syntaxique. Heureusement, Kotlin l'a déjà pris en charge dès qu'il est open source. Genre de grammaire.

Lambda comme base de la programmation de méthodes, sa syntaxe est également assez simple. Permettez-moi d'abord de comprendre la simplicité des expressions Lambda à travers une simple démonstration de code.

Événement de clic, l'expression Lambda n'est pas utilisée

view.setOnClickListener(new View.OnClickListener() {
    
    
    @Override
    public void onClick(View v) {
    
    
        Toast.makeText(context, "Lambda 简洁之道", Toast.LENGTH_LONG).show();
    }
});

Cliquez sur l'événement, utilisez l'expression Lambda

view.setOnClickListener {
    
     v -> Toast.makeText(context, "Lambda简洁之道", Toast.LENGTH_LONG).show() }

3.1, syntaxe d'expression Lambda

Aucun paramètre

val/var 变量名 = {
    
     操作的代码 }

fun test() {
    
    
    println("无参数")
}

// 将上述代码改造成使用 Lambda 表达式代码
val test1 = {
    
     println("无参数") }

Il y a des paramètres

val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型 = {
    
    参数1，参数2，... -> 操作参数的代码 }

// 此种写法：即表达式的返回值类型会根据操作的代码自推导出来。
val/var 变量名 = {
    
     参数1 ： 类型，参数2 : 类型, ... -> 操作参数的代码 }

fun test2(a: Int, b: Int): Int {
    
    
    return a + b
}

// 将上述代码改造成使用 Lambda 表达式代码
val test3: (Int, Int) -> Int = {
    
     a, b -> a + b }
// Lambda 表达式代码简化
val test4 = {
    
     a: Int, b: Int -> a + b }

3.2. Le savoir à Kotlin

ce n'est pas un mot clé dans Kotlin. Il est utilisé lorsqu'il n'y a qu'un seul paramètre d'une expression Lambda dans une méthode de niveau supérieur. Il peut être utilisé pour utiliser ce paramètre. Il peut être exprimé comme le nom implicite d'un seul paramètre. C'est le langage Kotlin D'accord.

Nom implicite d'un seul paramètre

// 过滤掉数组中小于 5 的元素，这里的 it 就表示每一个元素
fun test5() {
    
    
    val arr = arrayOf(1, 2, 3, 4, 5)
    println("test5${arr.filter { it < 5 }}")
}

3.2. Utiliser _ dans les expressions Lambda

Lorsque vous utilisez une expression Lambda, vous pouvez utiliser un trait de soulignement (_) pour indiquer un paramètre inutilisé, ce qui signifie que ce paramètre ne sera pas traité.

En parcourant la collection Map, l'utilité est très évidente

fun test6() {
    
    
    val map = mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3")
    
    map.forEach {
    
     (key, value) ->
        println("$key \t $value")
    }

    // 不需要key的时候
    map.forEach {
    
     (_, value) ->
        println(value)
    }
}

Quatrièmement, le code complet

fun main() {
    
    
    println("functionLearn: ${functionLearn(101)}")
    Person().test1()
    Person.test2()
    println("umUtil.double(2): ${NumUtil.double(2)}")
    println("double(2): ${double(2)}")
    println(append('a', 'b', 'c'))
    println(magic())

    // lambda
    test1()
    println(test3(1, 3))
    test5()
    test6()
}

fun plus(a: Int, b: Int): Int {
    
    
    return a + b
}

fun functionLearn(days: Int): Boolean {
    
    
    return days > 100
}

class Person {
    
    
    /**
     * 成员方法
     */
    fun test1() {
    
    
        println("成员方法")
    }

    companion object {
    
    
        fun test2() {
    
    
            println("companion object 实现类方法")
        }
    }
}

/**
 * 整个静态类
 */
object NumUtil {
    
    
    fun double(num: Int): Int {
    
    
        return num * 2
    }
}

/**
 * 单表达式方法，当方法当个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可
 */
fun double(x: Int): Int = x * 2


/**
 * 默认值，方法参数可以由默认值，当省略相应的参数时使用默认值。与Java相比，这可以减少重载数量
 */
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    
    

}

/**
 * 可变数量参数
 */
fun append(vararg str: Char): String {
    
    
    val result = StringBuffer()
    for (char in str) {
    
    
        result.append(char)
    }

    return result.toString()
}

/**
 * 局部方法
 */
fun magic(): Int {
    
    
    fun foo(v: Int): Int {
    
    
        return v * v
    }

    val v1 = (0..100).random()
    return foo(v1)
}


/**
 * 无参数情况
 */
fun test() {
    
    
    println("无参数")
}

val test1 = {
    
     println("无参数") }// lambda代码


/**
 * 有参数
 */
fun test2(a: Int, b: Int): Int {
    
    
    return a + b
}

val test3: (Int, Int) -> Int = {
    
     a, b -> a + b }// lambda代码
val test4 = {
    
     a: Int, b: Int -> a + b }// lambda代码简化

fun test5() {
    
    
    val arr = arrayOf(1, 2, 3, 4, 5)
    println("test5${arr.filter { it < 5 }}")
}

fun test6() {
    
    
    val map = mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3")
    map.forEach {
    
     (key, value) ->
        println("$key \t $value")
    }

    // 不需要key的时候
    map.forEach {
    
     (_, value) ->
        println(value)
    }
}