Kotlin学习记录（一）简介、变量和函数、逻辑控制、面向对象、Lambda、空指针检查

已于 2022-05-08 21:58:51 修改
阅读量750 收藏 1
点赞数
分类专栏： Android 文章标签： kotlin android java
于 2022-05-08 19:03:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53749266/article/details/124652596
版权

Kotlin学习记录（一）简介、变量和函数、逻辑控制、面向对象、Lambda、空指针检查

一、简介

编程语言大致可以分为编译型语言和解释性语言。

  • 编译型语言：编译器会将我们编写的源代码一次性编译成计算机可识别的二进制文件，然后计算机直接执行，例如C和C++。
  • 解释型语言：程序运行时，解释器会一行行读取编写的源代码，实时将源代码解释成计算机可识别的二进制数据后执行，例如Python、JavaScript和Java。

Java是先编译为只有Java虚拟机(Android中叫ART，移动优化版的虚拟机)才能识别种特殊的class文件，Java虚拟机担当的就是解释器。将.class文件解释成计算机可识别的二进制数据。

Kotlin工作原理：开发了一门新的编程语言，然后自己做了编译器，让它将这门新语言的代码编译成同样规格的class文件，只要是符合规格的class文件，java虚拟机都能识别

Kotlin优点：相较于Java，Kotlin增加了很多现代高级语言的语法特性，安全性方面也下了很多功夫，几乎杜绝了空指针。Kotlin与Java100%兼容，可以无缝使用Java第三方开源库

二、编程之本：变量和函数

2.1 变量

  1. val(value)声明一个不可变变量，对应Java中final。不可重新赋值！
    var(variable)声明一个可变变量。
  2. Kotlin完全抛弃基本数据类型，全部使用对象数据类型。

对象数据类型

Java中int是关键字，Kotlin中Int是一个类，拥有自己的方法和继承结构

好的编程习惯是，除非一个变量明确允许被修改，否则都应该给它加上final关键字。
永远优先使用val声明变量。防止项目变大后本不该修改的变量不知在何处被修改的问题。

2.2 函数

  1. fun是定义函数的关键字
  2. 参数声明格式为"参数名：参数类型"
  3. Kotlin函数语法糖：函数**只有一行代码时可以不写函数体！直接用等号连接在函数定义的尾部**
fun largerNumber(num1 : Int,num2 : Int)max = (num1,num2)

max()是函数。Kotlin的类型推导机制：

fun largeNumber(num1:Int,num2:Int) = max(num1,num2)

三、Kotlin中的程序逻辑控制

3.1 if语句

  1. if可以有**返回值，返回值为if语句中每个条件最后一行代码**的返回值。
fun largerNumber(num1 : Int,num2 : Int) : Int{
	val value = if(num1 > num2){    //将返回值赋给value变量
		num1
	}else {
		num2
	}
	return value
}

还可以简化成：
fun largerNumber(num1:Int,num2:Int):Int{
	return if(num1>num2){
		num1
	}else{
		num2
	}
}

//语法糖，去掉**多余**的value变量，并且**省略函数体**，等效于
fun largerNumber(num1 : Int,num2 : Int) = if(num1>num2) num1 else num2

3.2when语句

when语句有返回值。当判断条件非常多时应考虑使用when语句。

fun getScore(name:String) = when(name){
    "Tom"->86
    "Jim"->77
    "Jack"->95
    "Lily"->100
    else ->0
}

when与switch的区别：

  1. switch只能传入整型或短于整型的变量，JDK1.7后增加了对字符串变量的支持，switch中每个case条件都要主动加上break，否则会依次执行下面的case。
  2. when语句允许传入一个任意类型的参数，格式为：匹配值->{执行逻辑}，执行逻辑只有一行时{}可以省略。
  3. when语句支持类型匹配，is关键字是类型匹配的核心，相当于Java中的instanceof关键字，Number是Kotlin中内置的一个抽象类，Int、Long、Float、Double等与数字相关的类都是checkNumber()抽象类的子类。

