Quel est le mot clé en kotlin

Question

Je ne suis pas capable de comprendre et je n'ai pas trouvé le sens du mot-clé out dans kotlin.

Vous pouvez vérifier exemple ici:

 List<out T>
 

Si quelqu'un peut expliquer le sens de cela. Cela serait très apprécié.

Answer 1

 List<out T> is like List<? extends T> in Java
 

et

 List<in T> is like List<? super T> in Java
 

Par exemple, à Kotlin, vous pouvez faire des choses comme

  val value : List<Any> = listOf(1,2,3)
//since List signature is List<out T> in Kotlin
 

Answer 2

Avec cette signature:

List<out T>

vous pouvez faire ceci:

val doubleList: List<Double> = listOf(1.0, 2.0)
val numberList: List<Number> = doubleList

ce qui signifie T est covariant:

lorsqu'un paramètre de type T d'une classe C est déclaré out, C<Base> peut en toute sécurité être un supertype de C<Dérivés>.

Ceci est en contraste avec dans, par exemple

Comparable<in T>

vous pouvez faire ceci:

fun foo(numberComparable: Comparable<Number>) {
  val doubleComparable: Comparable<Double> = numberComparable
  // ...
}

ce qui signifie T est contravariant:

lorsqu'un paramètre de type T d'une classe C est déclarée dans, C<Dérivés> peut en toute sécurité être un supertype de C<Base>.

Une autre façon de se rappeler:

La consommation dans les, Producteur de hors.

voir Kotlin Génériques de la Variance

-----------------mis à jour le 4 janvier 2019-----------------

Pour le "Consommateur, Producteur", on lit seulement du Producteur - appel de la méthode pour obtenir un résultat de type T; et en écriture uniquement au Consommateur - appel d'une méthode, en passant en paramètre de type T.

Dans l'exemple de List<out T>, il est évident que nous pouvons faire ceci:

val n1: Number = numberList[0]
val n2: Number = doubleList[0]

Donc, il est sûr de fournir des List<Double> lorsque List<Number> est prévu, par conséquent List<Number> est super type d' List<Double>, mais pas vice-versa.

Dans l'exemple de Comparable<in T>:

val double: Double = 1.0
doubleComparable.compareTo(double)
numberComparable.compareTo(double)

Donc, il est sûr de fournir des Comparable<Number> lorsque Comparable<Double> est prévu, par conséquent Comparable<Double> est super type d' Comparable<Number>, mais pas vice-versa.

Answer 3

Reportez-vous à ce manuel de kotlin

Le Kotlin List<out T> type est une interface qui permet l'accès en lecture seulement des opérations telles que la taille, obtenir et ainsi de suite. Comme en Java, il hérite de Collection<T> , ce qui en hérite Iterable<T>. Des méthodes qui modifier la liste sont ajoutés par l' MutableList<T> interface. Cette motif en est de même pour Set<out T>/MutableSet<T> et Map<K, out V>/MutableMap<K, V>

Et ce,

Dans Kotlin, il y a une façon d'expliquer ce genre de chose à l' compilateur. Cela s'appelle de la déclaration de-site de la variance: on peut annoter le paramètre de type T de la Source pour s'assurer qu'il n'est retourné (produit) des membres de l' Source<T>, et de ne jamais consommé. Pour ce faire nous fournissons le modificateur:

> abstract class Source<out T> {
>     abstract fun nextT(): T }
> 
> fun demo(strs: Source<String>) {
>     val objects: Source<Any> = strs // This is OK, since T is an out-parameter
>     // ... }

La règle générale est la suivante: lorsqu'un paramètre de type T d'une classe d' C est déclarée hors, il peut se produire uniquement dans la position dans les membres de la C, mais dans de retour C<Base> peuvent en toute sécurité être un supertype de C<Derived>.

Dans "intelligent mots" ils disent que la classe C est covariant dans le paramètre T, ou que l' T est un covariant paramètre de type. Vous pouvez penser C comme étant un producteur de T, et non PAS un consommateur de Ts'. Le modificateur est appelé une annotation de variance, et depuis il est fourni en paramètre de type de déclaration du site, nous parlons de déclaration-le site de la variance. Ceci est en contraste avec Java utilisation du site la variance où les caractères génériques dans le type d'usages font les types covariants.