Kotlin 基础知识（上）

1，变长参数定义 vararg

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}

2, NULL检查机制

//类型后面加?表示可为空
var age: String? = "23" 
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

3,区间定义， in 关键字后可接 .. 、downTo、until，后接 step

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

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

// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”


// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}

区间源码实现
4,比较 三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小

fun main(args: Array<String>) {
    val a: Int = 10000
    println(a === a) // true，值相等，对象地址相等

    //经过了装箱，创建了两个不同的对象
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    //虽然经过了装箱，但是值是相等的，都是10000
    println(boxedA === anotherBoxedA) //  false，值相等，对象地址不一样
    println(boxedA == anotherBoxedA) // true，值相等
}

5,多行字符串用""" 三个引号
6，if 默认返回最后一行数据， when 关键字类似于switch
7，标签出返回
定义 tag@{...} 返回 return@tag value

8，类的定义

class Foo constructor(arg: String) {  // 类名为 Foo 默认构造函数
   var <propertyName>[: <PropertyType>] [= <property_initializer>]
        [<getter>]
        [<setter>]

    init { // 初始化代码段使用 init 关键字作为前缀
        println("FirstName is $firstName")
    }

    constructor(parent: Person) {
        parent.children.add(this) 
    }

    // 如果类有主构造函数，每个次构造函数都要，或直接或间接通过另一个次构造函数代理主构造函 
    // 数。在同一个类中代理另一个构造函数使用 this 关键字
    constructor (name: String, age:Int) : this(name) {
        // 初始化...
    }

    class Nested {             // 嵌套类, 相当于java 的静态内部类
        fun foo() = 2
    }

    inner class Inner {  // 内部类
        fun foo() = bar  // 访问外部类成员
        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }

    interface TestInterFace {
        fun test()
    }

    fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}
}

9，类的修饰符

abstract    // 抽象类  
final       // 类不可继承，默认属性
enum        // 枚举类
open        // 类可继承，类默认是final的
annotation  // 注解类

private    // 仅在同一个文件中可见
protected  // 同一个文件中或子类可见
public     // 所有调用的地方都可见
internal   // 同一个模块中可见

10，Kotlin 中所有类都继承该 Any 类，它是所有类的超类，Any 默认提供了三个函数

equals()

hashCode()

toString()

// 如果一个类要被继承，可以使用 open 关键字进行修饰。
// 属性重写使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序 
// 或者getter方法被重写, 也用一个var属性重写一个val属性，但是反过来不行。
open class Foo {
    open val x: Int get { …… }
}

class Bar1 : Foo() {
    override val x: Int = ……
}