原文在 https://github.com/Zhuinden/guide-to-kotlin

kotlin语言语法的不同

参照java对kotlin语言进行学习，对一些概念进行类比。

常识不同（参数和类型的顺序，void = unit，Object = Any？， fun等）：

• 定义函数使用fun
• 定义参数 name: type
• 定义返回参数 fun funName(paramName:type) : type {}. 例子如下：

fun matches(b: ByteArray): Boolean{
    return false;
}

• void 返回值在kotlin中是不需要显示写出来的，如果一定要显示写出来，就使用unit
• @Override 要改成override，且是强制性的，必需显示写出来，java中不需要显示写出来。
• 使用Any？替代Object类型
• 没有new关键字

public abstract class BaseClass{
    //...
}

public class MyClass extends BaseClass{
    private final Map<String, Object> objects = new HashMap<>();
    
    public MyClass(){}

    @Override
    public void addToMap(String key, Ojbect value){
        objects.put(key, value);
    }
}

final MyClass myClass = new MyClass();

对应的kotlin代码如下

abstract class BaseClass{}

class MyClass : BaseClass(){
    private val objects = hashMapOf<String, Any?>()

    init {
    
    }

    ovveride fun addToMap(key: String, value: Any?){
        objects.put(key, value);
    }

    fun <T> getObject(key: String): T = 
        objects.get(key) as T
}

val myClass = MyClass()

接口和val，var还有fun

在kotlin中val和var的区别很重要：

• var表示变量
• val表示一个final修饰的变量。
• 每一个var修饰的变量默认暴露getter/setter。 val修饰的只暴露了getter。

interface MyContract {
    var value: String
    
    val name: String
 
    fun doSomething(input1: String, input2: String)
}

class MyImpl(
    override var value: String,
    override val name: String
): MyContract {
    override fun doSomething(input1: String, input2: String) {
        ...
    }
}

构造函数和继承

如下，kotlin可以传递参数给supper-constructors，跟java中的super(param)一样。

class MyClass(
    tag: String,
    private val name: String,
    var mutableField: String = "" // default argument
): BaseClass(tag), MyInterface {
    override fun methodFromInterface() {
    }
}

class MyCustomView : FrameLayout {
    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
    constructor(context: Context, attrs: AttributeSet?, @AttrRes defStyleAttr: Int) : super(context, attrs, defStyleAttr)

kotlin中可以使用constructor关键字

lateinit vars

enum

java中使用 enum ClassName{}

kotlin定义方式 enum class ClassName{}

注解

java中定义一个注解是 public @interface MyAnnotation{}

kotlin定义为 annotation class

final 和open

任何class默认都是final修饰，意味着不能继承，如果要继承一个kotlin类，那么要使用open修饰

open class SomeClass{}

循环

for(i in 0 until n){}

for(pair in pairs){
}

for((key, value) in map.entries){
}

单例

object MySingleton{
    fun doSomething(){
    }
}

Mysingleton.doSomething()

object NetWork{
    const val API_URL = "http://www.baidu.com"
    const val TIMEOUT = 1000
}

object Positions {
    @JvmStatic
    fun create(x: Int, y: Int): Int = Position(x, y)
    // ...
}

伴生对象实现静态方法， 常量

在kotlin中没有static关键字，但是kotlin中有伴生对象的概念—companion object，使用伴生对象来实现静态变量和静态方法。

class MyClassWithStatics {
    companion object {
        const val SOME_CONSTANT = "Hello!"

        @JvmField var someUglyMutableField: String = "don't do this like ever"

        @JvmStatic fun hello() { println("$SOME_CONSTANT $someUglyMutableField") }
    }
}

// consuming Java code!
public class MyOtherClass {
    public void doSomething() {
        String constant = MyClassWithStatics.SOME_CONSTANT;
        String someUglyMutableField = MyClassWithStatics.someUglyMutableField;
        MyClassWithStatics.hello();
    }
}

为什么要使用 JvmField JvmStatic注解,如果不使用，那么在java端的使用样例如下：

public class MyOtherClass {
    public void doSomething() {
        String constant = MyClassWithStatics.Companion.INSTANCE.SOME_CONSTANT;
        String someUglyMutableField = MyClassWithStatics.Companion.INSTANCE.someUglyMutableField;
        MyClassWithStatics.Companion.INSTANCE.hello();
    }
}

可见性

在java中 有 private , package protected public

在kotlin中有private , protected public(default) internal

需要注意的是 internal不是package

在kotlin中没有package这个可见性。

static修饰的内部类和kotlin中的inner

在kotlin中，内嵌类默认就等同于java中的 public static class,所以定义一个内部类，需要明确使用inner修饰. 内部类会引用外部类对象，而内嵌类不会。

倒引号的使用

在kotlin中调用java类库中的代码，有可能类库中的方法是kotlin的关键字，这时候需要使用倒引号

Mockito.`when`(text.hashCode())

kotlin中的 is和as as？

java中判断一个对象是否是某类型使用 instanceof, 而kotlin中使用is。

kotlin使用as 和as？ 来进行强制类型转换

class Cat(private val name: String) {
    fun meow() {
        println("The cat $name meowed.")
    }
}

fun doSomething(obj: Any?) {
    if(obj is Cat) {
        obj.meow() // note that as `obj` is a `val`, the cast is automatic here
    }
}

强制类型转换的时候，我们不能确定时候，在kotlin中就可以使用as？，如果使用as 强制转型失败就会抛异常，而as？不会，返回的是null

(obj as? Cat)?.meow()

匿名实现类和接口

myView.setOnClickListener(object: View.OnClickListener{
    override fun onClick(view: View){
        //do something
    }
})

myView.setOnClickListener((view) -> {
    //do something
})

myView.setOnClickListener{view -> 
    //do something
}

kotlin中没有三元运算符

可以使用如下来代替

val something = if() ... else ...

val something = when {
    value != "hello" -> "beep"
    else -> "boop"
}

单行函数可以使用=代替return

fun getRepository(): Repository = repository

fun getRepository(): Repository {
    return repository
}

arrayOf / arrayOfNulls / listOf / mutableListOf / linkedMapOf

private final List<String> strings = new ArrayList<>();

private val strings = arrayListOf<String>()

val squares = List(size = 6) { index -> index * index}
//same as
val squares = ListOf(0, 1, 4, 9, 16, 25)

volatile 和@Volatile

多泛型边界

public class MyClass<T extends SomeClass & Comparable> {
    ...
}

class MyClass<T: SomeClass> { // this would be single-bounds

class MyClass<T>
    where T: SomeClass,
          T: Comparable { // multiple generic bounds