Использовать объект для представления val / var / method для статичности. Вы также можете использовать объект вместо Singleton. Вы можете использовать компаньон, если хотите сделать статичным внутри класса

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

Вы можете использовать объекты, отличные от сопутствующего объекта

object Utils {
    fun someFunction()
}

. Это будет выглядеть, когда вызывается метод.

Utils.someFunction()

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

Объявление

package foo

fun bar() = {}

Использование

import foo.bar

Альтернативно

import foo.*

Теперь вы можете вызвать функцию с помощью:

bar()

или если вы не используете ключевое слово import:

foo.bar()

Если вы это сделаете не указывать пакет, функция будет доступна из корня.

Если у вас есть только опыт работы с java, это может показаться немного странным. Причина в том, что котлин не является строго объектно-ориентированным языком. Можно сказать, что он поддерживает методы вне классов.

Код java выглядит следующим образом:

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

станет следующим в kotlin:

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

Однако, используя @JvmStatic аннотацию на JVM, мы можем имеют члены сопутствующих объектов, сгенерированных как реальные статические методы и поля.

Записывать их непосредственно в файлы.

В Java (уродливый):

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

В Kotlin:

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

Эти две части кодов равны после компиляции (даже скомпилированное имя файла, file:JvmName используется для управления скомпилированным именем файла, которое должно быть помещено непосредственно перед объявлением имени пакета).

Любой method/ val/ var внутри object (ключевое слово для Singleton) будет действовать как static в java.

Используйте companion object, если вы хотите вызвать метод просто используя класс, содержащий объект.

object Foo{
fun sayFoo() = println("Foo")
val bar ="bar"
}

2. Использование:

Foo.sayFoo()
println(Foo.bar)

3. Выход:

Foo
bar

В статическом методе java

public static add(){

}

В статическом методе kotlin

fun add():??? {
}

Все статические члены и функции должны быть внутри сопутствующего блока

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

    fun staticMethod() {
    }
  }

Вам нужно передать объект-компаньон для статического метода, потому что у kotlin нет статического ключевого слова. Члены сопутствующего объекта можно вызвать, просто используя имя класса в качестве определителя:

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

Если вы следуете стилю написания статики в верхней части класса на Java, я предлагаю попытаться рассмотреть возможность записи их на верхнем уровне (например, перед объявлением класса) в Котлине. Для многих случаев использования он работает лучше, чем введение сопутствующего объекта

Пример кода:

class Person {
companion object Test {
    fun callMe() = println("I'm called.")
}


}

fun main(args: Array<String>) { Person.callMe()}

Когда вы запускаете программу, выход будет:

Я вызван.

Используйте функцию внутри «объекта-компаньона или именованного объекта».

См. пример объекта-компаньона:

   class Foo {
  companion object {
     fun square(x : Int) : Int = x*x
  }
}

См. пример именованного объекта

object Foo{
   fun square(x : Int) : Int = x*x
}

Доступ к нему возможен с помощью

val k = Foo.square(12)

Это также сработало для меня

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

из Kotlin

Bell.ring()

из Java

Bell.ring()

Предположим, у вас есть класс Student. И у вас есть один статический метод getUniversityName () & amp; одно поле называется 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

У Kotlin нет никакого статического ключевого слова. Вы использовали это для java

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

и For Kotlin

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

Вызов для Java

AppHelper.getAge();

Вызов для Kotlin

AppHelper.Companion.getAge();

Я думаю, что он работает отлично.

Я хотел бы добавить что-то к приведенным выше ответам.

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

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

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

И вы можете вызывать выше определенную функцию, как вы вызовете любую функцию внутри объекта Companion.

object objectName {
    fun funName() {

    }
}

создать объект-компаньон и отметить метод с помощью jvmstatic annotation

Вы можете достичь статической функциональности в 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

Просто вам нужно создать объект-компаньон и поместить в него функцию

  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

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

Объекты Companion являются альтернативой ключевому слову java static, и вы можете сделать класс или метод статическими, объявив их как объекты Companion. Вам не нужно квалифицировать объекты-компаньоны с именем класса, если вы вызываете их из одного класса.

Например:

class SomeClass() {

    val id: Int

    init {
       id = nextId++       
    }

    private companion object {
       var nextId = 1
    }
}

fun main(args: Array<String>) {
    repeat(2) { 
        println(SomeClass().id)
    }
}