Kotlin 学习纲要

基本语法

变量声明


val a: Int = 1  // 立即赋值
val b = 2   // 自动推断出 `Int` 类型
val c: Int  // 如果没有初始值类型不能省略
c = 3       // 明确赋值

静态变量使用val 关键字

val PI = 3.14

使用可空值及 null 检测

当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空

fun parseInt(str: String): Int? {
    // ……
}

使用 for 循环

1.类似于 foreach 循环,conllection表示java集合，比如List,数组等

for (item in collection) {

   print(item)
}

区间迭代

if (i in 1..10) { // 等同于 1 <= i && i <= 10
    println(i)
}

逆序

for (i in 4 downTo 1) print(i)

while 和 do..while 照常使用

和java 类似

if,if else ,if..else if..else

这和java 类似

for (i in 1..3) {
    println(i)
}
for (i in 6 downTo 0 step 2) {
    println(i)
}

使用When 代理switch

when 取代了类 C 语言的 switch 操作符

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x is neither 1 nor 2")
    }
}

函数定义

带Int返回类型的函数，其中x是参数，:后面是参数返回类型，第二个:后面是方法的返回类型

fun double(x: Int): Int {
    return 2 * x
}

无返回类型值，它的返回类型是 Unit

fun double(x: Int): Unit {
    return 2 * x
}

也可以省略Unit

fun double(x: Int) {

}

函数调用和java类似

 val i=double(2)

类

声明

类声明由类名、类头（指定其类型参数、主构造函数等）以及由花括号包围的类体构成

  class MainActivity{

  }

如果一个类没有类体，可以省略花括号

class MainActivity{

  }

抽象类声明

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

构造函数

一类有主构造函数和次构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。

class Person constructor(firstName: String) { ... }

主构造函数没有任何注解或者可见性修饰符， constructor 关键字可省略

class Person(firstName: String) { ... }

创建类的实例

Kotlin 并没有 new 关键字,使用var来定义。

val invoice = Invoice()

val customer = Customer("Joe Smith")

在 Kotlin 中的一个类可以有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。

嵌套类与内部类

类可以嵌套在其他类中，嵌套类也就是是static 类，不可以访问外部引用

class Outer {
    private val bar: Int = 1
    class Nested {
        fun foo() = 2
    }
}

内部类

类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() = bar
    }
}

val demo = Outer().Inner().foo() // == 1

匿名内部类

使用object 关键字

    private var  handler: Handler= object : Handler() {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
        }
    }

类的继承

在 Kotlin 中所有类都有一个共同的超类 Any，这对于没有超类型声明的类是默认超类：

class Example // 从 Any 隐式继承

要声明一个显式的超类型，我们把类型放到类头的冒号之后

open class Base(p: Int)

class Derived(p: Int) : Base(p)

类上的 open 标注与 Java 中 final 相反，它允许其他类从这个类继承。默认情况下，在 Kotlin 中所有的类都是 final

接口声明

使用interface 定义接口，允许方法有默认实现

interface MyInterface {
    fun bar()
    fun foo() {
        // 可选的方法体
    }
}

接口种的属性

使用val 定义属性，在接口中声明的属性要么是抽象的，要么提供访问器的实现

interface MyInterface {
    val prop: Int // 抽象的

接口继承

interface Named {
    val name: String
}

interface Person : Named {
    val firstName: String
    val lastName: String

    override val name: String get() = "$firstName $lastName"
}

范型定义

java 类似

Android 相关

1.如何使用findViewById()

2.设置监听

#Java 与Kotlin 优劣势 Kotlin 支持类型推断，没有 Java 那样的啰嗦。

Kotlin学习纲要