什么是Kotlin中的Java静态方法？

时间：2016-11-01 00:52:34

标签： java kotlin

Kotlin中没有static个关键字。

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

35 个答案:

答案 0 :(得分：649)

您将该功能放在“配套对象”中。

所以像这样的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注释或命名您的伴侣类。

来自docs：

  

伴随对象

     

可以使用随播广告标记类中的对象声明   关键字：

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

可以通过简单地使用类来调用伴随对象的成员   name作为限定符：

val instance = MyClass.create()
     

...

     

但是，在JVM上，您可以生成伴随对象的成员   作为真正的静态方法和字段，如果您使用@JvmStatic   注解。有关更多详细信息，请参阅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中使用）。

答案 1 :(得分：101)

Docs建议使用包级功能来解决静态功能的大部分需求。它们只是在源代码文件中的类外声明。可以使用package关键字在文件的开头指定文件包。

<强>声明 

package foo

fun bar() = {}

<强>用法 

import foo.bar

<强>替代地 

import foo.*

现在可以使用以下方法调用该函数：

bar()

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

foo.bar()

如果您没有指定包，则可以从根目录访问该功能。

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

答案 2 :(得分：20)

使用companion object括起静态方法/变量 

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

<强> 2。用法： 

Foo.sayFoo()        // Output Foo    
println(Foo.bar) .  // Output Bar

答案 3 :(得分：5)

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

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

答案 4 :(得分：5)

这对我也有用

object Bell {
    @JvmStatic
    fun ring() { }
}

来自Kotlin 

Bell.ring()

来自Java 

Bell.ring()

答案 5 :(得分：4)

object objectName {
    fun funName() {

    }
}

答案 6 :(得分：4)

有两种方法可以在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
       }
}

快乐编码！

答案 7 :(得分：3)

我想在以上答案中添加一些内容。

是的，您可以在源代码文件（外部类）中定义函数。但是最好在类中使用 Companion Object 定义静态函数，因为您可以利用 Kotlin扩展来添加更多静态函数。

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

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

并且您可以调用上面定义的函数，就像您将在Companion Object中调用任何函数一样。

答案 8 :(得分：3)

Kotlin没有任何静态关键字。你用它来做java 

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

和Kotlin 

AppHelper.getAge();

Call for Java 

AppHelper.Companion.getAge();

致电Kotlin 

self.navigationController.navigationBar.prefersLargeTitles

我认为它工作得很好。

答案 9 :(得分：2)

使用＆＃34;伴侣对象或命名对象＆＃34;内的功能。

请参阅随播对象的示例：

   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)

答案 10 :(得分：2)

简而言之，您可以使用“伴侣对象” 进入Kotlin静态世界，例如：

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

并使用代码中的“ const val” 来使字段不变

答案 11 :(得分：2)

从java静态方法到kotlin等效项的确切转换就是这样。例如此处util类具有一个静态方法，该方法在java和kotlin中均等效。 @JvmStatic的使用很重要。

 //Java
class Util{
     public static String capitalize(String text){
     return text.toUpperCase();}
   }



//Kotlin
class Util {
    companion object {
        @JvmStatic
        fun capitalize(text:String): String {
            return text.toUpperCase()
        }
    }
}

答案 12 :(得分：2)

除了迈克尔·安德森（Michael Anderson）的答案外，我在项目中使用其他两种方式进行编码。

第一：

您可以将所有变量归为一类。 创建了一个名为Const的kotlin文件

object Const {
    const val FIRST_NAME_1 = "just"
    const val LAST_NAME_1 = "YuMu"
}

您可以在kotlin和Java代码中使用它

 Log.d("stackoverflow", Const.FIRST_NAME_1)

第二：

您可以使用Kotlin的扩展功能
创建了一个名为Ext的kotlin文件，下面的代码是Ext文件中的所有代码

package pro.just.yumu

/**
 * Created by lpf on 2020-03-18.
 */

const val FIRST_NAME = "just"
const val LAST_NAME = "YuMu"

您可以在kotlin代码中使用它

 Log.d("stackoverflow", FIRST_NAME)

您可以在Java代码中使用它

 Log.d("stackoverflow", ExtKt.FIRST_NAME);

答案 13 :(得分：2)

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

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

答案 14 :(得分：2)

顶级/companion object static 属性

顶级

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

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 中的 static 属性。

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

companion object

当属性与类密切相关并且仅在该类中使用时，在 companion object 中定义它们：

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

顶级/companion object static 方法

顶级

与上面的属性类似，当函数与类有些相关时，在类的正上方定义它们：

fun getAllUsers() { }

fun getProfileFor(userId: String) { }

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

用法：

val userList = getAllUsers()

companion object

