1.1 請(qǐng)簡(jiǎn)述一下什么是 Kotlin？它有哪些特性？

kotlin和java一樣也是一門jvm語(yǔ)言最后的編譯結(jié)果都是.class文件,并且可以通過(guò)kotlin的.class文件反編譯回去java代碼,并且封裝了許多語(yǔ)法糖,其中我在項(xiàng)目中常用的特性有

• 擴(kuò)展,(使用非集成的方式 擴(kuò)張一個(gè)類的方法和變量):比方說(shuō) px和dp之間的轉(zhuǎn)換 之前可能需要寫個(gè)Util現(xiàn)在,通過(guò)擴(kuò)展Float的變量 最后調(diào)用的時(shí)候僅僅是 123.dp 這樣px轉(zhuǎn)成dp了
• lamdba表達(dá)式,函數(shù)式編程. lamdba表達(dá)式并不是kotlin的專利,java中也有,但是有限制, 像setOnClickListener一樣,接口方法只有一個(gè)的情況才能調(diào)用, 而在kotlin中對(duì)接口的lambda也是如此,有這樣的限制,但是他更推薦你使用閉包的方式而不是實(shí)現(xiàn)匿名接口的方式去實(shí)現(xiàn)這樣的功能,閉包對(duì)lambda沒(méi)有接口這么多的限制,另外就是函數(shù)式編程 在java8中提供了streamApi 對(duì)集合進(jìn)行map sort reduce等等操作,但是對(duì)android api有限制,為了兼容低版本,幾乎不可能使用streamApi
• 判空語(yǔ)法 省略了許多if xxx==null 的寫法 也避免了空指針異常aaa?.toString ?: "空空如也" 當(dāng)aaa為空的時(shí)候 它的值被"空空如也"替代

aaa?.let{
    it.bbb
}

當(dāng)aaa不為空時(shí) 執(zhí)行括號(hào)內(nèi)的方法

• 省略了findViewById ,使用kotlin 就可以直接用xml中定義的id 作為變量獲取到這個(gè)控件,有了這個(gè) butterknife就可以淘汰了,使用databinding也能做到,但是,非常遺憾,databinding的支持非常不好,每次修改視圖,都不能及時(shí)生成,經(jīng)常要rebulid才能生成.
• 默認(rèn)參數(shù) 減少方法重載 fun funName(a :Int ,b:Int = 123)通過(guò)如上寫法 實(shí)際在java中要定義兩個(gè)寫法 funName(a)和funName(a,b)
• kotlin無(wú)疑是android將來(lái)語(yǔ)言的趨勢(shì),我已經(jīng)使用kotlin一年了,不僅App工程中使用,而且封裝的組件庫(kù)也是用kotlin,另外說(shuō)明,kotlin會(huì)是apk大小在混淆后增加幾百k.但對(duì)于更舒適的代碼來(lái)說(shuō)這又算的了什么呢

1.2 Kotlin 中注解 @JvmOverloads 的作用？

@JvmOverloads注解的作用就是:在有默認(rèn)參數(shù)值的方法加上@JvmOverloads注解，則Kotlin就會(huì)暴露多個(gè)重載方法?？梢詼p少寫構(gòu)造方法。
例如：沒(méi)有加注解，默認(rèn)參數(shù)沒(méi)有起到任何作用。

fun f(a: String, b: Int = 0, c: String="abc"){
    ...
}
那相當(dāng)于在java中：
void f(String a, int b, String c){
}
如果加上注解@JvmOverloads ，默認(rèn)參數(shù)起到作用
@JvmOverloads
fun f(a: String, b: Int = 0, c: String="abc"){
    ...
}
相當(dāng)于Java中：
三個(gè)構(gòu)造方法，
void f(String a)
void f(String a, int b)
void f(String a, int b, String c)

1.3 Kotlin中List與MutableList的區(qū)別？

List 返回的是EmptyList，MutableList 返回的是一個(gè)ArrayList，查看EmptyList的源碼就知道了，根本就沒(méi)有提供 add 方法。

