Kotlin'deki sabitler - bunları oluşturmanın önerilen yolu nedir?

Kotlin'de sabit oluşturmak nasıl önerilir? Peki adlandırma kuralı nedir? Bunu belgelerde bulamadım.

companion object {
    //1
    val MY_CONST = "something"

    //2
    const val MY_CONST = "something"

    //3
    val myConst = "something"
}

Yoksa ...?

Kotlin'de, sınıfta kullanılması gereken yerel sabitleri oluşturmak istiyorsanız, aşağıdaki gibi oluşturabilirsiniz.

val MY_CONSTANT = "Constants"

Ve java'da statik statik final gibi kotlin'de bir kamu sabiti oluşturmak istiyorsanız, bunu aşağıdaki gibi oluşturabilirsiniz.

companion object{

     const val MY_CONSTANT = "Constants"

}

Tamamlayıcı nesneler kullanmaktan kaçının. Kaputun arkasında, alanların erişilebilir olması için alıcı ve ayarlayıcı örnek yöntemleri oluşturulur. Örnek yöntemlerini çağırmak, statik yöntemleri çağırmaktan teknik olarak daha pahalıdır.

public class DbConstants {
    companion object {
        val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        val TABLE_USER_ATTRIBUTE_DATA = "data"
    }

Bunun yerine içindeki sabitleri tanımlayın object.

Önerilen uygulama :

object DbConstants {
        const val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        const val TABLE_USER_ATTRIBUTE_DATA = "data"
}

ve bunlara küresel olarak şu şekilde erişin: DbConstants.TABLE_USER_ATTRIBUTE_EMPID

Her şeyden önce , Kotlin'deki sabitler için adlandırma kuralı java ile aynıdır (örneğin: MY_CONST_IN_UPPERCASE).

Nasıl yaratmalıyım?

1. Üst seviye değeri olarak (önerilir)

Sen sadece kendi sınıf beyanı dışında const koymak zorunda .

İki olasılık : Sınıf dosyanızdaki sabitinizi beyan edin (sabitinizin sınıfınızla açık bir ilişkisi vardır)

private const val CONST_USED_BY_MY_CLASS = 1

class MyClass { 
    // I can use my const in my class body 
}

Bu küresel sabitin depolanacağı özel bir constants.kt dosyası oluşturun (Burada, sabitinizi projenizde yaygın olarak kullanmak istiyorsunuz):

package com.project.constants
const val URL_PATH = "https:/"

O zaman sadece ihtiyacınız olan yere aktarmanız gerekir:

import com.project.constants

MyClass {
    private fun foo() {
        val url = URL_PATH
        System.out.print(url) // https://
    }
}

2. Bunu bir tamamlayıcı nesnede (veya bir nesne bildiriminde) bildirin

Bu çok daha az temiz çünkü kaputun altında bayt kodu üretildiğinde işe yaramaz bir nesne yaratılır:

MyClass {
    companion object {
        private const val URL_PATH = "https://"
        const val PUBLIC_URL_PATH = "https://public" // Accessible in other project files via MyClass.PUBLIC_URL_PATH
    }
}

Bir const yerine val olarak bildirirseniz daha da kötüsü (derleyici işe yaramaz bir nesne + işe yaramaz bir işlev oluşturur):

MyClass {
    companion object {
        val URL_PATH = "https://"
    }
}

Not :

Kotlin'de, const sadece ilkel türleri tutabilir. Bir işlevi ona iletmek istiyorsanız, @JvmField ek açıklamasını eklemeniz gerekir. Derleme zamanında, genel statik son değişken olarak dönüştürülecektir. Ancak ilkel tipten daha yavaştır. Bundan kaçınmaya çalışın.

@JvmField val foo = Foo()

Derleme zamanında bilinen değerler (ve bence) sabit olarak işaretlenebilir.

Adlandırma kuralları Java kurallarını izlemeli ve Java kodundan kullanıldığında düzgün bir şekilde görünür olmalıdır (tamamlayıcı nesnelerle elde etmek bir şekilde zordur, ancak yine de).

Uygun sabit beyanlar:

const val MY_CONST = "something"
const val MY_INT = 1

Kotlin'de sabitleri bildirmek için bir sınıfa, nesneye veya eşlik eden bir nesneye ihtiyacınız yoktur. Tüm sabitleri içeren bir dosyayı (örneğin, Constants.kt dosyasını bildirebilir veya mevcut herhangi bir Kotlin dosyasının içine koyabilirsiniz) ve doğrudan dosyanın içindeki sabitleri bildirebilirsiniz. Derleme zamanında bilinen sabitler ile işaretlenmelidir const.

Yani, bu durumda, şöyle olmalıdır:

const val MY_CONST = "something"

ve sonra sabiti aşağıdakileri kullanarak içe aktarabilirsiniz:

import package_name.MY_CONST

Bu bağlantıya başvurabilirsiniz

Eğer const val valName = valValuesınıf adının önüne koyarsanız , bu şekilde bir

public static final YourClass.Ktpublic static finaldeğerleri olacak .

Kotlin :

const val MY_CONST0 = 0
const val MY_CONST1 = 1
data class MyClass(var some: String)

Java ayrıştırıldı:

public final class MyClassKt {
    public static final int MY_CONST0 = 0;
    public static final int MY_CONST1 = 1;
}
// rest of MyClass.java

class Myclass {

