首先申明下，本文为笔者学习《Kotlin 程序开发入门精要》的笔记，并加入笔者自己的理解和归纳总结。

在Java中，有一个匿名类的概念，在Kotlin中，也有类似的功能，就是对象。

1. 对象

建立一个对象，需要使用object关键字，该对象要继承的类需要与object之间用冒号(:)分隔。

open class Operation(var base : Int) {

    open fun add(step : Int) {
        println(base + step)
    }

}

fun main(args : Array<String>) {
    var op = Operation(10)
    op.add(1)  // 11

    op = object : Operation(10) {
            override fun add(step : Int) {
                println(base + step * 10)
            }
        }
    op.add(1)  // 20
}

对象和类一样，只能有一个父类，但可以实现多个接口。

interface ISubtract {
    fun sub(v : Int)
}

fun main(args : Array<String>) {
    ... ...

    op = object : Operation(20), ISubtract {
        override fun sub(v : Int) {
            println(base - v)
        }
    }
}

如果只想建立一个对象，不想继承类或者接口，可以直接使用object定义

fun main(args : Array<String>) {
    var obj = object {
        var x = 15
        var y = 20
    }
    println(obj.x + obj.y)  // 35
}

2. 声明对象

对象只能用于本地(函数)或private声明中，如果你们对象用于public函数的返回，或public属性的类型，那么编译器会将这些函数或属性的的返回类型重新定义为对象的父类。

class Anno {
    private var v1 = object {
        var x = 10
    }
    var v2 = object {
        var x = 10
    }

    private fun foo() = object : Operation(10) {
        var x = 10
    }

    fun publicFoo() = object : Operation (10) {
        var x = 10
    }

    fun call() {
        println(v1.x)  // 可以访问，10
        // println(v2.x)  编译错误
        var op1 = foo()
        op1.add(1)  // 可以访问，11
        println(op1.x)  // 可以访问，10
        var op2 = publicFoo()
        op2.add(2)  // 可以访问，12
        // println(op2.x) 编译错误
    }

}

3. 访问变量

对象可以任意访问封闭作用域内的变量，包括修改。

fun main(args : Array<String>) {
    var v = 10

    var obj = object {
        fun foo() {
            v = 100  // 修改封闭作用域内的变量
        }
    }

    println(v)  // 10
    obj.foo()
    println(v)  // 100
}

4. 陪伴对象

陪伴对象用来实现静态类成员的功能，使用companion关键字声明。陪伴对象中定义的成员是可以直接通过类名访问的。

class Shape {

    companion object Factory {
        fun create() = Shape()
    }

}

fun main(args : Array<String>) {
    var s = Shape.create()
}

陪伴对象可以实现kotlin的单例模式，返回的对象是同一个实例。

class Singleton private constructor() {

    private object mHolder {
        val INSTANCE = Singleton()
    }

    companion object Factory {
        fun getInstance() = mHolder.INSTANCE
    }
}

fun main(args : Array<String>) {
    var s1 = Singleton.getInstance()
    var s2 = Singleton.getInstance()
    println(s1 == s2)  // true
}