当函数与类密切相关时，将它们定义在 companion object 中：

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

    companion object {

        fun getAll() { }

        fun profileFor(userId: String) { }
    }
}

用法：

val userProfile = User.profileFor("34")

这类似于 Java 中的 static 方法。

顶级函数对于 Kotlin 来说通常更惯用。在 companion object 中定义函数的更好理由是当您使用 companion object 扩展 interface 时。单例部分显示了一个示例。

static 类的嵌套类

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

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

这相当于 Java 中的 static 嵌套类。此处的 UserAccess 类实现了 interface UserDao。

用法：

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

object 的单例 static INSTANCE

顶级

当您只需要一个类的单个对象时，您不再需要像在 Java 中那样在类中创建 static INSTANCE。只需使用顶级 object 声明：

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

还要注意在单例中扩展 interface 或 class 是多么容易。

上面的代码在底层产生了以下 static INSTANCE Java 单例模式（简化）：

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 object

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

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 类的实用程序。如果您需要多个单例或函数/属性组，您也可以在类中使用不带 object 关键字的 companion。

companion object 用于 static 工厂

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

例如，以下代码段中的 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 中的 static 工厂方法。

constructor 保留为 private，但 companion object 可以访问 constructor。

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

另请注意，伴随对象可以具有表示状态的属性（在本例中为 currentId）。

用法：

val john = User.newInstance("John")

@JvmStatic 用于 Java 互操作性

Java 的静态概念在 Kotlin 中不存在。 companion object 是名为 class 的真实 Companion 的实例。因此，当您从 Java 调用 Kotlin 代码时，Companion 类的一个对象首先在幕后实例化。您需要使用 Java 中的 Companion 对象调用该函数：

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

对于惯用的 Java 命名和更少的冗长，在该函数或属性上使用 @JvmStatic 注释：

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

@JvmStatic 注释创建了 static 函数的单独的纯 getProfileFor() 副本。现在您可以使用常规语法从 Java 中使用它：

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

就是这样！希望这些示例对您的项目有用。

答案 15 :(得分：2)

创建一个伴随对象并使用jvmstatic注释标记该方法

答案 16 :(得分：2)

您可以使用伴侣对象以外的对象

object Utils {
    fun someFunction()
}

所以在调用方法时会看起来像这样。

Utils.someFunction()

答案 17 :(得分：2)

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

例如：

class SomeClass() {

    val id: Int

    init {
       id = nextId++       
    }

    private companion object {
       var nextId = 1
    }
}

fun main(args: Array<String>) {
    repeat(2) { 
        println(SomeClass().id)
    }
}

答案 18 :(得分：1)

将它们直接写入文件。

在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也用于控制编译后的文件名，应该在包名声明之前放置。）

答案 19 :(得分：1)

使用@JVMStatic注释

companion object {

    // TODO: Rename and change types and number of parameters
    @JvmStatic
    fun newInstance(param1: String, param2: String) =
            EditProfileFragment().apply {
                arguments = Bundle().apply {
                    putString(ARG_PARAM1, param1)
                    putString(ARG_PARAM2, param2)
                }
            }
}

答案 20 :(得分：1)

kotlin中没有静态关键字。如果您想遵循DRY，kotlin docs建议使用软件包级功能。     创建具有 .kt 扩展名的文件，并将您的方法放入其中。

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

编译后 m 将具有公共静态最终空白

的签名

和

import p.m

☺

答案 21 :(得分：1)

让你有一个班学生。你有一个静态方法 getUniversityName（）＆amp;一个名为 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

答案 22 :(得分：1)

即使这已经有2年多的历史了，并且有很多不错的答案，但我发现缺少一些其他方法来获取“静态”科特林油田。这是Kotlin-Java static互操作的示例指南：

  

方案1：在Kotlin for Java中创建静态方法

     

科特林 

@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java
package com.frybits

class KotlinClass {
    companion object {

        //This annotation tells Java classes to treat this method as if it was a static to [KotlinClass]
        @JvmStatic
        fun foo(): Int = 1

        //Without it, you would have to use [KotlinClass.Companion.bar()] to use this method.
        fun bar(): Int = 2
    }
}
     

Java 

package com.frybits;

class JavaClass {

    void someFunction() {
        println(KotlinClass.foo()); //Prints "1"
        println(KotlinClass.Companion.bar()); //Prints "2". This is the only way to use [bar()] in Java.
        println(KotlinClass.Companion.foo()); //To show that [Companion] is still the holder of the function [foo()]
    }

    //Because I'm way to lazy to keep typing [System.out], but I still want this to be compilable.
    void println(Object o) {
        System.out.println(o);
    }
}

迈克尔·安德森（Michael Anderson）的答案比这更深入，在这种情况下肯定应该引用它。

