Kotlin 函数、扩展函数

###  with函数

     with函数用于对同一个对象执行多次操作而不需要反复把对象的名称写出来

 fun main(args: Array<String>) {
        val result = StringBuilder()
        result.append("yyy")
        result.append("\n")
        for (letter in 'A'..'Z') {
            result.append(letter)
        }
        println(result.toString())
    }
改为通过 with 函数来构建
    val result = with(StringBuilder()) {
        append("yyy")
        append("\n")
        for (letter in 'A'..'Z') {
            append(letter)
        }
        toString()
    }
    println(result)

    with 结构其实是一个接受两个参数的函数，一个 StringBuilder 和一个 Lambda 表达式，with 函数的返回值是执行 Lambda 表达式的结果，该结果就是 Lambda 中的最后一个表达式的返回值，因为 println() 方法无返回值， 所以打印出来的内容将是 kotlin.Unit

	val result = with(StringBuilder()) {
        append("yyy")
        append("\n")
        for (letter in 'A'..'Z') {
            append(letter)
        }
        println("Hello")
    }
    println(result)  //kotlin.Unit

### apply函数

    apply函数始终会返回作为实参传递给它的对象

    val result = StringBuilder().apply {
        append("yyy")
        append("\n")
        for (letter in 'A'..'Z') {
            append(letter)
        }
        toString()
    }
    println(result)
    println(result.javaClass) //class java.lang.StringBuilder

###  内联函数

    inline fun <T> with(t: T,   body: T.() -> Unit) { t.body() }

    这个函数接收一个 T 类型的对象和一个被作为扩展函数的函数。让这个对象去执行这个函数，第二个参数是一个函数，所以我们可以把它放在圆括号外面，

    内联函数与普通的函数有点不同

    一个内联函数会在编译的时候被替换掉，而不是真正的方法调用。 这在一些情况下可以减少内存分配和运行时开销。

    inline fun supportsLollipop(code: () -> Unit) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            code()
        }
    }
调用
    supportsLollipop {
        window.setStatusBarColor(Color.BLACK)
    }

###  自定义访问器

 class Point(val x: Int, val y: Int) {
    
        val isEquals1: Boolean
            get() {
                return x == y
            }
    
        val isEquals2
            get() = x == y
    
        var isEquals3 = false
            get() = x > y
            set(value) {
                field = !value
            }
    
    }

### 扩展函数

    扩展函数用于为一个类增加一种新的行为，展函数的用途就类似于在 Java 中实现的静态工具方法。在 Kotlin 中使用扩展函数的优势就是不需要在调用方法时把整个对象当作参数传递，和在类内部定义的方法不同的是，扩展函数不能访问私有的或是受保护的成员。

    Kotlin 的方法扩展并不是真正修改了对应的类文件，而是在编译器和 IDE方面做了处理。使我们看起来像是扩展了方法。

    //为 String 类声明一个扩展函数 lastChar() ，用于返回字符串的最后一个字符
    //get方法是 String 类的内部方法，length 是 String 类的内部成员变量，在此处可以直接调用
    fun String.lastChar() = get(length - 1)
    
    //为 Int 类声明一个扩展函数 doubleValue() ，用于返回其两倍值
    //this 关键字代表了 Int 值本身
    fun Int.doubleValue() = this * 2
调用：
    fun main(args: Array<String>) {
        val name = "yyy"
        println("lastChar is: " + name.lastChar())
    
        val age = 24
        println(" doubleValue is: " + age.doubleValue())
    }


        fun FragmentActivity.toast(message: CharSequence,duration: Int = Toast.LENGTH_SHORT) {
            Toast.makeText(this, message, duration).show()
        }
		this.toast("拓展函数")

### 扩展属性

    //扩展函数也可以用于属性为 String 类新增一个属性值 customLen
    var String.customLen: Int
        get() = length
        set(value) {
            println("set")
        }
    
    fun main(args: Array<String>) {
        val name = "leavesC"
        println(name.customLen)
        name.customLen = 10
        println(name.customLen)
        //7
        //set
        //7
    }

### 不能重写扩展函数

    fun main(args: Array<String>) {
        val view: View = Button()
        view.click() //Button clicked
    }
    
    open class View {
        open fun click() = println("View clicked")
    }
    
    class Button : View() {
        override fun click() = println("Button clicked")
    }

    对于扩展函数来说，一个类的成员函数和扩展函数有相同的签名，成员函数会被优先使用 ，扩展函数并不是真正地修改了原来的类，其底层其实是以静态导入的方式来实现的。

   class Android{
    
        //扩展函数
        fun String.lastChar(): Char = this.get(this.length - 1)
    
        //拓展属性
        val String.lastChar: Char
            get() = get(length - 1)
    
        fun testFunExtension() {
            val str = "test extension fun"
            println(str.lastChar())
    
            val s = "abc"
            println(s.lastChar)
        }
    }
    
    
    //转化为java代码
    public final class Android {
       public final char lastChar(@NotNull String $receiver) {
          Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
          return $receiver.charAt($receiver.length() - 1);
       }
    
       public final char getLastChar(@NotNull String $receiver) {
          Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
          return $receiver.charAt($receiver.length() - 1);
       }
    
       public final void testFunExtension() {
          String str = "test extension fun";
          char var2 = this.lastChar(str);
          System.out.println(var2);
          String s = "abc";
          char var3 = this.getLastChar(s);
          System.out.println(var3);
       }
    }