目录

---

汇总一

1.变量

const val PI=3.14  //定义编译时常量，只能在函数之外定义
fun main(){println("hello world")// TODO 声明变量/*可读可改  变量名    类型    值* var     name  :  String="mumu";* *///TODO 内置数据类型/*String          字符串Char            单字符Boolean         true/falseInt             整型Double          小数List            集合Set             无重复的元素集合Map             键值对集合*///TODO  只读变量val name : String ="mumu" //不可修改的
}

2.kotlin的range表达式

    val number = 101if(number in 90..100){println("优秀")}else if(number in 0..60){println("不及格")}else if(number !in 0..100){println("分数不在0到100范围内")}

3.kotlin的when表达式

     val week=2//java的if表达式//kotlin的if表达式，有返回值的val info = when(week){1 -> "今天是星期一"2 -> "今天是星期二"else->{println("忽略星期几")}}println(info)

4.kt的String模板

 val garden="龙山公园"val time = 5println("今天去了${garden}玩，玩了${time}个小时")//因为kt的if时表达式，所以可以更灵活；java的if是语句，有局限性val isLogin=trueprintln("server response result: ${if(isLogin) "恭喜，登录成功" else "登陆失败"}")

5.kt的函数

fun main(){//TODO kt的函数头学习method01(18,"张三")//TODO kt函数参数的默认参数action01("木木",19)action02("李四")action03("小小",20)//TODO kt语言的反引号中函数特点`登录功能测试20221209，测试人MuMa`("MuMa","123456")//is 在kt里面是关键字，所以在这里需要用到反引号test.`is`()
}
private fun action01(name:String,age:Int){println("我的姓名是$name,年龄是$age")
}
private fun action02(name:String,age:Int=19){println("我的姓名是$name,年龄是$age")
}
private fun action03(name:String="张三",age:Int=18){println("我的姓名是$name,年龄是$age")
}//TODO kt语言的反引号中函数特点
private fun `登录功能测试20221209，测试人MuMa`(username:String,userpwd:String){println("用户名：$username,密码：$userpwd")
}

6.kt的匿名函数

fun main(){//TODO kt的匿名函数val len="muma".count()println(len) //输出长度val len2 ="muma".count{it == 'm'}println(len2)//TODO kt的函数类型&隐式返回学习//现在写函数//第一步：函数输入输出声明val methodAction : () -> String//第二步：对上面函数的实现methodAction={val score=99999"${score}MuMa"//匿名函数不要写return，最后一行是返回值}//第三步：调用次函数println(methodAction())//TODO kt的函数参数学习//第一步：函数输入输出声明，对声明函数的实现val methodAction1:(Int,Int,Int)->String ={num1,num2,num3 ->val input = 8899"$input muma 参数一：$num1，参数二：$num2，参数三：$num3"//第三步调用此函数}println(methodAction1(11, 22, 33))//TODO kt语言的it关键字特点val methodAction2 : (Int,Int,Int) -> String = {num1,num2,num3 ->val input = 89println("$input num1:$num1,num2:$num2,num3:$num3")"$input num1:$num1,num2:$num2,num3:$num3"}methodAction2(11,22,33)val methodAction3 : (Double) -> String = {"$it mumu"}println(methodAction3(3.1415))//TODO kt语言的匿名函数类型推断//方法名：必须指定参数类型和返回类型//方法名=类型推断返回类型val method1 = {s1:Double,s2:Float,s3:Int ->"s1:$s1,s2:$s2,s3:$s3"}println(method1(5.6, 3.1f, 66))val method2={num:Int->num}println(method2(36))//TODO kt语言的lambda学习//匿名函数==lambda表达式val addResultMethod ={num1:Int,num2:Int->"两个数相加的结果是：${num1+num2}"}println(addResultMethod(2, 2))//匿名函数入参Int        返回Any类型//lambda表达式Int       lambda表达式的结果Any类型val weekResultMethod = {number:Int->when(number){1->"星期一"2->"星期二"3->"星期三"else->-1}}//weekResultMethod 函数: (Int)->Anyprintln(weekResultMethod(3))//总结 匿名函数 属于 lambda//TODO 在函数中定义参数是函数的函数loginAPI("mumu","1234"){msg:String,code:Int->println("提示：msg:$msg，code:$code")}}//TODO 在函数中定义参数是函数的函数
const val USER_NAME_SAVE_DB="mumu"
const val USER_PWD_SAVE_DB="123456"
//todo 如果函数有lambda，尽量使用inline关键帧(内联函数)，这样内部会做优化，减少函数开辟和对象开辟的损耗
public 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(wbeServiceLoginAPI(username,userpwd)){return responseResult("login success",200)}else{return responseResult("login error",444)}}else{TODO("用户名或密码格式不正确")}
}
fun wbeServiceLoginAPI(name:String,pwd:String) : Boolean{return name==USER_NAME_SAVE_DB && pwd==USER_PWD_SAVE_DB
}

7.kt语言的函数引用学习

fun main(){login("mumu","12345"){msg:String,code:Int->println("提示最终登陆结果：msg:$msg,code:$code")}login("mumu","123456",::methodResponseResult)//函数的引用
}
fun methodResponseResult(msg:String,code:Int){println("提示最终登陆结果：msg:$msg,code:$code")
}
const val USER_NAME_SAVE_DB1="mumu"
const val USER_PWD_SAVE_DB1="123456"
inline fun login(name:String,pwd:String,responseResult:(String,Int)->Unit){if(name==USER_NAME_SAVE_DB1 && pwd==USER_PWD_SAVE_DB1){responseResult("登录成功",200)}else{responseResult("登录失败",444)}}

8.kt语言的函数类型作为返回类型

