可怕！從簡潔高效的角度來說，Kotlin比Java強太多了吧！難道Java真的要被替代了？

這裏分享9個Kotlin比Java高效的tips。以下文章是在使用Kotlin寫過幾個項目，在對Kotlin有了一些基礎後總結出來的，比較適合對於Kotlin有一定基礎，有所瞭解的小夥伴。。

Tip1- 更簡潔的字符串

如果要在Java中讓字符串嵌套需要轉義的字符，那無疑是一件非常非常痛苦的事！比如，當要想表示下面這個字符串時，你的代碼可能要寫成這樣：

public void testString() {
        String js = "function myFunction()\n" +
                "{\n" +
                "    document.getElementById(\"demo\").innerHTML=\"My First JavaScript Function\";\n" +
                "}";
        System.out.println(js);
}

而Kotlin呢？Kotlin引入了三引號”“”，三引號中可以包含反斜槓、換行等特殊字符。

fun testString() {
    val js = """
        function myFunction()
        {
            document.getElementById("demo").innerHTML="My First JavaScript Function";
        }
        """.trimIndent()
    println(js)
}

代碼是不是簡潔清晰了很多？
同時，Kotlin引入了字符串模板，方便字符串的拼接，可以用$符號拼接變量和表達式。

fun testString() {
    val strings = arrayListOf("abc", "efd", "gfg")
    println("First content is $strings")
    println("First content is ${strings[0]}")
    println("First content is ${if (strings.size > 0) strings[0] else "null"}")
}

Tip2- 更好調用的函數：顯式參數名/默認參數值

Kotlin中函數更加好調用，主要表現在兩方面：1、顯示地表示參數名；2、函數可以有默認參數值。這可以大大減少Java中函數的重載。

fun saySomething(somethingToSay:String = "hello",
                     isBadMan: Boolean = false,
                     isStranger: Boolean = false,
                     isMyHater: Boolean = false) {
    if(isBadMan) {
        System.out.println("you should work hard day by day")
        return
    } else if(isStranger) {
        System.out.println("nice to meet you")
        return
    } else if(isMyHater) {
        System.out.println("i hate you")
        return
    }
    System.out.println("$somethingToSay")
}
/*
* 測試
* */
fun main() {
    saySomething(isBadMan = true)//輸出you should work hard day by day
    saySomething("how are you")//輸出how are you
}

如上面的代碼，由於Kotlin可以指定參數值，還可以給參數默認值，減少了大量函數的重載。

Tip3- 利用局部函數抽取重複代碼

Kotlin中提供了函數的嵌套，在函數內部還可以定義新的函數。這樣代碼的層次性更強，可讀性也更強。

fun validateUser() {
    fun validate(value: String, fildName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("Can't save user $id: empty $fildName")
        }
    }

    validate(name, "Name")
    validate(address, "Address")
    validate(email, "Email")
}

Tip4- 使用數據類來快速實現model類

在java中要聲明一個model類需要實現很多的代碼，如下所示，

public class User implements Serializable {
        private String name;
        private int age;
        private int gender;
        private String address;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public int getGender() {
            return gender;
        }

        public void setGender(int gender) {
            this.gender = gender;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }
}

這段代碼用kotlin，只需要一行代碼就可以做到。

class User(val name: String, val age: Int, val gender: Int, var address: String)

Tip5- 用類委託來快速實現代理模式

Java中要想實現裝飾器模式：創建一個新類，實現與原始類一樣的接口並將原來的類的實例作爲一個成員變量。 與原始類擁有相同行爲的方法不用修改，只需要直接轉發給原始類的實例。如下所示

class CountingSet<T>(val innerSet: MutableCollection<T> = HashSet<T>()) : MutableCollection<T> {

    var objectAdded = 0

    override val size: Int
        get() = innerSet.size

    /*
    * 需要修改的方法
    * */
    override fun add(element: T): Boolean {
        objectAdded++
        return innerSet.add(element)
    }

    /*
    * 需要修改的方法
    * */
    override fun addAll(elements: Collection<T>): Boolean {
        objectAdded += elements.size
        return innerSet.addAll(elements)
    }

    override fun contains(element: T): Boolean {
        return innerSet.contains(element)
    }

    override fun containsAll(elements: Collection<T>): Boolean {
        return innerSet.containsAll(elements)
    }

    override fun isEmpty(): Boolean {
        return innerSet.isEmpty()
    }

    override fun clear() {
        innerSet.clear()
    }

    override fun iterator(): MutableIterator<T> {
        return innerSet.iterator()
    }

    override fun remove(element: T): Boolean {
        return innerSet.remove(element)
    }

    override fun removeAll(elements: Collection<T>): Boolean {
        return innerSet.removeAll(elements)
    }

    override fun retainAll(elements: Collection<T>): Boolean {
        return innerSet.retainAll(elements)
    }

}

如上所示，想要修改HashSet的某些行爲函數add和addAll，需要實現MutableCollection接口的所有方法，將這些方法轉發給innerSet去具體的實現。雖然只需要修改其中的兩個方法，其他代碼都是模版代碼。 只要是重複的模版代碼，Kotlin這種全新的語法糖就會想辦法將它放在編譯階段再去生成。 這時候可以用到類委託by關鍵字，如下所示：

class CountingSet2<T>(val innerSet: MutableCollection<T> = HashSet<T>()) : MutableCollection<T> by innerSet {

    var objectAdded = 0

    override fun add(element: T): Boolean {
        objectAdded++
        return innerSet.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        objectAdded += elements.size
        return innerSet.addAll(elements)
    }
}

Tip6- apply函數來簡化代碼

• apply 函數原型：

  inline fun T.apply(block: T.() -> Unit): T { block(); return this }

• apply函數，在函數範圍內，可以任意調用該對象的任意方法，並返回該對象

  fun testApply(context: Context) {
  var imgView = ImageView(context).apply {
      setBackgroundColor(0)
      setImageBitmap(null)
  }
  
  var textView = TextView(context).apply {
      text = "content"
      textSize = 20.0f
      setPadding(10, 0, 0, 0)
  }
  
  var user = User().apply { 
      age = 15
      name = "Jack"
      val a = address
      address = "bbb"
  }
  }

  通過apply後，在apply的大括號裏可以訪問類的公有屬性和方法。另外，在類實例化的時候，就可以通過apply把需要初始化的步驟全部實現，非常的簡潔。

Tip7- 用函數型變量來簡化回調

Java中定義一個回調需要寫很多冗餘代碼，包括定義一個接口，一個接口類型的成員變量。。。
被調用方：

調用方：

而Kotlin中變量可以是一個函數，所以定義回調非常簡潔直觀。

參考

https://github.com/heimashi/kotlin_tips#tip8–%E4%BD%BF%E7%94%A8%E6%95%B0%E6%8D%AE%E7%B1%BB%E6%9D%A5%E5%BF%AB%E9%80%9F%E5%AE%9E%E7%8E%B0model%E7%B1%BB
https://mp.weixin.qq.com/s/ylAZnOObrwtJDPqaK2ONLw