java静态方法到kotlin等效方法的确切转换如下所示。例:这里util类有一个静态方法，它在java和kotlin中都是等效的。@JvmStatic的使用非常重要。

Java代码:

    class Util{
         public static String capitalize(String text){
         return text.toUpperCase();}
       }

芬兰湾的科特林代码:

    class Util {
        companion object {
            @JvmStatic
            fun capitalize(text:String): String {
                return text.toUpperCase()
            }
        }
    }

我想对以上的回答做一些补充。

是的，你可以在源代码文件中定义函数(在类之外)。但是如果使用Companion Object在类中定义静态函数会更好，因为您可以通过利用Kotlin Extensions添加更多静态函数。

class MyClass {
    companion object { 
        //define static functions here
    } 
}

//Adding new static function
fun MyClass.Companion.newStaticFunction() {
    // ...
}

你可以调用上面定义的函数，就像你调用伴侣对象中的任何函数一样。

你把函数放在“同伴对象”中。

java代码是这样的:

class Foo {
  public static int a() { return 1; }
}

将成为

class Foo {
  companion object {
     fun a() : Int = 1
  }
}

然后，您可以在Kotlin代码中作为

Foo.a();

但是在Java代码中，您需要将其调用为

Foo.Companion.a();

(也可以在Kotlin内部工作。)

如果您不喜欢指定Companion位，您可以添加@JvmStatic注释或命名您的Companion类。

从文档中可以看出:

Companion Objects An object declaration inside a class can be marked with the companion keyword: class MyClass { companion object Factory { fun create(): MyClass = MyClass() } } Members of the companion object can be called by using simply the class name as the qualifier: val instance = MyClass.create() ... However, on the JVM you can have members of companion objects generated as real static methods and fields, if you use the @JvmStatic annotation. See the Java interoperability section for more details.

添加@JvmStatic注释如下所示

class Foo {
  companion object {
    @JvmStatic
    fun a() : Int = 1;
  }
}

然后它将作为一个真正的Java静态函数存在，从 Java和Kotlin的Foo.a()。

如果只是不喜欢Companion名称，那么也可以 为同伴对象提供一个显式的名称，如下所示:

class Foo {
  companion object Blah {
    fun a() : Int = 1;
  }
}

这将让您以同样的方式从Kotlin调用它，但是 来自java，如Foo.Blah.a()(这也可以在Kotlin中工作)。

A.旧Java方式:

声明一个伴随对象来包含一个静态方法/变量 类Foo { 伴随对象{ fun foo() = println(" foo ") Val bar ="bar" ｝ ｝ 使用: Foo. Foo() //输出Foo println(Foo.bar) //输出bar

B.新的Kotlin方式

直接在文件上声明，而不需要在.kt文件上使用类。 fun foo() = println(" foo ") Val bar ="bar" 使用方法/变量的名称。(导入后) 使用: foo() //输出foo println(bar) //输出bar

Docs建议使用包级函数来解决静态函数的大部分需求。它们只是在源代码文件中的类之外声明的。文件的包可以在文件的开头用关键字package指定。

宣言

package foo

fun bar() = {}

使用

import foo.bar

另外

import foo.*

你现在可以调用函数:

bar()

或者不使用import关键字:

foo.bar()

如果不指定包，则可以从根目录访问该函数。

如果您只有java经验，这可能看起来有点奇怪。原因是kotlin不是严格的面向对象语言。你可以说它支持类之外的方法。

编辑: 他们编辑了文档，不再包含关于推荐包级函数的句子。这是上面提到的原稿。

简单地使用这种方法

object Foo{
   fun foo() = println("Foo")
   val bar ="bar"  
}

Foo.INSTANCE.foo()