Konstanten in Kotlin - Was ist eine empfohlene Methode, um sie zu erstellen?

Wie wird empfohlen, Konstanten in Kotlin zu erstellen? Und wie lautet die Namenskonvention? Ich habe das nicht in der Dokumentation gefunden.

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

    //2
    const val MY_CONST = "something"

    //3
    val myConst = "something"
}

Oder ...?

Wenn Sie in Kotlin die lokalen Konstanten erstellen möchten, mit denen in der Klasse verwendet werden soll, können Sie sie wie folgt erstellen

val MY_CONSTANT = "Constants"

Und wenn Sie eine öffentliche Konstante in Kotlin wie das öffentliche statische Finale in Java erstellen möchten , können Sie sie wie folgt erstellen.

companion object{

     const val MY_CONSTANT = "Constants"

}

Vermeiden Sie die Verwendung von Begleitobjekten. Hinter der Haube werden Getter- und Setter-Instanzmethoden erstellt, damit auf die Felder zugegriffen werden kann. Das Aufrufen von Instanzmethoden ist technisch teurer als das Aufrufen statischer Methoden.

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

Definieren Sie stattdessen die Konstanten in object.

Empfohlene Praxis :

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

und greifen Sie global wie folgt darauf zu: DbConstants.TABLE_USER_ATTRIBUTE_EMPID

Erstens ist die Namenskonvention in Kotlin für Konstanten dieselbe wie in Java (z. B. MY_CONST_IN_UPPERCASE).

Wie soll ich es erstellen?

1. Als Top-Level-Wert (empfohlen)

Sie müssen nur Ihre Konstante außerhalb Ihrer Klassendeklaration platzieren.

Zwei Möglichkeiten : Deklarieren Sie Ihre Konstante in Ihrer Klassendatei (Ihre Konstante hat eine klare Beziehung zu Ihrer Klasse).

private const val CONST_USED_BY_MY_CLASS = 1

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

Erstellen Sie eine dedizierte constants.kt-Datei, in der diese globalen const gespeichert werden (hier möchten Sie Ihre const in Ihrem Projekt weit verbreitet verwenden):

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

Dann müssen Sie es nur noch dort importieren, wo Sie es benötigen:

import com.project.constants

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

2. Deklarieren Sie es in einem Begleitobjekt (oder einer Objektdeklaration).

Dies ist viel weniger sauber, da unter der Haube beim Generieren von Bytecode ein nutzloses Objekt erstellt wird:

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

Noch schlimmer, wenn Sie es als Wert anstelle einer Konstante deklarieren (der Compiler generiert ein nutzloses Objekt + eine nutzlose Funktion):

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

Hinweis :

In Kotlin kann const nur primitive Typen enthalten. Wenn Sie eine Funktion an sie übergeben möchten, müssen Sie die Annotation @JvmField hinzufügen. Zur Kompilierungszeit wird es als öffentliche statische Endvariable transformiert. Aber es ist langsamer als bei einem primitiven Typ. Versuche es zu vermeiden.

@JvmField val foo = Foo()

Zum Zeitpunkt der Kompilierung bekannte Werte können (und sollten meiner Meinung nach) als konstant markiert werden.

Namenskonventionen sollten Java-Konventionen folgen und bei Verwendung aus Java-Code richtig sichtbar sein (mit Begleitobjekten ist dies jedoch irgendwie schwierig zu erreichen, aber trotzdem).

Die richtigen konstanten Deklarationen sind:

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

Sie benötigen keine Klasse, kein Objekt oder ein Begleitobjekt, um Konstanten in Kotlin zu deklarieren. Sie können einfach eine Datei deklarieren, die alle Konstanten enthält (z. B. Constants.kt, oder Sie können sie auch in eine vorhandene Kotlin-Datei einfügen) und die Konstanten direkt in der Datei deklarieren. Die zur Kompilierungszeit bekannten Konstanten müssen mit markiert sein const.

In diesem Fall sollte es also sein:

const val MY_CONST = "something"

und dann können Sie die Konstante importieren mit:

import package_name.MY_CONST

Sie können auf diesen Link verweisen

Wenn Sie Ihren const val valName = valValuevor den Klassennamen setzen, wird auf diese Weise ein erstellt

public static final YourClass.Ktdas wird die public static finalWerte haben.

Kotlin :

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

Java dekompiliert:

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
}

Sie haben zwei Möglichkeiten: Sie können das constSchlüsselwort oder das Schlüsselwort verwenden @JvmField, wodurch es zur statischen Endkonstante von Java wird.

class Myclass {

