【Kotlin】Kotlin学习总结

最新推荐文章于 2023-07-12 11:18:27 发布
最新推荐文章于 2023-07-12 11:18:27 发布
阅读量321 收藏
点赞数
分类专栏： Kotlin 文章标签： java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuzhangzhen/article/details/106516057
版权

Kotlin学习总结


学而不思则罔，思而不学则殆

保留字总结

常见

Kotlin关键字说明类比java
val不可变变量final修饰
var可变变量非final修饰
when条件选择switch
for循环语句（用法多变）for
open类或者属性可被继承 （默认是不能被继承的）非final修饰的类
init构造函数结构体无
constructor次构造函数无
interface接口,跟java一样interface
data数据类保留字无
object单例类修饰符无

可见性保留字

修饰符KotlinJAVA
public所有类可见（默认）所有类可见
private本类可见本类可见
protected本类，子类可见本类，子类，同一包路径下可见
default无同一包路径下可见
internal同一模块的类可见无
  1. default 在java中是同一包下可以访问
  2. internal 则是同一模块下可以访问，范围要大一些

变量对比

Java基本数据类型Kotlin基本数据类型说明
intInt整型
longLong长整型
shortShort短整型
floatFloat单精度浮点型
doubleDouble双精度浮点型
booleanBoolean布尔型
charChar字符型
byteByte字节型

语法糖

//当函数只有一行时，可以直接卸载尾部，省略return关键字
fun myMax(num1: Int, num2: Int): Int = max(num1, num2)
fun myMin(num1: Int, num2: Int): Int = min(num1, num2)
fun myMax1(num1: Int, num2: Int) = max(num1, num2)
fun myMin2(num1: Int, num2: Int) = min(num1, num2)

逻辑控制

if 条件判断

可以有返回

//很直白的方式
fun myMin3(num1: Int, num2: Int): Int {
    var value = 0
    value = if (num1 < num2) {
        num1
    } else {
        num2
    }
    return value
}
//更够充当返回值
fun myMin4(num1: Int, num2: Int): Int {
    return if (num1 < num2) {
        num1
    } else {
        num2
    }
}

fun myMin5(num1: Int, num2: Int): Int {
    return if (num1 < num2) num1 else num2
}

fun myMin6(num1: Int, num2: Int) = if (num1 < num2) num1 else num2

when 条件语句

可以有返回

fun getTest(num:Number) {
    when(num){
        is Int -> println("is Int")
        is Double -> println("is Double")
        else -> println("is Else")
    }
}

fun getTest(num: Int) = when (num) {
    1 -> "A"
    2 -> "B"
    else -> "C"
}
作为返回值

for 循环语句

Kotlin总的循环语句更加灵活

val range = 0..10 //[0,10]双端闭区间
val range1 = 0 until 10 //[0,10) 左闭右开区间

    for (i in 0..10) {
        print("$i,")
    }
    //0,1,2,3,4,5,6,7,8,9,10,

    for (i in 0 until 10) {
        print("$i,")
    }
    //0,1,2,3,4,5,6,7,8,9,

    for (i in 0 until 10 step 2) { //i += 2
        print("$i,")
    }
    //0,2,4,6,8,

    for (i in 10 downTo 0) { //降序
        print("$i,")
    }
    //10,9,8,7,6,5,4,3,2,1,0,

    for (i in 10 downTo 0 step 2) {
        print("$i,")
    }
    //10,8,6,4,2,0,

面向对象

对象

新建一个对象

class Person {
    var name = ""
    var age = 0

    fun sleep(): Unit {
        println("$name is sleeping, He is $age years old")
    }
}

    val person = Person()
    person.name = "张宇"
    person.age = 18
    person.sleep()
    //张宇 is sleeping, He is 18 years old

继承

Kotlin中类默认是不可被继承的，需要添加关键字open,继承时用":" 代替java的extends

