W staticKotlin nie ma słowa kluczowego.

Jaki jest najlepszy sposób reprezentowania staticmetody Java w Kotlin?

Umieszczasz funkcję w „obiekcie towarzyszącym”.

Więc kod Java taki jak ten:

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

stanie się

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

Następnie możesz użyć go z kodu Kotlin jako

Foo.a();

Ale z poziomu kodu Java należy nazwać go jako

Foo.Companion.a();

(Który działa również z poziomu Kotlina.)

Jeśli nie chcesz określać Companionbitu, możesz dodać@JvmStatic adnotację lub nazwać swoją klasę towarzyszącą.

Z dokumentów :

Obiekty towarzyszące

Deklaracja obiektu w klasie może być oznaczona słowem kluczowym towarzyszącym:

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

Członkowie obiektu towarzyszącego można wywoływać, używając po prostu nazwy klasy jako kwalifikatora:

val instance = MyClass.create()

...

Jednak w JVM możesz mieć elementy obiektów towarzyszących wygenerowane jako rzeczywiste metody statyczne i pola, jeśli użyjesz @JvmStatic adnotacji. Aby uzyskać więcej informacji, zobacz sekcję „Interoperacyjność Java”.

Dodanie @JvmStaticadnotacji wygląda następująco

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

i wtedy będzie istniał jako prawdziwa statyczna funkcja Java, dostępna zarówno z Javy, jak i Kotlin as Foo.a().

Jeśli nie podoba mu się Companionnazwa, możesz także podać jawną nazwę dla obiektu towarzyszącego, który wygląda następująco:

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

co pozwoli ci nazywać to z Kotlina w ten sam sposób, ale z języka java Foo.Blah.a()(który będzie działał również w Kotlinie).

Docs zaleca rozwiązanie większości potrzeb związanych z funkcjami statycznymi za pomocą funkcji na poziomie pakietu . Są po prostu zadeklarowane poza klasą w pliku kodu źródłowego. Pakiet pliku można określić na początku pliku za pomocą słowa kluczowego package.

Deklaracja

package foo

fun bar() = {}

Stosowanie

import foo.bar

Alternatywnie

import foo.*

Możesz teraz wywołać funkcję za pomocą:

bar()

lub jeśli nie używasz słowa kluczowego import:

foo.bar()

Jeśli nie określisz pakietu, funkcja będzie dostępna z poziomu katalogu głównego.

Jeśli masz tylko doświadczenie z Javą, może się to wydawać trochę dziwne. Powodem jest to, że kotlin nie jest językiem ściśle obiektowym. Można powiedzieć, że obsługuje metody poza klasami.

Edycja: Dokonali edycji dokumentacji, aby nie zawierać już zdania na temat rekomendowania funkcji na poziomie pakietu. Jest to oryginał, o którym mowa powyżej.

A. Old Java Way:

1. Zadeklaruj a, companion objectaby załączyć metodę / zmienną statyczną

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

2. Posługiwać się :

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

B. Nowa droga Kotlin

1. Deklaruj bezpośrednio w pliku bez klasy w .ktpliku.

   fun foo() = println("Foo")
   val bar ="bar"

2. Użyj methods/variablesz ich nazwami . ( Po ich zaimportowaniu )

   Posługiwać się :

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

Użyj obiektu do reprezentowania metody val / var /, aby uzyskać statyczną wartość. Możesz także użyć obiektu zamiast klasy singleton. Możesz użyć towarzysza, jeśli chcesz uczynić statycznym wewnątrz klasy

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

Jeśli chcesz zadzwonić z Java:

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

W Kotlin zignoruj ​​INSTANCE.

To również działało dla mnie

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

z Kotlin

Bell.ring()

z Java

Bell.ring()

object objectName {
    fun funName() {

    }
}

Musisz przekazać obiekt towarzyszący dla metody statycznej, ponieważ kotlin nie ma słowa kluczowego statycznego - Członkowie obiektu towarzyszącego można wywołać, używając po prostu nazwy klasy jako kwalifikatora:

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

Istnieją 2 sposoby zastosowania efektu statycznego w Kotlinie

Najpierw utwórz obiekt towarzyszący w klasie

Na przykład:

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

możesz wywołać tę funkcję jako

Test.Companion.isCheck(2)

Innym sposobem, w jaki możemy użyć, jest utworzenie klasy obiektu

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

Happy Coding!

Kotlin nie ma statycznego słowa kluczowego. Użyłeś tego dla java

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

i dla Kotlina

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

Zadzwoń po Javę

AppHelper.getAge();

Zadzwoń po Kotlina

AppHelper.Companion.getAge();