internal object EmptyList : List, Serializable, RandomAccess {
private const val serialVersionUID: Long = -7390468764508069838L
override fun equals(other: Any?): Boolean = other is List<*> && other.isEmpty()
override fun hashCode(): Int = 1
override fun toString(): String = "[]"
override val size: Int get() = 0
override fun isEmpty(): Boolean = true
override fun contains(element: Nothing):
Boolean = false
override fun containsAll(elements: Collection<Nothing>): Boolean = elements.isEmpty()
override fun get(index: Int): Nothing = throw IndexOutOfBoundsException("Empty list doesn't contain element at index $index.")
override fun indexOf(element: Nothing): Int = -1
override fun lastIndexOf(element: Nothing): Int = -1
override fun iterator(): Iterator<Nothing> = EmptyIterator
override fun listIterator(): ListIterator<Nothing> = EmptyIterator
override fun listIterator(index: Int): ListIterator<Nothing> {
    if (index != 0) throw IndexOutOfBoundsException("Index: $index")
        return EmptyIterator
}
override fun subList(fromIndex: Int, toIndex: Int): List<Nothing> {
    if (fromIndex == 0 && toIndex == 0) return this
    throw IndexOutOfBoundsException("fromIndex: $fromIndex, toIndex: $toIndex")
}
private fun readResolve(): Any = EmptyList

1.4 Kotlin中實(shí)現(xiàn)單例的幾種常見(jiàn)方式？

餓漢式：

object StateManagementHelper {
    fun init() {
        //do some initialization works
    }
}

懶漢式：

class StateManagementHelper private constructor() {
    companion object {
        private var instance: StateManagementHelper? = null
            @Synchronized get() {
                if (field == null) field = StateManagementHelper()
                return field
            }
    }
    fun init() {
        //do some initialization works
    }
}

雙重檢測(cè)：

class StateManagementHelper private constructor() {
    companion object {
        val instance: StateManagementHelper by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            StateManagementHelper()
        }
    }
    fun init() {
        //do some initialization works
    }
}

靜態(tài)內(nèi)部類：

class StateManagementHelper private constructor() {
    companion object {
        val INSTANCE = StateHelperHolder.holder
    }
    private object StateHelperHolder {
        val holder = StateManagementHelper()
    }
    fun init() {
        //do some initialization works
    }
}

1.5 談?wù)勀銓?duì)Kotlin中的 data 關(guān)鍵字的理解？相比于普通類有哪些特點(diǎn)？

在kotlin中數(shù)據(jù)類通過(guò)data關(guān)鍵字來(lái)修飾。

數(shù)據(jù)類需滿足的條件

• 主構(gòu)造器必須至少有一個(gè)參數(shù)
• 主構(gòu)造器中的參數(shù)需要用var/val聲明為屬性
• 數(shù)據(jù)類不能用abstract、open、sealed修飾，也不能定義成內(nèi)部類
• 數(shù)據(jù)類可以實(shí)現(xiàn)接口也可以繼承其他類

系統(tǒng)自動(dòng)為數(shù)據(jù)類生成哪些內(nèi)容

• 生成equals/hashCode的方法。
• 自動(dòng)重寫toString方法返回形如：”User(name=guojingbu,age=18)“的字符串
• 為每個(gè)屬性生成operator修飾的componentN()方法，來(lái)支持解構(gòu)。
• 生成copy()方法,方便完成對(duì)象復(fù)制。

示例代碼

系統(tǒng)生成方法代碼驗(yàn)證
數(shù)據(jù)類代碼如下：

data class Result(var code:Int,val msg:String)

反編譯后java代碼如下：

   private int code;
   @NotNull
   private final String msg;
    //...省略setter和getter方法
   public Result(int code, @NotNull String msg) {
      Intrinsics.checkNotNullParameter(msg, "msg");
      super();
      this.code = code;
      this.msg = msg;
   }
   public final int component1() {
      return this.code;
   }
   @NotNull
   public final String component2() {
      return this.msg;
   }
   @NotNull
   public final Result copy(int code, @NotNull String msg) {
      Intrinsics.checkNotNullParameter(msg, "msg");
      return new Result(code, msg);
   }
   @NotNull
   public String toString() {
      return "Result(code=" + this.code + ", msg=" + this.msg + ")";
   }
   public int hashCode() {
      int var10000 = this.code * 31;
      String var10001 = this.msg;
      return var10000 + (var10001 != null ? var10001.hashCode() : 0);
   }
   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof Result) {
            Result var2 = (Result)var1;
            if (this.code == var2.code && Intrinsics.areEqual(this.msg, var2.msg)) {
               return true;
            }
         }
         return false;
      } else {
         return true;
      }
   }

