Partage de tutoriel d'exemple de classe d'annotation Kotlin

Cet article présente principalement l'explication détaillée et les exemples des classes d'annotation de Kotlin. Les amis qui en ont besoin peuvent se référer aux

Explications détaillées de Kotlin et exemples de classes d'annotation

. Déclaration d'annotation

Les annotations sont un moyen d'attacher des métadonnées à votre code. Pour déclarer une annotation, placez le modificateur d'annotation devant la classe :

annotation class Fancy

Des propriétés supplémentaires de l'annotation peuvent être spécifiées en annotant la classe d'annotation avec une méta- annotation :

1. @Target précise les types possibles d'éléments pouvant être annotés avec cette annotation (classe, fonction, attribut, expression,

2. @Retention spécifie si l'annotation est stockée dans le fichier de classe compilé et si elle peut être visible par réflexion au moment de l'exécution (la valeur par défaut est vraie

@Repeatable Permet d'utiliser plusieurs fois la même annotation sur un seul élément
@MustBe
4. Document

   ed précise que l'annotation fait partie de l'API publique ; et doit être inclus dans la signature In générée de la classe ou de la méthode, comme indiqué dans la documentation de l'API.
   

@Target

(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,                   AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
@ Rétention
(AnnotationRetention.SOURCE)@MustBeDocumented

classe d'annotation Fantaisie

Utilisation

Si vous devez annoter le

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

constructeur principal

de la classe, vous devez ajouter le mot-clé constructor dans le constructeur déclaration , et ajoutez l'annotation devant :

Vous pouvez également annoter l'accesseur de propriété :

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

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

Constructeur

L'annotation peut avoir un constructeur qui accepte des paramètres.

Les types de paramètres autorisés sont :

annotation class Special(val why: String)

@Special("example") class Foo {}

Les types correspondant aux types natifs Java (Int, Long etc. .);
2. Chaîne

Énumération

3. Autre; annotations ;

4. Tableau des types répertoriés ci-dessus.

5. Les paramètres d'annotation ne peuvent pas avoir de types nullables car la JVM ne prend pas en charge le stockage de null comme valeur des propriétés d'annotation.
6. Si une annotation est utilisée comme paramètre d'une autre annotation, son nom n'est pas préfixé par le caractère @ :

   
   

Si une classe a besoin à préciser Pour les paramètres annotés, utilisez les classes Kotlin (KClass). Le compilateur Kotlin le convertira automatiquement en classe Java afin que le code Java puisse voir normalement l'annotation et les paramètres.

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"))

Expression Lambda L'annotation

peut également être utilisée pour les expressions lambda. Ils sont appliqués à la méthode Invoke() qui génère le corps de l'expression lambda. Ceci est utile pour les frameworks comme Quasar, qui utilisent des annotations pour le contrôle de concurrence.

import kotlin.reflect.KClass

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

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

Cible d'utilisation de l'annotation

Lors de l'annotation de propriétés ou de
paramètres de fonction

du constructeur principal, il y aura être plusieurs éléments Java générés à partir de l'élément Kotlin correspondant, il existe donc plusieurs emplacements possibles pour cette annotation dans le bytecode Java généré. Si vous souhaitez spécifier exactement comment l'annotation doit être générée, utilisez la syntaxe suivante :

annotation class Suspendable

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

Vous pouvez utiliser la même syntaxe pour annoter l'intégralité du fichier. . Pour cela, placez l'annotation avec fichier cible au niveau supérieur du fichier, avant la directive package ou avant toutes les importations (si le fichier est dans le package par défaut) :

Si vous avez plusieurs annotations pour le même objectif, vous pouvez éviter les objectifs en double en ajoutant des crochets après l'objectif et en plaçant toutes les annotations entre parenthèses :

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

sont :

@file:JvmName("Foo")

package org.jetbrains.demo

fichier

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

propriété (avec annotation pour cette cible invisible pour Java)

1. field

2. get (getter de propriété)

3. set (setter de propriété)

4. receiver (paramètre récepteur de la fonction ou de la propriété d'extension)

5. param (paramètre constructeur)

6. setparam ( paramètre de définition de propriété)

7. delegate (champ pour une propriété de délégué pour stocker son instance de délégué)

8. Pour annoter le paramètre de récepteur de une fonction d'extension, utilisez la syntaxe suivante :

9. 
   

   Si vous ne spécifiez pas de cible, elle est basée sur l'annotation @Target de l'annotation utilisée. votre cible. S'il existe plusieurs cibles applicables, la première cible applicable de la liste suivante est utilisée :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!