对于Android使用从单个活动到所有必要活动的字符串。 就像java中的静态

public final static String TEA_NAME = "TEA_NAME";

Kotlin中的等效方法:

class MainActivity : AppCompatActivity() {
    companion object {
        const val TEA_NAME = "TEA_NAME"
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

另一个需要价值的活动是:

val teaName = MainActivity.TEA_NAME

如果你需要一个函数或属性绑定到一个类，而不是它的实例，你可以在一个伴随对象中声明它:

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
        }
    }
}

伴生对象是一个单例对象，它的成员可以通过包含类的名称直接访问

val car = Car.makeCar(150)
println(Car.Factory.cars.size)

在Java中，我们可以这样写

class MyClass {
  public static int myMethod() { 
  return 1;
  }
}

在Kotlin中，我们可以用下面的方式写

class MyClass {
  companion object {
     fun myMethod() : Int = 1
  }
}

在Kotlin中，一个同伴被用作静态。

很多人提到伴生对象，这是正确的。但是，正如你所知道的，你也可以使用任何类型的对象(使用对象关键字，而不是类)，即，

object StringUtils {
    fun toUpper(s: String) : String { ... }
}

像使用java中的静态方法一样使用它:

StringUtils.toUpper("foobar")

That sort of pattern is kind of useless in Kotlin though, one of its strengths is that it gets rid of the need for classes filled with static methods. It is more appropriate to utilize global, extension and/or local functions instead, depending on your use case. Where I work we often define global extension functions in a separate, flat file with the naming convention: [className]Extensions.kt i.e., FooExtensions.kt. But more typically we write functions where they are needed inside their operating class or object.

将它们直接写入文件。

在Java中(丑陋):

package xxx;
class XxxUtils {
  public static final Yyy xxx(Xxx xxx) { return xxx.xxx(); }
}

在芬兰湾的科特林:

@file:JvmName("XxxUtils")
package xxx
fun xxx(xxx: Xxx): Yyy = xxx.xxx()

这两段代码在编译后是相等的(甚至编译后的文件名file:JvmName用于控制编译后的文件名，该文件名应该放在包名声明之前)。

kotlin文档提供了三种方法， 第一个是在包中定义函数，没有类:

package com.example

fun f() = 1

第二个是使用@JvmStatic注释:

package com.example

class A{
@JvmStatic
fun f() = 1
}

第三个是使用伴侣对象

package com.example

clss A{
companion object{
fun f() = 1
}
}