數(shù)據(jù)類可以繼承其他類代碼驗(yàn)證

open class Sup{}
interface Base{}
data class Result(var code:Int,val msg:String): Sup(),Base{}

如果想讓JVM為數(shù)據(jù)類生成一個(gè)無(wú)參構(gòu)造，那么數(shù)據(jù)類的主構(gòu)造中的參數(shù)必須都有默認(rèn)值，示例代碼如下：
數(shù)據(jù)類代碼：

data class Result(var code:Int=0,val msg:String=""){}

反編譯后生成的java代碼：

public final class Result {
    ...省略一些getter和setter方法
   public Result(int code, @NotNull String msg) {
      Intrinsics.checkNotNullParameter(msg, "msg");
      super();
      this.code = code;
      this.msg = msg;
   }
   // $FF: synthetic method
   public Result(int var1, String var2, int var3, DefaultConstructorMarker var4) {
      if ((var3 & 1) != 0) {
         var1 = 0;
      }
      if ((var3 & 2) != 0) {
         var2 = "";
      }
      this(var1, var2);
   }
   public Result() {
      this(0, (String)null, 3, (DefaultConstructorMarker)null);
   }
    ...省略不相關(guān)代碼
}

可以看到上的代碼JVM會(huì)為數(shù)據(jù)類生成一個(gè)沒(méi)有參數(shù)的構(gòu)造器。

1.6 什么是委托屬性？請(qǐng)簡(jiǎn)要說(shuō)說(shuō)其使用場(chǎng)景和原理？

屬性委托

有些常見(jiàn)的屬性操作，我們可以通過(guò)委托方式，讓它實(shí)現(xiàn)，例如:

• lazy 延遲屬性：值只在第一次訪問(wèn)的時(shí)候計(jì)算
• observable 可觀察屬性：屬性發(fā)生改變時(shí)通知
• map 集合：將屬性存在一個(gè)map集合里面

類委托

• 可以通過(guò)類委托來(lái)減少 extend
• 類委托的時(shí)，編譯器會(huì)優(yōu)先使用自身重寫的函數(shù)，而不是委托對(duì)象的函數(shù)

interface Base{
    fun print()
}
class BaseImpl(var x: Int):Base{
    override fun print(){
        print(x)
    }
}
// Derived 的 print 實(shí)現(xiàn)會(huì)通過(guò)構(gòu)造函數(shù)的b對(duì)象來(lái)完成
class Derived(b: Base): Base by b

1.7 請(qǐng)舉例說(shuō)明Kotlin中with與apply函數(shù)的應(yīng)用場(chǎng)景和區(qū)別？

• with 不怎么使用，因?yàn)樗_實(shí)不防空
• 經(jīng)常使用的是 run 和 apply

• run 閉包返回結(jié)果是閉包的執(zhí)行結(jié)果；apply 返回的是調(diào)用者本身。
• 使用上的差別：run 更傾向于做一些其他復(fù)雜邏輯操作，而 apply 更多的是對(duì)調(diào)用者自身配置。
• 大部分情況下，如果不是對(duì)調(diào)用者本身進(jìn)行設(shè)置，我會(huì)使用 run。

1.8 Kotlin中 Unit 類型的作用以及與Java中Void 的區(qū)別？

Unit : Kotlin 中Any的子類, 方法的返回類型為Unit時(shí)，可以省略；
Void：Java中的方法無(wú)法回類型時(shí)使用，但是不能省略；
Nothing：任何類型的子類，編譯器對(duì)其有優(yōu)化，有一定的推導(dǎo)能力，另外其常常和拋出異常一起使用；

1.9 Kotlin 中 infix 關(guān)鍵字的原理和使用場(chǎng)景？

