Який еквівалент статичних методів Java у Котліні?


619

У staticКотліна немає ключового слова.

Який найкращий спосіб представити staticметод Java в Котліні?


8
Використовуйте функцію рівня пакету .
фенікс

12
Зауважте: Котлін видалив статику стилю Java, щоб заохотити більш рентабельні (смію сказати «кращі») практики кодування. Статичні глобалі, як правило, проти парадигми ООП, але вони можуть бути досить зручними. Отже, Котлін надав нам супутників, більш сприятливих для OOP способів статики.
Ніколас Міллер

На думку Google, Котлін є бажаною мовою для розробки Android.
AFD

@NicholasMiller Чому це більш сприятливо для OOP? Я думаю, що це легше читати та писати без повторюваної ноти статики (котло). Або є ще одна вагома причина?
Torben G

Відповіді:


888

Ви розміщуєте функцію в "об'єкті-супутнику".

Тож код Java таким чином:

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

стане

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

Потім ви можете використовувати його з коду Котліна як

Foo.a();

Але з коду Java вам потрібно назвати його як

Foo.Companion.a();

(Що також працює з Котліна.)

Якщо вам не подобається вказувати Companionбіт, ви можете або додати @JvmStaticанотацію, або назвати свій клас-супутник.

З документів :

Об'єкти супутника

Декларація об'єкта всередині класу може бути позначена ключовим словом-супутником:

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

Члени об'єкта-супутника можна викликати, використовуючи просто ім'я класу як класифікатор:

val instance = MyClass.create()

...

Однак у JVM ви можете мати членів супутніх об’єктів, згенерованих як реальні статичні методи та поля, якщо ви використовуєте @JvmStatic анотацію. Детальнішу інформацію див. У розділі сумісності Java.

Додавання @JvmStaticпримітки виглядає приблизно так

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

і тоді вона буде існувати як справжня статична функція Java, доступна як від Java, так і від Kotlin як Foo.a().

Якщо це Companionім’я просто не подобається , ви також можете вказати чітке ім'я для супутнього об'єкта, який виглядає так:

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

що дозволить вам подзвонити з Котліна таким же чином, але від java like Foo.Blah.a()(який також працюватиме в Котліні).


4
У Котліні це буде fun a(): Int { return 1 }чи навітьfun a(): Int = 1
Дмитро Зайцев

3
@DmitryZaitsev чи навіть fun a() = 1.
Мойра

Що означають Фабрика?
Bagus Aji Santoso

@BagusAjiSantoso Factory- назва об'єкта-супутника - але для чого це можна використовувати? Я поняття не маю, але мені було цікаво, тому я створив питання, присвячене цьому: stackoverflow.com/q/45853459/221955 .
Майкл Андерсон

1
@ Yajairo87 Я думаю, що те, що ви запитуєте, занадто багато для висвітлення в коментарі тут, тому я створив запитання, яке безпосередньо стосується його: stackoverflow.com/questions/47046474/…
Майкл Андерсон

154

Документи рекомендують вирішити більшість потреб у статичних функціях за допомогою функцій на рівні пакету . Вони просто оголошуються поза класом у файлі вихідного коду. Пакет файлу можна вказати на початку файлу за допомогою ключового слова пакета.

Декларація

package foo

fun bar() = {}

Використання

import foo.bar

Як варіант

import foo.*

Тепер ви можете викликати функцію за допомогою:

bar()

або якщо ви не використовуєте ключове слово імпорту:

foo.bar()

Якщо ви не вказали пакет, функція буде доступна з кореня.

Якщо у вас є лише досвід роботи з java, це може здатися трохи дивним. Причина в тому, що kotlin не є строго об'єктно орієнтованою мовою. Можна сказати, що він підтримує методи поза класами.

Редагувати: Вони відредагували документацію, щоб більше не включати речення про рекомендації функцій рівня пакету. Це оригінал, про який згадувалося вище.


8
Зауважте, що під кришкою ці функції "найвищого рівня" або "пакета" фактично складаються у власний клас. У наведеному вище прикладі компілятор створив би class FooPackageвсі властивості та функції вищого рівня та спрямував усі ваші посилання на них відповідним чином. Більше інформації від jetbrains.
Мітчелл Трейсі

