Kotlin'deki Java statik yöntemlerinin eşdeğeri nedir?


619

staticKotlin'de anahtar kelime yok .

staticKotlin'de bir Java yöntemini temsil etmenin en iyi yolu nedir ?



12
Tavsiye : Kotlin, daha sürdürülebilir ('daha iyi' demeye cesaretim) kodlama uygulamalarını teşvik etmek için Java stili statikleri kaldırmıştır. Statik küreseller genellikle OOP paradigmasına karşıdır, ancak oldukça uygun olabilirler. Bu nedenle, Kotlin bize yoldaşları sağlamıştır, statik hale getirmenin daha OOP dostu bir yoludur.
Nicholas Miller

Google'a göre Kotlin artık Android geliştirme için tercih edilen bir dil.
AFD

@NicholasMiller neden daha OOP dostu? Ben tekrarlayan statik (kazan plakası) notu olmadan okumak ve yazmak daha kolay olduğunu düşünüyorum. Yoksa başka bir iyi neden var mı?
Torben G

Yanıtlar:


888

İşlevi "tamamlayıcı nesneye" yerleştirirsiniz.

Java kodu şöyle:

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

Olacak

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

Daha sonra Kotlin kodunun içinden kullanabilirsiniz.

Foo.a();

Ancak Java kodunun içinden, şu şekilde adlandırmanız gerekir:

Foo.Companion.a();

(Bu da Kotlin içinden çalışır.)

Biti belirtmek Companionistemiyorsanız, bir @JvmStaticek açıklama ekleyebilir veya tamamlayıcı sınıfınızı adlandırabilirsiniz.

Gönderen docs :

Tamamlayıcı Nesneler

Sınıf içindeki nesne bildirimi tamamlayıcı anahtar kelimeyle işaretlenebilir:

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

Tamamlayıcı nesnenin üyeleri, niteleyici olarak yalnızca sınıf adı kullanılarak çağrılabilir:

val instance = MyClass.create()

...

Ancak, @JvmStatic ek açıklama kullanıyorsanız, JVM'de tamamlayıcı nesnelerin üyelerini gerçek statik yöntemler ve alanlar olarak oluşturabilirsiniz . Daha fazla ayrıntı için Java ile birlikte çalışabilirlik bölümüne bakın.

@JvmStaticEk açıklama eklemek şöyle görünür

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

ve hem Java hem de Kotlin'den erişilebilen gerçek bir Java statik fonksiyonu olarak mevcut olacaktır Foo.a().

Sadece Companionad için beğenilmezse , tamamlayıcı nesne için aşağıdaki gibi açık bir ad da sağlayabilirsiniz:

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

bu da Kotlin'den aynı şekilde çağırmanıza izin verecek, ancak java gibi Foo.Blah.a()(Kotlin'de de çalışacak).


4
Kotlin'de olacak fun a(): Int { return 1 }ya da olacakfun a(): Int = 1
Dmitry Zaytsev

3
@DmitryZaitsev veya hatta fun a() = 1.
Moira

Fabrika anlamı ne?
Bagus Aji Santoso

@BagusAjiSantoso Factory, tamamlayıcı nesnenin adıdır - ancak bu ne için kullanılabilir? Hiçbir fikrim yok, ama bunun adanmış bir soru yarattı yüzden ilgi: stackoverflow.com/q/45853459/221955 .
Michael Anderson

1
@ Yajairo87 İstediğiniz şeyin burada bir yorumda yer almak için çok fazla olduğunu düşünüyorum - bu yüzden doğrudan adresleme ile ilgili bir soru oluşturdum: stackoverflow.com/questions/47046474/…
Michael Anderson

154

Dokümanlar , statik işlevlere yönelik gereksinimlerin çoğunu paket düzeyi işlevlerle çözmenizi önerir . Bunlar, kaynak kod dosyasındaki bir sınıfın dışında bildirilir. Bir dosyanın paketi, paket anahtar sözcüğüyle bir dosyanın başında belirtilebilir.

deklarasyon

package foo

fun bar() = {}

kullanım

import foo.bar

alternatif olarak

import foo.*

Artık işlevi şu şekilde çağırabilirsiniz:

bar()

veya import anahtar sözcüğünü kullanmıyorsanız:

foo.bar()

Paketi belirtmezseniz, işleve kökten erişilebilir.