使用場(chǎng)景是用來(lái)修飾函數(shù)，使用了 infix 關(guān)鍵字的函數(shù)稱為中綴函數(shù)，使用時(shí)可以省略 點(diǎn)表達(dá)式和括號(hào)。讓代碼看起來(lái)更加優(yōu)雅，更加語(yǔ)義化。
原理不過(guò)是編譯器在語(yǔ)法層面給與了支持，編譯為 Java 代碼后可以看到就是普通的函數(shù)調(diào)用。
kotlin 的很多特性都是在語(yǔ)法和編譯器上的優(yōu)化。

1.10 Kotlin中的可見(jiàn)性修飾符有哪些？相比于Java有什么區(qū)別？

kotlin存在四種可見(jiàn)性修飾符，默認(rèn)是public。 private、protected、internal、public

• private、protected、public是和java中的一樣的。
• 不同的是java中默認(rèn)是default修飾符（包可見(jiàn)），而kotlin存在internal修飾符（模塊內(nèi)部可見(jiàn)）。
• kotlin可以直接在文件頂級(jí)聲明方法、變量等。其中protected不能用來(lái)修飾在文件頂級(jí)聲明的類、方法、變量等。

構(gòu)造方法默認(rèn)是public修飾，可以使用可見(jiàn)性修飾符修飾constructor關(guān)鍵字來(lái)改變構(gòu)造方法的可見(jiàn)性。

1.11 你覺(jué)得Kotlin與Java混合開發(fā)時(shí)需要注意哪些問(wèn)題？

kotlin調(diào)用java的時(shí)候 如果java返回值可能為 null 那就必須加上@nullable 否則kotlin無(wú)法識(shí)別，也就不會(huì)強(qiáng)制你做非空處理，一旦java返回了 null 那么必定會(huì)出現(xiàn)null指針異常，加上@nullable 注解之后kotlin就能識(shí)別到j(luò)ava方法可能會(huì)返回null，編譯器就能會(huì)知道，并且強(qiáng)制你做非null處理，這也就是kotlin的空安全

1.12 在Kotlin中，何為解構(gòu)？該如何使用？

給一個(gè)包含N個(gè)組件函數(shù)（component）的對(duì)象分解為替換等于N個(gè)變量的功能，而實(shí)現(xiàn)這樣功能只需要一個(gè)表達(dá)式就可以了。

例如
有時(shí)把一個(gè)對(duì)象 解構(gòu) 成很多變量會(huì)很方便，例如:

val (name, age) = person

這種語(yǔ)法稱為 解構(gòu)聲明 。一個(gè)解構(gòu)聲明同時(shí)創(chuàng)建多個(gè)變量。 我們已經(jīng)聲明了兩個(gè)新變量： name 和 age，并且可以獨(dú)立使用它們：

println(name)
println(age)

一個(gè)解構(gòu)聲明會(huì)被編譯成以下代碼：

val name = person.component1()
val age = person.component2()

1.13 在Kotlin中，什么是內(nèi)聯(lián)函數(shù)？有什么作用？

Kotlin里使用關(guān)鍵 inline 來(lái)表示內(nèi)聯(lián)函數(shù)，那么到底什么是內(nèi)聯(lián)函數(shù)呢，內(nèi)聯(lián)函數(shù)有什么好處呢？

什么是內(nèi)聯(lián)inline？

在 Java 里是沒(méi)有內(nèi)聯(lián)這個(gè)概念的，所有的函數(shù)調(diào)用都是普通方法調(diào)用，如果了解 Java 虛擬機(jī)原理的，可以知道Java 方法執(zhí)行的內(nèi)存模型是基于 Java 虛擬機(jī)棧的：每個(gè)方法被執(zhí)行的時(shí)候都會(huì)創(chuàng)建一個(gè)棧幀（Stack Frame），用于存儲(chǔ)局部變量表、操作數(shù)棧、動(dòng)態(tài)鏈接、方法出口等信息。每一個(gè)方法被調(diào)用直至執(zhí)行完成的過(guò)程，就對(duì)應(yīng)著一個(gè)棧幀入棧、出棧的過(guò)程。

