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) {

//指定一个父类型(接口)的对象表达式

var ob1 = object : Outputable {

override fun output(msg: String) {

for (i in 1..6) {

println("${msg}")

}

}

}

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

}

输出结果：

随便输出点什么吧

随便输出点什么吧

随便输出点什么吧

随便输出点什么吧

随便输出点什么吧

随便输出点什么吧

-----------------------------------------------

初始化块

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) {

ObjectExprType().test()

}

输出结果：

Kotlin

Java

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

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

fun main(args: Array) {

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("${msg}")

}

}

}

//指定零个父类型的对象表达式

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) {

MyObject1.output("一起来学Kotlin")

println("-----------------------------------------------")

println(MyObject2.name)

MyObject2.test()

println("-----------------------------------------------")

println(MyObject3.name)

MyObject3.output("Kotlin真不错")

MyObject3.printInfo()

}

输出结果：

一起来学Kotlin

一起来学Kotlin

一起来学Kotlin

一起来学Kotlin

一起来学Kotlin

一起来学Kotlin

-----------------------------------------------

初始化块

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("${msg}")

}

}

}

}

fun main(args: Array) {

//使用伴生对象所在的类调用伴生对象的方法

MyClass.output("Kotlin必须学")

println(MyClass.name)

}

输出结果：

Kotlin必须学

Kotlin必须学

Kotlin必须学

Kotlin必须学

Kotlin必须学

Kotlin必须学

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("${msg}")

}

}

}

}

//为伴生对象扩展方法

fun MyClass.Companion.test() {

println("为伴生对象扩展的方法")

}

val MyClass.Companion.foo

get() = "为伴生对象扩展的属性"

fun main(args: Array) {

//使用伴生对象所在的类调用伴生对象的方法

MyClass.output("Kotlin必须学")

println(MyClass.name)

//通过伴生对象所在的类调用为伴生对象扩展的成员

MyClass.test()

println(MyClass.foo)

}

输出结果：

Kotlin必须学

Kotlin必须学

Kotlin必须学

Kotlin必须学

Kotlin必须学

Kotlin必须学

name属性值

为伴生对象扩展的方法

为伴生对象扩展的属性

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