29
+1 Для пояснення, як зробити еквівалент право в Котліні, а не просто дзеркальний еквівалент від Java.
фенікс

1
Це має бути прийнята відповідь, або мод повинен оновити прийняту відповідь, щоб містити функції рівня пакету
Осама Шабрез

@MitchellTracy Чудова інформація! Дякую.
дроїд

1
Це краще рішення поки що. Просто хотів уточнити, що там, де ви визначаєте функцію, bar()не має значення ім'я файлу, ви можете назвати його BarUtils.ktчи будь-що інше, то, як зазначено в тексті, ви будете імпортувати його зimport <package name>.bar
Маріано Руїз,

33

A. Старий шлях Java:

  1. Оголосити a, companion objectщоб долучити статичний метод / змінну

    class Foo{
    companion object {
        fun foo() = println("Foo")
        val bar ="bar"  
        }
    }
  2. Використання:

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


В. Новий шлях Котліна

  1. Декларуйте безпосередньо у файлі без класу у .ktфайлі.

    fun foo() = println("Foo")
    val bar ="bar"
  2. Використовуйте methods/variablesїхні імена . ( Після імпортування їх )

    Використання:

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


Якщо я намагаюся ініціалізуватися в якомусь іншому класі, він дає java.lang.ExceptionInInitializerError, і я використовую var замість val
Sudarshan

4
Виклики методу повинні мати таке INSTANCEключове слово, як це:Foo.INSTANCE.sayFoo()
Raeglan

Я думаю, що це рішення є кращим способом, якщо ви хочете static CLASSне просто static methdos. Тому що з супутніми об'єктами ви все одно можете інстанціювати батьківський клас.
fabriciorissetto

valне є статичним, це еквівалент static finalна Java
Farid

23

Використовуйте об'єкт для подання val / var / методу для статичного. Ви також можете використовувати об'єкт замість однокласного класу. Ви можете використовувати супутника, якщо хочете стати статичним усередині класу

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

Якщо вам потрібно зателефонувати з Java:

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

У Котліні ігноруйте ІНСТАНЦІЮ.


11

Це теж працювало для мене

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

з Котліна

Bell.ring()

з Java

Bell.ring()

8
object objectName {
    fun funName() {

    }
}

5
Хоча цей фрагмент коду може бути вирішенням, включаючи пояснення, справді допомагає покращити якість вашої публікації. Пам’ятайте, що ви відповідаєте на запитання читачів у майбутньому, і ці люди можуть не знати причини вашої пропозиції щодо коду.
Нарендра Ядхав

5

Вам потрібно передати об'єкт-супутник для статичного методу, оскільки у kotlin немає статичного ключового слова - Члени об'єкта-супутника можна викликати, використовуючи просто ім'я класу як класифікатор:

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

4

Є два способи застосування статики в Котліні

Спочатку зробіть об’єкт-супутник під класом

Наприклад:

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

Ви можете назвати цю функцію як

Test.Companion.isCheck(2)

Ще один спосіб, яким ми можемо скористатися, - це зробити клас об’єктів

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

Щасливе кодування!


Для першого використання (тобто Test.Companion.isCheck(2)) IDE показує попередження та скажіть Companion reference is redundant. Він може бути зведений до, Test.isCheck(2)а зменшена форма більше близька до еквіваленту java.
VSB

3

У Котліна немає статичного ключового слова. Ви використовували це для Java

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

і для Котліна

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

Телефонуйте на Java

AppHelper.getAge();

Телефонуйте на Котлін

AppHelper.Companion.getAge();

Я думаю, що його працює чудово.


3

Я хотів би додати щось до наведених вище відповідей.

Так, ви можете визначити функції у файлах вихідного коду (поза класом). Але краще, якщо ви визначаєте статичні функції всередині класу за допомогою Companion Object, оскільки ви можете додати більше статичних функцій, використовуючи розширення Kotlin .

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

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

І ви можете зателефонувати вище визначеної функції, як ви будете викликати будь-яку функцію всередині Companion Object.


