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

---

静态属性的顶级/伴生对象

顶级

当属性与类有些关联时，在类声明之前将它们定义为顶级属性:

const val MAX_ATTEMPTS = 3
private const val DEFAULT_NAME = "Guest"
private const val MIN_AGE = 16

data class User(val id: String, val name: String = DEFAULT_NAME)

这类似于Java中的静态属性。

当属性完全独立于任何类时，可以将它们定义为不包含类的单独文件中的顶级属性。

伴星

当属性与类密切相关并且只会在该类中使用时，在伴随对象中定义它们:

data class User(val id: String, val name: String = DEFAULT_NAME) {
    companion object {
        const val DEFAULT_NAME = "Guest"
        const val MIN_AGE = 16
    }
}

---

用于静态方法的顶级/伴生对象

顶级

类似于上面的属性，当函数与类有点关联时，将它们定义在类的上方:

fun getAllUsers() { }

fun getProfileFor(userId: String) { }

data class User(val id: String, val name: String)

用法:

val userList = getAllUsers()

伴星

当函数与类密切相关时，在伴随对象中定义它们:

data class User(val id: String, val name: String) {

    companion object {

        fun getAll() { }

        fun profileFor(userId: String) { }
    }
}

用法:

val userProfile = User.profileFor("34")

这类似于Java中的静态方法。

顶级函数对于Kotlin来说通常更习惯。在伴生对象中定义函数的一个更好的原因是当您使用接口扩展伴生对象时。在单例部分中展示了一个示例。

---

静态类的嵌套类

当具有相关功能的类属于一起时，可以通过嵌套将它们分组在一起:

class User(val id: String, val name: String) {
    class UserAccess : UserDao {
        override fun add(user: User) { }
        override fun remove(id: String) { }
    }
}

这相当于Java中的静态嵌套类。这里的UserAccess类实现了一个接口UserDao。

用法:

fun main() {
    val john = User("34", "John")
    val userAccess = User.UserAccess()
    userAccess.add(john)
}

---

用于静态INSTANCE的单例对象

顶级

当您只想要类的单个对象时，您不再需要像在Java中那样在类中创建静态INSTANCE。简单地使用顶级对象声明:

object UserAccess : UserDao {
    override fun add(user: User) { }
    override fun remove(id: String) { }
}

还要注意在单例中扩展接口或类是多么容易。

上面的代码，在底层，在Java中产生以下静态INSTANCE单例模式(简化):

public final class UserAccess implements UserDao {
   public static final UserAccess INSTANCE;

   public void add(User user) { }

   public void remove(String id) { }

   private UserAccess() { }

   static { INSTANCE = new UserAccess();}
}

伴星

当单例对象与类密切相关时，使用companion对象:

data class User(val id: String, val name: String) {
    companion object : UserDao {
        override fun add(user: User) { }
        override fun remove(id: String) { }
    }
}

这样可以获得更优雅的命名:User.add(john)。另外，您要明确这个单例只用作User类的实用程序。如果需要多个单例对象或函数/属性组，也可以在类中使用不带companion关键字的对象。

---

静态工厂的伴生对象

Koltin中的工厂函数是使用伴生对象创建的。当您希望提供多种方法来创建对象，而对象构造过程很复杂，或者多个构造函数表达能力不够时，工厂函数非常有用。

例如，下面代码段中的newInstance()工厂函数通过自动生成id来创建一个用户:

class User private constructor(val id: Long, val name: String) {
    companion object {
        private var currentId = 0L;
        fun newInstance(name: String) = User(currentId++, name)
    }
}

这相当于Java中的静态工厂方法。

构造函数是私有的，但是伴生对象可以访问构造函数。

在上面的代码中，下一个id生成的一致性得到了保证，因为伴生对象是一个单例对象，只有一个对象会跟踪id，不会有任何重复的id。

还要注意，伴生对象可以具有表示状态的属性(在本例中为currentId)。

用法:

val john = User.newInstance("John")

---

@JvmStatic用于Java互操作性

Java的静态概念在Kotlin中并不存在。同伴对象是一个称为companion的真实类的实例。因此，当您从Java调用Kotlin代码时，Companion类的对象首先在后台实例化。你需要在Java中使用Companion对象调用该函数:

Profile userProfile = User.Companion.profileFor("34");

为了获得惯用的Java命名和更少的冗长，可以在函数或属性上使用@JvmStatic注释:

companion object {
    @JvmStatic
    fun profileFor(userId: String): Profile { }
}

@JvmStatic注释创建getProfileFor()函数的一个单独的纯静态副本。现在你可以在Java中使用常规语法:

Profile userProfile = User.profileFor("34");

---

就是这样!希望这些例子对你的项目有用。

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

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

在kotlin中没有静态关键字。如果你想遵循DRY, kotlin文档建议使用包级函数。 创建一个扩展名为.kt的文件，并将您的方法放在其中。

package p
    fun m(){
    //fun body
    }

编译后m将会有一个public static final void的签名

and

import p.m

☺

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

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

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

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

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

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