У static
Котліна немає ключового слова.
Який найкращий спосіб представити static
метод Java в Котліні?
У static
Котліна немає ключового слова.
Який найкращий спосіб представити static
метод Java в Котліні?
Відповіді:
Ви розміщуєте функцію в "об'єкті-супутнику".
Тож код 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()
(який також працюватиме в Котліні).
fun a(): Int { return 1 }
чи навітьfun a(): Int = 1
fun a() = 1
.
Factory
- назва об'єкта-супутника - але для чого це можна використовувати? Я поняття не маю, але мені було цікаво, тому я створив питання, присвячене цьому: stackoverflow.com/q/45853459/221955 .
Документи рекомендують вирішити більшість потреб у статичних функціях за допомогою функцій на рівні пакету . Вони просто оголошуються поза класом у файлі вихідного коду. Пакет файлу можна вказати на початку файлу за допомогою ключового слова пакета.
Декларація
package foo
fun bar() = {}
Використання
import foo.bar
Як варіант
import foo.*
Тепер ви можете викликати функцію за допомогою:
bar()
або якщо ви не використовуєте ключове слово імпорту:
foo.bar()
Якщо ви не вказали пакет, функція буде доступна з кореня.
Якщо у вас є лише досвід роботи з java, це може здатися трохи дивним. Причина в тому, що kotlin не є строго об'єктно орієнтованою мовою. Можна сказати, що він підтримує методи поза класами.
Редагувати: Вони відредагували документацію, щоб більше не включати речення про рекомендації функцій рівня пакету. Це оригінал, про який згадувалося вище.
class FooPackage
всі властивості та функції вищого рівня та спрямував усі ваші посилання на них відповідним чином. Більше інформації від jetbrains.
bar()
не має значення ім'я файлу, ви можете назвати його BarUtils.kt
чи будь-що інше, то, як зазначено в тексті, ви будете імпортувати його зimport <package name>.bar
A. Старий шлях Java:
Оголосити a, companion object
щоб долучити статичний метод / змінну
class Foo{
companion object {
fun foo() = println("Foo")
val bar ="bar"
}
}
Використання:
Foo.foo() // Outputs Foo
println(Foo.bar) // Outputs bar
В. Новий шлях Котліна
Декларуйте безпосередньо у файлі без класу у .kt
файлі.
fun foo() = println("Foo")
val bar ="bar"
Використовуйте methods/variables
їхні імена . ( Після імпортування їх )
Використання:
foo() // Outputs Foo
println(bar) // Outputs bar
INSTANCE
ключове слово, як це:Foo.INSTANCE.sayFoo()
static CLASS
не просто static methdos
. Тому що з супутніми об'єктами ви все одно можете інстанціювати батьківський клас.
val
не є статичним, це еквівалент static final
на Java
Використовуйте об'єкт для подання val / var / методу для статичного. Ви також можете використовувати об'єкт замість однокласного класу. Ви можете використовувати супутника, якщо хочете стати статичним усередині класу
object Abc{
fun sum(a: Int, b: Int): Int = a + b
}
Якщо вам потрібно зателефонувати з Java:
int z = Abc.INSTANCE.sum(x,y);
У Котліні ігноруйте ІНСТАНЦІЮ.
object objectName {
fun funName() {
}
}
Вам потрібно передати об'єкт-супутник для статичного методу, оскільки у kotlin немає статичного ключового слова - Члени об'єкта-супутника можна викликати, використовуючи просто ім'я класу як класифікатор:
package xxx
class ClassName {
companion object {
fun helloWord(str: String): String {
return stringValue
}
}
}
Є два способи застосування статики в Котліні
Спочатку зробіть об’єкт-супутник під класом
Наприклад:
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.
У Котліна немає статичного ключового слова. Ви використовували це для Java
class AppHelper {
public static int getAge() {
return 30;
}
}
і для Котліна
class AppHelper {
companion object {
fun getAge() : Int = 30
}
}
Телефонуйте на Java
AppHelper.getAge();
Телефонуйте на Котлін
AppHelper.Companion.getAge();
Я думаю, що його працює чудово.
Я хотів би додати щось до наведених вище відповідей.
Так, ви можете визначити функції у файлах вихідного коду (поза класом). Але краще, якщо ви визначаєте статичні функції всередині класу за допомогою Companion Object, оскільки ви можете додати більше статичних функцій, використовуючи розширення Kotlin .
class MyClass {
companion object {
//define static functions here
}
}
//Adding new static function
fun MyClass.Companion.newStaticFunction() {
// ...
}
І ви можете зателефонувати вище визначеної функції, як ви будете викликати будь-яку функцію всередині Companion Object.
Незважаючи на те, що зараз трохи більше 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); } }
Щоб зробити його коротким, ви можете використовувати "супутник об'єкта", щоб потрапити в статичний світ Котліна на зразок:
companion object {
const val TAG = "tHomeFragment"
fun newInstance() = HomeFragment()
}
і для постійного використання поля "const val", як у коді. але намагайтеся уникати статичних класів, оскільки це створює труднощі при тестуванні одиниць за допомогою Mockito !.
Точне перетворення статичного методу 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()
}
}
}
Просто вам потрібно створити супутній об’єкт і помістити в нього функцію
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:
public class Constants {
public static final long MAX_CLICK_INTERVAL = 1000;}
Еквівалентний код Котліна:
object Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}
Отже, для еквівалента статичних методів Java є клас об'єктів у Котліні.
Для 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
окрім відповіді Майкла Андерсона, у моєму проекті є кодування з іншими способами.
ви можете побілити всі змінні в один клас. створив файл 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);
Запишіть їх безпосередньо у файли.
На 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
використовується для керування ім'ям компільованого файлу, яке слід поставити перед оголошенням імені пакета).
Використовуйте @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)
}
}
}
Нехай у вас є клас Учень . І у вас є один статичний метод 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
У kotlin немає статичного ключового слова. kotlin docs рекомендує використовувати функції рівня пакету, якщо ви хочете слідувати DRY. Створіть файл із розширенням .kt та введіть у нього свій метод.
package p
fun m(){
//fun body
}
після компіляції m матиме підпис публічної статичної остаточної недійсності
і
import p.m
☺
Ви можете домогтися статичної функціональності в 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
Дуже багато людей згадують супутні об’єкти, що правильно. Але, щоб ви знали, ви також можете використовувати будь-який тип об'єкта (використовуючи ключове слово об'єкта, а не клас), тобто,
object StringUtils {
fun toUpper(s: String) : String { ... }
}
Використовуйте його так само, як і будь-який статичний метод у Java:
StringUtils.toUpper("foobar")
Такий зразок є непотрібним у Котліні, одна з його сильних сторін полягає в тому, що він позбавляється потреби в класах, наповнених статичними методами. Більш доцільно замість цього використовувати глобальні, розширення та / або локальні функції, залежно від конкретного випадку використання. Там, де я працюю, ми часто визначаємо глобальні функції розширення в окремому плоскому файлі із умовою іменування: [className] Extensions.kt, тобто FooExtensions.kt. Але більш типово ми пишемо функції там, де вони потрібні всередині свого операційного класу чи об'єкта.
На Java ми можемо писати нижче способом
class MyClass {
public static int myMethod() {
return 1;
}
}
У Котліні ми можемо написати нижче
class MyClass {
companion object {
fun myMethod() : Int = 1
}
}
супутник використовується як статичний в Котліні.
Постачальник документів 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
}
}
Якщо вам потрібна функція або властивість прив'язуватися до класу, а не до його екземплярів, ви можете оголосити його всередині супутнього об'єкта:
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)
Можна використовувати об'єкти супутника - kotlinlang
Що це можна показати, спершу створивши цей інтерфейс
interface I<T> {
}
Тоді ми повинні зробити функцію всередині цього інтерфейсу:
fun SomeFunc(): T
Потім після цього нам потрібен клас:
class SomeClass {}
всередині цього класу нам потрібен супутник Об'єкт всередині цього класу:
companion object : I<SomeClass> {}
всередині цього об'єкта-супутника нам потрібна ця стара SomeFunc
функція, але нам потрібно переборювати:
override fun SomeFunc(): SomeClass = SomeClass()
Нарешті, нижче всієї цієї роботи. Нам потрібно щось, щоб живити цю статичну функцію, нам потрібна змінна:
var e:I<SomeClass> = SomeClass()