Kotlin Academy · Aula

Variância no Local de Uso

Projeções de tipos

Variância no Local de Uso é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Variância no ponto de uso

Às vezes, uma classe genérica é invariante como um todo, mas uma função específica apenas produz ou apenas consome o tipo. A variância no ponto de uso, ou seja, as projeções de tipo, aplica out ou in exatamente no local em que o tipo é usado.

Por que usar variância no ponto de uso

Uma classe invariante como MutableList<T> não pode se tornar covariante na declaração, pois tanto lê quanto grava T. Porém, uma função específica pode apenas ler a lista, e as projeções permitem expressar isso com segurança.

Projeção out

Escrever Array<out T> como tipo de parâmetro produz uma visão covariante: você pode ler T, mas não pode gravá-lo. Isso permite passar um Array<String> onde se espera um Array<out Any>.

fun printArray(items: Array<out Any>) {
    for (item in items) println(item)
}

fun main() {
    val names: Array<String> = arrayOf("Ann", "Bob")
    printArray(names)
}

Somente leitura

Com uma projeção out, o compilador permite leituras, ou saídas, mas proíbe gravações, ou entradas, pois uma gravação poderia violar a segurança de tipos do vetor original.

Projeção in

Escrever Array<in T> produz uma visão contravariante: você pode gravar T nela, mas as leituras retornam como Any?. Isso permite aceitar vetores de T ou de qualquer supertipo.

fun fill(dest: Array<in Int>, value: Int) {
    for (i in dest.indices) dest[i] = value
}

fun main() {
    val numbers: Array<Number> = arrayOf(0, 0, 0)
    fill(numbers, 7)
    println(numbers.toList())
}

Somente gravação

Com uma projeção in, você pode gravar valores de T, ou entradas, mas o tipo do elemento é visto como o tipo mais abrangente nas leituras, pois o tipo real do elemento pode ser qualquer supertipo.

Projeções versus variância no local da declaração

A variância no local da declaração, como em class Box<out T>, aplica-se a todos os lugares em que a classe é usada. As projeções no ponto de uso, como Box<out T> em um parâmetro, aplicam-se somente àquele local. Use projeções quando a própria classe precisar permanecer invariante.

A projeção estrela

Quando você não se importa com o argumento de tipo, use a projeção estrela *. List<*> significa uma lista de algum tipo desconhecido; você pode ler os elementos como o limite superior e não pode escrever nela com segurança.

fun printSize(collection: List<*>) {
    println("Size: ${collection.size}")
}

fun main() {
    printSize(listOf(1, 2, 3))
    printSize(listOf("a", "b"))
}

Limites da projeção estrela

Com *, você ainda pode chamar membros independentes do tipo, como size, e ler os elementos como Any?, mas não pode adicionar elementos porque o tipo real é desconhecido.

fun main() {
    val unknown: List<*> = listOf("x", "y")
    val first: Any? = unknown.first()
    println(first)
}

Escolhendo uma projeção

Use out T quando uma função apenas lê, in T quando ela apenas escreve e * quando o tipo exato não é relevante. Essas projeções mantêm as classes invariantes utilizáveis de maneiras flexíveis e seguras quanto aos tipos.

Relação com os curingas do Java

As projeções out T e in T do Kotlin correspondem aos curingas ? extends T e ? super T do Java. Se você conhece os genéricos do Java, as projeções serão familiares.

Verificação rápida

O que você pode fazer com um parâmetro tipado como Array<out Any>?

Recapitulação

A variância no ponto de uso aplica projeções out (somente leitura) ou in (somente escrita) em um uso específico, e * como uma projeção estrela quando o tipo é desconhecido. Isso torna as classes invariantes flexíveis sem alterar a declaração. Em seguida, você restringirá parâmetros de tipo com restrições genéricas.

Perguntas Frequentes

A aula “Variância no Local de Uso” é grátis?

Sim — o texto completo de “Variância no Local de Uso” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Variância no Local de Uso”?

Projeções de tipos Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Variância no Local de Uso”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy