Teilen eines Beispiel-Tutorials für die Kotlin-Annotationsklasse

Dieser Artikel stellt hauptsächlich die detaillierten Erklärungen und Beispiele der Annotationsklassen von Kotlin vor. Freunde, die sie benötigen, können auf

Kotlins detaillierte Erklärungen und Beispiele der Annotationsklassen

verweisen Anmerkungsdeklaration

Anmerkungen sind eine Möglichkeit, Metadaten an Ihren Code anzuhängen. Um eine Annotation zu deklarieren, platzieren Sie den Annotation-Modifikator vor der Klasse:

annotation class Fancy

Zusätzliche Eigenschaften der Annotation können angegeben werden, indem Sie die Annotationsklasse mit einem Meta- annotieren. Annotation:

1. @Target gibt die möglichen Arten von Elementen an, die mit dieser Annotation annotiert werden können (Klasse, Funktion, Attribut, Ausdruck usw.); >

2. @Retention gibt an, ob die Anmerkung in der kompilierten Klassendatei gespeichert wird und ob sie durch Reflektion zur Laufzeit sichtbar sein kann (der Standardwert ist true); 🎜>@Repeatable Ermöglicht die mehrfache Verwendung derselben Annotation für ein einzelnes Element.

3. @MustBe

   Document

   ed gibt an, dass die Annotation Teil der öffentlichen API ist und sollte in der generierten Signatur der Klasse oder Methode enthalten sein, wie in der API-Dokumentation gezeigt.

4. 
   @Target

   (AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
                  AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)

@ Aufbewahrung(AnnotationRetention.SOURCE)
@MustBeDocumented

Annotationsklasse Fancy

Verwendung

Wenn Sie den Haupt-

Konstruktor
der Klasse mit Anmerkungen versehen müssen, müssen Sie das Schlüsselwort „constructor“ im Konstruktor hinzufügen Deklaration und fügen Sie davor die Anmerkung hinzu:

@Fancy class Foo {
  @Fancy fun baz(@Fancy foo: Int): Int {
    return (@Fancy 1)
  }
}

Sie können den Eigenschaftsaccessor auch mit Anmerkungen versehen:

class Foo @Inject constructor(dependency: MyDependency) {
  // ……
}

Konstruktor

class Foo {
  var x: MyDependency? = null
    @Inject set
}

Annotation kann einen Konstruktor haben, der Parameter akzeptiert.

Die zulässigen Parametertypen sind:

annotation class Special(val why: String)

@Special("example") class Foo {}

Typen, die nativen Java-Typen entsprechen (Int, Long usw.) .);

1. String

2. Enum; Anmerkungen;

Array der oben aufgeführten Typen.

3. Annotationsparameter können keine nullbaren Typen haben, da die JVM das Speichern von Null als Wert von Annotationseigenschaften nicht unterstützt.
4. Wenn eine Annotation als Parameter einer anderen Annotation verwendet wird, wird ihrem Namen kein @-Zeichen vorangestellt:

5. Wenn eine Klasse dies benötigt Anzugebende Parameter: Verwenden Sie für annotierte Parameter Kotlin-Klassen (KClass). Der Kotlin-Compiler konvertiert es automatisch in eine Java-Klasse, sodass Java-Code die Annotation und Parameter normal sehen kann.

6. 
   

Lambda-Ausdrücke Die

-Annotation kann auch für Lambda-Ausdrücke verwendet werden. Sie werden auf die invoke()-Methode angewendet, die den Lambda-Ausdruckskörper generiert. Dies ist nützlich für Frameworks wie Quasar, die Annotationen zur Parallelitätskontrolle verwenden.

annotation class ReplaceWith(val expression: String)

annotation class Deprecated(
    val message: String,
    val replaceWith: ReplaceWith = ReplaceWith(""))
@Deprecated("This function is deprecated, use === instead", ReplaceWith("this === other"))

Annotationsverwendungsziel

Beim Annotieren von Eigenschaften oder Hauptkonstruktor-

import kotlin.reflect.KClass

annotation class Ann(val arg1: KClass<*>, val arg2: KClass<out Any?>)

@Ann(String::class, Int::class) class MyClass

Funktionsparametern

