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静态世界，比如:

  companion object {
    const val TAG = "tHomeFragment"
    fun newInstance() = HomeFragment()
}

要创建一个常量字段，请使用代码中的“const val”。 但是尽量避免使用静态类，因为它会给使用Mockito进行单元测试带来困难。

您只需要创建一个伴生对象并将函数放入其中

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

从kotlin类中调用该方法:

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

或使用import

import Packagename.UtilClass.Companion.repeatIt5Times
class KotlinClass{
  fun main(args : Array<String>) { 
     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")
   }
}

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

让，你有一个班级学生。你有一个静态方法getUniversityName()和一个静态字段totalStudent。

你应该在你的类中声明同伴对象块。

companion object {
 // define static method & field here.
}

然后你的类看起来像

    class Student(var name: String, var city: String, var rollNumber: Double = 0.0) {

    // use companion object structure
    companion object {

        // below method will work as static method
        fun getUniversityName(): String = "MBSTU"

        // below field will work as static field
        var totalStudent = 30
    }
}

然后你可以像这样使用那些静态方法和字段。

println("University : " + Student.getUniversityName() + ", Total Student: " + Student.totalStudent)
    // Output:
    // University : MBSTU, Total Student: 30

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

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.