Что эквивалентно статическим методам Java в Kotlin?
Здесь нет static Ключевое слово в Котлине.
Каков наилучший способ представить static Java-метод в Котлине?
39 ответов
Вы помещаете функцию в "объект-компаньон".
Таким образом, код Java, как это:
class Foo {
public static int a() { return 1; }
}
станет
class Foo {
companion object {
fun a() : Int = 1
}
}
Затем вы можете использовать его внутри кода Kotlin как
Foo.a();
Но из Java-кода вам нужно будет вызвать его как
Foo.Companion.a();
(Который также работает изнутри Kotlin.)
Если вам не нравится указывать Companion немного вы можете добавить @JvmStatic аннотации или назовите свой класс-компаньон.
Из документов:
Сопутствующие объекты
Объявление объекта внутри класса может быть помечено ключевым словом companion:
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;
}
}
что позволит вам вызывать его из Kotlin таким же образом, но из Java, как Foo.Blah.a() (который также будет работать в Котлине).
Документы рекомендуют решить большинство потребностей в статических функциях с помощью функций уровня пакета. Они просто объявлены вне класса в файле исходного кода. Пакет файла может быть указан в начале пакета с ключевым словом пакета.
декларация
package foo
fun bar() = {}
использование
import foo.bar
альтернативно
import foo.*
Теперь вы можете вызвать функцию с помощью:
bar()
или если вы не используете ключевое слово import:
foo.bar()
Если вы не укажете пакет, функция будет доступна из корня.
Если у вас есть только опыт работы с Java, это может показаться немного странным. Причина в том, что kotlin не является строго объектно-ориентированным языком. Можно сказать, что он поддерживает методы вне классов.
1. Определите:
любой method/ val/ var внутри object(ключевое слово для Singleton) будет действовать как статический в Java.
Использовать companion object если вы хотите вызвать метод, просто используя класс, который содержит объект.
object Foo{
fun sayFoo() = println("Foo")
val bar ="bar"
}
2. Использование:
Foo.sayFoo()
println(Foo.bar)
3. Выход:
Foo
bar
Используйте объект для представления val/var/method, чтобы сделать статичным. Вы также можете использовать объект вместо синглтон-класса. Вы можете использовать компаньон, если вы хотите сделать статические внутри класса
object Abc{
fun sum(a: Int, b: Int): Int = a + b
}
Это также сработало для меня
object Bell {
@JvmStatic
fun ring() { }
}
из Котлина
Bell.ring()
с Явы
Bell.ring()
Несмотря на то, что ему уже более 2 лет, и у него было много отличных ответов, я вижу, что некоторые другие способы получения "статических" полей Котлина отсутствуют. Вот пример руководства для Kotlin-Java static Interop:
Сценарий 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 } }Джава
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); } }
Ответ Майкла Андерсона дает больше глубины, чем это, и на него обязательно следует ссылаться для этого сценария.
Этот следующий сценарий обрабатывает создание статических полей в Kotlin, так что 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 } }Джава
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 является то, что вы можете создавать функции и переменные верхнего уровня. Это позволяет создавать "бесклассовые" списки константных полей и функций, которые, в свою очередь, могут использоваться как static функции / поля в Java.
Сценарий 3: Доступ к полям и функциям верхнего уровня в Kotlin из 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!") }Джава
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 как "статические" поля - это Kotlin object классы. Это одноэлементные классы с нулевым параметром, которые лениво создаются при первом использовании. Более подробную информацию о них можно найти здесь: https://kotlinlang.org/docs/reference/object-declarations.html
Тем не менее, для доступа к синглтону, специальный 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'?" }Джава
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); } }
Верхний уровень / для недвижимости
Верхний уровень
Когда свойства в некоторой степени связаны с классом, определите их как свойства верхнего уровня непосредственно перед объявлением класса:
const val MAX_ATTEMPTS = 3
private const val DEFAULT_NAME = "Guest"
private const val MIN_AGE = 16
data class User(val id: String, val name: String = DEFAULT_NAME)
Это похоже на свойства в Java.
Когда свойства полностью независимы от какого-либо класса, вы можете определить их как верхний уровень в отдельном файле без класса.
Когда свойства тесно связаны с классом и будут использоваться только в этом классе, определите их внутри:
data class User(val id: String, val name: String = DEFAULT_NAME) {
companion object {
const val DEFAULT_NAME = "Guest"
const val MIN_AGE = 16
}
}
Верхний уровень / для методов
Верхний уровень
Подобно свойствам выше, когда функции в некоторой степени связаны с классом, определите их чуть выше класса:
fun getAllUsers() { }
fun getProfileFor(userId: String) { }
data class User(val id: String, val name: String)
Использование:
val userList = getAllUsers()
Когда функции тесно связаны с классом, определите их внутри:
data class User(val id: String, val name: String) {
companion object {
fun getAll() { }
fun profileFor(userId: String) { }
}
}
Использование:
val userProfile = User.profileFor("34")
Это похоже на методы в Java.
Функции верхнего уровня часто более идиоматичны для Kotlin. Лучшая причина для определения функций внутри - это расширение с помощью. Пример этого показан в разделе singleton.
Вложенный класс для класса
Когда классы со связанными функциями принадлежат друг другу, их можно сгруппировать вместе, вложив:
class User(val id: String, val name: String) {
class UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
Это эквивалентно вложенным классам в Java. В
UserAccess класс здесь реализует
UserDao.
Использование:
fun main() {
val john = User("34", "John")
val userAccess = User.UserAccess()
userAccess.add(john)
}
Синглтон для
Верхний уровень
Когда вам нужен только один объект класса, вам больше не нужно создавать внутри класса, как в Java. Просто используйте объявление верхнего уровня:
object UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
Обратите также внимание на то, как легко расширить
interface или в синглтоне.
Приведенный выше код под капотом дает следующее
static INSTANCE шаблон singleton в Java (упрощенный):
public final class UserAccess implements UserDao {
public static final UserAccess INSTANCE;
public void add(User user) { }
public void remove(String id) { }
private UserAccess() { }
static { INSTANCE = new UserAccess();}
}
Когда синглтон тесно связан с использованием класса:
data class User(val id: String, val name: String) {
companion object : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
Таким образом вы получите более элегантное именование:
User.add(john). Кроме того, вы проясняете намерение, что этот синглтон используется только как утилита для
Userучебный класс. Вы также можете использовать
object без
companion ключевое слово внутри класса, если вам нужно несколько синглтонов или групп функций / свойств.
для фабрики
Заводские функции в Колтине создаются с использованием. Фабричные функции полезны, когда вы хотите предоставить несколько способов создания объекта, в котором процесс создания объекта сложен или когда несколько конструкторов недостаточно выразительны.
Например,
newInstance() Функция factory в следующем фрагменте кода создает пользователя путем автоматической генерации:
class User private constructor(val id: Long, val name: String) {
companion object {
private var currentId = 0L;
fun newInstance(name: String) = User(currentId++, name)
}
}
Это эквивалентно фабричным методам в Java.
Хранится
private но имеет доступ к
constructor.
В приведенном выше коде гарантируется согласованность следующего поколения, поскольку a - одноэлементный объект, и только один объект будет отслеживать
id, повторяющихся идентификаторов не будет.
Также обратите внимание, что сопутствующие объекты могут иметь свойства (
currentId в данном случае) для представления состояния.
Использование:
val john = User.newInstance("John")
для взаимодействия с Java
Статической концепции Java в Котлине не существует. А
companion object это пример настоящего
classназывается . Итак, когда вы вызываете код Kotlin из Java, объект класса сначала создается за кулисами. Вам нужно вызвать функцию, используя
Companion объект в Java:
Profile userProfile = User.Companion.profileFor("34");
Для идиоматического именования Java и меньшей многословности используйте аннотацию к этой функции или свойству:
companion object {
@JvmStatic
fun profileFor(userId: String): Profile { }
}
В
@JvmStatic аннотация создает отдельный чистый
static копия
getProfileFor()функция. Теперь вы можете использовать его из Java с обычным синтаксисом:
Profile userProfile = User.profileFor("34");
Вот и все! Надеюсь, примеры будут полезны для ваших проектов.
Есть 2 способа применения статики в Котлине
Сначала создайте объект-компаньон в классе
Например:
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
}
}
Удачного кодирования!
У Kotlin нет статического ключевого слова. Вы использовали это для Java
class AppHelper {
public static int getAge() {
return 30;
}
}
и для котлина
class AppHelper {
companion object {
fun getAge() : Int = 30
}
}
Призыв к Java
AppHelper.getAge();
Позвони в Котлин
AppHelper.Companion.getAge();
Я думаю, что это работает отлично.
Просто используйте этот подход
object Foo{
fun foo() = println("Foo")
val bar ="bar"
}
Foo.INSTANCE.foo()
Вам нужно передать сопутствующий объект для статического метода, потому что у kotlin нет статического ключевого слова. Члены этого сопутствующего объекта можно вызвать, используя просто имя класса в качестве квалификатора:
package xxx
class ClassName {
companion object {
fun helloWord(str: String): String {
return stringValue
}
}
}
Просто вам нужно создать сопутствующий объект и поместить в него функцию
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")
}
}
Точное преобразование статического метода Java в эквивалент Котлина будет выглядеть следующим образом. Например, здесь класс util имеет один статический метод, который был бы эквивалентен как в java, так и в kotlin. Использование @JvmStatic важно.
//Java
class Util{
public static String capitalize(String text){
return text.toUpperCase();}
}
//Kotlin
class Util {
companion object {
@JvmStatic
fun capitalize(text:String): String {
return text.toUpperCase()
}
}
}
Для Java:
public class Constants {
public static final long MAX_CLICK_INTERVAL = 1000;}
Эквивалентный код Котлина:
object Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}
Так что для эквивалента Java статические методы - это объектный класс в Kotlin.
Я хотел бы добавить что-то к ответам выше.
Да, вы можете определять функции в файлах исходного кода (вне класса). Но будет лучше, если вы определите статические функции внутри класса, используя Companion Object, потому что вы можете добавить больше статических функций, используя расширения Kotlin.
class MyClass {
companion object {
//define static functions here
}
}
//Adding new static function
fun MyClass.Companion.newStaticFunction() {
// ...
}
И вы можете вызвать определенную выше функцию, как и любую другую функцию внутри объекта Companion.
Для краткости вы можете использовать "объект-компаньон", чтобы попасть в статический мир Kotlin, например:
companion object {
const val TAG = "tHomeFragment"
fun newInstance() = HomeFragment()
}
и чтобы сделать постоянное поле, используйте "const val" как в коде
Для 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
За исключением ответа Майкла Андерсона, у меня есть кодирование с двумя другими способами в моем проекте.
Первый:
вы можете объединить все переменные в один класс. создал файл котлина с именем Const
object Const {
const val FIRST_NAME_1 = "just"
const val LAST_NAME_1 = "YuMu"
}
Вы можете использовать его в коде kotlin и java
Log.d("stackru", 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("stackru", FIRST_NAME)
Вы можете использовать его в Java-коде
Log.d("stackru", ExtKt.FIRST_NAME);
Предположим, у вас есть ученик класса. И у вас есть один статический метод 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
Использование @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)
}
}
}
Сопутствующие объекты - альтернатива ключевого слова java static, и вы можете сделать класс или метод статическими, объявив их как сопутствующие объекты.
Вам не нужно указывать сопутствующие объекты по имени класса, если вы вызываете их из одного и того же класса.
Например:
class SomeClass() {
val id: Int
init {
id = nextId++
}
private companion object {
var nextId = 1
}
}
fun main(args: Array<String>) {
repeat(2) {
println(SomeClass().id)
}
}
Используйте функцию внутри "объекта-компаньона или именованного объекта".
Смотрите пример сопутствующего объекта:
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 Utils {
fun someFunction()
}
Так что это будет выглядеть как при вызове метода.
Utils.someFunction()
Запишите их прямо в файлы.
На Яве (некрасиво):
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 используется для управления именем скомпилированного файла, которое следует поместить непосредственно перед объявлением имени пакета).
Сделать сопутствующий объект и пометить метод аннотацией jvmstatic
В kotlin нет статического ключевого слова. kotlin docs рекомендует использовать функции уровня пакета, если вы хотите следовать DRY. Создайте файл с расширением .kt и поместите в него свой метод.
package p
fun m(){
//fun body
}
после компиляции m будет иметь подпись публичного статического окончательного void
а также
import p.m
☺
Код Java похож на приведенный ниже:
class Foo { public static int a() { return 1; } }
станет как ниже в kotlin:
class Foo { companion object { fun a() : Int = 1 } }
Однако, используя аннотацию @JvmStatic в JVM, мы можем получить члены сопутствующих объектов, сгенерированные как реальные статические методы и поля.
Вы можете достичь статической функциональности в Kotlin с помощью Companion Objects
- Добавление компаньона к объявлению объекта позволяет добавитьстатическую функциональность к объекту, даже если фактическая статическая концепция не существует в Kotlin.
- Сопутствующий объект может также получить доступ ко всем членам класса, включая частные конструкторы.
- Сопутствующий объект инициализируется при создании экземпляра класса.
Сопутствующий объект не может быть объявлен вне класса.
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
Многие люди упоминают сопутствующие объекты, и это правильно. Но, как вы знаете, вы также можете использовать любой объект (используя ключевое слово object, а не class), т.е.
object StringUtils {
fun toUpper(s: String) : String { ... }
}
Используйте его так же, как любой статический метод в Java:
StringUtils.toUpper("foobar")
Такой тип шаблона бесполезен в Kotlin, однако, одна из его сильных сторон заключается в том, что он избавляется от необходимости в классах, заполненных статическими методами. Вместо этого более целесообразно использовать глобальные, расширенные и / или локальные функции, в зависимости от вашего варианта использования. Там, где я работаю, мы часто определяем глобальные функции расширения в отдельном плоском файле с соглашением об именах: [className]Extensions.kt, т.е. FooExtensions.kt. Но, как правило, мы пишем функции там, где они нужны, внутри их рабочего класса или объекта.