코틀린에서 자바 정전기법에 해당하는 것은 무엇인가?
거기에는 없다static코틀린어로 키워드.
A을 나타내는 가장 좋은 방법은?static코틀린에 자바 방식이요?
함수를 "동반자 객체"에 배치하십시오.
자바 코드는 다음과 같다.
class Foo {
public static int a() { return 1; }
}
될 것이다
class Foo {
companion object {
fun a() : Int = 1
}
}
그런 다음 코틀린 코드 안쪽에서 다음과 같이 사용할 수 있다.
Foo.a();
하지만 Java 코드 내에서 당신은 그것을 다음과 같이 부를 필요가 있을 것이다.
Foo.Companion.a();
(또한 코틀린 내부에서 작동한다.)
이 지만을 , 그것은 경우이다.Companion비트 a를 추가할 수 있음@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와 Kotlin 양쪽으로부터 접근 가능한 진짜 Java 정적 함수로 존재할 것이다.Foo.a().
만약 그것이 단지 미움받는다면Companion그런 다음 다음과 같이 보이는 동반 객체에 대한 명시적 이름을 제공하십시오.
class Foo {
companion object Blah {
fun a() : Int = 1;
}
}
코틀린에서 온 것과 같은 방식으로, 하지만 자바에서 온 것처럼Foo.Blah.a()(코틀린에서도 효과가 있을 것이다.)
Docs는 정적 기능에 대한 대부분의 니즈를 패키지 레벨 기능으로 해결할 것을 권고한다.그것들은 단순히 소스 코드 파일에서 클래스 외부에 선언된다.파일의 패키지는 패키지 키워드가 있는 파일의 시작 부분에 지정할 수 있다.
선언
package foo
fun bar() = {}
사용법
import foo.bar
대안으로
import foo.*
이제 다음 기능을 호출할 수 있다.
bar()
또는 가져오기 키워드를 사용하지 않는 경우:
foo.bar()
패키지를 지정하지 않으면 루트로부터 기능에 액세스할 수 있다.
만약 당신이 자바에 대한 경험만 있다면, 이것은 조금 이상하게 보일지도 모른다.그 이유는 코틀린이 엄밀하게 목적 지향적인 언어가 아니기 때문이다.당신은 그것이 수업 외의 방법을 지원한다고 말할 수 있다.
편집: 패키지 레벨 기능 권장 문장이 더 이상 포함되지 않도록 문서를 편집했다.이것은 위에서 언급된 원본이다.
A. 오래된 자바 방식:
a를 하다.
companion object정적 방법/변수를 동봉하다class Foo{ companion object { fun foo() = println("Foo") val bar ="bar" } }사용:
Foo.foo() // Outputs Foo println(Foo.bar) // Outputs bar
B. 뉴 코틀린 방식
클래스 없이 파일에 직접 선언
.kt파일fun foo() = println("Foo") val bar ="bar"사용
methods/variables그들의 이름으로(가져온 후)사용:
foo() // Outputs Foo println(bar) // Outputs bar
val/var/method를 나타내는 객체를 사용하여 정적을 만드십시오.싱글톤 클래스 대신 오브젝트를 사용할 수도 있다.클래스의 정적 내부를 만들려면 동반자를 사용할 수 있다.
object Abc{
fun sum(a: Int, b: Int): Int = a + b
}
Java에서 호출해야 하는 경우:
int z = Abc.INSTANCE.sum(x,y);
Kotlin에서는 INSTANT를 무시한다.
이것은 나에게도 효과가 있었다.
object Bell {
@JvmStatic
fun ring() { }
}
코틀린 출신
Bell.ring()
자바 출신
Bell.ring()
object objectName {
fun funName() {
}
}
지금은 2년이 조금 넘었고, 훌륭한 해답을 많이 가지고 있었지만, 나는 "정적인" 코틀린 필드를 얻는 다른 방법들을 보고 있다.여기 코틀린자바에 대한 예시 가이드가 있다.staticinterop:
시나리오 1: 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 } }자바
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가 계속 전화할 필요가 없도록 Kotlin에서 정적 필드 작성을 처리한다.KotlinClass.foo()정적 기능을 원하지 않는 경우.
시나리오 2: Kotlin for 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); } }
코틀린의 가장 큰 특징 중 하나는 최상위 수준의 기능과 변수를 만들 수 있다는 것이다.이를 통해 일정한 필드 및 함수의 "종류 없는" 리스트를 작성할 수 있으며, 이는 다시 다음과 같이 사용될 수 있다.staticJava의 함수/필드
시나리오 3: 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!") }자바
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); } }
자바에서 "정적" 분야로 사용할 수 있는 또 다른 주목할 만한 언급은 코틀린이다.object반이들은 제로 파라미터 싱글톤 클래스로, 처음 사용할 때 게으르게 인스턴스화된다.자세한 내용은 https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations를 참조하십시오.
그러나 싱글톤에 접근하기 위해서는 특별한 것이 필요하다.INSTANCE객체가 만들어지는데, 그만큼 다루기가 번거롭다.Companion주석을 사용하여 주석을 정리하는 방법은 다음과 같다.static자바어로 느끼다:
시나리오 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); } }
코틀린은 정적 키워드가 없다.Java와 Kotlin은 아래 코드를 사용할 수 있다.
object AppHelper {
@JvmStatic
fun getAge() : Int = 30
}
Java 클래스 호출
AppHelper.getAge();
코틀린 클래스 호출
AppHelper.getAge()
그것은 나에게 완벽하게 효과가 있다.고마워요.
cotlin에는 정적 키워드가 없으므로 정적 방법을 위해 동반 객체를 통과해야 함 - class name을 한정자로 사용하여 동반 객체의 멤버를 호출할 수 있음:
package xxx
class ClassName {
companion object {
fun helloWord(str: String): String {
return stringValue
}
}
}
최상위 수준 /companion object을 위해static
최상위 수준
속성이 클래스와 다소 관련이 있는 경우 클래스 선언 직전에 최상위 속성으로 정의하십시오.
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)
이것은 ~와 비슷하다.staticJava의 속성.
속성이 모든 클래스와 완전히 독립되어 있는 경우 클래스가 없는 별도의 파일에서 최상위 수준으로 정의할 수 있다.
companion object
속성이 클래스와 밀접하게 연관되어 있고 해당 클래스에서만 사용될 경우, 해당 속성을 a 내에서 정의하십시오.companion object:
data class User(val id: String, val name: String = DEFAULT_NAME) {
companion object {
const val DEFAULT_NAME = "Guest"
const val MIN_AGE = 16
}
}
최상위 수준 /companion object을 위해static방법들
최상위 수준
위의 특성과 유사하게 함수가 클래스와 어느 정도 관련이 있는 경우 클래스 바로 위에 정의하십시오.
fun getAllUsers() { }
fun getProfileFor(userId: String) { }
data class User(val id: String, val name: String)
사용량:
val userList = getAllUsers()
companion object
함수가 클래스와 밀접하게 관련된 경우, a 내에서 정의하십시오.companion object:
data class User(val id: String, val name: String) {
companion object {
fun getAll() { }
fun profileFor(userId: String) { }
}
}
사용량:
val userProfile = User.profileFor("34")
이것은 ~와 비슷하다.static자바의 방법들.
최상위 기능은 코틀린에게 더 관용적인 경우가 많다.내부 기능을 정의해야 하는 더 나은 이유companion object할 때 장장은 경우이다.companion object…과 함께interface이것의 예는 싱글톤 섹션에 나와 있다.
중첩 클래스:static계급
관련 기능을 가진 클래스가 함께 속할 경우 다음 중첩으로 그룹화할 수 있다.
class User(val id: String, val name: String) {
class UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
}
이것은 에 해당한다.staticJava의 중첩된 클래스.그UserAccess이곳의 클래스는 a를 구현한다.interface UserDao.
사용량:
fun main() {
val john = User("34", "John")
val userAccess = User.UserAccess()
userAccess.add(john)
}
싱글턴object을 위해static INSTANCE
최상위 수준
클래스의 단일 오브젝트만 원하는 경우 더 이상 오브젝트를 작성할 필요가 없음static INSTANCE자바 같은 반에서.간단히 최상위 수준 사용object선언:
object UserAccess : UserDao {
override fun add(user: User) { }
override fun remove(id: String) { }
}
또한 얼마나 쉽게 확장할 수 있는지 확인하십시오.interface또는 aclass단톤으로
위의 코드는 후드 아래에서 다음과 같이 생성된다.static INSTANCEJava의 싱글톤 패턴(간단화):
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();}
}
companion object
싱글톤이 클래스 사용과 밀접한 관련이 있는 경우companion object:
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할 수 . 당신은 또한 이 class를 사용할 수 있다.object 없이companion다중 단골격 또는 함수/수직 그룹을 원하는 경우 클래스 내의 키워드.
companion object을 위해static
콜틴의 공장 기능은 다음을 사용하여 생성된다.companion object를 만들 수 가지 표현하지 때 공장 기능은 객체 구성 과정이 복잡한 객체를 만들 수 있는 여러 가지 방법을 제공하거나 여러 시공자가 충분히 표현하지 못할 때 유용하다.
예를 들어,newInstance()은 다다이 장의 를 생성하여 를 생성한다.id자동:
class User private constructor(val id: Long, val name: String) {
companion object {
private var currentId = 0L;
fun newInstance(name: String) = User(currentId++, name)
}
}
이것은 에 해당한다.static자바의 공장 방식.
그constructor보관되어 있다private그 외에는companion object에 접근할 수 있다.constructor.
위의 코드에서 다음 코드의 일관성id는 보장이기 된다.companion object 오직 의 물체만이 의 수리를 할 이다.id중복된 ID는 없을 겁니다.
또한 지원 개체에는 속성이 있을 수 있음(currentId(이 경우) 주(州)를 대표한다.
사용량:
val john = User.newInstance("John")
@JvmStatic 상호용성용용용용용
자바의 정적인 개념은 코틀린에 존재하지 않는다.companion object보다.class불렀다Companion 의 그러니까 자바에서 코틀린 코드를 부르면, 코틀린 코드의 목적어.Companion수업은 막후에서 먼저 인스턴스화된다.다음 명령어를 사용하여 함수를 호출해야 함CompanionJava의 객체:
Profile userProfile = User.Companion.profileFor("34");
관용적인 Java 이름 지정 및 상세도 감소의 경우@JvmStatic해당 기능 또는 속성에 대한 주석:
companion object {
@JvmStatic
fun profileFor(userId: String): Profile { }
}
그@JvmStatic주석으로 별도의 순수 생성static의 복제품.getProfileFor()기글을 하다 할 수 이제 정규 구문을 사용하여 Java에서 사용할 수 있음:
Profile userProfile = User.profileFor("34");
바로 그거야!그 예들이 당신의 프로젝트에 유용하기를 바란다.
단순히 동반 객체를 만들어 그 안에 기능을 넣어야 한다.
class UtilClass {
companion object {
// @JvmStatic
fun repeatIt5Times(str: String): String = str.repeat(5)
}
}
코틀린 클래스에서 메소드를 호출하려면:
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")
}
}
코틀린에 정적을 적용할 수 있는 두 가지 방법이 있다.
먼저 클래스 아래에 동반 객체를 만드십시오.
ex의 경우:
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
}
}
해피 코딩!
나는 위의 대답에 뭔가를 덧붙이고 싶다.
예, 소스 코드 파일(아웃사이드 클래스)에서 함수를 정의할 수 있다.그러나 Cotlin Extensions를 활용하여 정적 기능을 더 추가할 수 있기 때문에 Companion Object를 사용하여 클래스 내에서 정적 기능을 정의하면 더 좋다.
class MyClass {
companion object {
//define static functions here
}
}
//Adding new static function
fun MyClass.Companion.newStaticFunction() {
// ...
}
그리고 Companion Object 내부의 모든 기능을 호출할 것이므로 위에 정의된 기능을 호출할 수 있다.
Java의 경우:
public class Constants {
public static final long MAX_CLICK_INTERVAL = 1000;}
등가 Kotlin 코드:
object Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}
그래서 자바 정적 방법의 등가에는 코틀린에서 객체 클래스가 있다.
간단히 말하면 다음과 같은 Kotlin 정적 세계에 들어가기 위해 "동반자 객체"를 사용할 수 있다.
companion object {
const val TAG = "tHomeFragment"
fun newInstance() = HomeFragment()
}
그리고 일정한 필드를 만들려면 코드와 같이 "const val"을 사용하십시오.하지만 모키토를 이용한 단위 테스트에 어려움을 겪고 있기 때문에 정적인 수업은 피하도록 하라!
단일 활동에서 필요한 모든 활동으로 문자열을 사용하는 Android용.자바의 정적처럼
public final static String TEA_NAME = "TEA_NAME";
Kotlin에서의 등가 접근법:
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
자바 정적 방법을 코틀린 등가물로 정확한 변환은 다음과 같다.여기서 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()
}
}
}
마이클 앤더슨의 대답만 빼면, 내 프로젝트에서 다른 두 가지 방식과 코딩을 할 수 있다.
첫 번째:
모든 변수를 하나의 클래스에 화이트닝할 수 있다.Const라는 이름의 코틀린 파일을 만들었다.
object Const {
const val FIRST_NAME_1 = "just"
const val LAST_NAME_1 = "YuMu"
}
코틀린과 자바코드로 사용할 수 있다.
Log.d("stackoverflow", Const.FIRST_NAME_1)
두 번째:
코틀린의 확장 기능을 사용할 수 있다.
코드 아래에 Ext 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)
자바코드로 사용할 수 있다.
Log.d("stackoverflow", ExtKt.FIRST_NAME);
이 접근 방식을 사용하십시오.
object Foo{
fun foo() = println("Foo")
val bar ="bar"
}
Foo.INSTANCE.foo()
파일에 직접 쓰십시오.
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컴파일된 파일 이름을 제어하는 데 사용되며, 이는 패키지 이름 선언 직전에 넣어야 한다.
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
사용하다@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)
}
}
}
많은 사람들이 반려동물을 언급하는데, 그것은 옳다.하지만, 알다시피, 당신은 어떤 종류의 오브젝트도 사용할 수 있다(클래스가 아닌 오브젝트 키워드 사용).
object StringUtils {
fun toUpper(s: String) : String { ... }
}
Java의 정적 방법과 동일하게 사용:
StringUtils.toUpper("foobar")
그런 패턴은 코틀린에서는 쓸모가 없지만, 그것의 장점 중 하나는 정적인 방법으로 가득 찬 수업의 필요성을 없앤다는 것이다.사용 사례에 따라 글로벌, 확장 및/또는 로컬 기능을 대신 활용하는 것이 더 적절하다.내가 일하는 곳에서 우리는 종종 글로벌 확장 기능을 이름 지정 규칙에 따라 별도의 플랫 파일로 정의한다. [className]Extensions.kt, 즉 FooExtensions.kt.그러나 더 일반적으로 우리는 그들의 운영 클래스나 객체 안에서 그것들이 필요한 곳에 기능들을 쓴다.
자, 너는 학급 학생이 있다.그리고 당신은 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
코틀린에는 정적 키워드가 없다.Cotlin 문서에서는 DRY를 따르려면 패키지 레벨 기능을 사용할 것을 권장한다..kt 확장자로 파일을 만들고 메소드를 넣으십시오.
package p
fun m(){
//fun body
}
컴파일 후 m은 공개 정적 최종 무효 서명을 받는다.
그리고
import p.m
☺
자바에서는 아래와 같이 쓸 수 있다.
class MyClass {
public static int myMethod() {
return 1;
}
}
코틀린에서는, 우리는 아래에 쓸 수 있다.
class MyClass {
companion object {
fun myMethod() : Int = 1
}
}
동반자는 코틀린에서 정적으로 사용된다.
코틀린 문서 공급자는 이를 위한 세 가지 방법, 첫 번째 방법은 클래스 없이 패키지로 기능을 정의하는 것이다.
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
}
}
모든 정적 부재 및 기능이 지원 블록 안에 있어야 함
companion object {
@JvmStatic
fun main(args: Array<String>) {
}
fun staticMethod() {
}
}
클래스의 인스턴스(instance)가 아닌 클래스에 바인딩할 함수 또는 속성이 필요한 경우, 동반 객체 내부에서 선언할 수 있다.
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()
참조URL: https://stackoverflow.com/questions/40352684/what-is-the-equivalent-of-java-static-methods-in-kotlin
'IT이야기' 카테고리의 다른 글
| Nuxt:js 파일에서vuex 상점에 액세스 할 수 없다. (0) | 2022.05.17 |
|---|---|
| Java 스레드에 매개 변수를 전달하는 방법 (0) | 2022.05.16 |
| Vuex, 루트 게이터에서 이름보다 앞선 모듈 게이터를 사용할 수 없는가? (0) | 2022.05.16 |
| 뮤텍스를 고정하는 나사산을 결정할 수 있는가? (0) | 2022.05.16 |
| GLIBC란 무엇인가?그것은 무엇에 쓰이는가? (0) | 2022.05.16 |