侧边栏壁纸
博主头像
叩钉壹刻博主等级

7分技术，3分管理，2分运气

  • 累计撰写 30 篇文章
  • 累计创建 13 个标签
  • 累计收到 0 条评论

目 录CONTENT

文章目录
编程语言与技术

kotlin 语言基础

鹿心肺语
鹿心肺语
2022-08-22 / 0 评论 / 0 点赞 / 19 阅读 / 67744 字

第一章 kotlin 前提

1.1 kotlin与JVM虚拟机关系

[Kotlin/Java/Groovy] → 编译环节 → 产生字节码 → JVM产生指令 → 系统命令式执行

1.2 kotlin的意义

  1. 各个语言的核心集合
  2. 可以作为全栈语言

第二章 kotlin 基础篇

2.1 hello word 输出

fun main(){
	println("hello world")
}

2.2 Kotlin内置数据类型(引用类型)

  1. 字符类型:
    • String(字符串)
    • Char(单字符)
  2. 数值类型:
    • Int(整型)
    • Float(浮点数)
    • Double(小数)
  3. 布尔类型
    • Boolean True/False
  4. 集合类型
    • List(列表元素)
    • Set(无重复的集合元素)
    • Map(键值对)

2.3 声明变量

  1. 格式1: var 变量名:数据类型 [= 初始值]

    作用: 可以读写

    fun main(){
	var name:String = "demo"
	println(name)
}

  2. 格式2: val 变量名:数值类型 [= 初始值]

    作用: 只能读

    fun main(){
	val name:String = "demo"
	// name = "demo1"  --> 报错
	println(name)
}

2.4 const val、val、var 声明区别

  1. const val 定义在函数外,编译时常量
  2. val 只读类型
  3. var 读写类型

2.5 查看字节码和反编译的java代码

  1. 查看字节码

    图2-1: 查看字节码

  2. 反编译java代码

    图2-2: kotlin字节码转java代码

2.6 Range表达式: ..

  1. 格式: 初始值..结束值

    作用: 从初始值到结束值

    fun main() {
    var num: Int = 59
    if (num in 0..59) {
        println("不及格")
    } else {
        println("及格")
    }
}

2.7 When表达式: when

  1. 格式: val 变量名:变量类型 = when(入参值){ 匹配入参值1 → 返回信息 … else → 返回信息}

    作用: 一值多匹配结果

    fun main() {
	var week: Int = 1
	var result: Any = when (week % 7) {
		0 -> "星期天"
		1 -> "星期一"
		2 -> "星期二"
		3 -> "星期三"
		4 -> "星期四"
		5 -> "星期五"
		6 -> "星期六"
		else -> "没有匹配到"
	}
	println(result)
}

2.8 String模版: 输出模版

  1. 格式: “{变量名}” 或 ”变量名”

    作用: 简化模版格式,其中 ”$变量名” 只能用于无文本紧密连接的情况

    fun main() {
	val name: String = "zhangsan"
	val age: Int = 18
	println("姓名：${name},年龄：$age")
}

2.9 控制台键入值: 输入内容

  1. 格式: readline()

    作用: 读取输入的一行内容

    fun main(args: Array<String>) {
	print("请输入内容: ")
	val content: String? = readLine()
	println("你所输入的内容为：${content}")
}

  2. 格式: val input:Scanner = Scanner(System.in)

    作用: 声明Java版本的读取

    import java.util.Scanner

fun main(args: Array<String>) {
	val input: Scanner = Scanner(System.`in`)
	print("请输入内容：")
	val content: String = input.nextLine()
	println("你所输入的内容为：${content}")
}

2.10 常规函数

  1. 参数中不含默认的函数

    格式: 函数修饰符 fun 函数名(参数名1:参数类型1…参数名n:参数类型n):返回数据类型 { 代码段 }

    注意: 函数修饰符默认为public

    fun main() {
	var result = add(2, 3)
	println("2 + 3 = $result")
}

public fun add(x: Int, y: Int): Int {
	return x + y
}

  2. 参数中含默认值的函数

    格式: 函数修饰符 fun 函数名(参数名1:参数类型1,参数名2:参数类型2=默认值…参数名n:参数类型n):返回数据类型 { 代码段 }

    注意: 默认值可以没有顺序,但传参赋值一定是从左到右

    fun main() {
	var result = add(3)
	println(result)
}

public fun add(x: Int = 2, y: Int = 4): Int {
	return x + y
}

  3. 具名参数的函数

    格式[调用]: val 变量名[:变量类型] = 函数名(参数名1=参数值1…参数名n=参数值n)

    注意: 调用时,不需要从左到右依次赋值

    fun main() {
	var result = add(y = 3)
	println(result)
}

public fun add(x: Int = 2, y: Int): Int {
	return x + y
}

2.11 空返回: Unit

  • 返回类型可以为空,空时可以输出内容[ kotlin.Unit ]

    注意: 不加返回值类型,默认为Unit

    fun main() {
	method()
	method1()
	
	//输出 kotlin.Unit
	var result = method2()
	println(result)
}

//默认为Unit, 可加入return语句，但必须为Unit类型
fun method() {
	return println()
}

//返回类型Unit, 可加入return语句，但必须为Unit类型
fun method1(): Unit {
	return println()
}

fun method2(): Unit {
	println()
}

2.12 无法正常返回: Nothing

  • 一般正常返回的值,都是有返回类型的,默认都是为空返回. 但存在无法返回的情况,例如抛出异常等,所以就存在了Nothing

    注意: Nothing是所有类型的子类

    fun main() {
	throwError()
}

fun throwError(): Nothing {
	// throw 和 TODO 都是可以抛出异常的
	//TODO("主动抛出异常")
	throw Exception("主动抛出异常")
}