下一个场景将处理在Kotlin中创建静态字段的情况，以便Java在不需要静态函数的情况下不必继续调用KotlinClass.foo()。

  

方案2：在Kotlin for Java中创建静态变量

     

科特林 

@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java
package com.frybits

class KotlinClass {

    companion object {

        //This annotation tells Kotlin to not generate the getter/setter functions in Java. Instead, this variable should be accessed directly
        //Also, this is similar to [@JvmStatic], in which it tells Java to treat this as a static variable to [KotlinClass].
        @JvmField
        var foo: Int = 1

        //If you want something akin to [final static], and the value is a primitive or a String, you can use the keyword [const] instead
        //No annotation is needed to make this a field of [KotlinClass]. If the declaration is a non-primitive/non-String, use @JvmField instead
        const val dog: Int = 1

        //This will be treated as a member of the [Companion] object only. It generates the getter/setters for it.
        var bar: Int = 2

        //We can still use [@JvmStatic] for 'var' variables, but it generates getter/setters as functions of KotlinClass
        //If we use 'val' instead, it only generates a getter function
        @JvmStatic
        var cat: Int = 9
    }
}
     

Java 

package com.frybits;

class JavaClass {

    void someFunction() {
        //Example using @JvmField
        println(KotlinClass.foo); //Prints "1"
        KotlinClass.foo = 3;

        //Example using 'const val'
        println(KotlinClass.dog); //Prints "1". Notice the lack of a getter function

        //Example of not using either @JvmField, @JvmStatic, or 'const val'
        println(KotlinClass.Companion.getBar()); //Prints "2"
        KotlinClass.Companion.setBar(3); //The setter for [bar]

        //Example of using @JvmStatic instead of @JvmField
        println(KotlinClass.getCat());
        KotlinClass.setCat(0);
    }

    void println(Object o) {
        System.out.println(o);
    }
}

关于Kotlin的一大特色是您可以创建顶级函数和变量。这样就可以创建常量字段和函数的“无类”列表，这些列表又可以用作Java中的static个函数/字段。

  

方案3：从Java访问Kotlin中的顶级字段和功能

     

科特林 

//In this example, the file name is "KSample.kt". If this annotation wasn't provided, all functions and fields would have to accessed
//using the name [KSampleKt.foo()] to utilize them in Java. Make life easier for yourself, and name this something more simple
@file:JvmName("KotlinUtils")

package com.frybits

//This can be called from Java as [KotlinUtils.TAG]. This is a final static variable
const val TAG = "You're it!"

//Since this is a top level variable and not part of a companion object, there's no need to annotate this as "static" to access in Java.
//However, this can only be utilized using getter/setter functions
var foo = 1

//This lets us use direct access now
@JvmField
var bar = 2

//Since this is calculated at runtime, it can't be a constant, but it is still a final static variable. Can't use "const" here.
val GENERATED_VAL:Long = "123".toLong()

//Again, no need for @JvmStatic, since this is not part of a companion object
fun doSomethingAwesome() {
    println("Everything is awesome!")
}
     

Java 

package com.frybits;

class JavaClass {

    void someFunction() {

        println(KotlinUtils.TAG); //Example of printing [TAG]


        //Example of not using @JvmField.
        println(KotlinUtils.getFoo()); //Prints "1"
        KotlinUtils.setFoo(3);

        //Example using @JvmField
        println(KotlinUtils.bar); //Prints "2". Notice the lack of a getter function
        KotlinUtils.bar = 3;

        //Since this is a top level variable, no need for annotations to use this
        //But it looks awkward without the @JvmField
        println(KotlinUtils.getGENERATED_VAL());

        //This is how accessing a top level function looks like
        KotlinUtils.doSomethingAwesome();
    }

    void println(Object o) {
        System.out.println(o);
    }
}

可以在Java中用作“静态”字段的另一个值得注意的提及是Kotlin object类。这些是零参数单例类，这些类在首次使用时会被延迟实例化。有关它们的更多信息，请参见：https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations

但是，要访问单例，将创建一个特殊的INSTANCE对象，该对象与Companion一样麻烦。以下是使用批注为Java提供清晰static的感觉的方法：

  

方案4：使用object类

     

科特林 

@file:JvmName("KotlinClass")

//This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java
package com.frybits

object KotlinClass { //No need for the 'class' keyword here.

    //Direct access to this variable
    const val foo: Int = 1

    //Tells Java this can be accessed directly from [KotlinClass]
    @JvmStatic
    var cat: Int = 9

    //Just a function that returns the class name
    @JvmStatic
    fun getCustomClassName(): String = this::class.java.simpleName + "boo!"

    //Getter/Setter access to this variable, but isn't accessible directly from [KotlinClass]
    var bar: Int = 2

