Kotlin编程之对象的表达式和声明

谁践踏了优雅 2022-06-15 10:39 182阅读 0赞

**Kotlin编程相关知识点介绍**：

*  [Kotlin编程之使用Intellij IED和了解源文件（.kt）][Kotlin_Intellij IED_.kt]
 *  [Kotlin编程之类的介绍和使用][Kotlin]
 *  [Kotlin编程之类的属性][Kotlin 1]
 *  [Kotlin编程之方法][Kotlin 2]
 *  [Kotlin编程之父类和继承父类][Kotlin 3]
 *  [ Kotlin编程之接口和实现接口][Kotlin 4]
 *  [Kotlin编程之伴生对象，抽象类，密封类][Kotlin 5]
 *  [Kotlin编程之嵌套类，内部类，匿名内部类][Kotlin 6]

--------------------

前言：

> 有时候我们想要创建一个对当前类有一点小修改的对象，但不想重新声明一个子类。java 用匿名内部类的概念解决这个问题。Kotlin 用对象表达式和对象声明巧妙的实现了这一概念

## **对象表达式** ##

--------------------

用表达式创建某些继承匿名类的对象：

package com.xingen.kotlin.day2017529
    
    fun main(args: Array<String>) {
        test()
        test1()
    }
    /** * 测试有父类和接口的匿名类 */
    fun test() {
        var t = object : Test2017529("创建继承方式延伸的匿名内部类"), Test1Interface {
            override fun test() {
                println("创建接口延伸的匿名内部类")
            }
        }
        println(t.v)
        t.test()
    }
    /** * 测试无继承和实现的匿名类 */
    fun test1() {
        var t = object {
            var show: String = "没有父类的匿名类"
        }
        println(t.show)
    }
    /** * 创建一个父类 */
    open class Test2017529(str: String) {
        public open var v = str
    }
    /** * 定义一个接口 */
    interface Test1Interface {
        fun test()
    }

输出结果：

创建继承方式延伸的匿名内部类
    创建接口延伸的匿名内部类
    没有父类的匿名类

可知：

创建匿名类的方式`var t=object:父类（）,接口名`。  
**注意点**：

*  若是父类中有构造方法，创建匿名类时候，必需传递参数
 *  匿名类拥有多个父类时候，父类之间用逗号隔开
 *  可以创建不继承父类，也不实现接口的匿名类

## **对象声明** ##

--------------------

在Kotlin声明一个单例类的对象，用object修饰。在开发中经常用到的单例模式。

package com.xingen.kotlin.day2017529
    
    fun main(args: Array<String>) {
        TestListener.test()
    }
    /** * object关键字声明一个单例的对象 * * 对象声明与对象表达式区别： * * 对象声明和变量声明一样，不能作为右值赋给等号左边。 * * 调用方式： * 1. 类名.属性名 * 2. 类名.方法（） */
    object  TestListener:Test1Interface {
        override fun test() {
          println("object声明类对象")
        }
    }

输出结果：

object声明类对象

可知：

*  注意：对象声明不可以是局部的(比如不可以直接在函数内部声明)，但可以在其它对象的声明或非内部类中进行内嵌入

## **伴随对象** ##

--------------------

package com.xingen.kotlin.day2017529
    
    fun main(args: Array<String>) {
        Day2017529.test()
    }
    class Day2017529{ 
        /** * companion object声明一个伴生对象，对象名可以省略。 * 伴随对象中的方法可以作为静态方法使用 * * @JvmStatic标记，真实的静态方法和静态属性 */
        companion object Test{ 
           @JvmStatic fun  test(){
                println("伴随对象的静态使用")
            }
        }
    }

输出结果:

伴随对象的静态使用

可知：

*  companion 标记类内部中的对象声明，即修饰伴随对象，对象的名字可以省略。
 *  使用`@JvmStatic`的注解，可以使用多个伴随对象成为真实的静态方法和属性。

### **对象表达式，对象的声明，伴随对象之间的区别**： ###

--------------------

*  对象表达式是，在使用的地方立即初始化，且执行的
 *  对象声明是懒加载的，需要用到访问调用时初始化的
 *  伴随对象是对应的类加载时候，进行初始化的，和Java中的静态初始对应的。

[Kotlin_Intellij IED_.kt]: http://blog.csdn.net/hexingen/article/details/72820445
[Kotlin]: http://blog.csdn.net/hexingen/article/details/72820822
[Kotlin 1]: http://blog.csdn.net/hexingen/article/details/72820984
[Kotlin 2]: http://blog.csdn.net/hexingen/article/details/72821113
[Kotlin 3]: http://blog.csdn.net/hexingen/article/details/72822247
[Kotlin 4]: http://blog.csdn.net/hexingen/article/details/72822291
[Kotlin 5]: http://blog.csdn.net/hexingen/article/details/72823961
[Kotlin 6]: http://blog.csdn.net/hexingen/article/details/72824084