Kotlin学习之 13对象表达式和对象声明

深藏阁楼爱情的钟 2022-05-26 08:05 238阅读 0赞

# Kotlin 对象表达式和对象声明 #

Kotlin 用对象表达式和对象声明来实现创建一个对某个类做了轻微改动的类的对象，且不需要去声明一个新的子类。  
本文的object是关键字，注意没有大写。

## 一.对象表达式 ##

### 1.通过对象表达式实现一个匿名内部类的对象用于方法的参数中： ###

window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            // ...
        }
        override fun mouseEntered(e: MouseEvent) {
            // ...
        }
    })

上面的匿名内部类，类似Android的Button点击事件监听，或者ListView的Item监听事件。

### 2.对象可以继承于某个基类，或者实现其他接口: ###

open class A(x: Int) {
        public open val y: Int = x
    }
    
    interface B {……}
    
    val ab: A = object : A(1), B {
        override val y = 15
    }

### 3.如果超类型有一个构造函数，则必须传递参数给它。多个超类型和接口可以用逗号分隔。 ###

通过对象表达式可以越过类的定义直接得到一个对象：

fun main(args: Array<String>) {
        val site = object {
            var name: String = "菜鸟教程"
            var url: String = "www.runoob.com"
        }
        println(site.name)
        println(site.url)
    }

上面这个示例代码是可以直接运行的。

### 4.匿名对象可以用作只在本地和私有作用域中声明的类型。 ###

如果你使用匿名对象作为公有函数的 返回类型或者用作公有属性的类型，  
那么该函数或属性的实际类型 会是匿名对象声明的超类型，  
如果你没有声明任何超类型，就会是 Any。  
在匿名对象中添加的成员将无法访问。

class C {
        
        // 私有函数，所以其返回类型是匿名对象类型
        private fun foo() = object {
        
            val x: String = "x"
        }
    
        // 公有函数，所以其返回类型是 Any
        fun publicFoo() = object {
        
            val x: String = "x"
        }
    
        fun bar() {
            val x1 = foo().x        // 没问题
            val x2 = publicFoo().x  // 错误：未能解析的引用“x”
        }
    }

有点不明白，为啥私有的方法属性可以再本地访问，而共有的方法属性不能在本地访问，设计者这是要干嘛？

### 4.在对象表达中可以方便的访问到作用域中的其他变量: ###

fun countClicks(window: JComponent) {
        var clickCount = 0
        var enterCount = 0
    
        window.addMouseListener(object : MouseAdapter() {
            override fun mouseClicked(e: MouseEvent) {
                clickCount++
            }
    
            override fun mouseEntered(e: MouseEvent) {
                enterCount++
            }
        })
        // ……
    }

## 二.对象声明 ##

Kotlin 使用 object 关键字来声明一个对象。

### 1.Kotlin 中我们可以方便的通过对象声明来获得一个单例。 ###

object DataProviderManager {
        
        fun registerDataProvider(provider: DataProvider) {
            // ……
        }
    
        val allDataProviders: Collection<DataProvider>
            get() = // ……
    }

### 2.引用该对象，我们直接使用其名称即可： ###

DataProviderManager.registerDataProvider(……)

当然你也可以定义一个变量来获取获取这个对象，当时当你定义两个不同的变量来获取这个对象时，你会发现你并不能得到两个不同的变量。  
也就是说通过这种方式，我们获得一个单例。

var data1 = DataProviderManager
    var data2 = DataProviderManager
    data1.name = "test"
    print("data1 name = ${data2.name}")

### 3.实例 ###

以下实例中，两个对象都输出了同一个 url 地址：

object Site {
        var url:String = ""
        val name: String = "菜鸟教程"
    }
    fun main(args: Array<String>) {
        var s1 =  Site
        var s2 = Site
        s1.url = "www.runoob.com"
        println(s1.url)
        println(s2.url)
    }

#### 输出结果为: ####

www.runoob.com
    www.runoob.com

### 4.对象可以有超类型： ###