3

Незважаючи на те, що зараз трохи більше 2 років, і було багато чудових відповідей, я бачу деякі інші способи отримання "статичних" полів Котліна відсутні. Ось приклад посібника для інтеропа Kotlin-Java static:

Сценарій 1: Створення статичного методу в 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
    }
}

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

Відповідь Майкла Андерсона забезпечує більшу глибину, ніж ця, і, безумовно, слід посилатися на цей сценарій.


Наступний сценарій обробляє створення статичних полів у Котліні, так що Java не повинна постійно телефонувати KotlinClass.foo()в тих випадках, коли вам не потрібно статичної функції.

Сценарій 2: Створення статичної змінної в 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 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);
    }
}

Однією з чудових особливостей Котліна є те, що ви можете створювати функції та змінні верхнього рівня. Це дає змогу створювати "безкласові" списки постійних полів і функцій, які, в свою чергу, можуть використовуватися як staticфункції / поля на Java.

Сценарій 3: Доступ до полів і функцій верхнього рівня в Котліні з Java

Котлін

//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 як "статичні" поля, - це objectкласи Котліна . Це нульові параметри однокласних класів, які при першому використанні інстанціюються ліниво. Більше інформації про них можна знайти тут: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations

Однак для доступу до сингтона створюється спеціальний INSTANCEоб’єкт, який так само громіздко мати справу Companion. Нижче описано, як використовувати примітки, щоб надати їй таку чистоту staticна Java:

Сценарій 4: Використання objectзанять

Котлін

@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

Щоб зробити його коротким, ви можете використовувати "супутник об'єкта", щоб потрапити в статичний світ Котліна на зразок:

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

і для постійного використання поля "const val", як у коді. але намагайтеся уникати статичних класів, оскільки це створює труднощі при тестуванні одиниць за допомогою Mockito !.


3

Точне перетворення статичного методу java в еквівалент kotlin було б таким. Наприклад, тут клас util має один статичний метод, який був би еквівалентним як у java, так і в kotlin. Використання @JvmStatic є важливим.

Код Java:

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

Котлін Код:

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

2

Просто вам потрібно створити супутній об’єкт і помістити в нього функцію

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

Щоб викликати метод із класу kotlin:

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

або Використання імпорту

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

Щоб викликати метод із класу java:

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

або додавши до методу анотацію @JvmStatic

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

або обидва, додаючи анотацію @JvmStatic до методу та здійснюючи статичний імпорт у java

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

2

Для Java:

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

Еквівалентний код Котліна:

object  Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}

Отже, для еквівалента статичних методів Java є клас об'єктів у Котліні.


2

Для Android використовується рядок від однієї діяльності до всієї необхідної діяльності. Так само, як статичний у Java

public final static String TEA_NAME = "TEA_NAME";

Еквівалентний підхід у Котліні:

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

Ще одна діяльність, де потрібне значення:

val teaName = MainActivity.TEA_NAME

2

окрім відповіді Майкла Андерсона, у моєму проекті є кодування з іншими способами.

Спочатку:

ви можете побілити всі змінні в один клас. створив файл kotlin на ім’я Const

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

Ви можете використовувати його в котліні та Java-коді

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

Друге:

Ви можете використовувати функцію розширення Kotlin,
створену файлом kotlin з назвою Ext , нижче коду - це весь код у файлі Ext

package pro.just.yumu

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

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

Ви можете використовувати його в котлін-коді

 Log.d("stackoverflow", FIRST_NAME)

Ви можете використовувати його в коді Java

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

1

Запишіть їх безпосередньо у файли.

На Java (некрасиво):

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

У Котліні:

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

Ці два фрагменти коду зрівнюються після компіляції (навіть зібране ім'я файлу file:JvmNameвикористовується для керування ім'ям компільованого файлу, яке слід поставити перед оголошенням імені пакета).


7
Ви забули "Kotlin (потворно)" ... KOTLIN: супутник об'єкта {val handler = object: Handler (Looper.getMainLooper ()) {] ..... JAVA: статичний обробник Handler = новий обробник (Looper.getMainLooper () ) {};
CmosBattery

1