Sadece java ile deneyiminiz varsa, bu biraz garip görünebilir. Bunun nedeni kotlin'in kesinlikle nesneye yönelik bir dil olmamasıdır. Sınıfların dışındaki yöntemleri desteklediğini söyleyebilirsiniz.

Düzenleme: Belgeleri, artık paket düzeyinde işlevler önerme konusundaki cümleyi içermeyecek şekilde düzenlediler. Bu , yukarıda belirtilen orijinal.


8
Kapağın altında bu "üst düzey" veya "paket" işlevlerinin aslında kendi sınıflarında derlendiğini unutmayın. Yukarıdaki örnekte, derleyici class FooPackage, tüm üst düzey özellik ve işlevlere sahip bir a oluşturur ve tüm referanslarınızı bunlara uygun şekilde yönlendirir. Jetbrains'den daha fazla bilgi.
Mitchell Tracy

29
+1 Eşdeğer hakkın Java'dan sadece ayna eşdeğeri yerine Kotlin'de nasıl yapılacağını açıklamak için .
anka kuşu

1
Bu kabul edilen cevap olmalı ya da bir mod kabul edilen cevabı paket seviyesi fonksiyonlarını içerecek şekilde güncellemelidir
Osama Shabrez

@MitchellTracy Mükemmel bilgi! Teşekkürler.
Bir Droid

1
Bu şimdiye kadar daha iyi bir çözüm. Sadece işlevi tanımladığınız yerde bar()dosya adının önemli olmadığını, BarUtils.ktya da herhangi bir şeyi adlandırabileceğinizi açıklığa kavuşturmak istedim , o zaman metnin dediği gibiimport <package name>.bar
Mariano Ruiz

33

A. Eski Java Yolu:

  1. companion objectStatik bir yöntemi / değişkeni kapsayacak şekilde a bildirme

    class Foo{
    companion object {
        fun foo() = println("Foo")
        val bar ="bar"  
        }
    }
  2. Kullanım:

    Foo.foo()        // Outputs Foo    
    println(Foo.bar) // Outputs bar


B. Yeni Kotlin yolu

  1. Bir dosya üzerinde sınıf olmadan doğrudan dosya üzerinde bildir .kt.

    fun foo() = println("Foo")
    val bar ="bar"
  2. İsimlerimethods/variables ile kullanın . ( İçe aktardıktan sonra )

    Kullanım:

    foo()        // Outputs Foo          
    println(bar) // Outputs bar     


Im başka bir sınıfta başlatmak için çalışıyorsa onun java.lang.ExceptionInInitializerError verir ve ben val yerine var kullanıyorum m
Sudarshan

4
Yöntem çağrıları şu şekilde INSTANCEanahtar kelimeye sahip olmalıdır :Foo.INSTANCE.sayFoo()
Raeglan

Bence static CLASSsadece bir çözüm istemiyorsanız bu çözüm tercih edilir static methdos. Çünkü, tamamlayıcı nesnelerle yine de ana sınıfı başlatabilirsiniz.
fabriciorissetto

valstatik değil static finalJava ile eşdeğer
Farid

23

Statik yapmak için val / var / yöntemini temsil eden nesneyi kullanın . Singleton sınıfı yerine nesne de kullanabilirsiniz. Bir sınıfın içinde statik yapmak istiyorsanız tamamlayıcıyı kullanabilirsiniz

object Abc{
     fun sum(a: Int, b: Int): Int = a + b
    }

Java'dan aramanız gerekirse:

int z = Abc.INSTANCE.sum(x,y);

Kotlin'de INSTANCE'ı görmezden gelin.


11

Bu da benim için çalıştı

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

Kotlin çıkışlı

Bell.ring()

Java'dan

Bell.ring()


5

Statik yöntem için tamamlayıcı nesneyi iletmeniz gerekir, çünkü kotlin'in statik anahtar sözcüğü yoktur - Tamamlayıcı nesnenin üyeleri, niteleyici olarak yalnızca sınıf adı kullanılarak çağrılabilir:

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

4

Kotlin'de statik uygulamak için 2 yol vardır

Önce sınıfın altında bir tamamlayıcı nesne oluşturun

Örneğin:

class Test{
    companion object{
          fun isCheck(a:Int):Boolean{
             if(a==0) true else false
          }
     }
}

