Kotlin语法-Day9

1.1 扩展函数

//TODO Kotlin语言中的扩展函数


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

//增加扩展函数
//KtBase74.xxx  xxx函数里面会持有this==KtBase74对象本身
fun KtBase74.show(){
    println("我是show函数，name：$name,age: $age,sex: $sex")
}

fun main() {
    val p = KtBase74("张安", 20, '女')
    p.show()
}

---

1.2 超类的扩展函数

//TODO Kotlin语言中的超类上定义扩展函数
/*
*
*       1.扩展函数不允许被重复定义
*       2.对超类扩展函数的影响
*       3.扩展函数，链式调用
* */
data class ResponseResult(val message:String,val code:Int)
fun Any.showPrintlnContent(){
    println("当前对象内容是：$this")
}
fun Any.showPrintlnContent2(): Any {
    println("这是方法二内容：$this")
    return this
}
fun main() {
    ResponseResult("login success",200).showPrintlnContent()

    println()
    //可以链式调用 类似于rxjava
    ResponseResult("login fail",-1).showPrintlnContent2().showPrintlnContent()

    println()
    val number:Int=898421
    number.showPrintlnContent()
}

---

1.3 泛型扩展函数

//TODO Kotlin语言中的泛型扩展函数
/*
*       1.String类型就输出长度
*       2.显示调用时间
*       3.显示调用者类型
* */

//       1.String类型就输出长度
fun <T> T.showContentInfo() = println(if (this is String) "你的字符串长度是：$length" else "你不是字符串 你的内容是：$this")

//       2.显示时间
fun <A> A.showTime()= println("你当前调用的时间是：${System.currentTimeMillis()}")

//       3.显示调用者类型
fun <C> C.showTypeAction() =
    when(this){
        is String -> "原来你是String类型"
        is Int ->"原来你是Int类型"
        is Char ->"原来你是Char类型"
        is Float ->"原来你是Float类型"
        is Double ->"原来你是Double类型"
        is Boolean ->"原来你是Boolean类型"
        else->"未知类型"
    }

fun test(){}
fun main() {
    111.showContentInfo()
    'c'.showContentInfo()
    false.showContentInfo()
    "Test".showContentInfo()
    test().showContentInfo()

    println()

    println(111.showTypeAction())
    println('c'.showTypeAction())
    println(false.showTypeAction())
    println(515.2f.showTypeAction())
    println(205.12.showTypeAction())
    println("Test".showTypeAction())

    'a'.showTime()
}

ps:

---

1.4 自定义内置函数扩展

//TODO Kotlin语言中的自定义内置函数
fun main() {
    "Test".mLet{

    }
    123.mLet{

    }
    'C'.mLet{

    }

}
//  private 私有化
//  inline  我们的函数是高阶函数，所以用到内联，做lambda的优化，性能提高
//  fun <I,O> 在函数中。声明两个泛型，函数泛型  I输入Input O输出Output
//  I.mLet  对I输入Input进行函数扩展，扩展函数的名称是mLet，意味着，所有的类型，万能类型，都可以用  xx.mLet
//  lambda :(I)->(O)  (I输入) ->(O输出)
//  lambda(this) I进行函数扩展，在整个扩展函数里面，this==I本身
private inline fun <I,O> I.mLet(lambda :(I)->(O))= lambda(this)

---

1.5 扩展属性

//TODO Kotlin语言中的扩展属性
/*
*
* */
// 打印输出 并且 链式调用（只有String有资格这样）
fun String.showPrintln():String{
    println("打印输出 并且 链式调用（只有String有资格这样）：内容$this")
    return  this
}

val String.stringAllInfoValue
    get() = "当前${System.currentTimeMillis()} 这个时间点被调用了一次，当前值是:$this,当前字符串长度是:$length"
fun main() {

    "Lisi测试".stringAllInfoValue.showPrintln()
}

---

1.6 可空类型函数扩展

//TODO Kotlin语言中的可空类型扩展函数

//如果是null，就输出默认值
fun String?.outputStringValueFun(defaultValue:String)= println(this ?:defaultValue)

fun main() {
        val infoValue :String?=null
        infoValue.outputStringValueFun("我是默认值")

        val name="张三"
        name.outputStringValueFun("我是默认值")
}

---

1.7 infix关键字

//TODO Kotlin语言中的中缀表达式
/*
*   自定义中缀表达式+扩展函数 一起用   使用者：”……“.gogogo 1
*   1.条件一  对第一个参数 C1.gogogo  函数扩展
*   2.条件二  需要在 括号（c2:C2）参数里面，传递一个参数
*
* */
private infix fun <C1,C2> C1.gogogo(c2: C2){
    println("中缀表达式，对第一个参数的内容是：$this")
    println("中缀表达式，对第二个参数的内容是：$c2")
}
//infix == 中缀表达式 可以简化我的代码
fun main() {
        //下面是我们自己写的中缀表达式
        123 gogogo '男'
        "Test1".gogogo ("Test2")
}

---

1.8 扩展文件

package com.example.kotlin_study.s3
//TODO Kotlin语言中的定义扩展文件

//  导入扩展文件
import com.example.kotlin_study.randomItemValue
import com.example.kotlin_study.randomItemValuePrintln

fun main() {

    val list: List<String> = listOf("张三","李四","王五")
    val set:Set<Int> = setOf(1,2,3,4);

    //如果不使用 扩展文件
    println(list.shuffled().first())
    println(set.shuffled().first())

    println()

    //使用 扩展文件
    println(list.randomItemValue())
    println(set.randomItemValue())

    println()

    list.randomItemValuePrintln()
    set.randomItemValuePrintln()
}

扩展文件单独写

package com.example.kotlin_study

// 1.扩展文件一般都是public，如果private外界无法使用
// 2.Iterable<E> 子类 set list 都可以用，所以用父类
// 3.本次扩展函数的作用是，随机取第一个元素返回
fun <E> Iterable<E>.randomItemValue()= this.shuffled().first()

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

---

1.9 重命名扩展

//  导入扩展文件
import com.example.kotlin_study.randomItemValue as rv
import com.example.kotlin_study.randomItemValuePrintln as rvp