     companion object {
           @JvmField val MYCONSTANT = 479
    }

Wenn Sie die @JvmFieldAnnotation verwenden, wird die Konstante nach dem Kompilieren für Sie so eingegeben, wie Sie es in Java nennen würden.
Genau wie Sie es in Java aufrufen würden, ersetzt der Compiler dies für Sie, wenn Sie die Companion-Konstante im Code aufrufen.

Wenn Sie jedoch das Schlüsselwort const verwenden, wird der Wert der Konstante inline. Mit Inline meine ich, dass der tatsächliche Wert nach dem Kompilieren verwendet wird.

Zusammenfassend lässt sich sagen, was der Compiler für Sie tun wird:

//so for @JvmField:

Foo var1 = Constants.FOO;

//and for const:

Foo var1 = 479

Kotlin statische und konstante Wert & Methode deklarieren

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
}

}}

Zugriffswert überall

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

Ebenso valsind mit dem constSchlüsselwort definierte Variablen unveränderlich. Der Unterschied besteht darin, dass conster für Variablen verwendet wird, die zur Kompilierungszeit bekannt sind.

Das Deklarieren einer Variablen constähnelt dem Verwenden des staticSchlüsselworts in Java.

Mal sehen, wie man eine const-Variable in Kotlin deklariert:

const val COMMUNITY_NAME = "wiki"

Und der in Java geschriebene analoge Code wäre:

final static String COMMUNITY_NAME = "wiki";

Hinzufügen zu den obigen Antworten -

@JvmField Dies kann verwendet werden, um den Kotlin-Compiler anzuweisen, keine Getter / Setter für diese Eigenschaft zu generieren und sie als Feld verfügbar zu machen.

 @JvmField
 val COMMUNITY_NAME: "Wiki"

Statische Felder

Kotlin-Eigenschaften, die in einem benannten Objekt oder einem Begleitobjekt deklariert sind, haben statische Hintergrundfelder entweder in diesem benannten Objekt oder in der Klasse, die das Begleitobjekt enthält.

Normalerweise sind diese Felder privat, aber sie können auf eine der folgenden Arten verfügbar gemacht werden:

• @JvmField Anmerkung;
• lateinit Modifikator;
• const Modifikator.

Weitere Details finden Sie hier - https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#instance-fields

Etwas, das in keiner der Antworten erwähnt wird, ist der Aufwand für die Verwendung companion objects. Wie Sie hier lesen können , sind Begleitobjekte tatsächlich Objekte, und das Erstellen dieser Objekte verbraucht Ressourcen. Darüber hinaus müssen Sie möglicherweise jedes Mal, wenn Sie Ihre Konstante verwenden, mehr als eine Getter-Funktion durchlaufen. Wenn Sie nur ein paar primitive Konstanten benötigen, sind Sie wahrscheinlich besser dran val, um eine bessere Leistung zu erzielen und die zu vermeiden companion object.

TL; DR; des Artikels:

Die Verwendung eines Begleitobjekts dreht diesen Code tatsächlich

class MyClass {

    companion object {
        private val TAG = "TAG"
    }

    fun helloWorld() {
        println(TAG)
    }
}

In diesen Code:

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

Also versuche sie zu vermeiden.

lokale Konstanten:

const val NAME = "name"

Globale Konstanten:

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

Zugriff auf MyConstants.NAME

Es gibt einige Möglichkeiten, wie Sie Konstanten in Kotlin definieren können:

Begleitobjekt verwenden

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

Sie können den obigen Begleitobjektblock in jeder Klasse verwenden und alle Ihre Felder in diesem Block selbst definieren. Bei diesem Ansatz gibt es jedoch ein Problem, heißt es in der Dokumentation:

Obwohl die Mitglieder von Begleitobjekten in anderen Sprachen wie statische Elemente aussehen, sind diese zur Laufzeit immer noch Instanzmitglieder von realen Objekten und können beispielsweise Schnittstellen implementieren.

Wenn Sie Ihre Konstanten mit einem Begleitobjekt erstellen und den dekompilierten Bytecode sehen , sehen Sie wie folgt aus:

  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;
     }
  }

Von hier aus können Sie leicht sehen, was in der Dokumentation gesagt wurde, obwohl die Mitglieder von Begleitobjekten in anderen Sprachen wie statische Elemente aussehen. Zur Laufzeit sind dies immer noch Instanzmitglieder von realen Objekten. Es erledigt zusätzliche Arbeit als erforderlich.

Jetzt kommt ein anderer Weg, bei dem wir kein Begleitobjekt wie unten verwenden müssen.

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

Wenn Sie wieder die dekompilierte Version des Bytecodes des obigen Snippets sehen, werden Sie so etwas finden:

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

Wenn Sie nun den oben dekompilierten Code sehen, wird für jede Variable eine get-Methode erstellt. Diese get-Methode ist überhaupt nicht erforderlich.

Um diese get-Methoden loszuwerden , sollten Sie const vor val wie unten verwenden.

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

Wenn Sie nun den dekompilierten Code des obigen Snippets sehen, ist das Lesen einfacher, da der Code am wenigsten im Hintergrund konvertiert wird.

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

    private ApiConstants() {
     }

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

Dies ist also der beste Weg, um Konstanten zu erstellen.

Für Primitive und Strings:

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

Für andere Fälle:

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

Beispiel:

/*
 * 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!"
        }
    }
}