bu işlevi şu adla

Test.Companion.isCheck(2)

Kullanabileceğimiz başka bir yol da bir nesne sınıfı yapmaktır

object Test{
       fun isCheck(a:Int):Boolean{
            if(a==0) true else false
       }
}

Mutlu Kodlama!


İlk kullanımda (yani Test.Companion.isCheck(2)) IDE uyarıları gösterir ve söyler Companion reference is redundant. İndirgenebilir Test.isCheck(2)ve indirgenmiş form java eşdeğerine daha yakındır.
VSB

3

Kotlin'in statik anahtar kelimesi yok. Java için kullandın

 class AppHelper {
        public static int getAge() {
            return 30;
        }
    }

ve Kotlin için

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

Java Çağrısı

AppHelper.getAge();

Kotlin Çağrısı

AppHelper.Companion.getAge();

Bence mükemmel çalışıyor.


3

Yukarıdaki cevaplara bir şeyler eklemek istiyorum.

Evet, işlevleri kaynak kod dosyalarında (sınıf dışında) tanımlayabilirsiniz. Ancak, sınıf içinde Companion Object kullanarak statik fonksiyonlar tanımlamanız daha iyidir, çünkü Kotlin Uzantılarını kullanarak daha fazla statik fonksiyon ekleyebilirsiniz .

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

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

Companion Object içindeki herhangi bir fonksiyonu çağıracağınız için yukarıda tanımlanan fonksiyonu çağırabilirsiniz.


3

Bu 2 yıldan biraz eski olmasına rağmen ve çok sayıda harika cevabı olmasına rağmen, "statik" Kotlin alanlarının eksik olmasının başka yollarını görüyorum. Kotlin-Java staticbirlikte çalışma için örnek bir kılavuz :

Senaryo 1: Kotlin'de Java için statik bir yöntem oluşturma

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

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'ın cevabı bundan daha fazla derinlik sağlar ve bu senaryo için kesinlikle referans verilmelidir.


Bir sonraki senaryo, Java'nın KotlinClass.foo()statik bir işlev istemediğiniz durumlar için çağrı yapmaya devam etmesi için Kotlin'de statik alanlar oluşturmayı ele alır .

Senaryo 2: Kotlin'de Java için statik değişken oluşturma

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

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'in en önemli özelliklerinden biri, üst düzey işlevler ve değişkenler oluşturabilmenizdir. Bu, staticJava'da işlevler / alanlar olarak kullanılabilen sabit alanların ve işlevlerin "sınıfsız" listelerini oluşturmayı mükemmelleştirir .

Senaryo 3: Kotlin'de üst düzey alanlara ve işlevlere Java'dan erişme

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'da "statik" alanlar olarak kullanılabilecek bir diğer dikkat çekici nokta Kotlin'dir. object sınıflarıdır. Bunlar, ilk kullanımda tembel olarak başlatılan sıfır parametreli singleton sınıflarıdır. Onlar hakkında daha fazla bilgiyi burada bulabilirsiniz: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations

Bununla birlikte, singleton'a erişmek için INSTANCE, olduğu gibi başa çıkmak için hantal olan özel bir nesne yaratılır Companion. staticJava'da bu temiz hissi vermek için ek açıklamaları nasıl kullanacağınız aşağıda açıklanmıştır :

Senaryo 4: objectSınıfları kullanma

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'?"
}

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

3

Kısa yapmak için, "tamamlayıcı nesne" yi Kotlin statik dünyasına girmek için kullanabilirsiniz :

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

ve sabit bir alan oluşturmak için kodda olduğu gibi "const val" kullanın . ancak Mockito kullanarak birim testinde zorluklar yarattığı için statik sınıflardan kaçınmaya çalışın.


3

Java statik yönteminin kotlin eşdeğerine tam dönüşümü böyle olacaktır. Örneğin burada util sınıfı, hem java hem de kotlin'e eşdeğer olacak bir statik yönteme sahiptir. @JvmStatic kullanımı önemlidir.

Java kodu:

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

Kotlin kodu:

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

2

Sadece bir tamamlayıcı nesne oluşturmanız ve işlevi içine koymanız gerekir

  class UtilClass {
        companion object {
  //        @JvmStatic
            fun repeatIt5Times(str: String): String = str.repeat(5)
        }
    }