Використовуйте @JVMStaticанотацію

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

Нехай у вас є клас Учень . І у вас є один статичний метод getUniversityName () та одне статичне поле під назвою totalStudent .

Вам слід оголосити блок- супровідний об’єкт у вашому класі.

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

Тоді виглядає ваш клас

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

Тоді ви можете використовувати такі статичний метод і поля, як цей спосіб.

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

1

У kotlin немає статичного ключового слова. kotlin docs рекомендує використовувати функції рівня пакету, якщо ви хочете слідувати DRY. Створіть файл із розширенням .kt та введіть у нього свій метод.

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

після компіляції m матиме підпис публічної статичної остаточної недійсності

і

import p.m


0

Ви можете домогтися статичної функціональності в Kotlin за допомогою Companion Objects

  • Додавання супутника до декларації об’єкта дозволяє додати статичну функціональність до об'єкта, навіть якщо фактична статична концепція не існує в Котліні.
  • Об'єкт компаньйона може отримати доступ до всіх членів класу теж, в тому числі приватних забудовників.
  • Об'єкт компаньйона инициализируется при створенні екземпляра класу.
  • Об'єкт супутник не може бути оголошений поза класом.

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

Члени об'єкта-супутника можна викликати, використовуючи просто ім'я класу як класифікатор:

Вихід:

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

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

0

Усі статичні елементи та функції повинні знаходитися всередині супутнього блоку

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

    fun staticMethod() {
    }
  }

0

Дуже багато людей згадують супутні об’єкти, що правильно. Але, щоб ви знали, ви також можете використовувати будь-який тип об'єкта (використовуючи ключове слово об'єкта, а не клас), тобто,

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

Використовуйте його так само, як і будь-який статичний метод у Java:

StringUtils.toUpper("foobar")

Такий зразок є непотрібним у Котліні, одна з його сильних сторін полягає в тому, що він позбавляється потреби в класах, наповнених статичними методами. Більш доцільно замість цього використовувати глобальні, розширення та / або локальні функції, залежно від конкретного випадку використання. Там, де я працюю, ми часто визначаємо глобальні функції розширення в окремому плоскому файлі із умовою іменування: [className] Extensions.kt, тобто FooExtensions.kt. Але більш типово ми пишемо функції там, де вони потрібні всередині свого операційного класу чи об'єкта.


0

На Java ми можемо писати нижче способом

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

У Котліні ми можемо написати нижче

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

супутник використовується як статичний в Котліні.


0

Постачальник документів kotlin пропонує три способи зробити це, перший - визначити функцію в пакеті, без класу:

package com.example

fun f() = 1

другий - використання @JvmStatic анотації:

package com.example

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

третім є використання супутнього об'єкта:

package com.example

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

-1

Якщо вам потрібна функція або властивість прив'язуватися до класу, а не до його екземплярів, ви можете оголосити його всередині супутнього об'єкта:

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

Об'єктом-компаньйоном є синглтон, і до його членів можна отримати доступ безпосередньо через ім'я класу, що містить

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

Схоже, прийнята відповідь вже описує супутні об’єкти. Так само багато інших відповідей. Чи відповідає ваша відповідь щось нове?
Sneftel

Для подальшого роз'яснення ви можете ознайомитись тут kotlinlang.org/docs/tutorials/kotlin-for-py/…
asad mahmood

-2

Можна використовувати об'єкти супутника - kotlinlang

Що це можна показати, спершу створивши цей інтерфейс

interface I<T> {

}

Тоді ми повинні зробити функцію всередині цього інтерфейсу:

fun SomeFunc(): T

Потім після цього нам потрібен клас:

class SomeClass {}

всередині цього класу нам потрібен супутник Об'єкт всередині цього класу:

companion object : I<SomeClass> {}

всередині цього об'єкта-супутника нам потрібна ця стара SomeFuncфункція, але нам потрібно переборювати:

override fun SomeFunc(): SomeClass = SomeClass()

Нарешті, нижче всієї цієї роботи. Нам потрібно щось, щоб живити цю статичну функцію, нам потрібна змінна:

var e:I<SomeClass> = SomeClass()
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.