भले ही अब यह 2 साल से अधिक पुराना है, और इसमें बहुत सारे शानदार जवाब थे, मैं देख रहा हूं कि "स्थिर" कोटलिन के खेत गायब होने के कुछ अन्य तरीके गायब हैं। यहाँ कोटलिन-जावा इंटरोप के लिए एक उदाहरण मार्गदर्शिका दी गई है static:
परिदृश्य 1: जावा के लिए कोटलिन में एक स्थिर विधि बनाना
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 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);
}
}
माइकल एंडरसन का उत्तर इससे अधिक गहराई प्रदान करता है, और निश्चित रूप से इस परिदृश्य के लिए संदर्भित होना चाहिए।
यह अगला परिदृश्य कोटलिन में स्थिर फ़ील्ड बनाने का काम करता है ताकि जावा को KotlinClass.foo()उन मामलों के लिए कॉल न करना पड़े जहां आप एक स्थिर फ़ंक्शन नहीं चाहते हैं।
परिदृश्य 2: जावा के लिए कोटलिन में एक स्थिर चर बनाना
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
}
}
जावा
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 के बारे में एक महान विशेषता यह है कि आप शीर्ष स्तर के कार्य और चर बना सकते हैं। यह निरंतर फ़ील्ड और फ़ंक्शंस की "क्लासलेस" सूची बनाने के लिए इसे महान बनाता है, जो बदले staticमें जावा में फ़ंक्शन / फ़ील्ड के रूप में उपयोग किया जा सकता है ।
परिदृश्य 3: जावा से कोटलिन में शीर्ष स्तर के खेतों और कार्यों तक पहुँचना
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वर्ग। ये शून्य पैरामीटर सिंगलटन कक्षाएं हैं जो पहले उपयोग पर आलसी रूप से तात्कालिक हैं। उनके बारे में अधिक जानकारी यहां पाई जा सकती है: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations
हालांकि, सिंगलटन तक पहुंचने के लिए, एक विशेष INSTANCEऑब्जेक्ट बनाया जाता है, जो कि जैसा है उससे निपटने के लिए उतना ही बोझिल Companionहै। यहां यह बताने के लिए कि एनोटेशन का उपयोग कैसे किया जाए ताकि staticजावा में साफ महसूस हो:
परिदृश्य 4: objectकक्षाओं का उपयोग करना
Kotlin
@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'?"
}
जावा
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);
}
}