 companion object {
        const val MYCONSTANT = 479
}

constanahtar kelimeyi kullanabileceğiniz veya @JvmFieldjava'nın statik son sabiti olmasını sağlayan iki seçeneğiniz vardır .

class Myclass {

     companion object {
           @JvmField val MYCONSTANT = 479
    }

@JvmFieldEk açıklamayı kullanırsanız, derledikten sonra sabit sizin için java dediğiniz şekilde konur.
Java'da dediğiniz gibi, derleyici koddaki refakatçi sabitini aradığınızda bunun sizin için yerini alacaktır.

Ancak, const anahtar sözcüğünü kullanırsanız, sabitin değeri satır içine alınır. Satır içi ile, gerçek değer derlendikten sonra kullanıldığı anlamına gelir.

özetlemek gerekirse derleyici sizin için ne yapar:

//so for @JvmField:

Foo var1 = Constants.FOO;

//and for const:

Foo var1 = 479

Kotlin statik ve sabit değer ve yöntem beyanı

object MyConstant {

@JvmField   // for access in java code 
val PI: Double = 3.14

@JvmStatic // JvmStatic annotation for access in java code
fun sumValue(v1: Int, v2: Int): Int {
    return v1 + v2
}

}

Her yerden erişim değeri

val value = MyConstant.PI
val value = MyConstant.sumValue(10,5)

Gibi val, tanımlanmış değişkenler constanahtar kelime değişken değildir. Buradaki fark constderleme zamanında bilinen değişkenler için kullanılır.

Değişken bildirmek const, staticanahtar kelimeyi Java'da kullanmaya benzer .

Kotlin'de bir sabit değişkenin nasıl bildirileceğini görelim:

const val COMMUNITY_NAME = "wiki"

Ve Java ile yazılmış benzer kod:

final static String COMMUNITY_NAME = "wiki";

Yukarıdaki cevaplara ekleme -

@JvmField Kotlin derleyicisine bu özellik için alıcı / ayarlayıcı oluşturmamasını ve bir alan olarak göstermemesini bildirmek için kullanılabilir.

 @JvmField
 val COMMUNITY_NAME: "Wiki"

Statik alanlar

Adlandırılmış bir nesnede veya tamamlayıcı nesnede bildirilen kotlin özellikleri, söz konusu nesnede veya tamamlayıcı nesneyi içeren sınıfta statik destek alanlarına sahip olacaktır.

Genellikle bu alanlar özeldir, ancak aşağıdaki yollardan biriyle gösterilebilir:

• @JvmField açıklama;
• lateinit değiştirici;
• const değiştirici.

Daha fazla ayrıntı burada - https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#instance-fields

Cevapların hiçbirinde bahsedilmeyen bir şey, kullanım yüküdür companion objects. Okumak gibi burada , refakatçi nesneler aslında nesneleri ve onları yaratan kaynakları tüketir. Ayrıca, sabitinizi her kullandığınızda birden fazla alıcı işlevinden geçmeniz gerekebilir. İhtiyacınız Hepsi bir kaç ilkel sabitler ise muhtemelen sadece daha iyi kullanarak kapalı olacak valbir olsun daha iyi bir performans ve önlemek companion object.

TL; DR; makalenin:

Tamamlayıcı nesne kullanmak aslında bu kodu döndürür

class MyClass {

    companion object {
        private val TAG = "TAG"
    }

    fun helloWorld() {
        println(TAG)
    }
}

Bu koda:

public final class MyClass {
    private static final String TAG = "TAG";
    public static final Companion companion = new Companion();

    // synthetic
    public static final String access$getTAG$cp() {
        return TAG;
    }

    public static final class Companion {
        private final String getTAG() {
            return MyClass.access$getTAG$cp();
        }

        // synthetic
        public static final String access$getTAG$p(Companion c) {
            return c.getTAG();
        }
    }

    public final void helloWorld() {
        System.out.println(Companion.access$getTAG$p(companion));
    }
}

Bu yüzden onlardan kaçınmaya çalışın.

yerel sabitler:

const val NAME = "name"

Global sabitler:

object MyConstants{
    val NAME = "name"
    val ID = "_id"
    var EMAIL = "email"
}

MyConstants.NAME dosyasına eriş

Kotlin'de sabitleri tanımlamanın birkaç yolu vardır,

Tamamlayıcı nesneyi kullanma

    companion object {
        const val ITEM1 = "item1"
        const val ITEM2 = "item2"
    }

herhangi bir sınıf içinde yukarıdaki tamamlayıcı nesne bloğunu kullanabilir ve bu bloğun içindeki tüm alanlarınızı tanımlayabilirsiniz. Ancak bu yaklaşımda bir sorun var, belgeler diyor ki,

tamamlayıcı nesnelerin üyeleri diğer dillerdeki statik üyeler gibi görünse de, çalışma zamanında bunlar gerçek nesnelerin örnek üyeleridir ve örneğin arabirimleri uygulayabilir.

Sabitinizi tamamlayıcı nesneyi kullanarak oluşturduğunuzda ve kodu çözülen bayt kodunu gördüğünüzde, aşağıdaki gibi bir şey görürsünüz ,

