Kotlin语法-Day6

1.1 定义类和field关键字

//TODO Kotlin语言中的定义类和field关键字学习
/*
*
* */
class KtBase50{
    //修改set get方法
    var name:String = ""
        get()=field.capitalize() //
        set(value) {
            field="$value]888"
         }
    /*背后的事情

          private String name=""

          public void setName(String name){
                this.name="%s"+"]888"
          }
          public String getName(){
                return StringKT.capitalize(this.name)
          }

     */
}
fun main() {
    //背后的操作  var s=new KtBase50
    var s= KtBase50()
    //s.setName("lisi)
    s.name="lisi"
    //System.out.println(s.getName())
    println(s.name)
}

var变量有set、get方法
val变量只有get方法

---

1.2 主构造函数

//TODO Kotlin语言中的主构造函数
/*
*
* */
//  主构造函数：规范来说，都是增加_xxx的方式，临时的输入类型，不能直接用，需要接收下来 成为变量才能用
class KtBase51 (_name:String,_sex:Char,_age:Int,_info:String){

    var name=_name

    val sex=_sex

    var age=_age
     get() = field+1
    val info=_info
        get() = "【$field】"
    fun show(){
        println(name)
        println(sex)
        println(age)
        println(info)
    }
}
fun main() {
    var p = KtBase51("张三", 'M', 20, "正在学习KT")
    p.show()
    //p.sex=""   //Val cannot be reassigned           val为只读没有set方法
}

---

1.3 次构造函数

//TODO Kotlin语言中的次构造函数
/*
*
* */
class KtBase52(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() {
    KtBase52("测试")   //主构造函数

    KtBase52("张三",'男')   //调用两个参数的次构造函数
    KtBase52("张三",'男',20)   //调用三个个参数的次构造函数
    KtBase52("张三",'男',20,"还在学习kt语言")   //调用四个参数的次构造函数

}

---

1.4 初始化代码块

//TODO Kotlin语言中的初始化代码块
/*
* 1.name,age,sex的主构造函数
* 2.init代码块学习
* 3。临时类型只有在  init代码块才能调用
* */
class KtBase53(name:String,age:Int,sex:Char){ //主构造

    //初始化块  init代码块
    //相当于java的构造代码块
    init {
        println("主构造函数被调用了 $name,$age,$sex")
    }
    constructor(name:String):this(name,20,'男'){
        println("次构造函数被调用了")
    }
}

fun main() {
        KtBase53("韩寒",23,'男')   //调用主构造
        println()
        KtBase53("微凉")      //调用次构造
}

---

1.5 延迟初始化lateinit

//TODO Kotlin语言中的延迟初始化lateinit
/*
*
* */
class KtBase54{
    lateinit var responseResultInfo:String   //先定义  一会再来初始化，所以没有赋值

    fun loadRequest(){
        responseResultInfo="服务器加载成功，恭喜你"
    }
    fun showResponseResult(){
        //由于你没有初始化，所以只要用这个变量就会崩溃
        //Exception in thread "main" kotlin.UninitializedPropertyAccessException:
        // lateinit property responseResultInfo has not been initialized
        //if (responseResultInfo==null) println()
        println("responseResultInfo: $responseResultInfo")
    }
}
fun main() {
    var a = KtBase54()

    //使用之前，加载一下（用到它才加载，懒汉式）
    a.loadRequest()

    //使用
    a.showResponseResult()
}

---

1.6 惰性初始化by lazy

1.6.1普通方式

直接加载 （饿汉式）

//TODO Kotlin语言中的by lazy
/*
*
* lateinit 是在使用的时候，手动加载的懒加载方式，然后再使用
* 惰性初始化by lazy 是在使用的时候，自动加载的懒加载方式
* */
class KtBase55 {
    //>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy     普通方式(饿汉式)
    val databaseData1:String =readSQLServerDatabaseAction()


    //>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy

   // val databaseData2 by lazy { readSQLServerDatabaseAction() }
    private fun readSQLServerDatabaseAction() :String{
        println("开始读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("结束读取数据库数据中。。。。")
        return "data  load  success ok"
    }
}
fun main() {
    //>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy     普通方式
    val  p=KtBase55()

    Thread.sleep(5000)

    println("即将开始使用")
    println("最终显示：${p.databaseData1}")


    //>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy


//    val  p=KtBase55()
//
//    Thread.sleep(5000)
//
//    println("即将开始使用")
//    println("最终显示：${p.databaseData2}")
}

1.6.2 by lazy方式

使用时才加载 （懒汉式）

//TODO Kotlin语言中的by lazy
/*
*
* lateinit 是在使用的时候，手动加载的懒加载方式，然后再使用
* 惰性初始化by lazy 是在使用的时候，自动加载的懒加载方式
* */
class KtBase55 {
    //>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy     普通方式(饿汉式)
   // val databaseData1:String =readSQLServerDatabaseAction()


    //>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy

    val databaseData2 by lazy { readSQLServerDatabaseAction() }
    private fun readSQLServerDatabaseAction() :String{
        println("开始读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("加载读取数据库数据中。。。。")
        println("结束读取数据库数据中。。。。")
        return "data  load  success ok"
    }
}
fun main() {
    //>>>>>>>>>>>>>>>>>>>>>>>>>>下面是不使用惰性初始化 by lazy     普通方式
//    val  p=KtBase55()
//
//    Thread.sleep(5000)
//
//    println("即将开始使用")
//    println("最终显示：${p.databaseData1}")


    //>>>>>>>>>>>>>>>>>>>>>>>>>>使用惰性初始化 by lazy


    val  p=KtBase55()

    Thread.sleep(5000)

    println("即将开始使用")
    println("最终显示：${p.databaseData2}")
}

---

1.7 类的继承与重载

//TODO Kotlin语言中的继承与重载
/*
*
* */
//所有的类，默认都是final修饰的，不能被继承  需要open关键字
open class Person(val name:String){
    open fun showName()="父类  人的姓名是【${name}】"

    //所有的函数，默认都是final修饰的，不能被继承  需要open关键字
    open fun myPrintln()= println(showName())
}
class Student(val stuname:String):Person(stuname){
    override fun showName()="子类  人的姓名是【${stuname}】"

    override fun myPrintln()= println(showName())
}
fun main() {
    val person:Person =Student("张三")
    person.myPrintln()
}

---

1.8 类型转换

//TODO Kotlin语言中的类型转换
/*
*
* 1.普通运行子类输出
* 2.is Person Student
* 3.is + as 转换
* */
//所有的类，默认都是final修饰的，不能被继承  需要open关键字
open class Person2(val name:String){
    open fun showName()="父类  人的姓名是【${name}】"

    //所有的函数，默认都是final修饰的，不能被继承  需要open关键字
    open fun myPrintln()= println(showName())
}
class Student2(val stuname:String):Person2(stuname){
     fun showName2()="子类  人的姓名是【${stuname}】"

    override fun myPrintln()= println(showName2())
}
fun main() {
    val person: Person2 =Student2("王五")
    person.myPrintln()

    println(person is Person2)
    println(person is Student2)


    //is + as
    if (person is Student2){
        (person as Student2).myPrintln()
    }

    if (person is Person2){
        println((person as Person2).showName())
    }
}

---