Kotlin编译后也是class文件，然后由java虚拟机调用

变量和函数：

val：不可变的变量; var：可变的变量

fun main() {
    val a = 10
    var b = 5
    b = b + 3
    println("a = " + a)
    println("b = " + b)
}

不再是基本数据类型，而是对象数据类型。

函数，越看越像python

fun methodName(param1: Int, param2: Int): Int {
      return 0
}

 只有一行代码可以直接将唯一的一行代码写在函数定义的尾部，中间用等号连接即可

fun methodName(param1: Int, param2: Int) = 0

if条件语句有返回值

fun largerNumber(num1: Int, num2: Int): Int {
    val value = if (num1 > num2) {
        num1
    } else {
        num2
    }
    return value
}

fun largerNumber(num1: Int, num2: Int): Int {
    return if (num1 > num2) {
        num1
    } else {
        num2
    }
}

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) {
    num1
} else {
    num2
}

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

 when条件语句

fun getScore(name: String) = when (name) {
    "Tom" -> 86
    "Jim" -> 77
    "Jack" -> 95
    "Lily" -> 100
    else -> 0
}

 类型匹配

fun checkNumber(num: Number) {
    when (num) {
        is Int -> println("number is Int")
        is Double -> println("number is Double")
        else -> println("number not support")
    }
}

for-in循环语句

val range = 0..10//[0, 10]

val range = 0 until 10//[0, 10)

fun main() {
    for (i in 0..10) {
        println(i)
    }
}

fun main() {
    for (i in 0 until 10 step 2) {//跳过
        println(i)
    }
}

fun main() {
    for (i in 10 downTo 1) {//降序
        println(i)
    }
}

类与对象

class Person {
    var name = ""
    var age = 0

    fun eat() {
        println(name + " is eating. He is " + age + " years old.")
    }
}

fun main() {
    val p = Person()
    p.name = "Jack"
    p.age = 19
    p.eat()
}

默认不可以被继承，可以追加open关键字

open class Person {
    …
}

class Student : Person() {
    var sno = ""
    var grade = 0
}

interface Study {//接口
    fun readBooks()
    fun doHomework()
}

class Student(val name: String, val age: Int) : Study {//接口实现也是冒号
    override fun readBooks() {
        println(name + " is reading.")
    }

    override fun doHomework() {
        println(name + " is doing homework.")
    }
}

data class Cellphone(val brand: String, val price: Double)//数据类，类似于struct

object Singleton {//单例
    fun singletonTest() {
        println("singletonTest is called.")
    }
}

Singleton.singletonTest()//后台默认创建一个singleton实例，全局只有一个singleton实例

lambda编程{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")//初始化list
val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape")//初始化set
val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)//初始化map

fun main() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val newList = list.map({ fruit: String -> fruit.toUpperCase() })//lambda函数将list变成大写
    for (fruit in newList) {
        println(fruit)
    }
}

• 当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号的外面。
• 如果Lambda参数是函数的唯一一个参数的话，还可以将函数的括号省略。
• Lambda表达式中的参数列表其实在大多数情况下也不必声明参数类型。
• 参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替。

val newList = list.map { it.toUpperCase() }

public interface OnClickListener {
     void onClick(View v);//单抽象方法接口
}

button.setOnClickListener { v ->//注册这个按钮的点击事件
}

public void doStudy(Study study) {//传入的如果是null则会引发空指针异常。
    study.readBooks();
    study.doHomework();
}

public void doStudy(Study study) {
    if (study != null) {//最稳妥的办法就是判断空指针
        study.readBooks();
        study.doHomework();
    }
}

fun doStudy(study: Study) {//kotlin编译器自动检测空指针
    study.readBooks()
    study.doHomework()
}

if (a != null) {
    a.doSomething()
}

a?.doSomething()//?. 操作符表示当对象不为空时正常调用相应的方法，当对象为空时则什么都不做。

val c = if (a ! = null) {
    a
} else {
    b
}

val c = a ?: b

fun doStudy(study: Study?) {
    study?.let {//?.操作符和let函数也可以对多次重复调用的某个变量统一进行判空处理
        it.readBooks()
        it.doHomework()
    }
}

"hello, ${obj.name}. nice to meet you!"//表达式写在字符串里面

"hello, $name. nice to meet you!"//表达式中仅有一个变量的时候

fun printParams(num: Int, str: String = "hello") {//默认参数
    println("num is $num , str is $str")
}