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的对象表达式可分为两种情形:
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的匿名内部类增强了三个方面:
二、对象声明和单例模式
对象声明的语法格式如下:
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属性值 为伴生对象扩展的方法 为伴生对象扩展的属性
以上就是本文的全部内容,希望对大家的学习有所帮助。