open class Person { //open关键字，标识该类可以被继承
    var name = ""
    var age = 0

    fun sleep(): Unit {
        println("$name is sleeping, He is $age years old")
    }
}

class Student : Person() { //: 表示继承
    var no = "20200630"//学号
    var grade = 12 //年级

    fun show(): Unit {
        println("$name $no $grade ,He is $age years old")
    }
}

构造函数

主构造函数

主构造函数是默认的，每个类默认都会有一个不带参数的主构造函数，跟java一样，当然也可以指定参数，在柱构造函数上

class Student(private var no: String, private var grade: Int) : Person() {
    fun show(): Unit {
        println("$name $no $grade ,He is $age years old")
    }
}
val student = Student("张宇",17)

init就是构造函数的结构体，一些初始化方法可以添加到这

class Student(private var no: String, private var grade: Int) : Person() {

    init {
        println("Student init a $no")
    }

    init {
        println("Student init b $grade")
    }

    fun show(): Unit {
        println("$name $no $grade ,He is $age years old")
    }
}

如果父类构造函数不为空，继承的时候需要指定父构造函数
添加默认值

class Student(private var no: String, private var grade: Int) : Person(name = "张宇", age = 18) {...}

添加参数，参数不能加任何val和var限定符，作用域限定在主构造函数中

class Student(name: String, age: Int, private var no: String, private var grade: Int) : Person(name, age) {...}

次构造函数

    class Student(name: String, age: Int, private var no: String, private var grade: Int) : Person(name, age) {
    constructor(name: String, age: Int) : this(name, age, "20200702", 12)
    constructor() : this("20200702", 12)
    }
    //初始化
    val student1 = Student()
    val student2 = Student("张宇", 18)
    val student3 = Student("张宇", 18, "20200702", 12)

只有次构造函数，没有主构造函数

class Student : Person {
    constructor(name: String, age: Int) : super(name, age) {} //显示调用父类构造函数super
    constructor() : this("20200702", 12) {}
}

//初始化
    val student1 = Student()
    val student2 = Student("张宇", 18)

接口

interface ICar {
    fun startUp() //启动
    fun stop() // 停车
}

实现

class Car(private val brand: String) : ICar {
    override fun startUp() {
        //TODO("Not yet implemented")
        println("$brand startUp")
    }

    override fun stop() {
        //TODO("Not yet implemented")
        println("$brand stop")
    }
}

简单使用

    val car = Car("红旗")
    val car1 = Car("长安")
    car.startUp()
    car1.startUp()
    car.stop()
    car1.stop()
    //红旗 startUp
    //长安 startUp
    //红旗 stop
    //长安 stop

接口默认实现

kotlin允许接口有默认实现，Java中JDK1.8过后也支持这个特性功能

interface ICar {
    fun startUp() {
        println("Car default startUp")
    } //启动

    fun stop() // 停车
}

class Car(private val brand: String) : ICar {
    override fun startUp() {
        //TODO("Not yet implemented")
        super.startUp()
        println("$brand startUp")
    }

    override fun stop() {
        //TODO("Not yet implemented")
        println("$brand stop")
    }
}
Car default startUp
红旗 startUp
Car default startUp
长安 startUp
红旗 stop
长安 stop

数据类与单例类

数据类 data class

在java中写一个数据类，需要各种get,set，而在kotlin中一行代码就可以

data class Card(var id: Int, var data: Date)
    val card = Card(10001, Date())
    val card1 = Card(10001, Date())
    println(card)
    println(card1)
    println("card == card1 : ${card == card1}")
    println("card === card1 : ${card === card1}")
    //Card(id=10001, data=Fri Jul 03 07:46:44 CST 2020)
    //Card(id=10001, data=Fri Jul 03 07:46:44 CST 2020)
    //card == card1 : true     值相等
    //card === card1 : false   不是同一个对象

单例类 object

单例类就是全局该类对象最多只有一个

