如何在Kotlin中使用对象表达式和对象声明

这期内容当中小编将会给大家带来有关如何在Kotlin中使用对象表达式和对象声明,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。

一、对象表达式

如何在Kotlin中使用对象表达式和对象声明

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

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

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

  • 对象表达式不能是抽象类,因为系统在创建对象表达式时会立即创建对象。因此不允许将对象表达式定义成抽象类。

  • 对象表达式不能定义构造器。但对象表达式可以定义初始化块,可以通过初始化块来完成构造器需要完成的事情。

  • 对象表达式可以包含内部类,不能包含嵌套类。

package`0705`

interfaceOutputable{
funoutput(msg:String)
}

abstractclassProduct(varprice:Double){
abstractvalname:String
abstractfunprintInfo()
}

funmain(args:Array<String>){
//指定一个父类型(接口)的对象表达式
varob1=object:Outputable{
overridefunoutput(msg:String){
for(iin1..6){
println("<h${i}>${msg}</h${i}>")
}
}
}
ob1.output("随便输出点什么吧")
println("-----------------------------------------------")
//指定零个父类型的对象表达式
varob2=object{
//初始化块
init{
println("初始化块")
}

//属性
varname="Kotlin"

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

//只能包含内部类,不可以包含嵌套类
innerclassInner
}
println(ob2.name)
ob2.test()
println("-----------------------------------------------")
//指定两个父类型的对象表达式
varob3=object:Outputable,Product(1.23){
overridefunoutput(msg:String){
println("输出信息:${msg}")
}

overridevalname:String
get()="激光打印机"

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

输出结果:

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

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

  • 对象表达式在方法的局部范围内,或使用private修饰的对象表达式,Kotlin编译器可识别对象表达式的真实类型。

  • 非private修饰的对象表达式与Java的匿名内部类相似,编译器只会把对象表达式当成它所继承的父类或所实现的接口处理。如果它没有父类型,系统当它是Any类型。

package`0705`

classObjectExprType{
privatevalob1=object{
valname:String="Kotlin"
}
internalvalob2=object{
valname:String="Kotlin"
}
privatefunprivateBar()=object{
valname:String="Java"
}
funpublicBar()=object{
valname:String="Java"
}
funtest(){
//ob1是private对象表达式,编译器可识别它的真实类型
println(ob1.name)
//ob2是非private对象表达式,编译器当它是Any类型
//println(ob2.name)
//privateBar是private函数,编译器可识别它返回的对象表达式的真实类型
println(privateBar().name)
//publicBar是非private函数,编译器将它返回的对象表达式当成Any类型
//println(publicBar().name)
}
}

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

输出结果:

KotlinJava

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

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

funmain(args:Array<String>){
vara=20
varobj=object{

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

输出结果:

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

Kotlin的对象表达式比Java的匿名内部类增强了三个方面:

  • 对象表达式可指定多个父类型

  • Kotlin编译器能更准确地识别局部范围内private对象表达式的类型。

  • 对象表达式可访问或修改其所在范围内的局部变量

二、对象声明和单例模式

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

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

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

两者还有如下区别:

  • 对象表达式是一个表达式,可以被赋值给变量;而对象声明不是表达式,不能用于赋值。

  • 对象声明可包含嵌套类,不能包含内部类;而对象表达式可包含内部类,不能包含嵌套类。

  • 对象声明不能定义在函数和方法内;但对象表达式可嵌套在其他对象声明或非内部类中。

package`0705`

interfaceOutputable{
funoutput(msg:String)
}

abstractclassProduct(varprice:Double){
abstractvalname:String
abstractfunprintInfo()
}

//指定一个父类型的对象表达式
objectMyObject1:Outputable{
overridefunoutput(msg:String){
for(iin1..6){
println("<h${i}>${msg}</h${i}>")
}
}
}

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

//属性
varname="Kotlin"

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

//只能包含嵌套类,不可以包含内部类
classInner
}

//指定两个父类型的对象表达式
objectMyObject3:Outputable,Product(1.23){
overridefunoutput(msg:String){
println("输出信息:${msg}")
}

overridevalname:String
get()="激光打印机"

overridefunprintInfo(){
println("高速极光打印机们支持自动双面打印!")
}
}

funmain(args:Array<String>){

MyObject1.output("一起来学Kotlin")
println("-----------------------------------------------")
println(MyObject2.name)
MyObject2.test()
println("-----------------------------------------------")
println(MyObject3.name)
MyObject3.output("Kotlin真不错")
MyObject3.printInfo()
}

输出结果:

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

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

三、伴生对象和静态成员

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

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

package`0705`

interfaceCompanionTest{
funoutput(msg:String)
}

classMyClass{
//使用companion修饰的伴生对象
companionobjectMyObject1:CompanionTest{
valname="name属性值"
overridefunoutput(msg:String){
for(iin1..6){
println("<h${i}>${msg}</h${i}>")
}
}
}
}

funmain(args:Array<String>){
//使用伴生对象所在的类调用伴生对象的方法
MyClass.output("Kotlin必须学")
println(MyClass.name)
}

输出结果:

<h2>Kotlin必须学</h2><h3>Kotlin必须学</h3><h4>Kotlin必须学</h4><h5>Kotlin必须学</h5><h6>Kotlin必须学</h6><h7>Kotlin必须学</h7>name属性值

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

四、伴生对象的扩展

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

package`0705`

interfaceCompanionTest{
funoutput(msg:String)
}

classMyClass{
//使用companion修饰的伴生对象
companionobject:CompanionTest{
valname="name属性值"
overridefunoutput(msg:String){
for(iin1..6){
println("<h${i}>${msg}</h${i}>")
}
}
}
}

//为伴生对象扩展方法
funMyClass.Companion.test(){
println("为伴生对象扩展的方法")
}

valMyClass.Companion.foo
get()="为伴生对象扩展的属性"

funmain(args:Array<String>){
//使用伴生对象所在的类调用伴生对象的方法
MyClass.output("Kotlin必须学")
println(MyClass.name)
//通过伴生对象所在的类调用为伴生对象扩展的成员
MyClass.test()
println(MyClass.foo)

}

输出结果:

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

上述就是小编为大家分享的如何在Kotlin中使用对象表达式和对象声明了,如果刚好有类似的疑惑,不妨参照上述分析进行理解。如果想知道更多相关知识,欢迎关注恰卡编程网行业资讯频道。

发布于 2021-02-24 07:34:45
收藏
分享
海报
0 条评论
165
上一篇:如何在Android项目中求相对路径 下一篇:如何在python中pandas cumsum求累计次数
目录

    0 条评论

    本站已关闭游客评论,请登录或者注册后再评论吧~

    忘记密码?

    图形验证码