什么是Kotlin的Java静态方法的等价物？

Kotlin中没有static关键字。

在Kotlin中表示static Java方法的最好方法是什么？

Answer 1

您将该function放在“伴侣对象”中。

所以这样的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关键字来标记：

 class MyClass { companion object Factory { fun create(): MyClass = MyClass() } } 

同伴对象的成员可以简单地使用类名作为限定符来调用：

 val instance = MyClass.create() 

…

但是，如果使用@JvmStatic注释，那么在JVM上可以将伴随对象的成员生成为真正的静态方法和字段。 有关更多详细信息，请参阅Java互操作性部分。

添加@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调用它，但是从像Foo.Blah.a()这样的Java（它也将在Kotlin中工作Foo.Blah.a()调用它。

Answer 2

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

宣言

 package foo fun bar() = {} 

用法

 import foo.bar 

另外

 import foo.* 

您现在可以通过以下方式调用函数：

 bar() 

或者如果您不使用import关键字：

 foo.bar() 

如果您不指定包，则可以从根访问该function。

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

Answer 3

1.定义 ：

任何 method/ val/ var内部的object （关键字为Singleton ）将在java中像静态一样。

如果您想简单地使用包含对象的类来调用方法，请使用companion object对象。

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

2.用法：

 Foo.sayFoo() println(Foo.bar) 

3.输出：

 Foo bar 

Answer 4

使用对象来表示val / var / method来创建静态。 你也可以使用object而不是singleton类。 如果你想在一个类中创建静态，你可以使用companion

 object Abc{ fun sum(a: Int, b: Int): Int = a + b } 

Answer 5

因为kotlin没有static关键字，所以你需要传递伴侣对象作为静态方法 – 可以简单地使用类名作为限定符来调用伴随对象的成员：

 package xxx class ClassName { companion object { fun helloWord(str: String): String { return stringValue } } } 

Answer 6

Kotlin没有任何静态关键字。 你用这个为java

  class AppHelper { public static int getAge() { return 30; } } 

和Kotlin

 class AppHelper { companion object { fun getAge() : Int = 30 } } 

调用Java

 AppHelper.getAge(); 

呼吁Kotlin

 AppHelper.Companion.getAge(); 

我认为它的工作完美。

Answer 7

直接写入文件。

在Java（丑陋）：

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

在Kotlin：

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

这两段代码在编译之后是相等的（即使是编译的文件名， file:JvmName也是用来控制编译的文件名，这个文件名应该放在包名声明的前面）。

Answer 8

使用“伴侣对象或命名对象”中的function。

查看伴侣对象的示例：

  class Foo { companion object { fun square(x : Int) : Int = x*x } } 

看到命名对象的例子

 object Foo{ fun square(x : Int) : Int = x*x } 

您可以通过使用访问

 val k = Foo.square(12) 

Answer 9

只需要创建一个伴侣对象并将其放入其中

  class UtilClass { companion object { // @JvmStatic fun repeatIt5Times(str: String): String = str.repeat(5) } } 

---

从kotlin类调用该方法：

 class KotlinClass{ fun main(args : Array) { UtilClass.repeatIt5Times("Hello") } } 

或使用导入

 import Packagename.UtilClass.Companion.repeatIt5Times class KotlinClass{ fun main(args : Array) { repeatIt5Times("Hello") } } 

---

从java类调用该方法：

  class JavaClass{ public static void main(String [] args){ UtilClass.Companion.repeatIt5Times("Hello"); } } 

或者通过向方法添加@JvmStatic注释

 class JavaClass{ public static void main(String [] args){ UtilClass.repeatIt5Times("Hello") } } 

或者通过在方法中添加@JvmStatic注释并在java中进行静态导入

 import static Packagename.UtilClass.repeatIt5Times class JavaClass{ public static void main(String [] args){ repeatIt5Times("Hello") } } 

Answer 10

Companion Objects是java静态关键字的替代品，通过将它们声明为Companion Objects，您可以将一个类或一个方法设为静态。
如果从同一个类中调用它们，则不需要使用类名称来限定伴随对象。

例如：

 class SomeClass() { val id: Int init { id = nextId++ } private companion object { var nextId = 1 } } fun main(args: Array) { repeat(2) { println(SomeClass().id) } } 

Answer 11

如果你遵循在Java的顶部写静态的风格，那么我建议考虑在Kotlin的顶层（例如在课堂申报之前）编写它们。 对于许多使用情况，它比引入伴随对象更好

示例代码：

 class Person { companion object Test { fun callMe() = println("I'm called.") } } fun main(args: Array) { Person.callMe()} 

当你运行程序时，输出将是：

我叫。

Answer 12

在java静态方法

 public static add(){ } 

用kotlin静态方法

 fun add():??? { }