也就是說(shuō)每調(diào)用一個(gè)方法，都會(huì)對(duì)應(yīng)一個(gè)棧幀的入棧出棧過(guò)程，如果你有一個(gè)工具類方法，在某個(gè)循環(huán)里調(diào)用很多次，那就會(huì)對(duì)應(yīng)很多次的棧幀入棧、出棧過(guò)程。這里首先要記住的一點(diǎn)是，棧幀的創(chuàng)建及入棧、出棧都是有性能損耗的。

下面以一個(gè)例子來(lái)說(shuō)明，看段代碼片段：

fun test() {
    //多次調(diào)用 sum() 方法進(jìn)行求和運(yùn)算
    println(sum(1, 2, 3))
    println(sum(100, 200, 300))
    println(sum(12, 34))
    //....可能還有若干次
}
/**
 *求和計(jì)算
 */
fun sum(vararg ints: Int): Int {
    var sum = 0
    for (i in ints) {
        sum += i
    }
    return sum
}

在測(cè)試方法 test() 里，我們多次調(diào)用了 sum() 方法。為了避免多次調(diào)用 sum() 方法帶來(lái)的性能損耗，我們期望的代碼類似這樣子的：

fun test() {
    var sum = 0
    for (i in arrayOf(1, 2, 3)) {
        sum += i
    }
    println(sum)
    sum = 0
    for (i in arrayOf(100, 200, 300)) {
        sum += i
    }
    println(sum)
    sum = 0
    for (i in arrayOf(12, 34)) {
        sum += i
    }
    println(sum)
}

3次數(shù)據(jù)求和操作，都是在 test() 方法里執(zhí)行的，沒(méi)有之前的 sum() 方法調(diào)用，最后的結(jié)果依然是一樣的，但是由于減少了方法調(diào)用，雖然代碼量增加了，但是性能確提升了。那么怎么實(shí)現(xiàn)這種情況呢，一般工具類有很多公共方法，我總不能在需要調(diào)用這些公共方法的地方，把代碼復(fù)制一遍吧，內(nèi)聯(lián)就是為了解決這一問(wèn)題。

定義內(nèi)聯(lián)函數(shù)：

inline fun sum(vararg ints: Int): Int {
    var sum = 0
    for (i in ints) {
        sum += i
    }
    return sum
}

如上所示，用關(guān)鍵字 inline 標(biāo)記函數(shù)，該函數(shù)就是一個(gè)內(nèi)聯(lián)函數(shù)。還是原來(lái)的 test() 方法，編譯器在編譯的時(shí)候，會(huì)自動(dòng)把內(nèi)聯(lián)函數(shù) sum() 方法體內(nèi)的代碼，替換到調(diào)用該方法的地方。查看編譯后的字節(jié)碼，會(huì)發(fā)現(xiàn) test() 方法里已經(jīng)沒(méi)了對(duì) sum() 方法的調(diào)用，凡是原來(lái)代碼里出現(xiàn)sum() 方法調(diào)用的地方，出現(xiàn)的都是 sum() 方法體內(nèi)的字節(jié)碼了。

noinline

如果一個(gè)內(nèi)聯(lián)函數(shù)的參數(shù)里包含 lambda表達(dá)式，也就是函數(shù)參數(shù)，那么該形參也是 inline 的，舉個(gè)例子：

inline fun test(inlined: () -> Unit) {...}

這里有個(gè)問(wèn)題需要注意，如果在內(nèi)聯(lián)函數(shù)的內(nèi)部，函數(shù)參數(shù)被其他非內(nèi)聯(lián)函數(shù)調(diào)用，就會(huì)報(bào)錯(cuò)，如下所示：

//內(nèi)聯(lián)函數(shù)
inline fun test(inlined: () -> Unit) {
    //這里會(huì)報(bào)錯(cuò)
    otherNoinlineMethod(inlined)
}
//非內(nèi)聯(lián)函數(shù)
fun otherNoinlineMethod(oninline: () -> Unit) {}

要解決這個(gè)問(wèn)題，必須為內(nèi)聯(lián)函數(shù)的參數(shù)加上 noinline 修飾，表示禁止內(nèi)聯(lián)，保留原有函數(shù)的特性，所以 test() 方法正確的寫法應(yīng)該是：