Yöntemi bir kotlin sınıfından çağırmak için:

class KotlinClass{
  fun main(args : Array<String>) { 
    UtilClass.repeatIt5Times("Hello")
  }
}

veya İçe aktarmayı kullanma

import Packagename.UtilClass.Companion.repeatIt5Times
class KotlinClass{
  fun main(args : Array<String>) { 
     repeatIt5Times("Hello")
  }
}

Bir java sınıfından yöntemi çağırmak için:

 class JavaClass{
    public static void main(String [] args){
       UtilClass.Companion.repeatIt5Times("Hello");
    }
 }

veya yönteme @JvmStatic ek açıklama ekleyerek

class JavaClass{
   public static void main(String [] args){
     UtilClass.repeatIt5Times("Hello")
   }
}

veya her ikisine de yönteme @JvmStatic ek açıklama ekleyerek ve java'da statik içe aktarma yaparak

import static Packagename.UtilClass.repeatIt5Times
class JavaClass{
   public static void main(String [] args){
     repeatIt5Times("Hello")
   }
}

2

Java için:

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

Eşdeğer Kotlin kodu:

object  Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}

Yani Java statik yöntemleri eşdeğer için Kotlin nesne sınıfıdır.


2

Android için tek bir etkinlikten gerekli tüm etkinliğe bir dize kullanma. Java'daki statik gibi

public final static String TEA_NAME = "TEA_NAME";

Kotlin'de eşdeğer yaklaşım:

