Tutorial de Kotlin para desarrolladores de Android (3)

I. Introducción

En un tutorial de Kotlin para desarrolladores de Android (b) , hablamos sobre la base esencial de Kotlin, a saber, Kotlin en los tipos de datos básicos , matrices y recopilación de los tres puntos de conocimiento.

En esta sección, hablemos de los dos puntos de conocimiento de los métodos en las expresiones Kotlin y Lambda .

En segundo lugar, el método de Kotlin

Los objetos son los más importantes en Java y los métodos son los más importantes en Kotlin. En Kotlin, los métodos se pueden definir directamente en archivos y no necesariamente necesitan definirse en clases.

2.1, declaración de método

El formato básico de un método en Kotlin es el siguiente:

Implementación de código específico

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

2.1.1, métodos de miembros de clase

Cómo escribir los métodos miembros de una clase

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

Cómo llamar a métodos de miembros

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

2.1.2, método de clase (método estático)

No hay una palabra clave estática en Kotlin, pero podemos usar el objeto complementario (el objeto complementario de Kotlin) para lograr el propósito del método de clase.

Cómo escribir métodos estáticos

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

Llamada al método estático

 Person.test2()

2.1.3, clase estática

En Kotlin, si queremos implementar una clase de herramienta util, podemos usar object para crear una clase estática Los métodos en la clase estática son todos métodos estáticos.

Cómo escribir clases estáticas

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

Invocación de métodos en clases estáticas

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

2.1.4, método de expresión única

Cuando el método devuelve una sola expresión, puede omitir las llaves y especificar el cuerpo del código después del signo =.

Método de expresión única

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

2.2. Parámetros del método

2.2.1, parámetros predeterminados

En Kotlin, puede establecer algunos parámetros predeterminados para el método y usar los valores de los parámetros predeterminados cuando se omiten los parámetros correspondientes. En comparación con Java, esto puede reducir la cantidad de sobrecargas.

Escritura de parámetros por defecto

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

}

2.2.2, número variable de parámetros

En Java, use ... (como String ...) para establecer parámetros de tipo variable. En Kotlin, los modificadores vararg se usan para marcar parámetros para lograr parámetros variables.

Escritura de parámetros variables

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

    return result.toString()
}

Llamada al método de parámetro variable

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

2.3, alcance del método

En Kotlin, los métodos se pueden declarar en el nivel superior del archivo, lo que significa que no es necesario crear una clase para almacenar un método como en Java.

Además de los métodos de nivel superior, los métodos en Kotlin también se pueden declarar en el ámbito local, como métodos miembros y métodos de extensión.

2.3.1, método local

Escritura de método local

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

Llamada al método local

println(rand())

Tres, expresión lambda

Java comenzó a admitir expresiones Lambda en Java 8. En la actualidad, la sintaxis Lambda se ha utilizado ampliamente en Java. Las expresiones Lambda pueden entenderse como una especie de azúcar sintáctico. Afortunadamente, Kotlin ya ha admitido esto tan pronto como código abierto. Tipo de gramática.

Lambda como base de la programación de métodos, su sintaxis también es bastante simple. Primero, permítame comprender la simplicidad de las expresiones Lambda a través de una demostración de código simple.

Haga clic en el evento, no se utiliza la expresión Lambda

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

Haga clic en el evento, use la expresión Lambda

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

3.1, sintaxis de expresión lambda

Sin parámetros

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

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

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

Hay parámetros

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. Conócelo en Kotlin

no es una palabra clave en Kotlin. Se usa cuando solo hay un parámetro de una expresión Lambda en un método de nivel superior. Se puede usar para usar este parámetro. Se puede expresar como el nombre implícito de un solo parámetro. Es el lenguaje Kotlin Convenido.

Nombre implícito de un solo parámetro

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

3.2. Usar _ en expresiones Lambda

Cuando utilice una expresión Lambda, puede utilizar un guión bajo (_) para indicar un parámetro no utilizado, lo que significa que este parámetro no se procesará.

Al recorrer la colección de mapas, la utilidad es muy obvia

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

Cuarto, el código completo

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