2.13 反引号: `

  • 用途: 1. 用做函数的名称; 2. 在调用其他语言过程中含有Kotlin语法的关键字(经常); 3. 具体功能的转译

    public class JavaClass {
	public void in(String content) {
		System.out.println("输出的内容为：" + content);
	}
}

    fun main(args: Array<String>) {
	val javaCode: JavaClass = JavaClass()
	javaCode.`in`("kotlin 传递给 java代码的内容")
}

2.14 进阶函数

  1. 匿名函数

    函数实现在方法之后,不需要显式声明调用

    fun main(args: Array<String>) {
	val len: Int = "hello".count()
	println("hello的个数为${len}")

	val lenforL: Int = "hello".count {
		it == 'l'
	}
	println("hello中的l的个数为${lenforL}")
}

  2. 函数的隐式返回: 函数不需要单独定义,在需要处直接声明实现

    不带参数: 可直接使用声明的名称调用

    fun main(args: Array<String>) {
	//函数的声明
	val method: () -> String

	//函数的实现
	method = {
		"这是返回的字符"
	}

	//函数的使用
	println(method)
}

    带参数: 需要进行传递所需参数内容。在只有一个参数时，注意默认会有一个 it 关键字

    fun main(args: Array<String>) {
	val add: (x: Int, y: Int, z: Int) -> Int = { x: Int, y: Int, z: Int ->
		x + y + z
	}

	println("1，2，3 三值只和为：${add(1, 2, 3)}")
}

  3. 函数返回的lambda推导

    在不确定返回值的情况下,可不用写返回类型,自动推导出返回值的类型

    注意: 当返回值类型不止一种的时候,返回的类型则为Any

    fun main(args: Array<String>) {
	var method = { x: String, y: Int ->
		"输入内容，字符串：${x},数值：${y}"
	}

	println(method("demo", 1))
}

  4. 函数中的参数为函数

    参数为函数作为返回值,处理返回来的内容信息

    fun main() {

	loginSQL("root", "123456") { code: Int, status: String, msg: String ->
		println("请求的结果如下：状态值：${code}，状态：${status}，提示信息：${msg}")
	}

	//其余写法
	loginSQL("root", "123456", { code: Int, status: String, msg: String ->
		println("请求的结果如下：状态值：${code}，状态：${status}，提示信息：${msg}")
	})

	loginSQL("root", "123456", Response = { code: Int, status: String, msg: String ->
		println("请求的结果如下：状态值：${code}，状态：${status}，提示信息：${msg}")
	})
}

//模拟前端发送请求
public fun loginSQL(username: String, password: String, Response: (code: Int, status: String, msg: String) -> Unit) {
	if (username != null && password != null) {
		if (loginSQLAPI(username, password)) {
			Response(200, "ok", "数据库访问成功")
		} else {
			Response(500, "error", "数据库访问失败")
		}
	} else {
		TODO("用户名或者密码为空")
	}
}

//数据库的数据
const val name = "root"
const val pwd = "123456"

//后台接口API
private fun loginSQLAPI(username: String, password: String): Boolean {
	return if (username == name && password == pwd) true else false
}

2.15 内联模式: inline

  • 作用对象: 存在函数中参数为函数的方法

    优点: 1. 不会存在性能损耗; 2. 不存在对象的开辟

    注意: 使用内联模式的函数,其调用的函数方法属性必须为public

    fun main() {

	loginSQL("root", "123456") { code: Int, status: String, msg: String ->
		println("请求的结果如下：状态值：${code}，状态：${status}，提示信息：${msg}")
	}

	//其余写法
	loginSQL("root", "123456", { code: Int, status: String, msg: String ->
		println("请求的结果如下：状态值：${code}，状态：${status}，提示信息：${msg}")
	})

	loginSQL("root", "123456", Response = { code: Int, status: String, msg: String ->
		println("请求的结果如下：状态值：${code}，状态：${status}，提示信息：${msg}")
	})
}

//模拟前端发送请求
public inline fun loginSQL(username: String, password: String, Response: (code: Int, status: String, msg: String) -> Unit) {
	if (username != null && password != null) {
		if (loginSQLAPI(username, password)) {
			Response(200, "ok", "数据库访问成功")
		} else {
			Response(500, "error", "数据库访问失败")
		}
	} else {
		TODO("用户名或者密码为空")
	}
}

//数据库的数据
const val name = "root"
const val pwd = "123456"

//后台接口API
public fun loginSQLAPI(username: String, password: String): Boolean {
	return if (username == name && password == pwd) true else false
}

2.16 函数类型引用: ::

  • 作用对象: 存在函数中参数为函数的方法

    优点: 可以将返回参数的函数进行显式的声明和实现

    fun main() {
	login("root", "123456", ::processResponse)
}

fun processResponse(code: Int, status: String, msg: String) {
	println("访问结果信息：状态值：${code}，状态：${status}，信息提示：${msg}")
}

public inline fun login(name: String, pwd: String, Response: (code: Int, status: String, msg: String) -> Unit) {
	if (name == "root" && pwd == "123456") {
		Response(200, "ok", "访问成功")
	} else {
		Response(200, "error", "访问失败")
	}
}

2.17 返回值为函数

  • 将函数的返回值由类型改为函数,可双重调用,调取函数返回函数的值

    fun main(args: Array<String>) {

	val subMethod: (age: Int) -> String = method("zhangsan")

	println(subMethod(19))

}

inline fun method(name: String): (age: Int) -> String {
	println("你的名字是：${name}")
	return {
		"实际的年龄为：${it - 1}"
	}
}

2.18 具名函数和匿名函数对比

  • 区别: 具名函数可以将函数声明实现在其他地方,匿名函数必须在调用的时候实现

    关联: 具名函数 == 函数类型引用 ; 匿名函数 == 函数中的参数为函数

    fun main(args: Array<String>) {
	//匿名调用
	method("zhangsan", 18) {
		println("实际年龄为：${it - 1}")
	}
	//具名调用
	method("zhangsan", 18, ::optionImpl)
}

fun method(name: String, age: Int, option: (age: Int) -> Unit) {
	println("你的姓名为：${name},虚岁年龄为：${age}")
	return option(age)
}

fun optionImpl(age: Int): Unit {
	println("实际年龄为：${age - 1}")
}

2.19 属性可空特性: ?

  • 注意: 默认声明一般是为不空

    fun main(args: Array<String>) {
	//不可空属性
	var name: String = "demo"
	println(name)

	//可空属性
	val num: Int? = null
	println(num)
}

2.20 属性安全调用

  1. 可空类型的安全调用

    格式: 属性名?.方法名()

    作用: 通过判断属性名是否为空,从而判断是否进行执行属性名后的方法

    fun main(args: Array<String>) {
	var name: String? = "demo"
	//属性名?.方法 ,当属性值不为空时执行后面的方法，属性值为空时不执行后面的方法
	println("当前值为：${name?.capitalize()}")
	name = null
	println("改变后的值为：${name?.capitalize()}")
}

  2. let安全调用

    格式: 属性名?.let{ 代码段 }

    作用: 当属性名不为空时,执行后面的代码段,且返回最后一行的值

    fun main(args: Array<String>) {
	var name: String? = "demo"
	val result1: String? = name?.let {
		it.capitalize()
	}
	println("当前值为：${result1}")

	name = null
	val result2: String? = name?.let {
		it.capitalize()
	}
	println("改变之后的值为：${result2}")
}

  3. 非空断言

    格式: 属性名!!.方法名()

    注意: 断言的内容一定要事先知道预期的结果,因为方法是会执行,不论属性为什么值

    fun main(args: Array<String>) {
	var name: String? = null
	//非空断言，属性值无论是什么都会执行后续的方法
	println(name!!.capitalize()) //这里会报错，空指针异常
}

  4. if判空

    格式: if(属性名 [比较] 预设值) 操作

    fun main(args: Array<String>) {
	var name: String? = null

	if (name == null) {
		println("当前的name值为空")
	} else {
		println("当前的name值不为空")
	}
}

  5. 空合并

    格式: 属性名?:为空时的值

    fun main(args: Array<String>) {
	var name: String? = null

	val result: String = name ?: "null"
	println("当前的name值为：${name}")
}

2.21 异常处理: try…catch

  • 作用: 主要为了预防一些可见的异常和一些不可见的异常

    fun main(args: Array<String>) {
	try {
		var info: String? = null
		checkNotNullException(info)

	} catch (e: Exception) {
		e.printStackTrace()
	}
}

fun checkNotNullException(value: String?) {
	value ?: throw ValueIsNullException()
}

public class ValueIsNullException : NullPointerException("空指针异常")

2.22 先决条件

  • 作用: 为了判断属性是否为空

    fun main(args: Array<String>) {
	var name: String? = null

	//为null时进行异常提示：java.lang.IllegalStateException: Required value was null.
	checkNotNull(name)

	//定义带有返回提示的异常信息：java.lang.IllegalStateException: 属性值不能为空
	checkNotNull(name, lazyMessage = { "属性值不能为空" })

	//当为false是抛出异常，为true正常执行：java.lang.IllegalStateException: Check failed.
	check(name?.let { true } ?: false)

	//带有返回提示的异常信息：java.lang.IllegalStateException: 属性值不能为空
	check(name?.let { true } ?: false, lazyMessage = {"属性值不能为空"})

	//同理 require和check相似，requireNotNull和checkNotNull相似
	requireNotNull(name)

	requireNotNull(name, lazyMessage = { "属性值不能为空" })

	require(name?.let { true } ?: false)

	require(name?.let { true } ?: false, lazyMessage = { "属性值不能为空" })
}

2.23 String类常用的方法

  1. subString方法

    用途: 分割字符串

    fun main(args: Array<String>) {
	var str: String = "hello world"

	val subStr1: String? = str.substring(0..5)
	println("字符串0-5的字符为：${subStr1}")

	val subStr2: String? = str.substring(0, str.indexOf(' '))
	println("字符串从头到第一个为空格的字符为：${subStr2}")

	val subStr3: String? = str.substring(0 until str.indexOf(' '))
	println("字符串从头到第一个为空格的字符为：${subStr3}")
}

  2. split方法

    用途: 分割字符串成若干子字符串数组

    fun main(args: Array<String>) {
	var str: String = "hello world"

	var splitStr: List<String> = str.split(' ')
	println("当前分割结果为；${splitStr}")
}

  3. replace方法

    用途: 替换字符中的部分内容

    fun main(args: Array<String>) {
	var str: String = "hello world"

	var result: String = str.replace('o', 'e')
	println("替换后的结果为：${result}")
}

  4. foreach方法

    用途: 用于循环某个内容

    fun main(args: Array<String>) {
	var str: String = "hello world"

	print("循环输出的结果为： ")
	str.forEach {
		print("${it} ")
	}
}

  5. ==和===比较

    区别: == 用于值或者内容的比较; === 除了值或内容比较外,还有引用的比较

    fun main(args: Array<String>) {
	var str1: String = "hello world"
	var str2: String = "hello world"

	// == 用于值或内容的比较，与java中的equals相同
	println("str1 == str2 的结果为：${str1 == str2}")
	println("str1 == str2 的结果为：${str1.equals(str2)}")
	
	// === 用于引用比较
	println("str1 === str2 的结果为：${str1 === str2}")
}

2.24 类型转换

  1. String类型 → Int类型

    作用: 将String类型的值转化为Int类型的值

    fun main(args: Array<String>) {
	val num: Int = "66".toInt()
	println(num)

	//转化失败将为null
	var num1: Int? = "66.6".toIntOrNull()
	println(num1)

	var num2: Int? = "99".toIntOrNull()
	println(num2)

	var num3: Int? = "66.6".toIntOrNull()
	println(num3 ?: "null值")
}

  2. Double类型 → Int类型

    作用: 将Double类型的值转化为Int类型

    import kotlin.math.roundToInt

fun main(args: Array<String>) {
	// toInt()和roundToInt()四舍五入方式
	println(65.13451234.toInt())
	println(65.13451234.roundToInt())
	println(65.612345.roundToInt())
}

  3. Double类型 → String类型

    作用: 将Double类型格式化String类型

    fun main(args: Array<String>) {
	var r: String = "%.3f".format(65.13451234)
	println(r)
}

2.25 内置函数

  1. apply内置函数

    特点: 入参默认含有this对象,返回对象本身类型

    fun main(args: Array<String>) {
	var name: String = "demo"

	//apply入参默认含有this对象
	var result: String = name.apply {
		println("你的名字为：${this.capitalize()}")
	}

	//apply返回对象本身
	println("返回的结果为：${result}")
}

  2. let内置函数

    特点: 入参默认含有it对象,返回最后一行的内容

    fun main(args: Array<String>) {
	var name: String = "demo"

	//let入参默认含有it对象
	var result: Unit = name.let {
		println("你的名字为：${it.capitalize()}")
	}

	//it返回代码块中最后一行内容
	println("返回的结果为：${result}")
}

  3. run 内置函数

    特点: 入参默认含有this对象,返回最后一行内容

    用法: 与apply和run相同.在链式调用时需要一个接一个

    fun main(args: Array<String>) {
	var name: String = "demo"

	//run入参默认含有this对象
	var result: Unit = name.run {
		println("你的名字为：${this.capitalize()}")
	}

	//run返回代码块中最后一行内容
	println("返回的结果为：${result}")
}

  4. with 内置函数

    特点: 入参默认含有this对象,返回最后一行内容

    用法: 与run不相同.在链式调用时,需要层层嵌套

    fun main(args: Array<String>) {
	var name: String = "demo"

	//run入参默认含有this对象
	var result = with(name, {
		println("你的名字为：${this}")
	})

	//run返回代码块中最后一行内容
	println("返回的结果为：${result}")
}

  5. also 内置函数

    特点: 入参默认含有it对象,返回对象本身

    fun main(args: Array<String>) {
	var name: String = "demo"

	//also入参默认含有it对象
	var result = name.also {
		println("你的名字为：${it.capitalize()}")
	}

	//also返回对象本身
	println("返回的结果为：${result}")
}

  6. takeif 内置函数

    特点: 如果takeif内的返回值为true则返回对象,否则返回nul

    fun main(args: Array<String>) {
	var name: String? = "demo"

	var result1 = name.takeIf { name?.let { true } ?: false }
	println("初始值takeif结果为：${result1}")

	name = null
	var result2 = name.takeIf { name?.let { true } ?: false }
	print("赋值为null后的结果为：${result2}")
}

  7. takeunless 内置函数

    特点: 如果takeunless内的返回值为false则返回对象,否则返回null

    关联: 与takeif相反

    fun main(args: Array<String>) {
	var name: String? = "demo"

	var result1 = name.takeUnless { name?.let { false } ?: true }
	println("初始值takeif结果为：${result1}")

	name = null
	var result2 = name.takeUnless { name?.let { false } ?: true }
	print("赋值为null后的结果为：${result2}")
}

2.26 List集合

  1. 长度不可变的List

    定义即初始化,该List可通过相应的方法增加、删除元素

    fun main(args: Array<String>) {
	val strs: List<String> = listOf("list1", "list2", "list3")

	//输出
	println(strs)

	//下标访问
	println(strs.get(0))
	println(strs[1])

	//防止越界操作 getOrElse当越界后返回{}内的值
	println(strs.getOrElse(3) { "越界" })

	//防止越界操作 getOrNull当越界之后返回null值，一般配合空合并操作
	println(strs.getOrNull(4) ?: "越界")

	//添加元素 该方法为kotlin.collections
	println(strs.plusElement("listNew1"))
	//删除元素 该方法为kotlin.collections
	println(strs.minusElement("listNew1"))
}

  2. 长度可变的List

    定义可以初始化,该List可以直接增加、删除和修改元素

    fun main(args: Array<String>) {
	val strs: MutableList<String> = mutableListOf("list1", "list2", "list3")

	//增加操作 默认增加在最后
	strs.add("listNew1")
	println(strs)

	//删除操作 如何删除的元素存在则删除，否则返回原数组内容
	strs.remove("list1")
	println(strs)

	//将不可变list集合转化为可变list集合
	val strs1: List<String> = listOf("new1", "new2", "new3")
	val strs2: MutableList<String> = strs1.toMutableList()
	println(strs2)
}

    可变长度的List,在增加时可以通过 += 进行添加元素; 在删除时也可以通过 removeif 进行删除

    fun main(args: Array<String>) {
	val strs: MutableList<String> = mutableListOf("list1", "list2", "list3")

	//增加操作 默认增加在最后
	strs += "listNew1"
	println(strs)

	//删除操作 对每一个元素判断是否包含字段值，包含则删除，不包含则保留
	strs.removeIf {
		it.contains("New")
	}
	println(strs)
}

  3. 遍历List

    遍历不可变和可变长度的List集合

    fun main(args: Array<String>) {
	val strs: List<String> = listOf("new1", "new2", "new3")
	val strs1: MutableList<String> = strs.toMutableList()

	//遍历 List-不可变 和 MutableList-可变 相同
	print("for循环的结果为：")
	for (item in strs1) {
		print("${item} ")
	}
	println()

	print("foreach循环的结果为：")
	strs1.forEach({
		print("${it} ")
	})
	println()

	print("含有下标的forEachIndexed循环结果为：")
	strs1.forEachIndexed({ index: Int, s: String ->
		print("下标为 ${index} 的值为 ${s}   ;")
	})
	println()
}

2.27 解构过滤

  • 通过对对象的解析,返回特定位置上的特定值

    注意: 当不需要某个位置的元素时,可以通过 _ 进行忽略

    fun main(args: Array<String>) {
	val strs: List<String> = listOf("value1", "value2", "value3")

	//对应位置的解构,不能过多的解析，否则就会报错
	var (v1: String, _, v2: String?) = strs
	println("解析结果为：${v1},${v2}")

	// var (v1: String, _, _, v2: String?) = strs -- 报错，strs的list集合并没有第四个元素
}

2.28 Set集合

  • 不可变的Set集合

    与长度不可变的List相似,但Set集合元素无重复

    fun main(args: Array<String>) {
	//Set集合元素不重复
	val strs: Set<String> = setOf("set1", "set2", "set3", "set1")
	println(strs)

	//访问 下标访问
	println(strs.elementAt(1))

	//访问 elementAtOrElse，当位置上没有值时返回{}内的内容
	var result1: String = strs.elementAtOrElse(3, { "该位置没有值" })
	println(result1)

	//访问 elementAtOrNull，当位置上没有值时返回null 一般与空拼接结合使用
	var result2: String = strs.elementAtOrNull(3) ?: "该位置没有值"
	println(result2)

	//增加元素
	println(strs.plusElement("it"))
	//删除元素
	println(strs.minusElement("it"))
}

  • 可变的Set集合

    与长度可变的List相似,但Set集合元素无重复

    fun main(args: Array<String>) {
	val strs: MutableSet<String> = mutableSetOf("set1", "set2", "set3", "set1")
	println(strs)

	//增加元素
	strs += "setNew"
	println(strs)

	strs.add("setNew1")
	println(strs)

	//删除元素
	strs -= "setNew"
	println(strs)

	strs.remove("setNew1")
	println(strs)
}

2.29 List集合去重

  • 解决List集合中含有重复的元素

    fun main(args: Array<String>) {
	val strs: List<String> = listOf("list1", "list2", "list3", "list1")
	println("去重前的值：${strs}")

	//去重方法1： 转化为Set集合
	val strsSet: Set<String> = strs.toSet()
	println("转化为Set集合去重后的结果：${strsSet}")

	//去重方法2：转化为Set集合，在转化为List集合
	val strsNew: List<String> = strs.toSet().toList()
	println("先转化为Set集合，再转化为List集合去重后的结果：${strsNew}")

	//去重方法3：通过distinct()方法去重
	val strsDistinct: List<String> = strs.distinct()
	println("通过Distinct()方法去重后的结果：${strsDistinct}")
	//等价方法 strs.toMutableSet().toList()
}

2.30 数组

  • 数组的类型

    数组类型赋值方法
    IntArrayintArrayOf
    DoubleArraydoubleArrayOf
    LongArraylongArrayOf
    ShortArrayshortArrayOf
    ByteArraybyteArrayOf
    FloatArrayfloatArrayOf
    BooleanArraybooleanArrayOf
    Arrayarrayof

  • 单一类型的一类值的集合

    fun main(args: Array<String>) {
	val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5, 7, 6)
	println(intArray)

	//访问元素
	println(intArray[0])
	println(intArray.get(1))

	//访问 elementAtOrElse，当位置上没有值时返回{}内的内容
	var result1: Int = intArray.getOrElse(10, { -1 })
	println(result1)
	//访问 elementAtOrNull，当位置上没有值时返回null 一般与空拼接结合使用
	var result2: Int = intArray.getOrNull(10) ?: -1
	println(result2)

	//List集合转为数组，只有数据类型内含有的才可以转化，但除了Arrya之外
	val strs: List<Char> = listOf('1', '2', '3', '4')
	val strsToArray: CharArray = strs.toCharArray()
	println(strsToArray)
}

2.31 Map集合

  • 创建Map集合

    参数格式: 类型1 to 类型2 或者 Pair(类型1,类型2)

    fun main(args: Array<String>) {
	var map1: Map<String, Any> = mapOf<String, Any>("code" to 200, "status" to "ok", "data" to listOf<String>("value1", "value2"))

	var map2: Map<String, Any> = mapOf<String, Any>(Pair("code", 200), Pair("status", "ok"), Pair("data", listOf<String>("value1", "value2")))
}

  • 访问Map集合

    fun main(args: Array<String>) {
	var map1: Map<String, Any> =
		mapOf<String, Any>("code" to 200, "status" to "ok", "data" to listOf<String>("value1", "value2"))

	var map2: Map<String, Any> =
		mapOf<String, Any>(Pair("code", 200), Pair("status", "ok"), Pair("data", listOf<String>("value1", "value2")))

	//访问Map集合
	println(map1["code"])
	println(map1["status"])
	println(map1.get("data"))

	//访问字段 getOrDefault 当对象中没有该key值时就会返回后面的默认的value值，反之返回对象中的值
	println(map1.getOrDefault("msg", "暂无此字段"))
	//访问字段 getOrElse 当对象中没有该key值时就会返回后面的默认的value值，反之返回对象中的值
	println(map1.getOrElse("msg", { "暂无此字段" }))
}

  • 遍历Map集合

    fun main(args: Array<String>) {
	var map1: Map<String, Any> =
		mapOf<String, Any>("code" to 200, "status" to "ok", "data" to listOf<String>("value1", "value2"))

	var map2: Map<String, Any> =
		mapOf<String, Any>(Pair("code", 200), Pair("status", "ok"), Pair("data", listOf<String>("value1", "value2")))

	map1.forEach { t, u ->
		println("集合的key为：${t},value为：${u}")
	}
	println()

	map1.forEach { (key: String, value: Any) ->
		println("集合的key为：${key},value为：${value}")
	}
	println()

	for (item: Map.Entry<String, Any> in map1) {
		println("集合的key为：${item.key},value为：${item.value}")
	}
}

  • 可变Map集合操作

    fun main(args: Array<String>) {
	var map: MutableMap<String, Any> =
		mutableMapOf<String, Any>(Pair("code", 200),
			Pair("status", "ok"),
			Pair("data", listOf<String>("value1", "value2")))

	//添加字段值
	map += Pair<String, Any>("msg", "操作成功")
	println(map)
	map["field1"] = "value1"
	println(map)

	//获取或者存入值 getOrPut
	val result = map.getOrPut("msg", { "暂无此字段的值" })
	println(result)

}

第三章 kotlin进阶篇

3.1 类: class

  1. 类与 filed 关键字

    注意: kotlin中的属性在经过转译之后,会将属性私有化,会提供对应的set或get方法.根据kotlin声明是var(读写属性)还是val(只读属性)进行具体提供

    //定义Person类,私有属性，会提供公有的set和get方法
class Person {
	var name: String? = null
		get() = field
		set(value) {
			field = value
		}

	var age: Int? = 18

}

fun main(args: Array<String>) {

	val person: Person = Person()

	person.name = "demo"
	println("创建的person对象，name赋值为：${person.name}")
	person.age = 20
	println("创建的person对象，age赋值为：${person.age}")
}

  2. 类的计算属性和防范空的情况

    class Person2 {
	var name: String? = null

	//计算属性，针对于只读属性val进行操作
	val randomNum: Int
		get() = (1..100).shuffled().first()

	//属性防范空的情况
	public fun getNameInfo(): String {
		return name?.let {
			"成功赋值，值的内容是：${name}"
		} ?: "没有赋值，当前为null"
	}

}

fun main(args: Array<String>) {
	var person: Person2 = Person2()

	//计算属性的获取
	println(person.randomNum)

	//默认为空的输出情况
	println(person.getNameInfo())
	//重新赋值情况
	person.name = "zhangsan"
	println(person.getNameInfo())
}

  3. 类的主构造

    作用: 主要是为了在声明时进行初始化

    注意: 主构造的变量默认为临时类型,在声明创建后不能获取该临时变量.若需要使用,则需要声明主构造中的变量属性或者赋值在类内部声明变量

    • 默认构造并且赋值到类的内部变量进行访问
    //默认主构造且采取赋值到类内部变量
class Person(_name: String, _age: Int) {
	var name: String = _name
	var age: Int = _age
}

fun main(args: Array<String>) {
	var person: Person = Person("zhangsan", 20)

	// person._name -> 无法进行该访问
	println("Person初始化内容信息为：name = ${person.name}; age = ${person.age}")
}
    • 声明主构造变量的变量属性, val 或者 var
    class Person(var name: String, var age: Int) {
}

fun main(args: Array<String>) {
	var person: Person = Person("zhangsan", 20)
	
	println("Person初始化内容信息为：name = ${person.name}; age = ${person.age}")
}

  4. 次构造函数

    作用: 可初始化类中的部分属性

    注意: 可重载;需实现主构造,为主构造赋值,让主构造统一管理

    class Person(_name: String) {

	var Cname: String = _name
	var Cage: Int = 18
	var Cinfo: String? = null

	constructor(name: String, age: Int) : this(name) {
		println("次构造函数中的属性为：name=${name};age=${age}")
		this.Cname = name
		this.Cage = age
	}

	constructor(name: String, age: Int, info: String?) : this(name) {
		println("次构造函数中的属性为：name=${name};age=${age};info=${info}")
		this.Cname = name
		this.Cage = age
		this.Cinfo = info
	}

}

fun main(args: Array<String>) {

	var person1: Person = Person("zhangsan")
	println(person1.Cname)

	var person2: Person = Person("zhangsan", 20)
	println("Person初始化内容信息为：name = ${person2.Cname}; age = ${person2.Cage}")

	var person3: Person = Person("zhangsan", 20, "个人信息")
	println("Person初始化内容信息为：name = ${person3.Cname}; age = ${person3.Cage}; info = ${person3.Cinfo}")
}

  5. 类参数的默认值和调用顺序

    优先调用主构造函数,其次再为次构造函数

    主构造是在init代码块中,次构造是在contructor中进行

3.2 init代码块

  • 相当于java中的代码块{} ,但不是静态代码块{}

    class Person(name: String, password: String) {
	init {
		println("主构造函数调用")
		require(name.isNotBlank()) { "参数为空" }
	}

	constructor(name: String, password: String, info: String) : this(name, password) {
		println("次构造函数参数为：name=${name};password:${password};info=${info}")
	}
}

fun main(args: Array<String>) {
	var person: Person = Person("zhangsan", "123456", "个人")
}

3.3 懒加载: lateinit

  • 用法: 在属性上进行的操作,通过关键字lateinit实现变量的懒加载.通过 ::变量名.isInitialized 获取变量名是否已经初始化

    fun main() {
	var b: Base = Base()
	b.initInfo()
	//需要先加载属性，才能进行使用
	b.showInfo()
}

class Base {
	//延迟初始化，用到的时候在进行加载数据
	lateinit var info: String

	fun initInfo() {
		info = "成功"
	}

	fun showInfo() {
		if (::info.isInitialized) {
			println(info)
		} else {
			println("忘记加载内容")
		}
	}
}

3.4 惰性加载: by lazy

  • 用法: 作用在变量名上,需要实现by lazy中的方法

    fun main() {

	//var b: Base = Base()
	//Thread.sleep(5000)
	//println(b.database)

	var b: Base = Base()
	Thread.sleep(5000)
	println(b.database2)
}

class Base {
	//val database: String = readSqlDataBase()

	val database2 by lazy { readSqlDataBase() }

	fun readSqlDataBase(): String {
		println(1)
		println(2)
		println(2)
		println(2)
		println(2)
		println(2)
		println(2)
		println(2)
		println(1)
		return "Mysql"
	}
}

3.5 类的继承与重写

  • 继承: 通过 : 完成父到子的继承

  • 重写: 方法名相同,存在于继承之间

    fun main() {
	var b: Base = Child("zhangsan")
	b.basePrintln()
}

// kotlin所有的类和函数都是final属性的，如果需要可继承，则需要加入open关键字
open class Base(private val name: String) {
	private fun showName(): String {
		return "父类：姓名是：${name}"
	}

	open fun basePrintln() = println(showName())
}

class Child(private val subname: String) : Base(subname) {

	private fun showName(): String {
		return "子类：姓名是：${subname}"
	}

	override fun basePrintln() = println(showName())
}

3.6 类的类型转化

  • 存在父类和子类之间的转化,调用父类或者子类的方法

    import java.io.File

fun main() {

	var b: Base = Child("zhangsan")
	b.basePrintln()

	println(b is Base)
	println(b is Child)
	println(b is File)

	//is+as进行转换

	if (b is Child) {
		(b as Child).basePrintln()
	}

	if (b is Base) {
		println((b as Base).test())
	}
}

// kotlin所有的类和函数都是final属性的，如果需要可继承，则需要加入open关键字
open class Base(private val name: String) {
	private fun showName(): String {
		return "父类：姓名是：${name}"
	}

	open fun basePrintln() = println(showName())

	fun test(): String {
		return "父类：姓名是：${name}"
	}
}

class Child(private val subname: String) : Base(subname) {

	private fun showName(): String {
		return "子类：姓名是：${subname}"
	}

	override fun basePrintln() = println(showName())
}

  • 在调用的过程中,如果之前有进行as转化,那之后在使用时,就是as转化后的对象

    import java.io.File

fun main() {

	var b: Base = Child("zhangsan")
	b.basePrintln()

	//智能声明类型，已确定后续使用子类的方法
	(b as Child).childPrintln()

	b.childPrintln()

}

// kotlin所有的类和函数都是final属性的，如果需要可继承，则需要加入open关键字
open class Base(private val name: String) {
	private fun showName(): String {
		return "父类：姓名是：${name}"
	}

	open fun basePrintln() = println(showName())

}

class Child(private val subname: String) : Base(subname) {

	private fun showName(): String {
		return "子类：姓名是：${subname}"
	}

	fun childPrintln() = println(showName())
}

3.7 Any超类

  • 任何类的父类,提供了规范接口定义

    fun main() {
	//Any类的toString只提供标准，不提供实现
	println(obj().toString())
}

//每个类都默认继承了Any类
class obj : Any() {

}

3.8 类的单例对象: object

  • 作用: 在类上的声明,使得类成为为单例模式

    fun main() {
	println(Base)
	println(Base)
	println(Base)
	println(Base)
	println(Base)

	println(Base.show())
}

//单例的实例，也是类名，只有一个被创建
object Base {
	init {
		print("Base create")
	}

	fun show(): Unit {
		println("show函数")
	}
}

3.9 对象表达式

  • 在继承接口时,只能使用唯一的一种方式进行创建对象 object:类型{实现方法}

    fun main() {

	var it: Base = object : Base() {
		override fun add(info: String) {
			//super.add(info)
			println("匿名对象add：${info}")
		}

		override fun del(info: String) {
			//super.del(info)
			println("匿名对象del：${info}")
		}
	}

	it.add("1234")
	it.del("12345")

	// 具名方式
	var it2: Child = Child()
	it2.add("1234")
	it2.del("12345")

	// java的Runable实现
	var p3: Runnable = object : Runnable {
		override fun run() {
			//TODO("Not yet implemented")
			println("Runable...")
		}
	}
	p3.run()

	var p4 = Runnable {
		println("run..")
	}
	p4.run()

	//KT接口只有一种对象表达式，没有简洁的写法，对象表达式object:类型{实现方法}
	object : RunableKT {
		override fun run() {
			//TODO("Not yet implemented")
			println("1111run")
		}
	}.run()
}

open class Base {
	open fun add(info: String) = println("add: ${info}")
	open fun del(info: String) = println("del: ${info}")
}

class Child : Base() {
	override fun add(info: String) {
		//super.add(info)
		println("具名对象add：${info}")
	}

	override fun del(info: String) {
		//super.del(info)
		println("具名对象add：${info}")
	}
}

interface RunableKT {
	fun run()
}

3.10 伴生对象: companion

  • 只会创建一次,类似于Java中的static静态块

    fun main() {
	println(Base.info)
	Base.showInfo()
}

//因为kotlin中没有java的那种static静态，所以产生了compannon伴生对象
//无论创建多少次companion只创建一次
class Base {
	companion object {
		const val info: String = "demo"
		fun showInfo(): Unit = println("info: $info")
	}
}

3.11 内部类和嵌套类

  • 默认情况下是嵌套类,类的内部的类含有inner关键字才能内部类

  • 内部类可以访问外部的属性,嵌套类不能访问外部属性

    fun main() {

	Body("isOk").Heart().run()
	Body("isOk").Hand().Left().run()

	Outer.Net().showInfo("info")
}

//外部和内部类
class Body(_bodyInfo: String) {
	val bodyInfo: String = _bodyInfo

	fun show() {
		Heart().run()
	}

	// inner 使得内部类可以访问外部类，外部类可以直接访问内部的类
	inner class Heart {
		fun run(): Unit = println("心跳运行：${bodyInfo}")
	}

	inner class Hand {
		inner class Left {
			fun run(): Unit = println("左手：${bodyInfo}")
		}
	}
}

//默认情况下就是嵌套类,除非是由外部类传递到内部类
class Outer {
	val info: String = "ok"

	fun show() {
		Net().showInfo(info)
	}

	class Net {
		fun showInfo(info: String): Unit = println(info)
	}
}

3.12 普通类和数据类

  • 普通类: 具有get和set、构造函数

  • 数据类: 除了普通类具有的get、set和构造函数外,还提供了解构、克隆、toString、HashCode、equals方法

    fun main() {

	println(ResponseBean(200, "ok", "成功"))

	println(ResponsedataBean(200, "ok", "成功"))

	//默认继承的Any父类equals时，是一种对象比较
	println(ResponseBean(200, "ok", "成功") == ResponseBean(200, "ok", "成功"))
	//数据类重写了equals，所以是在对值的比较
	println(ResponsedataBean(200, "ok", "成功") == ResponsedataBean(200, "ok", "成功"))
}

//普通类：具有set和get、构造函数
class ResponseBean(var code: Int, var msg: String, var data: Any) {

}

//数据类：除了set和get、构造函数外，还提供解构、克隆、toString、HashCode、equals方法
//服务器相应，javaBean，实体可以使用，主要就是数据存储载入，便于打印
//至少又一个参数的构造参数，且必须指明参数的类型 val 或 var
//数据类不能使用 abstract，open，sealed，inner
//比较，copy，toString，解构等
data class ResponsedataBean(var code: Int, var msg: String, var data: Any) {

}

3.13 类的复制函数: Copy

  • 类的复制函数,只复制了类的主构造方法,不管类的次构造方法

    fun main() {

	var bo: BaseObject = BaseObject("zhangsan")
	println(bo)

	// copy、toString、hashCode只看主构造的参数信息，不管次构造的参数信息
	var copybo: BaseObject = bo.copy(name = "wangwu")
	println(copybo)
}

data class BaseObject(var name: String, var age: Int) {
	var coreMsg: String = ""

	init {
		println("主构造被调用")
	}

	constructor(name: String) : this(name, 99) {
		println("此构造被调用")
		coreMsg = "核心信息"
	}

	override fun toString(): String {
		//return super.toString()
		return "toString: name: ${name};age: ${age};coreMsg: $coreMsg"
	}
}

3.14 数据类的解构

  • 在普通类中也可以实现解构造,需要运算符重载

    fun main() {
	val (name, age, sex) = CommClass("zhangsan", 14, '男')
	println("普通类：name: ${name};age:${age};sex:${sex}.")

	val (name2, age2, sex2) = CommDataClass("zhangsan", 14, '男')
	println("数据类：name: ${name2};age:${age2};sex:${sex2}.")

	val (name3, _, sex3) = CommDataClass("zhangsan", 14, '男')
	println("数据类：name: ${name3};sex:${sex3}.")
}

class CommClass(var name: String, var age: Int, var sex: Char) {
	//解构需要运算符重载关键字 operator
	operator fun component1() = name
	operator fun component2() = age
	operator fun component3() = sex
}

data class CommDataClass(var name: String, var age: Int, var sex: Char) {

}

3.15 运算符重载: operator

  • 通过重写对应的方法,以实现对应所需要的功能

    fun main() {
	println(Add(1, 2) + Add(2, 3))
}

class Add(var num1: Int, var num2: Int) {
	operator fun plus(add: Add): Int {
		return num1 + add.num1 + num2 + add.num2
	}

	//operator fun Add.   查看整个运算符重载的方式
}

3.16 枚举类: enum

  • 简单声明使用

    fun main() {
	println(Week.星期一)
	println(Week.星期六)
	//枚举的值等于枚举本身
	println(Week.星期三 is Week)
}

// 枚举也是一个class
enum class Week {
	星期一,
	星期二,
	星期三,
	星期四,
	星期五,
	星期六,
	星期日
}

  • 枚举类定义函数

    fun main() {

	//调用显示
	println(BodyPart.LEFT_HAND.show())
	println(BodyPart.RIGHT_HAND.show())
	println(BodyPart.LEFT_FOOT.show())
	println(BodyPart.RIGHT_FOOT.show())

	//更新数据
	BodyPart.LEFT_HAND.update(BodyInfo("left_hand", 32))
}

//枚举的主构造参数必须和枚举的参数保持一致
enum class BodyPart(private val bodyInfo: BodyInfo) {
	LEFT_HAND(BodyInfo("LEFT_HAND", 12)),
	RIGHT_HAND(BodyInfo("RIGHT_HAND", 12)),

	LEFT_FOOT(BodyInfo("LEFT_FOOT", 12)),
	RIGHT_FOOT(BodyInfo("RIGHT_FOOT", 12)),
	//结束枚举的值
	;

	fun show(): String = "四肢的信息是:${bodyInfo.flag},长度为:${bodyInfo.length}"
	fun update(newBodyInfo: BodyInfo): Unit {
		println("更新前Emnu数据,${this.bodyInfo.show()}")
		this.bodyInfo.flag = newBodyInfo.flag
		this.bodyInfo.length = newBodyInfo.length
		println("重新定义Emnu数据成功,${this.bodyInfo.show()}")
	}
}

class BodyInfo(var flag: String, var length: Int) {
	fun show(): String {
		return "${flag}的长度为：${length}"
	}
}

  • 代数数据类型

    fun main() {
	println(Teacher(Exam.GRAD4).show())
}

enum class Exam {
	GRAD1,
	GRAD2,
	GRAD3,
	GRAD4,
	;
}

class Teacher(private val exam: Exam) {
	fun show(): String =
		//枚举属于代数数据类型，所以不需要else
		when (exam) {
			Exam.GRAD1 -> "分数低"
			Exam.GRAD2 -> "分数中下"
			Exam.GRAD3 -> "分数中上"
			Exam.GRAD4 -> "分数高"
		}
}

3.17 密封类: sealed

  • 枚举类的一种特殊情况

    fun main() {

    println(Teacher(Exam.GRAD4("zhangsan")).show())

    //声明object是单例模式
    println(Exam.GRAD1 == Exam.GRAD1)
    //class不是单例模式的
    println(Exam.GRAD4("aaa") == Exam.GRAD4("aaa"))
}

sealed class Exam {
    object GRAD1 : Exam()

    object GRAD2 : Exam()

    object GRAD3 : Exam()

    //object GRAD4 : Exam()

    //var name: String? = null

    class GRAD4(val name: String) : Exam()
}

class Teacher(private val exam: Exam) {
    fun show(): String =
        //枚举属于代数数据类型，所以不需要else
        when (exam) {
            is Exam.GRAD1 -> "分数低"
            is Exam.GRAD2 -> "分数中下"
            is Exam.GRAD3 -> "分数中上"
            is Exam.GRAD4 -> "分数高,该学生的姓名是：${(this.exam as Exam.GRAD4).name}"
        }
}

3.18 接口: interface

  • 接口本身不能含有主构造;继承的接口不仅需要重写接口函数,也需要重写接口的成员;实现接口的部分全部要加入override关键字

    fun main() {

	val usb1: IUSB = Mouse()
	println(usb1.insertUSB())

	val usb2: IUSB = KeyBoard()
	println(usb2.insertUSB())

}

//接口本身都是public open，接口不能含有主构造
//接口不仅仅要重写接口的函数，也要重写接口的成员
//接口实现的部分全部要加入override关键字
interface IUSB {
	var usbVersion: String
	var usbInsertDriver: String

	fun insertUSB(): String
}

class Mouse(override var usbVersion: String = "3.2", override var usbInsertDriver: String = "鼠标") : IUSB {
	override fun insertUSB(): String {
		//TODO("Not yet implemented")
		return "设备为：${usbInsertDriver},设备版本为：${usbVersion}"
	}
}

class KeyBoard : IUSB {
	override var usbVersion: String = "3.2"
		get() = field//TODO("Not yet implemented")
		set(value) {
			field = value ?: "该字段为空"
		}
	override var usbInsertDriver: String = "键盘"
		get() = field//TODO("Not yet implemented")
		set(value) {
			field = value ?: "该字段为空"
		}

	override fun insertUSB(): String {
		//TODO("Not yet implemented")
		return "设备为：${usbInsertDriver},设备版本为：${usbVersion}"
	}
}

  • 接口默认实现

    fun main() {

	val usb1: USB2 = Mouse2()
	println(usb1.insertUSB())

	val usb2: USB2 = KeyBoard2()
	println(usb2.insertUSB())

	val usb3: USB2 = Mouse3()
	println(usb3.insertUSB())
}

//接口不能给成员赋值
//任何类 接口等等 val代表只读，是没有在其后动态赋值
interface USB2 {
	val usbVersion: String
		get() = (1..100).shuffled().last().toString()

	val usbInsertDriver: String
		get() = "usb设备接入"

	fun insertUSB(): String
}

class Mouse3() : USB2 {
	override val usbVersion: String
		get() = super.usbVersion
	override val usbInsertDriver: String
		get() = super.usbInsertDriver

	override fun insertUSB(): String {
		//TODO("Not yet implemented")
		return "设备为：${usbInsertDriver},设备版本为：${usbVersion}"
	}
}

class Mouse2(override var usbVersion: String = "3.2", override var usbInsertDriver: String = "鼠标") : USB2 {
	override fun insertUSB(): String {
		//TODO("Not yet implemented")
		return "设备为：${usbInsertDriver},设备版本为：${usbVersion}"
	}
}

class KeyBoard2 : USB2 {
	override var usbVersion: String = "3.2"
		get() = field//TODO("Not yet implemented")
		set(value) {
			field = value ?: "该字段为空"
		}
	override var usbInsertDriver: String = "键盘"
		get() = field//TODO("Not yet implemented")
		set(value) {
			field = value ?: "该字段为空"
		}

	override fun insertUSB(): String {
		//TODO("Not yet implemented")
		return "设备为：${usbInsertDriver},设备版本为：${usbVersion}"
	}
}

3.19 抽象类: abstract

  • 可以有一些抽象方法,也可以有一些具体实现

    fun main() {
	MainActivity().show()
}

abstract class BaseActivity {
	fun onCreate() {
		setContentView(getLayoutID())
		initView()
		initData()
		initOthers()
	}

	private fun setContentView(laoutID: Int) = println("加载${laoutID}")
	abstract fun getLayoutID(): Int
	abstract fun initView()
	abstract fun initData()
	abstract fun initOthers()
}

class MainActivity : BaseActivity() {
	override fun getLayoutID(): Int {
		//TODO("Not yet implemented")
		return 562
	}

	override fun initView() {
		//TODO("Not yet implemented")
		println("View 初始化")
	}

	override fun initData() {
		//TODO("Not yet implemented")
		println("data 初始化")
	}

	override fun initOthers() {
		//TODO("Not yet implemented")
		println("Ohters 初始化")
	}

	fun show() {
		super.onCreate()
	}

}

3.20 泛型

  • 普通泛型

    fun main() {
	var s: Student = Student(name = "zhangsan", age = 19, sex = '男')
	BaseF(s).show()

	var t: Teacher = Teacher(name = "wangwu", age = 29, sex = '男')
	BaseF(t).show()

	BaseF(String(("留意").toByteArray()))
}

class BaseF<T>(private val obj: T) {
	fun show() = println("输出对象：${obj}")
}

data class Student(val name: String, val age: Int, val sex: Char)
data class Teacher(val name: String, val age: Int, val sex: Char)

  • 泛型函数

    fun main() {
	var s: Student = Student(name = "zhangsan", age = 19, sex = '男')
	println(BaseF(true, s).getObj())

	var t: Teacher = Teacher(name = "wangwu", age = 29, sex = '男')
	println(BaseF(true, t).getObj())

	println(BaseF(false, t).getObj() ?: "返回了null呀")

	BaseF(true, s).getObj()?.run {
		println("对象为：${this}")
	} ?: "返回了null呀"

	var temp: Student? = BaseF(true, s).getObj()?.apply {
		if (this != null) {
			println("对象为：${this}")
		} else {
			println("返回了null呀")
		}
	}

	show("String")

	show2(null)
}

class BaseF<T>(private val isShow: Boolean = false, private val obj: T) {
	fun getObj() = obj.takeIf { isShow }
}

data class Student(val name: String, val age: Int, val sex: Char)
data class Teacher(val name: String, val age: Int, val sex: Char)


fun <B> show(item: B) {
	var result = item?.also {
		println("打印：${item}")
	} ?: println("返回了null呀")
}

fun <T> show2(item: T) {
	var r = item?.also {
		if (item == null) {
			println("null")
		} else {
			println("打印：${item}")
		}
	} ?: "返回了null呀"
}

  • 泛型变换

    fun main() {
	var p1 = BaseF2(isMap = true, 321421)
	var r = p1.map {
		it.toString()
	}
	println(r is String?)
	println(r)

	var r1: String? = map(inputValue = 12345) {
		it.toString()
	}
	println(r1)
}

class BaseF2<T>(private val isMap: Boolean = false, val inputType: T) {

	fun <R> map(mapAction: (T) -> R): R? = mapAction(inputType).takeIf {
		isMap
	}
}


inline fun <I, O> map(isChange: Boolean = true, inputValue: I, mapAction: (I) -> O): O? {
	return if (isChange) mapAction(inputValue) else null
}

  • 泛型类型的约束

    fun main() {

	val my = MyClass("1234")
	val person = PersonClass("1234")
	val student = StudentClass("1234")
	val teacher = TeacherClass("1234")
	val dog = DogClass("1234")

	val r1 = PrintF(inputTypeValue = student).getObj();
	println(r1)
}

open class MyClass(name: String)

open class PersonClass(name: String) : MyClass(name)

class StudentClass(name: String) : PersonClass(name)

class TeacherClass(name: String) : PersonClass(name)

class DogClass(name: String)

// <T : 类型>，类型的以及类型的子类可以使用
class PrintF<T : PersonClass>(private val isChange: Boolean = true, val inputTypeValue: T) {
	fun getObj() = inputTypeValue.takeIf { isChange }
}

3.21 动态关键字: vararg

  • 声明的该属性可接收多个值

    fun main() {

	// 类型： Baseargs<{Comparable<*> & java.io.Serializable}>
	var p: Baseargs<Any?> = Baseargs(ischange = true, true, "1234", 213.4)

	println(p.showObject(0))

	println(p.showObject(2).toString() is String)

	var r: String = p.mapObj(1) {
		it as String
	}
	println(r)
}

class Baseargs<T>(var ischange: Boolean, vararg objects: T) {
	//out 指我们的T只能被读取，不能进行修改
	val objectArray: Array<out T> = objects

	fun showObject(): Array<out T> {
		return objectArray
	}

	fun showObject(index: Int): T {
		return objectArray[index]
	}

	fun <O> mapObj(index: Int, mapAction: (T?) -> O): O {
		return mapAction(objectArray[index].takeIf { ischange })
	}
}

3.22 自定义操作符: []

  • 重写操作符: []

    fun main() {
	inputObj("demo")
	inputObj(null)

	var i: BaseClss<String?> = BaseClss(isChange = true, "zhangsan", "lisi", "wangwu")
	println(i.get(0))
	println(i.get(2))
}


class BaseClss<INPUT>(val isChange: Boolean, vararg objects: INPUT) {
	//out标识objectArray只能进行读取，不能进行修改
	val objectArray: Array<out INPUT> = objects

	fun getObj(): Array<out INPUT> = objectArray

	fun getObj2(): Any = objectArray.takeIf { isChange } ?: "null值"

	fun getObj3(): Any? = objectArray.takeIf { isChange } ?: "null值" ?: null

	fun getObj4(index: Int): INPUT? = objectArray[index].takeIf { isChange } ?: null

	fun getObj5(index: Int): Any? = objectArray[index].takeIf { isChange } ?: "AAA" ?: null

	operator fun get(index: Int): INPUT? = objectArray[index].takeIf { isChange }
}

fun <INPUT> inputObj(item: INPUT) {
	println((item as String?)?.length ?: "传递的是null")
}

3.23 out协变

  • 父 -> 子

    fun main() {

	var p1: Producer<Animal> = Produce1()
	//类型也可以为Animal，因为有out关键字，泛型的子类对象也可以赋值给父类对象，默认情况下不可以
	//相当于java中的 ? extends 例如：List<? extends CharSequence> list2=new ArrayList<String>();
	var p2: Producer<Animal> = Produce2()
	var p3: Producer<Animal> = Produce3()
	var p4: Producer<Animal> = Produce4()
	
}

//out T 协变
interface Producer<out T> {
	// 这里的T只能读取，不能修改，放在参数里，可能会产生修改
	//fun consumer(item:T){}

	fun Produce(): T
}

//in T 逆变
interface Consumer<in T> {

	fun Consume(item: T)

	//不能进行读取，只能修改
	//fun Produce():T
}

interface ProducerAndConsumer<T> {
	fun Produce(): T

	fun Consume(item: T)
}


open class Animal
open class Humanity : Animal()
open class Man : Humanity()
open class Woman : Humanity()


class Produce1 : Producer<Animal> {
	override fun Produce(): Animal {
		//TODO("Not yet implemented"
		println("Animal Produce")
		return Animal()
	}
}

class Produce2 : Producer<Humanity> {
	override fun Produce(): Humanity {
		//TODO("Not yet implemented"
		println("Humanity Produce")
		return Humanity()
	}
}

class Produce3 : Producer<Man> {
	override fun Produce(): Man {
		//TODO("Not yet implemented"
		println("Man Produce")
		return Man()
	}
}

class Produce4 : Producer<Woman> {
	override fun Produce(): Woman {
		//TODO("Not yet implemented"
		println("Woman Produce")
		return Woman()
	}
}

3.24 in 逆变

  • 子 -> 父

    // out 协变：只读 父类 = 子类
// in 逆变：只写 子类 = 父类
fun main() {

	var p1: Producer<Animal> = Produce1()
	//类型也可以为Animal，因为有out关键字，泛型的子类对象也可以赋值给父类对象，默认情况下不可以
	//相当于java中的 ? extends 例如：List<? extends CharSequence> list2=new ArrayList<String>();
	var p2: Producer<Animal> = Produce2()
	var p3: Producer<Animal> = Produce3()
	var p4: Producer<Animal> = Produce4()

	//因为有in关键字，泛型的子类对象也可以接收父类的对象，默认情况下是不可以
	//相当于java中的 ? super 例如：List<? extends String> list2=new ArrayList<CharSequence>();
	val c1: Consumer<Man> = Consume1()
}

//out T 协变
interface Producer<out T> {
	// 这里的T只能读取，不能修改，放在参数里，可能会产生修改
	//fun consumer(item:T){}

	fun Produce(): T
}

//in T 逆变
interface Consumer<in T> {

	fun Consume(item: T)

	//不能进行读取，只能修改
	//fun Produce():T
}

interface ProducerAndConsumer<T> {
	fun Produce(): T

	fun Consume(item: T)
}


open class Animal
open class Humanity : Animal()
open class Man : Humanity()
open class Woman : Humanity()


class Produce1 : Producer<Animal> {
	override fun Produce(): Animal {
		//TODO("Not yet implemented"
		println("Animal Produce")
		return Animal()
	}
}

class Produce2 : Producer<Humanity> {
	override fun Produce(): Humanity {
		//TODO("Not yet implemented"
		println("Humanity Produce")
		return Humanity()
	}
}

class Produce3 : Producer<Man> {
	override fun Produce(): Man {
		//TODO("Not yet implemented"
		println("Man Produce")
		return Man()
	}
}

class Produce4 : Producer<Woman> {
	override fun Produce(): Woman {
		//TODO("Not yet implemented"
		println("Woman Produce")
		return Woman()
	}
}


class Consume1 : Consumer<Animal> {
	override fun Consume(item: Animal) {
		//TODO("Not yet implemented")
		println("Animal Consume")
	}
}

class Consume2 : Consumer<Humanity> {
	override fun Consume(item: Humanity) {
		//TODO("Not yet implemented")
		println("Humanity Consume")
	}
}

class Consume3 : Consumer<Man> {
	override fun Consume(item: Man) {
		//TODO("Not yet implemented")
		println("Man Consume")
	}
}

class Consume4 : Consumer<Woman> {
	override fun Consume(item: Woman) {
		//TODO("Not yet implemented")
		println("Woman Consume")
	}
}

3.25 out和in的用法

fun main() {
    val p1: SetClass<String> = SetClass<String>();
    p1.set1("1234213")

    val o1: GetClass<String> = GetClass<String>("param");
    println(o1.get1())
}

// in T 或者 out T 声明处泛型 ，java不支持
//所有的成员 泛型相关只能修改更改，不能读取
class SetClass<in T>() {

    fun set1(item: T) {
        println("设置的item为：${item}")
    }
}

//所有的成员 泛型相关只能读取，不能更改
class GetClass<out T>(_item: T) {

    val item: T = _item

    fun get1(): T? {
        return item
    }
}

3.26 reified关键字

fun main() {

    //匿名方式
    var r = AllFun().randomOrDefault<ObjectClass1> {
        ObjectClass1("wangwu", 20)
    }
    println(r)

    //具名方式
    var r1: ObjectClass1? = AllFun().randomOrDefault<ObjectClass1>(::defaultAction)
    println(r1)
}

data class ObjectClass1(val name: String, val age: Int)
data class ObjectClass2(val name: String, val age: Int)
data class ObjectClass3(val name: String, val age: Int)

fun <T> defaultAction(): T {
    return ObjectClass1("wangwu", 20) as T
}

class AllFun {

    inline fun <reified T> randomOrDefault(defaultLambdaAction: () -> T): T? {
        var objLists: List<Any> = listOf<Any>(
            ObjectClass1("wangwu", 12),
            ObjectClass2("zangsan", 12),
            ObjectClass3("lsii", 12)
        )

        val randomObj: Any? = objLists.shuffled().first()
        println("随机产生的对象为：${randomObj}")

        //return randomObj.takeIf { it is T } as T ?: null
        return randomObj.takeIf { it is T } as T? ?: defaultLambdaAction()
    }
}

3.27 扩展函数

  • 基本扩展

    fun main() {
	val baseClass: BaseClass = BaseClass("zhangsan", 18, '男')
	baseClass.show()

	println("Demo".addExtAction(3))
}

class BaseClass(val name: String, val age: Int, val sex: Char)

//每个扩展类函数中都含有一个this，this代表类的本身
fun BaseClass.show() {
	println("name:${this.name},age:${age},sex:${sex}")
}

fun BaseClass.getAge(): Int = this.age

fun String.addExtAction(num: Int) = this + "@".repeat(num)

  • 超类扩展

    fun main() {
	ResponseResult(200, "ok", "成功").showPrintlnContent()
	"提示信息".showPrintlnContent()

	"提示信息".showPrintlnContent2().showPrintlnContent2()
}

//扩展函数不允许重复定义
fun Any.showPrintlnContent() = println("当前的对象是：${this}")

//链式调用
fun Any.showPrintlnContent2(): Any {
	println("当前的对象为：${this}")
	return this
}

data class ResponseResult(val code: Int, val status: String, val msg: String)

  • 泛型扩展

    fun main() {
	//所有的类型都是泛型，所以所有的类均可以调用showContentInfo函数
	123.showContentInfo()
	"1234".showContentInfo()
	contentFun().showContentInfo()
}

fun <T> T.showContentInfo() {
	println("${if (this is String) "字符长度为：${this.length}" else "内容为：${this}"} ")
}

fun contentFun() {

}

  • apply内置函数扩展

    fun main() {
	"Demo".myLet {
		true
	}

	"demo".let {
		true
	}
}

private inline fun <I, O> I.myLet(lambda: (I) -> O): O = lambda(this)

  • 扩展属性

    fun main() {
	var str: String = "abc"
	str.getInfo().getInfo()

	str.myinfo.getInfo()
}

val String.myinfo: String
	get() = "demo"

fun String.getInfo(): String {
	println("当前内容是：${this}")
	return this
}

  • 可用类型的应用

    fun main() {
	var info: String? = null
	info.outPutStringValueFun("默认值")
}

//String?可以接收可空数据，也可以接收有值数据
fun String?.outPutStringValueFun(defaultValue: String): Unit {
	println(this ?: defaultValue)
}

fun String?.outPutStringValueFun2(defaultValue: String): String {
	return this ?: defaultValue
}

3.28 中缀表达式

fun main() {
    mapOf("0".to(12))
    mapOf("1".to(23120))

    "demo".goto(1234)

    "demo" goto 12341
}

//中缀表达式 + 扩展函数
//条件：对一个对象需要进行函数扩展，另一个对象需要传递在参数内
private infix fun <C1, C2> C1.goto(c2: C2) {
    println("参数1：${this}")
    println("参数2：${c2}")
}

3.29 扩展文件

fun main() {
    val list: List<String> = listOf("12", "23124", "312412")
    val set: Set<Int> = setOf(1, 2, 3, 5, 9)

    println(list.shuffled().first())
    println(set.shuffled().first())

    println(list.randomItemValue())
    set.randomItemValuePrintln()
}

//扩展文件一般都是public，重写父类主要是为了子类可以使用
fun <E> Iterable<E>.randomItemValue(): E {
    return this.shuffled().first()
}

fun <T> Iterable<T>.randomItemValuePrintln() = println(this.shuffled().first())

3.30 重命名 as

主要用法:import 方法名 as 别名

3.31 apply解析扩展

  • 一般扩展

    fun main() {
	"str".mApply {
		println(this.length)
	}.mApply {
		println(this is String)
	}
}

//private 私有化
//inline 函数属于高阶函数，使用内联对lambda进行优化处理提高新能
//fun<INPUT> 函数中声明一个泛型
//INPUT.mApply 让所有类型都可以进行调用，泛型扩展
// INPUT.()->Unit 让我们的匿名函数中持有this，在lambda里面返回类型为空
// 调用lambda(this) 默认就含有this
//返回this的目的主要是用链式调用
private inline fun <INPUT> INPUT.mApply(lambda: INPUT.() -> Unit): INPUT {
	lambda()
	return this
}

  • let和apply总结

    //1. let 返回类型是根据匿名函数的变化而变化（lambda的返回类型变化而变化）
//2。 匿名函数李曼持有的是 it对象
inline fun <I, O> I.mLet(lambda: (I) -> O): O = lambda(this)

//1. apply返回类型永远都是I，lambda的返回类型与apply返回类型并无关联
//2. 匿名函数里面持有的是 this对象
inline fun <I> I.mApply(lambda: I.() -> Unit): I {
	lambda()
	return this
}

3.32 DSL

//DSL(Domain Specified Language)，领域专用语言
//定义输入和输出规则；
//定义使用的对象
fun main() {
    val context: Context = Context().apply1 {
        toast("success")
        toast(it)
    }
    println(context)
}

class Context {
    val info = "demo"

    fun toast(str: String): Unit {
        println("Toast: $str")
    }
}

fun Context.apply1(lambda: Context.(String) -> Unit): Context {
    lambda(this.info)
    return this
}

3.33 函数变换

  • map的函数变换

    fun main() {
	val list: List<String> = listOf("123", "1234", "12", "1")

	//通过匿名函数的最后一行返回值加入新的集合，并返回新的集合
	val list1: List<String> = list.map {
		println(it)
		"{$it}"
	}
	println(list1)

	list.map {
		"字符串是：$it"
	}.map {
		"$it,文字的长度是：${it.length}"
	}.map {
		"[$it]"
	}.map {
		println(it)
	}
}

  • flatmap的函数变换

    fun main() {
	val list: List<String> = listOf("zhangsan", "lisi", "wangwu")

	//map 返回每一个元素的加入到新的集合 List<String>
	//flatmap 返回每一个集合加入到新的集合 List<List<String>>
	val newlist: List<String> = list.map {
		"你的姓名是：$it"
	}.map {
		"$it,文字的长度是：${it.length}"
	}.flatMap {
		listOf("$it 在1", "$it 在2")
	}

	println(newlist)

	val list2: List<String> = list.flatMap {
		listOf("$it 在1", "$it 在2")
	}
	println(list2)
}

3.34 filter函数过滤

fun main() {
    val names: List<List<String>> = listOf(
        listOf("zhangsan", "wangwu", "zhaoliu"),
        listOf("lisi", "wanger", "wuli")
    )

    names.map {
        println(it)
    }

    names.flatMap {
        println(it)
        listOf("")
    }

    //返回的对象为String
    names.flatMap { it ->
        //filter：如果为true 加入到新的集合中进行组装；否则不加入
        it.filter {
            println("$it,1")
            false
        }
    }.map {
        println(it)
    }

    // 返回的类型为List<String>
    names.map { it ->
        //filter：如果为true 加入到新的集合中进行组装；否则不加入
        it.filter {
            //println("$it,1")
            true
        }
    }.map {
        println(it)
    }


    names.flatMap { it ->
        it.filter {
            it.contains("zhao")
        }
    }.map {
        print("$it   ")
    }
}

3.35 zip合并函数

fun main() {
    val names: List<String> = listOf("zhangsan", "lisi", "wangwu")
    val ages: List<Int> = listOf(19, 29, 31)

    //zip 第一个集合和第二个集合进行合并后，创建新的集合
    var new: List<Pair<String, Int>> = names.zip(ages)
    println(new)
    println(new.toMap())
    println(new.toMutableSet())
    println(new.toMutableList())

    //遍历
    new.forEach() {
        println("第一个：${it.first},第二个：${it.second}")
    }

    //map普通方式
    new.toMap().forEach() { key: String, value: Int ->
        println("第一个：${key},第二个：${value}")
    }
    //map的解构方式
    new.toMap().forEach() { (key: String, value: Int) ->
        println("第一个：${key},第二个：${value}")
    }
}

3.36 函数式编程

3.37. java与kotlin交互

public class DemoCon {
    public String getInfo() {
        return "Demo";
    }

    public String getInfo2() {
        return null;
    }
}

fun main() {

    //交互时不能直接使用，可能会出现异常错误提示
    //println(DemoCon().info.length)
    //println(DemoCon().info2.length)

    //java与kotlin交互式类型都是 :类型!
    val info: String? = DemoCon().info
    val info1: String? = DemoCon().info2
    println(info?.length)
    println(info1?.length)
}

3.38 单例模式的四种方式

// kotlin的饿汉模式加载
object Singleton

//kotlin的懒汉式加载
class Singleton2 {
    companion object {
        private var instance: Singleton2? = null
            get() {
                if (field == null) {
                    field = Singleton2()
                }
                return field
            }
        //fun getInstanceAction(): Singleton2 = instance!!

        //懒汉式处理+安全处理
        @Synchronized
        fun getInstanceAction(): Singleton2 = instance!!
    }

    fun show() {
        println("show")
    }
}


//懒汉式处理+双重安全处理
class Singleton3 {
    companion object {
        val instance: Singleton3 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            Singleton3()
        }
    }

    fun show() {
        println("show")
    }
}


fun main() {
    //Singleton2.getInstanceAction().show()
    Singleton3.instance.show()
}

3.39 kotlin 注解

  1. JvmName

    public class JvmNameJava {
    public static void main(String[] args) {
        //JvmNameAndkotlinKt.getJvmNameJavaInfo("1234");
        JNAK.getJvmNameJavaInfo("1234");
    }
}

    //编译环节修改类名称，使得其他进行调用时更简洁，必须要写在包名外
@file:JvmName("JNAK")

fun main() {

}

fun getJvmNameJavaInfo(str: String) = println(str)

  2. JvmField

    public class JvmFieldAndKotlin {
    public static void main(String[] args) {
        Text test = new Text();
//        for (String item : test.getName()) {
//            System.out.println(item);
//        }
        for (String item : test.name) {
            System.out.println(item);
        }
    }
}

    class Text {
    //将成员的私有化方法去掉，属性变为公开可访问的
    @JvmField
    val name: List<String> = listOf("zhangsan", "lisi")
}

  3. JvmOverloads

    public class JvmOverloadsJava {
    public static void main(String[] args) {
        JvmOverloadsAndKotlinKt.show("1234");
    }
}

    fun main() {
    show(name = "123")
}

//编译阶段会有一个重载函数供其调用
@JvmOverloads
fun show(name: String, age: Int = 20) {
    println("name:${name},age:${age}")
}

  4. JvmStatic

    public class JvmStaticJava {
    public static void main(String[] args) {
        //Test.Companion.getAddress();
        //Test.Companion.show();

        System.out.println(Test.address);
        Test.show();

    }
}

    class Test {
    companion object {
        @JvmField
        val address = "北京"

        @JvmStatic
        fun show() = println("当前的地址为：${address}")
    }
}

fun main() {
    Test.address

    Test.show()
}

3.40 自定义变换操作符

fun main() {
    //create 匿名表达式 只关心用户的输入 输出源是最后一行内容
    //map 输入源就是create输出源 输出源为最后一行内容
    //observer 输入源就是map存储的输出源
    create {
        "demo"
    }.map {
        "你的值是：$this"
    }.map {
        "{{${this}}}"
    }.observer {
        println(this)
    }
}

class RxJavaCoreObjectClass<T>(val value: T) {
}

inline fun <I, O> RxJavaCoreObjectClass<I>.map(mapAction: I.() -> O): RxJavaCoreObjectClass<O> {
    return RxJavaCoreObjectClass(mapAction(value))
}

inline fun <OUTPUT> create(action: () -> OUTPUT): RxJavaCoreObjectClass<OUTPUT> {
    return RxJavaCoreObjectClass<OUTPUT>((action()))
}

inline fun <INPUT> RxJavaCoreObjectClass<INPUT>.observer(observerAction: INPUT.() -> Unit): Unit {
    observerAction(value)
}
0
Kotlin 实战
版权归属： 鹿心肺语
本文链接： https://www.lxfycloud.cn/archives/b5934b50-745c-4a22-ab1b-9caff4dcae02
许可协议： 本文使用《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》协议授权

评论区