    fun someOtherFunction() = "What is 'INSTANCE'?"
}
     

Java 

package com.frybits;

class JavaClass {

    void someFunction() {
        println(KotlinClass.foo); //Direct read of [foo] in [KotlinClass] singleton

        println(KotlinClass.getCat()); //Getter of [cat]
        KotlinClass.setCat(0); //Setter of [cat]

        println(KotlinClass.getCustomClassName()); //Example of using a function of this 'object' class

        println(KotlinClass.INSTANCE.getBar()); //This is what the singleton would look like without using annotations
        KotlinClass.INSTANCE.setBar(23);

        println(KotlinClass.INSTANCE.someOtherFunction()); //Accessing a function in the object class without using annotations
    }

    void println(Object o) {
        System.out.println(o);
    }
}

答案 23 :(得分：1)

对于Java：

public class Constants {
public static final long MAX_CLICK_INTERVAL = 1000;}

等效的Kotlin代码：

object  Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}

因此，等效于Java静态方法的是Kotlin中的对象类。

答案 24 :(得分：0)

简单地使用这种方法

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

Foo.INSTANCE.foo()

答案 25 :(得分：0)

对于Android，使用从单个活动到所有必要活动的字符串。 就像Java中的

public final static String TEA_NAME = "TEA_NAME";

科特林的等效方法：

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

答案 26 :(得分：0)

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

答案 27 :(得分：0)

在Java中，我们可以按以下方式编写

class MyClass {
  public static int myMethod() { 
  return 1;
  }
}

在Kotlin中，我们可以通过以下方式编写

class MyClass {
  companion object {
     fun myMethod() : Int = 1
  }
}

同伴在Kotlin中用作静态对象。

答案 28 :(得分：0)

很多人提到伴侣对象，这是正确的。但是，您知道，您也可以使用任何类型的对象（使用object关键字，而不是class），即

object StringUtils {
    fun toUpper(s: String) : String { ... }
}

像使用Java中的任何静态方法一样使用它：

StringUtils.toUpper("foobar")

尽管这种模式在Kotlin中是无用的，但其优势之一是它摆脱了对用静态方法填充的类的需求。根据您的用例，更适当地使用全局，扩展和/或局部功能。在我工作的地方，我们经常在单独的平面文件中使用以下命名约定定义全局扩展函数：[className] Extensions.kt，即FooExtensions.kt。但是更典型的是，我们在操作类或对象中需要的地方编写函数。

答案 29 :(得分：0)

java代码如下：

class Foo { public static int a() { return 1; } }

在科特林中将变成如下：

class Foo { companion object { fun a() : Int = 1 } }

但是，通过在JVM上使用@JvmStatic批注，我们可以将伴随对象的成员生成为真正的静态方法和字段。

答案 30 :(得分：0)

所有静态成员和函数都应该在随播块

中 
  companion object {
    @JvmStatic
    fun main(args: Array<String>) {
    }

    fun staticMethod() {
    }
  }

答案 31 :(得分：0)

您可以通过 Companion Objects

在Kotlin中实现静态功能
  • 将随播广告添加到对象声明允许添加 即使是实际的静态，对象的静态功能 Kotlin中不存在这个概念。
  • 伴随对象也可以访问该类的所有成员，包括私有构造函数。
  • 在实例化类时初始化伴随对象。

  • 无法在课堂外声明伴侣对象。

    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

答案 32 :(得分：-1)

您可以执行以下操作：

  1. 使用包级别功能。
  2. 使用伴随对象。

答案 33 :(得分：-1)

如果需要将函数或属性绑定到类而不是实例，可以在一个伴随对象中声明它：

class Car(val horsepowers: Int) {
    companion object Factory {
        val cars = mutableListOf<Car>()

        fun makeCar(horsepowers: Int): Car {
            val car = Car(horsepowers)
            cars.add(car)
            return car
        }
    }
}

伴随对象是单例对象，可以通过包含类的名称直接访问其成员

val car = Car.makeCar(150)
println(Car.Factory.cars.size)

答案 34 :(得分：-1)

您可以使用Companion Objects - kotlinlang

首先创建该接口即可显示

interface I<T> {

}

然后我们必须在该接口内创建一个函数：

fun SomeFunc(): T

然后，我们需要一个课程：

class SomeClass {}

在该类内，我们需要在该类内提供一个伴随对象：

companion object : I<SomeClass> {}

在同伴对象内，我们需要旧的SomeFunc函数，但是我们需要过度使用它：

override fun SomeFunc(): SomeClass = SomeClass()

最后，在所有这些工作之下，我们需要一些东西来增强静态功能，我们需要一个变量：

var e:I<SomeClass> = SomeClass()
相关问题
最新问题