Kotlin基础学习10

目录

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

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

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

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

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

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

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

8.Kotlin语言的继承与重载的open关键字学习

9.Kotlin语言的类型转换学习

10.Kotlin语言的智能类型转换学习

---

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

//username: String ,userage:Int , usersex :Char 临时类型 必须要二次转换才能用
class KtBase75(username: String ,userage: Int , usersex : Char) //主构造
{
    //这个不是java的static{}
    //这个相当于java的{} 构造代码块
    //初始化块 init代码块
    init {
        println("主构造函数被调用了 $username,$userage,$usersex")
        //如果第一个参数是false，就会调用第二个参数的lambda
        //判断name是不是空值，isNotBlank ""
        require(username.isNotBlank()){ "你的username空空如也，抛出异常" }
        require(userage > 0){
            "你的userage年龄不符合，异常抛出"
        }
        require( usersex == '男' || usersex == '女'){
            println("你的性别很奇怪了，异常抛出")
        }
    }
    constructor(username: String) : this(username,87,'男'){
        println("次构造函数被调用了")
    }

}

// TODO 76 Kotlin语言的初始化块学习
// 1.name,age,sex的主构造函数
// 2.init代码块学习 require
// 3.临时类型只有在 init 代码块才能调用
fun main() {
    KtBase75("张三",22, '男') //调用主构造
    println()
    KtBase75("李四") //调用次构造
    //KtBase75("") //调用次构造
    //KtBase75("张三",-1,'男') //调用主构造
}

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

//第一步 ：生成val sex :Char
class KtBase76(_name : String ,val sex :Char) //主构造
{
    //第二步：生成val name //由于它写在init代码块前面，所以先生成这个。其实它是和init代码块同时进行的
    val name = _name
    init {
        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")
    }
    //第四步
    val bxb = "AAA"
}

// TODO 76 Kotlin语言的构造初始化顺序学习
//1.main调用次构造 name sex age
//2.主构造的val 变量
//3.nameValue = _name
//4.init{nameValue 打印}
fun main() {
    KtBase76("bxb",'男',22)
}

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

class KtBase77
{
    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 77 Kotlin语言的延迟初始化lateinit学习
//1.lateinit responseResultInfo 定义
//2.request 懒加载
//3.showResponseResult
//4.main 先请求 再显示
fun main() {
    val p = KtBase77()
    //使用它之前，加载一下（用到它才加载，就属于，懒加载）
    p.loadRequest()
    //使用它
    p.showResponseResult()
}

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

class KtBase78
{
    //>>>>>>>>>>>下面是 不使用惰性初始化 by lazy 普通方式（饿汉式 没有任何懒加载的特点）
    //val databaseData1 = readSQLServerDatabaseAction()
    //>>>>>>>>>>>使用惰性初始化by lazy 普通方式
    val databaseData2 by lazy { readSQLServerDatabaseAction() }
    private fun readSQLServerDatabaseAction():String{
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("开始读取数据库中....")
        println("结束读取数据库中....")
        return "database data load success ok"
    }
}

// TODO 78 Kotlin语言的惰性初始化by lazy学习
fun main() {
    //>>>>>>>>>下面是 不使用惰性初始化by lazy 普通方式（饿汉式 没有任何懒加载的特点）
//    val p = KtBase78()
//    Thread.sleep(5000)
//    println("即将开始使用")
//    println("最终显示：${p.databaseData1}")
    val p = KtBase78()
    Thread.sleep(5000)
    println("即将开始使用")
    println("最终显示：${p.databaseData2}")
}

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

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

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

class KtBase80{
    val info : String
    init {
        info = "Bxb"
        getInfoMethod()
    }

    fun getInfoMethod() {
        println("info:${info[0]}")
    }
}
// TODO 81 Kotlin语言的初始化陷阱二学习
fun main() {
    KtBase80()
}

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

class KtBase81(_info:String){
    private val info = _info
    val content : String = getInfoMethod()
    private fun getInfoMethod() = info
}
// TODO 81 Kotlin语言的初始化陷阱三学习
fun main() {
    println("内容的长度是：${KtBase81("Bxb").content.length}")
}

8.Kotlin语言的继承与重载的open关键字学习

//KT所有的类，默认是final修饰的，不能被继承，和java相反
//open ： 移除final修饰
open class Person(private val name : String){
    private fun showName() = "父类的姓名是：【${name}】"
    //KT所有的函数，默认是final修饰的，不能被继承，和java相反
    open fun myPrintln() = println(showName())
}
class Student(private val subName : String) : Person(subName){
    private fun showName() = "子类的姓名是：【${subName}】"
    override fun myPrintln() = println(showName())
}
// TODO 82.Kotlin语言的继承与重载的open关键字学习
fun main(){
    val person : Person = Student("张三")
    person.myPrintln()
}

9.Kotlin语言的类型转换学习

import java.io.File

//KT所有的类，默认是final修饰的，不能被继承，和java相反
//open ： 移除final修饰
open class Person2(private val name : String){
    fun showName() = "父类的姓名是：【${name}】"
    //KT所有的函数，默认是final修饰的，不能被继承，和java相反
    open fun myPrintln() = println(showName())
}
class Student2(private val subName : String) : Person2(subName){
    fun showName2() = "子类的姓名是：【${subName}】"
    override fun myPrintln() = println(showName2())
}
// TODO 83.Kotlin语言的类型转换学习
fun main(){
    val p : Person2 = Student2("张三三")
    p.myPrintln()
    println(p is Person2)
    println(p is Student2)
    println(p is File)
    //is + as 一般是配合一起使用
    if (p is Student2){
        (p as Student2).myPrintln()
    }
    if (p is Person2){
        println((p as Person2).showName())
    }
}

10.Kotlin语言的智能类型转换学习

//KT所有的类，默认是final修饰的，不能被继承，和java相反
//open ： 移除final修饰
open class Person3(val name : String){
    private fun showName() = "父类显示：【${name}】"
    open fun myPrintln() = println(showName())
    fun methodPerson() = println("我是父类的方法...") //父类独有的函数
}
class Student3(val nameSub : String) : Person3(nameSub){
    override fun myPrintln() = println("子类的显示：【${nameSub}】")
    fun methodStudent() = println("我是子类的方法...")
}
// TODO 84.Kotlin语言的智能类型转换学习
fun main(){
    val p : Person3 = Student3("张三三")
    println(p.myPrintln())
    (p as Student3).methodStudent()
    println(p.myPrintln())
    p.methodStudent()
    p.methodStudent()
    //智能类型转换：根据上面as转成的类型，自动明白，你现在的类型就是上面的类型
}