Myślę, że działa idealnie.

Chciałbym dodać coś do powyższych odpowiedzi.

Tak, możesz zdefiniować funkcje w plikach kodu źródłowego (poza klasą). Lepiej jest jednak zdefiniować funkcje statyczne w klasie za pomocą Companion Object, ponieważ można dodać więcej funkcji statycznych, korzystając z rozszerzeń Kotlin .

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

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

I możesz wywołać powyższą funkcję, tak jak wywołasz dowolną funkcję w obiekcie Companion.

Mimo że ma on już nieco ponad 2 lata i wiele wspaniałych odpowiedzi, widzę inne sposoby uzyskania „statycznych” pól Kotlina. Oto przykładowy przewodnik dla interakcji Kotlin-Java static:

Scenariusz 1: Tworzenie metody statycznej w Kotlin dla 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 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
    }
}

Jawa

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

Odpowiedź Michaela Andersona zapewnia więcej głębi i na pewno należy się odwoływać do tego scenariusza.

Następny scenariusz obsługuje tworzenie pól statycznych w Kotlin, dzięki czemu Java nie musi wywoływać KotlinClass.foo()tych przypadków, w których nie chcesz funkcji statycznej.

Scenariusz 2: Tworzenie zmiennej statycznej w Kotlin dla 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
    }
}

Jawa

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

Jedną z wielkich zalet Kotlina jest możliwość tworzenia funkcji i zmiennych najwyższego poziomu. To sprawia, że ​​warto tworzyć „bezklasowe” listy stałych pól i funkcji, które z kolei mogą być używane jako staticfunkcje / pola w Javie.

Scenariusz 3: Dostęp do pól i funkcji najwyższego poziomu w Kotlin z 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!")
}

Jawa

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

Kolejną godną uwagi wzmianką, która może być używana w Javie jako pola „statyczne”, są objectklasy Kotlin . Są to klasy singletonów o zerowym parametrze, które są tworzone leniwie przy pierwszym użyciu. Więcej informacji na ich temat można znaleźć tutaj: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations

Jednak, aby uzyskać dostęp do singletonu, INSTANCEtworzony jest specjalny obiekt, który jest tak samo niewygodny, jak się nim Companionzajmuje. Oto jak używać adnotacji, aby zapewnić czysty staticwygląd w Javie:

Scenariusz 4: Korzystanie z objectklas

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

Jawa

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

Krótko mówiąc, możesz użyć „obiektu towarzyszącego”, aby dostać się do statycznego świata Kotlin, takiego jak:

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

i aby zrobić stałe pole, użyj „const val” jak w kodzie. ale staraj się unikać klas statycznych, ponieważ utrudnia to testowanie jednostkowe przy użyciu Mockito !.

Dokładna konwersja metody statycznej Java na ekwiwalent kotlin byłaby taka. np. tutaj klasa util ma jedną metodę statyczną, która byłaby równoważna zarówno w java, jak i kotlin. Zastosowanie @JvmStatic jest ważne.

Kod Java:

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

Kod Kotlin:

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

Po prostu musisz utworzyć obiekt towarzyszący i umieścić w nim funkcję

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

Aby wywołać metodę z klasy kotlin:

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

lub Korzystanie z importu

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

Aby wywołać metodę z klasy Java:

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

lub dodając adnotację @JvmStatic do metody

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

lub oba, dodając adnotację @JvmStatic do metody i dokonując importu statycznego w Javie

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

W przypadku Java:

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

Odpowiednik kodu Kotlin:

object  Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}

Zatem odpowiednikiem metod statycznych Java jest klasa obiektowa w Kotlinie.

Dla systemu Android za pomocą ciągu od pojedynczego działania do wszystkich niezbędnych działań. Tak jak statyczny w java

public final static String TEA_NAME = "TEA_NAME";

Równoważne podejście w Kotlinie:

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

Kolejne działanie, w którym potrzebna jest wartość:

val teaName = MainActivity.TEA_NAME

z wyjątkiem odpowiedzi Michaela Andersona, mam kodowanie z innymi dwoma sposobami w moim projekcie.

Pierwszy:

możesz białą zmienną na jedną klasę. utworzył plik Kotlin o nazwie Const

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

Możesz go używać w kodzie kotlin i java

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

Druga:

Możesz użyć funkcji rozszerzenia Kotlin, która
utworzyła plik Kotlin o nazwie Ext, poniżej kodu jest cały kod w pliku Ext

package pro.just.yumu

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

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

Możesz go użyć w kodzie kotlin

 Log.d("stackoverflow", FIRST_NAME)

Możesz go użyć w kodzie Java

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

Zapisz je bezpośrednio do plików.

