যদিও এটি এখন 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);
}
}
কোটলিন সম্পর্কে দুর্দান্ত বৈশিষ্ট্যগুলির মধ্যে একটি হ'ল আপনি শীর্ষ স্তরের ফাংশন এবং ভেরিয়েবলগুলি তৈরি করতে পারেন। এটি ধ্রুবক ক্ষেত্র এবং ক্রিয়াকলাপগুলির "শ্রেণিবদ্ধ" তালিকা তৈরি করতে গ্রেট করে তোলে, যা ঘুরে 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/references/object-declations.html#object-dlalations
তবে, সিঙ্গলটনে অ্যাক্সেসের জন্য একটি বিশেষ 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);
}
}