fun main(){//    show("学习kt语言")val showMethod=show("show")//showMethod 是 show函数的返回值，只不过这个返回值是一个函数，所以可以调用showMethod这个函数println(showMethod("张三",12))
}
//show函数 再返回一个匿名函数
fun show(info:String) : (String,Int) -> String{println("我是show函数 info:$info")return { name:String,age:Int->"匿名函数：name:$name,age:$age"}
}

9.kt语言的匿名函数和具名函数

fun main(){//匿名函数showPersonInfo("张三",18,'男',"kotlin"){println("显示结果：$it")}//t1具名函数showPersonInfo("李四",28,'女',"java",::showResultImpl)//TODO kt语言的可空性特点//第一种：默认是不可空类型，不能随便给nullvar name1:String = "张三" //不能是非空类型//第二种：声明时指定为可空类型var name2:String ?name2=nullprintln(name2)}
//t1
fun showResultImpl(result: String){println("显示结果：$result")
}
inline fun showPersonInfo(name:String,age:Int,sex:Char,study:String,showResult:(String)->Unit){val str="name:$name,age:$age,sex:$sex,study:$study"showResult(str)
}

10.kt语言的安全调用操作符

fun main(){//TODO kt语言的安全调用操作符var name : String? ="abc"//name=null//name. //name是可空类型，可能是null，想要用name，必须给出补救措施val r=name?.capitalize() //name是可空类型,如果真的是null，?后面这一段代码不执行，就不会引发空指针异常//todo kt语言中非空断言操作符特点var s=name!!.capitalize() //!! 断言 不管name是不是null都执行//规矩：如果百分百能保证name不是空值，才能使用!!断言，否则空指针异常风险println(r)//TODO kt语言使用带let的安全调用var name1 : String? =null//name1="zhangsan"//name是可空类型,如果真的是null，?后面这一段代码不执行，就不会引发空指针异常var r1=name1?.let{//let可以把name1拿到内部用//it==name1本身//执行到这里 it 一定不为nullif(it.isBlank()){"Default"}else{it}}println(r1)//TODO kt语言的空合并操作符println(name1?.let{ "【$it】" } ?: "原来你是null")
}

汇总二

1.kt语言的substring

const val INFO="Muma like kotlin"
fun main(){val indexOf=INFO.indexOf("k")println(INFO.substring(0 , indexOf))println(INFO.substring(0 until indexOf)) //kt语言基本上用此方式 0 until indexOf
}

2.kt语言的split操作

     val jsonText="mumu,zhangsan,lisi,zhaowu"val list=jsonText.split(",") //list 自动类型推断成 list==List<String>//直接输出list集合 不解构println("分割后的list里面的元素有：$list")//c++ 解构，kt也有解构val (m1,m2,m3,m4) = listprintln("解构四个只读变量的值是：m1:$m1,m2:$m2,m3:$m3,m4:$m4")

3.kt语言的replace完成加密解码操作

     val sourcePwd="ABCDE"println("原始密码是：$sourcePwd")//加密操作：把字符替换成数字val newPwd = sourcePwd.replace(Regex("[ABCDE]")){when(it.value){"A" -> "3""B" -> "5""C" -> "6""D" -> "2""E" -> "1"else -> it.value}}println("加密后的密码是：$newPwd")

4.kotlin语言中== & ===比较操作

     val name1="Muma"val name2="muma".capitalize()println(name1 == name2) //trueprintln(name1 === name2) //false

5.字符串遍历

     val str = "ABCDEFG"str.forEach { /*c-> //覆盖掉默认的it参数名,改$it为$c*/print("字符:$it，")}

6.数字类型安全转换函数

    val num : Int = "666".toInt()println(num)//字符串放入了double类型，无法转换成Int，会崩溃//例如：val num : Int = "3.14".toInt()//解决崩溃问题val num2 : Int? = "3.14".toIntOrNull()println(num2 ?: "原来你是null") //空合并

7.Double转Int与类型格式化

     println(34.65.toInt()) //不会四舍五入println(34.65.roundToInt()) //四舍五入println("%.3f".format(35.6578)) //保留三位小数，输出的是String类型

汇总三（内置函数）

1.apply内置函数

val info = "Mumu Like Kotlin"//普通方式println("info字符串长度是：${info.length}")println("info最后一个字符是：${info.length -1}")println("info全部转成小写是：${info.toLowerCase()}")//apply内置函数方式//特点：始终返回info本身String类型val infoNew =info.apply {//一般情况下，匿名函数都会持有一个it，apply会持有有个this==info本身println("apply匿名函数里面打印的：$this")println("info字符串长度是：$length")println("info最后一个字符是：${this[length -1]}")println("info全部转成小写是：${toLowerCase()}")}//apply使用规则//apply始终返回 info本身，所以可以链式调用info.apply {println("info字符串长度是：$length")}.apply {println("info最后一个字符是：${this[length -1]}")}.apply {println("info全部转成小写是：${toLowerCase()}")}//普通写法val file=File("C:\\Users\\Administrator\\Desktop\\a.txt")file.setExecutable(true)file.setReadable(true)println(file.readLines())//apply写法file.apply {setExecutable(true)}.apply {setReadable(true)}.apply {println(readLines())}

2.let内置函数

fun main(){//todo let内置函数//普通方式，对集合中第一个元素进行相加//let方式，对集合中第一个元素进行相加//普通方式，对值判null，并返回//let方式，对值判null，并返回//普通方式，对集合中第一个元素进行相加val list= listOf(3,5,2,6,7)val value1=list.first()+list.first()println(value1)//let方式，对集合中第一个元素进行相加//let函数的返回类型，根据匿名函数的最后一行变化而变化val value2=listOf(3,5,2,6,7).let {it.first()+it.first() //let的特点，匿名函数最后一行作为返回值；但apply永远返回元素本身}println(value2)println(getMethod3("Mumu"))
}
//普通方式，对值判null，并返回
fun getMethod(value:String?):String{return if (value==null) "传入的值是null" else "欢迎回来${value}"
}
//普通方式，对值判null，并返回,简化版本
fun getMethod2(value:String?) = if (value==null) "传入的值是null" else "欢迎回来${value}"//let方式，对值判null，并返回
fun getMethod3(value: String?) : String{return value?.let{"欢迎回来$it"} ?: "传入的值是null"
}
//let方式，对值判null，并返回,简化版本
fun getMethod4(value: String?) =value?.let{"欢迎回来$it"} ?: "传入的值是null"

3.run内置函数

fun main(){//todo run内置函数val str = "MuMa like Kotlin"//run函数返回类型根据最后一行变化而变化，和let一样//run函数的匿名函数里面持有的this==str本身，和apply一样//具名函数配合run函数str.run(::isLong).run(::showText).run(::mapText).run(::println)//匿名函数调用给run执行str.run{str.length>5}.run {if (this) "你的字符合格" else "你的字符不合格"}.run {"【$this】"}.run(::println)
}
fun isLong(str : String) = str.length>5
fun showText(islong : Boolean) = if (islong) "你的字符合格" else "你的字符不合格"
fun mapText(getText : String) = "【$getText】"

4.with内置函数

fun main(){//具名操作val str="张三"val s1 = with(str,::getStrLen)val s2 = with(s1,::getLenInfo)val s3 = with(s2,::getInfoMap)with(s3,::shows)//匿名函数with(with(with(with(str){this.length}){"你的字符串长度是：$this"}){"【$this】"}){println(this)}
}
fun getStrLen(str : String) = str.length
fun getLenInfo(len : Int) = "你的字符串长度是：$len"
fun getInfoMap(info : String) = "【$info】"
fun shows(content : String) = println(content)

5.takeIf内置函数

fun main(){//todo takeIf内置函数val result = checkpermissionAction("root","root")if(result != null){println("欢迎${result}尊贵用户登录系统，拥有超级权限")}else{println("没有权限")}println(checkpermissionAction2("root","root"))//小结：一般情况下，都是takeIf + 空合并一起使用
}//前端
fun checkpermissionAction(name : String , pwd : String) : String?{return name.takeIf { permissionSystem(name,pwd) }
}
//takeIf + 空合并操作符
fun checkpermissionAction2(name : String , pwd : String) : String{return name.takeIf { permissionSystem(name,pwd) } ?: "没有权限"
}
//权限系统
private fun permissionSystem(username:String,userpwd:String) : Boolean{return if(username == "root" && userpwd == "root") true else false
}

汇总四

1.list

//todo list创建和元素获取val list= listOf<String>("Mumu","zhangsan","lisi","wangwu")//普通取值方法println(list[0])//防止崩溃取值方法：getOrElse,getOrNullprintln(list.getOrElse(4){"越界"})println(list.getOrNull(4)) //null//getOrNull + 空合并操作符println(list.getOrNull(4) ?: "越界")//todo 可变List集合val list1 = mutableListOf("Mumu","zhangsan","lisi","wangwu")list1.add("zhaoliu")list1.remove("zhangsan")println(list1)//不可变集合 to 可变集合val list3 : MutableList<String> = list.toMutableList()list3.add("xiaoxiao")list3.remove("zhangsan")println(list3)//可变集合 to 不可变集合val list4 : List<String> = list3.toList()//todo List集合遍历val list6 = listOf(1,2,3,4,5,6)//第一种遍历方式：for (i in list6){print("元素:$i   ")}println()//第二种遍历方式：list6.forEach {print("元素:$it   ")}println()//第三种遍历方式：list6.forEachIndexed{index,i ->print("下标:$index,元素:$i   ")}println()

2.mutator函数

    //mutator += -= 操作val list5 : MutableList<String> = mutableListOf("zhangsan","lisi")list5 += "mumu"list5 -= "zhangsan"println(list5)//removeIf//list5.removeIf(){ true } //如果是true全部删除掉list5.removeIf(){it.contains("li")} //过滤所有元素 只要包含li的元素就是true 删除println(list5)

3.kt语言的解构语法过滤元素学习

 val list7 :List<String> = listOf("张三","李四","赵武")val(v1,v2,v3) = list7println("v1:$v1,v2:$v2,v3:$v3")//用_内部可以不接受的赋值，可以节约一点性能val(_,value2,value3) = list7println("v2:$v2,v3:$v3")//todo set创建与元素获取//set集合不会出现重复元素，若出现则会被覆盖val set : Set<String> = setOf("zhangsan","lisi","zhaowu","zhangsan")println(set.elementAt(0))println(set.elementAt(1))println(set.elementAt(2))println(set.elementAtOrElse(3){"越界"})//OrNull + 空合并操作符 一起使用println(set.elementAtOrNull(10)?:"越界了")

4.可变set集合

    val set1 : MutableSet<String> = mutableSetOf("张三","李四")set1 += "木马"set1 += "小小"set1 -= "李四"println(set)

5.集合转换与快捷函数

    val list11 : MutableList<String> = mutableListOf("zhangsan","zhangsan","lisi","xiaoxiao")//list 转 set 去重val set2 = list11.toSet()println(set2)//list转set转list去重val list12 = list11.toSet().toList()println(list12)//快捷去重 distinctprintln(list11.distinct()) //内部：县转换成可变的set集合 在转换成list集合 如下：println(list11.toMutableSet().toList())

6.数组类型

     val intArray = intArrayOf(1,2,3,4,5)//越界崩溃println(intArray[0])println(intArray.elementAtOrElse(10){-1})println(intArray.elementAtOrNull(10) ?: "越界")//list集合转数组val charArray = listOf('A','B','C').toCharArray()//arrayOfval objArray = arrayOf<File>(File("AAA"),File("bbb"))

7.Map

//todo Map的创建val mMap1 : Map<String,Double> = mapOf<String,Double>("Mumu" to(123.3),"xiaoxiao" to(234.4))val mMap2 : Map<String,Double> = mapOf(Pair("Mumu",123.3), Pair("xiaoxiao",234.4))//读取Map的值//方式一println(mMap1["Mumu"])println(mMap1.get("Mumu")) //以上两个等价//方式二 getOrDefaultprintln(mMap1.getOrDefault("xiaoxiao",-1))//方式三 getOrNullprintln(mMap1.getOrElse("Mumu"){-1})//todo Map遍历学习val map : Map<String,Double> = mapOf("zhangsan" to(12.22),"李四" to(3.14))//第一种方式map.forEach{println("K:${it.key},v:${it.value}")}//第二种方式map.forEach{key,value->println("key:$key,value:$value")}//第三种方式map.forEach{(k,v)->println("key:$k,value:$v")}//第四种方式for (item in map){println("key:${item.key},value:${item.value}")}//todo 可变的map集合val map1 : MutableMap<String,Int> = mutableMapOf(Pair("zhangsan",123), Pair("lisi",111),Pair("xiaoxiao",555))map1 += "jj" to(656)map1 += "kk" to 999map1 -= "xiaoxiao"map1["CCC"] = 909map1.put("dd",898) //put 和 [] 等价//getOrPut 没有的情况//如果map1里没有ff的key元素，就先帮你添加到map集合里去，然后再从map1中获取val r :Int =map1.getOrPut("ff"){189}println(map1["ff"])map1.forEach{println("${it.key}:${it.value}，")}//getOrPut 有的情况val r2 =map1.getOrPut("zhangsan"){909} //发现zhangsan的key是有的，就直接取出来，备用值909失效println(r2)

汇总五

1.field关键字的学习

class KtBase10(){var name="Muma"var value ="ABCD"//下面的隐式代码不写也有get()=fieldset(value){field=value}var info = "abcd is success"get()=field.capitalize()//把首字母改成大写set(value){field="**【$value】**"}/* 背后做的事@NotNullpublic final String getInfo() {return StringsKt.capitalize(this.info);}public final void setInfo(@NotNull String value) {Intrinsics.checkNotNullParameter(value, "value");this.info = "**【" + value + "】**";}*/
}
//todo field关键字的学习
fun main(){//背后隐式代码：new KtBase10().setName("Xiaoxiao");KtBase10().name="Xiaoxiao"//背后隐式代码：System.out.println(new KtBase10().getName);println(KtBase10().name)
}

2.计算属性与防范竞态

class KtBase11(){val num : Int = 1/* 背后的代码private int num = 1public int getNum(){return this.num}*///计算属性 下面这样写 get函数覆盖了field内容 相当于field失效了val num1 : Intget()=(1..1000).shuffled().first() //从1到1000取出随机值 返回给getNum1()函数/* 背后隐式代码private int num2;public int getNum2(){return (1..1000).shuffled().first() java的随机逻辑}* */var info : String ?= ""//null//防范竞态条件 当你调用的成员可能为null 可能为空值 就必须采用防范竞态条件 这是KT的规范fun getShowInfo() : String {return info ?.let{if(it.isBlank()){"空值，请检查代码..."}else{"最终结果是：$it"}} ?: "null,请检查代码..."}
}
fun main(){//System.out.println(new KtBase11().getNum());println(KtBase11().num)//new KtBase11().setNum(9)//KtBase11().num=9 //val根本没有setNum()函数，只有getNum()函数println(KtBase11().num1)println(KtBase11().getShowInfo())
}

3.主构造函数

class KtBase12(_name:String,_sex:Char,_age:Int,_info:String){ //主构造函数var name = _nameget() = fieldprivate set(value){field = value}val sex = _sexget() = fieldval age = _ageget() = field + 1val info = _infoget() = "【$field】"fun show(){println(name)println(sex)println(age)println(info)}
}
fun main(){val p = KtBase12(_name = "Muma",_age = 17,_info = "学习Kotlin语言",_sex = '男')p.show()
}

4.主构造函数里定义属性

//var name :String  就相当于 var name = _name 只不过看不到而已
//一步到位
class KtBase13(val name: String,val sex: Char,val age: Int,var info: String){fun show(){println(name)println(sex)println(age)println(info)}
}
fun main(){val p = KtBase13(name="张三",sex='男',age=18,info="学习Kotlin语言")p.show()
}

5.次构造函数

 class KtBase14(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")}
}
fun main(){val p = KtBase14("张三")KtBase14("张三",'男')KtBase14("李四",'女',18)KtBase14("小小",'女',19,"还在学习Kotlin语言")
}

6.初始化块学习

class KtBase15(username:String,userage:Int,usersex:Char){//初始化块 init代码块init{println("主构造函数被调用了，$username,$userage,$usersex")//如果第一个参数是false，就会调用第二个参数的lambda//判断username是不是空值 ""require(username.isNotBlank()){"你的username空空如也，异常"}require(userage > 0){"你的年龄不符合，异常"}require(usersex == '男' || usersex == '女'){"你的性别很奇怪，异常"}}constructor(username:String) : this(username,18, '男'){println("次构造函数被调用")}
}
fun main(){KtBase15("张三",19,'男') //调用主函数KtBase15("李四") //调用次函数
//    KtBase15("")
//    KtBase15("张三",-1,'男')KtBase15("张三",21,'k')
}

7.构造初始化顺序学习

//第一步生成val sex:Char
class KtBase16(_name : String,val sex : Char){//第二步生成val nameval name=_nameinit{val nameValue=_name //第三步生成nameValue细节println("init代码块打印，nameValue：$nameValue")}//次构造 三个参数 必须调用主构造constructor(name:String,sex:Char,age : Int):this(name,sex){//第四部生成次构造细节println("次构造，三个函数，name:$name,sex:$sex,age:$age")}
}
fun main(){KtBase16("张三",'男',19)
}

8.延迟初始化lateinit

class KtBase17(){lateinit var responseResultInfo: String //等会再来初始化，先定义//模拟服务器加载fun loadRequest(){responseResultInfo = "恭喜，服务器加载成功"}fun showResponseResult() {if (::responseResultInfo.isInitialized) {println("responseResultInfo:$responseResultInfo")} else {println("你还没有初始化")}}
}
//todo 延迟初始化lateinit
fun main(){val p = KtBase17()//用到它才加载，就属于懒加载p.loadRequest()p.showResponseResult()
}

9.惰性初始化by lazy

class KtBase18(){//不使用惰性初始化 普通方式
//    val databaseData1=readSQLServerDatabaseAction()//使用惰性初始化，by lazyval databaseData2 by lazy{readSQLServerDatabaseAction()}private fun readSQLServerDatabaseAction(): String {println("开始读取数据库中...")println("加载数据库中...")println("结束读取数据库中...")return "database data load success ok."}
}
//todo 惰性初始化by lazy
//1、不使用惰性初始化：databaseData1=readSQLServerDatabaseAction()
//2、使用惰性初始化：databaseData2 by lazy
//3、KtBase18() 睡眠 db1.databaseData1
//lateinit 是在使用的时候 手动加载懒加载方式，然后在使用
//惰性初始化 by lazy 是在使用的时候，自动加载的懒加载方式，然后再使用
fun main(){//    val p = KtBase18()
//    Thread.sleep(5000)
//    println("提示：${p.databaseData1}")val p = KtBase18()Thread.sleep(5000)println("提示：${p.databaseData2}")
}

10.继承与重载的open关键字学习

//默认的类，默认都是final修饰，不能被继承
open class Person(val name:String){private fun showName() = "父类 的姓名是【$name】"open fun myPrint() = println(showName())
}
class Student(private val subName : String) : Person(subName){private fun showName()="子类 的姓名是【${subName}】"override fun myPrint()= println(showName())
}
fun main(){val person : Person =Student("张三")person.myPrint()
}

汇总六

1.类型转换学习

open class Person2(val name:String){fun showName() = "父类 的姓名是【$name】"open fun myPrint() = println(showName())fun methodPerson()= println("父类方法..")
}
class Student2(private val subName : String) : Person2(subName){fun showName2()="子类 的姓名是【${subName}】"override fun myPrint()= println(showName2())fun methodStudent()= println("子类方法..")
}
fun main(){val p: Person2 =Student2("张三")p.myPrint()//检测类型println(p is Person2) //trueprintln(p is Student2) //true//转换类型if(p is Student2){(p as Student2).myPrint()}if(p is Person2){println((p as Person2).showName())}//todo 智能类型转换(p as Student2).methodStudent()p.methodStudent()p.methodPerson()p.methodStudent()
}

2.Any超类学习

//在KT语言中，所有的类都隐式继承了 :Any()，你不写，默认就有
//Any类在KT语言设计中，只提供标准，看不到实现，实现在各个平台都实现好了
class Obj1 : Any()
class Obj2 : Any()
class Obj3 : Any()
class Obj4 : Any()
class Obj5 : Any()
fun main(){println(Obj1().toString())
}

3.对象声明

object KtBase28{init {println("KtBase28 init...")}fun show() = println("我是show函数")
}
fun main(){println(KtBase28)println(KtBase28)println(KtBase28)println(KtBase28.show())
}

4.对象表达式

interface RunnableKT{fun run()
}
open class KtBase29(){open fun add(info : String) = println("add:$info")open fun del(info : String) = println("del:$info")
}
fun main(){//匿名对象表达式方式val p : KtBase29 = object : KtBase29(){override fun add(info: String) {//            super.add(info)println("我是匿名对象 add:$info")}override fun del(info: String) {//            super.del(info)println("我是匿名对象 del:$info")}}p.add("张三")p.del("李四")//具名实现方式val p2 :KtBase29 = KtBase29Impl()p2.add("张具三")p2.del("李具四")//对Java的接口 用KT[对象表达式]val p3 =object : Runnable{override fun run() {println("Runnable run ...")}}p3.run()//对Java的接口 用Java最简洁的方式val p4 = Runnable {println("Runnable run2 ...")}p4.run()//对KT的接口 用KT[对象表达式]object : RunnableKT{override fun run() {println("RunnableKT run ...")}}.run()//小结：Java接口有两种方式，KT接口只有一种方式
}
//具名实现
class KtBase29Impl : KtBase29(){override fun add(info: String) {//        super.add(info)println("我是具名对象 add:$info")}override fun del(info: String) {//        super.del(info)println("我是具名对象 del:$info")}
}

5.伴生对象

class KtBase30{//伴生对象companion object{val info = "MumaInfo"fun showInfo()="显示:$info"}
}
//伴生对象的由来：在KT中没有java的这种static静态，伴生很大程度上和这种static差不多
//无论KtBase30()构建对象多少次，我们的伴生对象加载一次
//伴生对象只会初始化一次
fun main(){println(KtBase30.info)KtBase30.showInfo()KtBase30KtBase30KtBase30
}

6.嵌套类和内部类的学习

//内部类
//内部类的特点：内部的类 能访问 外部的类；外部的类 能访问 内部的类
class Body(_bodyInfo :String){val bodyInfo = _bodyInfofun show(){}//默认情况下 内部的类不能访问外部的类，要增加inner修饰符，成为内部类才能访问外部类inner class Heart{fun run()= println("心脏访问身体信息：$bodyInfo")}inner class Hand{inner class leftHand{fun run()= println("左手访问身体信息：$bodyInfo")}inner class rightHand{fun run()= println("右手访问身体信息：$bodyInfo")}}
}
//嵌套类
//默认情况下就是嵌套类关系
//嵌套类特点：外部的类 能访问 内部的嵌套类；内部的类 不能访问 外部的成员
class Outer{val info :String = "OK"fun show(){Nested().inp()}class Nested{fun inp()= println("嵌套类")}
}
fun main() {//内部类Body("isOk").Heart().run()Body("isOk").Hand().leftHand().run()Body("isOk").Hand().rightHand().run()//嵌套类Outer.Nested().inp()
}

7.copy函数的学习

data class KtBase32(var name :String,var age : Int){ //数据类 主构造var coreInfo : String = ""init {println("主构造被调用")}constructor(name: String):this(name,99){println("次构造被调用")coreInfo="增加非常核心的内容信息"}override fun toString(): String {return "toString name:$name,age:$age,coreInfo:$coreInfo"}
}
//默认生成的toString、hashcode equals等..只管主构造，不管次构造
fun main() {val p1 = KtBase32("张三") //调用次构造println(p1)val p2 = p1.copy("李四",88)println(p2)//注意：使用copy的时候，由于内部代码只处理主构造，所以必须考虑次构造内容
}

8.解构声明学习

//普通类
class KtBase33(var name : String,var age : Int,var sex : Char){//顺序必须是和成员一一对应operator fun component1() = nameoperator fun component2() = ageoperator fun component3() = sex
}
//数据类
data class KtBase33Data(var name : String,var age : Int,var sex : Char)
fun main() {val(name,age,sex)=KtBase33("张三",78,'男')println("普通类解构后：name:$name,age:$age,sex:$sex")val(name1,age1,sex1)=KtBase33Data("李四",45,'男')println("数据类解构后：name1:$name1,age1:$age1,sex1:$sex1")val(name2,_,_)=KtBase33Data("李四",45,'男')println("数据类解构后：name2:$name2")
}

9.plus代表+运算符重载

data class AddClass(var num1:Int,var num2:Int){operator fun plus(p1:AddClass):Int{return (num1+p1.num1)+(num2+p1.num2)}//查看整个kt可以用的运算符重载方式
//    operator fun AddClass.
}
fun main() {//kt语言 plus代表+运算符重载println(AddClass(1,2)+AddClass(2,3))
}

10.枚举类定义函数

data class LimbsInfo(var limbsInfo: String, var length:Int){fun show(){println("${limbsInfo}的长度是:$length")}
}
enum class Limbs(private var limbsInfo: LimbsInfo){LEFT_HAND(LimbsInfo("左手",18)),RIGHT_HAND(LimbsInfo("右手",18)),LEFT_FOOT(LimbsInfo("左脚",26)),RIGHT_FOOT(LimbsInfo("右脚",26));fun show()="四肢是:${limbsInfo.limbsInfo},长度是:${limbsInfo.length}"fun updateData(limbsInfo: LimbsInfo){println("更新前的数据：${this.limbsInfo}")this.limbsInfo.limbsInfo=limbsInfo.limbsInfothis.limbsInfo.length=limbsInfo.lengthprintln("更新后的数据：${this.limbsInfo}")}
}
fun main() {//显示枚举值println(Limbs.LEFT_HAND.show())println(Limbs.RIGHT_HAND.show())println(Limbs.LEFT_FOOT.show())println(Limbs.RIGHT_FOOT.show())//更新枚举值Limbs.LEFT_FOOT.updateData(LimbsInfo("左脚更新",25))
}

汇总七

1.密封类

sealed class Exams(){object Fraction1 : Exams()object Fraction2 : Exams()object Fraction3 : Exams()class Fraction4(val studentName : String) : Exams()
}
class Teacher(private val exams: Exams){fun show() =when(exams){is Exams.Fraction1 -> "该学生分数很差"is Exams.Fraction2 -> "该学生分数及格"is Exams.Fraction3 -> "该学生分数良好"is Exams.Fraction4 -> "该学生分数优秀：该学生的名字是：${this.exams.studentName}"}
}
fun main() {println(Teacher(Exams.Fraction2).show())println(Teacher(Exams.Fraction4("张三")).show())
}

2.数据类型使用条件

data class LoginRequest(var info : String)
//todo 数据类型使用条件
//条件一：服务器请求回来相应的JavaBean、LoginResponseBean 基本上可以使用数据类
//条件二：数据类必须有一个参数的主构造函数
//条件三：数据类必须有参数，var val的参数
//条件四：数据类不能使用abstract、open、sealed、inner等修饰 （数据类，数据载入的事情、数据存输）
//条件五：需求 比较，copy、toString、解构等等，这些丰富的功能时也可以使用数据类

3.接口定义

interface IUSB{var usbVersionInfo:String //USB版本相关信息var usbInsertDavice:String //USB插入设备信息fun insertUSB() : String
}
//鼠标USB实现类
class Mouse(override var usbVersionInfo: String = "USB 3.0", override var usbInsertDavice: String = "鼠标接入USB口") : IUSB{override fun insertUSB() = "Mouse $usbVersionInfo,$usbInsertDavice"
}
//键盘USB实现类
class KeyBoard : IUSB{override var usbVersionInfo: String = "USB 3.1"get() = fieldset(value) {field=value}override var usbInsertDavice: String = "键盘接入了USB口"get() {println("get${field}的值出去了")return field}set(value) {field = valueprintln("set${value}的值进来了")}override fun insertUSB(): String = "KeyBoard $usbVersionInfo,$usbInsertDavice"
}//todo 接口定义
//1.接口里面的所有成员都是public open的，所以不需要open
//2.接口不能有主构造，没有构造
//3.实现类不仅仅要重写接口函数，还要重写接口成员
fun main(){val iusb1 : IUSB = Mouse()println(iusb1.insertUSB())//    val iusb2 : IUSB = KeyBoard()
//    println(iusb2.insertUSB())
}

4.接口默认实现

interface USB2{//接口 var是不能给接口赋值的//任何类、接口等是不可以动态赋值的val usbVersionInfo : Stringget()=(1..1000).shuffled().last().toString()//val 不需要setval usbInsertDevice : Stringget()="高级设备接入USB"fun insertUSB() : String
}
class Mouse2() : USB2{override val usbVersionInfo: Stringget() = super.usbVersionInfooverride val usbInsertDevice: Stringget() = super.usbInsertDeviceoverride fun insertUSB() = "Mouse2 $usbVersionInfo,$usbInsertDevice"
}
//todo 接口默认实现
fun main(){val iusb = Mouse2()println(iusb.insertUSB())
}

5.定义泛型类

class KtBase40<T> (private  val obj : T){ //万能输出器fun show() = println("万能输出器：$obj")
}
data class Students(val name : String , val age : Int , val sex : Char)
data class Teachers(val name : String , val age : Int , val sex : Char)fun main() {val stu1 = Students("张三",29,'男')val stu2 = Students("李四",19,'男')val tea1 = Teachers("赵武",12,'男')val tea2 = Teachers("刘柳",45,'男')KtBase40(stu1).show()KtBase40(stu2).show()KtBase40(tea1).show()KtBase40(tea2).show()KtBase40(String("小小".toByteArray())).show()KtBase40(23).show()KtBase40(23.4534).show()KtBase40(565.3f).show()
}

6.泛型函数学习

//万能对象返回器 Boolean控制是否返回，运用takeIf
class KtBase41<T>(private val isR : Boolean , private val obj : T){fun getObj() = obj.takeIf { isR }
}//todo 泛型函数学习
fun main() {val stu1 = Students("张三",29,'男')val stu2 = Students("李四",19,'男')val tea1 = Teachers("赵武",12,'男')val tea2 = Teachers("刘柳",45,'男')println(KtBase41(true, stu1).getObj())println(KtBase41(true, stu2).getObj())println(KtBase41(true, tea1).getObj())println(KtBase41(true, tea2).getObj())println(KtBase41(false, tea2).getObj())//对象打印 + run + ?:KtBase41(true,stu1).getObj()?.run {println("万能对象是：$this")} ?: println("万能对象返回器，返回的是null")//对象打印 + apply + ?://apply特点：永远返回getObj本身val r1 : Students = KtBase41(true,stu2).getObj()?.apply {if(this == null){println("万能对象返回器，返回的是null")}else{println("万能对象是：$this")}}!! //断崖println("r1:$r1")show1("张三")show1(12.22)show1(null)
}
//show(a : A) + also + ?
fun <A> show1(item : A){item?.also{println("万能对象是：$it")}?:println("万能对象返回器，返回的是null")
}

7.泛型变换实战

//模仿RxJava T是要变化的输入类型，R是变换后的输出类型
class KtBase42 <T> (val isMap : Boolean = false,val inputType : T){inline fun <R> map(mapAction:(T) -> R) = mapAction(inputType).takeIf { isMap }
}
inline fun <I , O> map(inputValue : I,isMap : Boolean = true,mapActionLambda : (I) -> O)=if (isMap) mapActionLambda(inputValue) else null
//todo 泛型变换实战
fun main() {val p1 = KtBase42(isMap = true,inputType = 123)val r1 : String? = p1.map {it.toString() //lambda最后一行是返回值}println(r1)//map Persons1->Student1 最终接收什么类型val p2 = KtBase42(true ,Persons1("张三",28))val r2 : Student1?=p2.map{itStudent1(it.name,it.age)}println(r2)//map函数 模仿RxJava变换操作map(123){it.toString()}//todo 泛型类型的约束val per = personClass("张三")val son1 = son1Class("张大儿")val son2 = son2Class("张小儿")val dog = dogClass("其他")val a1 = KtBases(per).getObj()val a2 = KtBases(son1).getObj()val a3 = KtBases(son2).getObj()//val q1 = KtBases(dog).getObj() //其他类不兼容会报错}
data class Persons1(val name : String , val age : Int)
data class Student1(val name : String , val age : Int)//todo 泛型类型的约束
open class personClass (name:String) //父类
class son1Class(name:String) : personClass(name = name) //子类
class son2Class(name:String) : personClass(name = name) //子类
class dogClass(name : String) //其他类
//<A : personClass>：personClass本身 和personClass的所有子类都可以使用，其他的类，都不能兼容此泛型
class KtBases <A : personClass> (private val inputVal : A,private val isR: Boolean = true){//万能对象返回器fun getObj() = inputVal.takeIf { isR }
}

8.vararg关键字(动态参数)

//vararg val objects : T == val objects : List<T>
class KtBase43<T> (vararg val objects : T,var isMap : Boolean){//out T只能被读取，不能被修改val objectArray : Array<out T> = objectsfun showObj(index : Int) : T? = objectArray[index].takeIf { isMap } /* objectArray[index] */fun <O> mapObj(index: Int,mapAction : (T?) -> O) = mapAction(objectArray[index].takeIf { isMap })
}//todo vararg关键字(动态参数)
fun main() {//由于使用了太多的混合类型，所以使用Any?val p : KtBase43<Any?> = KtBase43("paul",12232,false,null,33.2,12.3f,isMap = true)println(p.showObj(0))println(p.showObj(1))println(p.showObj(2))println(p.showObj(3))println(p.showObj(4))println(p.showObj(5))val r : Int =p.mapObj(0){it.toString().length}println("第0个元素的字符串长度是：$r")val r1 : String = p.mapObj(1){"第1个元素是:$it"}println(r1)
}

10.运算符重载

class KtBase44 <INPUT> (vararg objects : INPUT,private val isR : Boolean = true){private val objectArray : Array<out INPUT> = objects//五种返回类型变化fun getR1() : Array<out INPUT>? = objectArray.takeIf { isR }//有可能是Array<out INPUT>，也有可能是String，用Any代替fun getR2() : Any = objectArray.takeIf { isR } ?: "是null"//有可能是Array<out INPUT>，有可能是String，也有可能是null，用Any?代替fun getR3() : Any? = objectArray.takeIf { isR } ?:"是null" ?:nullfun getR4(index : Int) : INPUT? = objectArray[index].takeIf { isR } ?: nullfun getR5(index: Int) : Any? = objectArray[index].takeIf { isR } ?:"张三" ?:123 ?:'k' ?:null//todo 运算符重载operator fun get(index : Int) : INPUT ? =objectArray[index].takeIf { isR }
}fun <INPUT> inputObj (item : INPUT) {//泛型有很大的类型范围，可以接受很多类型，也可以接受null，但接收null要处理好//String? 可以接收字符串也可以接受null，要比String功能强大//小结：异步处理泛型接收，都用String?处理if(item is String?){println((item as String?)?.length ?: "传递的值为null")}else if(item is Int?){println((item as Int?)?.toString()?.length ?: "传递的值为null")}
}fun main() {inputObj("张三")inputObj(123)inputObj(null)//todo []操作符学习val p : KtBase44<String?> = KtBase44("张三","李四",null)println(p[0])println(p[1])println(p[2])
}

Kotlin语言学习笔记相关推荐

1. 梓益C语言学习笔记之链表＆动态内存＆文件

   梓益C语言学习笔记之链表&动态内存&文件 一.定义: 链表是一种物理存储上非连续,通过指针链接次序,实现的一种线性存储结构. 二.特点: 链表由一系列节点(链表中每一个元素称为节点)组 ...

2. 6.方法(go语言学习笔记)

   6.方法(go语言学习笔记) 目录 定义 匿名字段 方法集 表达式 1. 定义 方法是与对象实例绑定的特殊函数. 方法是面向对象编程的基本概念,用于维护和展示对象的自身状态.对象是内敛的,每个实例对象 ...

3. 梓益C语言学习笔记之指针

   梓益C语言学习笔记之指针 一.32位平台下,地址是32位,所以指针变量占32位,共4个字节 二.内存单元的地址即为指针,存放指针的变量称为指针变量,故:"指针"是指地址,是常量,& ...

4. c语言中void arrout,c语言学习笔记(数组、函数

   <c语言学习笔记(数组.函数>由会员分享,可在线阅读,更多相关<c语言学习笔记(数组.函数(53页珍藏版)>请在人人文库网上搜索. 1.数组2010-3-29 22:40一维数 ...

5. c语言float二进制输出代码_C语言学习笔记——学前知识概述

   将我大一学习C语言时做的笔记拿来与大家分享,内容比较浅显,比较适合初学者,如有错误还请见谅,提出改正,谢谢! 前言:此C语言笔记是本人在自学时记录的一些重点或初学者常犯的错误,希望我的这本笔记能够对大 ...

6. c语言学习笔记【结构体02】结构体指针变量与结构体变量的函数参数,C语言学习笔记结构体02结构体指针变量与结构体变量的函数参数.docx...

   C 语言学习笔记[结构体02]结构体指针变量与结构体变量 的函数参数 C 语言学习笔记之结构体指针变量一提指针,那可 是 C 语言的核心了,有多少学子曾拜倒在指针的脚下.单纯的说指针,其实并不难,但是 ...

7. C语言学习笔记---001C语言的介绍,编译过程原理,工具等

   C语言学习笔记---001C语言的介绍,编译过程原理,工具等 创梦技术交流平台:资源下载,技术交流,网络赚钱: 交流qq群:1群:248318056 2群:251572072 技术交流平台:cre.i ...

8. go get 拉取指定版本_go语言学习笔记-基础知识-3

   相关文档 go语言学习笔记-目录 1.简介 1.1 什么是GO Go 是一个开源的编程语言,它能让构造简单.可靠且高效的软件变得容易.Go是从2007年末由Robert Griesemer, Rob ...

9. 安装成功配置环境变量_go语言学习笔记-Windows10开发环境安装和环境变量配置

   相关文档 go语言学习笔记-目录 1.安装 1.1.访问 https://golang.google.cn/dl/ 或 https://golang.org/dl/ 下载官方安装包 1.2.选择Win ...

最新文章

1. java and asp.net
2. CodeSmith 破解和注册
3. springBoot 项目 jar/war打包 并运行
4. 【网址收藏】k8s中helm方式安装postgresql及pgadmin
5. boost::statechart模块实现无效结果分配测试
6. python怎么安装bokeh_python怎么安装bokeh
7. leetcode 674. 最长连续递增序列
8. linux下安装phantomjs
9. android java 调用js_Android Java/JS互相调用
10. 谷歌浏览器中打开IE
11. 猜数字游戏（Java）
12. zlib、libzip、 libzippp 库编译(windows + cmake + vs2013)
13. Spring 的 ApplicationEvent and ApplicationListener
14. 友元(友元函数、友元类和友元成员函数) C++
15. 扩展欧几里得算法的证明
16. git 下载指定历史版本
17. 效率是绳，质量是命！——浅析如何运用UML来提高手游团队的绳命质量
18. Burp Proxy
19. App Store 内购项目配置
20. envoy实现_使用Envoy实现一键部署项目

热门文章

1. Nginx代理mysql端口
2. 程序员表白html倒计时,火热的程序员表白方式，调皮弹窗表白代码，赶紧拿去试试吧...
3. 白鹭引擎加密算法 - XXTEA -typescript
4. python处理大数据的库
5. 网页php载入live2d,给网页添加Live2D和图片不显示解决方法
6. 关于三菱GXWORK安装失败或者安装向导被中断的解决办法
7. NoMachine 输入用户名密码后 闪断 解决办法
8. (经典)瑾此献给1975-1989年出生的人(看后请顶)
9. 创建vue 项目的具体步骤
10. 金蝶星瀚人力云vs北森iTalentX 5.0，HR SaaS下半场如何开启？