inline fun test(noinline inlined: () -> Unit) {
    otherNoinlineMethod(inlined)
}

crossinline

首先來(lái)理解一個(gè)概念：非局部返回。我們來(lái)舉個(gè)栗子：

fun test() {
    innerFun {
        //return 這樣寫會(huì)報(bào)錯(cuò)，非局部返回，直接退出 test() 函數(shù)。
        return@innerFun //局部返回，退出 innerFun() 函數(shù)，這里必須明確退出哪個(gè)函數(shù)，寫成 return@test 則會(huì)退出 test() 函數(shù)
    }
    //以下代碼依舊會(huì)執(zhí)行
    println("test...")
}
fun innerFun(a: () -> Unit) {
    a()
}

非局部返回我的理解就是返回到頂層函數(shù)，如上面代碼中所示，默認(rèn)情況下是不能直接 return 的，但是內(nèi)聯(lián)函數(shù)確是可以的。所以改成下面這個(gè)樣子：

fun test() {
    innerFun {
        return //非局部返回，直接退出 test() 函數(shù)。
    }
    //以下代碼不會(huì)執(zhí)行
    println("test...")
    inline fun innerFun(a: () -> Unit) {
        a()
    }
}

也就是說(shuō)內(nèi)聯(lián)函數(shù)的函數(shù)參數(shù)在調(diào)用時(shí)，可以非局部返回，如上所示。那么 crossinline 修飾的 lambda 參數(shù)，可以禁止內(nèi)聯(lián)函數(shù)調(diào)用時(shí)非局部返回。

fun test() {
    innerFun {
        return //這里這樣會(huì)報(bào)錯(cuò)，只能 return@innerFun
    }
    //以下代碼不會(huì)執(zhí)行
    println("test...")
    inline fun innerFun(crossinline a: () -> Unit) {
        a()
    }
}

• 具體化的類型參數(shù) reified
  這個(gè)特性我覺(jué)得特別牛逼，有了它可以少寫好多代碼。在Java 中是不能直接使用泛型的類型，但是在 Kotlin 中確可以。舉個(gè)栗子：

inline fun startActivity() {
    startActivity(Intent(this, T::class.java))
}

使用時(shí)直接傳入泛型即可，代碼簡(jiǎn)潔明了：

startActivity()

1.14 談?wù)刱otlin中的構(gòu)造方法？有哪些注意事項(xiàng)？

概要簡(jiǎn)述

• kotlin中構(gòu)造函數(shù)分為主構(gòu)造和次級(jí)構(gòu)造兩類
• 使用關(guān)鍵詞constructor標(biāo)記構(gòu)造函數(shù)，部分情況可省略
• init關(guān)鍵詞用于初始化代碼塊，注意與構(gòu)造函數(shù)的執(zhí)行順序，類成員的初始化順序
• 繼承，擴(kuò)展時(shí)候的構(gòu)造函數(shù)調(diào)用邏輯
• 特殊的類如data class、object/componain object、sealed class等構(gòu)造函數(shù)情況與繼承問(wèn)題
• 構(gòu)造函數(shù)中的形參聲明情況

主/次 構(gòu)造函數(shù)

• kotlin中任何class（包括object/data class/sealed class）都有一個(gè)默認(rèn)的無(wú)參構(gòu)造函數(shù)
• 如果顯式的聲明了構(gòu)造函數(shù)，默認(rèn)的無(wú)參構(gòu)造函數(shù)就失效了。
• 主構(gòu)造函數(shù)寫在class聲明處，可以有訪問(wèn)權(quán)限修飾符private,public等，且可以省略constructor關(guān)鍵字。
• 若顯式的在class內(nèi)聲明了次級(jí)構(gòu)造函數(shù)，就需要委托調(diào)用主構(gòu)造函數(shù)。
• 若在class內(nèi)顯式的聲明處所有構(gòu)造函數(shù)（也就是沒(méi)有了所謂的默認(rèn)主構(gòu)造），這時(shí)候可以不用依次調(diào)用主構(gòu)造函數(shù)。例如繼承View實(shí)現(xiàn)自定義控件時(shí)，三四個(gè)構(gòu)造函數(shù)同時(shí)顯示聲明。

