Kotlin基础-扩展函数

目录

一、认识

二、扩展方法

1、普通类的扩展

2、泛型类的扩展

三、扩展属性 

1、kotlin里的属性扩展

2、在Java中使用Koltin的扩展属性

四、伴生对象的扩展

五、常见的扩展函数

1、run

2、apply

3、let

六：案例：为Activity扩展findViewById方法

七：案例：四则运算

---

一、认识

     Koltin的扩展函数，能够使你扩展一个类的新功能而无需继承的方式，例如，你可以为一个你不

能修改的来自第三方库中的某个类编写扩展，这个新增的函数就像那个原始类里本来有的函数一

样，可以用普通方法调用，除此，还有属性扩展，常见的扩展函数。

二、扩展方法

    对一个类进行方法扩展，只需要在方法声明时，在函数名前加上类名.

如:表示对String类进行求取最后一个字符的方法扩展，类的方法扩展应在类本体之外

fun String.lastChar(str:String):Char{



}

1、普通类的扩展

fun main() {
    val a :Char=  OpenString().lastChar("abc")
    println(a)
}


fun OpenString.lastChar(str:String):Char{
    if(str.isEmpty()){
        throw Exception("this String an illegal")
    }
    return  str[str.length-1]
}

open class  OpenString{

    fun test(){
        println("test")
    }

}

在Java中使用Kotlin扩展，通过文件名+Kt.函数名(扩展类的对象，完整的其他参数)来在 Java 中调用扩展函数（相当于调用工具类的静态方法）,比如在test.java中：

public class test {

    public static void main(String[] args) {
        char lastChar = BaseDataTypeKt.lastChar(new OpenString(),"hello world");
        System.out.printf(String.valueOf(lastChar));
    }

}

2、泛型类的扩展

fun main() {
    val  list = mutableListOf<String>("android","kotlin","java")
    list.swap(0,1)

    list.forEach {
        println(it)
    }
}

fun <T> MutableList<T>.swap(index: Int,index1: Int){
    val temp:T = this[index1]
    this[index1] = this[index]
    this[index] = temp
}

kotlin
android
java

三、扩展属性 

1、kotlin里的属性扩展

比如，对String类进行求取首个字符

fun main() {
    val str = "android"
    println(str.firstChar)

    val array :ArrayList<Int> = arrayListOf(1,2,3,4,5)
    println(array.lastItem)

}


val String.firstChar:Char get() = this[0]

val <T> List<T>.lastItem:T get() = this[size-1]

2、在Java中使用Koltin的扩展属性

在Java中，获取Kotlin的扩展属性，使用类名KT.get扩展属性(参数)

    public static void main(String[] args) {
        char lastChar = BaseDataTypeKt.getFirstChar("hello world");
        System.out.printf(String.valueOf(lastChar));
    }

四、伴生对象的扩展

如果一个类定义了伴生对象，也可以对伴生对象进行属性和方法扩展

fun main() {
    val studentA =  Student.search("lisi")
    println(studentA)

    val height = Student.height
    println(height)

}

class Student{
    companion object{

    }
}


fun Student.Companion.search(name:String):String{
    return name
}

val Student.Companion.height:Int get() = 100

lisi
100

五、常见的扩展函数

1、run

run函数是对一个类的实例，进行扩展，在run方法里，可以直接访问一个类的公有实例或方法，

什么是公有的属性或方法，就是非private/protected修饰的。第二，run方法是有返回值的，以最后

一条语句结束，或者以return结束。

fun main() {
    val result = test(Tree())
    println("this tree have $result leaf.")
    method(Tree())
}


fun test(tree: Tree):Int{
    tree.run {
        return leaf
    }
}

fun method(tree: Tree):Unit{
    tree.run {
        grow()
    }
}

class Tree{

    val leaf = 2

    fun grow():Unit{
      println("this tree growing")
    }
}

2、apply

apple扩展函数是一个作用域函数，调用某对象的apply函数，可以在作用域内，调用该对象的任意方法，并且返回该对象。apply和run函数很相像，区别就是run返回的是值，而apply返回的是对象

fun main() {
    ArrayList<Int>().apply {
        this.add(1)
        this.add(2)
        this.add(3)
    }.run {
        for (i in this) {
            println(i)
        }
    }
}

3、let

let扩展函数是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内时，就可以用

let，除此，let还有一个作用就是属性判null。

fun main() {

  val a = 3

    //作用域
    a.let {
        val b = a+2
        println(b)
    }

     //判null
    val c:String? = null
    c?.let {
        println(c.length)
    }
}

六：案例：为Activity扩展findViewById方法

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        R.id.btn_test.onClick(this){
            println("click btn_test")
        }

    }


}

 private fun Int.onClick(activity: Activity, function: () -> Unit) {
          activity.findViewById<View>(this).setOnClickListener {
              function() 
          }
}

七：案例：四则运算

//四则运算
fun main() {
    while (true) {
        println("=============请输入你的表达式=============")
        val input = readLine()
        try {
            input?.let {
                val ret = calculate(input)
                println("{$input}={$ret}")
                println("=============是否继续使用(y/n)=============")
                val cmd = readLine()
                cmd?.let {
                    if (cmd == "n")
                        exitProcess(0)
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
}




fun calculate(input: String): String {
    val add = "+"
    val sub = "-"
    val mul = "*"
    val eli = "/"

    if (input.contains(add)) {
        val nums = input.trim().split(add)
        return operate(nums[0].toDouble(), nums[1].toDouble(), add).toString()
    } else if (input.contains(sub)) {
        val nums = input.trim().split(sub)
        return operate(nums[0].toDouble(), nums[1].toDouble(), sub).toString()
    } else if (input.contains(eli)) {
        val nums = input.trim().split(eli)
        return operate(nums[0].toDouble(), nums[1].toDouble(), eli).toString()
    } else if (input.contains(mul)) {
        val nums = input.trim().split(mul)
        return operate(nums[0].toDouble(), nums[1].toDouble(), mul).toString()
    }
    return "计算有误"
}

fun operate(s: Double, s1: Double, s2: String): Double {
   return when (s2) {
        "+" -> s + s1
        "-" -> s - s1
        "/" -> s / s1
        "*" -> s * s1
       else -> {0.0}
   }

}