Java에 대한 Kotlin 정적 변수 및 함수를 어떻게 만드나요?

할 수 없습니다.적어도순수Kotlin 프로젝트에서는

Kotlin은 static 에 대한 개념이 없습니다 . static 방법  Kotlin-Java 프로젝트에서 작동하는 것은 Kotlin 클래스의 주석을 사용하여 원하는 변수/함수가 static 로 노출되어야한다는 것을 JVM에 알리는 것입니다  자바 클래스에.

다음은 Kotlin-Java static 에 대한 예제 안내서입니다.  interop (코 틀린에서 Java 정적 메소드에 해당하는 것은 무엇입니까?에 원래 게시 된 답변) :

와이즈 비즈 와이즈 비즈      

자바

 
Scenario 1: Creating a static method in Kotlin for Java
  
 
Kotlin


이 답변은 이것보다 더 깊이를 제공하며,이 시나리오에서 반드시 참조되어야합니다.
<시간>
이 다음 시나리오는 Kotlin에서 정적 필드 작성을 처리하므로 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
    }
}
를 계속 호출 할 필요가 없습니다.
 정적 기능을 원하지 않는 경우에 해당합니다.

와이즈 비즈
와이즈 비즈

     

자바

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

<시간> Kotlin의 가장 큰 특징 중 하나는 최상위 함수와 변수를 만들 수 있다는 것입니다. 이를 통해 상수 필드 및 함수의 "클래스리스"목록을 작성하면 KotlinClass.foo() 로 사용할 수 있습니다.  Java의 함수/필드.

와이즈 비즈 와이즈 비즈      

자바

 
Scenario 2: Creating a static variable in Kotlin for Java
  
 
Kotlin


<시간>
"정적"필드로 Java에서 사용할 수있는 또 다른 주목할만한 것은 Kotlin 
@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
    }
}
입니다.
 클래스. 이들은 처음 사용할 때 느리게 인스턴스화되는 0 개의 매개 변수 싱글 톤 클래스입니다. 이에 대한 자세한 내용은 https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations
에서 확인할 수 있습니다.
그러나, 특별한 
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);
    }
}
 싱글 톤에 액세스하려면
 
static
와 같이 다루기가 번거로운 객체가 생성됩니다.
 입니다. 주석을 사용하여 깔끔한 

 
Scenario 3: Accessing top level fields and functions in Kotlin from 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!")
}


  
  
자바
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);
    }
}



object