fun checkNumber(num:Number){
	when(num){             //类型匹配
		is Int -> println("number is Int")
		is Double -> println("number is Double")
		else -> println("number not support")
}

Kotlin中判断字符串或对象是否相等可以直接使用==关键字，而不必像Java调用equals()。

  1. 有些场景必须使用when不带参数的用法，如所有名字以Tom开头的人分数都是86，这时无法用带参数的when语句实现。
//when语句不带参数的用法
fun getScore(name : String) = when{
	**name.startsWith("Tom" -> 86)         //不管传入Tom还是Tommy都是86.**
	name == "Jim" -> 77
	name == "Jack" -> 95
	name == "Lily" -> 100
	else -> 0
}

3.3 循环语句

for-i循环在Kotlin中被舍弃，for-each循环被大幅度增强为for-in循环。while循环没有区别。

Kotlin区间

val range = 0..10表示0到10的区间，两端闭。

val range = 0 until 10表示0到10左闭右开区间。

fun main(){
    for(i in 0..10){
        println(i)
    }
}
  1. ..关键字创建两端闭区间。
  2. until关键字创建左闭右开区间。
  3. step a关键字在for-in循环中，相当于i = i+a的效果，每次递增a
fun main(){
	for(i in 0 until 10 step 2){
		println(i)	
	}
}

输出：0，2，4，6，8
  1. downTo关键字用来创建一个降序区间。
fun main(){
	for(i in 10 downTo 1){    //创建一个[10,1]降序区间
		println(i)
	}
}
  1. 如果有一些特殊场景for-in循环无法实现我们可以改用while循环。

四、面向对象编程

4.1 类与对象

面向对象的语言可以创建类，类是对事物的一种封装，如人，汽车，房子等都可以将它封装成一个类，类通常是名词，类中可以拥有自己的字段和函数，字段：该类拥有的属性，字段名通常是名词，函数：该类可以拥有的行为，函数名通常是动词。通过这种类的封装，我们可以在适当的时候创建该类的对象，调用对象中的字段和函数满足实际编程的要求。

Kotlin中实例化一个类的方式与Java类似，只是去掉了new关键字。val p = Person()
Kotlin本着最简化的设计原则，将诸如new、行尾分号等不必要的语法结构取消。

4.2 继承与构造函数

写一个Student类，继承Person类，这样Student类就自动拥有了Person中的字段和函数，另外还可以定义自己独有的字段和函数

如果一个类不是专门为继承设计，应该主动加上final声明。Kotlin中任何一个非抽象类都是不可以被继承的，相当于被声明了final关键字。因为一个类允许被继承就无法预知子类会如何实现，就会产生未知的风险。抽象类本身是无法创建实例的，一定要有子类去继承它才能创建实例，因此抽象类必须可以被继承。

  1. class前加open关键字表示该类可被继承。
  2. 继承关键字为：。

Kotlin将构造函数分为主构造函数和次构造函数

主构造函数

  1. 主构造函数是最常用的构造函数，没有函数体，直接定义在类名后面
class Student(val sno : String, val grade :Int):Person(){
}
//进行实例化：实例化时必须传入构造函数要求的所有参数，
val student = Student("s1",5)

  1. Kotlin提供了init结构体，所有主构造函数中的逻辑写在里面。

    与Java相同，Kotlin中子类构造函数必须调用父类构造函数，子类的主构造函数调用父类中的哪个构造函数，在继承的时候通过括号来指定。

    class Student(val sno:String,val grade:Int):Person(){
	init{
		println("sno is " + sno)
		println("grade is " + grade.)
	}
}

    代表Student类主构造函数初始化时会调用Person类无参构造函数，即使无参数，括号也不能省略。

  2. 在主构造函数中声明val或var，参数将自动成为该类的字段。

次构造函数

  1. 一个类只能有一个主构造函数，多个次构造函数
  2. 次构造函数通过constructor关键字定义。
  3. 当类既有主构造函数，又有次构造函数，所有次构造函数必须调用主构造函数（包括间接调用）。
class Student(val sno:String, val grade:Int, name:String, age:Int):
        Person(name,age){
    constructor(name: String,age: Int):this("",0,name,age){ //通过this关键字调用了主构造函数
    }
    constructor():this("",0){  //调用了第一个次构造函数，间接调用了主构造函数
    }
}
  1. 当一个类没有显示定义主构造函数且定义次构造函数，此类没有主构造函数，
class Student:Person{
    constructor(name:String,age:Int):super(name,age){       
    }
}

4.3 接口

接口：用于实现多态编程的重要组成部分

interface Study {
    fun readBooks()
    fun doHomework()
}

//让Student类去实现Study接口
class Student(name: String,age: Int):Person(name,age),Study{
    override fun readBooks() {
        println(name+" is reading")
    }

    override fun doHomework() {
        println(name + " is doing homework")
    }
}
//调用
fun main(){
    val student = Student("Jack",19)
    student.readBooks()
    student.doHomework()
}

override关键字重写父类或者实现接口中的函数

这种叫做面向接口编程，也叫**多态，**也可以对接口中的函数进行默认实现

函数的可见修饰符

public与private在两种语言中一样，分别是对所有类和当前类可见。

  1. Kotlin中public修饰符是默认项，Java中default是默认项。
  2. protected关键字Java中表示对当前类、子类和同一包路径下的类可见。Kotlin中表示对当前类和子类可见，删除了同一包路径下的类。
  3. Kotlin抛弃了default的同一包路径下的类可见，internal修饰符表示同一模块下的类可见。

在这里插入图片描述

4.4数据类与单例类

hashCode()与equals()方法配套重写，否则会导致HashMap、HashSet等hash相关系统无法正常工作，toString()如果不重写默认打印一行内存地址。

数据类

将服务器端或数据库中的数据映射到内存中，为编程逻辑提供数据模型的支持。数据类通常需要重写equals()，hashCode()，toString()这几个方法

  1. data关键字用于修饰数据类，Kotlin会根据主构造函数中的参数重写equals()、hashCode()、toString()等固定方法。
data class Cellphone(val brand:String,val price:Double)
fun main(){
    val cellphone1 = Cellphone("Samsung",1299.99)
    val cellphone2 = Cellphone("Samsung",1299.99)
    println(cellphone1)
    println(cellphone1 == cellphone2)
}

  1. 类中无代码可将尾部大括号省略。

单例类

避免创建重复对象，Singleton.singletonTest()，Kotlin帮我们创建了一个单例类实例，并保证全局只存在一个Singleton实例

Java:
public class Singleton {
     private static Singleton instance;

     private Singleton(){} 
     //禁止外部创建Singleton实例，private关键字将**构造函数**私有化
	 //给外部提供了一个**getInstance()静态方法用于获取Singleton的实例**
     public synchronized static Singleton getInstance(){ 
         if(instance!=null){
             instance = new Singleton();
         }
         return instance;
     }

     public void singletonTest(){
         System.out.println("SingleTonTest is called. ");
     }
}

//要使用单例中的方法时
Singleton singleton = Singleton.getInstance();
singleton.singletonTest();

Kotlin:
object关键字
object Singleton {
    fun singletonTest(){
        println("SingleTonTest is called. ")
    }
}
//调用很简单
Singleton.singletonTest()
  1. class关键字改成object关键字即可创建单例类。
  2. 无需私有化构造函数，也不需要getInstance()方法。

五、Lambda编程

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

对接口的要求

  1. Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法
  2. jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。
  3. @FunctionalInterface修饰函数式接口的，要求接口中的抽象方法只有一个。 这个注解往往会和 lambda 表达式一起出现。

5.1 集合的创建与遍历

  1. Kotlin中提供了内置的listOf()简化初始化集合的写法、还有setOf()和mutableSetOf()、mapOf()和mutableMapOf()

listOf函数，创建的是一个不可变的集合，只能用于读取，无法添加、修改或删

val list = listOf("Apple","Banana","Orange","Pear")
    for (fruit in list){
        println(fruit)
    }

mutableListOf()函数，创建的是可变集合

Set集合：setOf()，mutableSetOf()，注意Set集合底层是使用hash映射机制来存放数据的，集合中的元素无法保证有序，这是与List的不同

Map集合：

//写法1：
    val map = HashMap<String,Int>()
    map["Apple"] = 1
    map["Banana"] = 2
    map["Orange"] = 3
    map["Pear"] = 4
    map["Grape"] = 5
//写法2：
    val map = mapOf("Apple" to 1,"Banana" to 2)
    for((fruit,number) in map){
        println("fruit is "+fruit+" , number is "+number)
    }
  1. Kotlin中建议用类似于数组下标的语法结构对Map进行添加和读取数据。
  2. for-in遍历map需要将map的键值对变量声明在一对括号中。
  3. 这里的to不是关键字，而是infix函数。

5.2 集合的函数式API

例子：找出长度最长的水果单词：
//普通写法
    val list = listOf("Apple","Orange","Banana","Pear","Grape","Watermelon")
    var maxLengthFruit = ""
    for (fruit in list){
        if(fruit.length > maxLengthFruit.length){
            maxLengthFruit = fruit
        }
    }
    println("max length fruit is "+maxLengthFruit)
//集合的函数式API
    val list = listOf("Apple","Orange","Banana","Pear","Grape","Watermelon")
    var maxLengthFruit = list.maxBy { it.length }
    println("max length fruit is "+maxLengthFruit)
maxBy是一个普通的函数，只不过接收一个Lambda类型的参数

//maxBy，函数，接收的是一个Lambda类型的参数，
//遍历集合时将每次遍历的值作为参数传递给Lambda表达式
//工作原理：根据我们传入的条件来遍历集合，从而找到该条件下的最大值
fruit是参数名，String是参数类型，fruit.length是函数体
//1.
    val list = listOf("Apple","Orange","Banana","Pear","Grape","Watermelon")
	   val lambda = { fruit:String ->fruit.length }
    maxLengthFruit = list.maxByOrNull (lambda).toString()
    println("max length fruit is "+maxLengthFruit)
//2.简化
	val maxLengthFruit = list.maxByOrNull ({fruit:String -> fruit.length})
//3.简化——当Lambda参数是函数的最后一个参数时，将Lambda表达式移到函数括号的外面
	val maxLengthFruit = list.maxByOrNull (){fruit:String -> fruit.length}
//4.简化——当Lambda参数是函数的唯一一个参数时，将函数的括号省略
	val maxLengthFruit = list.maxByOrNull {fruit:String -> fruit.length}
//5.简化——类型推导机制
	val maxLengthFruit = list.maxByOrNull {fruit-> fruit.length}
//6.简化——当Lambda表达式的参数列表中只有一个参数时，不必声明参数名，可以使用it关键字来代替
	val maxLengthFruit = list.maxByOrNull { it.length }

  1. Lambda就是一小段可以作为参数传递的代码。
    语法结构：    {参数名1 : 参数类型,参数名2 : 参数类型 → 函数体}

  2. 当Lambda是函数的最后一个参数时，可以将Lambda表达式移到函数的括号外面。

  3. Lambda是函数唯一一个参数时，可以将函数的括号省略。

  4. Kotlin拥有出色的类型推导机制，参数列表大多数情况下不必声明参数类型。

  5. 只有一个参数时不必声明参数名，使用it关键字代替。

  6. map函数用于将集合中的每个元素映射成另外的值，映射的规则在Lambda表达式中指定按照需求对集合中元素进行任意映射转换。

val list = listOf("Apple","Orange","Banana","Pear","Grape","Watermelon")
val newList = list.map { it.toUpperCase() }
for (fruit in newList){
    println(fruit)
}
  1. filter函数用来过滤集合中的数据。
//保留5个字母以内的水果
val list = listOf("Apple","Orange","Banana","Pear","Grape","Watermelon")
val newList = list.filter { it.length <5 }
for (fruit in newList){
    println(fruit)
}
  1. 先进行过滤再进行映射转换效率会高的多。
  2. any函数会判断集合中是否至少存在一个元素满足指定条件，all函数判断集合中是否所有元素满足指定条件。
val list = listOf("Apple","Orange","Banana","Pear","Grape","Watermelon")
val anyResult = list.any { it.length<=5 }
val allResult = list.all { it.length <=5 }

5.3 Java函数式API的使用

如果我们再Kotlin代码中调用一个Java方法，并且该方法接收一个Java单抽象方法接口参数，就可以使用函数式API。Java单抽象方法接口——接口中只有一个待实现方法。最常见的单抽象方法接口——Runnable接口

public interfac Runnable{
	void run();
}
java：
new Thread(new Runnable(){
    @Override
    public void Run(){
        System.out.println("Thread is running");
    }
}).start();
kotlin：
Thread(object : Runnable{
        override fun run(){
            println("Thread is running")
        }
    }).start()
//化简
Thread(Runnable { 
    println("Thread is running")
}).start()
//化简参数列表中有且仅有一个Java单抽象方法接口参数，将接口名省略
Thread( { 
    println("Thread is running")
}).start()
//最终化简
Thread{
    println("Thread is running")
}.start()

注意：本节中的Java函数式API使用都限定从Kotlin中调用Java方法，并且单抽象方法接口也必须是用Java语言定义的

小结：Kotlin完全舍弃new关键字，创建匿名类实例改用object关键字，**object可以省略，仅有一个Java单抽象方法接口参数时接口名也可以省略**。

六、空指针检查

如果每处检查代码都用if判断，会让代码变得比较啰嗦。

6.1可空类型系统

Kotlin默认所有的参数和变量不可为空。
可为空的类型系统：类名后加上一个问号?表示可为空的类型。
var adapter : MsgAdapter? = null 表示adapter继承自可为空的MsgAdapter且初始赋值为null。

fun main(){
	    doStudy(null)
	}
	
	fun doStudy(study: Study?){
	    if(study!=null){
	        study.doHomework()
	        study.readBooks()
	    }
	}

6.2 判空辅助工具

  1. ?.操作符可以省略if判断语句，对象不为空正常调用，对象为空什么都不做。
if(a!=null){
	a.doSomething()
}
即
a?.doSomething()

val c = if(a!=null){
	a
}else{
	b
}
即
val c = a?:b
  1. ?:操作符左右两边都接收一个表达式，如果左边表达式不为空就返回左边表达式结果，否则返回右边表达式结果。
    fun getTextLength(text : String?) = text?.length?:0
    如果text为空，text?.length返回null，借助?:让他返回0（text?.length?为null的的话就返回:右边的0）

辅助工具——let

let函数会将调用的对象本身作为参数传递到Lambda表达式中，let函数可提供了函数式API的编程接口而且可以处理全局变量的判空问题，if是无法解决的

fun doStudy(study:Study?){
	study?.let{ stu ->  //对象为空时什么都不做，不为空时调用let函数
						//let函数将study对象本身作为参数传递到Lambda表达式中
						//study的对象肯定不为空
		stu.readBooks()
		stu.doHomework()
	}
}
  1. !!.为非空断言工具，意在告诉Kotlin，非常确信这里的对象不会为空，出现问题抛出空指针异常，后果自己承担。但往往一个潜在的空指针异常发生在最自信不会为空的对象上。

字符串内嵌表达式——${}

当表达式中仅有一个变量的时候，将两边的大括号省略

fun main(){
    doStudy(null)
    val name = "Tome"
    val age = 19
    println("name ${name} ,age $age")
}

不需要加号连接符，很好用。

函数的参数默认值

可以给函数设定参数默认值

printParams(str = "world",name = 123)
//不管哪个参数在前还是在后，都可以准确将参数匹配上
  1. 给函数设置参数默认值可以很大程度上替代次构造函数作用**。**
  2. 在没有给参数传值的情况下会自动使用参数的默认值。
  3. Kotlin可以通过键值对传参，而不必像传统写法按照参数定义顺序传参。
_NOUS_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android学习笔记-Kotlin Lambda编程、空指针检查
u010186280的博客
09-20 209
一、集合的创建 使用如下代码可以初始化一个List集合： val list = listOf(“Apple”, “Banana”, “Orange”, “Pear”, “Grape”) 使用如下代码可以初始化一个Set集合： val set = setOf(“Apple”, “Banana”, “Orange”, “Pear”, “Grape”) 使用如下代码可以初始化一个Map集合： val map = mapOf(“Apple” to 1, “Banana” to 2, “Orange” t
kotlin-lambda-return-inliner:Kotlin编译器插件，可优化内联函数返回的lambda
03-08
Kotlin-lambda返回衬里 （当前正在等待批准） Kotlin编译器插件，可优化由内联函数返回并存储在局部变量中的lambda。 此优化可用于免费模拟Kotlin代码中的结构（以及更多）。 这个仓库目前处于非常非常试验的状态，...
【Kotlin学习】高阶函数的控制流——lambda的返回语句和匿名函数
PanicLin的博客
04-05 801
学习于《Kotlin实战》，本文讲解了关于高阶函数控制流的知识，其中包括lambda的返回语句以及匿名函数的概念
【Kotlin】面向对象基础使用方法（继承、接口、Lambda、空指针检查机制等）
摸鱼小小虫的博客
09-11 528
Kotlin面向对象基础使用方法（继承、接口、Lambda、空指针检查机制、数据类、单例类等）
Kotlin 基础学习笔记第八章——高阶函数：Lambda作为形参和返回值
liuqinhou的博客
12-10 1448
kotlin 高阶函数
Kotlin学习笔记7——高阶函数和Lambda表达式
abs625的博客
06-24 709
Kotlin学习笔记7——高阶函数和Lambda表达式前言高阶函数函数用作函数参数函数用作函数返回值自定义高阶函数Lambda 表达式与匿名函数Lambda 表达式语法拖尾 lambda 表达式it：单个参数的隐式名称lambda 表达式中返回一个值下划线用于未使用的变量匿名函数闭包尾巴 前言 上一篇，我们学习了Kotlin中的普通函数，今天继续来学习Kotlin中的函数。由于Kotlin中支持高阶函数语法，所以函数我们分为三篇来学习，今天是第二篇：高阶函数和Lambda表达式。 高阶函数 高阶函数是将函数
Kotlin中匿名函数（又称为Lambda，或者闭包）和高阶函数的详解
路宇的博客
01-18 940
7、函数类型作为返回值类型、以及闭包。8、lambda表达式与匿名内部类。3、函数的参数是另一个函数。2、Lambda的概述。2、kotlin代码。
【Kotlin】Kotlin 函数总结 ( 具名函数 | 匿名函数 | Lambda 表达式 | 闭包 | 内联函数 | 函数引用 )
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-05 2万+
一、函数头声明、 二、函数参数、 三、Unit 函数、 四、TODO 函数、 五、反引号函数名、 六、匿名函数、 七、匿名函数的函数类型、 八、匿名函数的隐式返回、 九、匿名函数参数、 十、匿名函数 it 关键字、 十一、匿名函数变量类型推断、 十二、匿名函数参数类型自动推断、 十三、Lambda 表达式、 十四、 函数参数为 Lambda 表达式、 十五、Lambda 表达式作为参数的简略写法、 十六、内联函数、 十七、普通函数代码示例、 十八、内联函数代码示例、
【Kotlin学习】Lambda编程——Lambda表达式和成员引用、集合的函数式API
PanicLin的博客
03-29 1627
学习于《Kotlin实战》，本文讲解了Lambda编程的基本用法，讲述了Lambda表达式和成员引用和一部分的集合函数式API
Kotlin 空指针检查
canada_numbfish的博客
03-18 1879
某国外机构做过一个统计，Android系统上崩溃率最高的异常类型就是空指针异常（），空指针是一种不受编程语言检查的，只能由程序员主动通过逻辑判断来避免。Kotlin却非常科学地解决了这个问题，它利用的机制几乎杜绝了空指针异常。虽然编译时判空检查的机制有时候会导致代码变得比较难写，但是Kotlin提供了 一系列的辅助工具，让我们能轻松地处理各种判空情况（和Dart挺相似的）。正文空指针检查机制Kotlin写法虽然看上去似乎和Java没有什么区别，但实际上它是没有空指针风险的，因为。
Kotlin如何捕获上下文中的变量与常量详解
01-20
Lambda表达式或匿名函数可以访问或修改其所在上下文中的变量和常量，这个过程被称为捕获。 fun main(args: Array) { //定义一个函数，该函数的返回值类型为()->List fun makeList(ele: String): () -> List...
Android：Kotlin详细入门学习指南-基础语法(一).md
03-19
这篇文章是一份详细的Kotlin入门学习指南,重点介绍了Kotlin的基础语法部分。主要内容包括: 1. 介绍了Kotlin的概念、优点以及在Android开发中的使用方法。 2. 讲解了Kotlin的基础语法,包括定义包名、函数、变量、...
Kotlin 使用高阶函数实现回调方式
01-03
之前学习了 lambda 和高阶函数，然后在 android 开发中对 onClick 事件进行监听是一个很常用的功能，kotlin 的常规实现如下： rootView.setOnClickListener { view -> println(点击了这个ID=${view.id}的view) }...
Kotlin的教程.txt
04-10
操作符与控制流：学习Kotlin中的算术操作符、比较操作符和逻辑操作符，以及控制流语句，如if-else语句、when表达式和循环结构（for循环、while循环）。 二、函数与类 函数定义与调用：了解如何定义函数，包括...
Kotlin可空类型与非空类型以及`lateinit` 的作用
micro9981的专栏
06-09 460
使用lateinit修饰符可以在 Kotlin 中声明一个非空类型的变量，并允许稍后初始化它，从而避免了每次使用该变量时的空值检查，提高了代码的简洁性和可读性。代码参考。
探索Napier：Kotlin Multiplatform的日志记录库
最新发布
虎哥LoveDroid
06-14 612
Napier是一个多平台日志记录库，旨在为Kotlin Multiplatform项目提供一致的日志记录体验。它允许开发者在通用模块中编写日志代码，并在各个平台上显示相应的日志。Napier允许开发者注入自定义的Antilog，以便在调试和发布版本中切换不同的日志记录策略。Napier作为一个Kotlin Multiplatform日志记录库，为开发者提供了一致且强大的日志记录功能。无论是调试信息还是错误日志，Napier都能帮助你在多个平台上高效记录和管理日志。
kotlin 音频播放，多音轨同时播放，音频播放期间，可以随时设置播放速度
delacroix_xu的专栏
06-09 441
然而，如果你想要在多音轨播放的同时调整播放速度，你可能需要考虑使用 `AudioTrack` 或者 `MediaPlayer`（对于较长的音频文件）。但请注意，`MediaPlayer` 本身也不直接支持播放速度的调整，但你可以通过 `setPlaybackParams` 方法来间接实现。`SoundPool` 的 `play` 方法允许你调整播放的优先级和循环次数，但并不能直接调整播放速度。不过，由于 `SoundPool` 的限制，我们将使用 `MediaPlayer` 来实现你的需求。
java(kotlin) ai框架djl
heeheeai的博客
06-13 999
提供训练模型的接口，包含优化器、损失函数和训练循环等功能。：DJL支持多个深度学习引擎，如MXNet、PyTorch、ONNX、TensorFlow，Engine接口提供统一的抽象，方便切换底层引擎。用于对训练好的模型进行推理。它提供了一个简单的接口，用于将输入数据传递给模型并获取预测结果。：表示一个深度学习模型的接口，包含模型的加载、保存和运行等操作。：管理NDArray，用于处理多维数组，封装了底层的数组操作。：定义数据集的抽象类，用户可以继承该类来实现自定义的数据集。：提供多种预训练模型。
kotlin生命一个变量为lambda表达式
03-31
在Kotlin中，可以使用函数类型来声明一个变量为lambda表达式。例如： ``` val add: (Int, Int) -> Int = { a, b -> a + b } ``` 这个变量add的类型为函数类型，接受两个Int类型的参数并返回一个Int类型的值。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值