类、对象与接口

主、次构造函数

/**
 * 主、次构造函数
 * 1. 主构造函数，在类名后面，使用constructor关键字，也可以省略
 * 2. 次构造函数，在类体中，使用constructor关键字
 */
class Person constructor(name: String, age: Int) {
    var name: String = ""
    var age: Int = 0

    /**
     * 次构造函数，不能与主构造函数冲突
     * 次构造函数要调用主构造函数
     */
    constructor(name: String) : this(name, 0) {
        this.name = name
        println("constructor1：$name，$age")
    }

    /**
     * 次构造函数
     */
    constructor(age: Int) : this("lixingyun", age) {
        this.age = age
        println("constructor2：$name，$age")
    }

    /**
     * 次构造函数
     */
    constructor(age: Int, gender: String) : this("lixingyun", age) {
        this.age = age
        println("constructor3：$name，$age，$gender")
    }
}

class Student {
    var name: String = ""
    var age: Int = 0

    /**
     * 因为没有主构造函数，所以次构造函数就不必显示调用主构造函数
     */
    constructor(name: String) {
        this.name = name
        println("constructor1：$name，$age")
    }
}

继承与重载

Kotlin中类的继承用:表示。

/**
 * Kotlin中所有的类都是final的，如果想要继承，需要显示声明为open
 */
open class Person1(name: String, age: Int) {
    var name: String = ""
    var age: Int = 0

    init {
        this.name = name
        this.age = age
        println("Person1：" + this.name + "， " + this.age)
    }

    // 可覆盖的成员（属性或方法）需要显式修饰符open
    open fun eat() {}

    fun run() {}
}

/**
 * 没有主构造函数的类
 */
open class Person2 {
}

/**
 * 继承时需要一并继承主构造函数
 */
class Student1(name: String, age: Int) : Person1(name, age) {
    // 覆盖后的成员（属性或方法）也需要显式修饰符override
    override fun eat() {}
}

/**
 * 如果没有继承主构造函数，那么父类就需要指定具体的值
 */
class Student2 : Person1("lixingyun", 22) {
}

/**
 * 如果子类没有主构造函数，那么每个次构造函数必须使用super关键字初始化其父类
 */
class Student3 : Person1 {
    constructor(name: String, age: Int) : super(name, age) {
        println("Student3：" + name + "， " + age)
    }
}

/**
 * 父类与子类均没有主构造函数就不需要super了
 */
class Student4 : Person2 {
    constructor(name: String, age: Int) {
        println("Student4：" + name + "， " + age)
    }
}

fun main(args: Array<String>) {
    var student1 = Student1("lixingyun", 20)
    student1.eat()
    student1.run()

    var student2 = Student2()
    // 会调用两次构造函数
    var student3 = Student3("wanglin", 21)
    var student4 = Student4("xiaoyan", 19)
}

getter和setter

Kotlin中的getter和setter会自动创建。

/**
 * Kotlin中的getter和setter是可选的，如果没有在代码中显式地创建，则会默认自动生成
 *
 * class Person {
 *     var name: String = ""
 *     var age: Int = 0
 * }
 * 相当于
 * class Person {
 *     var name: String = ""
 *     var age: Int = 0
 *     set(vaule){
 *         field = value
 *     }
 *     get() = field
 * }
 */
class Person1(name: String, age: Int) {
    // getter和setter
    var name: String? = null
        get() {
            return "lixingyun"
        }
        set(value) {
            field = value
            println("调用set方法：" + field)
        }

    // 仅getter
    val age: Int?
        get() {
            return 20
        }

    // 另一种getter写法
    val area get() = "饶疆"
}

/**
 * 另一种getter和setter风格
 */
class Person2 {
    private var name: String = ""
    private var age: Int = 0

    fun setName(name: String) {
        this.name = name
    }

    fun getName(): String {
        return this.name
    }

    fun setAge(age: Int) {
        this.age = age
    }

    fun getAge(): Int {
        return this.age
    }
}

fun main() {
    val person1 = Person1("wanglin", 18)
    person1.name = "xiaoyan"
    println(person1.name)
    println(person1.age)
    println(person1.area)

    val person2 = Person2()
    person2.setName("luofeng")
    person2.setAge(22)
    println(person2.getName())
    println(person2.getAge())
}

抽象类与接口

/**
 * 定义抽象类和抽象方法
 */
abstract class Base {
    abstract fun foo()
}

/**
 * 继承抽象类
 */
class Derived(val name: String, i: Int) : Base() {
    override fun foo() {
        println("Derived -> " + name)
    }
}

/**
 * 定义接口1
 */
interface BaseInterface1 {
    // 接口定义的字段是抽象的
    val age: Int

    fun bar()

    // 接口可以定义方法的实现
    fun baz() {
        println("BaseInterface1.baz()")
    }
}

/**
 * 定义接口2
 */
interface BaseInterface2 {
    // 接口定义的字段是抽象的
    val age: Int

    fun bar()

    // 接口可以定义方法的实现
    fun baz() {
        println("BaseInterface2.baz()")
    }
}

/**
 * 实现多个接口
 * 要在主构造方法中实现抽象字段
 */
class DerivedInterface(val name: String, override val age: Int) : BaseInterface1, BaseInterface2 {
    override fun bar() {
        println("DerivedInterface -> $name, $age")
    }

    override fun baz() {
        // 指定调用哪个接口的实现
        super<BaseInterface1>.baz()
        // 同时实现两个接口
        super<BaseInterface2>.baz()
    }
}

/**
 * 数据类，无法被继承，所以不能定义成abstract抽象的或open开放的
 */
data class Person(val name: String, val age: Int) {
    val isAdult: Boolean
        get() = age >= 18

    // 默认参数
    fun greet(greeting: String = "Welcome") {
        println("$greeting, I'm $name")
    }
}

/**
 * 对象表达式
 */
open class Student(name: String, age: Int) {
    open fun foo() {}
}

class Teacher {
    var student: Student? = null
    fun tech(student: Student) {
        this.student = student
    }
}

fun addStudent() {
    // 如果类有构造方法，则必须传递适当的构造方法参数给它
    Teacher().tech(object : Student("lixingyun", 21) {
        override fun foo() {
            super.foo()
            // println()不会被执行
            println("Student -> foo()")
        }
    })
}

/**
 * 不需要类，只需要对象
 */
fun test() {
    // 声明一个匿名对象
    val simple = object {
        var x: Int = 1
        var y: Int = 2
    }
    println(simple.x + simple.y)
}

/**
 * 也可以直接用object声明一个对象，通常这种对象会作为工具类使用
 */
object Utils {
    fun <T> add(x: Int, y: Int) = x + y
    fun <T> isEmpty(list: List<T>?): Boolean {
        return list?.isEmpty() ?: true
    }
}

/**
 * 伴生对象
 */
class MyClass(val name: String) {
    // 类的伴生对象
    companion object {
        val myclazz = MyClass("lixingyun")
        fun show() {
            println("I'm wanglin")
        }
    }
}

fun main() {
    val d = Derived("lixingyun", 18)
    d.foo()

    val di = DerivedInterface("wanglin", age = 20)
    di.bar()
    di.baz()

    val p = Person("lixingyun", 19)
    println(p.isAdult)
    p.greet()

    addStudent()

    test()

    println(Utils.add<Int>(1, 2))
    println(Utils.isEmpty(arrayListOf(1)))

    // 访问伴生对象
    println(MyClass.myclazz.name)
    MyClass.show()
}

---

感谢支持

更多内容，请移步《超级个体》。