Método Descrição Quando é Chamado?
É o ponto de partida. Chamado apenas 1
vez quando a tela é criada. É o local ideal
para toda a configuração inicial que não
muda:
1. Definir o layout (com
onCreate()
setContentView()). Quando a Activity é
criada pela primeira vez.
2. Inicializar variáveis.
3. Vincular componentes (com
findViewById()).
Logo após o onCreate()
A Activity está prestes a se tornar visível
ou quando o usuário volta
onStart() para o usuário, mas ele ainda não pode
para a tela depois dela
interagir com ela.
estar em onStop().
Logo após o onStart()
A Activity agora está visível, em primeiro
onResume() plano, e o usuário pode interagir com ela. É
ou quando o app volta a
ter foco (depois de uma
o estado "ativo" do seu app.
ligação, por exemplo).
A Activity perdeu o foco, mas ainda pode
Quando outra Activity
estar parcialmente visível (ex: uma caixa de
fica parcialmente na frente
onPause() diálogo de permissão aparece). É aqui que
ou o usuário recebe uma
você deve pausar animações e salvar dados
notificação.
críticos que não podem ser perdidos.
A Activity não está mais visível para o
Quando a Activity fica
onStop() usuário. Ela foi para segundo plano (ex:
completamente invisível.
usuário apertou "home" ou abriu outro app).
Quando o usuário navega
Chamado quando uma Activity que estava
onRestart() parada (onStop()) está prestes a ser iniciada
de volta para a sua
Activity depois de ela ter
novamente.
sido parada.
Quando a Activity é
É o "último suspiro" da sua Activity.
finalizada (pelo usuário
Chamado pouco antes de ela ser destruída.
onDestroy() apertando "voltar" ou pelo
Aqui você deve liberar todos os recursos
sistema precisando de
pesados (como conexões de rede ou banco).
memória).
Possíveis Perguntas de Prova:
Pergunta: Em qual método do ciclo de vida você deve definir o layout da sua
tela (setContentView) e por quê?
o Resposta: No onCreate(), porque é o método de inicialização
executado apenas uma vez. É o local perfeito para configurações que
não mudam.
Parte 1: O Componente Fundamental - A Activity e seu Ciclo de Vida
Tudo no Android começa com a Activity. Ela é a base para qualquer tela.
Conceito de Activity: É um componente que representa uma (1) única tela
com a qual o usuário pode interagir (ex: tela de login, tela de detalhes, etc.).
Conceito de Ciclo de Vida (Lifecycle): O sistema Android gerencia o estado da
sua Activity (se ela está visível, em foco, destruída). O ciclo de vida são os
métodos que o sistema chama automaticamente durante essas mudanças. Você
precisa saber o que fazer em cada um deles.
Perguntas-Chave da Prova:
Qual a principal diferença entre onPause() e onStop()?
o Em onPause(), a tela ainda pode estar parcialmente visível (só
perdeu o foco). Em onStop(), ela está completamente invisível.
O que acontece ao girar a tela?
o Por padrão, o Android destrói a Activity (chama onDestroy())
e a recria do zero (chama onCreate() de novo).
Parte 2: Estrutura de Projeto (Onde Cada Coisa Fica)
Antes de codificar, você precisa saber onde colocar seus arquivos. Uma boa organização
é fundamental.
manifests
o [Link]: O "RG" do app. Declara todas as suas
Activities, solicita permissões (como internet) e define qual Activity
é a tela principal.
java
o [Link]: Onde fica todo o seu código Java (o Back-End). Suas
classes Activity, suas classes DAO, seus modelos (ex: [Link]).
res (Recursos - O Front-End)
o res/drawable: Imagens e Ícones (ex: [Link]).
o res/layout: Arquivos XML que definem a aparência das suas telas
(ex: activity_main.xml).
o res/mipmap: O ícone do seu aplicativo (o que aparece na tela inicial do
celular).
o res/values: "Gaveta" de valores estáticos.
[Link]: Onde TODOS os textos do seu app devem ficar.
Isso facilita a tradução e manutenção. Nunca escreva texto direto
no XML (ex: android:text="Login" está errado). O certo é
android:text="@string/texto_login".
[Link]: Onde você define as cores do seu app (ex:
azul_primario).
[Link] (ou [Link]): Define a aparência geral (tema)
do app.
Parte 3: Desenvolvimento - A Vinculação Front (XML) ao Back (Java)
Este é o processo prático central: como fazer um botão no XML executar uma ação no
Java.
Fase 1: O Front-End (XML)
Onde: res/layout/activity_main.xml
O que fazer: Você "desenha" sua tela adicionando componentes (Views).
O Passo Crítico: Dar um ID único para cada componente que você precisa
controlar.
XML
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout ...>
<EditText
android:id="@+id/et_nome"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Digite seu nome" />
<Button
android:id="@+id/btn_enviar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Enviar" />
</LinearLayout>
O + em @+id/: Significa "CRIE um novo ID com este nome".
Fase 2: O Back-End (Java)
Onde: java/[Link]/[Link]
O que fazer: Carregar o XML, encontrar os componentes e adicionar lógica.
Java
package [Link];
// 1. Importar as classes dos componentes que você vai usar
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class MainActivity extends AppCompatActivity {
// 2. Declarar as variáveis (vazias) para "segurar" os componentes
private EditText etNome;
private Button btnEnviar;
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
// 3. Carregar o XML (A "planta baixa")
// Esta linha DESENHA a tela. Deve ser a primeira coisa no
onCreate.
setContentView([Link].activity_main);
// 4. A VINCULAÇÃO: Conectar as variáveis Java aos IDs do XML
// Usa o "[Link]", o arquivo gerado automaticamente que mapeia
os IDs
etNome = findViewById([Link].et_nome);
btnEnviar = findViewById([Link].btn_enviar);
// 5. Adicionar Lógica (Comportamento)
// "Adicione um ouvidor de clique no meu botão"
[Link](new [Link]() {
@Override
public void onClick(View v) {
// Este código executa QUANDO o botão é clicado
// a. Pegar o texto da variável 'etNome'
String nomeDigitado = [Link]().toString();
// b. Fazer algo com o texto
[Link]([Link], "Olá, " +
nomeDigitado, Toast.LENGTH_SHORT).show();
}
});
}
}
Parte 4: Responsividade (Fazendo o XML se Adaptar)
Responsividade é garantir que seu layout (XML) fique bom em telas de tamanhos e
formatos diferentes.
Unidades de Medida:
o dp (Density-independent Pixels): Use para TUDO que for tamanho e
espaçamento (largura, altura, margem, padding). 16dp terá um tamanho
físico parecido em qualquer tela. NUNCA use px!
o sp (Scale-independent Pixels): Use APENAS para tamanho de texto
(android:textSize). Ele respeita o dp e também a configuração de
"Tamanho da Fonte" do usuário (acessibilidade).
Tamanhos de Layout (layout_width / layout_height):
o match_parent: O componente se expande para ocupar todo o espaço do
contêiner pai.
o wrap_content: O componente se encolhe para ocupar apenas o espaço
que seu conteúdo precisa (um botão com texto "OK" será menor que um
com "Confirmar Envio").
o Evite valores fixos: Usar android:layout_width="300dp" é perigoso,
pois pode ser maior que a tela de um celular pequeno.
Layouts (ViewGroups) para Organizar:
o LinearLayout: O mais simples. Empilha componentes na vertical
(orientation="vertical") ou horizontal. É rígido.
o ConstraintLayout: O mais moderno e recomendado. Você cria
"amarras" (constraints) para "prender" os componentes uns aos outros ou
às bordas da tela. É o mais flexível e poderoso para criar layouts
complexos e responsivos.
Parte 5: Gerenciamento de Dados - DAO e CRUD
Seu app quase sempre precisará salvar dados (login, posts, etc.). É aqui que entram o
DAO e o CRUD.
Seção A: O Conceito de DAO (Data Access Object)
O DAO não é uma classe pronta do Android. É um padrão de design, uma forma de
organizar seu código.
A Analogia do Restaurante:
A Activity (Sua Tela): É o Cliente. Ele quer dados ("Eu quero a lista de
usuários"), mas não sabe (e não deve saber) como o banco de dados funciona.
O Banco de Dados (SQLite/Room): É a Cozinha. É complexa e só entende
comandos SQL (SELECT * FROM ...).
O DAO (A Classe que Você Cria): É o Garçom. Ele é o intermediário que
traduz o pedido simples do Cliente (buscarTodosUsuarios()) para o comando
complexo da Cozinha (SELECT * FROM ...).
Benefícios:
1. Separação: Sua Activity cuida da tela, seu DAO cuida dos dados.
2. Abstração: Sua Activity não sabe SQL. Toda a complexidade fica escondida
no DAO.
3. Manutenção: Se você mudar o banco de dados (da Cozinha), sua Activity (o
Cliente) nem percebe. Você só precisa treinar um novo "Garçom" (mudar o
código do DAO).
Hoje em Dia (Biblioteca Room):
O Google recomenda usar a biblioteca Room, que gera o DAO para você. Você apenas
define uma interface com anotações:
Java
@Dao // Diz ao Room que esta é uma interface DAO
public interface UsuarioDao {
@Insert // Room cria o código de inserção
void salvarUsuario(Usuario usuario);
@Query("SELECT * FROM tabela_usuarios") // Você escreve o SQL
List<Usuario> buscarTodos();
@Query("SELECT * FROM tabela_usuarios WHERE id = :idUsuario")
Usuario buscarPeloId(int idUsuario);
@Update // Room cria o código de atualização
void atualizarUsuario(Usuario usuario);
@Delete // Room cria o código de deleção
void deletarUsuario(Usuario usuario);
}
Seção B: As Operações CRUD
CRUD é o acrônimo para as 4 operações básicas de dados que seu DAO vai realizar.
C - Create (Criar)
o Fluxo: Usuário preenche EditTexts e clica em "Salvar".
o Ação Java: onClick -> Pega os textos -> Cria um objeto (new
Usuario()) -> Chama o DAO:
[Link](novoUsuario);
R - Read (Ler)
o Fluxo (Ler Todos): Usuário abre a tela de lista.
o Ação Java: onCreate -> Chama o DAO: List<Usuario> lista =
[Link](); -> Usa essa lista para preencher um
RecyclerView (o componente visual para listas).
o Fluxo (Ler Um): Usuário clica em um item da lista.
o Ação Java: Pega o ID do item -> Chama o DAO: Usuario u =
[Link](id); -> Usa o objeto u para preencher os
EditTexts da tela de detalhes.
U - Update (Atualizar)
o Fluxo: Usuário está na tela de detalhes (que já fez um "Read"), altera um
EditText e clica em "Atualizar".
o Ação Java: onClick -> Pega os novos textos e atualiza o objeto u ->
Chama o DAO: [Link](u);
D - Delete (Deletar)
o Fluxo: Usuário está na tela de detalhes e clica em "Excluir".
o Ação Java: onClick -> Pega o objeto u que está sendo exibido ->
Chama o DAO: [Link](u);
Parte 6: Outros Conceitos Importantes
Intent (Intenção):
o Conceito: Uma "mensagem" usada para navegar entre Activities ou
solicitar ações.
o Explícita: Para navegar dentro do seu app (ex: new Intent(this,
[Link]);).
o Implícita: Para pedir uma ação fora do seu app (ex: "Abrir o navegador
com este link").
Context:
o Conceito: Representa o "estado atual" do aplicativo. É o "controle
remoto" que permite acessar recursos (como [Link]), iniciar
Activities, mostrar Toasts, etc.
o Exemplos: this (dentro de uma Activity) ou [Link].
Este guia cobre tudo, desde o conceito mais básico de uma tela (Activity) até como ela
se adapta (Responsividade) e gerencia dados (DAO e CRUD). Boa sorte na prova!
Resumo para Estudo Rápido
Teoria: Memorize a sequência do ciclo de vida: onCreate -> onStart ->
onResume (ativo) -> onPause -> onStop (em segundo plano) -> onDestroy
(destruído).
Prática (Fluxo):
1. XML: Crie a interface em res/layout/. Dê um android:id para cada
View interativa.
2. Java (onCreate):
Use setContentView([Link].nome_do_xml) para carregar o
layout.
Declare variáveis para as Views (ex: private Button
meuBotao;).
Associe as variáveis às Views com meuBotao =
findViewById([Link].id_do_botao);.
Para ações, use [Link](...) para
definir o que acontece no clique.