object Singleton {
    var id = 0

    fun show(): Unit {
        println("Singleton show!")
    }
}

    println(Singleton.id)
    Singleton.id = 1
    println(Singleton.id)
    Singleton.show()
    println(Singleton)
    println(Singleton)

单例类的调用和使用相当于Java的静态类的属性和方法

0
1
Singleton show!
learning.data.Singleton@5e2de80c
learning.data.Singleton@5e2de80c

集合

List

    val list = ArrayList<String>()
    list.add("ONE")
    list.add("TWO")
    list.add("THREE")
    //java的使用习惯
    val list1 = listOf("FOUR","FIVE","SIX") //Kotlin方式，不可变集合
    val list2 = mutableListOf("FOUR","FIVE","SIX") // 可变集合
    list2.add("SEVEN")
    //访问list
    for (node in list){
        println(node)
    }

Set

    val set = setOf("FOUR","FIVE","SIX")//不可变set
    println(set)
    val set1 = mutableSetOf("FOUR","FIVE","SIX") //可变set
    set1.add("SEVEN")
    println(set1)

Map

    val map = mapOf("ONE" to 1, "TWO" to 2, "THREE" to 3) //不可变map
    println(map)
    val map1 = mutableMapOf("FOUR" to 5, "FIVE" to 5, "SIX" to 6) //可变map
    map1["SEVEN"] = 7
    println(map1)

Lambda

EX： 集合的函数式API
查找列表中最长的字符串

    val list = listOf("FOUR", "FIVE", "SIX", "ZhangYu", "WXF")
    println(list)
    var maxStr = "";
    for (node in list){ // 用java思想实现
        if (node.length > maxStr.length){
            maxStr = node;
        }
    }
    println(maxStr)
    //kotlin实现
    var maxL = list.maxBy { it.length}
    println("max $maxL")

[FOUR, FIVE, SIX, ZhangYu, WXF]
ZhangYu
max ZhangYu

语法结构

{参数名1：参数类型，参数名2：参数类型 -> 函数体}
最后一行自动作为Lambda表达式的返回值
现在很多Lambda的表达式都是简化后的，读者很更难理解，我们一步一步来理解

步骤1：构造lambda表达

    val lambda4 = { str: String -> str.length } //构建一个lambda的表达式
    var maxL4 = list.maxBy(lambda4) //传入lambda表达式作为入参
    println(lambda4) //打印lambda表达式
    println("max4 $maxL4")

(kotlin.String) -> kotlin.Int
max4 ZhangYu

步骤2：构造隐式lambda表达

var maxL5 = list.maxBy({ str: String -> str.length })

步骤3：
Kotlin规定，当Lambda参数为最后一个参数时，可以将Lambda表达式移到函数括号外面

var maxL6 = list.maxBy(){ str: String -> str.length }

步骤4
如果Lambda参数时函数唯一一个参数的话，还可以将函数的括号省略，其实跟闭包类似

    var maxL7 = list.maxBy{ str: String -> str.length }

步骤5：
类型推导机制，，不必声明参数类型

    var maxL8 = list.maxBy { str -> str.length }

步骤6：
Lambda参数唯一时，也不必声明参数，可以用默认it关键字代替

var maxL9 = list.maxBy { it.length }

Example:
所有字符都小写

    val list = listOf("FOUR", "FIVE", "SIX", "ZhangYu", "WXF")
    println(list)
    val lambda1 = { str: String -> str.toLowerCase() }
    var list1 = list.map(lambda1)
    var list2 = list.map({ str: String -> str.toLowerCase() })
    var list3 = list.map() { str: String -> str.toLowerCase() }
    var list4 = list.map { str: String -> str.toLowerCase()  }
    var list5 = list.map { str -> str.toLowerCase() }
    var list6 = list.map { it.toLowerCase() }
    println(list1)
    println(list2)
    println(list3)
    println(list4)
    println(list5)
    println(list6)