object DefaultListener : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            // ……
        }
    
        override fun mouseEntered(e: MouseEvent) {
            // ……
        }
    }

与对象表达式不同，当对象声明在另一个类的内部时，这个对象并不能通过外部类的实例访问到该对象，  
而只能通过类名来访问，同样该对象也不能直接访问到外部类的方法和变量。

#### 示例 ####

class Site {
        
        var name = "菜鸟教程"
        object DeskTop{
        
            var url = "www.runoob.com"
            fun showName(){
                //print("desk legs $name") // 错误，不能访问到外部类的方法和变量
                var n=Site()
                println("desk legs ${n.name}") // 正确，自己创建对象来访问
            }
        }
    }
    fun main(args: Array<String>) {
        var site = Site()
        //val url=site.DeskTop.url // 错误，不能通过外部类的实例访问到该对象
        val url=Site.DeskTop.url // 正确
        println(site.name)
        println(url)
    
        //访问DeskTop的内部方法
        Site.DeskTop.showName()
    
    
    }

#### 运行结果： ####

菜鸟教程
    www.runoob.com
    desk legs 菜鸟教程

从上面一个例子可以简单的理解，object定义的内部类，相当于一个静态类。

## 三.伴生对象 ##

### 1.类内部的对象声明可以用 companion 关键字标记. ###

这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素。

class MyClass {
        
        companion object Factory {
        
            fun create(): MyClass = MyClass()
        }
    }
    
    val instance = MyClass.create()   // 访问到对象的内部元素

### 2.我们可以省略掉该对象的对象名，然后使用 Companion 替代需要声明的对象名： ###

class MyClass {
        
        companion object {
        
        }
    }
    
    val x = MyClass.Companion

注意：一个类里面只能声明一个内部关联对象，即关键字 companion 只能使用一次。

### 3.请伴生对象的成员看起来像其他语言的静态成员，但在运行时他们仍然是真实对象的实例成员。 ###

例如还可以实现接口：

interface Factory<T> {
        fun create(): T
    }
    
    
    class MyClass {
        companion object : Factory<MyClass> {
            override fun create(): MyClass = MyClass()
        }
    }

### 4.对象表达式和对象声明之间的语义差异 ###

对象表达式和对象声明之间有一个重要的语义差别：

对象表达式是在使用他们的地方立即执行的
    
    对象声明是在第一次被访问到时延迟初始化的
    
    伴生对象的初始化是在相应的类被加载（解析）时，与 Java 静态初始化器的语义相匹配

### 5.实例1 ###

class MyClass {
        
        companion object {
        //伴生对象
            var text="伴生对象文字"
            fun foo(){
                println("伴生对象的方法")
            }       
        }
    
    }
    
    
    
    fun main(arg : Array<String>){
        val x = MyClass.Companion //获取伴生对象
        println(x.text)   //获取半生对象的属性
        x.foo()           //调用伴生对象的方法   
    }

#### 代码运行结果： ####

伴生对象文字
    伴生对象的方法

### 6.实例2 ###

class Test{
        var test:String="Test"
    }
    
    interface Factory<T> { //定义接口
        fun create(): T
    }
    
    class MyClass {
    
         companion object : Factory<Test> { //继承接口
            override fun create(): Test = Test()
        }
    }
    
    
    
    fun main(arg : Array<String>){
        val x = MyClass.Companion //获取伴生对象,这里是接口对象
        val y=x.create()  //调用接口对象的方法，得到类Test对象
        val z=y.test     //获取Test对象的属性
        println("result:"+z)
    }

#### 代码运行结果； ####

result:Test

感觉这个Kotlin的对象表达式和对象声明没什么大作用！上面能看懂一两个示例就可以了。

需要的话可以在线测试一下：[https://blog.csdn.net/wenzhi20102321/article/details/79859347][https_blog.csdn.net_wenzhi20102321_article_details_79859347]

# 共勉：计划并行动 #

[https_blog.csdn.net_wenzhi20102321_article_details_79859347]: https://blog.csdn.net/wenzhi20102321/article/details/79859347