kotlin学习记录

13.rang

if (number in 10..59)

14.when

val info = when (week) {

1 -> "今天是星期一，非常忙碌的一天开会"

2 -> "今天是星期二，非常忙碌的一天开会"

3 -> "今天是星期三，非常忙碌的一天开会"

4 -> "今天是星期四，非常忙碌的一天开会"

5 -> "今天是星期五，非常忙碌的一天开会"

6 -> "今天是星期六，非常忙碌的一天开会"// else->"不满足"

else -> { println("不满足") } }

15.String模板

println("今天天气很晴朗，去${garden}玩了$time 小时")

16.函数头默认都是public，先有输入，再有输出

private fun method01(age: Int, name: String): Int

17.Kotlin中函数参数的默认参数

private fun action02(name: String, age: Int=77): Int

18.Kotlin语言的具名参数

loginAction(age = 99, name = "123", phone = "5555", pwd = "234")

19.Kotlin语言的Unit函数特点

private fun doWork(): Unit

20.Kotlin语言的Nothing函数特点

TODO("没有这种")

21.Kotlin语言的反引号中函数名特点

private fun `655566`(){

23.Kotlin语言的匿名函数学习

val len2 = "Derry".count() { //it 等价于 D e r r y字符 it == 'r'}

24.Kotlin语言的函数类型&隐式返回学习

//第一步: 函数输入输出声明

val methodAction: () -> String

//第二步：对上面函数的实现

methodAction = {

val inputValue = 999

" $inputValue Derry"//== return " $inputValue Derry"

//匿名函数不要写return,最后一行就是返回

}

//第三步：调用此函数

println(methodAction())

25.Kotlin语言的函数参数学习

//第一步: 函数输入输出声明第二步：对声明函数的实现

val methodAction: (Int, Int, Int) -> String = { number1, number2, number3 ->

val inputValue = 999

" $inputValue Derry 参数一：$number1，参数二：$number2，参数三：$number3"}

//第三步：调用此函数

println(methodAction(1, 2, 3))

26.Kotlin语言的it关键字特点

//一个入参

val methodAction2: (String) -> String = { "$it Derry" }println(methodAction2("DDD"))

27.Kotlin语言的匿名函数的类型推断 =

val method1 = { v1: Double, v2: Float, v3: Int -> "v1:$v1,v2:$v2,v3:$v3"}

28.Kotlin语言的lambda学习匿名函数 == lambda表达式

//lambda表达式的参数 Int,lambda表达式的结果 Any类型

val weekResultMethod = { number: Int ->

when (number) {

1 -> "星期1"

2 -> "星期2"

3 -> "星期3"

4 -> "星期4"

5 -> "星期5"

6 -> "星期6"

else -> -1

}}//weekResultMethod 函数：（Int ）-> Anyprintln(weekResultMethod(2))

29.在函数中定义参数是函数的函数

//第一种方式

/* loginAPI("Derry", "123456",{ msg: String, code: Int ->

println("最终登录的情况如下：msg:$msg,code:$code") })*/

//第二种方式

/* loginAPI("Derry", "123456", responseResult = { msg: String, code: Int ->

println("最终登录的情况如下：msg:$msg,code:$code") })*/

//第三种方式

loginAPI("Derry", "123456") { msg: String, code: Int ->

println("最终登录的情况如下：msg:$msg,code:$code")}

30.Kotlin语言的简略写法学习

31.Kotlin语言的函数内联学习（inline）函数中有lamda

//此函数使用lambda作为参数，就需要声明成内联//如果此函数，不使用内联，在调用端，会生成多个对象来完成lambda的调用（会造成性能损耗）//如果此函数，使用内联，相当于C++#define 宏定义宏替换会把代码替换到调用处，调用处没有任何函数开辟对象开辟的损耗//小结：如果函数参数有lambda,尽量使用inline关键帧，这样内部会做优化，减少函数开辟对象开辟的损耗//登录API 模仿前端

inline fun loginAPI(username: String, userpwd: String, responseResult: (String, Int) -> Unit) {

if (username == null || userpwd == null) {

TODO("用户名或密码为null")//此处问题，终止程序

} //做很多的校验，前端校验

if (username.length > 3 && userpwd.length > 3) {

if (webServiceLoginAPI(username, userpwd)) { //登录成功

//做很多事情校验成功信息等

//..

responseResult("login success", 200)

} else { //登录失败

//做很多事情登录失败的逻辑处理

//..

responseResult("login error", 444)

} } else {

TODO("用户名和密码不合格")//此处问题，终止程序

}}//此函数没有使用lambda作为参数，就不需要声明成内联

//登录的API暴露者服务器

fun webServiceLoginAPI(name: String, pwd: String): Boolean {

//kt的if是表达式（很灵活）java的if是语句（有局限性）

//做很多事情登录逻辑处理return

if (name == USER_NAME_SAVE_DB && pwd == USER_PWD_SAVE_DB) true else false}

32.Kotlin语言的函数引用学习 ::

//lambda属于函数类型的对象,需要把methodResponseResult普通函数变成函数类型的对象（函数引用）

login("Derry","123456",::methodResponseResult)

val obj=::methodResponseResult

login("Derry","123456",obj)}

fun methodResponseResult(msg:String,code:Int){

println("最终登录的成果是 msg:$msg,code:$code")}

const val USER_NAME_SAVE_DB4 = "Derry"

const val USER_PWD_SAVE_DB4 = "123456"

inline fun login(name:String,pwd:String,responseResult: (String,Int)->Unit){

if (USER_NAME_SAVE_DB4==name&&USER_PWD_SAVE_DB4==pwd){

//登录成功

responseResult("登录成功",200)

}else{

responseResult("登录失败",4444) }}

33.Kotlin语言的函数类型作为返回类型不需要等号

fun main() { val r = show("学习KT语言")

//r是show函数的返回值

val niming_showMethod = showMethod("show")

//niming_showMethod 是showMethod函数的返回值只不过这个返回值是一个函数

//niming_showMethod==匿名函数 println(niming_showMethod("Derry", 333))}

fun show(info: String): Boolean {

println("我是show函数 info :$info") return true}

//showMethod函数再返回一个匿名函数

fun showMethod(info: String): (String, Int) -> String {

println("我是show函数 info :$info")

//return 一个函数匿名函数

return { name: String, age: Int -> "我就是匿名函数，我的name是$name,age:$age" }}

34.Kotlin语言的匿名函数与具名函数

fun main() {

//匿名函数

showPersonInfo("lisi",99,'男',"学习KT语言"){

println("显示结果：$it") }

//具名函数 showPersonInfo

showPersonInfo("wangyu",99,'女',"学习C++语言",::showResultIml)}

fun showResultIml(result:String){

println("显示结果：$result")}

35.Kotlin语言的可空性特点?

//TODO 第一种情况默认是不可空类型，不能随意给null

var name: String = "Derry"

//TODO 第二种情况：声明时指定为可空类型

var name2 :String ?

36.Kotlin语言的安全调用操作符?.

val r = name?.capitalize()//name是可空类型的如果真的是null，? 后面这一段代码不执行，就不会引发空指针异常

37.在Kotlin中使用带let的安全调用?.let

val r = name?.let { //it == name 本身

//如果能够执行到这里面的 it 一定不为null

if (it.isBlank()) {//如果name是空值“”没有内容

"Default"

} else {

"[$it]"

}}

println(r)

38.Kotlin语言中的非空断言操作符特点!!

val r = name!!.capitalize()//!!不管name是不是null 都执行这个和java一样了

39.Kotlin语法中对比使用if判断null值情况 name != null

40.在Kotlin空合并操作符

//空合并操作符 xxx ? :"原来你是null啊" “如果xxx等于null,就会执行？：后面的区域”

println(info ?: "原来你是null")//let函数 + 空合并操作符

println(info?.let { "{$it}" }?:"原来你是null")

41.在Kotlin语法中异常处理与自定义异常特点

fun main() {

try {

var info: String? = null

checkException(info)

println(info!!.length)

} catch (e: Exception) {

e.printStackTrace()

}}

fun checkException(info: String?) {

info ?: throw CustomException()}

class CustomException : IllegalArgumentException("你的代码太不严谨了")

42.在Kotlin语言的先决条件函数

var value: String? = null

val value2: Boolean = false

checkNotNull(value)//java.lang.IllegalStateException: Required value was null.

requireNotNull(value)//java.lang.IllegalArgumentException: Required value was null.

require(value2)//java.lang.IllegalArgumentException: Failed requirement.

43.Kotlin语言的

val indexof = INFO.indexOf('i')

println( INFO.substring(0,indexof))

println( INFO.substring(0 until indexof))//KT基本用这种写法 0 until indexof

44.Kotlin语言的split操作

val jsonText = "Derry,Leo,Lance,Alvin"//list 自动类型推断成

list == List

val list = jsonText.split(",")//直接输出 list 集合不解构

println("分割后的list里面的元素有：$list")//C++ 解构 KT也有解构

val (v1, v2, v3, v4) = list

println("解构四个只读变量的值是：v1:$v1,v2:$v2,v3:$v3,v4:$v4")

45.Kotlin语言的replace完成加密解码操作

val soucePwd = "ABCDEFGHIGKLMNOPQRSTUVWXYZ"

println("原始密码是：$soucePwd")//加密操作 :就是把字符替换成数字打乱了，就属于加密了

val newPwd = soucePwd.replace(Regex("[AKMNO]")) {

it.value//完全没有做任何操作

when (it.value) {//这里的每一个字符 A B C D

"A" -> "9"

"K" -> "3"

"M" -> "5"

"N" -> "1"

"O" -> "4"

else -> it.value//就啥事不做，直接返回字符本身 A B C D }}

println("加密后的密码是：$newPwd")

46.Kotlin语言的==（内容的比较）与===（引用的比较）比较操作

fun main() {

//==值内容的比较相当于Java的equals

//=== 引用的比较

val name1 = "Derry"

val name2 = "Derry"

val name3 = "ww" //小结：name1.equals(name2) 等价于 name1==name2 就是属于值内容的比较

println(name1.equals(name2))//java

println(name1 == name2)//kt

//引用的比较

println(name1 === name2)//true

println(name1 === name3)//false

//引用的比较难度更高一点

val name4 = "derry".capitalize()//修改成"Derry"

println(name1 === name4)//false}

47.Kotlin语言的字符串遍历操作forEach

val str = "ABCDEFGHIMNOPQRSTUVWXYZ"

str.forEach {c->//覆盖默认的it参数名，修改参数名为 c

//it == str 的每一个字符 A B C D ...

// println("所以字符是：$it")

println("所以字符是：$c") }

48.Kotlin语言中数字类型的安全转换函数

val number = "666".toInt()

println(number) //字符串里面放入了Double类型，无法转换成Int,会崩溃

// val number2 :Int="666.6".toInt()

// println(number2) //解决什么崩溃的问题

val number2: Int? = "666.6".toIntOrNull()

println(number2)

val number3: Int? = "666".toIntOrNull()

println(number3)

val number4: Int? = "666.6".toIntOrNull()

println(number4?:"原来你是null啊") //小结：以后字符串有整型相关的转换，尽量用toIntOrNull 此函数

49.Kotlin语言中Double转Int与类型格式化

println(65.4645654.toInt())//65 四舍五入

println(65.4645654.roundToInt())//65 四舍五入

println(65.8343433.roundToInt())//66 四舍五入

//结论：用roundToInt函数，保证Double->转Int 持有四舍五入的效果//r的类型：String

val r = "%.3f".format(65.8343433)//65.834

println(r)

50.Kotlin语言的apply内置函数

始终返回info本身String类型this== info 可以链式调用

//apply内置函数的方式/

/info.apply特点：apply始终返回info本身String类型

val infoNew: String = info.apply {

//一般大部分情况下。匿名函数，都会持有一个it,但是apply函数不会持有it,却会持有当前this == info

println("apply匿名函数里面打印的$this")

println("info字符串的长度是：${length}")

println("info最后一个字符串是：${this[length - 1]}")

println("info全部转成小写是：${toLowerCase()}")}

println("apply返回的值：$infoNew")

//真正使用apply函数的写法规则如下：

//info.apply特点：apply函数始终返回”info本身“所以可以链式调用

info.apply { println("info字符串的长度是：${length}")}

.apply { println("info全部转成小写是：${toLowerCase()}")}

.apply { println("info最后一个字符串是：${this[length - 1]}")}

val file=File("D:\\a.txt")

file.setExecutable(true)

file.setReadable(true)

println(file.readLines())//apply写法//匿名函数里面持有的this == file本身

file.apply {

setExecutable(true)}

.apply { setReadable(true)}

.apply { println(readLines())}

51.Kotlin语言的let内置函数

it ==list集合匿名函数的最后一行，作为返回值

let方式 +空合并操作符对值判null,并返回

//let方式对集合第一个元素相加

val result2 = listOf(6, 5, 2, 3, 5, 7).let { //it ==list集合

it.first() + it.first()//匿名函数的最后一行，作为返回值，let的特点，但前面学的apply永远是返回info本身}

println(result2)

//let方式 +空合并操作符对值判null,并返回简化版本

fun getMethod4(value: String?) =value?.let { "欢迎回来${it}非常欢迎" } ?: "你传递的内容是null"

52.Kotlin语言的run内置函数

/this== str本身 最后一行

//这个属于具名函数

str .run(::isLong)//this == String

.run(::showText)//this == isLong 返回的Boolean值

.run(::mapText)

.run(::println)

Str.let(::isLong)

.let(::showText)

.let(::mapText)

.let(::println)

匿名函数调用给run执行

str.run { if (length > 5) true else false}

.run { if (this) "你的字符串合格" else "你的字符串不合格"}

.run { "{$this}"}

.run { println(this)}

53.Kotlin语言的with内置函数

this == str本身 最后一行

//具名操作

/* with(str){ this == str 本身 }*/

val r1 = with(str, ::getStrLen)

val r2 = with(r1, ::getLenInfo)

val r3 = with(r2, ::getInfoMap)

val r4 = with(r3, ::show)//匿名操作

with( with(with(with(str) { length}) { "你的字符串长度是：$this"}){ "$this"}){ println(this)}

54.Kotlin语言的also内置函数

also函数始终返回”str本身“所以可以链式调用 it

//str.also：also函数始终返回”str本身“所以可以链式调用

val r: String = str.also { println("str的原始数据是：$it")}

.also {

println("str转换大写的效果是${it.toLowerCase()}")}

.also { println("结束了")}

55.Kotlin语言的takeIf内置函数

true返回本身false返回null it

//name.takeIf{true/false}true:返回name本身，false返回null

//takeIf + 空合并操作符

fun checkPermissionAction2(name: String, pwd: String): String? { //true 返回本身 false返回null

return name.takeIf { permissionSystem(name, pwd) }?:"你的权限不够"}

56.Kotlin语言的takeUnless内置函数

false:返回name本身，true返回null it

//name.takeUnless{true/false}false:返回name本身，true返回null

57.Kotlin语言的List创建与元素获取学习

//防止崩溃取值方式： getOrElse getOrNull

println(list.getOrElse(3){"越界"})

//getOrNull + 空合并操作符

println(list.getOrNull(3)?:"你越界了")

58.Kotlin语言的可变List集合学习

val list = mutableListOf/**/("Derry", "Zhangsan", "Wangwu")//可变的集合，可以完成可变的操作

list.add("赵六")list.remove("Wangwu")

println(list)//不可变集合 to 可变集合

val list2 = listOf(123, 456, 789)//不可变的集合，无法完成可变的操作

//list2.add//list2.remove

val list3:MutableList = list2.toMutableList()//可变的集合，可以完成可变的操作

list3.add(111)

list3.remove(123)

println(list3)//可变集合 to 不可变集合

val list4:MutableList = mutableListOf('A','B','C')//可变的集合，可以完成可变的操作

list4.add('C')list4.remove('A')println(list4)

val list5:List =list4.toList()//不可变的集合，无法完成可变的操作

//list5.add

//list5.remove

59.Kotlin语言的mutator函数学习

//1.mutator += -=操作

val list: MutableList = mutableListOf("Derry", "DerryAll", "DerryStr", "Zhangsan")

list += "李四" //mutator 的特性 += -= 其实背后就是运算符重载而已

list += "王五"

list -= "Derry"

println(list)

//2.removeIf

// list.removeIf { true }//如果是true 自动遍历整个可变集合，进行一个元素一个元素的输出

list.removeIf {

it.contains("Derr") }//过滤所以的元素，只要是有Derr的元素，就是true 删除

println(list)

60.Kotlin语言的List集合遍历学习

val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

//第一种，遍历方式

for (i in list) {

print("元素：$i")}//第二种，遍历方式

list.forEach { //it == 每个元素

print("元素：$it")}

list.forEach { s -> //it == 每个元素

print("元素：$s")}//第三种，遍历方式

list.forEachIndexed {

item, index -> print("下标：$index，元素：$index")}

61.Kotlin语言的解构语法过滤元素学习

val list: List = listOf("李元霸", "李小龙", "李连杰")

//1.集合配合解构语法

val (value1, value2, value3) = list

//value = "" val只读的

println("value1:$value1,value2:$value2,value3:$value3")//2.反编译看java给三个变量赋值的代码

var (v1, v2, v3) = list

v1="OK"

println("v1:$v1,v2:$v2,v3:$v3")//3.解构屏蔽接收值

val (_, n2, n3) = list

// println(_) _不是变量名，是用来过滤解构赋值的，不接收赋值给我

println("n2:$n2,n3:$n3")

62.Kotlin语言的Set创建与元素获取

//1.set 定义不允许重复

val set : Set = setOf("lisi","zhaoliu","zhaoliu") //set集合不会出现重复元素的

println(set)

//2.普通方式elementAt 会越界崩溃

//set[0] 没有这样[] 的功能去Set集合元素

println(set.elementAt(0)) //[0]

// println(set.elementAt(4)) //[4] 崩溃会越界

println()//3.elementAtOrElse elementAtOrNull

//使用list或set集合，尽量使用此方式防止越界崩溃异常

println(set.elementAtOrElse(4){"越界了"})

println(set.elementAtOrNull(4)?:"越界了")

63.Kotlin语言的可变Set集合

val set: MutableSet = mutableSetOf("李元霸", "李连杰")

set += "李俊"

set += "李天"

set -= "李连杰"

set.add("刘军")

set.remove("刘军")

println(set)

64.Kotlin语言的集合转换与快捷函数学习

//1.定义可变list集合

val list: MutableList = mutableListOf("Derry", "Derry", "Leo", "Lance")//list 可以重复元素println(list)

//2.List 转 Set 去重val set/*:Set*/ = list.toSet()println(set)

//3.List 转 Set 转 List 也能去重val list2/*: List */= list.toSet().toList()println(list2)

//4.快捷函数去重distinctprintln(list2.distinct()) //内部做了：先转变成可变的Set结合再转换成List集合println(list2.toMutableSet().toList()) //跟上面代码等价

65.Kotlin中的数组类型

/*Kotlin语言中的各种数组类型，虽然是引用类型，背后可以编译成Java基本数据类型

IntArray intArrayOf

DoubleArray doubleArrayOf

LongArray longArrayOf

ShortArray shortArrayOf

ByteArray byteArrayOf

FloatArray floatArrayOf

BooleanArray booleanArrayOf

Array <对象类型> arrayOf 对象数组 */

//1.intArrayOf 常规操作的越界崩溃

//2.elementAtOrElse elementAtOrNull

//3.List集合转数组

//4.arrayOf Array

fun main() {

//1.intArrayOf 常规操作的越界崩溃

val intArray/*:IntArray*/ = intArrayOf(1, 2, 3, 4,5)

println(intArray[0])

println(intArray[1])

println(intArray[2])

println(intArray[3])

println(intArray[4])

// println(intArray[5]) //崩溃会越界异常

println()

//2.elementAtOrElse elementAtOrNull

println(intArray.elementAtOrElse(0) { -1 })

println(intArray.elementAtOrElse(100) { -1 })

println(intArray.elementAtOrNull(0))

println(intArray.elementAtOrNull(200)) //OrNull + 空合并操作符一起来使用

println(intArray.elementAtOrNull(200) ?: "你越界啦")

println()

//3.List集合转数组

var charArray /*: CharArray*/ = listOf('A', 'B', 'C').toCharArray()

println(charArray)

//4.arrayOf Array

val objArray/*: Array*/ = arrayOf/**/(File("AAA"), File("BBB"), File("CCC"))}

66.Kotlin语言的Map的创建

val mMap1: Map = mapOf("Derry" to (534.4), "Kevin" to 454.5)val mMap2 = mapOf(Pair("Derry", 454.5))

67.Kotlin语言的读取Map的值

val mMap = mapOf("Derry" to 123, "Kevin" to 654)

//方式一 [] 找不到会返回null

println(mMap["Derry"])//背后对[] 运算符重载了

println(mMap.get("Derry"))//get 和 [] 完全等价的

println(mMap["Kevin"])

println(mMap["XXX"])//map通过key找如果找不到返回null,不会奔溃

//方式二

getOrDefaultprintln(mMap.getOrDefault("Kevin2",-1))

//方式三

getOrElseprintln(mMap.getOrElse("Kevin2"){-1})

//方式四与Java一样会崩溃

println(mMap.getValue("Derry"))//map获取内容，尽量使用方式二方式三

68.Kotlin语言的遍历Map学习

val map: Map = mapOf(Pair("Derry", 123), Pair("Kevin", 456), Pair("Leo", 789))

//第一种方式

map.forEach{ //it == 内容每一个元素（K 和 V） //it == Map.Entry

print("K:${it.key} V:${it.value}")}

println()//第二种方式

map.forEach{key,value->//把默认的it给覆盖了

print("key:${key} value:${value}")}

println()

//第三种方式

map.forEach{(k,v)-> print("key:${k} value:${v}")}

println()//第四种方式

for (item in map){ //item 内容每一个元素（K 和 V）

print("key:${item.key} value:${item.value}")}

69.Kotlin语言的可变Map集合学习

val map = mutableMapOf(Pair("Derry", 123), Pair("Kevin", 456), Pair("Leo", 789))

//下面是可变操作

map +="AAA" to (111)

map +="BBB" to 1234

map -="AAA"

map["CCC"]=888

map.put("DDD",999)//put 和 [] 等价的 //2.getOrPut 没有的情况

//如果整个map集合里面没有 FFF的key元素我就帮你先添加到map集合中去，然后再从map集合中获取

val r=map.getOrPut("FFF"){555}

println(r) println(map["FFF"])

//3.getOrPut 有的情况

val r2= map.getOrPut("Derry"){666}//发现Derry的key是有的，那么就直接获取出来，相当于666备用值就失效了

println(r2)

70.Kotlin语言的定义类与field关键字学习

class KTBase70 {

var name = "Derry"

/*背后做的事情：

@NotNull

private String name = "Derry"

public void setName(@NotNull String name){

this.name=name; }

@NotNull

public String getName(@NotNull String name){

return this.name; } */

var value="ABCDEFG" //下面的隐式代码，不写也有

get() = field//字段

set(value){

field=value

}

var info = "abcdefg ok is success"

get() = field.capitalize()//把首字母修改成大写

set(info){

field="**【$info】**"

} /*背后做的事情：

@NotNull

private String info = "abcdefg ok is success"

public void setInfo(@NotNull String info){

this.info="**["+info+"]**";

}

@NotNull

public String getInfo(@NotNull String info){

return StringKT.capitalize(this.info); } */

}//TODO 70.Kotlin语言的定义类与field关键字学习

fun main() { //背后隐式代码 new KTBase70().setName("")

KTBase70().name = "Kevin" //背后隐式代码 new KTBase70().getName("")

println(KTBase70().name) println(">>>>>>>>>>")

println(KTBase70().info) KTBase70().info = "学习KT"}

71.Kotlin语言的计算属性与防范竞态条件

class KTBase71{

val number : Int = 0

/*背后代码：

private int number = 0

public int getNumber(){

return this.number } */

//计算属性下面这样写，get函数覆盖了 field内容本身，相当于field失效了，无用了以后用不到了

val number2 : Int

get()=(1..1000).shuffled().first()//从1到1000取出随机值返回给 getNumber2()函数

/*背后代码：

private int number2 为社么没有看到number2属性定义？答：因为属于计算属性的功能，根本在getNumber2函数里面就没有用到number2属性所以number2属性失效了无用了以后用不到了

public int getNumber2(){

return (1..1000).shuffled().first() java的逻辑 } */

var info :String ?=/*null*/"" //防范竞态条件当你调用成员，这个成员，可能为null,可能为空值，就必须采用防范竞态条件这个是KT编程的规范化

fun getShowInfo():String{ //这个成员，可能为null,可能为空值，就启用防范竞态条件

//这种写法：就属于防范竞态条件我们可以看到专业的KT开发者，有大量这种代码

//also永远返回info本身

return info?.let {

if (it.isEmpty()){

"你原来是空值,请检查代码。。。"

}else{

"最终info结果是：$it"

} }?:"你原来是null,请检查代码。。。"

}}

//TODO 71.Kotlin语言的计算属性与防范竞态条件

fun main() {

println(KTBase71().number)

// KTBase71().number=9

//val 根本没有 setXXX函数，只有getXXX()函数

println(KTBase71().number2)

println(KTBase71().getShowInfo())}

72.Kotlin语言的主构造函数学习

//主构造函数：规范来说，都是增加_xxx的方式，临时的输入类型，不能直接用需要接收下来，成为变量才能用//_name 等等，都是临时的类型，不能直接要用，需要转化一下才能用class KTBase72(_name: String, _sex: Char, _age: Int, _info: String)//主构造函数{ var name = _name get() = field //get 不允许私有化 private set(value) { field = value } val sex = _sex get() = field // set(value) {} 只读的，不能修改的，不能set函数定义 val age: Int = _age get() = field + 1 val info = _info get() = "【${field}】" fun show() { // println(_name) println(name) println(sex) println(age) println(info) }}//TODO 72.Kotlin语言的主构造函数学习fun main() {// KTBase72() val p = KTBase72(_name = "Zhangsan", _info = "学习KT语言", _age = 88, _sex = 'm') println(p.name) // p.name = "AAA"被私有化了，不能调用 p.show()}

73.Kotlin语言的主构造函数里定义属性

/*伪代码class KTBase73 (_name: String, _sex: Char, _age: Int, _info: String){ var name=_name var sex=_sex var age=_age var name=_name fun show(){ println(name) }} *///var name: String 就相当于 var name=_name 只不过你看不到而已//一步到位不像我们上一篇是分开写的class KTBase73 (var name: String, val sex: Char, var age: Int, val info: String){ fun show(){ println(name) println(sex) println(age) println(info) }}//TODO 73.Kotlin语言的主构造函数里定义属性fun main() { KTBase73(name = "Zhangsan", info = "学习KT语言", age = 88, sex = 'm').show()}

74.Kotlin语言的次构造函数学习

class KTBase74 (name: String)//主构造函数{ //2个参数的次构造函数，必须要调用主构造函数,否则不通过，为什么次构造必须调用主构造？答：主构造统一处理，为了更好的初始化设计 constructor(name: String, sex: Char):this(name){ println("2个参数的次构造函数 name $name sex $sex") } //3个参数的次构造函数，必须要调用主构造函数 constructor(name: String, sex: Char,age:Int):this(name){ println("3个参数的次构造函数 name $name sex $sex age $age") } //4个参数的次构造函数，必须要调用主构造函数 constructor(name: String, sex: Char,age:Int,info:String):this(name){ println("4个参数的次构造函数 name $name sex $sex age $age info $info") }}//TODO 74.Kotlin语言的次构造函数学习//name: String, sex: Char, age: Int, info: Stringfun main() { val p = KTBase74("李元霸")//调用主构造 KTBase74("张三",'男')//调用2个参数的次构造函数 KTBase74("张三",'男',88)//调用3个参数的次构造函数 KTBase74("张三",'男',88,"还在学习新语言")//调用4个参数的次构造函数}

75.Kotlin语言的构造函数中默认参数学习

class KTBase75 (name: String="李元霸")//主构造函数{ //2个参数的次构造函数，必须要调用主构造函数,否则不通过，为什么次构造必须调用主构造？答：主构造统一处理，为了更好的初始化设计 constructor(name: String="李连杰", sex: Char='M'):this(name){ println("2个参数的次构造函数 name $name sex $sex") } //3个参数的次构造函数，必须要调用主构造函数 constructor(name: String="李小龙", sex: Char='M',age:Int=33):this(name){ println("3个参数的次构造函数 name $name sex $sex age $age") } //4个参数的次构造函数，必须要调用主构造函数 constructor(name: String="李俊", sex: Char='W',age:Int=87,info:String="还在学校新开发语言"):this(name){ println("4个参数的次构造函数 name $name sex $sex age $age info $info") }}//TODO 75.Kotlin语言的构造函数中默认参数学习fun main() { val p = KTBase75("李元霸")//调用主构造 KTBase75("张三",'男')//调用2个参数的次构造函数 KTBase75("张三",'男',88)//调用3个参数的次构造函数 KTBase75("张三",'男',88,"还在学习新语言")//调用4个参数的次构造函数 KTBase75()//到底调用哪一个构造函数，是次构造函数还是主构造函数？优先调用主构造函数}

76.Kotlin语言的初始化块学习

class KTBase76(username: String, userage: Int, usersex: Char) //主构造{ //这个不是Java的 static //相当于是Java的{} 构造代码块 //初始化块 init代码块 init {//可以使用临时变量校验打印 println("主构造函数被调用了$username") //第一个参数为false,就会调用第二个参数的lambda //判断username是不是空值 isNotBlank require(username.isNotBlank()){"你的username空空如也，异常抛出"} require(userage>0){"你的userage年龄不符，异常抛出"} require(usersex=='男'||usersex=='女'){"你的性别奇怪了，异常抛出"} } constructor(username: String) :this(username,87,'M'){ println("次构造函数被调用了") } fun show(){// println(username) 必须要二次转换，才能用 }}//TODO 76.Kotlin语言的初始化块学习//1.name,age,sex的主构造函数//2.init代码块学习 require//3.临时类型只有在init代码块才能调用fun main() { KTBase76("李四", userage = 88, usersex = 'M')//调用主构造 println() KTBase76("李三")//调用次构造（次构造会调用主构造） println()// KTBase76("") KTBase76("李四", userage = -1, usersex = 'M')//调用主构造}

77.Kotlin语言的构造初始化顺序学习

//1.val sex:Charclass KTBase77(_name: String,val sex:Char)//主构造{ //2.生成val mName 由于你是写在init代码块前面，所以先生成你，其实类成员和init代码块是同时生成 val mName=_name init { val nameValue = _name //3.生成nameValue细节 println("init代码块打印：nameValue $nameValue") } //次构造三个参数的必须调用主构造 constructor(name:String,sex: Char,age:Int):this(name,sex){ //4.生成次构造的细节 println("次构造三个参数的 name $name sex $sex age $age") } //init代码块和类成员是同时的只不过你写在init代码块前面就是先生成你}//TODO 77.Kotlin语言的构造初始化顺序学习//1.main 调用次构造 name sex age//2.主构造的val 变量//3.var mName=_name//4.init{nameValue 打印}fun main() {//调用次构造 KTBase77("李元霸",'男',99)}

init代码块打印：nameValue 李元霸

次构造三个参数的name李元霸 sex 男 age 99

78.Kotlin语言的延迟初始化lateinit学习

class KTBase78 { lateinit var responseResultInfo: String //我等会儿再来初始化你我先定义再说所以没有赋值 //模拟服务器请求 fun loadRequest() {//延时初始化，属于懒加载用到你再给你加载 responseResultInfo = "服务器加载成功，恭喜你" } fun showResponseResult() { //由于你没有给它初始化，所以只有用到它，就崩溃// if (responseResultInfo == null) println()// println("responseResultInfo : $responseResultInfo") if (::responseResultInfo.isInitialized){ println("responseResultInfo : $responseResultInfo") }else{ println("你都没有初始化加载，你是不是忘记加载了") } }}//TODO 78.Kotlin语言的延迟初始化lateinit学习//1.lateinit responseResultInfo定义//2.request懒加载//3.showResponseResult//4.main 先请求再显示fun main() { val p = KTBase78() //使用它之前加载一下（用到它才加载，就属于懒加载）// p.loadRequest() //使用它 p.showResponseResult()}

79.Kotlin语言的惰性初始化 by lazy 学习

class KTBase79 {//>>>>>>>>>下面是不使用惰性初始化 by lazy 普通方式(饿汉式没有任何懒加载的特点) val database1: String = readSQLServerDatabaseAction() //>>>>>>>>>使用惰性初始化 by lazy 普通方式 /* val database2 by lazy{readSQLServerDatabaseAction()}*/ private fun readSQLServerDatabaseAction(): String { println("开始读取数据库数据....") println("加载读取数据库数据....") println("加载读取数据库数据....") println("加载读取数据库数据....") println("加载读取数据库数据....") println("结束读取数据库数据....") return "database data load success ok" }}//TODO 79.Kotlin语言的惰性初始化 by lazy 学习//1.不使用惰性初始化 databaseData1 = readSQLServerDatabaseAction()//2.使用惰性初始化 databaseData2 by lazy//3.KtBase82() 睡眠 db1.databaseData1//lateinit 是在使用的时候，手动加载的懒加载方式，然后再使用//惰性初试化 by lazy是在使用的时候自动加载的懒加载方式然后再使用fun main() { //>>>>>>>>>下面是不使用惰性初始化 by lazy 普通方式 val p = KTBase79() Thread.sleep(5000) println("即将开始使用") println("最终显示：${p.database1}") //>>>>>>>>>不使用惰性初始化 by lazy 普通方式 /* val p = KTBase79() Thread.sleep(5000) println("即将开始使用") println("最终显示：${p.database2}")*/}

开始读取数据库数据....

加载读取数据库数据....

结束读取数据库数据....

即将开始使用

最终显示：database data load success ok

//>>>>>>>>>使用惰性初始化 by lazy 普通方式val p = KTBase79()Thread.sleep(5000)println("即将开始使用")println("最终显示：${p.database2}")

即将开始使用

开始读取数据库数据....

加载读取数据库数据....

结束读取数据库数据....

最终显示：database data load success ok

80.Kotlin语言的初始化陷阱学习

class KTBase80 { var number = 9 init { number = number.times(8) }}//TODO 80.Kotlin语言的初始化陷阱学习fun main() { println(KTBase80().number)}

81.Kotlin语言的初始化陷阱二学习

class KTBase81 { val info :String init {// getInfoMethod() info="DerryOK" } fun getInfoMethod(){ println("info : ${info[0]}") }// val info :String}//TODO 81.Kotlin语言的初始化陷阱二学习//1.定义info//2.init getInfo//3.info= ""fun main() { KTBase81().getInfoMethod()}

81.Kotlin语言的初始化陷阱三学习

class KTBase82(_info: String) { val info = _info val content: String = getInfoMethod()// val info = _info //把这种转换info的代码写到最前面这样保证就不会出现这种问题 fun getInfoMethod() = info //当此函数调用info变量的时候，你以为是赋值好了，但是还没有赋值}//TODO 81.Kotlin语言的初始化陷阱三学习//1.主构造 _info 放后面//2.value = initInfoAction()放前面//3.p.value.lengthfun main() { println("内容的长度是：${KTBase82("Derry").content.length}")}

kotlin学习记录

你可能感兴趣的:(kotlin学习记录)