全面了解Kotlin，android面试基础_android func: () -> unit

//使用withIndex迭代list
val list = arrayListOf(“10”,“11”,“100”)
for ((index,element) in list.withIndex()){//解构申明
println(“$index:$element”)
}

//打印结果
0:10
1:11
2:100

迭代map

val map = mapOf(1 to “Java”, 2 to “Kotlin”, 3 to “Flutter”)//中缀调用
for ((key, value) in map) { //解构
println(“$key:$value”)
}

//打印结果
1:Java
2:Kotlin
3:Flutter

5.类

和Java一样，类的定义如下

class Base {
var num = 1
}

但是意义却不太一样。

5.1可见性

**Kotlin中，默认类的可见性为public以及final的。**内部类默认为static的，用inner标记非静态内部类。

①Kotlin 中可见性

• private ：私有，本类内部可见
• protected ：子类可见
• internal ：模块内可见
• public ：默认，公有

②对比 Java

• private ：私有，本类内部可见
• protected ：子类可见
• default ：默认，包内可见
• public ：公有

单个构造函数&私有构造

class Response private constructor(val code: Int, val msg: String){
override fun toString(): String {
return “code:$code,msg:$msg”
}
}

多个构造函数

//非open不可被继承
class Response {
val code: Int
val msg: String

constructor(code: Int) {
this.code = code
msg = “”
}

constructor(code: Int, msg: String) {
this.code = code
this.msg = msg
}

override fun toString(): String {
return “code:$code,msg:$msg”
}
}

其中code和msg的getter会自动生成。

kotlin中也是单继承多实现，共同存在时，继承类写到第一位，后面追加逗号跟上接口接口。

public class String : Comparable, CharSequence{
…
}

密封类（private构造，默认open）

sealed class Expr {

class Num(val value: Int) : Expr()
class Sum(val left: Expr, val right: Expr) : Expr()

}

5.2Object关键字

①类单例

object SingleTon {

@JvmStatic
fun isEmpty(str: String) = str.isEmpty()
}

反编译成Java

public final class SingleTon {
public static final SingleTon INSTANCE;

@JvmStatic
public static final boolean isEmpty(@NotNull String str){
Intrinsics.checkParameterIsNotNull(str, “str”);
CharSequence var1 = (CharSequence)str;
boolean var2 = false;
return var1.length() == 0;
}

private SingleTon() {
}

static {
SingleTon var0 = new SingleTon();
INSTANCE = var0;
}
}

根据面可以看出，object单独修饰一个类，表示为静态代码块实现的单例。

@JvmStatic修饰的方法，kotlin会在其方法上添加static关键字，而static关键字在kotlin中是不存在的。

②匿名类

test(object : Listener {

})
interface Listener{

}

kotlin中没有new关键字，所以匿名类用object实现。

③伴生对象

kotlin没有static，那么如何实现静态变量以及常量等的定义和使用呢？

答案是伴生对象

class UserManager {

companion object{
val USER_TYPE = 0x01
}
}

上面的companion object会生成一个内部类Companion，并添加返回USER_TYPE的静态getter，如下

public final class UserManager {
private static final int USER_TYPE = 1;
public static final UserManager.Companion Companion = new UserManager.Companion((D