[FOUR, FIVE, SIX, ZhangYu, WXF]
[four, five, six, zhangyu, wxf]
[four, five, six, zhangyu, wxf]
[four, five, six, zhangyu, wxf]
[four, five, six, zhangyu, wxf]
[four, five, six, zhangyu, wxf]
[four, five, six, zhangyu, wxf]

Lambda 之 filter

过滤集合中的数据

    val list = listOf("FOUR", "FIVE", "SIX", "ZhangYu", "WXF")
    println(list)
    val lambda1 = { str: String -> str.length >= 5 }
    val lambda2 = { str: String -> str.toLowerCase() }
    var list1 = list.map(lambda1)
    var list2 = list.filter(lambda1)
    var list3 = list.filter(lambda1).map(lambda2) //组合使用
    println(list1)
    println(list2)
    println(list3)
    //[FOUR, FIVE, SIX, ZhangYu, WXF]
    //[false, false, false, true, false]
    //[ZhangYu]
    //[zhangyu]

Lambda 之any all

  1. any用户判断集合中是否至少存在一个元素满足指定条件
  2. all用户判断集合中是否所有元素满足指定条件
    val list = listOf("FOUR", "FIVE", "SIX", "ZhangYu", "WXF")
    println(list)
    val lambda1 = { str: String -> str.length >= 5 }
    val lambda2 = { str: String -> str.length <= 5 }
    val lambda3 = { str: String -> str.length <= 7 } 

    var anyResult = list.any(lambda1)  //存在一个字符串大于等于5
    var allResult = list.all(lambda2)  //所以字符创都小于等于5
    var allResult1 = list.all(lambda3) //所以字符创都小于等于7
    //anyResult=true, allResult=false, allResult1=true

Java函数式API的使用

    //step1:最全的Runnable
    Thread(object : Runnable {
        override fun run() {
            println("Running 1 ${Thread.currentThread()}")
        }
    }).start()

    //step2:优化
    Thread(Runnable {
        run() {
            println("Running 2  ${Thread.currentThread()}")
        }
    }).start()

    //step3:接口中只有一个待实现的方法，不显示重写，kotlin也能识别
    Thread(Runnable {
            println("Running 3 ${Thread.currentThread()}")
    }).start()

    //step4:
    Thread({
        println("Running 4 ${Thread.currentThread()}")
    }).start()

    //step5:接下来就跟Lambda一样
    Thread{
        println("Running 5 ${Thread.currentThread()}")
    }.start()
Running 1 Thread[Thread-0,5,main]
Running 2  Thread[Thread-1,5,main]
Running 3 Thread[Thread-2,5,main]
Running 4 Thread[Thread-3,5,main]
Running 5 Thread[Thread-4,5,main]

空指针检查

    var s: Student? = Student() //对象可以为空
    var s1: Student = Student() //对象不能为空
    s = null  //不会编译报错
    s1 = null //会编译报错

fun test1(student: Student) {
    //student不会为空
    student.sleep()  //正确的操作
    student?.sleep() //多余的操作
    student!!.sleep() //多余的操作
}

fun test(student: Student?) {
    //student可能为空
    student.sleep()  //不正确的操作，编译不通过
    student?.sleep() //正确的操作,为空就不运行
    if (student != null) { //等效student?.sleep()
        student.sleep()
    }
    
    student!!.sleep() //正确的操作，为空会强制跑出异常
}

?. 和 ?:

?. 表示如果为空，就不执行
?: 表示如果为空，就取默认的

    val str: String? = null
    println(str)
    var length = str?.length //如果为空就不执行，返回一个null
    println(length)

    var length1 = str?.length ?: 0 // 如果为空，就位默认值0
    println(length1)

null
null
0

let

