Kotlin中的对象表达式和对象声明的具体使用

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()
}

输出结果：

kotlin
java

kotlin编译器可以识别private对象表达式的真实类型。

kotlin的对象表达式可访问或修饰其作用域内的局部变量。

fun main(args: array<string>) {
  var a = 20
  var obj = object {

    fun change() {
      println("change()方法修改变量a的值")
      a++
    }
  }
  obj.change()
  println(a)
}

输出结果：

change()方法修改变量a的值
21

kotlin的对象表达式比java的匿名内部类增强了三个方面：

• 对象表达式可指定多个父类型
• kotlin编译器能更准确地识别局部范围内private对象表达式的类型。
• 对象表达式可访问或修改其所在范围内的局部变量

二、对象声明和单例模式

对象声明的语法格式如下：

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

对象声明与对象表达式的语法很相似，区别在于：对象表达式在object关键字后没有名字；而对象声明需要在object关键字后指定名字。

两者还有如下区别：

• 对象表达式是一个表达式，可以被赋值给变量；而对象声明不是表达式，不能用于赋值。
• 对象声明可包含嵌套类，不能包含内部类；而对象表达式可包含内部类，不能包含嵌套类。
• 对象声明不能定义在函数和方法内；但对象表达式可嵌套在其他对象声明或非内部类中。

package `0705`

interface outputable {
  fun output(msg: string)
}

abstract class product(var price: double) {
  abstract val name: string
  abstract fun printinfo()
}

//指定一个父类型的对象表达式
object myobject1 : outputable {
  override fun output(msg: string) {
    for (i in 1..6) {
      println("<h${i}>${msg}</h${i}>")
    }
  }
}

//指定零个父类型的对象表达式
object myobject2 {
  //初始化块
  init {
    println("初始化块")
  }

  //属性
  var name = "kotlin"

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

  //只能包含嵌套类，不可以包含内部类
  class inner
}

//指定两个父类型的对象表达式
object myobject3 : outputable, product(1.23) {
  override fun output(msg: string) {
    println("输出信息：${msg}")
  }

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

  override fun printinfo() {
    println("高速极光打印机们支持自动双面打印！")
  }
}

fun main(args: array<string>) {

  myobject1.output("一起来学kotlin")
  println("-----------------------------------------------")
  println(myobject2.name)
  myobject2.test()
  println("-----------------------------------------------")
  println(myobject3.name)
  myobject3.output("kotlin真不错")
  myobject3.printinfo()
}

输出结果：

<h1>一起来学kotlin</h1>
<h2>一起来学kotlin</h2>
<h3>一起来学kotlin</h3>
<h4>一起来学kotlin</h4>
<h5>一起来学kotlin</h5>
<h6>一起来学kotlin</h6>
-----------------------------------------------
初始化块
kotlin
test方法
-----------------------------------------------
激光打印机
输出信息：kotlin真不错
高速极光打印机们支持自动双面打印！

对象声明专门用于实现单例模式，对象声明所定义的对象也就是该类的唯一实例，程序可通过对象声明的名称直接访问该类的唯一实例。

三、伴生对象和静态成员

在类中定义的对象声明，可使用companion修饰，这样该对象就变成了伴生对象。

每个类最多只能定义一个伴生对象，伴生对象相当于外部类的对象，程序可通过外部类直接调用伴生对象的成员。

package `0705`

interface companiontest {
  fun output(msg: string)
}

class myclass {
  //使用companion修饰的伴生对象
  companion object myobject1 : companiontest {
    val name = "name属性值"
    override fun output(msg: string) {
      for (i in 1..6) {
        println("<h${i}>${msg}</h${i}>")
      }
    }
  }
}

fun main(args: array<string>) {
  //使用伴生对象所在的类调用伴生对象的方法
  myclass.output("kotlin必须学")
  println(myclass.name)
}

输出结果：

<h1>kotlin必须学</h1>
<h2>kotlin必须学</h2>
<h3>kotlin必须学</h3>
<h4>kotlin必须学</h4>
<h5>kotlin必须学</h5>
<h6>kotlin必须学</h6>
name属性值

伴生对象的主要作用就是为其所在的外部类模拟静态成员，但只是模拟，伴生对象的成员依然是伴生对象本身的实例成员，并不属于伴生对象所在的外部类。

四、伴生对象的扩展

伴生对象也可以被扩展。如果一个类具有伴生对象，则kotlin允许为伴生对象扩展方法和属性。

package `0705`

interface companiontest {
  fun output(msg: string)
}

class myclass {
  //使用companion修饰的伴生对象
  companion object : companiontest {
    val name = "name属性值"
    override fun output(msg: string) {
      for (i in 1..6) {
        println("<h${i}>${msg}</h${i}>")
      }
    }
  }
}

//为伴生对象扩展方法
fun myclass.companion.test() {
  println("为伴生对象扩展的方法")
}

val myclass.companion.foo
  get() = "为伴生对象扩展的属性"

fun main(args: array<string>) {
  //使用伴生对象所在的类调用伴生对象的方法
  myclass.output("kotlin必须学")
  println(myclass.name)
  //通过伴生对象所在的类调用为伴生对象扩展的成员
  myclass.test()
  println(myclass.foo)

}

输出结果：

<h1>kotlin必须学</h1>
<h2>kotlin必须学</h2>
<h3>kotlin必须学</h3>
<h4>kotlin必须学</h4>
<h5>kotlin必须学</h5>
<h6>kotlin必须学</h6>
name属性值
为伴生对象扩展的方法
为伴生对象扩展的属性

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。