init初始化代碼塊

kotlin中若存在主構(gòu)造函數(shù)，其不能有代碼塊執(zhí)行，init起到類似作用，在類初始化時(shí)侯執(zhí)行相關(guān)
的代碼塊。

• init代碼塊優(yōu)先于次級(jí)構(gòu)造函數(shù)中的代碼塊執(zhí)行。
• 即使在類的繼承體系中，各自的init也是優(yōu)先于構(gòu)造函數(shù)執(zhí)行。
• 在主構(gòu)造函數(shù)中，形參加有var/val，那么就變成了成員屬性的聲明。這些屬性聲明是早于init代碼塊的。

特殊類

• object/companion object是對(duì)象示例，作為單例類或者伴生對(duì)象，沒(méi)有構(gòu)造函數(shù)。
• data class要求必須有一個(gè)含有至少一個(gè)成員屬性的主構(gòu)造函數(shù)，其余方面和普通類相同。
• sealed class只是聲明類似抽象類一般，可以有主構(gòu)造函數(shù)，含參無(wú)參以及次級(jí)構(gòu)造等。

1.15 談?wù)凨otlin中的Sequence，為什么它處理集合操作更加高效？

處理集合時(shí)性能損耗的最大原因是循環(huán)。集合元素迭代的次數(shù)越少性能越好。
我們寫個(gè)例子：

list.map { it ++ }
.filter { it % 2 == 0 }
.count { it< 3 }

反編譯一下，你會(huì)發(fā)現(xiàn)：Kotlin編譯器會(huì)創(chuàng)建三個(gè)while循環(huán)。
Sequences 減少了循環(huán)次數(shù)
Sequences提高性能的秘密在于這三個(gè)操作可以共享同一個(gè)迭代器(iterator)，只需要一次循環(huán)即可完成。
Sequences允許 map 轉(zhuǎn)換一個(gè)元素后，立馬將這個(gè)元素傳遞給 filter操作 ，而不是像集合(lists) 那樣，等待所有的元素都循環(huán)完成了map操作后，用一個(gè)新的集合存儲(chǔ)起來(lái)，然后又遍歷循環(huán)從新的集合取出元素完成filter操作。

Sequences 是懶惰的
上面的代碼示例，map、filter、count 都是屬于中間操作，只有等待到一個(gè)終端操作，如打印、sum()、average()、first()時(shí)才會(huì)開始工作，不信？你跑下下面的代碼？

val list = listOf(1, 2, 3, 4, 5, 6)
val result = list.asSequence()
    .map { println("--map"); it * 2 }
    .filter { println("--filter");it % 3 == 0 }
println("go~")
println(result.average())

擴(kuò)展：Java8 的 Stream(流) 怎么樣呢?

list.asSequence()
.filter { it < 0 }
.map { it++ }
.average()
list.stream()
.filter { it < 0 }
.map { it++ }
.average()

stream的處理效率幾乎和Sequences一樣高。它們也都是基于惰性求值的原理并且在最后(終端)處理集合。

1.16 請(qǐng)談?wù)凨otlin中的Coroutines，它與線程有什么區(qū)別？有哪些優(yōu)點(diǎn)？

說(shuō)一下個(gè)人理解吧。先列出協(xié)程幾個(gè)特點(diǎn)：

• 在單個(gè)進(jìn)程內(nèi)，多個(gè)協(xié)程串行執(zhí)行，只掛起不阻塞
• 協(xié)程最終的執(zhí)行還是在各個(gè)線程之中

優(yōu)點(diǎn)：

• 由于不阻塞線程，異步任務(wù)是編譯器主動(dòng)交到線程池中執(zhí)行。因此，在異步任務(wù)執(zhí)行上，切換和消耗的資源都較少。
• 由于協(xié)程是跨多個(gè)線程，并且能夠保持串行執(zhí)行；因此，在處理多并發(fā)的情況上，能夠比鎖更輕量級(jí)。通過(guò)狀態(tài)量實(shí)現(xiàn)

