有两种方法可以在Kotlin中应用静态

首先在类下创建一个伴生对象

为例:

class Test{
    companion object{
          fun isCheck(a:Int):Boolean{
             if(a==0) true else false
          }
     }
}

你可以称这个函数为

Test.Companion.isCheck(2)

另一种方法是创建一个对象类

object Test{
       fun isCheck(a:Int):Boolean{
            if(a==0) true else false
       }
}

编码快乐!

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

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

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

您可以通过Companion Objects在Kotlin中实现静态功能

Adding companion to the object declaration allows for adding the static functionality to an object even though the actual static concept does not exist in Kotlin. A companion object can access all members of the class too, including the private constructors. A companion object is initialized when the class is instantiated. A companion object cannot be declared outside the class. class MyClass{ companion object { val staticField = "This is an example of static field Object Decleration" fun getStaticFunction(): String { return "This is example of static function for Object Decleration" } } }

伴侣对象的成员可以通过简单地使用类名作为限定符来调用:

输出:

MyClass.staticField // This is an example of static field Object Decleration

MyClass.getStaticFunction() : // This is an example of static function for Object Decleration

对于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