let是一个函数，lambda的参数是自己

    val student = Student()
    println(student.hashCode())

    var lambda = { student1: Student ->
        student1.sleep()
        student1.hashCode() }
    student.let(lambda)
    
    student.let({ student2 ->
        student2.sleep()
        println(student2.hashCode()) })

    student.let({
        it.sleep()
        println(it.hashCode())
    })
    student.let {
        it.sleep()
        println(it.hashCode())
    }

都是同一个

1580066828
20200702 is sleeping, He is 12 years old
20200702 is sleeping, He is 12 years old
1580066828
20200702 is sleeping, He is 12 years old
1580066828
20200702 is sleeping, He is 12 years old
1580066828

let 结合?. 使用可以减少空判断

    var student: Student? = Student()
    println(student.hashCode())

    //优化1
    student?.let {
        it.sleep()
        println(it.hashCode())
    }

    student = null
    //优化2
    student?.let {
        it.sleep()
        println(it.hashCode())
    } ?: println("student is null")

参数默认值

fun test(num: Int = 20, name: String = "zhangyu"): Unit {
    println("name=$name num=$num")
}
    test() //两个参数都不传
    test(18)  //name采用默认的
    test(name = "wxf")//age采用默认的
    test(18, "wxf")
    test(name = "wxf", num = 28) //参数顺序可以随意

学习借鉴

第一行代码-第三版-郭霖著
Kotlin是Google官方推广的语言，Kotlin学习网址