1.17 Kotlin中該如何安全地處理可空類型？

對(duì)于方法傳入的參數(shù)直接通過(guò)if判斷，例如：

fun a(tag: String?, type: String) {
    if (tag != null && type != null) {
        // do something
    }
}

還有就是

a?.let{}
a?.also{}
a?.run{}
a?.apply{}

然后接著有一個(gè)疑問(wèn)，假如同時(shí)判斷兩個(gè)變量，寫成：

a?.let{
    b?.let {
        //do something
    }
}

1.18 說(shuō)說(shuō)Kotlin中的Any與Java中的Object有何異同？

同：都是頂級(jí)父類
異：成員方法不同

Any只聲明了toString()、hashCode()和equals()作為成員方法。

我們思考下，為什么 Kotlin 設(shè)計(jì)了一個(gè) Any ？

當(dāng)我們需要和 Java 互操作的時(shí)候，Kotlin 把 Java 方法參數(shù)和返回類型中用到的 Object 類型看作 Any，這個(gè) Any 的設(shè)計(jì)是 Kotlin 兼容 Java 時(shí)的一種權(quán)衡設(shè)計(jì)。

所有 Java 引用類型在 Kotlin 中都表現(xiàn)為平臺(tái)類型。當(dāng)在Kotlin 中處理平臺(tái)類型的值的時(shí)候，它既可以被當(dāng)做可空類型來(lái)處理，也可以被當(dāng)做非空類型來(lái)操作。

試想下，如果所有來(lái)自 Java 的值都被看成非空，那么就容易寫出比較危險(xiǎn)的代碼。反之，如果 Java 值都強(qiáng)制當(dāng)做可空，則會(huì)導(dǎo)致大量的 null 檢查。綜合考量，平臺(tái)類型是一種折中的設(shè)計(jì)方案。

1.19 Kotlin中的數(shù)據(jù)類型有隱式轉(zhuǎn)換嗎？為什么？

不可隱式轉(zhuǎn)換
在Java中從小到大，可以隱式轉(zhuǎn)換，數(shù)據(jù)類型將自動(dòng)提升。下面以int為例
這么寫是ok的

int a = 2312;
long b = a;
//那么在Kotlin中
//隱式轉(zhuǎn)換，編譯器會(huì)報(bào)錯(cuò)
val anInt: Int = 5
val ccLong: Long = anInt
//需要去顯式的轉(zhuǎn)換,下面這個(gè)才是正確的
val ddLong: Long = anInt.toLong()

1.20 Kotlin中集合遍歷有哪幾種方式？

對(duì)于如下集合

val list = mutableListOf("a", "b", "c", "d", "e", "f", "g")
// kotlin中集合的遍歷方式有下面幾種
// 1、 通過(guò)解構(gòu)的方式，可以方便的獲取index和value
for ((index, value) in list.withIndex()){
    println("index = $index , value = $value")
}
// 2、 … 左閉右閉 [,]
for (i in 0 .. list.size - 1){
    println("index = $i , value = ${list[i]}")
}
// 3、 until 左閉右開 [,)
for (i in 0 until list.size){
    println("index = $i , value = ${list[i]}")
}
// 4、 downTo 遞減的循環(huán)方式 左閉右閉 [,]
for (i in list.size - 1 downTo 0){
    println("index = $i , value = ${list[i]}")
}
// 5、帶步長(zhǎng)的循環(huán)step可以和其他循環(huán)搭配使用
for (i in 0 until list.size step 2){
    println("index = $i , value = ${list[i]}")
}
// 6、指定循環(huán)次數(shù) it就代表了當(dāng)前循環(huán)的計(jì)數(shù),從0開始下面的語(yǔ)句循環(huán)了10次 每次的計(jì)數(shù)分別是 0，1…9
repeat(10){
    println(it)
}
// 7、不需要數(shù)據(jù)的下標(biāo)，直接for循環(huán)list中的每個(gè)item
for (item in list){
    println(item)
}

以上就是基于Android Kotlin高頻面試題解析的詳細(xì)內(nèi)容，更多關(guān)于Android Kotlin面試題的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！