前言
本文章只是用于记录学习，所以部分地方如果有错误或者理解不对的地方，麻烦请指正。本篇为 csdn 原文章 转移修改版 原文章
Java中，不管是为了实现接口，或者是抽象类，我们总是习惯使用匿名内部类。最熟悉的例子，莫过于对单击事件的监听.
btn.setOnClickListener(new OnClickListener{
// 处理单击事件逻辑
});
Kotlin没有匿名内部类，恰巧其用object一个简单的关键字，解决了这一个问题,我们一起来学习下。
对象表达式
对象表达式更倾向于表达式这一点，针对 java 中点击事件的使用，我们演示下再kotlin 中如何编写
btn.setOnClickListener(object : OnClickListener{
});
对象表达式内的代码可以访问创建这个对象的代码范围内的变量，与Java不同的是,被访问的变量不需要被限制为final变量（挺爽的）。
var a = 10
val listener = object {
fun doClick() {
println("a:$a")
}
}
listener.doClick() // 打印 a:10
当然我们也可以只是用对象
val adHoc = object {
var x: Int = 0
var y: Int = 0
}
print(adHoc.x + adHoc.y)
接下来我们看一下 对象在继承实现方面的使用
open class A(x: Int) {
public open val y: Int = x
}
interface B {……}
val ab: A = object : A(1), B {
override val y = 15
}
如果超类型有一个构造函数，则必须传递参数给它。多个超类型和接口可以用逗号分隔。
请注意，匿名对象可以用作只在本地和私有作用域中声明的类型。如果你使用匿名对象作为公有函数的 返回类型或者用作公有属性的类型，那么该函数或属性的实际类型 会是匿名对象声明的超类型，如果你没有声明任何超类型，就会是 Any。在匿名对象 中添加的成员将无法访问
class C {
// 私有函数，所以其返回类型是匿名对象类型
private fun foo() = object {
val x: String = "x"
}
// 公有函数，所以其返回类型是 Any
fun publicFoo() = object {
val x: String = "x"
}
fun bar() {
val x1 = foo().x // 没问题
val x2 = publicFoo().x // 错误：未能解析的引用“x”
}
}
2. 对象声明
所谓的对象声明，我们可以理解为 java 中的单例模式。
object Site {
var url:String = ""
val name: String = "ymc"
}
fun main(args: Array<String>) {
var s1 = Site
var s2 = Site
s1.url = "www.google.com"
println(s1.url)
println(s2.url)
}
输出结果
www.google.com
www.google.com
可以看到，object 指向的对象是同一个。
与对象表达式不同，当对象声明在另一个类的内部时，这个对象并不能通过外部类的实例访问到该对象，而只能通过类名来访问
同样该对象也不能直接访问到外部类的方法和变量。
class ObjectDemo {
var objName = "菜鸟教程"
object DeskTop{
var url = "www.runoob.com"
fun showName(){
print{"desk legs $objName"} // 错误，不能访问到外部类的方法和变量
}
}
}
fun main(args: Array<String>) {
ObjectDemo.DeskTop.url //只能通过类名 访问到，而不能通过实例
val obj = ObjectDemo()
obj.objName // 通过实例 不能访问到 ObjectDemo 对象
}
3. 伴生对象
类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素。当然我们也可以省略对象的对象名，使用 Companion 来代替
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
val instance = MyClass.create() // 访问到对象的内部元素
--------------------------
// 也可以这样写
class MyClass {
companion object {
}
}
val x = MyClass.Companion //直接使用 companion 代替
注意：一个类里面只能声明一个内部关联对象，即关键字 companion 只能使用一次。
请伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员。例如还可以实现接口：
interface Factory<T> {
fun create(): T
}
class MyClass {
companion object : Factory<MyClass> {
override fun create() : MyClass{
return MyClass()
}
}
}