wird dies der Fall sein Da es sich um mehrere Java-Elemente handelt, die aus dem entsprechenden Kotlin-Element generiert wurden, gibt es mehrere mögliche Positionen für diese Annotation im generierten Java-Bytecode. Wenn Sie genau angeben möchten, wie die Anmerkung generiert werden soll, verwenden Sie die folgende Syntax:

Sie können dieselbe Syntax verwenden, um die gesamte Datei mit Anmerkungen zu versehen . Platzieren Sie dazu die Annotation mit der Zieldatei auf der obersten Ebene der Datei, vor der Paketanweisung oder vor allen Importen (wenn sich die Datei im Standardpaket befindet):

annotation class Suspendable

val f = @Suspendable { Fiber.sleep(10) }

Wenn Sie mehrere Anmerkungen für dasselbe Ziel haben, können Sie doppelte Ziele vermeiden, indem Sie nach dem Ziel eckige Klammern hinzufügen und alle Anmerkungen in die Klammern einfügen:

sind:

class Example(@field:Ann val foo,  // 标注 Java 字段
       @get:Ann val bar,   // 标注 Java getter
       @param:Ann val quux)  // 标注 Java 构造函数参数

Datei

Eigenschaft (mit Anmerkung für dieses Ziel, unsichtbar für Java)

@file:JvmName("Foo")

package org.jetbrains.demo

field

class Example {
   @set:[Inject VisibleForTesting]
   var collaborator: Collaborator
}

get (property getter)

1. set (property setter)

2. receiver (Empfängerparameter der Erweiterungsfunktion oder -eigenschaft)

3. param (Konstruktorparameter)

4. setparam ( Eigenschaftssetter-Parameter)

5. delegate (Feld für eine Delegateneigenschaft zum Speichern ihrer Delegateninstanz)

6. Zum Kommentieren des Empfängerparameters von Als Erweiterungsfunktion verwenden Sie die folgende Syntax:

Wenn Sie kein Ziel angeben, basiert es auf der @Target-Annotation der verwendeten Annotation Ihr Ziel. Wenn mehrere anwendbare Ziele vorhanden sind, wird das erste anwendbare Ziel aus der folgenden Liste verwendet:

8. • param

   • property

   • field

   Java 注解

   Java 注解与 Kotlin 100% 兼容：

   
   

   import org.junit.Test
   import org.junit.Assert.*
   import org.junit.Rule
   import org.junit.rules.*
   
   class Tests {
     // 将 @Rule 注解应用于属性 getter
     @get:Rule val tempFolder = TemporaryFolder()
   
     @Test fun simple() {
       val f = tempFolder.newFile()
       assertEquals(42, getTheAnswer())
     }
   }

   因为 Java 编写的注解没有定义参数顺序，所以不能使用常规函数调用 语法来传递参数。相反，你需要使用命名参数语法。

   
   

   // Java
   public @interface Ann {
     int intValue();
     String stringValue();
   }
   // Kotlin
   @Ann(intValue = 1, stringValue = "abc") class C

   就像在 Java 中一样，一个特殊的情况是 value 参数；它的值无需显式名称指定。

   
   

   // Java
   public @interface AnnWithValue {
     String value();
   }
   // Kotlin
   @AnnWithValue("abc") class C

   如果 Java 中的 value 参数具有数组类型，它会成为 Kotlin 中的一个 vararg 参数：

   
   

   // Java
   public @interface AnnWithArrayValue {
     String[] value();
   }
   // Kotlin
   @AnnWithArrayValue("abc", "foo", "bar") class C

   对于具有数组类型的其他参数，你需要显式使用 arrayOf：

   
   

   // Java
   public @interface AnnWithArrayMethod {
     String[] names();
   }
   // Kotlin
   @AnnWithArrayMethod(names = arrayOf("abc", "foo", "bar")) class C

   注解实例的值会作为属性暴露给 Kotlin 代码。

   
   

   // Java
   public @interface Ann {
     int value();
   }
   // Kotlin
   fun foo(ann: Ann) {
     val i = ann.value
   }

Das obige ist der detaillierte Inhalt vonTeilen eines Beispiel-Tutorials für die Kotlin-Annotationsklasse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!