Android Academy · Aula

O que é Jetpack Compose?

Entenda a interface declarativa no Android.

O que é Jetpack Compose? é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 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 Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

O que é o Jetpack Compose?

Jetpack Compose é o kit de ferramentas moderno do Android para criar interfaces nativas. Em vez de escrever arquivos de layout XML, você descreve sua interface diretamente em código Kotlin.

O Compose é declarativo: você informa como a tela deve ser para um determinado estado, e ele decide como desenhá-la e atualizá-la.

O método antigo: visualizações XML

Tradicionalmente, uma tela Android precisava de duas partes:

Um arquivo de layout XML que descrevia os componentes.
Código Kotlin/Java que encontrava essas visualizações com findViewById e as modificava.

Manter o XML e o código sincronizados era trabalhoso e propenso a erros.

<!-- res/layout/activity_main.xml -->
<TextView
    android:id="@+id/greeting"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

Imperativo versus declarativo

Com visualizações XML, você escreve código imperativo: obtém uma visualização e depois a altera passo a passo.

Com o Compose, você escreve código declarativo: descreve o resultado final como uma função dos seus dados. Quando os dados mudam, o Compose redesenha automaticamente o que for necessário.

// Imperative (old views)
val tv = findViewById<TextView>(R.id.greeting)
tv.text = "Hello"
tv.visibility = View.VISIBLE

Funções componíveis

O bloco de construção do Compose é a função componível: uma função Kotlin comum anotada com @Composable que emite a interface.

As funções componíveis podem chamar outras funções componíveis, permitindo criar telas a partir de pequenas partes reutilizáveis.

@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}

Sem findViewById

No Compose, não há findViewById nem IDs de visualização. A interface é a chamada da função. Para mostrar um texto diferente, basta passar um argumento diferente e deixar o Compose recompô-la.

@Composable
fun Screen() {
    Greeting(name = "Ada")
    Greeting(name = "Linus")
}

A interface como função do estado

Uma ideia fundamental: interface = f(estado). A tela é a saída das suas funções componíveis dado o estado atual. Altere o estado, e a mesma função produzirá uma nova interface.

Isso torna as interfaces previsíveis e facilita sua compreensão.

Tudo é Kotlin

Como as funções componíveis são funções Kotlin, você pode usar laços, condicionais e variáveis para criar a interface. Não é necessária nenhuma linguagem especial de modelos.

@Composable
fun Items(names: List<String>) {
    for (n in names) {
        Text(text = n)
    }
}

Menos código repetitivo

O Compose elimina grandes quantidades de código de ligação. Não há inflação de XML, adaptadores para listas simples nem conexão manual entre o layout e a lógica.

O resultado: menos arquivos e menos erros.

Interoperabilidade com visualizações

Você não precisa reescrever um aplicativo inteiro. O Compose interopera com o antigo sistema de visualizações. Você pode incorporar o Compose a uma tela XML existente ou incorporar uma visualização ao Compose.

Isso permite que as equipes migrem gradualmente.

O que você precisa

Para usar o Compose, você precisa de:

Uma versão recente do Android Studio.
As dependências do Compose no seu arquivo do Gradle.
Uma atividade que chame setContent { } para hospedar as funções componíveis.

Uma tela pequena

Aqui está uma tela Compose mínima e completa. setContent é a ponte entre a Activity do Android e o mundo do Compose.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Greeting(name = "World")
        }
    }
}

Verificação rápida

Qual é a melhor descrição do Jetpack Compose?

Recapitulação

Você aprendeu que o Jetpack Compose é um kit de ferramentas de interface declarativo e centrado em Kotlin. Ideias principais:

A interface é criada a partir de funções @Composable.
Não há XML nem findViewById.
interface = f(estado) — altere o estado, e o Compose redesenhará a interface.

Perguntas Frequentes

A aula “O que é Jetpack Compose?” é grátis?

Sim — o texto completo de “O que é Jetpack Compose?” é 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 Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “O que é Jetpack Compose?”?

Entenda a interface declarativa no Android. Você pratica Android 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 Android Academy?

Nenhuma experiência prévia é necessária. Android 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 1 de 4.

Quanto tempo leva a aula “O que é Jetpack Compose?”?

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 Android Academy?

Sim. Cada aula de Android 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 Android Academy