珍心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kotlin入门学习心得
weixin_36317299的博客
05-30 1302
写在前面：作为一个安卓客户端的开发人员，现在Android的官方语言已经从java变成了kotlin。java稳稳占据了Android的官方语言长达数十年，而现在谷歌决定改用kotlin自然有它的方便和独到之处。 作为开发人员，还是有必要了解一下kotlin的基础特性和语法的，所以本篇博客就是我个人学习和使用kotlin的心得。如果同学们看到，能有兴趣了解和学习kotlin，那我这篇博客的目的也就...
Kotlin基础知识总结（三万字超详细）
编程小鹏的博客
05-05 891
Kotlin学习笔记总结
Kotlin知识点总结
屈云硕的博客
07-04 637
与Java不同的是，Kotlin并不强制要求每条语句必须以分号结尾，如果单独一行内只有一条语句，那么Kotlin允许这条语句不以分号结尾。 Kotlin允许一条语句可以跨多行。 Kotlin是强类型语言，要求所有的变量必须先声明后使用，声明变量时必须显示或隐式的指定变量的类型。 var声明的变量是值可变的、val声明的变量是值不可变的。 一般来说整型当中，开发者应该尽量使用Int型，这样可...
kotlin 基础总结
SlagSea
06-09 2794
kotlin 学习总结 记录一下与java相比的一些基础重要的点 1.基础知识 1.1 基本类型 kotlin中没有java基本类型的int、float、double等，所有东西都是对象，这与java类似。但是kotlin对数字没有隐式拓宽转换，需要显示转换；数字字面量不支持八进制。 1.2 包与导入 使用import关键字，功能上与java差不多。import不限于导入类，还可以导入声明如枚举...
Kotlin入门学习(非常详细)，从零基础入门到精通，看完这一篇就够了
热门推荐
Javachichi的博客
07-12 3万+
和Java中的接口定义类似。
Kotlin总结
linglingchenchen的专栏
05-06 2357
Kotlin总结
kotlin学习kotlin学习
08-16
kotlin学习kotlin学习
Kotlin概述与学习指南
最新发布
06-14
Kotlin概述与学习指南
Kotlin学习资料自用
06-13
【Kotlin学习资料自用】 Kotlin是一种现代的、面向对象的编程语言，由JetBrains公司开发，主要用于Android应用开发，但也可应用于Web、服务器端和桌面应用等平台。Kotlin的设计目标是提供简洁、安全、可空安全以及...
kotlin学习demo
08-14
【Kotlin学习Demo详解】 Kotlin，一种由JetBrains公司开发的现代编程语言，自2016年发布以来，已经在Android开发领域取得了显著的地位。它以其简洁、安全和面向表达性的特性，深受开发者喜爱。这个"Kotlin学习demo...
kotlin语法：学习Kotlin语法
02-20
Kotlin是一种现代、类型...通过深入学习Kotlin的这些语法特性，开发者可以编写出更加简洁、高效且易于维护的代码。Kotlin的这些设计决策使得其在实际开发中具有更高的生产力和更低的错误率，是现代软件开发的强大工具。
kotlin知识点
bp1907的博客
01-06 3135
kotin知识点 一、kotlin基础 1.变量与函数 1.1变量 val、var 2.逻辑控制 3.面向对象编程 4.Lambda编程 5.空指针检查 二、标准函数和静态函数 三、延迟初始化和密封类 四、扩展函数和运算符重载 五、高阶函数 六、泛型和委托 七、infix函数 八、协程 九、DSL 十、java与kotlin之间的转换 ...
准备起航，了解Kotlin
北漂周的专栏（微信：stchou_zst）
06-08 2984
“近一百多年来，总有一些公司很幸运地、有意识或无意识地站在技术革命的浪尖之上。一旦出在了那个位置，即使不做任何事，也可以随着波浪顺顺当当地向前飘个十年甚至更长时间。在这十几年间，它们代表着科技的浪潮，直到下一波浪潮的来临。” —— 吴军 《浪潮之巅》 正如作者吴军所言，“在工业史上，一种新技术代替旧的技术是不以人的意志为转移的。”浪潮和巨头以一种相辅相成的关系一次次推动IT行业的进化，这样看
Kotlin 总结学习，温故知新
蓝枫
03-28 396
1.kotlin中函数 (1) kotlin中函数以fun关键字开头 (2) 返回值类型写在函数名后面 (3) java中无返回值是void，kotlin中无返回值是Unit (4) 函数参数的写法是：参数名：参数名类型 (5) 函数可以直接写在文件中，也可以写在类中 2.kotlin中的变量 (1) 可读可写变量var、只读变量val (2) val 相当于java中的final...
Kotlin基础总结
hao378300757的博客
04-24 1662
Kotlin的学习总结
Kotlin学习总结(一）
woaichihuoguoguo的博客
08-30 176
目录 前言 最近在学习Android开发，在之前Google只提供了Java一种语言来开发Android。但是现在Android官网文档已经是kotlin First。并且Kotlin和Java是100%兼容的。也就是说Kotlin可以直接调用Java编写的代码，也可以使用Java的第三方开源库。 编程语言大致可以分为编译性语言和解释性语言。编译性语言的特点是编译器可以将我们编写的源代码一次性编译成计算机可以识别的二进制文件，然后由计算机直接执行，如C/C++。解...
Kotlin学习总结
hao378300757的博客
04-24 154
Kotlin的复习总结
Kotlin核心知识梳理
流星雨的博客
07-30 2034
Kotlin 知识点总结-基础篇 文章目录Kotlin 知识点总结-基础篇一、数据类型1.1、基本数据类型定义1.2、模板操作符1.3、类和对象初始化1.4、空类型和智能类型转换二、数组2.1、定义方式2.2、数组处理方法2.2.1、slice用法2.2.2、String接收字符串数组初始化2.2.3、遍历三、程序结构3.1、常量与变量(val,var)3.2、函数3.2.1、基础写法3.2.2、简化与匿名函数3.2.3、lambda表达式3.2.3.1、普通写法3.2.3.2、简化3.2.3.3、forE
kotlin核心功能学习路线
04-09
以下是学习Kotlin核心功能的一条推荐路线： 1. 变量和数据类型：了解Kotlin中的变量声明和数据类型，包括基本数据类型、可空类型和集合类型等。 2. 控制流程：学习Kotlin中的条件语句（if-else、when）和循环语句...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值