  ClassName.Companion Companion = ClassName.Companion.$$INSTANCE;
  @NotNull
  String ITEM1 = "item1";
  @NotNull
  String ITEM2 = "item2";

  public static final class Companion {
     @NotNull
     private static final String ITEM1 = "item1";
     @NotNull
     public static final String ITEM2 = "item2";

     // $FF: synthetic field
     static final ClassName.Companion $$INSTANCE;

     private Companion() {
     }

     static {
        ClassName.Companion var0 = new ClassName.Companion();
        $$INSTANCE = var0;
     }
  }

Burada , tamamlayıcı nesnelerin üyeleri diğer dillerdeki statik üyeler gibi görünse de, çalışma zamanında hala gerçek nesnelerin örnek üyeleri olan belgelerin söylediklerini kolayca görebilirsiniz .

Şimdi, aşağıdaki gibi tamamlayıcı nesneyi kullanmamız gerekmediği başka bir yol geliyor ,

object ApiConstants {
      val ITEM1: String = "item1"
 }

Yine, yukarıdaki snippet'in bayt kodunun decompiled sürümünü görürseniz, böyle bir şey bulacaksınız,

public final class ApiConstants {
     private static final String ITEM1 = "item1";

     public static final ApiConstants INSTANCE;

     public final String getITEM1() {
           return ITEM1;
      }

     private ApiConstants() {
      }

     static {
         ApiConstants var0 = new ApiConstants();
         INSTANCE = var0;
         CONNECT_TIMEOUT = "item1";
      }
    }

Şimdi yukarıdaki kod çözülmüş kodu görürseniz, her değişken için get yöntemi yaratıyor. Bu get yöntemi hiç gerekli değildir.

Bu olsun yöntemlerinin kurtulmak için kullanmanız gereken, const önce val aşağıda gibi,

object ApiConstants {
     const val ITEM1: String = "item1"
 }

Şimdi yukarıdaki snippet'in ayrıştırılmış kodunu görürseniz, kodunuz için en az arka plan dönüşümünü yaptığı için okumayı daha kolay bulacaksınız.

public final class ApiConstants {
    public static final String ITEM1 = "item1";
    public static final ApiConstants INSTANCE;

    private ApiConstants() {
     }

    static {
        ApiConstants var0 = new ApiConstants();
        INSTANCE = var0;
      }
    }

Bu sabitleri yaratmanın en iyi yoludur.

İlkel ve Dizgiler için:

/** The empty String. */
const val EMPTY_STRING = ""

Diğer durumlar için:

/** The empty array of Strings. */
@JvmField val EMPTY_STRING_ARRAY = arrayOfNulls<String>(0)

Misal:

/*
 * Copyright 2018 Vorlonsoft LLC
 *
 * Licensed under The MIT License (MIT)
 */

package com.vorlonsoft.android.rate

import com.vorlonsoft.android.rate.Constants.Utils.Companion.UTILITY_CLASS_MESSAGE

/**
 * Constants Class - the constants class of the AndroidRate library.
 *
 * @constructor Constants is a utility class and it can't be instantiated.
 * @since       1.1.8
 * @version     1.2.1
 * @author      Alexander Savin
 */
internal class Constants private constructor() {
    /** Constants Class initializer block. */
    init {
        throw UnsupportedOperationException("Constants$UTILITY_CLASS_MESSAGE")
    }

    /**
     * Constants.Date Class - the date constants class of the AndroidRate library.
     *
     * @constructor Constants.Date is a utility class and it can't be instantiated.
     * @since       1.1.8
     * @version     1.2.1
     * @author      Alexander Savin
     */
    internal class Date private constructor() {
        /** Constants.Date Class initializer block. */
        init {
            throw UnsupportedOperationException("Constants.Date$UTILITY_CLASS_MESSAGE")
        }

        /** The singleton contains date constants. */
        companion object {
            /** The time unit representing one year in days. */
            const val YEAR_IN_DAYS = 365.toShort()
        }
    }

    /**
     * Constants.Utils Class - the utils constants class of the AndroidRate library.
     *
     * @constructor Constants.Utils is a utility class and it can't be instantiated.
     * @since       1.1.8
     * @version     1.2.1
     * @author      Alexander Savin
     */
    internal class Utils private constructor() {
        /** Constants.Utils Class initializer block. */
        init {
            throw UnsupportedOperationException("Constants.Utils$UTILITY_CLASS_MESSAGE")
        }

        /** The singleton contains utils constants. */
        companion object {
            /** The empty String. */
            const val EMPTY_STRING = ""
            /** The empty array of Strings. */
            @JvmField val EMPTY_STRING_ARRAY = arrayOfNulls<String>(0)
            /** The part 2 of a utility class unsupported operation exception message. */
            const val UTILITY_CLASS_MESSAGE = " is a utility class and it can't be instantiated!"
        }
    }
}