Extensões com escopo e extensões de companion
Limite a visibilidade das extensões e adicione extensões a companion objects.
Extensões com escopo e extensões de companion é 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.
Por que usar extensões com escopo
Por padrão, as extensões ficam visíveis onde quer que sejam importadas. Restringir o escopo limita a visibilidade a uma classe, arquivo ou contexto — reduzindo a poluição do espaço de nomes e melhorando a localização.
Extensões privadas no arquivo
Marque uma função de extensão como private no nível do arquivo para restringi-la somente a esse arquivo.
private fun String.shout() = uppercase() + "!"
fun main() {
println("hello".shout()) // HELLO!
}Visibilidade interna
Use internal para limitar as extensões ao módulo atual — ideal para elementos internos de uma biblioteca que não se destinam ao uso externo.
internal fun List<Int>.sumIfPositive(): Int = filter { it > 0 }.sum()
fun main() {
println(listOf(-1, 2, 3, -4).sumIfPositive()) // 5
}Funções de extensão-membro
Declare uma extensão dentro de uma classe para torná-la utilizável somente quando uma instância dessa classe estiver no escopo. Ela tem dois receptores: o de despacho (a classe) e o de extensão (o alvo).
class StringHelper(val prefix: String) {
fun String.withPrefix() = prefix + this
fun build(): String = "world".withPrefix() // calls extension via instance
}
fun main() {
println(StringHelper("hello ").build()) // hello world
}Visibilidade das extensões-membro
As extensões-membro não podem ser acessadas de fora da classe de despacho. Isso é útil para encapsulamento.
class Repo {
fun List<Int>.allPositive() = all { it > 0 }
fun check(xs: List<Int>) = xs.allPositive()
}
fun main() {
val r = Repo()
println(r.check(listOf(1, 2, 3))) // true
// listOf(1).allPositive() // ERROR — no access
}Extensão de um objeto companheiro
Adicione uma extensão ao objeto companheiro de uma classe. Para quem a chama, ela se parece com um método estático, mas vive fora da classe.
class Greeter {
companion object
}
fun Greeter.Companion.morning() = "Good morning!"
fun main() {
println(Greeter.morning())
}Por que usar extensões de objetos companheiros
Elas são úteis para adicionar métodos de fábrica ou auxiliares de fora da classe original — sem modificá-la.
class User(val name: String) {
companion object
}
fun User.Companion.guest() = User("Guest")
fun User.Companion.system() = User("System")
fun main() {
println(User.guest().name)
println(User.system().name)
}Objeto companheiro obrigatório
Uma classe precisa declarar um objeto companheiro, mesmo que vazio, para que extensões de objetos companheiros possam ser anexadas. Caso contrário, o alvo da extensão não existe.
class Box {
companion object // required, even if empty
}
fun Box.Companion.create(): Box = Box()
fun main() {
println(Box.create())
}Extensões com escopo por meio de importações
Você pode restringir o uso de uma extensão importando-a somente em arquivos específicos. Os arquivos que não a importarem não poderão acessá-la.
// File A:
// fun String.shout() = uppercase()
// File B imports:
// import com.example.shout
// Only File B can call shout()
fun String.shout() = uppercase() + "!"
fun main() { println("hi".shout()) }Função de extensão por meio de uma função de escopo
Use with ou apply para trazer temporariamente um objeto para o escopo e usá-lo com uma extensão.
class StringTools {
fun String.greet() = "Hello, $this!"
fun process(name: String) = with(this) {
name.greet()
}
}
fun main() {
println(StringTools().process("Ada"))
}Propriedades de extensão em Companion
As extensões de Companion também podem ser propriedades — adicione constantes nomeadas de fora da classe.
class HttpStatus {
companion object
}
val HttpStatus.Companion.OK_CODE: Int get() = 200
val HttpStatus.Companion.NOT_FOUND: Int get() = 404
fun main() {
println(HttpStatus.OK_CODE)
println(HttpStatus.NOT_FOUND)
}Boas práticas
Use private para auxiliares locais ao arquivo, internal para APIs exclusivas do módulo, extensões de membro para encapsulamento e extensões de Companion para adicionar auxiliares semelhantes a fábricas de fora.
class StringUtils {
companion object
}
fun StringUtils.Companion.isAlpha(s: String) = s.all { it.isLetter() }
fun main() {
println(StringUtils.isAlpha("hello"))
println(StringUtils.isAlpha("hi5"))
}Verificação rápida
O que é necessário em uma classe para que seja possível adicionar uma extensão de Companion a ela de fora?
Recapitulação
Defina o escopo das extensões com private, internal ou como extensões de membro dentro de uma classe. Adicione extensões de Companion (funções ou propriedades) de fora vinculando-as ao objeto companion declarado da classe. Isso reduz a poluição do espaço de nomes e mantém o código modular.
Aprenda Kotlin com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Extensões com escopo e extensões de companion” é grátis?
Sim — o texto completo de “Extensões com escopo e extensões de companion” é 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 “Extensões com escopo e extensões de companion”?
Limite a visibilidade das extensões e adicione extensões a companion objects. 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 “Extensões com escopo e extensões de companion”?
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
- Funções de extensão: sintaxe e regras de despacho
- Propriedades de extensão e extensões calculadas
- Extensões com escopo e extensões de companion
- Extensões práticas: auxiliares de Context, View e String