Kotlin的对象表达式与Java中的匿名内部类的主要区别：匿名内部类只能指定一个父类型，但对象表达式可以指定0~N个肤类型。

一、对象表达式

对象表达式的语法格式如下：

object [: 0~N个父类型]{
  //对象表达式的类体部分
}

对象表达式还有如下规则：

对象表达式不能是抽象类，因为系统在创建对象表达式时会立即创建对象。因此不允许将对象表达式定义成抽象类。 对象表达式不能定义构造器。但对象表达式可以定义初始化块，可以通过初始化块来完成构造器需要完成的事情。 对象表达式可以包含内部类，不能包含嵌套类。

package `0705`

interface Outputable {
  fun output(msg: String)
}

abstract class Product(var price: Double) {
  abstract val name: String
  abstract fun printInfo()
}

fun main(args: Array<String>) {
  //指定一个父类型（接口）的对象表达式
  var ob1 = object : Outputable {
    override fun output(msg: String) {
      for (i in 1..6) {
        println("<h${i}>${msg}</h${i}>")
      }
    }
  }
  ob1.output("随便输出点什么吧")
  println("-----------------------------------------------")
  //指定零个父类型的对象表达式
  var ob2 = object {
    //初始化块
    init {
      println("初始化块")
    }

    //属性
    var name = "Kotlin"

    //方法
    fun test() {
      println("test方法")
    }

    //只能包含内部类，不可以包含嵌套类
    inner class Inner
  }
  println(ob2.name)
  ob2.test()
  println("-----------------------------------------------")
  //指定两个父类型的对象表达式
  var ob3 = object : Outputable, Product(1.23) {
    override fun output(msg: String) {
      println("输出信息：${msg}")
    }

    override val name: String
      get() = "激光打印机"

    override fun printInfo() {
      println("高速极光打印机们支持自动双面打印！")
    }
  }
  println(ob3.name)
  ob3.output("Kotlin慢慢学")
  ob3.printInfo()
}

输出结果：

<h1>随便输出点什么吧</h1>
<h2>随便输出点什么吧</h2>
<h3>随便输出点什么吧</h3>
<h4>随便输出点什么吧</h4>
<h5>随便输出点什么吧</h5>
<h6>随便输出点什么吧</h6>
-----------------------------------------------
初始化块
Kotlin
test方法
-----------------------------------------------
激光打印机
输出信息：Kotlin慢慢学
高速极光打印机们支持自动双面打印！

Kotlin的对象表达式可分为两种情形：

对象表达式在方法的局部范围内，或使用private修饰的对象表达式，Kotlin编译器可识别对象表达式的真实类型。 非private修饰的对象表达式与Java的匿名内部类相似，编译器只会把对象表达式当成它所继承的父类或所实现的接口处理。如果它没有父类型，系统当它是Any类型。

package `0705`

class ObjectExprType {
  private val ob1 = object {
    val name: String = "Kotlin"
  }
  internal val ob2 = object {
    val name: String = "Kotlin"
  }
  private fun privateBar()=object {
    val name:String="Java"
  }
  fun publicBar()=object {
    val name:String="Java"
  }
  fun test(){
    //ob1是private对象表达式，编译器可识别它的真实类型
    println(ob1.name)
    //ob2是非private对象表达式，编译器当它是Any类型
//    println(ob2.name)
    //privateBar是private函数，编译器可识别它返回的对象表达式的真实类型
    println(privateBar().name)
    //publicBar是非private函数，编译器将它返回的对象表达式当成Any类型
//    println(publicBar().name)
  }
}

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