kotlin基本语法

函数

表达式：fun 方法名(参数名1: 数据类型, 参数名2: 数据类型): 返回值数据类型{

}

普通用法

fun test(a: Int): String {
        return "";
}

// 将表达式作为函数体，花括号可以省略
fun test1(a: Int): Int = 1;

// 函数返回无意义的值Unit，返回值可省略
fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

条件表达式if else

// else不可省略
fun test2(a: Int, b: Int): Int {
        if (a > b) {
            return a
        } else {
            return b
        }
    }

fun test3(a: Int, b: Int): Int = if (a > b) a else b

fun test8(s1: String, s2: String): Int {
      val i1 = test7(s1)
      val i2 = test7(s2)

      return if (i1 != null && i2 != null) i1 * i2 else 0
}

非空条件判断（没有java的三元运算符）

 fun test4(a: String?): String {
        return a?.length.toString() ?: "0";
    }

fun test5(file: File?): String {
     return file?.absolutePath ?: "xx";
 }

 fun test6(file: File?) {
     file ?: throw IllegalArgumentException()
 }

 fun test7(s: String?): Int? = s?.toInt() ?: 0

when表达式(java的switch)

1、必须加else
2、如果对象是class类型的，则必须用 is
3、object / companion object这种类型的，则不用加 is

class A{
}

object B{
}

// else不可省略
 fun test9(s: Any): Int = when (s) {
        "1" -> 1
        "2" -> 2
        is A -> 3
        B -> 4
        else -> 0
}

let、also、with、run、apply

fun test10(file: File?) {
    var let = file.let {
        it?.absolutePath
        it?.name
    }

	val also = file.also {
	    it?.absolutePath
	    it?.name
	    999
	}
	
	with(file) {
	    this?.absolutePath
	    this@MainActivity.test5(file)
	    this?.name
	}
	
	file.run {
	    this?.absolutePath
	    this?.name
	}
	
	file.apply {
	    this?.absoluteFile
	    this?.absolutePath
	    this?.name
		}
}

fun test11(file: File?): String = file.let { it?.absolutePath } ?: ""

// a b互换值
fun test12() {
	var a = 1;
	var b = 2;
	a = b.also { b = a }
}

区别：

is（java的instanceOf）

fun test13(obj: Any): String? {
     return if (obj is String) obj else null
}

遍历

fun test14() {
    val list = listOf("a", "b", "c")
    for (li in list) {
        println(li)
    }

    for (index in list.indices) {
        println("$index ---${list.get(index)}")
    }

    list.forEach {

    }

    val map = mapOf("a" to "aa", "b" to "bb", 1 to "cc")
    map.forEach {
        println("${it.key} ${it.value}")
    }

    map.entries.forEach {
        println("${it.key} ${it.value}")
    }
}

in（区间）

fun test15(a: Int): Int {
        return if (a in 1..10) a else 0
}

vararg和array

1、当参数类型是array时，vararg可直接传入。
2、当参数类型是vararg时，array传入时需要在前面加上 * 号。

变量

普通变量

val 和 var

申明变量的关键字：val 和 var
区别：val表示只读，默认只有getter方法，var表示读写，默认有getter和setter方法

// ？表示可为null，kotlin里默认都不可为null
var name: String? = null

lateinit

如果不想赋值为null，可用 lateinit 关键字

lateinit var file:File

类

public protected private （和java一样），open

1、默认public，可省略不写
2、kotlin中的类默认是不可被扩展修改的，类似于java的final修饰，不可被继承，要想可被继承，可用open修饰符。
3、kotlin中的接口（interface）和抽象类（abstract）默认是public和open的。
4、接口和抽象类中的成员变量，在实现类或子类中必须实现

interface IDemo {
 	var text:String
    fun iTest()
}

abstract class AbsDemo {
    abstract fun absTest()
}

// 非抽象类必须用open修饰，才可被继承
open class BaseDemo  {
	// 非抽象方法必须用open修饰，才可被重写
    open fun baseTest() {

    }

    var file: File? = null
}

class Demo : IDemo, BaseDemo() {
	// 必须实现
	override var text: String = ""
        get() = field
        set(value) {
            field = value
        }

    override fun iTest() {

    }

    override fun baseTest() {
        super.baseTest()
        // 可访问父类的成员变量
        file
    }
}

5、另类创建接口实现类的方法，无需创建这个kt类，类似于内部类中的匿名内部类。

fun test() {
      val v = object : IDemo {
           override var text: String
               get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templa