class MainActivity : AppCompatActivity() {
    companion object {
        const val TEA_NAME = "TEA_NAME"
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Değere ihtiyaç duyulan bir başka faaliyet:

val teaName = MainActivity.TEA_NAME

2

Michael Anderson'ın yanıtı dışında, projemde diğer iki yolla kodlama yapıyorum.

İlk:

tüm değişkenleri bir sınıfa beyazlayabilirsiniz. Const adlı bir kotlin dosyası oluşturdu

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

Kotlin ve java kodlarında kullanabilirsiniz

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

İkinci:


Kotlin'in dahili fonksiyonunu kullanarak Ext adında bir kotlin dosyası yarattı code Aşağıdaki kod Ext dosyasındaki tüm kodlardır

package pro.just.yumu

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

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

Kotlin kodunda kullanabilirsiniz

 Log.d("stackoverflow", FIRST_NAME)

Java kodunda kullanabilirsiniz

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

1

Bunları doğrudan dosyalara yazın.

Java dilinde (çirkin):

package xxx;
class XxxUtils {
  public static final Yyy xxx(Xxx xxx) { return xxx.xxx(); }
}

Kotlin'de:

@file:JvmName("XxxUtils")
package xxx
fun xxx(xxx: Xxx): Yyy = xxx.xxx()

Bu iki kod parçası derlemeden sonra eşitlenir (derlenmiş dosya adı bile, derlenmiş dosya adını file:JvmNamekontrol etmek için kullanılır ve paket adı bildiriminden hemen önce konulmalıdır).


7
"Kotlin (çirkin)" unuttun ... KOTLIN: tamamlayıcı nesne {val handler = object: Handler (Looper.getMainLooper ()) {] ..... JAVA: statik Handler handler = yeni Handler (Looper.getMainLooper () ) {};
CmosBattery

1

@JVMStaticEk Açıklama Kullan

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

1

Bir sınıf öğrenciniz olsun . Ve birine sahip statik yöntemini getUniversityName () & tek statik olarak adlandırılan alan totalStudent .

Sınıfınızdaki tamamlayıcı nesne bloğunu bildirmelisiniz .

companion object {
 // define static method & field here.
}

Sonra sınıfın benziyor

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

Sonra bu statik yöntemi ve bu şekilde alanları kullanabilirsiniz.

println("University : " + Student.getUniversityName() + ", Total Student: " + Student.totalStudent)
    // Output:
    // University : MBSTU, Total Student: 30

1

Kotlin'de statik bir anahtar kelime yok. kotlin docs, DRY'yi takip etmek istiyorsanız paket seviyesi işlevlerini kullanmanızı önerir. .Kt uzantılı bir dosya oluşturun ve yönteminizi içine yerleştirin.

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

derleme m sonra bir imzası olacak kamu statik nihai boşluk

ve

import p.m


0

Companion Objects tarafından Kotlin'de statik işlevsellik elde edebilirsiniz

  • Ekleme arkadaşı nesne beyanına eklemek için izin verir statik , gerçek statik kavramı Kotlin'de bulunmasa bile bir nesneye işlevsellik .
  • Bir arkadaşı nesne özel kurucular dahil çok sınıfın tüm üyeleri erişebilir.
  • Bir arkadaşı nesne sınıfı örneği zaman başlatılır.
  • Bir arkadaşı nesne sınıfının dışında ilan edilemez.

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

Tamamlayıcı nesnenin üyeleri, niteleyici olarak yalnızca sınıf adı kullanılarak çağrılabilir:

Çıktı:

MyClass.staticField // This is an example of static field Object Decleration

MyClass.getStaticFunction() : // This is an example of static function for Object Decleration

0

Tüm statik eleman ve işlev tamamlayıcı blok içinde olmalıdır

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

    fun staticMethod() {
    }
  }

0

Bir çok insan doğru nesnelerden bahseder, ki bu doğrudur. Ancak, bildiğiniz gibi, herhangi bir nesne türünü de kullanabilirsiniz (sınıf yerine object anahtar sözcüğünü kullanarak),

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

Java'daki herhangi bir statik yöntem gibi kullanın:

StringUtils.toUpper("foobar")

Kotlin'de bu tür bir desen işe yaramaz, güçlü yanlarından biri statik yöntemlerle dolu sınıflara duyulan ihtiyaçtan kurtulmasıdır. Kullanım durumunuza bağlı olarak bunun yerine genel, genişletme ve / veya yerel işlevleri kullanmak daha uygundur. Çalıştığım yerde genellikle global uzantı işlevlerini adlandırma kuralına sahip ayrı, düz bir dosyada tanımlıyoruz: [className] Extensions.kt yani, FooExtensions.kt. Ancak daha tipik olarak, işlevleri kendi sınıflarında veya nesnelerinde ihtiyaç duydukları yerde yazarız.


0

Java ile aşağıdaki şekilde yazabiliriz

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

Kotlin'de aşağıdaki şekilde yazabiliriz

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

bir arkadaşı Kotlin'de statik olarak kullanılır.


0

Kotlin belge sağlayıcısı bunu yapmanın üç yolu, birincisi sınıfta paket olmadan işlevi tanımlamaktır:

package com.example

fun f() = 1

ikincisi @JvmStatic ek açıklaması kullanmaktır:

package com.example

class A{
@JvmStatic
fun f() = 1
}

ve üçüncüsü, tamamlayıcı nesneyi kullanın:

package com.example

clss A{
companion object{
fun f() = 1
}
}

-1

Bir işleve veya bir özelliğin, örneklerinden ziyade bir sınıfa bağlanması gerekiyorsa, bunu bir tamamlayıcı nesnenin içinde bildirebilirsiniz:

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

Tamamlayıcı nesne tek bir öğedir ve üyelerine doğrudan kapsayıcı sınıfın adı üzerinden erişilebilir

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

Kabul edilen cevap zaten eşlik eden nesneleri tarif ediyor gibi görünüyor. Diğer cevapların çoğu da öyle. Cevabınız yeni bir şey sağlıyor mu?
Sneftel

daha fazla açıklama için buradan kontrol edebilirsiniz kotlinlang.org/docs/tutorials/kotlin-for-py/…
asad mahmood

-2

Sen kullanabilirsiniz Companion Nesneleri - kotlinlang

İlk önce bu Arabirimi oluşturarak gösterilebilir

interface I<T> {

}

O zaman bu arayüzün içinde bir işlev yapmalıyız:

fun SomeFunc(): T

Sonra bir sınıfa ihtiyacımız var:

class SomeClass {}

o sınıfın içinde, o sınıfın içinde bir yardımcı nesneye ihtiyacımız var:

companion object : I<SomeClass> {}

bu Yardımcı Nesnenin içinde o eski SomeFuncişleve ihtiyacımız var , Ama aşırı sürmemiz gerekiyor:

override fun SomeFunc(): SomeClass = SomeClass()

Sonunda tüm bu işin altında, bu Statik fonksiyona güç verecek bir şeye ihtiyacımız var, bir değişkene ihtiyacımız var:

var e:I<SomeClass> = SomeClass()
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.