Question

Factory和Factory2有什么区别？他们俩似乎都在做同样的事情。

data class Car(val horsepowers: Int) {
companion object Factory {
    val cars = mutableListOf<Car>()

    fun makeCar(horsepowers: Int): Car {
        val car = Car(horsepowers)
        cars.add(car)
        return car
    }
}
object Factory2 {
    val cars = mutableListOf<Car>()
    fun makeCar(horsepowers: Int): Car {
        val car = Car(horsepowers)
        cars.add(car)
        return car
    }
}
}

Answer 1

伴随对象是一种特定类型的对象声明，它允许对象执行与其他语言（例如Java）中的静态对象相似的操作。即使在Kotlin中不存在实际的静态概念，在对象声明中添加伴随对象也可以为对象添加“静态”功能。

Answer 2

可以使用类名直接访问在伴随对象中声明的属性和函数，就像我们在Java中访问静态成员一样。

因此在您的代码中，可以通过以下两种方式调用Factory的makeCar函数

Car.makeCar(50)         // From outside the class
Car.Factory.makeCar(50) // From outside the class
makeCar(50)             // From inside the class
Factory.makeCar(50)     // From insie the class

另一方面，Factory2的makeCar函数只能按以下方式调用。

Car.Factory2.makeCar(50) // From outside the class
Factory2.makeCar(50)     // Inside the class

Answer 3

kotlin 中的

Object 是一种实现单例的方式。

object MyObject {

// further implementation
  
  fun printHello() {
    println("Hello World!")
  }
  
}

这个实现也称为对象声明。对象声明是线程安全的并且是延迟初始化的，即对象在第一次被访问时初始化。

伴随对象 如果我们希望某些实现是一个类，但仍希望将某些行为公开为静态行为，那么伴随对象就派上用场了。这些是类中的对象声明。这些伴随对象在包含类解析时被初始化，类似于java世界中的静态方法和变量。

class MyClass {

  // some implementations
  
  companion object {
    val SOME_STATIC_VARIABLE = "STATIC_VARIABLE"
    fun someStaticFunction() {
      // static function implementation
    }
  }
}

类中的对象与伴侣对象

3 个答案: