android开发分享Kotlin中的对象表达式和对象声明的具体使用

kotlin的对象表达式与java中的匿名内部类的主要区别:匿名内部类只能指定一个父类型,但对象表达式可以指定0~n个肤类型。 一、对象表达式 对象表达式的语法格式如下:

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

以上就是android开发分享Kotlin中的对象表达式和对象声明的具体使用的全部内容,希望对大家的学习有所帮助,也希望大家多多支持<计算机技术网(www.ctvol.com)!!>。

本文来自网络收集,不代表计算机技术网立场,如涉及侵权请联系管理员删除。

ctvol管理联系方式QQ:251552304

本文章地址:https://www.ctvol.com/addevelopment/899627.html

(0)
上一篇 2021年10月23日
下一篇 2021年10月23日

精彩推荐