W Javie (brzydka):

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

W Kotlinie:

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

Te dwa fragmenty kodów są równoważone po kompilacji (nawet nazwa skompilowanego pliku file:JvmNamesłuży do kontrolowania nazwy skompilowanego pliku, który należy umieścić tuż przed deklaracją nazwy pakietu).

Użyj @JVMStaticadnotacji

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

Niech masz klasowego ucznia . I masz jedną metodę statyczną getUniversityName () i jedno pole statyczne o nazwie totalStudent .

Powinieneś zadeklarować blok obiektów towarzyszących w swojej klasie.

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

Wtedy twoja klasa wygląda

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

Następnie możesz użyć tych statycznych metod i pól w ten sposób.

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

W kotlin nie ma statycznego słowa kluczowego. kotlin docs zaleca korzystanie z funkcji na poziomie pakietu, jeśli chcesz stosować DRY. Utwórz plik z rozszerzeniem .kt i umieść w nim swoją metodę.

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

po kompilacji m będzie miał podpis publicznej ostatecznej nieważności

i

import p.m

☺

Funkcję statyczną można osiągnąć w Kotlin dzięki obiektom towarzyszącym

• Dodanie elementu towarzyszącego do deklaracji obiektu pozwala na dodanie elementu statycznego funkcji do obiektu, nawet jeśli rzeczywista koncepcja statyczna nie istnieje w Kotlinie.
• Obiekt towarzyszący może również uzyskać dostęp do wszystkich członków klasy, w tym do prywatnych konstruktorów.
• Obiekt towarzyszący jest inicjowany podczas tworzenia instancji klasy.

• Obiekt towarzyszący nie może zostać zadeklarowany poza klasą.

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

Członkowie obiektu towarzyszącego można wywoływać, używając po prostu nazwy klasy jako kwalifikatora:

Wynik:

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

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

Wszystkie elementy statyczne i funkcje powinny znajdować się w bloku pomocniczym

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

    fun staticMethod() {
    }
  }

Wiele osób wspomina o obiektach towarzyszących, co jest poprawne. Ale dla pewności możesz użyć dowolnego obiektu (używając słowa kluczowego object, a nie klasy), tj.

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

Użyj go tak jak każdej metody statycznej w Javie:

StringUtils.toUpper("foobar")

Ten rodzaj wzorca jest jednak trochę bezużyteczny w Kotlinie, jedną z jego zalet jest to, że pozbywa się potrzeby klas wypełnionych metodami statycznymi. Bardziej właściwe jest korzystanie z funkcji globalnych, rozszerzeń i / lub lokalnych, w zależności od przypadku użycia. Tam, gdzie pracuję, często definiujemy globalne funkcje rozszerzeń w osobnym, płaskim pliku z konwencją nazewnictwa: [nazwa_klasy] Extensions.kt tj. FooExtensions.kt. Ale częściej piszemy funkcje tam, gdzie są potrzebne w swojej klasie operacyjnej lub obiekcie.

W Javie możemy pisać poniżej

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

W Kotlinie możemy pisać poniżej

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

Towarzysz jest używany jako statyczny w Kotlinie.

Dostawca dokumentów kotlin ma na to trzy sposoby, pierwszy to zdefiniowanie funkcji w pakiecie, bez klasy:

package com.example

fun f() = 1

drugim jest użycie adnotacji @JvmStatic:

package com.example

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

a trzeci to użyj obiektu towarzyszącego:

package com.example

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

Jeśli potrzebujesz funkcji lub właściwości do powiązania z klasą, a nie z jej instancjami, możesz zadeklarować ją w obiekcie towarzyszącym:

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

Obiekt towarzyszący jest singletonem, a do jego elementów można uzyskać bezpośredni dostęp poprzez nazwę klasy zawierającej

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

Możesz użyć przedmiotów towarzyszących - kotlinlang

Które można pokazać, tworząc najpierw ten interfejs

interface I<T> {

}

Następnie musimy stworzyć funkcję wewnątrz tego interfejsu:

fun SomeFunc(): T

Potem potrzebujemy zajęć:

class SomeClass {}

wewnątrz tej klasy potrzebujemy obiektu towarzyszącego w tej klasie:

companion object : I<SomeClass> {}

wewnątrz tego obiektu towarzyszącego potrzebujemy tej starej SomeFuncfunkcji, ale musimy go przejechać:

override fun SomeFunc(): SomeClass = SomeClass()

Wreszcie poniżej całej tej pracy, Potrzebujemy czegoś do zasilania tej funkcji statycznej, Potrzebujemy zmiennej:

var e:I<SomeClass> = SomeClass()