0Pricing
Kotlin Academy · Aula

companion object: membros semelhantes a estáticos no Kotlin

Adicione companion objects a classes para simular métodos estáticos e constantes.

companion object: membros semelhantes a estáticos no Kotlin é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 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.

Sem static, mas com companion object

O Kotlin não tem a palavra-chave static. Em vez disso, um companion object declarado dentro de uma classe fornece membros de nível de classe (semelhantes a membros estáticos).

Declarando um companion object

Coloque um companion object dentro de uma classe. Seus membros podem ser chamados como ClassName.member.

class MathUtils {
    companion object {
        fun square(x: Int) = x * x
    }
}
fun main() {
    println(MathUtils.square(5)) // 25
}

Constantes em um companion object

As constantes normalmente ficam no companion object, geralmente com const val para literais em tempo de compilação.

class HttpClient {
    companion object {
        const val DEFAULT_TIMEOUT = 5000
        const val USER_AGENT = "MyApp/1.0"
    }
}
fun main() {
    println(HttpClient.DEFAULT_TIMEOUT)
    println(HttpClient.USER_AGENT)
}

Companion object nomeado

Você pode nomear o companion object. Tanto ClassName.member quanto ClassName.CompanionName.member funcionam.

class Database {
    companion object Factory {
        fun create() = Database()
    }
}
fun main() {
    val db1 = Database.create()       // works
    val db2 = Database.Factory.create() // also works
    println("$db1 / $db2")
}

Padrão de método de fábrica

Use o objeto companheiro para criar instâncias com validação ou lógica de construção alternativa.

class User private constructor(val name: String, val email: String) {
    companion object {
        fun create(name: String, email: String): User {
            require(email.contains("@")) { "invalid email" }
            return User(name, email)
        }
    }
}
fun main() {
    val u = User.create("Ada", "ada@example.com")
    println("${u.name} <${u.email}>")
}

Implementação de interfaces

O próprio objeto companheiro pode implementar interfaces — isso é útil para combiná-lo com classes que precisam de um contrato semelhante a um estático.

interface Loadable<T> { fun load(): T }
class Config(val data: String) {
    companion object : Loadable<Config> {
        override fun load() = Config("loaded data")
    }
}
fun main() {
    println(Config.load().data)
}

@JvmStatic para interoperabilidade com Java

Anote os membros do objeto companheiro com @JvmStatic para expô-los como métodos estáticos verdadeiros para chamadores Java.

class Util {
    companion object {
        @JvmStatic
        fun greet(name: String) = "Hello, $name!"
    }
}
fun main() {
    println(Util.greet("Kotlin"))
    // In Java: Util.greet("Java")
}

Acessando o próprio objeto companheiro

ClassName.Companion referencia diretamente o objeto companheiro. Use-o ao passá-lo como argumento.

class Counter {
    companion object {
        fun greet() = "hi from companion"
    }
}
fun main() {
    val ref = Counter.Companion
    println(ref.greet())
}

Objeto companheiro versus nível superior

Para funções utilitárias que não pertencem a uma classe, prefira funções de nível superior a uma classe que contenha apenas um objeto companheiro.

// File-level — usually cleaner:
fun greet(name: String) = "Hi, $name!"
// Versus:
class Greeter { companion object { fun greet(n: String) = "Hi, $n!" } }
fun main() {
    println(greet("Ada"))
    println(Greeter.greet("Ada"))
}

Um objeto companheiro por classe

Uma classe pode ter no máximo um objeto companheiro. Objetos internos comuns podem armazenar estado compartilhado adicional, se necessário.

class Service {
    companion object {
        val version = "1.0"
    }
    object InternalHelper { fun log() = println("internal") }
}
fun main() {
    println(Service.version)
    Service.InternalHelper.log()
}

Funções de extensão do objeto companheiro

Você pode estender o objeto companheiro de fora da classe, adicionando auxiliares que simulam funções estáticas.

class Lib {
    companion object
}
fun Lib.Companion.helper() = "added later"
fun main() {
    println(Lib.helper())
}

Verificação rápida

Qual é o equivalente em Kotlin aos membros static do Java?

Recapitulação

O Kotlin não tem static. Use um objeto companheiro para membros no nível da classe — constantes, fábricas e implementações de interfaces. Anote com @JvmStatic para interoperabilidade com Java ou estenda com funções de extensão para obter auxiliares que simulam funções estáticas.

Perguntas Frequentes

A aula “companion object: membros semelhantes a estáticos no Kotlin” é grátis?

Sim — o texto completo de “companion object: membros semelhantes a estáticos no Kotlin” é 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 “companion object: membros semelhantes a estáticos no Kotlin”?

Adicione companion objects a classes para simular métodos estáticos e constantes. 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 2 de 4.

Quanto tempo leva a aula “companion object: membros semelhantes a estáticos no Kotlin”?

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

  1. Declaração object: singletons do Kotlin
  2. companion object: membros semelhantes a estáticos no Kotlin
  3. Objetos anônimos e expressões de objeto
  4. Métodos de fábrica com companion object
← Voltar para Kotlin Academy