Kotlin

声明变量

Kotlin使用val声明不可变变量，使用var声明可变变量

val name: String = "小明"
var age: Int = 18

类型推导机制：自动推导变量的数据类型，不需要显式指定

val name = "小明"
var age = 18

但是如果延迟赋值，就必须显式指定类型

val name: String
val age: Int

name = "小明"
age = 18

函数

Kotlin使用fun声明函数

fun test() {
    println("test")
}

返回值类型放在形参列表后面，使用:分隔

fun add(i1: Int, i2: Int): Int {
    return i1 + i2
}

函数只有一个表达式时，可以省略花括号和return关键字，用一个等号代替

fun add(i1: Int, i2: Int): Int = i1 + i2

因为类型推导机制的存在，可以省略返回值类型

fun add(i1: Int, i2: Int) = i1 + i2

类

声明类

Kotlin使用class声明类

class User {
    private var name: String = ""
    private var age: Int = 0
}

类中没有属性和方法时，可以省略花括号

class User

Kotlin中创建对象不需要使用new关键字

val user = User()
user.setAge(18)
user.setName("xxin")

println(user.toString())

构造函数

Kotlin中构造函数分为主构造函数和次构造函数，主构造函数只能有一个，次构造函数可以有多个

主构造函数

主构造函数写在类名后面，使用constructor关键字声明，后面括号中的形参作为类的属性，使用var或val关键字修饰，constructor关键字也可以省略

如果类没有显式声明任何主构造函数和次构造函数，会自动生成一个无参的主构造函数

class User constructor(private var name: String, private var age: Int) {
    private var name: String = name
    private var age: Int = age
}

主构造函数没有函数体，如果要在主构造函数中写逻辑，可以写在init结构体中

class User(private var name: String, private var age: Int) {
    init {
        println("name: $name, age: $age")
    }
}

主构造函数中的形参可以省略var或val关键字，省略之后的形参不作为属性，只能在init结构体中使用

class User(name: String, age: Int) {
    init {
        println("name: $name, age: $age")
    }
}

次构造函数

Kotlin中可以有多个次构造函数，而无主构造函数，使用constructor关键字声明次构造函数

class User {
    private var name: String = ""
    private var age: Int = 0

    // 使用 this 调用两个参数的构造函数
    constructor(name: String) : this(name, 18) {
        println("一个参数的构造函数")
    }

    // 给属性赋值
    constructor(name: String, age: Int) {
        println("两个参数的构造函数")
        this.name = name
        this.age = age
    }
}

当一个类既有主构造函数又有次构造函数时，所有次构造函数必须直接或间接的调用主构造函数

// 主构造函数中的形参省略了var或val关键字，只能在init结构体中使用
open class User(name: String, age: Int) {
    private var name: String = ""
    private var age: Int = 0

    init {
        // 初始化块中给属性赋值
        println("初始化块")
        this.name = name
        this.age = age
    }

    // 次构造函数，直接调用主构造函数
    constructor(name: String) : this(name, 18) {
        println("一个参数的构造函数")
    }

    // 次构造函数，间接调用主构造函数
    constructor(age: Int) : this("xxin") {
        println("两个参数的构造函数")
    }
}

继承

Kotlin中的类默认是不可继承的，如果要使一个类可以被继承，需要在类名前添加open关键字

open class User {

}

让IKun类继承User类，使用:关键字

下面代码中，被继承的类User之所以带有()，是因为Kotlin和java一样，在类继承时子类的构造函数会调用父类的构造函数，如果父类没有定义构造函数，子类继承时应该调用父类的无参构造函数，所以被继承的类带有()

class IKun : User() {
    
}

如果父类有多个构造函数，子类只需要选择调用一个构造函数即可，具体选择哪个构造函数，在继承时通过括号中的参数指定

// 父类的主构造函数无形参
open class User() {
    // 一个形参的次构造函数
    constructor(name: String) : this() {
        println("User的构造方法1")
    }
    // 两个形参的次构造函数
    constructor(name: String, age: Int) : this(name) {
        println("User的构造方法2")
    }
}

// 调用空参的主构造函数
class IKun(name: String) : User() {

}

// 调用一个形参的次构造函数
class IKun(name: String) : User(name) {

}

如果子类中只有次构造函数，没有主构造函数，那么被继承的类User后不需要再带()，构造函数中使用super关键字调用父类的构造函数

class IKun : User {
    constructor() : super() {
        println("IKun constructor")
    }
}