什么是Kotlin的Java静态方法的等价物?
Kotlin中没有static
关键字。
在Kotlin中表示static
Java方法的最好方法是什么?
您将该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()
调用它。
Docs推荐使用包级函数来解决静态函数的大部分需求。 他们只是在一个类客栈之外的源代码文件中声明。 文件包可以用package关键字在包的开头指定。
宣言
package foo fun bar() = {}
用法
import foo.bar
另外
import foo.*
您现在可以通过以下方式调用函数:
bar()
或者如果您不使用import关键字:
foo.bar()
如果您不指定包,则可以从根访问该function。
如果你只有java的经验,这可能看起来有点奇怪。 原因是kotlin不是严格的面向对象的语言。 你可以说它支持类之外的方法。
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
使用对象来表示val / var / method来创建静态。 你也可以使用object而不是singleton类。 如果你想在一个类中创建静态,你可以使用companion
object Abc{ fun sum(a: Int, b: Int): Int = a + b }
因为kotlin没有static关键字,所以你需要传递伴侣对象作为静态方法 – 可以简单地使用类名作为限定符来调用伴随对象的成员:
package xxx class ClassName { companion object { fun helloWord(str: String): String { return stringValue } } }
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();
我认为它的工作完美。
直接写入文件。
在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
也是用来控制编译的文件名,这个文件名应该放在包名声明的前面)。
使用“伴侣对象或命名对象”中的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)
只需要创建一个伴侣对象并将其放入其中
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") } }
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) } }
如果你遵循在Java的顶部写静态的风格,那么我建议考虑在Kotlin的顶层(例如在课堂申报之前)编写它们。 对于许多使用情况,它比引入伴随对象更好
示例代码:
class Person { companion object Test { fun callMe() = println("I'm called.") } } fun main(args: Array) { Person.callMe()}
当你运行程序时,输出将是:
我叫。
在java静态方法
public static add(){ }
用kotlin静态方法
fun add():??? { }