原创

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属性值
为伴生对象扩展的方法
为伴生对象扩展的属性

学海无涯苦作舟

我的微信公众号.jpg

基本语法
  • 作者:HunterArley (联系作者)
  • 发表时间:2019-11-26 10:45
  • 版权声明:本网站部分内容转载于合作站点或其他站点,但都会注明作/译者和原出处。如有不妥之处,敬请指出。
  • 公众号转载:请在文末添加作者公众号二维码