object关键字:对象声明 对象表达式 伴生对象

object关键字:

对象声明 ,就是一个单例对象

object ApplicationConfig{
    init {
        println("ApplicationConfig loading...")
    }

    fun doSomething(){
        println("doSomething")
    }
}

对象表达式  :

该匿名类依然遵循object关键字的一个规则,一旦初始化,该匿名类只有唯一一个实例对象存在。

 对象声明 重写父类Player的 load()方法



open class Player{
    open fun load() = "loading nothing.."
}

fun main() {
    //对象声明 重写父类Player的 load()方法
    val p = object : Player(){
        override fun  load() = "anonymous nothing.."
    }

    println(p.load())

}

伴生对象  :

伴生对象的定义:

使用 companion 关键字声明的 companion object。 即为伴生对象

伴生对象内部的成员可以使用类名直接访问，而不需要创建类的实例。

 class MyClass {

   //类的 常规类成员
    var age:Int?=null

    companion object{
       // 伴生对象的成员
        const val CONSTANT_VALUE = 42
         fun staticFunction() {}
   
 }

}

fun main() {
    
    val value = MyClass.CONSTANT_VALUE
    MyClass.staticFunction()  
}

理解伴生对象的要点

1.接口：伴生对象可以扩展接口，这是在无需创建实例对象时定义与类相关的方法的有用方式。

2.单一实例：伴生对象是与类关联的单一实例，其成员在所有类的实例之间共享。

3.初始化：伴生对象在类加载时初始化（类似于 Java 中的静态块）。

4.可见性：伴生对象的成员可以使用类名从类外部访问，类似于其他语言中的静态成员。

5. 默认匿名：伴生对象默认为匿名对象，但可以根据需要提供自定义名称有名伴生对象。

class MyClass {

    // 伴生对象默认为匿名对象
    companion object {

         // 匿名伴生对象的成员
         const val CONSTANT_VALUE = 42
         fun staticFunction() {}

       init {
            // 初始化时执行的代码
        }    
 
    }


     companion object Factory {
        // 有名伴生对象的成员
         const val CONSTANT_VALUE = 12
        fun staticFunction() {}

      init {
            // 初始化时执行的代码
        }


    }



fun main() {
      //匿名伴生对象的成员可以使用类名MyClass从类外部访问
    val value = MyClass.CONSTANT_VALUE
    MyClass.staticFunction()  

     // 使用有名伴生对象名称Factory访问其成员
      val value = MyClass.Factory.CONSTANT_VALUE   
      MyClass.Factory.someMethod()

}


}

常见的伴生对象使用场景

 1.工厂方法

 

class MyClass private constructor() {
    companion object {
        fun create(): MyClass {
            return MyClass()
        }
    }
}

2.常量

 

class Constants {
    companion object {
        const val PI = 3.14
        const val VERSION = "1.0"
    }
}

3.单例模式

class Singleton {
    companion object {
        val instance: Singleton by lazy { Singleton() }
    }
}

4.实用函数

class Utils {
    companion object {
        fun performTask() {
            // 实现
        }
    }
}

5.共享首选项处理

class SharedPreferencesManager {
    companion object {
        fun saveData(key: String, value: String) {
            // 实现
        }
        fun getData(key: String): String {
            // 实现
        }
    }
}

6.数学运算

class MathOperations {
    companion object {
        fun add(a: Int, b: Int): Int {
            return a + b
        }
        fun multiply(a: Int, b: Int): Int {
            return a * b
        }
    }
}

7.日志记录

 

class Logger {
    companion object {
        fun log(message: String) {
            // 实现
        }
    }
}

8.扩展函数

class StringExtensions {
    companion object {
        fun String.reverse(): String {
            return this.reversed()
        }
    }
}

object 和 companion object 的区别

1. 与实例的关联

• object：表示一个与任何特定类实例无关的单例对象。它是一个独立对象。

• companion object：表示一个与特定类关联的对象。它与类本身相关联，可以访问其私有成员。

2. 可访问性

• object：可以直接通过名称访问，不与类关联，无法访问类成员。

• companion object：可以访问其所在类的私有成员，通过类名访问。

3. 命名

• object：在定义时可以赋予任何名称，没有默认名称可访问。

• companion object：如果未显式命名，默认名称为 Companion，通过类名访问。

4. 初始化

• object：不能有带参数的构造函数。初始化在对象主体中完成。

• companion object：可以有构造函数，允许用参数初始化。支持可选的初始化块。

class MyClass {

//MyClass 类的 常规类成员
 var age:Int?=null
 fun someFunction()

    //匿名伴生对象
   companion object {
      // 匿名伴生对象的成员
      const val CONSTANT_VALUE = 42
      fun staticFunction() {}


        // 初始化块
        init {
            // 初始化代码
        }
    }
}

5. 伴生对象成员的使用

• object：成员通过对象实例直接访问。

• companion object：成员通过类名访问。如果显式命名，使用该名称访问。

fun main() {

  // object
 val obj = MyClass
 obj.someFunction()
    

// companion object  
val value = MyClass.CONSTANT_VALUE

// companion object
MyClass.Companion.someFunction()
// 或
  MyClass.staticFunction()  


}

伴生对象与静态成员的区别

尽管 Kotlin 中的伴生对象和 Java 中的静态成员目的类似，提供了一种方法将方法和属性与类关联而不是实例，但两者之间还是存在一些区别。

1. 命名伴生对象：

在 Kotlin 中，伴生对象使用 companion 关键字显式命名，允许你赋予它有意义的名称。在 Java 中，静态成员没有特定名称，只需使用 static 关键字定义即可。

 

// Kotlin
class MyClass {
     //默认匿名伴生对象
    companion object {
        // ...
    }

   // 有名伴生对象
   
 companion object Factory{
        // ...
    }

}

// Java
public class MyClass {
    // 静态成员
    // ...
}

2. 初始化块init{}：

 在 Kotlin 中，伴生对象可以有一个初始化块init{}，用于在创建伴生对象时进行额外的设置。Java 中静态成员没有显式的初始化块。

// Kotlin
class MyClass {
    companion object {
        init {
            // 伴生对象的初始化块
        }
    }
}

// Java
public class MyClass {
    // 没有直接对应的静态初始化块
    // ...
}

3. 接口：

在 Kotlin 中，伴生对象可以实现接口，允许其定义接口的方法。Java 中静态成员不能直接实现接口。

// Kotlin 接口
interface MyInterface {
    fun myMethod()
}

class MyClass {
//伴生对象实现接口MyInterface 实现接口方法
    companion object : MyInterface {
        override fun myMethod() {
            // 伴生对象的实现
        }
    }
}

// Java
interface MyInterface {
    void myMethod();
}

public class MyClass {
    // 静态成员不能直接实现接口
}

4. 可见性：

 在 Kotlin 中，伴生对象可以有自己的可见性修饰符，允许单独控制其可见性。Java 中静态成员共享封闭类的可见性。

// Kotlin
class MyClass {
    private companion object {
        // 伴生对象的私有可见性
    }
}

// Java
public class MyClass {
    private static void myStaticMethod() {
        // 静态方法的私有可见性
    }
}

鸣谢:

Kotlin 中的伴生对象