FIC - Programador de dispositivos móveis_2

Prévia do material em texto

Programador de 
dispositivos móveis 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Catalogação e Normalização 
Hugo Cavalcanti (Crb-4 2129) 
 
Diagramação 
Jailson Miranda 
 
Coordenação Executiva 
George Bento Catunda 
Renata Marques de Otero 
Manoel Vanderley dos Santos Neto 
 
Coordenação Geral 
Maria de Araújo Medeiros Souza 
Maria de Lourdes Cordeiro Marques 
 
Secretaria Executiva de 
Educação Integral e Profissional 
 
Escola Técnica Estadual 
Professor Antônio Carlos Gomes da Costa 
 
Gerência de Educação a distância 
 
Julho, 2020 
Professor(es) Autor(es) 
Rebecca Cristina Linhares de Carvalho 
Danilo de Sousa Barbosa 
 
Revisão 
Rebecca Cristina Linhares de Carvalho 
Danilo de Sousa Barbosa 
 
Coordenação de Curso 
José Américo Teixeira de Barros 
 
Coordenação Design Educacional 
Deisiane Gomes Bazante 
 
Design Educacional 
Ana Cristina do Amaral e Silva Jaeger 
Helisangela Maria Andrade Ferreira 
Izabela Pereira Cavalcanti 
Jailson Miranda 
Roberto de Freitas Morais Sobrinho 
 
Descrição de imagens 
Sunnye Rose Carlos Gomes 
 
 
 
 
 
 
 
 
 
 
 
 
Sumário 
Introdução .............................................................................................................................................. 7 
1. Competência 01 | Introduzir os conceitos básicos de um sistema operacional móvel, configurar e 
conhecer o ambiente de desenvolvimento ........................................................................................... 8 
1.1 O que é o Android ....................................................................................................................................... 8 
1.1.1 Sistema operacional Linux ....................................................................................................................... 9 
1.1.2 Código aberto e livre .............................................................................................................................. 10 
1.2 Arquitetura da plataforma ........................................................................................................................ 11 
1.3 Os diversos sabores do Android ............................................................................................................... 15 
1.4 Google Play ............................................................................................................................................... 19 
1.5 O ambiente de desenvolvimento ............................................................................................................. 19 
1.5.1 Instalação do JDK ................................................................................................................................... 20 
1.5.2 Instalação e configuração do Android Studio ........................................................................................ 24 
1.6 Configuração do AVD no Android Studio.................................................................................................. 33 
2. Competência 02 | Formatar uma Activity para o Desenvolvimento, Utilizando Operadores 
Matemáticos......................................................................................................................................... 39 
2.1 Conceitos Básicos ...................................................................................................................................... 39 
2.1.1 Iniciando um novo projeto com Android Studio ................................................................................... 39 
2.1.2 Estrutura de um projeto Android .......................................................................................................... 44 
2.1.2.1 Arquivo AndroidManifest.xml ............................................................................................................ 45 
2.1.2.2 Classe MainActivity ............................................................................................................................. 46 
2.1.2.3 Arquivo de Layout activity_main.xml ................................................................................................. 48 
2.1.3 Processo de compilação e execução de um projeto Android ............................................................... 50 
2.2 Variáveis .................................................................................................................................................... 52 
2.3 Tipo de dados ............................................................................................................................................ 54 
2.3.1 Tipo de dado primitivo ........................................................................................................................... 54 
 
 
2.3.2 Tipo de dado lógico ................................................................................................................................ 55 
2.3.3 Tipo de dado numérico Inteiros............................................................................................................. 55 
2.3.4 Tipo de dado numérico de ponto flutuante .......................................................................................... 57 
2.3.5 Tipo de dado de caractere ..................................................................................................................... 58 
2.3.6 Tipo de dado complexo: String .............................................................................................................. 59 
2.4 Separadores .............................................................................................................................................. 61 
2.5 Operadores ............................................................................................................................................... 61 
2.5.1 Operadores Aritméticos......................................................................................................................... 62 
2.5.1.1 Incremento e decremento .................................................................................................................. 63 
2.5.2 Operadores Relacionais e Lógicos ......................................................................................................... 66 
2.5.3 Operadores de atribuição ...................................................................................................................... 67 
2.5.3.1 Operadores de atribuições abreviadas ............................................................................................... 68 
3. Competência 03 | Formatar uma Activity para o desenvolvimento de instruções de controle de 
programa .............................................................................................................................................. 70 
3.1 Estruturas de controle condicional ........................................................................................................... 70 
3.1.1 Estrutura if ............................................................................................................................................. 70 
3.1.1.1 Estrutura if-else................................................................................................................................... 71 
3.1.1.2 Estrutura if-else aninhada ................................................................................................................... 73 
3.1.2 Estrutura Switch ..................................................................................................................................... 75 
3.2 Estruturas de repetição ............................................................................................................................ 78 
3.2.1 Estrutura For ..........................................................................................................................................78 
3.2.2 Estrutura While ...................................................................................................................................... 79 
3.2.3 Estrutura Do-While ................................................................................................................................ 81 
4.Competência 04 | Formatar uma Activity para utilização de Arrays ................................................ 84 
4.1 Arrays ........................................................................................................................................................ 84 
4.1.1 Arrays Unidimensionais ......................................................................................................................... 85 
 
 
4.1.2 Arrays Multidimensionais ...................................................................................................................... 87 
4.1.2.1 Arrays Bidimensionais ......................................................................................................................... 87 
5. Competência 05 | Conhecer o Activity em detalhes ....................................................................... 90 
5.1 Criando um novo projeto com Activity ..................................................................................................... 90 
5.2 Conceito de Activity .................................................................................................................................. 92 
5.3 Ciclo de vida de uma Activity .................................................................................................................... 94 
5.4 Navegabilidade entre Activity ................................................................................................................. 101 
5.5 Navegabilidade Simples de uma Activity para outra .............................................................................. 102 
5.6 Navegação entre telas com passagem de parâmetros........................................................................... 106 
6. Competência 06 | Manipular Action bar e temas .......................................................................... 111 
6.1 Criando um novo projeto com Action Bar .............................................................................................. 111 
6.2 Conceito de Action Bar ........................................................................................................................... 115 
6.3 Conceito de temas .................................................................................................................................. 116 
6.4 Customização de Action Bar com botão ................................................................................................. 117 
6.5 Modificando Action Bar com temas ....................................................................................................... 120 
7.Competência 07 | Conhecer os conceitos de interface gráfica - gerenciadores de layout ............ 124 
7.1 Criando um novo projeto com a classe ViewGroup ............................................................................... 124 
7.2 Conceito da classe View .......................................................................................................................... 125 
7.3 Conceito da classe ViewGroup ............................................................................................................... 126 
7.3.1 LinearLayout ........................................................................................................................................ 130 
7.3.2 ConstraintLayout.................................................................................................................................. 136 
7.3.3 RelativeLayout ..................................................................................................................................... 142 
7.4 Dimensões dos componentes do layout ................................................................................................ 145 
8. Competência 08 | Conhecer os conceitos de interface gráfica – view .......................................... 148 
8.1 Criando um novo projeto com a classe Widget ...................................................................................... 148 
8.2 Conceito da classe Widget ...................................................................................................................... 149 
 
 
8.2.1 TextView .............................................................................................................................................. 151 
8.2.2 EditText ................................................................................................................................................ 154 
8.2.3 Imageview ............................................................................................................................................ 161 
9. Competência 09 | Utilizar recursos avançados de view ................................................................ 166 
9.1 Avanços da Widget ................................................................................................................................. 166 
9.1.1 Button .................................................................................................................................................. 166 
9.1.2 ImageButton ........................................................................................................................................ 169 
9.1.3 CheckBox .............................................................................................................................................. 171 
9.1.4 RadioButton ......................................................................................................................................... 174 
9.1.5 Spinner ................................................................................................................................................. 177 
10. Competência 10 | Planejar e executar o compartilhamento do APK .......................................... 182 
10.1 Versionamento da aplicação ................................................................................................................ 182 
10.2 Compatibilidade para instalação .......................................................................................................... 184 
10.3 Assinatura da aplicação com certificado digital ................................................................................... 186 
10.4 Assinatura da aplicação para publicá-la no Google Play ...................................................................... 189 
10.5 Publicando a sua aplicação no Google Play .......................................................................................... 191 
Conclusão ........................................................................................................................................... 195 
Referências ......................................................................................................................................... 196 
Minicurrículo do Professor ................................................................................................................. 197 
 
 
 
 
 
 
7 
Introdução 
Olá, desenvolvedor em formação! Estamos iniciando nossa jornada no curso 
“Programador para Dispositivos Móveis”. O objetivo geral deste curso é por meio de uma linguagem 
simples, descomplicada e com aplicações práticas facilitar seu caminho para uma melhor 
compreensão das noções iniciais e essenciais do desenvolvimento de aplicativos para a plataforma 
Android. 
Para tal, no primeiro momento deste e-book, você conhecerá algumas das principais 
ferramentas necessárias para o desenvolvimento de aplicações emAndroid no ambiente operacional, 
aprenderá os pormenores de suas instalações, bem como suas configurações corretas. Também 
aprenderá a identificar e a trabalhar com termos tais quais variáveis, os tipos de dados e os 
operadores, as estruturas de controle condicional, as estruturas de repetição e o tipo de dado arrays. 
Já no segundo momento deste e-book, você aprenderá sobre as classes de interface 
gráfica mais importantes e utilizadas no desenvolvimento de aplicativos em Android: será mostrado 
o conceito da classe Activity; será visto como manipular Action bar e temas; e será abordado os 
conceitos de interface gráfica dos layouts ConstraintLayout, linearLayout e RelativeLayout. Em 
seguida, vamos aprofundar sobre o conceito de interface gráfica utilizando classe view. Por fim, será 
mostrado como planejar e executar o compartilhamento de aplicação do Android no Google Play. 
Esperamos que o conteúdo aqui discutido lhe sirva como uma primordial ferramenta em 
sua busca por um amplo universo de conhecimentos, e que você alce um voo muito além deste curso. 
Cordialmente, Rebecca Linhares e Danilo de Sousa. 
 
 
8 
1. Competência 01 | Introduzir os conceitos básicos de um sistema 
operacional móvel, configurar e conhecer o ambiente de desenvolvimento 
Caro estudante, a primeira competência tem o objetivo de apresentá-lo ao sistema 
operacional Android e ao ambiente de desenvolvimento de aplicações Android. Na primeira parte 
desta competência, você irá aprender os conceitos básicos do Android e sua arquitetura. Em seguida, 
você acompanhará a evolução das “doces” versões do Android. Na segunda parte desta competência, 
você irá conhecer os componentes necessários para o ambiente de desenvolvimento de aplicações 
Android: o Java Development Kit (JDK) e o Android Studio. Por fim, você irá aprender como instalar e 
configurar estes componentes. 
Vamos Iniciar! 
 
1.1 O que é o Android 
O Android (Figura1.1) é o sistema operacional móvel da Google completamente livre e de 
código aberto, e líder mundial nesse segmento. Na conferência anual da Google, Google I/O 2017, foi 
anunciado que já existem mais de dois bilhões de dispositivos Androids ativados no mundo. 
 
Figura 1.1 - Marca do sistema operacional Android. 
Fonte: veja.abril.com. 
Descrição da imagem: robô na cor verde. 
 
 
 
9 
Atualmente, o Android está disponível para diversas plataformas, como smartphones e 
tablets, TV, relógios, carros, e é o sistema operacional móvel mais utilizado no mundo. 
 
1.1.1 Sistema operacional Linux 
O sistema operacional do Android é baseado no Kernel do Linux, que é responsável por 
gerenciar a memória, os processos, as threads, a segurança dos arquivos e das pastas, redes e drivers, 
além da energia. 
Cada aplicativo no Android dispara um novo processo no sistema operacional. Diversos 
processos e aplicativos podem ser executados simultaneamente, e o kernel do sistema operacional é 
o responsável por realizar todo o controle de memória. Por exemplo, caso seja necessário, o próprio 
sistema operacional pode decidir encerrar algum processo para liberar memória e recursos. E quando 
a situação estiver controlada, talvez o mesmo processo seja reiniciado. 
 
 
 
Veja os principais anúncios da gigante Google na conferência Google I/O 2019: 
https://canaltech.com.br/google-io/google-io-2019-os-principais-anuncios-da-
gigante-para-este-ano-138705/ 
 
Linux é um Sistema Operacional, assim como o Windows e o Mac OS, que 
possibilita a execução de programas em um computador e outros dispositivos, e 
pode ser livremente modificado e distribuído. Mas, em uma definição mais 
profunda e técnica, Linux é o nome dado apenas ao núcleo do sistema 
operacional, chamado de Kernel. 
 
Kernel é um conjunto de instruções que controla como será usado o 
processador, a memória, o disco e dispositivos periféricos. É o software presente 
em todo sistema operacional que dita como o computador deve funcionar. Saiba 
mais sobre o Linux e o Kernel: 
https://www.4linux.com.br/o-que-e-linux 
https://www.vivaolinux.com.br/artigo/Como-explicar-o-que-e-kernel-para-um-
leigo/ 
 
https://canaltech.com.br/google-io/google-io-2019-os-principais-anuncios-da-gigante-para-este-ano-138705/
https://canaltech.com.br/google-io/google-io-2019-os-principais-anuncios-da-gigante-para-este-ano-138705/
https://www.4linux.com.br/o-que-e-linux
https://www.vivaolinux.com.br/artigo/Como-explicar-o-que-e-kernel-para-um-leigo/
https://www.vivaolinux.com.br/artigo/Como-explicar-o-que-e-kernel-para-um-leigo/
 
 
10 
 
1.1.2 Código aberto e livre 
Em 21 de outubro de 2008 o android se transformou em Open Source (Figura 1.2), com 
seu código publicado como AOSP (Android Open Source Project). Se tornado a primeira plataforma 
para aplicativo móveis completamente livre e de código aberto (open source), o que representou 
uma grande vantagem competitiva para a sua evolução, uma vez que diversas empresas e 
desenvolvedores do mundo podem contribuir para melhorar a plataforma. 
 
Figura 1.2 – Marca da iniciativa Adroid Open Source Project (AOSP). 
Fonte: mobilenet.cz. 
Descrição da imagem: robô na cor verde e ao seu entorno há diversos outros tipos de robôs, nos mais variados 
tamanhos e cores. 
 
Para os fabricantes de celulares, isso também é uma grande vantagem, uma vez que é 
possível utilizar o sistema operacional do Android em seus celulares sem ter de pagar por isso. 
Toda a segurança do sistema operacional Android é baseada na segurança do sistema 
Linux. Isto significa que, o Android é um sistema Linux multiusuário em que cada aplicativo é um 
usuário diferente. Ou seja, para cada aplicação instalada no celular é criado um usuário no sistema 
operacional para ter acesso a sua estrutura de diretórios. Assim, somente o usuário atribuído àquele 
aplicativo pode acessá-lo. 
 
 
11 
 
 
1.2 Arquitetura da plataforma 
Como descrito no site oficial, “O Android é uma pilha de software com base em Linux de 
código aberto criada para diversos dispositivos e fatores de forma”. Isto significa que, a arquitetura 
do Android é construída em camadas onde estas camadas são software agrupados em uma pilha. E 
estas, se dividem em seis camadas (Figura 1.3): Kernel do Linux, Camada de abstração de hardware 
(HAL), Android Runtime, Bibliotecas C/C++ nativas, Estruturas da Java API e os Aplicativos do sistema. 
 
Figura 1.3 - As seis camadas da arquitetura da plataforma Android: Kernel do Linux (Linux Kernel), Camada de abstração 
de hardware (Hardware Abstraction Layer - HAL), Android Runtime (ART), Bibliotecas nativas (Native Libraries), Java API 
Framework e os Aplicativos do sistema (System Apps). 
Fonte: source.android.com. 
 
O Android Open Source Project (AOSP) é uma iniciativa que visa disponibilizar 
versões do Android totalmente baseadas em código-fonte aberto. Saiba mais 
sobre o AOSP: 
https://source.android.com/ 
https://source.android.com/
 
 
12 
Descrição da imagem: figuras geométricas no formato de um quadrado representando camadas, sobrepostas de cima 
para baixo na seguinte sequência: rosa pink, lilás, laranja, azul, verde e verde claro. 
 
O diagrama a seguir (Figura 1.4) mostra a maioria dos componentes da arquitetura 
Android: 
 
Figura 1.4 - A pilha de software do Android e suas respectivas camadas: Kernel do Linux (Linux Kernel), Camada de 
 
 
13 
abstração de hardware (Hardware Abstraction Layer - HAL), Bibliotecas C/C++ nativas (Native C/C++ Libraries) e Android 
Runtime (ART), Java API Framework e os Aplicativos do sistema (System Apps). 
Fonte: developer.android.com 
Descrição da imagem: figuras geométricas no formato de um retângulo representando uma pilha, onde os elementos 
estão em cima do outro na seguinte sequência (base-topo): laranja, azul claro, lilás e amarelo, verde claro e azul escuro. 
 
• Kernel do Linux (Linux Kernel): 
O kernel do linux é o nível mais baixo e a base da arquitetura Android. Por exemplo:o 
Android Runtime (ART) confia no kernel do Linux para cobrir funcionalidades como encadeamento e 
gerenciamento de memória de baixo nível. 
Usar um kernel do Linux permite que o Android aproveite os recursos de segurança 
principais e que os fabricantes dos dispositivos desenvolvam drivers de hardware para um kernel 
conhecido. 
 
• Camada de abstração de hardware (Hardware Abstraction Layer - HAL): 
A camada de abstração de hardware (HAL) fornece interfaces padrão que expõem as 
capacidades de hardware do dispositivo para a estrutura da Java API de maior nível. A HAL consiste 
em módulos de biblioteca, que implementam uma interface para um tipo específico de componente 
de hardware, como o módulo de câmera ou Bluetooth. Quando uma Framework API faz uma 
chamada para acessar o hardware do dispositivo, o sistema Android carrega o módulo da biblioteca 
para este componente de hardware. 
 
 
• Android Runtime: 
Para dispositivos com Android versão 5.0 ou mais recente, cada aplicativo executa o 
próprio processo com uma instância própria do Android Runtime (ART). O ART é projetado para 
executar várias máquinas virtuais em dispositivos de baixa memória executando arquivos DEX, um 
formato de bytecode projetado especialmente para Android, otimizado para oferecer consumo 
mínimo de memória. 
 
 
 
 
 
14 
• Bibliotecas C/C++ nativas (Native C/C++ Libraries): 
Vários componentes e serviços principais do sistema Android, como ART e HAL, são 
implementados por código nativo que exige bibliotecas nativas programadas em C e C++. A 
plataforma Android fornece as Java APIs Framework para expor a funcionalidade de algumas dessas 
bibliotecas nativas aos aplicativos. Por exemplo, é possível acessar OpenGL ES pela Java OpenGL API 
da estrutura do Android para adicionar a capacidade de desenhar e manipular gráficos 2D e 3D no 
seu aplicativo. 
Se estiver desenvolvendo um aplicativo que exige código C ou C++, você pode usar o 
Android NDK para acessar algumas dessas bibliotecas de plataforma nativa diretamente do seu 
código nativo. 
 
• Java API Framework: 
O conjunto completo de recursos do sistema operacional Android está disponível pelas 
APIs programadas na linguagem Java. Essas APIs formam os blocos de programação que você precisa 
para criar os aplicativos Android simplificando a reutilização de componentes e serviços de sistema 
modulares e principais, inclusive: 
• Um sistema de visualização rico e extensivo útil para programar a IU de um aplicativo, 
com listas, grades, caixas de texto, botões e até mesmo um navegador da web 
incorporado 
• Um gerenciador de recursos, fornecendo acesso a recursos sem código como strings 
localizadas, gráficos e arquivos de layout 
• Um gerenciador de notificação que permite que todos os aplicativos exibam alertas 
personalizados na barra de status 
• Um gerenciador de atividade que gerencia o ciclo de vida dos aplicativos e fornece 
uma pilha de navegação inversa 
• Provedores de conteúdo que permite que aplicativos acessem dados de outros 
aplicativos, como o aplicativo Contatos, ou compartilhem os próprios dados 
 
 
 
15 
Os desenvolvedores têm acesso completo às mesmas Framework APIs que os aplicativos 
do sistema Android usam. 
 
• Os Aplicativos do sistema (System Apps): 
O Android vem com um conjunto de aplicativos principais para e-mail, envio de SMS, 
calendários, navegador de internet, contatos etc. Os aplicativos inclusos na plataforma não têm 
status especial entre os aplicativos que o usuário opta por instalar. Portanto, um aplicativo 
terceirizado pode se tornar o navegador da Web, o aplicativo de envio de SMS ou até mesmo o 
teclado padrão do usuário (existem algumas exceções, como o aplicativo Configurações do sistema). 
Os aplicativos do sistema funcionam como aplicativos para os usuários e fornecem 
capacidades principais que os desenvolvedores podem acessar pelos próprios aplicativos. Por 
exemplo: se o seu aplicativo quiser enviar uma mensagem SMS, não é necessário programar essa 
funcionalidade — é possível invocar o aplicativo de SMS que já está instalado para enviar uma 
mensagem ao destinatário que você especificar. 
 
1.3 Os diversos sabores do Android 
Em 22 de outubro de 2008, foi lançado oficialmente o primeiro Android comercial do 
mercado, o Android Alpha, com o famoso HTC Dream, e após isso o Android não parou mais de 
evoluir. 
E essa evolução aconteceu de uma forma engraçada e doce, pois cada nova versão do 
Android foi apelidada com o nome de um doce. Quando este caderno foi escrito a versão mais recente 
chamada extraoficialmente Android Q, foi batizada como Android 10 (Figura 1.5). Isso significa que 
houve uma quebra de tradição, e desta vez não houve doce. 
 
 
16 
 
Figura 1.5 - Imagem de divulgação do Android 10. 
Fonte: techtudo.com. 
Descrição da Imagem: palavra Android na cor branca seguida por uma cabeça de um robô na cor verde, com fundo em 
formato retangular na cor azul marinho. 
A tabela (Tabela 1.1) a seguir mostra os diversos sabores, ou melhor, as diversas versões do Android: 
Data de 
Lançamento 
Versão Nome Características Figura do Android 
Abril.2009 Android 1.5 Cupcake A principal novidade foi o 
lançamento do primeiro Android 
(HTC Magic) com apenas o touch 
screen e o teclado virtual. Foi no 
Cupcake que nasceram os 
widgets. 
Set.2009 Android 1.6 Donut Com o auxílio das pesquisas de 
voz, a home do Android ganhou 
mais funcionalidades, e o usuário 
pôde começar a pesquisar na 
agenda de contatos, na galeria de 
música. 
Out.2009 
(atualizado 
em 
Jan.2010) 
Android 12.0 
e 2.1 
Eclair Trouxe uma interface de usuário 
diferenciada e adicionou os Live 
Wallpapers (plano de fundo 
animado na tela inicial). E 
também lançou o suporte a 
múltiplas contas do Google e 
sincronização. 
 
Mai.2010 Android 2.2 Froyo Trouxe diversas melhorias de 
desempenho para o sistema 
operacional. 
 
 
 
17 
Dez.2010 Android 2.3 Gingerbread Trouxe novidade na câmera, pois 
era possível alternar entre a 
câmera frontal e a traseira. E 
melhorias na funcionalidade de 
copy-paste. Foi nesta versão que 
tivemos um grande ganho com 
relação ao gerenciamento da 
bateria. 
 
 
Fev.2011 Android 3.0 Honeycomb Trouxe um sistema operacional 
totalmente focado nos tablets, 
com uma experiência de usuário 
totalmente diferenciada para 
telas grandes. 
Nesta versão, o Android deixou 
de ter botões físicos e os botões 
de voltar e início (home) 
passaram a fazer parte da barra 
de navegação dentro da tela com 
o touch screen. 
 
 
Out.2011 Android 4.0 Ice cream 
Sandwich 
Unificou a plataforma de 
desenvolvimento entre 
smartphones e tablets 
executando o mesmo sistema 
operacional. 
 
Jun.2012 Android 4.1 Jelly Bean Trouxe um ganho significativo 
com relação ao desempenho do 
sistema, e todo o sistema 
operacional ganhou melhorias no 
suporte às animações, deixando a 
interface mais sensível ao toque e 
mais fluida. 
 
 
Out.2013 Android 4.4 KikKat Otimizou o Android ao máximo. 
E também trouxe 
aperfeiçoamento no Bluetooth. 
 
 
 
18 
Nov.2014 Android 5.0 Lollipop Foi a maior release focada na 
interface de usuário, usabilidade, 
animações e experiência do 
usuário. 
 
Agost.2015 Android 6.0 Marshmallow Trouxe um novo recurso, o novo 
modelo de permissão em tempo 
de execução, chamado Runtime 
Permissions. 
O Google Now também recebeu 
atualizações. 
 
 
Google I/O 
2016 
Android 7.0 Nougat Trouxe o suporte ao sistema de 
várias janelas (multi-window), 
uma nova central de notificações 
mais ricas, respostas diretas nas 
notificações e atalhos para 
executar ações nos aplicativos 
pela tela Home. 
 
Google I/O 
2017 
Android 8.0 Oreo Foi a versão que mais trouxe 
novidades para o usuário final. 
Dentre elas, tivemos uma 
inicialização mais rápida do 
sistema operacional. 
 
 
Google I/O 
2018 
Android 9.0 Pie Dentre as principais novidades 
tem o suporte ao Wi-Fi RTT para 
obter melhor localizaçãodo 
usuário, mesmo em ambientes 
internos. 
 
Set. 2019 Android 10 Android 10 O Android 10 foi construído em 
torno de três temas importantes. 
Primeiro, ele está liderando a 
inovação móvel com machine 
learning avançado e 
compatibilidade com novos 
dispositivos, como smartphones 
habilitados para 5G e dobráveis. 
Segundo o Android 10 tem um 
foco central em privacidade e 
segurança, com quase 50 
recursos que oferecem aos 
usuários maior proteção, 
 
 
 
19 
transparência e controle. Por fim, 
o Android 10 expande os 
controles de bem-estar digital 
dos usuários, para que indivíduos 
e famílias possam encontrar um 
melhor equilíbrio com a 
tecnologia. 
 
Tabela 1.1 - As diversas versões do Android 
Figura 1.6 - Versões do Android: Cupcake, Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice cream Sandwich, Jelly 
Bean, KikKat, Lollipop, Marshmallow, Nougat, Oreo, Pie e Android 10. 
Fonte: in.c.mi.com., tecmundo.com., developer.android.com., 
Descrição da Imagem: cupcake no formado de um robô na cor verde, uma rosquinha com um robô na cor verde, um 
doce bomba de chocolate com um robô na cor verde, um iogurte gelado na cor verde, um biscoito de gengibre no 
formato de um robô, um doce favo de mel no formato de uma abelha robô, um robô na cor verde com balas de jujuba 
de diversas cores, um sanduíche de sorvete no formato de um robô, um chocolate kitkat no formato de um robô, um 
robô na cor verde segurando um pirulito, um robô na cor verde segurando um marsmallow, um robô na cor verde sobre 
o doce torrone, um biscoito oreo no formato de um robô na cor verde e um robô na cor verde segurando um pedaço de 
torta. 
 
1.4 Google Play 
A Google Play é a loja de aplicativos, livros, filmes e músicas do Android, e é por meio dela 
que usuários de todo o mundo podem fazer o download de conteúdo para o seu aparelho. 
Foi criada para auxiliar na distribuição dos aplicativos, além da divulgação de sua nova 
plataforma. Inicialmente se chamava Android Market. O objetivo do site foi oferecer aos 
desenvolvedores um lugar comum para disponibilizar seus aplicativos. 
 
1.5 O ambiente de desenvolvimento 
Para começar a estudar a tão esperada “Programação para dispositivos móveis” é 
necessário configurar o ambiente de desenvolvimento de aplicações para o Android no seu 
computador ou no computador onde aplicação vai ser criada. Para isso o computador deve possuir 
os seguintes componentes: o Java Development Kit (JDK) e o Android Studio. 
Caso não tenha estes componentes no computador, você deverá instalá-los. Se esse for o 
seu caso, fique tranquilo nas próximas seções serão explicados tanto o processo de instalação como 
o processo de configuração do ambiente de desenvolvimento de aplicações para o Android. 
 
 
20 
Antes de realizar a instalação dos componentes é necessário verificar se o computador 
possui a configurações mínimas para executá-los. Os requisitos são: 
• Sistema operacional Microsoft Windows 7/8/10 (32 bits ou 64 bits) 
• No mínimo de 3 GB de RAM, porém o recomendado é de 8 GB de RAM (mais 1 GB 
para o emulador do Android). 
• No mínimo 2 GB de espaço disponível em disco, porém o recomendado é 4 GB (500 
MB para IDE mais 1.5 GB para Android SDK e imagem do sistema emulador). 
• Resolução mínima de tela de 1280 x 800. 
 
1.5.1 Instalação do JDK 
Java Development Kit (JDK) significa Kit de desenvolvimento Java, ou seja, é um pacote de 
ferramentas que permitem o desenvolvimento de uma aplicação baseado em Java. É composto por 
compilador e bibliotecas. 
O Java é fornecido em dois pacotes: o pacote JDK e o pacote Java Runtime Enviroment 
(JRE). JRE é o pacote de runtime (pacote de ferramenta para executar o código Java) e faz parte do 
JDK. 
A versão de JDK que iremos instalar será Java SE 11.0.5, a qual está disponível no site da 
Oracle para download no link abaixo: 
 
Você usa outro Sistema Operacional? 
Você utiliza outro SO (Sistema Operacional) como Mac OS e Linux e quer saber 
quais são os requisitos mínimos? Segue o link com as configurações mínimas 
para executar os componentes: 
https://www.javaworld.com/article/3095406/android-studio-for-beginners-part-
1-installation-and-setup.html 
 
https://www.javaworld.com/article/3095406/android-studio-for-beginners-part-1-installation-and-setup.html
https://www.javaworld.com/article/3095406/android-studio-for-beginners-part-1-installation-and-setup.html
 
 
21 
 
 
Assim, para fazer o Download do JDK, acesse o link e selecione a versão Java SE 11.0.5 de 
acordo com o sistema operacional do seu computador (Figura 1.7). 
 
Figura 1.7 - Seleção do pacote JDK. 
Fonte: oracle.com 
Descrição da Imagem: página do site oracle apresentando texto que informam a versão do JDK e as diversas opções do 
software para download. 
Finalizado o download, execute o JDK e siga as instruções para completar o processo de 
instalação (Figuras 1.8, 1.9 e 1.10). 
 
Download do JDK 
https://www.oracle.com/technetwork/java/javase/downloads/jdk11-
downloads-5066655.html 
https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html
https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html
 
 
22 
 
Figura 1.8 - Instalação do pacote JDK. 
Fonte: Java SE 11.0.5 
Descrição da Imagem: janela com texto descritivo para instalação do pacote JDK que será confirmado mediante o click 
do mouse sobre um dos botões: Next, se deseja continuar a instalação e Cancel, se deseja cancelar a instalação. 
 
 
 
23 
 
Figura 1.9 - Processo de instalação do pacote JDK. 
Fonte: Java SE 11.0.5 
Descrição da imagem: janela com texto descritivo do progresso da instalação do pacote JDK. 
 
 
24 
 
Figura 1.10 - Finalizado o processo de instalação do pacote JDK. 
Fonte: Java SE 11.0.5 
Descrição da imagem: janela com texto descritivo da conclusão da instalação do pacote JDK. A janela será fechada 
mediante o click do mouse sobre o botão Close. 
 
1.5.2 Instalação e configuração do Android Studio 
O Android Studio é o IDE (Integrated Development Environment) ou ambiente de 
desenvolvimento integrado padrão da Google cuja a função é o desenvolvimento exclusivo de 
aplicações Android. Atualmente na versão 3.5.2, o Android Studio traz diversas ferramentas para 
auxiliar no processo de desenvolvimento, testes, análise e depuração de aplicações para android. 
Além de ser gratuito. Por este motivo, utilizaremos o Android Studio para criarmos os projetos que 
desenvolveremos no decorrer deste caderno. 
 
O que é Java? 
Java é uma linguagem de programação e plataforma computacional lançada pela 
primeira vez pela Sun Microsystems em 1995. 
Saiba mais: https://www.java.com/pt_BR/download/faq/whatis_java.xml 
https://www.java.com/pt_BR/download/faq/whatis_java.xml
 
 
25 
 
A versão do Android Studio que iremos instalar será 3.5.2, a qual está disponível no site 
oficial do Android Studio para download, segue o link abaixo: 
 
Assim, para fazer o Download do Android Studio, acesse o link e clique no botão baixar 
android studio (Figura 1.11) e aceite os termos e condições e clique no botão fazer o download de 
Android Studio para Windows para iniciar o download. 
 
Figura 1.11 - Download do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da Imagem: página de acesso para fazer o Download do Android Studio, com texto descritivo do Android 
Studio em que na parte inferior tem-se um botão com fundo verde-escuro com o texto baixar android studio. 
 
 
O que é SDK? 
O Android SDK (Software Development Kit) ou Kit de Desenvolvimento de 
Software para Android é um pacote completo de ferramentas utilizadas pelo 
Android Studio e pelos desenvolvedores Android, incluindo componentes como 
o SDK Tools, Build Tools e o Platform Tools. 
Saiba mais: https://www.androidpro.com.br/blog/android-studio/android-sdk/ 
 
 
Downloads do Android Studio 
Downloads do Android Studio para os sistemas operacionais Windows, Mac, 
Linuxe Chrome OS: 
https://developer.android.com/studio/index.html 
Saiba mais: https://www.androidpro.com.br/blog/android-studio/android-sdk/ 
 
https://developer.android.com/studio/index.html
https://www.androidpro.com.br/blog/android-studio/android-sdk/
 
 
26 
Finalizado o download, execute o Android Studio e siga as instruções para completar o 
processo de instalação (Figuras 1.12, 1.13, 1.14, 1.15, 1.16 e 1.17). 
 
Figura 1.12 - Instalação do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: janela com texto descritivo para instalação do Android Studio que será confirmado mediante o 
click do mouse sobre um dos botões: Back, se deseja voltar, Next, se deseja continuar a instalação e Cancel, se deseja 
cancelar a instalação. 
 
 
 
27 
 
Figura 1.13 - Instalação do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: janela com texto descritivo para instalação dos componentes do Android Studio que será 
confirmado mediante o click do mouse sobre um dos botões: Back, se deseja voltar, Next, se deseja continuar a 
instalação e Cancel, se deseja cancelar a instalação. 
 
 
28 
 
Figura 1.14 - Instalação do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: janela com texto descritivo para a instalação do Android Studio. E logo abaixo uma caixa de 
texto com o texto descritivo do local de instalação, em que no lado direito tem-se um botão com fundo cinza com o 
texto Browser. A instalação do Android Studio será confirmada mediante o click do mouse sobre um dos botões: Back, 
se deseja voltar, Next, se deseja continuar a instalação e Cancel, se deseja cancelar a instalação. 
 
Figura 1.15 - Instalação do Android Studio 
Fonte: Android Studio 3.5.2 
 
 
29 
Descrição da imagem: janela com texto descritivo para instalação do Android Studio que será confirmado mediante o 
click do mouse sobre um dos botões: Back, se deseja voltar, Next, se deseja continuar a instalação e Cancel, se deseja 
cancelar a instalação. 
 
 
Figura 1.16 - Instalação do Android Studio 
Fonte: Android Studio 3.5.2 
Descrição da imagem: janela com texto descritivo do progresso de instalação do Android Studio. A instalação do 
Android Studio será confirmada mediante o click do mouse sobre um dos botões: Back, se deseja voltar, Next, se deseja 
continuar a instalação e Cancel, se deseja cancelar a instalação. 
 
 
 
30 
 
Figura 1.17 - Instalação do Android Studio 
Fonte: Android Studio 3.5.2 
Descrição da imagem: janela com texto descritivo da instalação completa do Android Studio. O Android Studio será 
executado mediante o click do mouse sobre um dos botões: Back, se deseja voltar, Finish, se deseja finalizar a instalação 
e Cancel, se deseja cancelar a instalação. 
 
Após o processo de instalação, o Android Studio irá executar pela primeira vez e então 
surgirá a janela de carregamento do editor (Figura 1.18). 
 
Você usa outro SO? 
Você utiliza outro SO como Mac OS e Linux e quer instalar o Android Studio 
Segue o link com o guia de instalação para estes SO: 
https://developer.android.com/studio/install#mac 
https://developer.android.com/studio/install#linux 
 
https://developer.android.com/studio/install#mac
https://developer.android.com/studio/install#linux
 
 
31 
 
Figura 1.18 - Tela de carregamento do Android Studio 3.5.1 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza com figuras geométricas em diversos tamanhos, no centro a palavra 
Android na cor verde seguida pela palavra Studio na cor cinza-claro. 
 
Uma janela com texto descritivo da instalação completa do Android Studio. O Android 
Studio será executado mediante o click do mouse sobre um dos botões: Back, se deseja voltar, Finish, 
se deseja finalizar a instalação e Cancel, se deseja cancelar a instalação. 
Surgirá a tela intitulada Android Studio Setup Wizard, siga as instruções para o Android 
Studio realizar o download de alguns componentes padrão do SDK. Para finalizar o processo, clique 
no botão finish. 
Em seguida, irá aparecer a tela intitulada Welcome to Android Studio, onde existem várias 
opções, selecione a opção Start a new Android Studio project. Esta opção irá conduzi-lo para o 
processo de configuração de um novo projeto Android. 
Finalizado o processo de configuração de um novo projeto Android, é exibida a janela 
principal do Android Studio (Figura 1.19). 
 
 
32 
 
Figura 1.19 - janela principal do Android Studio 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se o menu textual, a barra de 
ferramentas e a barra de navegação. Logo em seguida, ao lado esquerdo, tem-se a barra de janela de ferramentas e ao 
lado direito, na cor preta, tem-se a janela do editor, . E na parte inferior tem-se outra janela de ferramenta e a barra de 
estado. 
Agora, iremos conhecer cada área destacada na janela principal do Android Studio (Figura 
2.13): 
1) Menu textual: onde os comandos e controles são exibidos de forma textual. 
2) Barra de ferramentas: é a barra de ícones com comandos. Permite executar diversas 
ações, incluindo a execução de aplicações e iniciar ferramentas do Android. 
3) Barra de navegação: é a barra que permite a navegação pelo projeto e a abertura de 
janelas para edição. Além de oferecer uma visualização mais compacta da estrutura visível na janela 
Project. 
4) Janela das ferramentas ou Janela Project: é a janela que dá o acesso a tarefas 
específicas, como gestão de projetos, controle de versão e etc. 
5) Barra de janela de ferramentas: é a barra que contém botões que permitem expandir 
ou recolher a janela de cada ferramenta. 
6) Janela do editor: é a janela que permite ao programador criar e modificar o código. 
 
 
33 
7) Outra janela de ferramentas: neste caso, o LogCat. A janela Logcat no Android Studio 
exibe mensagens do sistema, como quando ocorre uma coleta de lixo, e mensagens que você 
adicionou ao seu app com a classe Log. Ela exibe mensagens em tempo real e mantém um histórico 
para que você possa ver mensagens mais antigas. 
8) Barra de estado: é a barra que mostra o estado do projeto e do próprio IDE. Além de 
mostrar advertências e mensagens. 
 
1.6 Configuração do AVD no Android Studio 
O Android Virtual Device (AVD) é um emulador do Android Studio onde podemos testar 
as aplicações desenvolvidas. Então, é no AVD que configuramos e definimos as características de um 
smartphone ou tablet Android, Wear OS, Android TV ou um dispositivo Android Automotive OS que 
você queira simular no Android Emulator. Já o AVD Manager é uma interface que pode ser iniciada 
no Android Studio para ajudar a criar e gerenciar AVDs. 
Para abrir o AVD Manager, siga um dos procedimentos a seguir: 
Selecione o ícone AVD Manager na barra de ferramentas, na janela principal do 
Android Studio (Figura 1.20): 
 
O que é LogCat? 
Saiba mais: https://developer.android.com/studio/debug/am-logcat.html?hl=pt-
br 
https://developer.android.com/studio/debug/am-logcat.html?hl=pt-br
https://developer.android.com/studio/debug/am-logcat.html?hl=pt-br
 
 
34 
 
Figura 1.20 - Ícone AVD Manager na janela principal do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se o menu textual, a barra de 
ferramentas e a barra de navegação. Na barra de ferramentas, tem-se o ícone com um celular na cor branco e cinza-
escuro com uma cabeça de um robô na cor verde. 
Logo em seguida tem-se a barra de janela de ferramentas e a janela do editor. E na parte inferior tem-se outra janela de 
ferramenta e a barra de estado. 
 
Surgirá a tela intitulada Android Studio Device Manager (Figura 1.21), clique no botão 
+Create Virtual Device na parte inferior da caixa de diálogo. 
 
 
 
35 
 
Figura 1.21 - Configuração do Android Virtual Device 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro,com as figuras de um celular na cor cinza-claro, um relógio na 
cor cinza-claro, uma tv na cor cinza-claro e um carro na cor cinza-claro, com texto descritivo do Android Virtual Device. E 
logo abaixo, na parte inferior tem-se um botão com fundo cinza-claro com o texto create virtual device. 
 
A janela Select Hardware será exibida (Figura1.22). 
 
Figura 1.22 – Configuração do Hardware 
 
 
36 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro, com texto descritivo para a configuração do hardware. A 
configuração do hardware será confirmada mediante o click do mouse sobre um dos botões: Next, se deseja continuar a 
configuração e Cancel, se deseja cancelar a configuração. 
 
O AVD Manager já contém alguns perfis de hardware pré-carregados, nós iremos utilizar 
o perfil Nexus 5K. Para definir o perfil de hardware selecione primeiro a categoria Phone, após 
selecione o perfil Nexus 5K e para finalizar clique no botão Next 
A janela System Imagem será exibida 
 
Figura 1.23 – Configuração do Android Oreo 8.0. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro, com texto descritivo para a seleção da versão Android. A 
configuração do Android Oreo 8.0 será confirmada mediante o click do mouse sobre um dos botões: Next, se deseja 
continuar a configuração e Cancel, se deseja cancelar a configuração. 
 
Selecione a imagem de sistema com o Release Name Oreo e o Target Android 8.0 (Google 
Play), e clique em Next (Figura 1.23). 
A janela Verify Confiuration será exibida. 
 
 
37 
 
Figura 1.24 – Verificando a configuração do AVD. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro, com texto descritivo para a configuração do AVD. A 
configuração do AVD será confirmada mediante o click do mouse sobre um dos botões: Next, se deseja continuar a 
configuração e Cancel, se deseja cancelar a configuração. 
 
Altere as propriedades na Verify Configuration conforme as propriedades exibidas na 
Figura 1.24 e clique em Finish. 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• Os conceitos básicos do Android. 
• Arquitetura da plataforma. 
• A evolução das “doces” versões do Android. 
• Instalar o JDK. 
 
Saiba mais sobre AVD 
Ficou curioso? Quer saber mais sobre o AVD e sua configuração? Então acesse: 
https://developer.android.com/studio/run/managing-avds.html?hl=pt-br 
https://developer.android.com/studio/run/managing-avds.html?hl=pt-br
 
 
38 
• Instalar e configurar do Android Studio. 
• Configurar do AVD no Android Studio. 
• Criar um projeto no Android Studio. 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
Agora, o próximo passo é mergulhar na competência 2, que trata das variáveis, dos tipos 
de dados e dos operadores. Esses elementos definem os limites de uma linguagem e determinam o 
tipo de tarefas às quais ela pode ser aplicada. 
 E então, vamos lá? 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a nossa primeira videoaula competência 1. 
 
 
39 
2. Competência 02 | Formatar uma Activity para o Desenvolvimento, 
Utilizando Operadores Matemáticos 
Caro estudante, vamos iniciar a segunda competência! Nesta competência, você irá 
conhecer as variáveis. Também irá conhecer com detalhes os tipos de dados e os operadores. Porém, 
antes disso, você vai aprender a criar um projeto Android. E em seguida, conhecerá a estrutura de 
um projeto Android e o processo de compilação e execução de um aplicativo. 
Vamos continuar! 
 
2.1 Conceitos Básicos 
2.1.1 Iniciando um novo projeto com Android Studio 
O Android Studio é um ambiente de desenvolvimento que facilita a criação de aplicativos 
Android em vários formatos, como celulares, tablets, TVs e dispositivos Wear. Neste caderno, vamos 
aprender a criar aplicativos para Android com a linguagem Java, focado no desenvolvimento mobile. 
Vamos criar o nosso projeto Android. Execute o Android Studio, no menu principal clique 
em File e selecione a opção New → New Project (Figura 2.1). 
 
 
 
 
40 
Figura 2.1 - Criando um novo projeto no Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se o menu textual. Um Novo 
projeto é iniciado mediante o click do mouse sobre File → New → New Project, no menu textual. 
 
Surgirá a janela Create New Projet, onde será iniciado o processo de configuração de um 
novo projeto. Nesta janela é possível adicionar uma Activity ao projeto partindo de um 
template. Para escolher o seu template selecione primeiro Phone and Tablet, após selecione Empty 
Activity e clique no botão next (Figura 2.2). 
 
Figura 2.2 - Tela do assistente de criação de um novo projeto. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro, com texto descritivo para escolher seu projeto. Além de dez 
retângulos em formato paralelo representando os projetos a serem escolhidos. A escolha do projeto será confirmada 
mediante o click do mouse sobre um dos botões: Next, se deseja continuar a configuração e Cancel, se deseja cancelar a 
configuração. 
 
 
O que é um activity? 
Uma Activity é responsável por criar uma janela na qual é exibida a interface 
gráfica do aplicativo. 
https://www.androidpro.com.br/blog/desenvolvimento-android/activity-intro/ 
https://www.androidpro.com.br/blog/desenvolvimento-android/activity-intro/
 
 
41 
A janela Configure your project será exibida (Figura 2.3). 
 
Figura 2.3 - Definindo as configurações iniciais do projeto. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro, do lado esquerdo temos um retângulo representando o 
projeto escolhido. E do lado temos texto descritivo para configurar seu projeto: a palavra Name, e logo baixo uma caixa 
de texto. A palavra language, e logo abaixo uma caixa de seleção de texto. A palavra Minimum API level, e ao lado uma 
caixa de seleção de texto. A configuração do novo projeto será confirmada mediante o click do mouse sobre um dos 
botões: Cancel, se deseja cancelar a configuração, e Finish, quando estiver tudo pronto para criar o projeto. 
 
Nesta janela (Figura 2.3) você irá definir algumas configurações para criar um novo 
projeto. Vamos a configuração: 
1. Em Name digite o nome do seu projeto que aparecerá no aparelho. 
2. Em Package Name digite o nome do pacote, que define onde ficarão as classes do 
projeto. Por padrão, esse nome de pacote também se torna o ID do aplicativo, ou 
seja, não pode haver duas aplicações com o mesmo nome de pacote instalados no 
aparelho. 
3. Em Save location, especifique em que local do computador o seu projeto será salvo. 
 
 
42 
4. Em Language, devemos selecionar a linguagem de programação que o Android 
Studio irá usar ao criar um código. Todos os exemplos deste caderno serão 
desenvolvidos com a linguagem Java, por isso, no campo Language, selecione Java. 
5. Em Minimum API level devemos selecionar a versão mínima do Android que o 
aparelho deve possuir para executar a aplicação. Todos os exemplos apresentados 
neste caderno devem funcionar no Android Oreo, por isso, no campo Minimum API 
level, selecione API 26: Android 8.0 (Oreo). 
6. Se o tipo de projeto selecionado for compatível com experiências instantâneas por 
meio do Google Play Instant e você quiser ativá-las para a sua aplicação, marque a 
caixa ao lado de This project will support instant apps. O Google Play Instant não 
será utilizado nos exemplos apresentados neste caderno, desta forma desmarque a 
caixa ao lado de This project will support instant apps. 
7. Se você quiser que o projeto use bibliotecas AndroidX por padrão, que são 
substituições aprimoradas das Android Support Libraries, marquea caixa ao lado de 
Use AndroidX artifacts. A bibliotecas AndroidX não será utilizado nos exemplos 
apresentados neste caderno, desta forma desmarque a caixa ao lado de Use 
Androidx.* artifacts. 
 
Quando estiver tudo pronto para criar o projeto, clique em Finish. 
Depois que o projeto for criado, iremos visualizá-lo igual à da Figura 2.4. 
 
 
43 
 
Figura 2.4 – Novo projeto criado. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se o menu textual, a barra de 
ferramentas e a barra de navegação. Logo em seguida tem-se a barra de janela de ferramentas e a janela do editor. E na 
parte inferior tem-se outra janela de ferramenta e a barra de estado. 
 
 
 
O que é Google Play Instant? 
O Google Play Instant é um serviço que permite que aplicativos sejam iniciados 
em dispositivos com Android 5.0 sem serem instalados, ou seja, sem realizar o 
download. Desta forma, você irá experimentar a aplicação Android antes de 
instalar. 
https://developer.android.com/topic/google-play-instant/overview?hl=pt-br 
https://www.techtudo.com.br/noticias/2019/08/o-que-e-google-instant-apps-
no-android-saiba-como-funciona-o-servico.ghtml 
 
 
O que é AndroidX? 
O AndroidX é o projeto de código aberto que a equipe Android usa para 
desenvolver, testar, incluir, controlar a versão e liberar bibliotecas no Jetpack. 
https://developer.android.com/jetpack/androidx/?hl=pt-br 
https://www.techtudo.com.br/noticias/2019/08/o-que-e-google-instant-apps-no-android-saiba-como-funciona-o-servico.ghtml
https://www.techtudo.com.br/noticias/2019/08/o-que-e-google-instant-apps-no-android-saiba-como-funciona-o-servico.ghtml
https://developer.android.com/jetpack/androidx/?hl=pt-br
 
 
44 
 
 
2.1.2 Estrutura de um projeto Android 
Depois de aprender a criar um projeto, vamos conhecer a estrutura de diretórios e 
arquivos gerados. No lado esquerdo é exibida a estrutura do projeto (Figura 2.5). 
 
Figura 2.5 – Estrutura de um projeto Android 
Fonte: Android Studio 3.5.2 
 
O que é Android Jetpack? 
O Android Jetpack é uma coleção de bibliotecas para facilitar o desenvolvimento 
de aplicativos Android. Esta coleção de bibliotecas ajudam o desenvolvedor a 
seguir as práticas mais recomendadas e simplifica tarefas complexas. 
https://developer.android.com/jetpack?hl=pt-br 
https://developer.android.com/jetpack?hl=pt-br
 
 
45 
Descrição da imagem: apresenta um fundo cinza-escuro em que tem-se a janela de ferramentas, com texto descritivo 
na cor branca. E do lado esquerdo temos a barra de janela de ferramentas contendo botões. 
 
Na parte superior, ao selecionar a opção Project, é exibida outra forma de visualização do 
projeto mais próxima que existe no sistema de arquivos. Alguns arquivos desta estrutura serão 
detalhados neste caderno, são eles: o AndroidManifest.xml, a Classe MainActivity e o arquivo de 
Layout activity_main.xml. 
 
2.1.2.1 Arquivo AndroidManifest.xml 
O arquivo AndroidManifest.xml é a base de um aplicativo e contém boa parte das 
informações que foram declaradas no assistente de criação do projeto (Figura 2.6). 
 
Figura 2.6 - Arquivo AndroidManifest.xml 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se três botões: 
AndroidManifest.xml, MainActivity.java e activity_main.xml. Logo abaixo tem-se a janela do editor com o código do 
arquivo AndroidManifest.xml. 
 
Quando criamos um novo projeto, é gerada a classe MainActivity, a qual é configurada 
automaticamente como a activity inicial do projeto no AndroidManifest.xml. 
 
 
46 
Na tag <manifest> é declarado o pacote principal do projeto, utilizando a tag 
<package>. O <package> é o pacote identificador do projeto e deve ser único. 
 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="br.gov.pe.edu.helloworld"> //pacote único do projeto 
 
Na tag <application> são adicionadas algumas configurações do aplicativo. A propriedade 
andoid:label = “@string/app_name” informa o nome do aplicativo na tela inicial. 
 
android:label="@string/app_name" 
// Nome do aplicativo na tela inicial 
 
Todas as activities das aplicações que serão exibidas para o usuário devem estar 
declaradas no AndroidManifest.xml com a tag <activity>. 
 
<activity android:name=".MainActivity"> 
// Classe da activity que deve ser executada 
 <intent-filter> 
 <action android:name="android.intent.action.MAIN" /> 
// A ação MAIN indica que esta activity pode ser executada como a inicial 
do app 
 <category android:name="android.intent.category.LAUNCHER" /> 
 </intent-filter> 
</activity> 
 
2.1.2.2 Classe MainActivity 
A classe MainActivity foi configurada pelo wizard do Android Studio como a activity inicial, 
portanto pode ser executada pelo usuário ao clicar no ícone do aplicativo na tela Home do Android 
(Figura 2.7). 
 
 
47 
 
Figura 2.7 - Classe MainActivity. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que tem-se a janela do editor com o código do arquivo 
MainActivity. 
 
A classe MainActivity ou qualquer outra activity deve ser filha da classe 
android.app.activity: 
public class MainActivity extends AppCompatActivity { 
 
........ 
 
} 
 
 
 
 
Nota: Se no wizard de criação de projetos for selecionado para adicionar a 
biblioteca de compatibilidade, o Android Studio vai criar a classe MainActivity 
como filha de AppCompactActivity. A classe AppCompactActivity é uma 
subclasse de Activity. 
 
 
48 
A classe android.app.Activity representa uma tela do aplicativo, sendo responsável por 
controlar os estados e os eventos da tela. Portanto para cada tela do aplicativo você criará uma classe-
filha de android.app.Activity. 
 
2.1.2.3 Arquivo de Layout activity_main.xml 
No Android é possível criar o layout da tela em arquivos XML ou utilizar a API via código. 
Porém, o mais recomendado é criar o layout em XML, para separar a lógica de negócios da camada 
de apresentação. Uma view pode ser um simples componente gráfico como botão, check box, 
imagem e etc ou uma view complexa, atuando como um gerenciador de layout, que pode conter 
várias views-filhas. 
A seguir podemos visualizar o código do arquivo activity_main.xml (Figura 2.8): 
 
Figura 2.8 - Arquivo activity_main.xml. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que tem-se a janela do editor com o código do arquivo 
activity_main.xml. 
 
No código existem as tags <ConstraintLayout> e <TextView> que correspondem às classes 
ConstraintLayout e TextView, respectivamente. A classe ConstraintLayout é filha da classe 
ViewGroup. E as classes ViewGroup e TextView são filhas da classe android.view.view do Android. A 
 
 
49 
classe ConstraintLayout é um gerenciador de layout da plataforma Android. Esta classe é similar a 
classe LinearLayout, ou seja, possui as melhores características do LinearLayout. Porém, permite a 
criação de layouts grandes e complexos. Neste exemplo a tag <TextView> está contida dentro da tag 
<ConstraintLayout> justamente para compor a interface da tela. 
 
 
 
 
 
 
 Saiba mais sobre a classe LinearLayout 
https://developer.android.com/guide/topics/ui/layout/linear?hl=pt-BR 
 
Saiba mais sobre a classe ConstraintLayout 
https://developer.android.com/reference/android/support/constraint/Constrain
tLayout 
https://medium.com/collabcode/implementando-telas-no-android-com-
constraint-layout-13a90e44622f 
https://imasters.com.br/android/como-usar-o-constraint-layout-no-android 
 
 
Saiba mais sobre a classe TextView 
https://developer.android.com/reference/android/widget/TextView.html?hl=pt-
BR 
 
Saiba mais sobre a classe ViewGroup 
https://developer.android.com/reference/android/view/ViewGroup 
Saiba mais sobre a classe View 
https://developer.android.com/reference/android/view/View.html 
SaibaComo usar Android Views 
https://www.androidpro.com.br/blog/desenvolvimento-android/android-views-
intro/ 
https://developer.android.com/guide/topics/ui/layout/linear?hl=pt-BR
https://developer.android.com/reference/android/support/constraint/ConstraintLayout
https://developer.android.com/reference/android/support/constraint/ConstraintLayout
https://medium.com/collabcode/implementando-telas-no-android-com-constraint-layout-13a90e44622f
https://medium.com/collabcode/implementando-telas-no-android-com-constraint-layout-13a90e44622f
https://imasters.com.br/android/como-usar-o-constraint-layout-no-android
https://developer.android.com/reference/android/widget/TextView.html?hl=pt-BR
https://developer.android.com/reference/android/widget/TextView.html?hl=pt-BR
https://developer.android.com/reference/android/view/ViewGroup
https://developer.android.com/reference/android/view/View.html
https://www.androidpro.com.br/blog/desenvolvimento-android/android-views-intro/
https://www.androidpro.com.br/blog/desenvolvimento-android/android-views-intro/
 
 
50 
2.1.3 Processo de compilação e execução de um projeto Android 
Para compilar e executar seu projeto no Android Studio, selecione Run → Run na barra 
de menus ou clique em Run na barra de ferramentas (Figura 2.9). Uma terceira opção para compilar 
e executar o novo projeto é selecionar AVD Mananger na barra de ferramentas. Será exibida a tela 
Available Virtual Devices e no campo Actions selecione Run (Figura 2.10). 
 
Figura 2.9 – compilando e executando um projeto no Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se o menu textual. O processo 
de compilar e executar o novo projeto é iniciado mediante o click do mouse sobre Run → Run, no menu textual. 
 
 
 
51 
 
Figura 2.10 – compilando e executando um projeto no AVD Mananger do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte superior tem-se o menu textual. O processo 
de compilar e executar o novo projeto é iniciado mediante o click do mouse sobre AVD Mananger na barra de 
ferramentas. Será exibida a tela Available Virtual Devices e no campo Actions selecione Run. 
 
O resultado deve ficar igual ao da Figura 2.11. 
 
 
52 
 
Figura 2.11 – Resultado. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: apresenta um fundo cinza-escuro em que na parte central tem-se um celular com a palavra Hello 
World. 
 
 
2.2 Variáveis 
As aplicações podem ser vistas como funções que devem ser aplicadas a certos dados de 
entrada com objetivo de produzir determinados resultados. Portanto, todas as aplicações utilizam 
dados. 
Mas, para que possamos transformar o dado em algo útil, temos que primeiro guardá-los. A estrutura 
que guarda um valor para ser utilizados depois é a variável. 
 Monitorar o processo de compilação 
https://developer.android.com/studio/run#gradle-console 
https://developer.android.com/studio/run#gradle-console
 
 
53 
Talvez nenhuma outra estrutura seja tão importante para uma linguagem de programação quanto 
a atribuição de um valor a uma variável. Uma variável é um local nomeado na memória ao qual pode ser 
atribuído um valor. E o valor de uma variável é alterável e não fixo. 
Por exemplo, vamos criar duas variáveis chamadas variavel01 e variavel02 (Figura 2.12): 
 
public class MainActivity extends AppCompatActivity { 
 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 
 int variavel01; //esta instrução declara uma variável 
 
 int variavel02; //esta instrução declara uma variável 
 
 
 
 variavel01 = 7; //esta instrução atribui 7 a variavel01 
 
 variavel02 = variavel01 + 1; //esta instrução atribui (7 + 1) a 
variavel02 
 
 } 
 
} 
Figura 2.12 – Declaração de variáveis. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando as duas variáveis: variavel01 e variavel02 
 
 
Nota: Em Java todas as variáveis devem ser declaradas antes de serem usadas. 
 
Saiba mais sobre variáveis 
https://www.embarcados.com.br/variaveis-e-constantes/ 
Saiba mais sobre variáveis na linguagem de programação Java 
https://www.devmedia.com.br/java-variaveis-e-constantes/38311 
https://www.embarcados.com.br/variaveis-e-constantes/
https://www.devmedia.com.br/java-variaveis-e-constantes/38311
 
 
54 
2.3 Tipo de dados 
Os tipos de dados são especialmente importantes em Java porque essa é uma linguagem 
fortemente tipada. Ou seja, todas as operações têm a compatibilidade de seus tipos verificada pelo 
compilador. Para que seja possível fazer a verificação cuidadosa dos tipos, todas as variáveis, 
expressões e valores têm um tipo. Não há o conceito de uma variável sem tipo. 
 
2.3.1 Tipo de dado primitivo 
Na base de Java, existem oito tipos de dados primitivos, também chamados de 
elementares ou simples, mostrados na Tabela 2.1. O termo primitivo é usado para indicar que esses 
tipos são valores binários simples. 
Tipo Significado 
Boolean Representa os valores 
verdadeiro/falso. 
Byte Inteiro de 8 bits. 
Char Caractere. 
Double Ponto flutuante de precisão dupla. 
Int Ponto flutuante de precisão 
simples. 
Long Inteiro longo. 
Short Inteiro curto. 
Tabela 2.1 - Tipo de dados primitivos de Java 
Fonte: o autor 
 
 
Nota: Todos os outros tipos de dados de Java são construídos a partir dos tipos 
primitivos. 
 
 
55 
2.3.2 Tipo de dado lógico 
São também chamados de dados booleanos. O tipo boolean representa os valores 
verdadeiro/falso. Java define os valores verdadeiro e falso usando as palavras reservadas true e false. 
Desta forma, uma variável ou expressão de tipo boolean terá um desses valores. 
Aqui está um exemplo que demonstra o tipo boolean (Figura 2.13): 
 
public class MainActivity extends AppCompatActivity { 
 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 boolean t; //esta instrução declara uma variável do tipo boolean 
 
 t = true; //esta instrução atribui true a variável t 
 
 
 
 } 
 
} 
Figura 2.13 – Declaração da variável boolean. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando variáveis do tipo boolean. 
 
2.3.3 Tipo de dado numérico Inteiros 
Java define quatro tipos de inteiros, mostrados na Tabela 2.2 abaixo: 
Tipo Tamanho em bits Intervalo 
Byte 8 -128 a 127 
Short 16 -32.768 a 32.767 
Int 32 -2.147.483.648 a 2.147.483.647 
Long 64 -9.223.372.036.854.775.808 a -
9.223.372.036.854.775.807 
 
 
56 
Tabela 2.2 - Tipo de dados inteiros de Java 
Fonte: o autor 
Todos os tipos inteiros são valores de sinal positivo e negativo. Java não suporta inteiros 
sem sinal, ou seja, somente positivos. O tipo inteiro mais usado é o Int. Quando for preciso usar um 
inteiro com um intervalo maior do que o de Int use Long. Por exemplo, aqui está um programa que 
calcula soma de dois valores inteiros (Figura 2.14): 
 
public class MainActivity extends AppCompatActivity { 
 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 
 int variavel01; // esta instrução declara uma variável 
 
 int variavel02; // esta instrução declara uma variável 
 
 int Soma; // esta instrução declara uma variável 
 
 
 
 variavel01 = 7; // esta instrução atribuiu 7 a variavel01; 
 
 variavel02 = variavel01 + 1; // esta instrução atribuiu 7 + 1 a 
variavel02; 
 
 Soma = variavel01 + variavel02; // esta instrução atribuiu (7 + 8) aSoma; 
 
 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 c.setText("O resultado da soma é: " + Soma); 
 
 
 
 } 
 
} 
Figura 2.14 – Declaração das variáveis int. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando variáveis do tipo int. 
 
 
57 
 
Aqui está a saída gerada por esse programa: 
O resultado da soma é: 15 
 
2.3.4 Tipo de dado numérico de ponto flutuante 
Representam números fracionários. Há dois tipos de ponto flutuante, float e double, que 
representam números de precisão simples e dupla, respectivamente. O tipo float tem 32 bits e o tipo 
double tem 64 bits. Dos dois o double é o mais usado. 
Por exemplo, aqui está um programa que calcula a média de dois valores de ponto 
flutuante (Figura 2.15): 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 
 double variavel01; 
 
 double variavel02; 
 
 double Soma; 
 
 double Media; 
 
 
 
 variavel01 = 7.5; 
 
 variavel02 = 9.8; 
 
 Soma = variavel01 + variavel02; 
 
 Media = Soma/2; 
 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 
 
58 
 c.setText("O resultado da soma é " + Media); 
 
 
 } 
 
} 
Figura 2.15 – Declaração das variáveis double. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando variáveis do tipo double. 
 
Aqui está a saída gerada por esse programa: 
o resultado da média é: 8.6 
 
2.3.5 Tipo de dado de caractere 
Em Java, o tipo de dado de caractere guarda um número que representa um caractere. 
Java usa Unicode. O Unicode define um conjunto de caracteres que pode representar todos os 
caracteres encontrados em todos os idiomas humanos. Char é o tipo de 16 bits sem sinal com um 
intervalo que vai de 0 a 65.536, podemos armazenar apenas um caractere neste tipo de variável. 
Aqui está um exemplo que demonstra o tipo char (Figura 2.16): 
 
public class MainActivity extends AppCompatActivity { 
 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 char x; 
 x = 'X'; 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 c.setText("A variável x contém: " + x); 
 
 
 } 
 
} 
 
 
59 
Figura 2.16 – Declaração da variável char. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando variáveis do tipo char. 
 
Aqui está a saída gerada por esse programa: 
A variável x contém: X 
 
2.3.6 Tipo de dado complexo: String 
Um dos tipos de dados Java mais importantes é o tipo String. String define e dá suporte 
a strings de caracteres. Em Java, Strings são objetos. Por exemplo, na instrução: 
 
System.out.println(“Em Java, Strings são objetos”); 
 
O string “Em Java, Strings são objetos” é convertido automaticamente em um objeto 
String por Java. É bom ressaltar, no entanto, que a classe String é muito grande e aqui só a 
examinaremos superficialmente. 
Você pode construir um String como construiria qualquer outro tipo de objeto: usando 
new e chamando o construtor de String. Por exemplo: 
String game = new String (“Death Stranding”); 
 
Essa linha cria um objeto String chamado game que contém o string de caracteres “Death 
Stranding”. Você também pode construir um String a partir de outro. Por exemplo: 
String jogo = new String (“Death Stranding”); 
 
String kojimaProductions = new String (jogo); 
 
 
Saiba mais sobre tipos de dados 
https://www.embarcados.com.br/tipos-de-dados/ 
 
Saiba mais sobre tipos de dados primitivos em Java 
http://www.bosontreinamentos.com.br/java/tipos-de-dados-primitivos-em-
java/ 
https://www.embarcados.com.br/tipos-de-dados/
http://www.bosontreinamentos.com.br/java/tipos-de-dados-primitivos-em-java/
http://www.bosontreinamentos.com.br/java/tipos-de-dados-primitivos-em-java/
 
 
60 
Após essa sequência ser executada, objeto String chamado kojimaProductions também 
irá conter o string de caracteres “Death Stranding”. 
Outra maneira de construir um String é: 
 
String melhorJogo = new String ("Sekiro: Shadows Die Twice" é eleito o Game do 
Ano no Game Awards 2019”); 
 
 
Nesse caso, melhorJogo é inicializada com a sequência de caracteres "Sekiro: Shadows 
Die Twice" é eleito o Game do Ano no Game Awards 2019”. 
Você também pode concatenar strings, ou seja, realizar a junção de uma string com outra. 
Por exemplo: 
String jogo = new String (“Death Stranding”); 
 
 
String estudio= new String (“Kojima Productions”); 
 
 
 
String concatenacao = jogo + “ é um jogo eletrônico de ação desenvolvido pelo 
estúdio japonês “ +estudio; 
 
 
 
Após essa sequência ser executada, objeto String chamado concatenacao irá conter o 
string de caracteres “Death Stranding é um jogo eletrônico de ação desenvolvido pelo estúdio 
japonês Kojima Productions”. Na operação concatenação, utilizamos o símbolo de soma (+) para 
juntar strings. 
 
 
 Saiba mais sobre os tipos de dado complexo String em Java 
https://www.devmedia.com.br/trabalhando-com-string-string-em-java/21737 
https://www.devmedia.com.br/trabalhando-com-string-string-em-java/21737
 
 
61 
2.4 Separadores 
Java define quatro separadores, mostrados na Tabela 2.3 abaixo: 
 
Separador Descrição 
Ponto e Vírgula 
“;” 
é usado para terminar uma instrução. 
Parênteses ‘()’ Separa as expressões. 
Colchetes ‘[]’ são utilizados para indicar/separar os índices de 
vetores. 
Chaves ‘{}’ Separa blocos de programação. 
Tabela 2.3 - Separadores. 
Fonte: o autor 
Na linguagem de programação Java, o ponto e vírgula é um separador que é usado para 
terminar uma instrução. Ou seja, cada instrução individual deve ser finalizada com um ponto e vírgula. 
Um bloco é um conjunto de instruções conectadas logicamente que são delimitados por chaves de 
abertura e fechamento. Ou seja, o início e o fim de cada bloco é indicado pela chave de abertura e 
pela chave fechamento. 
 
2.5 Operadores 
Um operador é um símbolo que solicita ao compilador que execute uma operação 
matemática ou lógica específica. Java tem quatro classes gerais de operadores: aritmético, bitwise, 
relacional e lógico. Nós iremos conhecer agora os operadores aritmético, relacional e lógico. 
 
 Saiba mais sobre Separadores 
https://pt.wikibooks.org/wiki/Java/Operadores#Separadores 
https://pt.wikibooks.org/wiki/Java/Operadores#Separadores
 
 
62 
2.5.1 Operadores Aritméticos 
Os operadores aritméticos definidos por Java podem ser visualizados a seguir, na Tabela 
2.4 : 
Operador Significado 
+ Adição 
- Subtração 
* Multiplicação 
/ Divisão 
% Módulo 
++ Incremento 
-- Decremento 
Tabela 2.4 - Operadores aritméticos. 
Fonte: o autor 
Os operadores soma, subtração, multiplicação e divisão funcionam em Java da mesma 
maneira que qualquer outra linguagem de programação. Eles podem ser aplicados a qualquer tipo de 
dado numérico. E também podem ser usados em objetos do tipo char. 
Em Java o operador % (módulo ou resto) gera o resto de uma divisão. Pode ser aplicado 
a tipos inteiros e de ponto flutuante. Por exemplo, 10 % 3 é igual a 1. 
Aqui está um exemplo que demonstra o operador módulo (Figura 2.17): 
 
public class MainActivity extends AppCompatActivity { 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 
 int modulo; 
 
 modulo = 10 % 3; 
 
 
 
 
63 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 c.setText("A variável modulo contém o valor: " + modulo);} 
 
} 
Figura 2.17 – Demonstração do operador módulo. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando o operador módulo. 
 
Aqui está a saída gerada por esse programa: 
A variável modulo contém: 1 
 
2.5.1.1 Incremento e decremento 
Em Java, o operador de incremento adiciona 1 ao seu operando e o operador de 
decremento subtrai 1. Por exemplo: 
 
i = i + 1; 
 
é o mesmo que: 
i++; 
 
e 
i = i - 1; 
 
é o mesmo que: 
i--; 
 
Tanto o operador de incremento quanto o operador de decremento podem preceder 
(prefixar) ou vir após (posfixar) o operando. Por exemplo: 
i = i + 1; 
 
pode ser escrito como: 
++i; //forma prefixada 
 
 
64 
 
ou como: 
i++; //forma posfixada 
 
Quando um operador de incremento ou decremento precede seu operando, Java executa 
a operação correspondente antes de obter o valor do operando a ser usado pelo resto da expressão. 
Se o operador vier após o seu operando, Java obterá o valor do operando antes dele ser incrementado 
ou decrementado. Por exemplo nas Figuras 2.18 e Figura 2.19 com a demonstração do operador 
módulo incrementado ou decrementado: 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 int x; 
 
 int y; 
 
 
 x = 10; 
 
 y = ++x; // Java executa a operação correspondente antes de obter o valor 
do operando 
 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 c.setText("O resultado de y é: " + y); 
 
 } 
 
} 
Figura 2.18 – Demonstração do operador de incremento de forma prefixada. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando o operador de incremento de forma 
prefixada. 
 
Aqui está a saída gerada por esse programa: 
O resultado de y é: 11 
 
 
65 
 
public class MainActivity extends AppCompatActivity { 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 
 int x; 
 
 int y; 
 
 
 x = 10; 
 
 y = x++; // Java obterá o valor do operando antes dele ser incrementado 
 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 c.setText("O resultado de y é: " + y); 
 
 
 } 
 
} 
Figura 2.19 – Demonstração do operador de incremento de forma posfixada. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando o operador de incremento de forma 
posfixada. 
Aqui está a saída gerada por esse programa: 
O resultado de y é: 10 
Nos dois casos, x é igual a 11. A diferença é quando isso ocorre. 
 
 
 Saiba mais sobre as operações aritméticas 
https://www.embarcados.com.br/operacoes-aritmeticas/ 
https://www.embarcados.com.br/operacoes-aritmeticas/
 
 
66 
2.5.2 Operadores Relacionais e Lógicos 
O operador relacional se refere aos relacionamentos que os valores podem ter uns com 
os outros. Os operadores relacionais são mostrados na Tabela 2.5 abaixo: 
Operador Significado 
== Igual a 
!= Diferente de 
> Maior que 
< Menor que 
>= Maior ou igual a 
<= Menor ou igual a 
Tabela 2.5 - Operadores relacionais. 
Fonte: o autor 
O operador lógico se refere às maneiras como os valores verdadeiro e falso podem estar 
conectados. Estes, fazem operações com os operandos do tipo boolean e o resultado da operação 
lógica é também de tipo boolean. Já que os operadores relacionais produzem resultados verdadeiros 
ou falsos, com frequência trabalham com os operadores lógicos. Logo, o resultado dos operadores 
relacionais e lógicos é um valor boolean. Os operadores lógicos são mostrados na Tabela 2.6 abaixo: 
 
Operador Significado 
& AND 
| OR 
^ XOR (exclusive OR) 
|| OR de curto-circuito 
&& AND de curto-circuito 
! NOT 
Tabela 2.6 - Operadores lógicos. 
Fonte: o autor 
Os operadores lógicos &, |,^ e ! dão suporte às operações lógicas básicas AND, OR, XOR 
e NOT. Observe na Tabela 2.7 os resultados das comparações. 
 
 
67 
 
a b a & b a | b a^b !a 
true true true true false false 
true false false true true false 
false treu false true true true 
false false false false false true 
Tabela 2.7 - Tabela verdade. 
Fonte: o autor 
Na tabela acima, é mostrado o resultado das operações lógicas básicas AND, OR, XOR 
(exclusive OR) e NOT. Na operação exclusive OR, pode-se observar que o resultado mostrado é 
diferente do OR. Isso ocorre porque o resultado de uma operação exclusive OR é verdadeiro quando 
exatamente um, e apenas um, operando é verdadeiro. 
 
 
2.5.3 Operadores de atribuição 
O operador de atribuição é o sinal de igual simples, =. Esta é a sua forma geral em Java: 
variavel = expressao; 
Onde, o tipo de variavel deve ser compatível com o tipo de expressao. 
O operador de atribuição permite a criação de uma cadeia de atribuições. Por exemplo: 
int a, b, c; 
 
a = b = c = 8; //configura a, b e c com o valor 8. 
 
 Saiba mais sobre as operações relacionais e lógicas 
https://www.embarcados.com.br/operacoes-relacionais-e-logicas/ 
https://www.embarcados.com.br/operacoes-relacionais-e-logicas/
 
 
68 
2.5.3.1 Operadores de atribuições abreviadas 
As atribuições abreviadas são operadores especiais que simplificam a codificação de 
certas instruções de atribuição. Por exemplo: 
x = x + 8; 
pode ser escrita, com o uso da atribuição abreviada em Java, como: 
x += 8; 
O par de operadores += solicita ao compilador que atribua a x o valor de x mais 8. 
Observe na Tabela 2.8 os operadores aritméticos de atribuição abreviada: 
Significado Par de Operadores 
Soma x += 8; 
Subtração x -= 8; 
Multiplicação x *= 8; 
Divisão x /= 8; 
Módulo x %= 8; 
Tabela 2.8 - Operadores de atribuição abreviada 
Fonte: o autor 
Já que esses operadores combinam uma operação com uma atribuição, são formalmente 
chamados de operadores de atribuição composta. 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• Criar um novo projeto com o Android Studio. 
• A estrutura de um projeto Android. 
• O processo de compilação e execução de um projeto Android. 
• Variáveis 
• Tipos de dados 
• Operadores 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
69 
 
Agora, o próximo passo é mergulhar na competência 3, que trata do desenvolvimento de 
instruções de controle de programa 
Vamos juntos? 
 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a nossa primeira videoaula competência 2. 
 
 
70 
3. Competência 03 | Formatar uma Activity para o desenvolvimento de 
instruções de controle de programa 
 
Caro estudante, vamos iniciar a terceira competência! Nesta competência, você irá 
conhecer as estruturas de controle condicional e as estruturas de repetição. Você aprenderá as 
instruções que controlam o fluxo de execução do programa: as instruções de seleção, que incluem as 
estruturas if e switch, e as instruções de interação, que incluem os laços for, while e do-while. 
Vamos continuar! 
 
3.1 Estruturas de controle condicional 
3.1.1 Estrutura if 
Podemos executar seletivamente parte de um programa com o uso da instrução 
condicional: a instrução if. A instrução if da linguagem Java funciona de maneira semelhante à 
instrução if de qualquer outra linguagem. Sua forma mais simples é mostrada abaixo: 
if (condição) instrução; 
 
A forma geral de if, usando blocos de instruções é: 
 
if (condição) 
{ 
Instrução ou sequência de instruções 
} 
 
A condição é uma expressão booleana. Se a condição for verdadeira, a instrução (ou o 
bloco de instruções)será executada. Se a condição for falsa, a instrução será ignorada. 
Para demonstrar if, iremos criar e desenvolver um jogo de adivinhação simples. Na 
primeira versão do jogo, o programa pede ao jogador um número entre 0 e 9. Se o jogador pressionar 
o número correto no teclado, o programa responderá exibindo a mensagem “O número da 
adivinhação está certo”. O código pode ser visualizado na Figura 3.1 abaixo: 
 
 
71 
 
 
Figura 3.1 - Estrutura if no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura if. 
 
Esse programa interage com o jogador e então lê um número no teclado. Usando uma 
instrução if, ele compara o número com a resposta que, nesse caso, é 7. Se 7 for inserido, a mensagem 
“O número da adivinhação está certo!” será exibida. 
 
3.1.1.1 Estrutura if-else 
A instrução if-else é uma instrução de seleção dupla, porque seleciona entre duas ações 
diferentes (ou bloco de ações), diferentemente da instrução if que seleciona ou ignora uma única 
ação (ou bloco de instruções). A forma completa da instrução if-else é: 
 
if (condição) instrução; 
else instrução; 
 
Onde as ações de if e else são instruções individuais. As ações tanto de if quanto de else 
pode ser uma única instrução ou ser um bloco de instruções. A forma geral de if-else, usando blocos 
de instruções é: 
 
 
 
72 
if (condição) 
{ 
Instrução ou sequência de instruções 
} 
else 
{ 
Instrução ou sequência de instruções 
} 
 
Se a expressão condicional for verdadeira, a ação de if será executada, caso contrário, a 
ação de else será executada. Nunca ambos serão executados. 
 
Na segunda versão do jogo, iremos usar else para exibir a mensagem “O número da 
adivinhação está errado” quando o número errado é escolhido. O código pode ser visualizado na 
Figura 3.2 abaixo: 
 
 
 
Figura 3.2 - Estrutura if-else no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura if-else. 
 
Esse programa interage com o jogador e então lê um número no teclado. Usando uma 
instrução if, ele compara o número com a resposta que, nesse caso, é 7. Se 7 for inserido, a mensagem 
 
 
73 
“O número da adivinhação está certo” será exibida. Caso contrário, a cláusula else será executado, 
e a mensagem “O número da adivinhação está errado” será exibida. 
 
 
3.1.1.2 Estrutura if-else aninhada 
Um if aninhado é uma instrução if que é a ação de outro if ou else. Em Java, uma instrução 
else será sempre referente à instrução if mais próxima que estiver dentro do mesmo bloco e ainda 
não estiver associada a um else. A forma geral de if aninhada, usando blocos de instruções é: 
 
if (condição) 
{ 
if (condição) 
{ 
Instrução ou sequência de instruções 
} 
else 
{ 
Instrução ou sequência de instruções 
} 
 
} 
else 
{ 
Instrução ou sequência de instruções 
} 
 
Se a expressão condicional for verdadeira, a ação de if será executada, 
consequentemente, a instrução if-else associada a ela será executada. Caso contrário, a ação de else 
será executada. 
 
Na terceira versão do jogo, iremos usar um if-else aninhado para melhorar ainda mais o 
jogo de adivinhação. Esse acréscimo irá fornecer um palpite exibindo ou a mensagem “A resposta é 
um número menor!” caso o número seja maior que 7, ou a mensagem “A resposta é um número 
maior!” caso o número seja menor que 7. O código pode ser visualizado na Figura 3.3 abaixo: 
 
 
 
74 
public class MainActivity extends AppCompatActivity { 
 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 
 
 int adivinhacao = 5; 
 
 int resposta = 9; 
 
 
 
 if (adivinhacao == resposta){ 
 
 
 
 c.setText("O número da adivinhação está certo"); 
 
 
 
 } else { 
 
 
 
 //Este é um if-else aninhado 
 
 if (adivinhacao > resposta){ 
 
 c.setText("a resposta é um número menor"); 
 
 } else { 
 
 c.setText("a resposta é um número maior"); 
 
 } 
 
 } 
 
 
 
 } 
 
} 
 
 
75 
 Figura 3.3 - Estrutura if-else aninhado no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura if-else aninhado. 
 
Esse programa interage com o jogador e então lê um número no teclado. Usando uma 
instrução if, ele compara o número com a resposta que, nesse caso, é 7. Se 7 for inserido, a mensagem 
“O número da adivinhação está certo” será exibida. Caso contrário, else será executado. Na a 
cláusula else, será executado o if-else aninhado, o qual irá fornecer um palpite. 
 
 
3.1.2 Estrutura Switch 
A instrução switch fornece uma ramificação com vários caminhos. Logo, ela permite que 
o programa faça uma seleção entre várias alternativas. Funciona desta forma: o valor de uma 
expressão é verificado sucessivamente em uma lista de constantes. Quando uma ocorrência é 
encontrada, a sequência de instruções associada a essa ocorrência é executada. A forma geral da 
estrutura switch é: 
 
switch(expressão){ 
case constante1: 
sequência de instruções 
break; 
case constante2: 
sequência de instruções 
break; 
case constante3: 
sequência de instruções 
break; 
. 
. 
. 
default: 
sequência de instruções 
} 
 
A sequência de instruções default é executada quando nenhuma constante case coincide 
com a expressão. 
 
 
 
76 
Para demonstrar switch, iremos criar e desenvolver um jogo simples para RPGs. Neste 
jogo, o programa irá pedir ao jogador um número entre 1 e 6, que corresponde a um dado de seis 
faces, e irá informar uma classe de personagem. Assim, ao pressionar um número, o programa 
responderá exibindo uma mensagem com a face do dado escolhida e uma mensagem com a classe 
que será atribuída ao personagem do jogador no RPG. O código pode ser visualizado na Figura 3.4 
abaixo: 
 
public class MainActivity extends AppCompatActivity { 
 
 
 
 @Override 
 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 
 setContentView(R.layout.activity_main); 
 
 
 TextView c = (TextView) findViewById(R.id.campo); 
 
 
 int faceDado = 2; 
 
 
 
 switch (faceDado){ 
 
 case 1: 
 
 c.setText("O número escolhido da face do dado foi: " + faceDado); 
 
 c.setText("Wow! A classe do seu personagem é: Guerreiro"); 
 
 break; 
 
 case 2: 
 
 c.setText("O número escolhido da face do dado foi: " + faceDado); 
 
 c.setText("Wow! A classe do seu personagem é: Berserker"); 
 
 break; 
 
 case 3: 
 
 c.setText("O número escolhido da face do dado foi: " + faceDado); 
 
 c.setText("Wow! A classe do seu personagem é: Assassino"); 
 
 
 
77 
 break; 
 
 case 4: 
 
 c.setText("O número escolhido da face do dado foi: " + faceDado); 
 
 c.setText("Wow! A classe do seu personagem é: Ninja"); 
 
 break; 
 
 case 5: 
 
 c.setText("O número escolhido da face do dado foi: " + faceDado); 
 
 c.setText("Wow! A classe do seu personagem é: Arqueiro"); 
 
 break; 
 
 case 6: 
 
 c.setText("O número escolhido da face do dado foi: " + faceDado); 
 
 c.setText("Wow! A classe do seu personagem é: Mago"); 
 
 break; 
 
 default: 
 
 c.setText("What!?! Não lembra os valores de um D6?"); 
 
 } 
 } 
} 
 
Figura 3.4 - Estruturaswitch no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura switch. 
 
Tecnicamente, a instrução break é opcional. Quando encontrada dentro da sequência de 
instruções de um case, a instrução break faz o fluxo do programa sair da instrução switch e continuar 
na próxima instrução externa. 
 
 
 
 
78 
3.2 Estruturas de repetição 
3.2.1 Estrutura For 
Podemos executar repetidamente uma sequência de código criando um laço. Java 
fornece um grupo poderoso de estrutura de laço. A que examinaremos primeiro é o laço for. A forma 
mais simples do laço for é mostrada a seguir: 
 
for(inicialização; condição; interação) instrução; 
 
Para a repetição de um bloco, a forma geral é: 
 
for(inicialização; condição; interação) 
{ 
Instrução ou sequência de instruções 
} 
 
Onde: 
• A inicialização do laço define uma variável de controle de laço com um valor inicial. 
• A condição é uma expressão booleana que testa a variável de controle de laço. Se o 
resultado desse teste for verdadeiro, o laço for continuará a iterar. Se for falso, o laço 
será encerrado. 
• A interação determina como a variável de laço é alterada sempre que o laço itera. 
 
Para demonstrar for, iremos inicialmente pensar em como você irá guiar o seu 
personagem no mundo. Onde, o laço de repetição irá fazer seu o personagem andar x passos em 
uma direção ou y passos em outra direção. Por exemplo, como podemos guiar o personagem para 
“andar cinco passos para o leste”? O código pode ser visualizado na Figura 3.5 abaixo: 
 
 
 
79 
 
 
Figura 3.5 – Estrutura for no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura for. No lado esquerdo tem-se um 
celular com as palavras PASSO 0L, PASSO 1L, PASSO 2L, PASSO 3L. 
 
Nesse exemplo, passo é a variável de controle do laço. Ela é configurada com zero na 
parte de inicialização do for. No começo de cada iteração (inclusive a primeira), o teste condicional 
passo < 4 é executado. Se o resultado desse teste for verdadeiro, serão executadas as instruções 
b.setText() e l.addView(), e então a parte de iteração do laço, que aumentará passo em uma unidade. 
Esse processo continua até o teste condicional ser falso, momento em que a execução é retomada 
no final do laço. 
 
3.2.2 Estrutura While 
Outro laço Java é o while. A forma mais simples do laço while é mostrada a seguir: 
while (condição) instrução; 
 
Para a repetição de um bloco, a forma geral é: 
 
Inicialização; 
while (condição) 
{ 
 Instrução ou sequência de instruções; 
interação; 
} 
 
Onde: 
 
 
80 
• A inicialização do laço define uma variável de controle de laço com um valor inicial. 
• A condição pode ser qualquer expressão booleana válida. O laço se repete enquanto 
a condição é verdadeira. Quando a condição se torna falsa, o controle do programa 
passa para a linha imediatamente posterior ao laço. 
• Enquanto a condição for verdadeira, a instrução (ou um bloco de instruções) será 
executada. 
• A interação determina como a variável de controle do laço é alterada sempre que o 
laço itera. 
 
Para demonstrar o laço while, iremos novamente guiar o seu personagem no 
mundo. Onde, o laço de repetição irá fazer seu o personagem andar x passos em uma direção ou y 
passos em outra direção. Por exemplo, como podemos guiar o personagem para “andar quatro 
passos para o oeste”? O código pode ser visualizado na Figura 3.6 abaixo: 
 
 
Figura 3.6 – Estrutura while no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura while. No lado esquerdo tem-se 
um celular com as palavras PASSO0, PASSO1, PASSO2. 
 
 
 
81 
No exemplo, a variável passo é inicializado com 0. A cada passagem pelo laço, a 
mensagem é exibida e a variável passo é incrementada. Esse processo continuará até que o teste da 
expressão condicional seja verdadeiro, ou seja, até que o valor da variável passo seja menor que 3. 
Quando o teste da expressão condicional se tornar falso, o controle do programa irá passa para a 
linha imediatamente posterior ao laço. 
Como no laço for, while verifica a expressão condicional no início do laço, ou seja, o 
código do laço pode não ser executado. Isso elimina a necessidade de execução de um teste separado 
do laço. 
 
3.2.3 Estrutura Do-While 
O último dos laços Java é o do-while. Diferentemente dos laços for e while, em que a 
condição é testada no início do laço, o laço do-while verifica sua condição no fim do laço. Ou seja, um 
laço do-while será sempre executado pelo menos uma vez. A forma mais simples do laço do-while é 
mostrada a seguir: 
 
do instrução; 
while (condição); 
 
Para a repetição de um bloco, a forma geral é: 
 
Inicialização; 
do { 
Instrução ou sequência de instruções; 
interação; 
} while(condição); 
 
Onde: 
• A inicialização do laço define uma variável de controle de laço com um valor inicial. 
• A instrução (ou um bloco de instruções) será executada. 
• A interação determina como a variável de controle do laço é alterada sempre que o 
laço itera. 
 
 
82 
• A condição pode ser qualquer expressão booleana válida. O laço se repete enquanto 
a condição é verdadeira. Quando a condição se torna falsa, o controle do programa 
passa para a linha imediatamente posterior ao laço. 
 
Embora as chaves não sejam necessárias quando há apenas uma instrução presente, elas 
são usadas com frequência para melhorar a legibilidade da estrutura do-while, evitando, assim, 
confusão com while. o Laço do-while é executado enquanto a expressão condicional for verdadeira. 
Para demonstrar o laço do-while, iremos novamente guiar o seu personagem no 
mundo. Onde, o laço de repetição irá fazer seu o personagem andar x passos em uma direção ou y 
passos em outra direção. Por exemplo, como podemos guiar o personagem para “voltar três passos 
para o leste”? O código pode ser visualizado na Figura 3.7 abaixo: 
 
Figura 3.7 – Estrutura do-while no Android Studio. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando a estrutura do-while. No lado esquerdo tem-
se um celular com as palavras PASSO0, PASSO1, PASSO2. 
 
No exemplo, a variável passo é inicializado com 0. A cada passagem pelo laço, a 
mensagem é exibida e a variável passo é incrementada. Esse processo continuará até que o teste da 
expressão condicional seja verdadeiro, ou seja até que o valor da variável passo seja menor que 3. 
Quando o teste da expressão condicional se tornar falso, o controle do programa irá passa para a 
linha imediatamente posterior ao laço. 
Diferente da estrutura for e da estrutura while, o laço do-while verifica a expressão 
condicional no fim do laço. Ou seja, um laço do-while será sempre executado pelo menos uma vez. 
 
 
83 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• As estruturas de controle condicional. 
• A forma completa da estrutura if. 
• Usar a instrução if. 
• A forma completa da estrutura switch. 
• Usar a instrução switch. 
• As estruturas de repetição. 
• A forma completa da estrutura for. 
• Usar a instrução for. 
• A forma completa da estrutura while. 
• Usar a instrução while. 
• A forma completa da estrutura do-while. 
• Usar a instrução do-while. 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
Agora, o próximo passo é mergulhar na competência 4, que trata da utilização de listas e 
arrays. Vamos juntos? 
 
 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a nossa primeira videoaula competência. 
 
 
84 
4.Competência 04 | Formatar uma Activity para utilização de Arrays 
Caro estudante, vamos iniciar a quarta competência! Nesta competência,o assunto “tipos 
de dados” será retomado, e você irá conhecer o tipo de dado array. Em seguida, você vai entender e 
criar um array unidimensionais. E por fim, você vai entender e criar um array multidimensionais. 
Vamos continuar! 
4.1 Arrays 
Um array é um tipo de dado formado por um conjunto de variáveis do mesmo tipo, 
referenciadas por um nome comum. Em Java, os arrays podem ter uma ou mais dimensões. Os arrays 
são usados para diversos fins, porque oferecem um meio conveniente de agrupar variáveis 
relacionadas. Por exemplo, imagine que durante o desenvolvimento de um programa fosse preciso 
declarar variáveis para armazenar um registro da temperatura máxima diária durante um mês, ou 
seja, você teria que declarar tempmax01, tempmax02, tempmax03, tempmax04, …. , tempmax30 e 
tempmax31. Nesse caso, para resolver este problema, você pode usar um array para armazenar o 
registro diário da temperatura máxima de um mês. 
A principal vantagem de um array é que ele organiza os dados de tal forma que é fácil 
tratá-los. Por exemplo, com um array contendo o registro diário da temperatura máxima de um mês, 
será fácil calcular a temperatura média percorrendo-o. 
 
 
 
 
 
 
 Você sabia que um vetor é uma estrutura de dados formada por um conjunto de 
elementos de mesmo tipo. Em programação, os vetores são chamados de arrays. 
 
 
85 
4.1.1 Arrays Unidimensionais 
Um array unidimensional é uma lista de variáveis relacionadas. Essas listas são comuns 
em programação. Para declarar um array unidimensional, você pode usar esta forma geral: 
 
tipo nome-array[ ] = new tipo[tamanho] 
onde: 
• tipo declara o tipo do elemento do array. O tipo de elemento determina o tipo de 
dado de cada elemento contido no array. 
• nome-array determinará o nome que o array conterá. 
• tamanho determinará o número de elementos que o array conterá. 
 
Em Java, a criação de um array se dá em duas etapas, primeiro você declara uma variável 
de referência de array. Depois, aloca memória para o array, atribuindo uma referência dessa memória 
a variável de array. 
Para demonstrar o array unidimensional, iremos inicialmente pensar como armazenar 
um conjunto de palavras secretas para um jogo de advinhação simples, o jogo da forca. Por exemplo, 
como podemos criar um array String de 15 elementos e o vincular a uma variável de referência de 
array chamado palavra. A linha a seguir cria um array String de 15 elementos e o vincula a palavra: 
String palavra[] = new String [15]; 
A variável palavra contém uma referência a memória alocada por new. Essa memória é 
suficientemente grande para conter 15 elementos do tipo String. 
Um elemento individual de um array é acessado com o uso de um índice. Um índice 
descreve a posição de um elemento dentro de um array. Em Java, todos os arrays tem zero como o 
índice de seu primeiro elemento. Já que a variável palavra tem 15 elementos, ela tem valores de 
índice que vão de 0 a 14. Para indexar um array, devemos especificar o número do elemento 
desejado, inserido em colchetes. Portanto o primeiro elemento de palavra é palavra[0] e o último é 
palavra[14]. 
 
 
 
86 
Por exemplo, o programa a seguir (Figura 4.1) carrega palavra com 15 elementos 
(palavras secretas): 
 
 
Figura 4.1 - Array unidimensional. Neste exemplo o array carrega palavra com 15 elementos (palavras secretas). 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando array unidimensional. 
 
 
 
 
 
 
87 
Conceitualmente, o array palavra tem a seguinte aparência (Figura 4.2): 
 
Figura 4.2 - Aparência conceitual do array palavra. 
Fonte: o autor 
Descrição da imagem: apresenta um retângulo contendo outros quadrados, cada um representando o elemento 
individual de um array unidimensional. Cada quadrado contendo as seguintes palavras: Deadpool, Wolverine, Black 
Widow, Iroman, ..., Gamora, Death, Kratos, Yoda e Drácula. Em seguida temos abaixo de cada quadrado textos 
descritivos do índice da posição de cada elemento dentro de um array. 
 
4.1.2 Arrays Multidimensionais 
O array unidimensional é o mais comum em programação, porém os arrays 
multidimensionais (arrays de duas ou mais dimensões) não são raros. Em Java, o array 
multidimensional é um array composto por arrays. 
4.1.2.1 Arrays Bidimensionais 
A forma mais simples de array multidimensional é o array bidimensional. Para declarar 
um array bidimensional, você pode usar esta forma geral: 
tipo nome-array[ ] [ ] = new tipo[tamanho] [tamanho] 
 
Diferentemente de outras linguagens de programação, que usam vírgulas para separar as 
dimensões do array, Java insere cada dimensão em seu próprio conjunto de colchetes. 
Para demonstrar o array bidimensional, iremos inicialmente pensar como criar um 
tabuleiro para o desenvolvimento do jogo da velha. Por exemplo, como podemos criar um array int 
de 9 elementos e o vincular a uma variável de referência de array chamado tabuleiro. Por exemplo, 
o programa a seguir (Figura 4.3) cria um array int de 9 elementos e o vincula a tabuleiro: 
 
 
88 
 
Figura 4.3 - Array bidimensional. Neste exemplo o array carrega tabuleiro com 9 elementos. 
Fonte: o autor 
Descrição da imagem: apresenta um fundo preto com o código utilizando array bidimensional. 
 
Neste exemplo, tabuleiro[0][0] terá o valor 1, tabuleiro[0][1] terá o valor 2, tabuleiro[0][2] 
terá o valor 3, e assim por diante. O valor de tabuleiro[2][2] será 9. Conceitualmente, o array ficará 
parecido como mostrado na Figura 4.4: 
 
 
89 
 
 
Figura 4.4 - Visão conceitual do array tabuleiro. 
Fonte: o autor 
Descrição da imagem: apresenta um retângulo contendo outros quadrados, cada um representando o elemento 
individual de um array bidimensional. Cada quadrado contendo os seguintes textos: 1, 2, 3, 4, 5, 6, 7, 8 e 9. Em seguida 
temos acima de cada quadrado textos descritivos do índice direito, no lado esquerdo de cada quadrado temos textos 
descritivos do índice esquerdo, e no lado direito temos o texto descritivos do índice da posição Tabuleiro [1][2] e o valor 
do elemento. 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• Entender e criar arrays. 
• A forma completa de um array unidimensional. 
• Criar arrays unidimensional. 
• A forma completa de um array bidimensional. 
• Criar arrays bidimensional. 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
Agora, o próximo passo é mergulhar na competência 5, que trata da utilização de Activity 
em detalhes. Vamos juntos? 
 
 
 
90 
5. Competência 05 | Conhecer o Activity em detalhes 
Caro estudante, vamos iniciar a quinta competência! Nesta competência você vai 
aprender como criar um novo projeto com Activity. Em seguida, será mostrado a descrição do 
conceito da classe Activity e o funcionamento do ciclo de vida de uma Activity. E por fim, será 
mostrado como realizar a navegabilidade entre Activity, e será visto como realizar navegabilidade 
simples de uma Activity para outra e a navegação entre telas com passagem de parâmetros. 
Vamos Continuar! 
 
5.1 Criando um novo projeto com Activity 
A competência 1 introduziu os conceitos básicos de um sistema operacional móvel, e 
ensinou a criar e a configurar o ambiente de desenvolvimento, o Android Studio. Você lembra? Na 
construção desse projeto criado por você foram gerados os arquivos AndroidManifest.xml, 
MainActivity.java e o activity_main.xml. A declaração da sintaxe da nova Activity ocorre no arquivo 
AndroidManifest.xml com a execução da Activity sendo realizada no arquivo MainActivity.java 
através da seguinte sintaxe <activity android:name=".MainActivity"/>. O código do 
AndroidManifest.xml do novo projeto com Activity pode ser visualizado na Figura 5.1 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<manifestxmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco"> 
 
 <application 
 android:allowBackup="true" 
 android:icon="@mipmap/ic_launcher" 
 android:label="@string/app_name" 
 android:roundIcon="@mipmap/ic_launcher_round" 
 android:supportsRtl="true" 
 android:theme="@style/AppTheme"> 
 <activity android:name=".MainActivity"/> 
 </application> 
 
</manifest> 
Figura 5.1 – Arquivo AndroidManifest.xml do novo projeto com Activity 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml possuindo 
as principais declarações da aplicação e a declaração da activity no novo projeto. 
 
 
 
91 
No arquivo MainActivity.java é executado o método setContentView(view) para 
especificar a View que contém os elementos de layout com acesso ao arquivo de gerenciamento de 
layout activity_main.xml. O código do arquivo MainActivity.java pode ser visualizado na Figura 5.2 
abaixo: 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
 
public class MainActivity extends AppCompatActivity { 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 } 
} 
 
Figura 5.2 – Arquivo MainActivity.java 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo o 
acesso ao arquivo de layout com o nome activity_main. 
 
O arquivo activity_main.xml é responsável por configurar o gerenciador de layout, ou 
classe ViewGroup, além de configurar os elementos da classe Widgets. O código do activity_main.xml 
do novo projeto com Activity pode ser visualizado na Figura 5.3 abaixo: 
 
 <?xml version="1.0" encoding="utf-8"?> 
 
<androidx.constraintlayout.widget.ConstraintLayout 
xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:app="http://schemas.android.com/apk/res-auto" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="Hello World" 
 app:layout_constraintBottom_toBottomOf="parent" 
 app:layout_constraintLeft_toLeftOf="parent" 
 app:layout_constraintRight_toRightOf="parent" 
 app:layout_constraintTop_toTopOf="parent" /> 
 
</androidx.constraintlayout.widget.ConstraintLayout 
 
 
92 
 
Figura 5.3 – Arquivo activity_main.xml 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml possuindo a 
declaração do layout ConstraintLayout com o componente de texto chamado TextView. 
 
Até aqui você aprendeu como criar um novo projeto com declaração da classe Activity. 
Nas seções a seguir, você vai aprender sobre os conceitos da classe Activity, ciclo de vida de uma 
Activity e a navegabilidade entre Activity. 
 
5.2 Conceito de Activity 
A classe Activity é responsável por controlar os eventos da tela dos aplicativos e definir 
qual componente visual será responsável pela interface gráfica do usuário. Mas o que é uma classe 
Activity? A classe Activity deve herdar da classe Java android.app.Activity ou alguma subclasse Java 
desta, essa classe Activity é representada por alguma tela da aplicação, assim como é responsável por 
tratar todos os eventos gerados nessa tela, por exemplo, os cliques de botão, seleção de checkbox, 
cliques no menu e mudanças de tela. 
Essa classe Activity possui implementado o método onCreate(bundle), responsável por 
realizar a inicialização dos elementos necessários para exibir uma tela do aplicativo. Esse método 
onCreate(bundle) é executado no método setContentView(view), responsável por configurar o layout 
XML (Extensible Markup Language) que contém os elementos da tela, tais como as suas imagens e 
botões. Por fim, cada Activity criada deve ser declarada no arquivo AndroidManifest.xml, como será 
mostrado nos exemplos abaixo. O código do AndroidManifest.xml com MainActivity pode ser 
visualizado na Figura 5.4 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco"> 
 
 <application> 
 <activity android:name=".MainActivity"/> 
 
 </application> 
 
</manifest> 
 
Figura 5.4 – Arquivo AndroidManifest.xml no Android Studio com MainActivity 
 
 
93 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml possuindo a 
declaração da Activity com o nome MainActivity. 
 
Nessa configuração, esse “.” (ponto) antes do nome da sua Activity indica que o pacote 
da classe Java é relativo ao pacote do projeto. Caso esse pacote estivesse em um pacote diferente, o 
nome desse pacote deveria ser especificado, por exemplo, br.com.cursoandroid.hello.activity. O 
código do AndroidManifest.xml com activity.MinhaClasseActivity pode ser visualizado na Figura 5.5 
abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco"> 
 
 <application> 
 <activity android:name=".activity.MinhaClasseActivity"/> 
 </application> 
 
</manifest> 
 
Figura 5.5 – Arquivo AndroidManifest.xml no Android Studio com activity.MinhaClasseActivity 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml possuindo a 
declaração da Activity com o nome MinhaClasseActivity na pasta Activity. 
 
Se achar necessário, pode definir o nome completo da classe Java, pois não é considerado 
uma declaração errada. O código do AndroidManifest.xml com a declaração da classe Java completa 
br.com.cursoandroid.hello.activity.MinhaClasseActivity pode ser visualizado na Figura 5.6 abaixo: 
 
xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco"> 
 
 <application> 
 <activity android:name=" br.com.cursoandroid.hello.activity.MinhaClasseActivity 
"/> 
 </application> 
 
</manifest> 
 
Figura 5.6 – Arquivo AndroidManifest.xml no Android Studio com 
br.com.cursoandroid.hello.activity.MinhaClasseActivity 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml possuindo a 
declaração da Activity com o nome da classe br.com.cursoandroid.hello.activity.MinhaClasseActivity. 
 
 
94 
Na prática podemos relacionar a palavra “Activity” à palavra “tela”. Diante desse 
raciocínio, caso seja necessário criar uma nova tela do seu projeto, você deverá criar uma nova 
Activity, e essa classe deverá ser declarada no arquivo AndroidManifest.xml. Esse arquivo é 
responsável por controlar os eventos e elementos da tela, que é especificada no método 
setContentView(view), que já vimos anteriormente. 
Por fim, lembre-se de configurar corretamente o nome da classe Activity, pois o 
compilador é case sensitive, ou seja, ele diferencia as letras maiúsculas das minúsculas, dessa forma 
para ele “MinhaActivity” é diferente de “minhaActivity”. Para ter certeza de que o nome e o pacote 
foram especificados corretamente, segure a tecla ctrl (control) do seu teclado e passe o mouse em 
cima do nome da sua Activity, se o texto ficar selecionado, você pode clicar para abrir o código-fonte 
da classe. Se o editor abrir, essa execução está correta. 
 
5.3 Ciclo de vida de uma Activity 
Na execução do ciclo de vidade uma Activity é importante entender em qual estado ele 
se encontra e como você pode controlar o comportamento da sua aplicação. Tenha em mente o 
seguinte conceito: quem cuida da execução do fluxo do ciclo de vida é o sistema operacional Android, 
mas você pode customizar esses estados, por exemplo, criando outros estados como: executando, 
temporariamente interrompida em segundo plano e completamente destruída. 
Imagine que você tenha desenvolvido um jogo espetacular para Android e enquanto o 
usuário está jogando ele receba uma ligação, então o que vai acontecer com o jogo? Bom, o sistema 
operacional vai interromper o jogo temporariamente e colocá-lo em segundo plano para que o 
usuário possa atender a ligação. Depois que ligação for encerrada a grande pergunta é: o que deve 
acontecer com o jogo? as informações do jogo serão salvas? Bom, isso vai depender das 
especificações realizada por você. O Android fornece toda a estrutura necessária para isso, basta 
você entender o ciclo de vida da Activity. 
Mas o que acontecerá quando for executado diversos aplicativos no Android, como o 
browser, a tela inicial (Home) e a tela para discar um número? Bem, cada execução possui uma 
Activity inicial sendo inserido no topo de uma pilha, chamada de pilha de atividades. Assim, nessa 
pilha de atividade, sempre que uma nova Activity é inserida no topo da pilha, a Activity anterior que 
 
 
95 
estava em execução fica logo abaixo da nova, ou seja, a Activity que está no topo da pilha é a Activity 
em execução no momento, as demais podem estar executando no segundo plano, estar no estado 
pausado ou totalmente paradas. 
Agora você vai aprender como utilizar na prática o ciclo de vida de uma Activity. Vamos 
começa? Alguns métodos da classe Activity pode ser utilizado para controlar o estado da tela. Dentre 
eles, existem o método onCreate(), que é responsável por inicializar a Activity e iniciar o seu ciclo de 
vida. Além desse método, os outros métodos importantes do ciclo de vida são onStart(), onRestart(), 
onPause(), onStop() e onDestroy(). A Figura 5.7, abaixo, mostra o fluxo do ciclo de vida de uma Activity 
e seus possíveis estados. 
 
 
96 
 
Figura 5.7 – Ciclo de vida de uma activity 
Fonte: o autor 
Descrição: a imagem apresenta todas as fases do ciclo de vida de uma aplicação Android. Quando uma activity é 
iniciada o seu ciclo de vida tem início e o método onCreate é executado, em seguida é executado o onStart e o 
onResume. Caso outra activity seja iniciada, a atual é pausada, então, é executado o método onPause. Se a activity 
anterior voltar a executar, ela chamará novamente o onResume, caso contrário, é chamado o método onStop e em 
seguida pode ser chamado o onDestroy, que encerra a activity ou pode ser chamado o onRestart , se a Activity voltar a 
executar ou caso ela tenha ido para segundo plano no onStop e encerrada pelo SO. No caso dela voltar a ser exibida, o 
método onCreate é chamado novamente. 
 
 
 
97 
Preste atenção nesse momento, pois agora você cai aprender sobre cada um dos métodos 
que se encontram no ciclo de vida de uma Activity na Tabela 5.1, abaixo. É importante que você leia 
a descrição do método e acompanhe o fluxograma da Figura 5.7, acima. 
 
Método Descrição 
onCreate(bundle) 
 
Esse método é considerado obrigatório no ciclo de vida da Activity, 
por isso deve ser iniciado apenas uma vez. O objetivo desse 
método é realizar a inicialização necessária para executar um 
aplicativo. Neste método, deve-se criar uma view e chamar o 
método setContentView(view) para configurar os elementos que 
serão exibidos no layout da tela dos usuários. Após a execução do 
onCreate(bundle) é chamado o método onStart. 
onStart() 
 
Esse método é chamado quando uma Activity está criada, assim 
como a sua view, ou seja, após o método onCreate(bundle) ocorre 
uma execução quando a activity está visível ao usuário. Como 
mostrado no fluxo acima, esse método também é chamado depois 
dos métodos onRestart ou onCreate, dependendo assim do 
estado atual o aplicativo. 
onRestart() 
 
Esse método é chamado quando uma Activity é parada 
temporariamente e esteja sendo iniciada novamente, então uma 
aplicação em Android chama o método onRestart que logo após 
executa o método onStart. 
onResume() 
 
Esse método é chamado quando a Activity principal já está 
executando e está interagindo com o usuário. Além disso, quando 
esse método está sendo executado, o usuário está vendo a tela. 
Por isso, esse método é frequentemente utilizado para consultar 
o banco de dados e atualizar as informações da tela do aplicativo. 
 
onPause() 
 
 
Esse método é chamado quando a tela da Activity fecha. Isso pode 
acontecer quando o usuário pressiona o botão voltar para sair do 
 
 
98 
aplicativo. Outra maneira ocorre quando você recebe uma ligação 
telefônica. Nesse momento, o método é chamado para salvar o 
estado do aplicativo, para posteriormente, quando essa activity 
voltar a executar, tudo possa ser recuperado no método 
onResume. 
onStop() 
 
Esse método é chamado quando a Activity está sendo encerrada e 
não está mais visível para o usuário. Depois de parada, a Activity 
pode ser reiniciada. Caso isso ocorra, o método onRestart realiza 
a reinicialização da activity. Caso essa Activity fique muito tempo 
parada em segundo plano e o sistema operacional Android precise 
liberar a memória, o método onDestroy pode ser 
automaticamente chamado para remover completamente 
Activity. 
onDestroy() 
 
Esse método encerra a execução de uma Activity. Com isso, esse 
método pode ser chamado automaticamente pelo sistema 
operacional para liberar recursos alocados pela Activity como 
valores de atributos e demais recursos. Após o método onDestroy 
ser executado, a Activity será removida completamente e o seu 
processo no sistema operacional será completamente encerrado. 
 
Tabela 5.1 – Ciclo de vida de uma aplicação Android 
Fonte: o autor 
Descrição da imagem: a descrição dos métodos do ciclo de vida de uma Activity e seus respectivos conceitos. 
 
Depois de mostrar o ciclo de vida de uma Activity e descrever o funcionamento dos seus 
métodos. Você deve ter ficado curioso para entender a execução desse ciclo de vida em código! Bem, 
a seguir será mostrado um exemplo do código de uma activity que implementa os métodos: 
onCreate(bundle), onStart(), onRestart(), onResume(), onPause(), onStop() e onDestroy() do ciclo de 
vida que mostramos anteriormente. 
Recomendo seguir esse exemplo e implementar todos os métodos. Dessa maneira, você 
pode fazer diversos testes. Como exemplo, realizar ligação para o seu celular, encerrar uma aplicação 
 
 
99 
e acompanhar esses métodos chamados, através das mensagens de log que serão exibidas na janela 
do LogCat. Para testar isso, você pode criar um projeto Android e executá-lo usando o emulador do 
Android ou diretamente no seu próprio celular. O código do MainActivity com a descrição do Logcat 
pode ser visualizado na Figura 5.8 abaixo: 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.util.Log; 
import android.widget.TextView; 
 
public class MainActivity extends AppCompatActivity { 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 
 Log.i(getLocalClassName(), "onCreate()"); 
 
 TextView olaMundo = new TextView(this); 
 olaMundo.setText("Olá mundo! :)"); 
 setContentView(olaMundo); 
 setContentView(R.layout.activity_main); 
 } 
 @Override 
 protected void onStart(){ 
 super.onStart(); 
 Log.i(getLocalClassName(), "onStart()"); 
 } 
 @Override 
 protected void onRestart(){ 
 super.onRestart(); 
 Log.i(getLocalClassName(), "onRestart()"); 
 } 
 @Override 
 protectedvoid onResume(){ 
 super.onResume(); 
 Log.i(getLocalClassName(), "onResume()"); 
 } 
 @Override 
 protected void onPause(){ 
 super.onPause(); 
 Log.i(getLocalClassName(), "onPause()"); 
 } 
 @Override 
 protected void onStop(){ 
 super.onStop(); 
 Log.i(getLocalClassName(), "onStop()"); 
 } 
 @Override 
 protected void onDestroy(){ 
 super.onDestroy(); 
 Log.i(getLocalClassName(), "onDestroy()"); 
 } 
} 
 
 
100 
 
Figura 5.8 – estrutura do logcat no arquivo MainActivity.java do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
declaração dos métodos onCreate, onStart, onRestart, onResume, onPause, onStop e onDestroy. 
 
Na execução do código mostrada na Figura 1.8, acima, o Android Studio mostra no LogCat 
a descrição dos métodos onCreate(), onStart() e onResume(). A execução do LogCat do Android Studio 
pode ser visualizada na Figura 5.9 abaixo: 
 
Figura 5.9 – descrição de logs no LogCat do Android Studio. 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com a tela de logCat com logs mostrando a descrição do 
Logcat com os métodos onCreate(), onStart() e onResume() que foram chamados a partir da exibição de uma Activity 
 
Entender o ciclo de vida de uma Activity é fundamental para você dominar o 
desenvolvimento de aplicações Android. O conhecimento desses métodos é considerado importante 
principalmente quando você está jogando no seu celular. A seguir será mostrado dois exemplos do 
ciclo de vida de uma Activity no momento da execução do jogo. 
Imagine que você está jogando e ocorre uma interrupção por receber uma ligação, ou a 
bateria do seu celular acaba quando você estiver jogando. Nessas situações, o ideal seria que o jogo 
fosse salvo ao ser interrompido pela falta de bateria ou pausado no momento da ligação, para assim 
o usuário não ser prejudicado com interrupções externas. 
 
 
 
101 
5.4 Navegabilidade entre Activity 
Até esse momento abordamos conceitos do que significa uma Activity, para que serve 
uma Activity e o funcionamento do ciclo de vida da Activity. Agora chegou o momento de aprender 
como criar uma Activity, assim como a navegabilidade de uma para outra. Essas activities são 
representadas por telas. Diante disso, os aplicativos utilizam um conjunto de telas diferentes, então 
para cada tela desse aplicativo será criado uma nova Activity. 
A navegabilidade entre activities pode ocorrer utilizando os métodos startActivity(intent) 
ou startActivityForResult(intent, código). Ambos os métodos utilizam uma instância da classe Intent. 
Essa classe Intent significa intenção, nesse caso a intenção é mudar de Activity, ou seja, a 
navegabilidade da transição da tela de origem para uma tela de destino com envio de informação 
entre elas. 
Mas como ocorre a execução desses dois métodos? Bem, o método startActivity é 
responsável pela mudança de uma tela de origem para uma tela de destino, porém a navegabilidade 
entre activities não vincula relação com a Activity anterior. A Figura 5.10, abaixo, mostra a 
navegabilidade do método startActivity(intent). Com isso, a informação da Activity de origem e 
enviada para Activity de destino sem retorno de informação. 
 
Figura 5.10 – navegabilidade do método startActivity(intent). 
Fonte: o autor 
Descrição da imagem: A imagem apresenta uma caixa azul representando a tela azul com a Activity A e uma caixa 
vermelha representando a tela vermelha com a Activity B. Entre as telas azul e vermelha possui uma seta azul com a 
navegabilidade do método startActivity(intent) que realiza a transição entre a tela azul (Activity A) e a tela vermelha 
(Activity B). 
 
Já o método startActivityForResult é responsável pela mudança de uma tela de origem 
para uma tela de destino, porém a navegabilidade entre activities retorna informações da tela de 
 
 
102 
destino para a tela de origem. A Figura 5.11, abaixo, mostra a navegabilidade do método 
startActivityForResult. Com isso, a informação da Activity de origem (Activity A) é enviada para 
Activity de destino (Activity B). Em seguida, a Activity de destino (Activity B) faz o tratamento do 
parâmetro recebido e retorna à informação para Activity de origem. 
 
 
Figura 5.11 – navegabilidade do método startActivityForResult(). 
Fonte: o autor 
Descrição da imagem: A imagem apresenta uma caixa azul representando a tela azul com a Activity A e uma caixa 
vermelha representando a tela vermelha com a Activity B. Entre as telas azul e vermelha possui uma seta com a 
navegabilidade do método startActivityForResult() que realiza a transição entre a tela azul e a tela vermelha e outra seta 
azul com o retorno da tela vermelha para azul. 
 
 
 
5.5 Navegabilidade Simples de uma Activity para outra 
A navegação simples de uma Activity para outra necessita de duas telas. Mas como isso 
ocorre a nível de código? O código da Figura 5.12, abaixo, mostra como a partir de um clique é 
possível abrir uma nova tela. Para isso ocorrer é necessário criar uma segunda Activity como 
mostrado na Figura 5.13, abaixo. Nesse código será necessário criar duas activities para navegar de 
uma tela para outra. A primeira Activity será chamada de MainActivity e a segunda Activity de 
SegundaTela. 
 
package com.example.eadpernambuco; 
 
import androidx.appcompat.app.AppCompatActivity; 
 
import android.content.Intent; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.Button; 
 
public class MainActivity extends AppCompatActivity implements 
 
 
103 
View.OnClickListener { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 
 Button olaMundo = new Button(this); 
 olaMundo.setText("EAD Pernambuco! :)"); 
 olaMundo.setOnClickListener(this); 
 setContentView(olaMundo); 
 } 
 
 public void onClick(View v) { 
 Intent tela2 = new Intent(this, SegundaTela.class); 
 startActivity(tela2); } 
} 
 
Figura 5.12 – Arquivo MainActivity.java com navegabilidade simples de uma Activity 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java com 
navegabilidade simples de uma Activity para outra, por meio da classe MainActivity.java que realiza a navegabilidade 
entre a tela de origem representada por MainActivity para a tela de destino representada por SegundaTela usando a 
classe intent. 
 
 
package com.example.eadpernambuco; 
 
import android.app.Activity; 
import android.os.Bundle; 
import android.widget.TextView; 
 
public class SegundaTela extends Activity { 
 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 TextView tela2 = new TextView(this); 
 tela2.setText("Bem vindo a SegundaTela."); 
 setContentView(tela2); } 
 
} 
 
Figura 5.13 – Arquivo SeguntaTela.java com navegabilidade simples de uma Activity 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo SeguntaTela.java com 
navegabilidade simples de uma Activity para outra, por meio da classe SegundaTela que mostra o resultado da tela de 
destino representada por SegundaTela e mostrada na mensagem ("Bem vindo a SegundaTela."). 
 
Depois de criar as activities dessas classes é necessário criar a declaração dessas activities 
no AndroidManifest.xml. Mas ocorre algum erro caso não declare essas activities no 
AndroidManifest.xml? Sim, a criação da nova Activity(tela) deve ser declarada no AndroidManisfest. 
 
 
104 
Caso você não realize essa declaração no AndroidManifest, a seguinte mensagem de erro será exibida 
no seu LogCat. A descrição do erro no Logcatpode ser visualizada na Figura 5.14 abaixo: 
 
 
Figura 5.14 – Descrição do erro no Logcat 
Fonte: Android Studio 3.5.2 
 
Descrição da imagem: a imagem apresenta um fundo preto com a tela de logCat com log de erro mostrando a seguinte 
mensagem “você declarou essa activity no seu AndroidManifest.xml?”. 
 
 
Perceba nessa mensagem de exceção fatal a explicação do erro em inglês, traduzindo: 
“você declarou essa Activity no seu AndroidManifest.xml?”. Para resolve esse problema adicione as 
seguintes linhas no seu AndroidManifest.xml <activity android:name=".MainActivity"/>. O código do 
MainActivity com a declaração da Activity pode ser visualizado na Figura 5.15 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco"> 
 
 <application 
 android:allowBackup="true" 
 android:icon="@mipmap/ic_launcher" 
 android:label="@string/app_name" 
 android:roundIcon="@mipmap/ic_launcher_round" 
 android:supportsRtl="true" 
 android:theme="@style/AppTheme"> 
 <activity android:name=".MainActivity"> 
 <intent-filter> 
 <action android:name="android.intent.action.MAIN" /> 
 
 <category android:name="android.intent.category.LAUNCHER" /> 
 </intent-filter> 
 </activity> 
 <activity android:name=".SegundaTela"/> 
 
 </application> 
</manifest> 
 
Figura 5.15 - Arquivo AndroidManifest.xml com a declaração da Activity 
Fonte: Android Studio 3.5.2 
 
 
105 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml com a 
declaração da Activity com o nome MainActivity. 
 
Depois da atualização dessas duas activities no AndroidManifest.xml o erro anterior foi 
resolvido e ocorreu a navegabilidade da primeira tela (Figura 5.16) para a segunda tela (Figura 5.17). 
 
 
 
Figura 5.16 – tela da classe MainActivity.java no android Studio 
Fonte: o autor 
Descrição da imagem: a imagem apresenta uma tela do celular da classe MainActivity.java mostrado na parte superior 
da tela a mensagem EADPrnambucoPDM, na barra inferior da tela três botões do celular com símbolos da seta, bola e 
quadrado e na parte do meio da tela a mensagem "EAD Pernambuco! :)”. 
 
 
106 
 
 
Figura 5.17 - tela da classe SegundaTela.java no android Studio 
Fonte: o autor 
Descrição da imagem: a imagem apresenta uma tela do celular da classe SegundaTela.java mostrado na parte superior 
da tela a mensagem EADPernambucoPDM, na barra inferior da tela três botões do celular com símbolos da seta, bola e 
quadrado e na parte do meio da tela a mensagem ("Bem vindo a SegundaTela."). 
 
5.6 Navegação entre telas com passagem de parâmetros 
Agora você vai aprender sobre como funciona a navegação entre telas com passagem de 
parâmetros. Mas como ocorre o envio de uma ou mais informações da primeira tela para a segunda 
tela? Nessa navegação é utilizada a classe Bundle que é semelhante a uma HashTable (estrutura de 
dados do tipo chave com valor). Essa classe utiliza o método putString(chave, valor) para configurar 
as informações com formato de texto para a segunda tela. O código do MainActivity com a 
navegabilidade entre telas com passagem de parâmetro pode ser visualizado na Figura 5.18 abaixo: 
 
package com.example.eadpernambuco; 
 
import androidx.appcompat.app.AppCompatActivity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.view.View; 
 
 
 
107 
public class MainActivity extends AppCompatActivity implements 
View.OnClickListener { 
 
 public void onClick(View v) { 
 Intent tela2 = new Intent(this, SegundaTela.class); 
 Bundle informacoes = new Bundle(); 
 
 informacoes.putString("disciplina", "Programação de desenvolvimento de 
sistemas"); 
 informacoes.putString("professor", "Danilo "); 
 tela2.putExtras(informacoes); 
 startActivity(tela2); 
 } 
} 
 
Figura 5.18 - Arquivo MainActivity.java com navegabilidade entre telas com passagem de parâmetros 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java com 
navegabilidade entre telas com passagem de parâmetros, por meio do método putString que configurar o formato de 
texto para a segunda tela. 
 
Nesse exemplo anterior utilizamos o método putString, porém a classe Bundle possui 
outras opções de tipo primitivo como putInt, putChar, putBoolean, entre outros. Até esse momento 
você aprendeu como enviar as informações entre as telas, em seguida você vai aprender como 
conseguir informação da segunda tela. O código da SegundaTela com a navegabilidade entre telas 
com passagem de parâmetro pode ser visualizado na Figura 5.19 abaixo: 
package com.example.eadpernambuco; 
 
import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.widget.TextView; 
 
 
public class SegundaTela extends Activity { 
 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 TextView tela2 = new TextView(this); 
 Intent it = getIntent(); String disciplina = "", professor = ""; 
 if(it != null){ 
 Bundle informacoes = it.getExtras(); 
 if(informacoes != null){ 
 disciplina = informacoes.getString("disciplina"); 
 professor = informacoes.getString("professor"); 
 } 
 } 
 tela2.setText("Bem vindo " + disciplina + " " + professor); 
 setContentView(tela2); } 
} 
 
Figura 5.19 – Arquivo SegundaTela.java com navegabilidade entre telas com passagem de parâmetros 
 
 
108 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo SegundaTela.java com 
navegabilidade entre telas com passagem de parâmetros, por meio do parâmetro do startActivity e do método 
onCreate da segunda tela retornamos essa mesma intent da tela2 e extraímos as informações relacionadas a 
“disciplina” e “professor”. 
 
No método onClick da primeira tela (MainActivity) executamos a Intent (chamado tela2) 
com as informações que desejamos transferir para segunda tela. Como parâmetro do startActivity e 
no método onCreate da segunda tela (SegundaTela) retornamos essa mesma Intent(tela2) e 
extraímos as informações relacionadas as chaves “disciplina” e “professor”. 
Em linguagem de programação existem diversas maneiras de realizar a mesma 
funcionalidade, isso depende do seu conhecimento e da sua flexibilidade sobre a lógica utilizada. 
Diante disso, você pode realizar a passagem de informação entre as telas da seguinte maneira. O 
código com a navegabilidade entre telas com passagem de parâmetro utilizando putExtra pode ser 
visualizado na Figura 5.20 abaixo: 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.content.Intent; 
 
import android.view.View; 
 
public class MainActivity extends AppCompatActivity implements 
View.OnClickListener { 
 
 
 public void onClick(View v) { 
 Intent tela2 = new Intent(this, SegundaTela.class); 
 tela2.putExtra("disciplina","Programação de desenvolvimento de 
sistemas"); 
 tela2.putExtra("professor","Danilo "); 
 startActivity(tela2); 
 } 
} 
 
Figura 5.20 - Arquivo MainActivity.java com navegabilidade entre telas com passagem de parâmetro utilizando putExtra 
Fonte: o autor 
 Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java com 
navegabilidade entre telas com passagem de parâmetros, por meio do parâmetro putExtra que extrair informações 
relacionadas a “disciplina” e “professor”. 
 
No exemplo da Figura 5.20, acima, não utilizamos o Bundle e colocamos os parâmetros 
diretamente no Intent. Depois damodificação dessas classes de activities ocorreu a navegabilidade 
da primeira tela para a segunda tela. A tela com a execução da segunda tela pode ser visualizada na 
Figura 5.21 abaixo: 
 
 
109 
 
Figura 5.21 - tela da classe SegundaTela.java no android Studio 
Fonte: o autor 
Descrição da imagem: a imagem apresenta uma tela do celular da classe SegundaTela.java mostrado na parte superior 
da tela a mensagem EADPernambucoPDM, na barra inferior da tela três botões do celular com símbolos da seta, bola e 
quadrado e na parte do meio da tela a mensagem “Bem vindo Programação de desenvolvimento de sistemas Danilo”. 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
● Criar um novo projeto com Activity 
● Conceito de Activity 
● Ciclo de vida de uma Activity 
● Navegabilidade entre Activity 
● Navegabilidade Simples de uma Activity para outra 
● Navegação entre telas com passagem de parâmetros 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
 
110 
 
Agora, o próximo passo é mergulhar na competência 6, que trata da utilização de sobre 
Action Bar, a barra de ação dos aplicativos e sobre o tipo de estilo temas. 
Vamos juntos? 
 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a nossa primeira videoaula competência. 
 
 
111 
6. Competência 06 | Manipular Action bar e temas 
Caro estudante, vamos iniciar a sexta competência! Nesta competência você vai aprender 
com criar um novo projeto com Action Bar e os conceitos de Action Bar e temas. Em seguida, será 
mostrado sobre a customização de Action Bar. Por fim, será visto a Modificando Action Bar com 
temas. 
Vamos continuar! 
6.1 Criando um novo projeto com Action Bar 
A competência 1 introduziu os conceitos básicos de um sistema operacional móvel, e 
ensinou a criar e a configurar o ambiente de desenvolvimento, o Android Studio. Você lembra? No 
início da construção desse novo projeto você selecionou a opção Basic Activity com a funcionalidade 
do Action Bar. Diante disso, esse novo projeto incluir de maneira automática uma biblioteca de 
suporte para utilizar o Action Bar. A criação do novo projeto com a opção do Action Bar pode ser 
visualizado na Figura 6.1 abaixo: 
 
 
 
112 
Figura 6.1 - Criando uma nova Activity com Action Bar 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta a tela do Android para criar um novo projeto com Action Bar possuindo a 
seleção de uma tela com Activity e a opção next para prosseguir na criação da nova Activity. 
 
Para prosseguir a criação do projeto clique em Next. Em seguida, na próxima tela será 
necessário inserir a nova configuração do projeto. As opções modificadas nesse novo projeto são o 
nome do projeto, a linguagem Java e a API com a versão 26 e o Android Oreo. A configuração do novo 
projeto com Action Bar pode ser visualizado na Figura 6.2 abaixo: 
 
Figura 6.2 – Configurar um novo projeto com Action Bar 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta a tela do Android para configurar um novo projeto com ActionBar 
possuindo o preenchimento do name com o nome do projeto, Package name com a descrição do pacote do projeto, 
save location com a localização da pasta do projeto, language com a descrição da linguagem e a Minimum API Level 
com a descrição da mínima versão utilizada nesse projeto. Com o preenchimento desses campos deve acessar o botão 
finish para finalizar o projeto. 
 
Em seguida, o projeto no Android Studio inicia a sua execução. Nesse projeto, as classes 
utilizadas para executar o Action Bar são AndroidManifest.xml, styles.xml e colors.xml. Agora você vai 
 
 
113 
aprender sobre esses arquivos geradas pelo Android Studio para realizar a configuração inicial de um 
Action Bar. Vamos iniciar explicando o arquivo AndroidManifest.xml com a definição do tema do 
Action Bar definido no atributo android:theme da tag application. O código do arquivo 
AndroidManifest.xml com a declaração do tema pode ser visualizado na Figura 6.3 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambucopdm"> 
 <application 
 android:allowBackup="true" 
 android:icon="@mipmap/ic_launcher" 
 android:label="@string/app_name" 
 android:roundIcon="@mipmap/ic_launcher_round" 
 android:supportsRtl="true" 
 android:theme="@style/AppTheme"> 
 <!—Código comentado em XML: outros temas padrões 
 android:theme="@android:style/Theme.Black" Padrão cor preta 
 android:theme="@style/Theme.AppCompat.Light" padrão cor branca 
 --> 
 <activity 
 android:name=".MainActivity" 
 android:label="@string/app_name" 
 android:theme="@style/AppTheme.NoActionBar"> 
 
 <intent-filter> 
 <action android:name="android.intent.action.MAIN" /> 
 
 <category android:name="android.intent.category.LAUNCHER" /> 
 </intent-filter> 
 </activity> 
 </application> 
 
</manifest> 
 
 
Figura 6.3 – Arquivo AndroidManifest.xml com Action Bar 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
declaração da Activity com a tag name com o nome da activity, label com rótulo com a string da aplicação e o theme 
com o tema da aplicação. 
 
O código do AndroidManifest,xml da Figura 6.3, acima, mostra o atributo android:theme 
com a declaração no arquivo @style/AppTheme. No arquivo do AndroidManifest.xml, o arquivo 
@style/AppTheme é criado em Theme.AppCompat do arquivo styles.xml. No arquivo styles.xml, o 
AppTheme é considerado o nome do estilo e o tema Theme.AppCompat.Light.DarkActionBar é 
representado pela cor branca do layout. O Android Studio possui outros temas padrões como o 
 
 
114 
android:theme="@android:style/Theme.Black" representado pela cor preta do layout e o 
android:theme="@style/Theme.AppCompat.Light" representando pela cor branca do layout. Por fim, 
O AppTheme.NoActionBar é considerado o nome do estilo do Action Bar. O código do arquivo 
styles.xml com a configuração do estilo do Action Bar pode ser visualizado na Figura 6.4 abaixo: 
<resources> 
 <!-- Base application theme. --> 
 <style name="AppTheme" parent="Theme.AppCompat.Light "> 
 <!-- Customize your theme here. --> 
 <item name="colorPrimary">@color/colorPrimary</item> 
 <item name="colorPrimaryDark">@color/colorPrimaryDark</item> 
 <item name="colorAccent">@color/colorAccent</item> 
 </style> 
 <style name="AppTheme.NoActionBar"> 
 <item name="windowActionBar">false</item> 
 <item name="windowNoTitle">true</item> 
 </style> 
</resources> 
 
Figura 6.4 - Arquivo styles.xml com a declaração do Action Bar 
Fonte: Android Studio 3.5.2 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo styles.xml possuindo a 
declaração do estilo com a cor branca, com a tag style com name possuindo o nome do estilo AppTheme e o parent 
possuindo o acesso ao arquivo do tema Theme.AppCompat.Light, em seguida a declaração do estilo do Action Bar com 
o nome do estilo AppTheme.NoActionBar relacionado ao Action Bar. 
 
Outra maneira de utilizar o arquivo styles.xml é declarando a personalização da cor com 
formato de número hexadecimal. Essa declaração possui o nome o tema AppTheme com fundo 
branco e os itens colorPrimary com descrição hexadecimal na cor verde clara, colorPrimaryDark com 
descrição hexadecimal na cor verde escura e o colorAccent com descrição hexadecimal na cor rosa. 
O código do arquivo styles.xml com o tema personalizadopor cor pode ser visualizado na Figura 6.5 
abaixo: 
 <resources> 
 <!-- Base application theme. --> 
 <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar"> 
 <!-- Customize your theme here. --> 
 <item name="colorPrimary">#008577</item> 
 <item name="colorPrimaryDark">#00575B</item> 
 <item name="colorAccent">#D81B60</item> 
 </style> 
</resources> 
 
 
Figura 6.5 - Arquivo styles.xml com o tema personalizado por cor 
Fonte: Android Studio 3.5.2 
 
 
115 
Descrição da imagem: a imagem apresenta um fundo branco com o código do arquivo styles.xml possuindo a descrição 
do tema personalizado por cor possuindo a tag resources e as três tags color com a descrição da cor primária, cor 
primária escura e cor acentuada, assim como, a descrição hexadecimal da cor. 
 
Até aqui você aprendeu como criar um novo projeto com Action Bar. Nas seções a seguir, 
você vai aprender sobre os conceitos de Action Bar e temas, a customização de Action Bar com botão 
e a modificando do Action Bar com temas. 
 
6.2 Conceito de Action Bar 
Action Bar, ou simplesmente barra de ação, é considerado um elemento de interface 
gráfica utilizado em aplicativos. Mas qual a função do Action Bar? A sua função é identificar em qual 
região do aplicativo você está, além de fornecer ações contextualizadas executada por você, assim 
como, o processo de navegação para outras telas utilizando Activity. 
Além disso, a Action Bar é capaz de realizar o ajuste adequado de qualquer configuração 
de tela no arquivo AndroidManifest.xml do Android Studio. Os principais elementos de um Action Bar 
pode ser visualizado na Figura 6.6 abaixo: 
 
 Figura 6.6 – Elementos do Action Bar 
Fonte: o autor 
Descrição da imagem: a imagem apresenta uma barra de navegação com os quatro elementos do Action 
bar. A barra de navegação possui no número um o ícone do Android (No inglês App icon), no número dois possui a 
descrição em texto do Action bar que realiza a navegação com controle de telas (No inglês View control), no número três 
possui os ícones de ações (No inglês Action buttons) com uma lupa de pesquisa em seguida uma câmera de vídeo e no 
número quatro possui um submenu com as ações (No inglês Action overflow) possuindo três pontos com os ícones que 
não couberam na barra de ações. 
 
Nesse momento você vai aprender sobre esses quatro elementos do Action Bar na Tabela 
6.1, abaixo. Essa tabela está relacionada aos quatro elementos com números mostrado na Figura 6.6, 
acima. 
 
 
 
116 
Elemento Descrição 
(1) Ícone (App Icon) O ícone é considerado o elemento de identificação do seu 
aplicativo. Além disso, esse elemento com o ícone do Android 
realiza o processo de navegação, por meio da seta para 
esquerda que realiza a navegação para cima no processamento 
entre telas. 
(2) Navegação (View 
control) 
 
A navegação é considerada o elemento de navegação entre 
outras telas (views) do aplicativo, permitindo assim uma rápida 
navegação entre telas. 
(3) Botões de ações 
(Action bottons) 
Os botões de ações são considerados os elementos com 
opções mais importantes e disponíveis para o usuário. Alguns 
exemplos de ações são acesso a lupa do celular, acesso a fotos 
e vídeos. 
(4) Submenu de 
acesso (Action 
overflow) 
 
O submenu de acesso é considerado um dos elementos com 
ações menos usadas ou ações que não são visualizadas nessa 
barra de ações. 
 
Tabela 6.1 – Os elementos do Action Bar 
Fonte: o autor 
Descrição da imagem: a descrição dos quatro elementos do Action Bar ícone, navegação, botões de ações e submenu 
de acesso, assim como as respectivas descrições desses elementos. 
 
 
6.3 Conceito de temas 
O tema é considerado um tipo de estilo que pode ser configurado em toda aplicação, 
atividade ou hierarquia de exibição do Android. Mas o que é estilo? É considerado uma coleção de 
atributos que especificam a aparência de um único elemento visual do Android. 
Com o estilo você pode especificar atributos como cor, tamanho da fonte e cor do plano 
de fundo. Quando você aplica o seu estilo com tema, todas as visualizações no aplicativo ou atividade 
aplicam cada atributo de estilo configurado nesse tema. Os temas também podem aplicar estilos que 
não são visualizados, como por exemplo, as barras de status e o plano de fundo da janela. 
 
 
117 
O tema é declarado no arquivo styles.xml da pasta values do Android Studio. Esse tema 
deve possuir a tag <style> responsável por identificar o tipo de estilo e a tag <item> responsável pela 
configuração de cada atributo do estilo definido. 
Na tag <item> possui o item name responsável por especifica um atributo XML em seu 
layout. O código do styles.xml com exemplo de estilo com tema pode ser visualizado na Figura 6.7 
abaixo: 
 
<resources> 
 
 <!-- Base application theme. --> 
 <style name=" " parent=" "> 
 <!-- Customize your theme here. --> 
 <item name="colorPrimary">@color/colorPrimary</item> 
 
 </style> 
</resources> 
 
Figura 6.7 – Arquivo styles.xml do Android Studio 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo styles.xml possuindo o item da 
cor com o nome da cor primária e o acesso dessa cor representado por @color/colorPrimary . 
 
6.4 Customização de Action Bar com botão 
A customização do Action Bar com botão de ação (Action Buttons) necessita de 
configuração em sua visualização. Você pode definir se o botão sempre ficará visível, ou se ficará 
disponível no menu de submenu com ações (Action overflow). Para isso, podemos utilizar o atributo 
showAsAction responsável por definir o tipo de item que será exibido no Action Bar. Os itens do 
atributo showAsAction pode ser: 
• always – Indica que o botão sempre será exibido no botão de ação (Action Buttons). 
Sendo considerado o item recomendado para definir as ações mais comuns do 
aplicativo. 
• ifRoom – Exibe o item no botão de ação (Action Buttons) somente se houver espaço 
disponível. Sendo considerado o item de configuração mais adequado para manter a 
compatibilidade em diversos tipos de dispositivos. 
 
 
118 
• withText – Mostra o título do item ao lado do ícone caso haja espaço disponível no 
botão de ação (Action Buttons). 
• never – Nunca exibe o item, nesse caso o item é exibido no submenu de ações (Action 
Overflow). 
As configurações dos itens do atributo showAsAction pode ser definida no arquivo 
activity_main.xml. Esses itens são declarados na tag menu, com a declaração do item com a função 
showAsAction podendo ser Always, ifRoom, withText ou never. O código do arquivo activity_main.xml 
com os itens personalizados do Action Bar customizado pode ser visualizado na Figura 6.8 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<menu xmlns:app="http://schemas.android.com/apk/res-auto" 
 xmlns:android="http://schemas.android.com/apk/res/android" > 
 <!-- Search / will display always --> 
 <item android:id="@+id/action_search" 
 android:icon="@mipmap/ic_launcher_round" 
 android:title="Android" 
 app:showAsAction="always"/> 
 
 <item android:id="@+id/camera" 
 android:icon="@android:drawable/ic_menu_camera" 
 android:title="camera" 
 app:showAsAction="ifRoom" /> 
 
 <item android:id="@+id/help" 
 android:icon="@android:drawable/ic_menu_help" 
 android:title="help" 
 app:showAsAction="never" /> 
 
 <item android:id="@+id/Agenda" 
 android:icon="@android:drawable/ic_menu_agenda" 
 android:title="Agenda" 
 app:showAsAction="never" /> 
 
 <item android:id="@+id/menuJanela3" 
 android:icon="@android:drawable/ic_menu_call" 
 android:title="call" 
 app:showAsAction="withText" /> 
 
</menu> 
 
Figura 6.8 – Código activity_main.xml com customização do Action Bar 
Fonte: o autor 
Descriçãoda imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
customização do Action Bar possuindo a descrição dos cinco itens com nome Android, câmera, help, agenda e call. 
 
A customização do Action Bar no arquivo MainActivity.java possui o método 
getMenuInflater que permite configurar as ações definidas no arquivo activity_main.xml e adicioná-
 
 
119 
las ao botão de ações do Action Bar. Por fim, o método onCreateOptionsMenu é responsável por 
iniciar uma Activity e executar os botões de ações no arquivo activity_main.xml. O código do arquivo 
MainActivity.java do Android Studio representando o Action Bar pode ser visualizado na Figura 6.9 
abaixo: 
 
 
package com.example.eadpernambuco; 
 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.view.MenuInflater; 
import android.view.Menu; 
public class MainActivity extends AppCompatActivity { 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 } 
 @Override 
 public boolean onCreateOptionsMenu(Menu menu) { 
 MenuInflater inflater = getMenuInflater(); 
 inflater.inflate(R.menu.activity_main, menu); 
 return super.onCreateOptionsMenu(menu); 
 } 
} 
 
Figura 6.9– Arquivo da classe MainActivity.java com a customização do Action Bar 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java com a 
customização do Action Bar possuindo a execução da tela do Action Bar no arquivo activity_main.xml 
 
A tela do Android Studio representando a customização do Action Bar pode ser 
visualizado na Figura 6.10 abaixo: 
 
 
120 
 
Figura 6.10 – tela com customização do Action Bar 
Fonte: o autor 
Descrição da imagem: a imagem apresenta uma tela do celular com customização do Action bar 
mostrando na parte superior da tela a mensagem Action Bar e os dois botões com o símbolo do Android e da câmera e 
os três menus com os nomes help, agenda e call e na barra inferior da tela três botões do celular com símbolos da seta, 
bola e quadrado e na parte do meio da tela a mensagem “hello world”. 
 
6.5 Modificando Action Bar com temas 
A aplicação de temas no Android Studio ocorre no arquivo AndroidManifest.xml. Nesse 
arquivo, o tema da aplicação é definido no atributo android:theme na tag application. A alteração do 
tema pode ser executada acessando o arquivo themes.xml. O código do arquivo AndroidManifest.xml 
com a modificação do tema pode ser visualizado na Figura 6.11 abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco"> 
 
 <application 
 
 android:theme ="@android:style/Theme.Black"> 
 
 </application> 
 
</manifest> 
 
Figura 6.11 – Arquivo AndroidManifest.xml com modificação do tema 
Fonte: o autor 
 
 
121 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml possuindo a 
tag application com a aplicação do tema e a descrição do theme com acesso específico. 
 
O código anterior acessa o arquivo themes.xml e realiza a configuração do layout da 
aplicação para cor preta. O código do arquivo themes.xml com a configuração das cores pode ser 
visualizado na Figura 6.12 abaixo: 
<resources> 
 
 <style name="Theme.Black"> 
 <item name="windowBackground">@color/black</item> 
 <item name="colorBackground">@color/black</item> 
 </style> 
 
</resources> 
 
Figura 6.12– Arquivo themes.xml com a configuração das cores. 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo themes.xml possuindo a tag style 
com o tema preto e duas tags item com os name windowBackground representando a cor da janela de fundo e o 
colorBackground representando a cor de fundo. 
 
 A execução desse código gera a tela do layout para a cor preta. A tela com a execução 
do layout para a cor preta pode ser visualizada na Figura 6.13 abaixo: 
 
Figura 6.13 – tela com modificação de temas 
Fonte: o autor 
Descrição da imagem: a imagem apresenta uma tela do celular com modificação de temas mostrando na parte 
superior da tela a mensagem EADPernambucoPDM e na barra inferior da tela três botões do celular com símbolos da 
seta, bola e quadrado e na parte do meio com layout com fundo preto a mensagem “hello world” na cor branca. 
 
 
122 
 
Outra maneira de alterar a cor dos temas é acessando o arquivo styles.xml. Nesse arquivo, 
deve-se alterar a descrição do tema para Theme.AppCompat, dessa forma modifica a cor do layout 
para preto. O código do arquivo styles.xml com a configuração do tema com a cor preta pode ser 
visualizado na Figura 6.14 abaixo: 
<resources> 
 
 <!-- Base application theme. --> 
 <style name="AppTheme" parent="Theme.AppCompat"> 
 <!-- Customize your theme here. --> 
 <item name="colorPrimary">@color/colorPrimary</item> 
 <item name="colorPrimaryDark">@color/colorPrimaryDark</item> 
 <item name="colorAccent">@color/colorAccent</item> 
 </style> 
 
</resources> 
 
Figura 6.14 – Arquivo styles.xml com o tema na cor preta. 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo styles.xml possuindo o tema com 
a cor preta representada pela tag style com o nome do estilo AppTheme e os três itens representando a cor primária, 
cor primária sombria e cor acentuada. 
 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• Criando um novo projeto com Action Bar 
• Conceito de Action Bar 
• Conceito de temas 
• Customização de Action Bar com botão 
• Modificando Action Bar com temas 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
123 
 
Agora, o próximo passo é mergulhar na competência 7, que trata sobre conceitos de 
gerenciadores de layout ou ViewGroup e sobre os layouts ConstraintLayout , LinearLayout e 
RelativeLayout. Vamos juntos? 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a nossa vídeo aula sobre a competência. 
 
 
124 
7. Competência 07 | Conhecer os conceitos de interface gráfica - 
gerenciadores de layout 
Caro estudante, vamos iniciar a sétima competência! Nesta competência você vai 
aprender sobre os conceitos de interface gráfica utilizando a classe View com os seus componenetes 
da classe ViewGroup ou gerenciadores de layout. Em seguida, será visto os layouts ConstraintLayout, 
linearLayout e RelativeLayout. Por fim, será mostrado os componentes de dimensões do layout. 
Vamos continuar! 
 
7.1 Criando um novo projeto com a classe ViewGroup 
A competência 1 introduziu os conceitos básicos de um sistema operacional móvel, e 
ensinou a criar e a configurar o ambiente de desenvolvimento, o Android Studio. Você lembra? Na 
criação desse novo projeto é gerado o arquivo activity_main.xml responsável por modificar a classe 
ViewGroup. A declaração da classe ViewGroup utiliza alguns componentes da paleta de layouts. Os 
principais layouts mostrados nessa paleta são ConstraintLayout, LinearLayout, FrameLayout, 
RelativeLayout e TableLayout. A declaração do identificador desses layouts e a modificação do nome 
do atributo id (identificador) ocorre na paleta atributos. Por exemplo: o identificador do textView 
declarado na Figura 7.1, abaixo, possui o id representado pelo nome “campo” e a sua declaração no 
arquivo XML é representado por android:id="@+id/campo". A tela com a execução do arquivo 
activity_main.xml da classe ViewGroup pode ser visualizada na Figura 7.1 abaixo:125 
 
Figura 7.1 - Arquivo activity_main.xml gerado pelo novo projeto da classe ViewGroup 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml possuindo do 
lado esquerdo a opção clicada na paleta de layout do tipo ContraintLayout e o componente campo com o nome “Hello 
World”, e no lado direito duas telas da aplicação nas cores branco e verde com o nome centralizado “Hello World”. 
 
Até aqui você aprendeu como criar um novo projeto com a classe ViewGroup. Nas seções 
a seguir, você vai aprender sobre o conceito da classe View e sobre o seu componente ViewGroup. 
 
7.2 Conceito da classe View 
A classe View é considerada a classe principal dos componentes visuais do Android, e suas 
subclasses são utilizadas na criação das interfaces gráficas dos aplicativos. Além disso, é uma classe 
base de qualquer outro componente utilizada com a respectiva classe Activity. Cada subclasse dessa 
classe View representada no Android por android.iew.View deve realizar a implementação do método 
onDraw(Canvas), essa classe Canvas utilizada no método onDraw define os métodos para desenhar 
texto, linhas, bitmaps e outras primitivas gráficas das telas dos aplicativos. 
No Android podemos classificar a classe View em dois tipos de componentes: os widgets 
e os gerenciadores de layout ou ViewGroup. O widget é considerado um componente que herda 
diretamente da classe View, como exemplos existe o elemento TextView representada pela classe 
android.widget.TextView, além de outros elementos como Button, ImageButton, ImageView e o 
 
 
126 
gerenciador de layout ou ViewGroup representado pela classe android.view.ViewGroup, é 
considerado um componente mais popular sendo representado pelos layouts dos aplicativos. A 
imagem representando as classes da View pode ser visualizada na Figura 7.2 abaixo: 
 
Figura 7.2 – Representação da classe View 
Fonte: o autor 
Descrição da imagem: a imagem apresenta o fluxograma de execução da classe View. O retângulo amarelo com a classe 
android.view.View herda do retângulo azul o componente ViewGroup ou gerenciador de layouts representado pela 
classe android.view.ViewGroup que herda cinco retângulo azuis com as classes android.vew.FrameLayout, 
android.view.ConstraintLayout, android.view.RelativeLayout e a classe android.view.TableLayout herdada por 
android.view.LinearLAyout. O retângulo amarelo com a classe android.view.View também herda os componentes da 
Widget representada pelo retângulo azul da classe android.widget.TextView que herda dois retângulos representados 
por android.view.Button e android.widget.EditText, além de herda o quadrado azul representado pela classe 
android.widget.ImageView. 
 
 
7.3 Conceito da classe ViewGroup 
O gerenciador de layout, ou classe ViewGroup, é considerado um componente visual 
responsável por organizar os componentes da tela. Essa classe é representada no Android por 
android.view.ViewGroup, sendo assim considerada a classe principal de todos os gerenciadores de 
layout. Os principais componentes da ViewGroup pode ser visualizado na Tabela 7.1 abaixo. 
 
 
 
 
 
 
127 
Componente Descrição Figura do Layout 
LinearLayout É um 
componente 
utilizado para 
organizar as 
telas na forma 
linear no sentido 
horizontal ou 
vertical. Por 
exemplo, o 
elemento vai ter 
que ser 
posicionar na 
tela de maneira 
horizontalmente 
ou 
verticalmente. 
 
 
 
128 
RelativeLayout É um 
componente 
utilizado para 
posicionar um 
componente de 
forma relativa a 
outro. Por 
exemplo, o 
elemento acima, 
abaixo de outro 
componente já 
existente ou ao 
lado de um 
componente já 
existente. 
 
 
 
129 
ConstraintLayout É similar ao 
componente da 
RelativeLayout, 
ou seja, o seu 
alinhamento é 
feito de relações 
entre as Views 
por meio dos 
seus eixos. Por 
exemplo: o 
componente de 
texto 
centralizado e os 
seus eixos 
definidos como 
X sendo eixo de 
início (esquerdo) 
e fim (direito) e o 
Y o eixo do topo 
(cima) e inferior 
(baixo). 
 
 
Tabela 7.1 – Os principais componentes do ViewGroup ou gerenciadores de layout 
Fonte: o autor 
Descrição da imagem: a descrição de cinco componentes da classe ViewGroup representadas pelos layouts 
ConstraintLayout, linearLayout, e relativeLayout. 
 
Existem diversas classes que herdam de ViewGroup, como por exemplo FrameLayout, 
TableLayout GridLayout, GridView e TableRow. Portanto, nesse e-book de programador de 
dispositivos móveis você vai aprender sobre os três principais tipos de layouts mostrado na Tabela 
3.1, acima. Esses componentes são considerados os mais utilizados como componente visual em telas 
de aplicativos. 
 
 
130 
Nas seções a seguir, você vai aprender sobre os componentes de layout LinearLayout e 
ConstraintLayout e RelativeLayout. 
7.3.1 LinearLayout 
O LinearLayout é considerado o gerenciador de layout mais utilizado, pois possui a 
possibilidade de organizar os seus componentes internos de maneira linear, posicionando objetos um 
abaixo do outro, quando configurado na orientação vertical ou um ao lado do outro, quando 
configurado na orientação horizontal. Na tela da aplicação, a orientação vertical representa o layout 
de cima para baixo e na orientação horizontal representa o layout da esquerda para a direita. 
Toda classe do LinearLayout representada no Android por android.widget.LinearLayout 
possui os atributos layout_width (android:layout_width) e o layout_height (android:layout_height), 
para especificar, respectivamente, a largura e altura do layout. Esses atributos possuem dois valores 
importantes, o match_parent e o wrap_content. O valor do match_parent informa que o componente 
deve ocupar o tamanho definido pelo seu layout, ou seja, o layout deve ocupar toda a tela da 
aplicação e o wrap_content informa que o componente deve ocupar apenas o seu tamanho real, ou 
seja, o layout não possui nenhum tipo de alteração. 
Além desses atributos, o LinearLayout possui o atributo orientation (android:orientation), 
com a função de especificar a orientação dos seus respectivos componentes. Esse atributo 
orientation pode ser representado por valores na horizontal (android:orientation=”horizontal”) ou 
vertical (android:orientation=”vertical”), outra maneira é o valor default (android:orientation=””), o 
qual é utilizado quando não é especificado nenhum valor, assim, os elementos serão exibidos de 
maneira horizontal. Outro atributo é o android:gravity, com a função de localizar a gravidade do 
layout na tela. Esse atributo gravity pode ser representado pelo layout centralizado verticalmente e 
horizontalmente na tela. A imagem representando os componentes LinearLayout pode ser 
visualizada na Figura 7.3 abaixo: 
 
 
131 
 
Figura 7.3 – Telas representando os componentes do LinearLayout 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas de celular na cor fundo branco e com linhas azuis 
representando o layout do LinearLayout. A primeira tela possui uma tela (lado esquerdo) com fundo branco e cinco 
linhas na horizontal representando o LinearLayout horizontal e a segunda tela (lado direito) com fundo branco e três 
linhas na vertical representando o LinearLayout vertical. 
 
Por exemplo, imagine que existe um aplicativo de jogo com o layout LinearLayout com a 
visualização horizontal dos jogos Mario, Lol e Barkbridge. Diante desse exemplo, você vai aprender 
como utilizar a classe LinearLayout na visualização de imagens dos jogos na horizontal. O arquivo 
activity_main.xml mostrado na Figura 7.4, abaixo, possui o layout LinearLayout com orientação 
horizontal e três classes Imageview com as imagens dos jogos Mario, Lol e Barkbridge. Esse código 
do activity_main.xml representando o LinearLayout horizontal pode ser visualizado na Figura 7.4 
abaixo: 
<?xml version=”1.0” encoding=”utf-8”?> 
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”xmlns:tools=”http://schemas.android.com/tools” 
 android:layout_width=”match_parent” 
 android:layout_height=”match_parent” 
 android:orientation=”horizontal” 
 tools:context=”.MainActivity”> 
 <ImageView 
 android:id=”@+id/lol” 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:src=”@mipmap/ic_launcher_mario” 
 /> 
 <ImageView 
 android:id=”@+id/mario” 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:src=”@mipmap/ic_launcher_barkbridge” 
 /> 
 <ImageView 
 android:id=”@+id/ barkbringe” 
 android:layout_width=”wrap_content” 
 
 
132 
 android:layout_height=”wrap_content” 
 android:src=”@mipmap/ic_launcher_lol” 
 /> 
</LinearLayout> 
 
Figura 7.4 – Arquivo activity_main.xml com LinearLayout horizontal 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do LinearLayout horizontal possuindo a representação da tag LinearLayout com os componentes altura, 
largura, orientação horizontal e o contexto do layout, e as três tags de imagens representadas pelas imagens do mario, 
barkbridge e lol. 
 
Depois da execução do arquivo activity_main.xml com LinearLayout horizontal da Figura 
7.4, acima, e gerado o designer da tela no Android Studio visualizado na Figura 7.5 abaixo: 
 
Figura 7.5 – Tela do LinearLayout horizontal 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o LinearLayout horizontal. A 
tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três 
botões do celular e na parte do meio da tela três imagens dos jogos mario, barkbridge e lol organizado na sequência de 
maneira horizontal, a tela do lado direito possui um quadrado com fundo verde representado a tela e três quadrados 
pequenos representados as três imagens organizada de maneira horizontal. 
 
O LinearLayout horizontal configura no arquivo MainActivity.java da Figura 7.6, abaixo, 
esse LinearLayout horizontal possui a declaração do método setOrientation() com orientação 
 
 
133 
horizontal e na imageView é utilizado o método addView() para visualizar uma respectiva imagem. 
Por fim é executado o método setContextview() responsável por configurar o layout XML com o 
LinearLayout. O código do arquivo MainActivity.java do Android Studio representando o LinearLayout 
horizontal pode ser visualizado na Figura 7.6 abaixo: 
 
 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.LinearLayout; 
import android.widget.ImageView; 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 
 
 LinearLayout linearLayout = new LinearLayout(this); 
 linearLayout.setOrientation(LinearLayout.HORIZONTAL); 
 LinearLayout.LayoutParams param = new 
 LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 
LinearLayout.LayoutParams.MATCH_PARENT); 
 linearLayout.setLayoutParams(param); 
 
 ImageView imageView = new ImageView(this); 
 imageView.setImageResource(R.mipmap.lol); 
 linearLayout.addView(imageView); 
 
 ImageView imageView2 = new ImageView(this); 
 imageView2.setImageResource(R.mipmap.mario); 
 linearLayout.addView(imageView2); 
 
 ImageView imageView3 = new ImageView(this); 
 imageView3.setImageResource(R.mipmap.barkbringe); 
 linearLayout.addView(imageView3); 
 
 setContentView(linearLayout); 
 } 
} 
 
Figura 7.6 – Arquivo da classe MainActivity.java do LinearLayout horizontal 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do LinearLayout horizontal no arquivo activity_main.xml. 
 
 
134 
 
 
Por exemplo, imagine que existe um aplicativo de jogo com o layout LinearLayout com a 
visualização vertical dos jogos Mario, Lol e barkbridge. Diante desse exemplo, você vai aprender como 
utilizar a classe LinearLayout na visualização de imagens dos jogos na vertical. O arquivo 
activity_main.xml mostrado na Figura 7.7, abaixo, possui o layout LinearLayout com orientação 
vertical e três classes Imageview com as imagens dos jogos Mario, Lol e Barkbridge. Esse código do 
activity_main.xml representando o LinearLayout vertical pode ser visualizado na Figura 7.7 abaixo: 
 
<?xml version=”1.0” encoding=”utf-8”?> 
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android” 
 xmlns:tools=”http://schemas.android.com/tools” 
 android:layout_width=”match_parent” 
 android:layout_height=”wrap_content” 
 android:orientation=”vertical” 
 tools:context=”.MainActivity”> 
 <ImageView 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:src=”@mipmap/ic_launcher_mario” 
 /> 
 <ImageView 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:src=”@mipmap/ic_launcher_barkbridge” 
 /> 
 <ImageView 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:src=”@mipmap/ic_launcher_lol” 
 /> 
</LinearLayout> 
 
Figura 7.7 – Arquivo activity_main.xml com LinearLayout vertical 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do LinearLayout vertical possuindo a representação da tag LinearLayout com os componentes altura, 
largura, orientação vertical e o contexto do layout, e as três tags de imagens representadas pelas imagens do mario, 
barkbridge e lol. 
 
Depois da execução do arquivo activity_main.xml com LinearLayout vertical da Figura 7.7, 
acima, e gerado o designer da tela no Android Studio visualizado na Figura 7.8 abaixo: 
 
 
135 
 
Figura 7.8 – Tela do LinearLayout vertical 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o LinearLayout vertical. A tela 
do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três 
botões do celular e na parte do meio da tela três imagens dos jogos mario, barkbridge e lol organizado na sequência de 
maneira vertical, a tela do lado direito possui um quadrado com fundo verde representado a tela e três quadrados 
pequenos representados as três imagens organizada de maneira vertical. 
 
O LinearLayout vertical configura no arquivo MainActivity.java da Figura 7.9, abaixo, esse 
LinearLayout horizontal possui a declaração do método setOrientation() com orientação vertical e na 
imageView é utilizado o método addView() para visualizar uma respectiva imagem. Por fim é 
executado o método setContextview() responsável por configurar o layout XML com o LinearLayout. 
O código do arquivo MainActivity.java do Android Studio representando o LinearLayout vertical pode 
ser visualizado na Figura 7.9 abaixo: 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.LinearLayout; 
import android.widget.ImageView; 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 
 
136 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 
 LinearLayout linearLayout = new LinearLayout(this); 
 linearLayout.setOrientation(LinearLayout.VERTICAL); 
 LinearLayout.LayoutParams param = new 
 LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 
LinearLayout.LayoutParams.MATCH_PARENT); 
 linearLayout.setLayoutParams(param);ImageView imageView = new ImageView(this); 
 imageView.setImageResource(R.mipmap.lol); 
 linearLayout.addView(imageView); 
 
 ImageView imageView2 = new ImageView(this); 
 imageView2.setImageResource(R.mipmap.mario); 
 linearLayout.addView(imageView2); 
 
 ImageView imageView3 = new ImageView(this); 
 imageView3.setImageResource(R.mipmap.barkbringe); 
 linearLayout.addView(imageView3); 
 setContentView(linearLayout); 
 } 
} 
 
Figura 7.9 – Arquivo da classe MainActivity.java do LinearLayout vertical 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do LinearLayout vertical no arquivo activity_main.xml. 
 
7.3.2 ConstraintLayout 
 O ConstraintLayout é considerado o gerenciador de layout padrão do Android, pois possui 
recursos de outros gerenciadores de layout, assim como, uma série de outras funcionalidades desses 
layouts para posicionar e redimensionar os seus componentes. Nesse layout é possível criar layout 
planos, ou seja, sem as características de encadeamento de diversos layouts, como exemplo o 
LinearLayout dentro de FrameLayout e dentro do RelativeLayout. Dessa maneira, os layouts do 
ConstraintLayout possuem a tendência de renderizar de forma mais rápida e eficiente. 
O ConstraintLayout representada pela classe android.widget.ConstraintLayout possui os 
atributos layout_width (android:layout_width) e o layout_height (android: layout_height), para 
definir, consequentemente, a sua largura e a altura. Nesses atributos é utilizado o valor match_parent 
para informar que o componente deve ocupar um tamanho definido pelo seu respectivo layout, ou 
seja, esse layout deve ocupar a tela inteira da aplicação. Além desses atributos, o ConstraintLayout 
 
 
137 
possui os atributos de Bias representando a inclinação do Layout e os atributos Editor representando 
o posicionamento do layout como visualizado na Tabela 7.2 abaixo: 
 
Atributo Descrição 
app:layout_constraintHorizontal_bias define a inclinação horizontal do layout da 
tela 
app:layout_constraintVertical_bias define a inclinação vertical do layout da tela 
tools:layout_editor_absoluteX define o posicionamento do eixo X na tela 
do layout 
tools:layout_editor_absoluteY define o posicionamento do eixo y na tela 
do layout 
 
Tabela 7.2 – Atributos de posicionamento do ConstraintLayout 
Fonte: o autor 
Descrição da imagem: a descrição dos quatro atributos de posicionamento do ConstraintLayout. 
. 
 
Por exemplo, imagine que existe um aplicativo de jogo com o layout ConstraintLayout 
com a descrição textual do jogo no formato de texto. Diante desse exemplo, você vai aprender como 
utilizar a classe ConstraintLayout na visualização da descrição do texto. O arquivo activity_main.xml 
mostrado na Figura 7.10, abaixo, possui o layout Constraintlayout e a classe TextView com a descrição 
“Descrição do jogo!”. Esse código do activity_main.xml representando o layout ConstraintLayout com 
a classe TextView pode ser visualizado na Figura 7.10 abaixo: 
 
<?xml version=”1.0” encoding=”utf-8”?> 
<androidx.constraintlayout.widget.ConstraintLayout 
xmlns:android=”http://schemas.android.com/apk/res/android” 
 xmlns:app=”http://schemas.android.com/apk/res-auto” 
 xmlns:tools=”http://schemas.android.com/tools” 
 android:layout_width=”match_parent” 
 android:layout_height=”match_parent” 
 tools:context=”.MainActivity”> 
 
 <TextView 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:text=”Descrição do jogo!” 
 app:layout_constraintBottom_toBottomOf=”ontent” 
 app:layout_constraintLeft_toLeftOf=”ontent” 
 app:layout_constraintRight_toRightOf=”ontent” 
 app:layout_constraintTop_toTopOf=”ontent” /> 
 
 
</androidx.constraintlayout.widget.ConstraintLayout> 
 
 
138 
Figura 7.10 – Arquivo activity_main.xml do ConstraintLayout com TextView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do ConstraintLayout com TextView possuindo a representação da tag ConstraintLayout com os 
componentes altura, largura e o contexto do layout, e a tag do TextView com os componentes altura, largura e texto 
com a mensagem “Descrição do jogo!”. 
 
Depois da execução do arquivo activity_main.xml do ConstraintLayout com TextView da 
Figura 7.10, acima, e gerado o designer da tela no Android Studio visualizado na Figura 7.11 abaixo: 
 
 
Figura 7.11 – Tela do ConstraintLayout com TextView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o ConstraintLayout com 
TextView. A tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra 
inferior três botões do celular e na parte do meio o texto descrição do jogo na cor cinza, a tela do lado direito possui um 
quadrado com fundo verde representado a tela e quadrado centralizado na tela com o nome “Descrição do jogo”. 
 
O ConstraintLayout com texto configura no arquivo MainActivity.java da Figura 7.12, 
abaixo, esse ConstraintLayout possui a declaração do método SetId() com o identificador do 
ConstraintLayout e no TextView é utilizado o método addView() para visualizar a mensagem do texto 
“descrição do jogo”. Por fim é executado o método setContextview() responsável por configurar o 
 
 
139 
layout XML com o ConstraintLayout. O código do arquivo MainActivity.java do Android Studio 
representando o ConstraintLayout com TextView pode ser visualizado na Figura 7.12 abaixo: 
 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import androidx.constraintlayout.widget.ConstraintLayout; 
import android.widget.TextView; 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 
 ConstraintLayout constraintLayout = new ConstraintLayout(this); 
 constraintLayout.setId(R.id.constraintLayout); 
 ConstraintLayout.LayoutParams param = new 
ConstraintLayout.LayoutParams(ConstraintLayout.LayoutParams.MATCH_PARENT, 
ConstraintLayout.LayoutParams.MATCH_PARENT); 
 constraintLayout.setLayoutParams(param); 
 
 TextView textView = new TextView(this); 
 textView.setText(“descrição do jogo”); 
 constraintLayout.addView(textView); 
 
 setContentView(constraintLayout); 
 } 
} 
 
Figura 7.12 – Arquivo da classe MainActivity.java do ConstraintLayout com TextView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do ConstraintLayout com TextView no arquivo activity_main.xml. 
 
 
Por exemplo, imagine que existe um aplicativo de jogo com o layout ConstraintLayout 
com o botão de acesso ao jogo. Diante desse exemplo, você vai aprender como utilizar a classe 
ConstraintLayout utilizando um botão do jogo. O arquivo activity_main.xml mostrado na Figura 7.13, 
abaixo, possui o layout ConstraintLayout e a classe Button com a descrição=”Acesso ao jogo”. Esse 
código do activity_main.xml representando o layout ConstraintLayout com a classe Button pode ser 
visualizado na Figura 7.13 abaixo: 
 
 
 
140 
<?xml version=”1.0” encoding=”utf-8”?> 
<androidx.constraintlayout.widget.ConstraintLayout 
xmlns:android=”http://schemas.android.com/apk/res/android” 
 xmlns:app=”http://schemas.android.com/apk/res-auto” 
 xmlns:tools=”http://schemas.android.com/tools” 
 android:layout_width=”match_parent” 
 android:layout_height=” match_parent” 
 tools:context=”.MainActivity”> 
<Button 
 android:id=”@+id/button” 
 android:layout_width=”wrap_content” 
 android:layout_height=”wrap_content” 
 android:text=”Acessoao jogo” 
 
 tools:layout_editor_absoluteX=”135dp” 
 tools:layout_editor_absoluteY=”221dp” /> 
</androidx.constraintlayout.widget.ConstraintLayout> 
 
Figura 7.13 – Arquivo activity_main.xml do ConstraintLayout com Button 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do ConstraintLayout com Button possuindo a representação da tag ConstraintLayout com os 
componentes altura, largura e o contexto do layout, e a tag do Button com os componentes id do botão, altura, largura 
e texto com a mensagem “Acesso ao jogo”. 
 
Depois da execução do arquivo activity_main.xml do ConstraintLayout com Button da 
Figura 7.13, acima, e gerado o designer da tela no Android Studio visualizado na Figura 7.14 abaixo: 
 
Figura 7.14- Tela do ConstraintLayout com Button 
Fonte: o autor 
 
 
141 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o ConstraintLayout com 
botão. A tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra 
inferior três botões do celular e na parte do meio o botão na cor azul com o texto acesso ao jogo, a tela do lado direito 
possui um quadrado com fundo verde representado a tela e um quadrado verde claro centralizado na tela 
representando o botão com o nome acesso ao jogo na cor branca. 
 
 
O ConstraintLayout com botão configura no arquivo MainActivity.java da Figura 7.15, 
abaixo, esse ConstraintLayout possui a declaração do método SetId() com o identificador do 
ConstraintLayout e no Button é utilizado o método addView() para visualizar a mensagem do botão 
“Acesso ao jogo’. Por fim é executado o método setContextview() responsável por configurar o layout 
XML com o ConstraintLayout. O código do arquivo MainActivity.java do Android Studio 
representando o ConstraintLayout com Button pode ser visualizado na Figura 7.15 abaixo: 
 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import androidx.constraintlayout.widget.ConstraintLayout; 
import android.widget.Button; 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 
 
 ConstraintLayout constraintLayout = new ConstraintLayout(this); 
 constraintLayout.setId(R.id.constraintLayout); 
 ConstraintLayout.LayoutParams param = new 
ConstraintLayout.LayoutParams(ConstraintLayout.LayoutParams.MATCH_PARENT, 
ConstraintLayout.LayoutParams.MATCH_PARENT); 
 constraintLayout.setLayoutParams(param); 
 Button button = new Button(this) 
 button.setText(“Acesso ao jogo”); 
 constraintLayout.addView(button); 
 setContentView(constraintLayout); 
 } 
} 
 
 
 
Figura 7.15 – Arquivo da classe MainActivity.java do ConstraintLayout com Button 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do ConstraintLayout com Button no arquivo activity_main.xml. 
 
 
142 
 
7.3.3 RelativeLayout 
O componente RelativeLayout também é bastante utilizada, através desse layout é 
possível posicionar um componente em relação ao outro. Nesse layout também é possível especificar 
um determinado elemento para aparecer ao lado direito ou lado esquerdo de uma determinada 
imagem, assim como pode ser posicionado acima ou abaixo dessa imagem. 
Mas como esse componente deve aparecer ao lado, abaixo ou acima de outro 
componente já existente? Para realizar isso você deve definir um ID (identificador) para cada 
componente da tela, pois o posicionamento de um conjunto depende do outro. Com isso, é possível 
com o RelativeLayout dizer para um componente “A” fique abaixo do componente “B”. Os atributos 
importantes que podem ser usados pelo RelativeLayout podem ser visualizados na Tabela 7.3, abaixo. 
 
Atributo Descrição 
android:layout_below Posiciona o elemento abaixo de outro. 
android:layout_above Posiciona o elemento acima de outro. 
 
android:layout_toLeftOf Posiciona o elemento à esquerda de outro. 
 
android:layout_toRightOf Posiciona o elemento à direita de outro 
android:layout_marginTop 
 
Utilizado para definir um espaço (margem) na parte 
superior (Top) do componente 
android:layout_marginBottom Utilizado para definir um espaço (margem) na parte 
inferior (Bottom) do componente. 
android:layout_marginRight 
 
Utilizado para definir um espaço (margem) na parte 
direita (Right) do componente. 
android:layout_marginLeft Utilizado para definir um espaço (margem) na parte 
esquerda (Left) do componente 
Tabela 7.3 – Atributos de posicionamento do RelativeLayout 
Fonte: o autor 
Descrição da imagem: a descrição dos oito atributos de posicionamento do RelativeLayout. 
 
 
143 
 
Por exemplo, imagine que existe um aplicativo de jogo com o layout RelativeLayout com 
um formulário de cadastro do jogo. Diante desse exemplo, você vai aprender como utilizar a classe 
RelativeLayout no formulário de cadastro o jogo com os atributos de posicionamento 
layout_marginBottom e layout_marginLeft. O arquivo activity_main.xml mostrado na Figura 7.16, 
abaixo, possui o layout RelativeLayout, a classe TextView possuindo a descrição "Formulário de 
cadastro de jogo", as três classes do TextView possuindo os nomes Login, senha e confirmação da 
senha e as três classes do EditText como preenchimento desse formulário. Esse código do 
activity_main.xml representando o layout RelativeLayout com as classes ImageView e EditText pode 
ser visualizado na Figura 7.16 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:id="@+id/txtViewDescricao" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:layout_margin="25dp"" 
 android:gravity="center" 
 android:textSize="18dp" 
 android:text="Formulário de cadastro de jogo" /> 
 
 <TextView 
 android:id="@+id/txtViewLogin" 
 android:layout_width="155dp" 
 android:layout_height="wrap_content" 
 android:layout_below="@+id/txtViewDescricao" 
 android:layout_marginBotton="20dp" 
 android:layout_marginLeft="15dp" 
 android:text="Login" /> 
 
 
 <EditText 
 android:id="@+id/editTxtLogin" 
 Você pode entender um pouco sobre a execução do RelativeLayout consultando 
este link: https://www.youtube.com/watch?v=rNyrFNxVwZs 
https://www.youtube.com/watch?v=rNyrFNxVwZs
 
 
144 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:layout_alignTop="@+id/txtViewLogin" 
 android:layout_toRightOf="@+id/txtViewLogin" 
 android:background="@android:drawable/editbox_background"/> 
 
 <TextView 
 android:id="@+id/txtViewSenha" 
 android:layout_width="155dp" 
 android:layout_height="wrap_content" 
 android:layout_below="@+id/txtViewLogin" 
 android:layout_marginBottom="20dp" 
 android:layout_marginLeft="15dp" 
 android:text="Senha"/> 
 
 <EditText 
 android:id="@+id/editTxtSenha" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:layout_alignTop="@+id/txtViewSenha" 
 android:layout_toRightOf="@+id/txtViewSenha" 
 android:background="@android:drawable/editbox_background"/> 
 
 <TextView 
 android:id="@+id/txtViewConfirmacaoDeSenha" 
 android:layout_width="155dp" 
 android:layout_height="wrap_content"android:layout_below="@+id/editTxtSenha" 
 android:layout_marginBottom="20dp" 
 android:layout_marginLeft="15dp" 
 android:text="Confirmação de senha/> 
 
 <EditText 
 android:id="@+id/editTxtConfirmacaoDeSenha" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:background="@android:drawable/editbox_background" /> 
 
</RelativeLayout> 
 
Figura 7.16 - Arquivo activity_main.xml com RelativeLayout 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do RelativeLayout possuindo a representação da tag RelativeLayout com os componentes altura, largura, 
e as quatro tags de TextView com a descrição do texto do formulário e as três tags do EditText com campos para 
preencher o login, senha e a confirmação da senha do formulário. 
 
Depois da execução do arquivo activity_main.xml com RelativeLayout da Figura 7.16, 
acima, e gerado o designer da tela no Android Studio visualizado na Figura 7.17 abaixo: 
 
 
145 
 
 Figura 7.17 – Tela do RelativeLayout 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o RelativeLayout. A tela do lado 
esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três botões do 
celular e na parte do meio possui uma tela branca com um campo de texto na parte superior com a descrição 
“formulário de cadastro de jogo”, em baixo um campo de texto login e um campo para preencher o login, em seguida o 
campo de texto senha e um campo para preencher a senha, por fim o campo com o texto confirmação da senha, a tela 
do lado direito possui um quadrado na parte superior com o nome “formulário de cadastro de jogo”, em baixo dois 
quadrados com login e o campo para editar o login, em seguida dois quadrados com o texto senha e o campo para 
editar a senha, por fim um quadrado com o texto de confirmação da senha 
 
 
7.4 Dimensões dos componentes do layout 
As dimensões de altura e largura geralmente utilizam valores como match_parent e 
wrap_content. Entretanto, outra possibilidade possível é definir os valores específicos, ou seja, 
valores numéricos com notações indicando a unidade que está sendo utilizado. Por exemplo: 15px 
(pixels) ou 16mm (milímetros). Dessa forma é possível modificar a dimensão do layout utilizando o 
tamanho do componente. As dimensões no Android e as suas respectivas notações pode ser 
visualizado na Tabela 7.4. 
 
 
146 
Notação Descrição 
px (pixels) É uma medida que corresponde ao número de pixels que será ocupado na 
tela. 
in (inches) Inches significa polegadas, é uma medida baseada no tamanho físico em 
polegadas da tela. 
mm (milímetros) É uma medida baseada no tamanho em milímetros da tela. 
pt (pontos) É uma medida baseado no tamanho físico de pontos da tela. A medida pt 
corresponde a 1/72 de uma polegada. 
dp(Density-
independent 
Pixels) 
É a unidade relacionada à resolução da tela. Por exemplo, caso a resolução 
da tela é de 160 dpi, significa que para cada dp representa 1 pixel em um 
total de 160. A notação dp é a mais utilizada. 
Sp (Scale-
independent 
Pixels) 
É a unidade mais recomendada quando pretende especificar o tamanho 
de uma fonte, para que esta seja automaticamente ajustada conforme a 
resolução da tela do usuário. A notação sp é semelhante a notação dp. 
 
Tabela 7.4 – Notações com dimensões dos componentes de layout 
Fonte: o autor 
Descrição da imagem: a descrição das seis notações com dimensões dos componentes de layout representadas por px 
(pixels), in (inches), mm (milímetros), pt (pontos), dp(Density-independent Pixels) e Sp (Scale-independent Pixels). 
 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• A classe View 
• A classe ViewGroup 
• O layout LinearLayout 
• O layout ConstraintLayout 
• O layout RelativeLayout 
• As dimensões dos componentes do layout 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
147 
 
 Agora, o próximo passo é mergulhar na competência 8, que trata sobre conceitos da 
classe Widget gerada pela classe View e sobre os componentes TextView, EditText e ImageView. 
Vamos juntos? 
 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a vídeo aula sobre a competência. 
 
 
148 
8. Competência 08 | Conhecer os conceitos de interface gráfica – view 
Caro estudante, vamos iniciar a oitava competência! Nesta competência você vai 
aprender os conceitos de interface gráfica utilizando a classe widget que herda diretamente da classe 
view. A classe widget possui os elementos TextView e EditText relacionados para texto. Além disso, 
será mostrado o componente ImageView relacionado a imagem. 
Vamos entender sobre view! 
 
8.1 Criando um novo projeto com a classe Widget 
A competência 1 introduziu os conceitos básicos de um sistema operacional móvel, e 
ensinou a criar e a configurar o ambiente de desenvolvimento, o Android Studio. Você lembra? Na 
criação desse novo projeto é gerado o arquivo activity_main.xml responsável por modificar a classe 
Widget. A declaração da classe Widget utiliza alguns componentes nas paletas Common, Text e 
Buttons. Os principais componentes mostrado nessa paleta são textView, editText, imageView, 
button, imageButton, checkBox e radioButton. A declaração do identificador desses componentes 
ocorre na paleta atributos com a modificação do nome do atributo id (identificador). Por exemplo: o 
identificador do textView declarado na Figura 8.1, abaixo, possui o id representado pelo nome 
“identificador” e a sua declaração no arquivo XML é representado por 
android:id="@+id/identificador". A tela com a execução do arquivo activity_main.xml da classe 
Widgets pode ser visualizada na Figura 8.1 abaixo: 
 
 
149 
 
Figura 8.1 - Arquivo activity_main.xml gerado pelo novo projeto da classe Widgets 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml 
possuindo do lado esquerdo a opção clicada na paleta Common do tipo TextView e o componente campo com o nome 
Hello World, e no lado direito duas telas da aplicação nas cores branco e verde com o nome centralizado Hello World. 
 
Até aqui você aprendeu como criar um novo projeto com a classe Widgets. Na seção a 
seguir, você vai aprender sobre os conceitos da classe Widgets com a descrição dos seus principais 
métodos. 
 
8.2 Conceito da classe Widget 
A classe widgets é responsável por herdar da classe View e são utilizados para estruturar 
o layout das telas de uma aplicação Android. Essa subclasse de View implementa o método onDraw 
(Canvas) que é responsável por desenhar o componente na tela. Essa classe Canvas utilizada no 
onDraw define os métodos para desenhar texto, linhas, bitmaps e outras primitivas gráficas. 
Geralmente utilizamos alguns componentes prontos do próprio Android, como TextViews, EditText e 
Buttons, mas você pode criar o seu próprio componente, por meio da sua própria View, com a classe 
que herde de View e implementar o método onDraw (Canvas). Os métodos mais importantes da 
classe View pode ser visualizado na Tabela 8.1 abaixo: 
 
 
 
150 
Método Descrição 
onDraw(Canvas) O método onDraw é responsável por desenhar algum 
componente de layout na tela do Android. 
setPadding(direita, 
abaixo, esquerda, acima) 
O método setPadding é responsável por informar o 
espaçamento à direita, abaixo, à esquerda e acima em pixels 
que devem ser colocados na tela do Android antes de inserir 
algum componente. No XML esse método equivale a função 
android:padding que define um único valor e esse mesmo 
valor ser aplicado a todos os parâmetros.Caso necessite 
informar um valor diferente para cada espaçamento, deve 
utilizar os seguintes atributos android:paddingLeft, 
android:paddingTop, android:paddingRight e 
android:paddingBottom, respectivamente. 
setVisibility(visibility) O método setVisibility pode receber três valores definidos 
pelas constantes View.VISIBLE, View.INVISIBLE e 
View.GONE. A constante View.VISIBLE é responsável pela 
exibição do componente na tela, já as constantes 
View.INVISIBLE e View.GONE são responsáveis pela não 
exibição do componente na tela. A diferença entre essas 
duas constantes é que a constante View.INVISIBLE não exibe 
o elemento, porém deixa o espaço que ele usaria reservado 
na tela (em branco), enquanto a constante View.GONE faz 
com que se remova tanto o elemento quanto o espaço 
utilizado na tela. No XML esse método é equivalente ao 
android:visibility que recebe os seguintes valores: visible, 
invisible e gone. 
 
 
Tabela 8.1 – Métodos da classe View 
Fonte: o autor 
Descrição da imagem: a descrição dos três métodos da classe View. 
 
 
151 
 
Nas seções a seguir, você vai aprender sobre os componentes TextView, EditText e 
ImageView. Além disso, os componentes button, ImageButton, CheckBox e RadioButton serão 
mostrados na próxima competência. 
 
8.2.1 TextView 
A classe TextView é considerada uma subclasse da classe View responsável por desenhar 
um determinado texto na tela das aplicações. A classe TextView no arquivo XML é representado pela 
seguinte sintaxe <TextView/>. Para escrever um texto normal na tela é utilizada a seguinte 
declaração android:text="Hello World". Assim como a declaração do endereço de site é utilizada a 
seguinte declaração android:text=" https://ead.educacao.pe.gov.br/". A seguir será mostrado alguns 
exemplos para utilizar a classe TextView com descrição de nome, descrição de site e utilizando nomes 
com diversas cores. 
Por exemplo, imagine que existe um determinado layout de aplicativo possuindo textos 
com a descrição de nome, descrição de site e os nomes com diversas cores. Diante desse exemplo, 
você vai aprender como utilizar a classe TextView para editar formato de texto. O arquivo 
activity_main.xml mostrado na Figura 5.2, abaixo, possui o layout LinearLayout e classe TextView. 
Esse código do activity_main.xml representando o layout LinearLayout e a classe TextView com 
descrição de nome, descrição de site e utilizando nomes com diversas cores pode ser visualizado na 
Figura 8.2 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 <TextView 
 android:id="@+id/text01" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="Hello World!" 
 /> 
 <TextView 
 
 
152 
 android:id="@+id/text02" 
 android:layout_width="wrap_content" 
 android:layout_height="match_parent" 
 android:autoLink="web" 
 android:text="https://ead.educacao.pe.gov.br/" 
 /> 
 <TextView 
 android:id="@+id/text03" 
 android:layout_width="wrap_content" 
 android:layout_width="wrap_content" 
 android:background="#0000ff" 
 android:textColor="#ffffff" 
 android:text="Texto branco (text_color) e fundo azul (background)" 
 /> 
 
</LinearLayout> 
 
Figura 8.2 – Arquivo activity_main.xml do TextView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do TextView possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e as três tags de TextView representadas pelas propriedades de texto normal com o nome Hello 
World!, texto com o site https://ead.educacao.pe.gov.br/" e com o texto personalizado por cores com o nome Texto 
branco (text_color) e fundo azul (background). 
 
 
Depois da execução do arquivo activity_main.xml com TextView com descrição de nome, 
descrição de site da Figura 8.2, acima, e gerado o designer da tela no Android Studio visualizado na 
Figura 8.3 abaixo: 
 
 
153 
 
Figura 8.3 – Tela do TextView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o TextView. A tela do lado 
esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três botões do 
celular e na parte do meio possui uma tela branca com a descrição do nome hello world com de texto preta, a descrição 
do site https://ead.educacao.pe.gov.br/ com cor vermelha e o texto Texto branco (text_color) e a descrição “Texto 
branco (text_color) e fundo azul (background)” com cor de texto branca e negrito azul, a tela do lado direito possui um 
quadrado com fundo verde representado a tela e três retângulos representando as três descrições. 
 
 
O TextView configura no arquivo MainActivity.java da Figura 8.4, abaixo, esse TextView 
possui um ID (identificador) definido pelo arquivo XML para recuperar um determinado componente 
no código Java, dessa maneira é possível executar o identificador R.id.text01 utilizando o método 
findViewById(), em seguida é utilizado o método setText() para mostrar o texto Hello World!. O código 
do arquivo MainActivity.java do Android Studio representando o TextView pode ser visualizado na 
Figura 8.4 abaixo: 
 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.TextView 
 
 
 
154 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 TextView textView = (TextView)findViewById((R.id.text01)); 
 textView.setText("Hello World!"); 
 } 
} 
 
 
 
Figura 8.4 – Arquivo da classe MainActivity.java do TextView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do TextView no arquivo activity_main.xml. 
 
 
8.2.2 EditText 
A classe EditText é utilizada quando se pretende criar um campo, onde um determinado 
usuário deve digitar uma informação do texto. A classe EditText no arquivo XML é representada pela 
seguinte sintaxe <EditText/>. A propriedade android:inputType é responsável por indicar o tipo de 
entrada mais adequado para a digitação dos campos. Para escrever um texto normal é utilizada a 
seguinte declaração android:inputType ="text". Os principais valores utilizando o EditText pode ser 
visualizado na Tabela 8.2 abaixo: 
 
Propriedade Descrição 
text Responsável pela descrição de texto normal 
textEmailAddress Responsável pela descrição do endereço de e-mail 
textUri Responsável pela descrição de endereços com recursos com 
URL. 
textPassword Responsável pela descrição de campo com senha. 
number Responsável pela descrição de apenas números sem sinal. 
NumberSigned Responsável pela descrição de apenas números com sinal. 
phone Responsável pela descrição de número de telefone. 
 
 
 
155 
Tabela 8.2 – Representação das propriedades do EditText 
Fonte: o autor 
Descrição da imagem: a descrição das seis propriedades do EditText. 
 
Essa classe EditText é utilizada também no processo de criação de formulários. A seguir 
será mostrado alguns exemplos para utilizar a classe EditText com os componentes text, 
textEmailAddress, textUri, textPassword, number, NumberSigned e phone. 
Por exemplo, imagine que existe um determinado layout com campos de descrição do 
jogo, e-mail do jogo, site do jogo,senha do jogo, número de acesso do jogo e telefone de contato do 
jogo. Diante desse exemplo, você vai aprender como utilizar a classe EditText na visualização de 
campos de edição utilizado nesse jogo. O arquivo activity_main.xml mostrado na Figura 8.5, abaixo, 
possui o layout LinearLayout e as classes TextView e EditText. Esse código do activity_main.xml 
representando o layout LinearLayout e as classes TextView e EditText pode ser visualizado na Figura 
8.5 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:id="@+id/text01" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:text="Descrição do jogo:" 
 /> 
 
 <EditText 
 android:id="@+id/edit01" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content"" 
 android:textSize="20dp" 
 android:inputType="text" 
 /> 
</LinearLayout> 
 
Figura 8.5 – Arquivo activity_main.xml do EditText 
Fonte: O autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do EditText possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e a tag TextView representando por texto a mensagem “descrição do jogo” e a tag EditText 
 
 
156 
representando como tipo de entrado um texto. 
 
Depois da execução do arquivo activity_main.xml com EditText da Figura 8.5, acima, e 
gerado o designer da tela no Android Studio visualizado na Figura 8.6 abaixo: 
 
 
Figura 8.6 – Tela do EditText 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o EditText. A tela do lado 
esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três botões do 
celular e na parte do meio possui uma tela branca com a descrição do texto com a mensagem “descrição do jogo” e 
uma linha representando o tipo de entrada com texto, a tela do lado direito possui um quadrado com fundo verde 
representado a tela e dois retângulos representando a descrição do texto e o campo de entrada de texto representada 
por EditText. 
 
O EditText configura no arquivo MainActivity.java da Figura 8.7, abaixo, esse EditText 
possui um ID (identificador) definido pelo arquivo XML para recuperar um determinado componente 
no código Java, dessa maneira é possível executar o identificador R.id.edit01 utilizando o método 
findViewById(), em seguida é utilizado o método setText() para mostrar o texto o jogo possui três 
telas com acesso ao jogo do mario, Lol e barkbringe!"!. O código do arquivo MainActivity.java do 
Android Studio representando o EditText pode ser visualizado na Figura 8.7 abaixo: 
 
 
157 
 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.EditText 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 EditText editText = (EditText) findViewById((R.id.edit01)) ; 
 editText.setText("O jogo possui três telas com acesso ao jogo do 
mario, Lol e barkbringe!"); 
 
 } 
} 
 
 
Figura 8.7 – Arquivo da classe MainActivity.java do EditText 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do EditText no arquivo activity_main.xml. 
 
O código XML do Android Studio representando o layout LinearLayout e a classe TextView 
com inputType textEmailAddress pode ser visualizado na Figura 8.8 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:textSize="20dp" 
 android:text="Email do jogo:" 
 /> 
 
 <EditText 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:inputType="textEmailAddress" 
 /> 
 
 
158 
 
</LinearLayout> 
 
Figura 8.8 - Arquivo activity_main.xml do EditText com textEmailAddress 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do EditText com endereço de e-mail possuindo a representação da tag LinearLayout com os 
componentes altura, largura e orientação vertical, e a tag TextView representando por texto a mensagem “Email do 
jogo” e a tag EditText representando como tipo de entrado uma endereço de e-mail. 
 
O código XML do Android Studio representando o layout LinearLayout e a classe TextView 
com inputType textUri pode ser visualizado na Figura 8.9 abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:text="site do jogo:" 
 /> 
 
 <EditText 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:inputType="textUri" 
 /> 
 
</LinearLayout> 
 
Figura 8.9 - Arquivo activity_main.xml do EditText com textUri 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do EditText com endereço de site possuindo a representação da tag LinearLayout com os componentes 
altura, largura e orientação vertical, e a tag TextView representando por texto a mensagem “site do jogo” e a tag 
EditText representando como tipo de entrado uma endereço de site. 
 
O código XML do Android Studio representando o layout LinearLayout e a classe TextView 
com inputType textPassword pode ser visualizado na Figura 8.10 abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 
 
159 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:text="Senha do jogo:" 
 /> 
 
 <EditText 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:inputType="textPassword" 
 /> 
 
</LinearLayout> 
 
Figura 8.10 – Arquivo activity_main.xml do EditText com textPassword 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação da senha de acesso possuindo a representação da tag LinearLayout com os componentes altura, largura 
e orientação vertical,e a tag TextView representando por texto a mensagem “senha do jogo” e a tag EditText 
representando como tipo de entrado uma senha de acesso. 
 
O código XML do Android Studio representando o layout LinearLayout e a classe TextView 
com inputType number pode ser visualizado na Figura 8.11 abaixo: 
 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:text="Número de acesso do jogo:" 
 /> 
 
 <EditText 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:inputType="number" 
 /> 
</LinearLayout> 
 
Figura 8.11 - Arquivo activity_main.xml do EditText com number 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
 
 
160 
representação do número possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e a tag TextView representando por texto a mensagem “Número de acesso do jogo” e a tag EditText 
representando como tipo de entrado uma senha de acesso. 
 
O código XML do Android Studio representando o layout LinearLayout e a classe TextView 
com inputType NumberSigned pode ser visualizado na Figura 8.12 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:text="Pontuação do jogo:" 
 /> 
 <EditText 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:inputType="numberSigned" 
 /> 
</LinearLayout> 
 
Figura 8.12- Arquivo activity main.xml do EditText com NumberSigned 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do número com ponto possuindo a representação da tag LinearLayout com os componentes altura, 
largura e orientação vertical, e a tag TextView representando por texto a mensagem “Pontuação do jogo” e a tag 
EditText representando como tipo de entrado uma pontuação do jogo. 
 
O código XML do Android Studio representando o layout LinearLayout e a classe TextView 
com inputType phone pode ser visualizado na Figura 8.13 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 
 
161 
 android:layout_height="wrap_content" 
 android:textSize="20dp" 
 android:text="telefone de contato do jogo:" 
 /> 
 <EditText 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:inputType="phone" 
 /> 
</LinearLayout> 
 
Figura 8.13 - Arquivo activity main.xml do EditText com phone 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do telefone possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e a tag TextView representando por texto a mensagem “Telefone de contato do jogo” e a tag 
EditText representando como tipo de entrado um numeração com telefone. 
 
 
8.2.3 Imageview 
 A classe ImageView é utilizada quando se pretende visualizar uma determinada imagem. 
A classe ImageView é representada pela seguinte sintaxe <ImageView/>. Para declarar um 
identificador com o nome da imagem é utilizada a seguinte declaração 
android:id="@+id/imageView" para a declaração da altura da imagem é utilizada a seguinte 
declaração android: layout_width="match_parent" e da largura da imagem a seguinte declaração 
android: layout_height="wrap_content". Cada imagem possui uma respectiva pasta com o caminho 
da imagem representada pela seguinte declaração android:src="@drawable/ic_launcher". Essa 
imagem pode ser representada por imagem normal (com apenas a figura), imagem da internet 
através de URL e imagem por representação de catálogo. 
Por exemplo, imagine que existe um determinado layout com a visualização das imagens 
dos jogos Mario e Lol. Diante desse exemplo, você vai aprender como utilizar a classe ImageView na 
visualização de imagens de jogos. O arquivo activity_main.xml mostrado na Figura 8.14, abaixo, 
possui o layout LinearLayout e a classe ImageView. Esse código do activity_main.xml representando 
o layout LinearLayout e a classe ImageView pode ser visualizado na Figura 8.14 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 
 
162 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <ImageView 
 android:id="@+id/imgBtn01" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:src="@mipmap/ic_launcher_mario" 
 /> 
 <ImageView 
 android:id="@+id/imgBtn02" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:src="@mipmap/ic_launcher_lol" 
 /> 
</LinearLayout> 
 
Figura 8.14 – Arquivo activity main.xml do ImageView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação da ImageView possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e as duas tags ImageView representada pelas imagens do jogo do Mario e o jogo do Lol. 
 
Depois da execução do arquivo activity_main.xml com ImageView da Figura 8.14, acima, 
e gerado o designer da tela no Android Studio visualizado na Figura 8.15 abaixo: 
 
 
 
163 
 
Figura 8.15 – Tela da Imageview 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando a Imageview. A tela do 
lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três 
botões do celular e na parte do meio possui uma tela branca com as imagens dos jogos Mario e Lol, a tela do lado 
direito possui um quadrado com fundo verde representado a tela e dois retângulos com o nome ImageView 
representando as duas imagens. 
 
A ImageView configura no arquivo MainActivity.java da Figura 8.16, abaixo, essa 
ImageView possui um ID (identificador) definido pelo arquivo XML para recuperar um determinado 
componente no código Java, dessa maneira é possível executar os identificadores R.idimgBtn01 e 
R.id.imgBtn02 utilizando o método findViewById(), em seguida é utilizado o método 
setImageResource() para acessar as imagens do mario e lol na pasta do Android Studio. O código do 
arquivo MainActivity.java do Android Studio representando a ImageView pode ser visualizado na 
Figura 8.16 abaixo: 
 
 
 
164 
 
package com.example.eadpernambuco;import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget. ImageView 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 ImageView imageView1 = (ImageView) findViewById(R.id.imgBtn01); 
 imageView1.setImageResource(R.mipmap.mario); 
 ImageView imageView2 = (ImageView) findViewById(R.id.imgBtn02); 
 imageView2.setImageResource(R.mipmap.lol); 
 
 } 
} 
 
 
Figura 8.16 – Arquivo da classe MainActivity.java do ImageView 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do ImageView no arquivo activity_main.xml. 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
• A classe Widgets 
• O componente TextView 
• O componente EditText 
• O componente ImageView 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
165 
 
 
Agora, o próximo passo é mergulhar na competência 9, que trata sobre conceitos 
avançados da classe Widget gerada pela classe View e sobre os componentes Button, ImageButton, 
CheckBox, RadioButton e Spinner. Vamos juntos? 
 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a vídeo aula sobre a competência. 
 
 
166 
9. Competência 09 | Utilizar recursos avançados de view 
Caro estudante, vamos iniciar a nona competência! Nesta competência você vai aprender 
os conceitos avançados da classe widget que herda diretamente da classe view. A classe widget possui 
outros elementos avançados utilizando botão, como ImageButton e o Button. Em seguida você vai 
aprender sobre os componentes Checkbox e RadioButton. Por fim sobre o componente Spinner. 
Vamos aprofundar mais sobre os avanços da classe widget! 
 
9.1 Avanços da Widget 
A classe widget possui diversos outros componentes que herdam diretamente da classe 
view. Os componentes que utilizam botões como o Button e o ImageButton, além dos componentes 
com CheckBox, RadioButtone e Spinner. O CheckBox é responsável por desenhar uma caixa de 
seleção ou caixa de verificação utilizando elemento da interface gráfica, RadioButton responsável por 
selecionar uma única opção de uma determinada lista e o Spinner é responsável por desenhar na tela 
um combobox, ou seja, um conjunto de opções. Nas seções a seguir você vai aprender sobre os 
componentes Button, ImageButton, CheckBox, RadioButton e Spinner. 
 
9.1.1 Button 
A classe Button é responsável pela criação de novos botões na tela das aplicações. A classe 
Button no arquivo XML é representado pela seguinte sintaxe <Button />. Para declarar um botão é 
necessário a identificação do botão com a seguinte sintaxe android:id="@+id/bt01". A declaração de 
altura e largura são representadas pelas seguintes sintaxes android:layout_width ="match_parent" e 
android: layout_height="wrap_content" e para declarar o nome do texto do botão é utilizada a 
seguinte sintaxe android:text="Botão 01". 
Por exemplo, imagine que existe um determinado layout de aplicativo possuindo botão 
de acesso dos jogos de Mario e Lol. Diante desse exemplo, você vai aprender como utilizar a classe 
Button para criar um novo botão. O arquivo activity_main.xml mostrado na Figura 9.1, abaixo, possui 
o layout LinearLayout e duas classes Button com os botões “botão de acesso do Mario” e “botão de 
acesso do Lol”. Esse código do activity_main.xml representando a classe Button pode ser visualizado 
na Figura 9.1 abaixo: 
 
 
167 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <Button 
 android:id="@+id/btn01" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="Botão de acesso do Mario"/> 
 
 <Button 
 android:id="@+id/btn02" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="Botão de acesso do Lol"/> 
 
</LinearLayout> 
 
Figura 9.1 – Arquivo activity main.xml do Button 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do Button possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e as duas tags Button representada pelos botões com o nome “Botão de acesso do Mario” e “Botão 
de acesso do Lol”. 
 
Depois da execução do arquivo activity_main.xml com Button da Figura 9.1, acima, e 
gerado o designer da tela no Android Studio visualizado na Figura 9.2 abaixo: 
 
 
 
168 
Figura 9.2 – Tela do Button 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o componente button. A tela do 
lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três botões 
do celular e na parte do meio possui uma tela branca com dois botões na cor cinza com os nomes “BOTÃO DE ACESSO 
DO MARIO” e “BOTÃO DE ACESSO DE LOL”, a tela do lado direito possui um quadrado com fundo verde representado a 
tela e dois retângulos representando os botões com os nomes “BOTÃO DE ACESSO DO MARIO” e “BOTÃO DE ACESSO 
DE LOL”. 
 
 
O Button é executado no arquivo MainActivity.java da Figura 9.3, abaixo, possuindo um 
ID (identificador) definido pelo arquivo XML para recuperar um determinado componente no código 
Java, dessa maneira é possível executar os identificadores R.id.btn01 e R.id.btn02 utilizando o método 
findViewById(), em seguida é utilizado o método setText() para mostrar o texto do botão 01 “Botão 
de acesso do Mario e do botão 02 “Botão de acesso do Lol”. O código do arquivo MainActivity.java 
do Android Studio representando o Button pode ser visualizado na Figura 9.3 abaixo: 
 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.Button 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 Button botao1 = (Button) findViewById((R.id.btn01)); 
 botao1.setText("Botão de acesso do Mario"); 
 Button botao2 = (Button) findViewById((R.id.btn02)); 
 botao2.setText("Botão de acesso do Lol"); 
 
 } 
} 
 
 
Figura 9.3 – Arquivo da classe MainActivity.java do Button 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do Button no arquivo activity_main.xml. 
 
 
 
 
 
169 
9.1.2 ImageButton 
A classe ImageButton é responsável pela criação de novos botões representada por 
imagem na tela das aplicações. A classe Button no arquivo XML é representado pela seguinte 
sintaxe <ImageButton/>. Para declarar um botão com imagem é necessário a identificação do 
botão com a seguinte sintaxe android:id="@+id/btImg01". A declaração de altura e largura são 
representadas pelas seguintes sintaxes android:layout_width="match_parent" e 
android:layout_height="wrap_content" e para declarar o caminho da imagem do botão é utilizado 
a seguinte sintaxe android:scr="@drawable/android_mini2". 
Por exemplo, imagine que existe um determinado layout de aplicativo possuindo botão 
com imagemdos jogos de Mario e Lol. Diante desse exemplo, você vai aprender como utilizar a classe 
ImageButton para criar o botão com imagem. O arquivo activity_main.xml mostrado na Figura 9.4, 
abaixo, possui o layout LinearLayout e duas classes ImageButton com os botões com imagens dos 
jogos de Mario e Lol. Esse código do activity_main.xml representando a classe ImageButton pode ser 
visualizado na Figura 9.4 abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <ImageButton 
 android:id="@+id/imgBtn01" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:src="@mipmap/mario" 
 android:contentDescription="todo" /> 
 <ImageButton 
 android:id="@+id/imgBtn02" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:src="@mipmap/lol" 
 android:contentDescription="todo" /> 
</LinearLayout> 
 
Figura 9.4 - Arquivo activity_main.xml do ImageButton 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do ImageButton possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e as duas tags ImageButton representada pelos botões com imagens dos jogos Mario e Lol. 
 
 
 
170 
Depois da execução do arquivo activity_main.xml com ImageButton da Figura 9.4, acima, 
e gerado o designer da tela no Android Studio visualizado na Figura 9.5 abaixo: 
 
Figura 9.5– Tela do ImageButton 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o componente ImageButton. A 
tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três 
botões do celular e na parte do meio possui uma tela branca com dois botões de imagens dos jogos Mario e Lol”, a tela 
do lado direito possui um quadrado com fundo verde representado a tela e dois retângulos representando os botões de 
imagem com o nome das imagens dos jogos Mario e Lol. 
 
A ImageButton é executado no arquivo MainActivity.java da Figura 9.6, abaixo, possuindo 
um ID (identificador) definido pelo arquivo XML para recuperar um determinado componente no 
código Java, dessa maneira é possível executar os identificadores R. imgBtn01 e R.id.imgBtn02 
utilizando o método findViewById(), em seguida é utilizado o método setImageResource() para 
acessar as imagens do mario e lol na pasta do Android Studio. O código do arquivo MainActivity.java 
do Android Studio representando a ImageButton pode ser visualizado na Figura 9.6 abaixo: 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
 
 
171 
import android.widget.ImageButton 
 
public class MainActivity extends AppCompatActivity { 
 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 ImageButton imageButton1 = (ImageButton) 
findViewById(R.id.imgBtn01); 
 imageButton1.setImageResource(R.mipmap.mario); 
ImageView imageView1 = (ImageView) findViewById(R.id.imgBtn01); 
 ImageButton imageButton2 = (ImageButton) 
findViewById(R.id.imgBtn02); 
 imageButton2.setImageResource(R.mipmap.lol); 
 
 } 
} 
 
Figura 9.6 – Arquivo da classe MainActivity.java do ImageButton 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do ImageButton no arquivo activity_main.xml. 
 
9.1.3 CheckBox 
O Checkbox é um componente do Android responsável pelo estado de marcado e 
desmarcado. Geralmente, esse componente é utilizado quando se pretende fazer uma escolha 
mútua, no qual não seja mutuamente exclusiva. O componente Checkbox no arquivo XML é 
representado pela seguinte sintaxe <CheckBox />. Para declarar um componente Checkbox é 
necessário a declaração de altura e largura representadas pelas seguintes sintaxes 
android:layout_width ="match_parent" e android:layout_height="wrap_content" e texto com a 
opção do Checkbox é utilizado a seguinte sintaxe android:text="opcaodocheckbox". 
Por exemplo, imagine que existe um determinado formulário que pergunta quais tipos 
de jogos você domina ou conhece e existem várias opções: mortal kombat, kung fu for, MMA Fighter 
e Gangsters, caso você conheça mais de um jogo de luta é ideal utilizar o componente Checkbox para 
representar essas várias opções. Diante desse exemplo, você vai aprender como utilizar o 
componente Checkbox para escolher uma opção desse jogo. 
O arquivo activity_main.xml mostrado na Figura 9.7, abaixo, possui o layout LinearLayout, 
a classe TextView com a descrição "Assinale os jogos que você domina ou conhece:" e quatro 
 
 
172 
componentes Checkbox com as opções dos jogos mortal kombat, kung fu for, MMA e Gangsters. Esse 
código do activity_main.xml representando o Checkbox pode ser visualizado na Figura 9.7 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="Assinale os jogos que você domina ou conhece:"/> 
 
 <LinearLayout 
 android:layout_width="match_parent" 
 android:layout_height="match_parent"> 
 
 <CheckBox 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="mortal kombat" 
 /> 
 <CheckBox 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="kung fu for" 
 /> 
 <CheckBox 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="MMA Fighter " 
 /> 
 <CheckBox 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="Gangsters" 
 /> 
 
 </LinearLayout> 
</LinearLayout> 
 
Figura 9.7 - Arquivo activity_main.xml do Checkbox 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do Checkbox possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e a tag TextView com a descrição “Assinale os jogos que você domina ou conhece:” e quatro tags 
Checkbox com as opções Mortal Kombat, kunf fu for, MMA Fighter e Gangsters. 
 
 
 
173 
O Checkbox é executado no arquivo MainActivity.java da Figura 9.8, abaixo, possuindo 
um ID (identificador) definido pelo arquivo XML para recuperar um determinado componente no 
código Java, dessa maneira é possível verificar caso o checkbox está marcado ou não está marcado. 
Isso é realizado através do método isChecked(). O código do arquivo MainActivity.java do Android 
Studio representando o Checkbox pode ser visualizado na Figura 9.8 abaixo: 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.CheckBox; 
 
public class MainActivity extends AppCompatActivity { 
 
 @Override 
 protectedvoid onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 CheckBox chkBox = (CheckBox) findViewById(R.id.checkboxJava); 
 boolean checkboxSelecionado = chkBox.isChecked(); 
 } 
} 
 
Figura 9.8 – Arquivo da classe MainActivity.java do Checkbox 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java possuindo a 
execução da tela do CheckBox no arquivo activity_main.xml. 
 
Caso o Checkbox esteja marcado com a seleção dos jogos Mortal kombat e MMA indica 
que os valores de Mortal kombat e MMA estão selecionados. A tela do Android Studio representando 
o componente de Checkbox para identificar mais de um jogo de luta pode ser visualizado na Figura 
9.9 abaixo: 
 
 
174 
 
Figura 9.9 – Tela do checkbox 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o componente 
ImageButton. A tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na 
barra inferior três botões do celular e na parte do meio possui uma tela branca com a descrição do nome na cor preta 
“Assinale os jogos que você domina ou conhece:", e quatro checkbox com nos nomes Mortal Kombat, kunf fu for, MMA 
Fighter e Gangsters, a tela do lado direito possui um quadrado com fundo verde representado a tela e cinco quadrados 
retângulos representando a descrição do nome e quatro checkbox. 
 
 
9.1.4 RadioButton 
O RadioButton é um componente do Android responsável por selecionar uma única opção 
de uma determinada lista. Geralmente, esse componente é utilizado quando o usuário pretende fazer 
uma única escolha, ou seja, as opções são mutuamente exclusivas, não sendo assim possível ter mais 
de uma resposta para a mesma pergunta. O componente RadioButton no arquivo XML é 
representado pelas seguintes classes <RadioGroup /> e <RadioButton />. A classe RadioGroup é 
responsável por definir um grupo que contém uma lista de opções, no qual cada opção é 
representada por um respectivo RadioButton. 
Para declarar um componente RadioGroup é necessário realizar a declaração de altura e 
largura com as seguintes sintaxes android:layout_width="match_parent" e 
android:layout_height="wrap_content", assim como a orientação do layout com a seguinte sintaxe 
android:orientation=" horizontal". Com relação ao componente RadioButton é necessário realizar a 
 
 
175 
declaração do ID (identificador) do componente com a seguinte sintaxe android:id="@+id/radioM". 
Já a declaração de altura e largura devem ser realizadas com as seguintes sintaxes 
android:layout_width="match_parent" e android:layout_height="wrap_content" e o texto com a 
opção de sexo com a seguinte sintaxe android:text ="Feminino ". 
Por exemplo, imagine que existe um determinado formulário de jogo que pergunta o sexo 
dos seus jogadores, este pode ser masculino ou feminino, ou quando se pretende fazer uma pergunta 
de execução do jogo e a resposta é sim ou não. Diante desse exemplo, você vai aprender como utilizar 
o componente RadioButton para escolher o sexo dos jogadores desse jogo. 
O arquivo activity_main.xml mostrado na Figura 9.10, abaixo, possui o layout 
LinearLayout, a classe TextView com a descrição "Sexo:", o componente RadioGroup e dois 
componentes RadioButton com as opções Masculino e Feminina. Esse código do activity_main.xml 
representando o layout LinearLayout e os componentes RadioGroup e RadioButton pode ser 
visualizado na Figura 9.10 abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:id="@+id/lblSexo" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:text="Sexo:" 
 /> 
 
 <RadioGroup 
 android:id="@+id/radioGroup" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="horizontal"> 
 
 <RadioButton 
 android:id="@+id/radioM" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="Masculino"/> 
 
 <RadioButton 
 android:id="@+id/radioF" 
 android:layout_width="wrap_content" 
 android:layout_height="wrap_content" 
 android:text="Feminina" 
 
 
176 
 /> 
 </RadioGroup> 
</LinearLayout> 
 
 
Figura 9.10 - Arquivo activity_main.xml do RadioButton 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do RadioButton possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, e a tag RadioGroup com os componentes altura, largura e orientação vertical e duas tags do 
RadioButton representando as opções masculino e feminina. 
 
O RadioGroup é executado no arquivo MainActivity.java da Figura 9.11, abaixo, possuindo 
ID (identificador) definido pelo arquivo activity_main.xml para identificar um componente no código 
Java, dessa maneira quando se escolhe um RadioButton o outro vai ser automaticamente 
desmarcado. Isso é verificado através do método do RadioGroup chamado 
getCheckedRadioButtonId(). O código do arquivo MainActivity.java do Android Studio representando 
o RadioButton pode ser visualizado na Figura 9.11 abaixo: 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.widget.RadioGroup; 
 
public class MainActivity extends AppCompatActivity 
{ 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 RadioGroup radioGroup = (RadioGroup) findViewById(R.id.radioGroup); 
 boolean radioM_Checked = R.id.radioM == 
radioGroup.getCheckedRadioButtonId(); 
 } 
} 
 
Figura 9.11 - Arquivo da classe MainActivity.java do RadioButton 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java do RadioButton 
possuindo a execução da tela do RadioButton no arquivo activity_main.xml. 
 
Caso o valor de RadioButton masculino seja considerado verdadeiro indica que o 
RadioButton com o valor Masculino está selecionado, da mesma maneira pode-se fazer para o 
 
 
177 
RadioButton Feminino. A tela do Android Studio representando o componente RadioButton com o 
sexo dos jogadores pode ser visualizado na Figura 9.12 abaixo: 
 
Figura 9.12 – Tela do RadioButton 
Fonte: o autor. 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o componente RadioButton. A 
tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três 
botões do celular e na parte do meio possui uma tela branca com a descrição do nome na cor preta “Sexo dos 
jogadores:", e dois RadioButton representando as opções Masculino e Feminino, a tela do lado direito possui um 
quadrado com fundo verde representado a tela, uma linha representando o texto “Sexo dos jogadores:" e dois 
quadrado representando os dois RadioButton. 
 
 
9.1.5 Spinner 
 O Spinner é um componente do Android responsável por selecionar um valor a partir de 
um conjunto de dados de um combobox. No estado padrão, esse Spinner mostra o seu valor 
atualmente selecionado nesse combobox. A seleção do Spinner exibe um menu com todos os outros 
valores disponíveis, a partir do qual o usuário pode selecionarum novo. 
 O componente Spinner no arquivo XML é representado pela seguinte classe <Spinner/>. 
No Spinner é necessário declarar a altura e largura utilizando as seguintes sintaxes 
android:layout_width ="match_parent" e android:layout_height="wrap_content". Além disso, o 
identificador do combobox possui a seguinte declaração android:id=" +@id/combobox ". 
 
 
178 
Por exemplo, imagine que existe uma determinada lista de jogos e ao selecionar o jogo a 
aplicação irá exibir a imagem do jogo. Diante desse exemplo, você vai aprender como utilizar o 
componente Spinner para selecionar um jogo e mostrar a imagem desse jogo. 
O arquivo activity_main.xml mostrado na Figura 9.13, abaixo, possui o layout 
LinearLayout, a classe TextView com a descrição "Selecione um jogo:", o componente Spinner com a 
opção de combobox dos jogos Barkbridge, Lol e Mario e o componente ImageView com a imagem do 
jogo selecionado. Esse código do activity_main.xml representando o layout LinearLayout e os 
componentes TextView, ImageView e Spinner pode ser visualizado na Figura 9.13 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" 
 tools:context=".MainActivity"> 
 
 <TextView 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:text="Selecione um jogo:" 
 /> 
 
 <Spinner 
 android:id="@+id/combobox" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 /> 
 
 <ImageView 
 android:id="@+id/imgJogo" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 /> 
 
</LinearLayout> 
 
Figura 9.13 - Arquivo activity_main.xml do Spinner 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo activity_main.xml com a 
representação do RadioButton possuindo a representação da tag LinearLayout com os componentes altura, largura e 
orientação vertical, a tag TextView representando o texto “Selecione um jogo:”, Spinner representando o combobox e a 
tag ImageVew representando a imagem do Mario. 
 
 
O Spinner é executado com imagens para preencher o seu combobox, para utilizar essas 
imagens você precisa baixá-las e colocá-las na pasta drawable. Sempre que você quiser exibir uma 
 
 
179 
imagem no seu aplicativo, você pode colocá-la nessa pasta e, para ter acesso a essa imagem, basta 
digitar R.drawable.NOME_DA_IMAGEM sem a extensão do arquivo (.jpg, .png, etc.). O Spinner 
configura no arquivo MainActivity.java da Figura 9.14, abaixo, as imagens dos jogos barkbridge, lol e 
mario na pasta do drawable, além disso, utiliza o método onCreate() para configurar os itens do 
combobox do jogo, o onItemSelected() para executar um item da seleção quando tiver sido 
selecionado e o método onNothingSelected() para executar um item da seleção quando não tiver 
sido selecionado na exibição do seu combobox. O código do arquivo MainActivity.java do Android 
Studio representando o Spinner pode ser visualizado na Figura 9.14 abaixo: 
 
package com.example.eadpernambuco; 
import androidx.appcompat.app.AppCompatActivity; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.AdapterView; 
import android.widget.ArrayAdapter; 
import android.widget.ImageView; 
import android.widget.Spinner; 
 
public class MainActivity extends AppCompatActivity { 
 
 private int[] imagens = {R.drawable.ic_launcher_barkbridge_background, 
R.drawable.ic_launcher_lol_background, 
 R.drawable.ic_launcher_mario_background}; 
 private String[] jogos = new String[]{"barkbridge", "lol", "mario"}; 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
 super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity_main); 
 
 final ImageView imgJogo = (ImageView) findViewById(R.id.imgJogo); 
 Spinner combobox = (Spinner) findViewById(R.id.combobox); 
 ArrayAdapter adaptador = new ArrayAdapter<String> 
 (this, android.R.layout.simple_spinner_item, jogos); 
 
adaptador.setDropDownViewResource(android.R.layout.simple_spinner_item); 
 combobox.setAdapter(adaptador); 
 
 combobox.setOnItemSelectedListener(new 
AdapterView.OnItemSelectedListener() { 
 
 @Override 
 public void onItemSelected(AdapterView<?> parent, View view, int 
position, long id) { 
 
 imgJogo.setImageResource(imagens[position]); 
 } 
 
 @Override 
 
 
180 
 public void onNothingSelected(AdapterView<?> parent) { 
 
 } 
 }); 
 } 
} 
 
Figura 9.14 – Arquivo da classe MainActivity.java do Spinner 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo MainActivity.java do Spinner 
possuindo a execução do Spinner com as três opções do jogo barkbridge", "lol", "mario". 
 
 
Caso a opção selecionada no jogo seja Mario indica a visualização do arquivo do Mario 
executado na pasta drawable do Android Studio. A tela do Android Studio representando o 
componente de Spinner com as opções de jogos barkbridge, Lol e Mario pode ser visualizado na Figura 
9.15 abaixo: 
 
 
Figura 9.15 – Tela do Spinner 
 
 
181 
Fonte: o autor 
Descrição da imagem: a imagem apresenta duas telas do Android Studio representando o componente ImageButton. A 
tela do lado esquerdo possui na parte superior uma barra azul com o nome EADPernambucoPDM, na barra inferior três 
botões do celular e na parte do meio possui uma tela branca com a descrição do nome na cor preta “Selecione um 
jogo:", a tag Spinner com a opção Mario selecionada e uma imagem representando o jogo Mario , a tela do lado direito 
possui um quadrado com fundo verde representado a tela, duas linhas representando o texto “Selecione um jogo:", e a 
opção do Spinner, e uma quadrado representando a imagem pela tag ImageView. 
 
E aí, estudante, foi legal o caminho até aqui! O bom é que até aqui você aprendeu sobre: 
 
• A classe Widgets 
• O componente Button 
• O componente ImageButton 
• O componente CheckBox 
• O componente RadioButton 
• O componente Spinner 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
Agora, o próximo passo é mergulhar na competência 10, que trata sobre como planejar e 
executar o compartilhamento da sua aplicação no Google Play. Vamos juntos? 
 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a vídeo aula sobre a competência. 
 
 
182 
10. Competência 10 | Planejar e executar o compartilhamento do APK 
Caro estudante, vamos iniciar a décima competência! Nesta competência você vai 
aprender sobre o versionamento da aplicação e a compatibilidade para instalação da APK (Android 
Package) que representa um pacote destinado a uma nova aplicação gerada no Android Studio. Em 
seguida, você vai aprender sobre a assinatura da aplicação com certificado digital e assinatura da 
aplicação para publicá-la no Google Play. Por fim, sobre com publicar a sua aplicação no Google Play. 
Vamos entender como realizar a publicação de APK no Google Play! 
 
10.1 Versionamento da aplicação 
O versionamento da aplicação em Android possui como extensão de arquivo a sigla APK 
(Android Package). APK é considerado um pacote destinado a uma nova aplicação gerada pelo 
Android. A primeira modificação para realizar a publicação do seu aplicativo é definir ou atualizar a 
sua versão no arquivo AndroidManifest.xml. O códigodo arquivo AndroidManifest.xml do Android 
Studio com versionamento da aplicação pode ser visualizado na Figura 10.1 abaixo: 
 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco" 
 android:versionCode="1" 
 android:versionName="0.0.1-beta"> 
 
 <application 
 android:allowBackup="true" 
 android:icon="@mipmap/ic_launcher" 
 android:label="@string/app_name" 
 android:roundIcon="@mipmap/ic_launcher_round" 
 android:supportsRtl="true" 
 android:theme="@style/AppTheme"> 
 <activity android:name=".MainActivity"> 
 <intent-filter> 
 <action android:name="android.intent.action.MAIN" /> 
 <category android:name="android.intent.category.LAUNCHER" /> 
 </intent-filter> 
 </activity> 
 </application> 
</manifest> 
 
Figura 10.1 - Arquivo AndroidManifest.xml com versionamento da aplicação 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o código do arquivo AndroidManifest.xml com a 
declaração do versionamento da aplicação na tag manifest possuindo as configurações das propriedades versionCode e 
versionName. 
 
 
183 
 
 
As propriedades modificadas no arquivo AndroidManifest.xml são android:versionCode e 
android:versionName. A propriedade versionCode é utilizada para modificar a versão da aplicação no 
Google Play. Por exemplo, imagine que você lançou um aplicativo com versão "2.0" e uma semana 
depois precisou fazer uma correção de bug (erro no código) e lançará uma nova versão. Nesse caso, 
você pode nomeá-la como "2.1" e lançar a atualização. Já a propriedade versionName indica ao 
usuário o versionamento da aplicação que está instalada. Dessa maneira, o usuário pode apresentar 
uma versão anterior à versão da loja e ele pode identificar essa desatualização pelo nome da versão 
apresentado através da propriedade versionName. 
Caso você esteja executando o Android Studio, existe um arquivo chamado build.gradle 
que fica em Gradle Scripts que contém as configurações de build da sua APK. Nesse arquivo, assim 
como no AndroidManifest.xml você também pode definir o versionCode e o versionName da sua 
aplicação. Esse arquivo build.gradle possui prioridade sobre as configurações de build do projeto, ou 
seja, caso você defina o versionName e versionCode no AndroidManifest.xml, mas o seu projeto 
também possui o arquivo build.gradle localizado no Gradle Scripts, as informações usadas serão as 
informações contidas no build.grade, como visualizado na Figura 10.2 abaixo. O código do arquivo 
build.gradle do Android Studio com a descrição da versão pode ser visualizado na Figura 10.3 abaixo: 
 
Figura 10.2 - Estrutura de um projeto do Android Studio com a configuração do arquivo build.gradle 
Fonte: o autor 
 
 
184 
Descrição da imagem: a imagem apresenta um fundo preto com a estrutura de pastas de um projeto criado no Android 
Studio e mostra onde o arquivo build.gradle está localizado. 
 
apply plugin: 'com.android.application' 
 
android { 
 compileSdkVersion 29 
 buildToolsVersion "29.0.2" 
 defaultConfig { 
 applicationId "com.example.eadpernambuco" 
 minSdkVersion 26 
 targetSdkVersion 29 
 versionCode 1 
 versionName "1.0" 
 testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" 
 } 
 buildTypes { 
 release { 
 minifyEnabled false 
 proguardFiles getDefaultProguardFile('proguard-android-
optimize.txt'), 'proguard-rules.pro' 
 } 
 } 
} 
dependencies { 
 implementation fileTree(dir: 'libs', include: ['*.jar']) 
 implementation 'androidx.appcompat:appcompat:1.0.2' 
 implementation 'androidx.constraintlayout:constraintlayout:1.1.3' 
 testImplementation 'junit:junit:4.12' 
 androidTestImplementation 'androidx.test.ext:junit:1.1.0' 
 androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1' 
} 
 
Figura 10.3- arquivo build.gradle com a descrição da versão 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o arquivo build.gradle.possuindo destacando o valor 
dos atributos versionCode na versão 1 e o valor do atributo versionName na versão“1.0”. 
 
10.2 Compatibilidade para instalação 
A compatibilidade da versão é uma configuração importante no momento da geração do 
build.gradle ou versão da sua aplicação. Dessa maneira, esse arquivo build possui uma propriedade 
chamada minSdkVersion que especifica a menor versão que a aplicação deve suportar, ou seja, 
especifica a versão pela qual sua aplicação pode ser instalada. Caso a versão do Android seja inferior 
a ela, a Google Play não vai permitir que o usuário instale a aplicação. Existe também a propriedade 
targetSdkVersion que especifica a última versão que a sua aplicação pode ser instalada. Os códigos a 
seguir mostram como especificar o minSdkVersion e targetSdkVersion no arquivo 
 
 
185 
AndroidManisfest.xml visualizado na Figura 10.4, abaixo, e o arquivo build.gradle.java visualizado na 
Figura 10.5 abaixo: 
<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
 package="com.example.eadpernambuco" > 
 
 ...> ... 
 <uses-sdk 
 android:minSdkVersion="10" 
 android:targetSdkVersion="21" /> 
 
</manifest> 
 
Figura 10.4 - arquivo AndroidManisfest.xml com a descrição do minSdkVersion e targetSdkVersion 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o arquivo AndroidManifest.xml possuindo a descrição 
do minSdkVersion na versão 10 e do targetSdkVersion na versão 21. 
 
apply plugin: 'com.android.application' 
 
android { 
 compileSdkVersion 29 
 buildToolsVersion "29.0.2" 
 defaultConfig { 
 applicationId "com.example.eadpernambuco" 
 minSdkVersion 26 
 targetSdkVersion 29 
 versionCode 1 
 versionName "1.0" 
 testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" 
 } 
 buildTypes { 
 release { 
 minifyEnabled false 
 proguardFiles getDefaultProguardFile('proguard-android-
optimize.txt'), 'proguard-rules.pro' 
 } 
 } 
} 
dependencies { 
 implementation fileTree(dir: 'libs', include: ['*.jar']) 
 implementation 'androidx.appcompat:appcompat:1.0.2' 
 implementation 'androidx.constraintlayout:constraintlayout:1.1.3' 
 testImplementation 'junit:junit:4.12' 
 androidTestImplementation 'androidx.test.ext:junit:1.1.0' 
 androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1' 
} 
 
Figura 10.5- arquivo build.gradle 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com o arquivo build.gradle possuindo as configurações 
identificador do aplicativo com o nome "com.example.eadpernambuco", com a descrição do versionCode com a versão 
1, versionName com a versão. "1.0" 
 
 
186 
10.3 Assinatura da aplicação com certificado digital 
O processo de instalação de uma aplicação em um celular ou emulador necessita da 
assinatura digital. Quando você compila usando o modo Debug esse processo é realizado de maneira 
automática no Android Studio. Contudo para realizar a assinatura de uma APK no Google Play é 
necessário gerar o seu próprio certificado através do JDK (Java Development Kit), dessa maneira você 
deve possuir uma chave privada e com essa chave deve assinar APK durante o build. 
No Android Studio você deve clicar no menu Build e depois em Generate Signed APK como 
visualizado na Figura 10.6 abaixo. Em seguida, a nova janela será aberta Generate signed Bundle or 
APK, como visualizado na figura 10.7 abaixo: 
 
Figura 10.6 – Tela geração de certificado do Android Studio 
Fonte: o autor 
Descrição da imagem: a imagem apresentaum fundo preto com a tela do Android Studio de geração de certificado 
possuindo a opção Build na cor azul e executando a opção Generate Signed Bundle / APK. 
 
 
187 
 
Figura 10.7 - Tela geração de certificado do Android Studio 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com a tela do Android Studio de geração de certificado 
possuindo a seleção da opção APK, em seguida na parte de baixo da tela a opção next para prosseguir. 
 
Em seguida, você deve clicar em next como mostrado na figura 10.7, acima, para iniciar o 
processo de criação da assinatura digital. A tela para gerar o certificado digital pode ser visualizada 
na Figura 10.8 abaixo: 
 
Figura 10.8 – Tela geração de certificado do Android Studio 
 
 
188 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com a tela do Android Studio de geração de certificado 
possuindo a seleção do campo módulo com a opção app e a opção do botão create new, em seguida na parte de baixo 
da tela a opção next para prosseguir. 
 
Na Figura 10.8, acima, você pode escolher uma assinatura existente ou criar um novo 
arquivo de assinatura no formato jks (Keystore Java) que serve como repositório de certificados e 
chaves privadas. Caso seja um aplicativo novo, crie um novo arquivo através do botão Create new... 
para assiná-lo; se for um arquivo que já foi assinado utilize o botão Choose existing... . para selecionar 
o arquivo anterior. Vamos seguir os passos de criação de um novo arquivo clicando no botão Create 
new... A tela com o novo arquivo chave pode ser visualizada na Figura 10.9 abaixo: 
 
Figura 10.9 – Tela do novo armazenamento de chave preenchido 
Fonte: o autor 
Descrição da imagem: a imagem apresenta um fundo preto com a tela do Android Studio com seguintes campos chave 
alias, password, validaty, first and last name, organization unit, organization, city or locality, state or province, em 
seguida na parte debaixo da tela clica na opção de botão com a seleção OK. 
 
 
 
 
189 
Na Figura 10.9, acima, você deve preencher alguns campos e clicar no botão OK. 
• Key store path : caminho para salvar o arquivo no formato jks. 
• Password : senha para o arquivo. 
 
Key (Chave): 
• Alias : um "apelido" para essa chave; esse nome é de escolha do desenvolvedor. Eu 
geralmente deixo o Alias com o mesmo nome do App. 
• Password : senha para a chave que está sendo criada. Essa senha pode ser diferente 
da senha anterior, do arquivo, ou você pode manter a mesma senha para não 
confundir, no entanto, para melhor segurança é bom ter senhas diferentes. 
• Validity : validade desse certificado em anos. 
• First and Last Name : primeiro e último nome, pode ser o seu nome. 
• Organizational Unit : nome da sua unidade organizacional (campo opcional). 
• Organization : nome da sua organização (campo opcional). 
• City or Locality : cidade ou localização (campo opcional). 
• State or Province : Estado ou província (campo opcional). 
• Country Code(XX) : código do país (campo opcional). 
 
10.4 Assinatura da aplicação para publicá-la no Google Play 
Com o certificado criado existe a possibilidade de utilizar essa assinatura na sua APK. Mas 
como realizar isso? Para assinar a sua respectiva APK utilizando o certificado que você criou, basta 
importá-lo no Android Studio clicando no botão Choose existing..., digitar a sua senha e gerar a sua 
APK assinada clicando no botão Next. A tela utilizando o botão Choose existing pode ser visualizada 
na Figura 10.10 abaixo: 
 
 
190 
 
Figura 10.10 – Tela do Assinando APK com as configurações preenchidas 
Fonte: o autor. 
Descrição da imagem : a imagem apresenta um fundo preto com a tela assinando uma APK do Android Studio com os 
configurações preenchidas possuindo os campos Module com a opção app, key store path com a opção preenchida 
chave_teste_as.jks, key store password com a senha preenchida, key alias com a opção alias e key password com a 
senha preenchida , em seguida na parte de baixo da tela a opção next para prosseguir. 
 
Na figura 10.10, acima, você deve clicar no botão next para aparecer uma janela pedindo 
para informar o local onde você deseja que a sua APK assinada seja gerada e ao final do processo 
basta clicar em Finish. A tela com o processo final da sua APK assinada pode ser visualizada na Figura 
10.11 abaixo. 
 
 
191 
 
Figura 10.11 – Tela da assinando APK com a finalização da assinatura 
Fonte: o autor 
Descrição da imagem a imagem apresenta um fundo preto com a tela assinando uma APK do Android Studio no final da 
assinatura com os campos Destination folder com a descrição preenchida, a opção release selecionad com a cor azul, em 
seguida na parte de baixo da tela a opção finish para finalizar a assinatura. 
 
Na Figura 10.11, acima, você deve escolher o Build type (tipo de compilação) entre release 
(lançamento) ou debug (desenvolvimento). Como vamos enviar à loja, este é um build de release. Em 
Signature Versions (versões de assinatura) selecione as duas opções V1 e V2. O tipo de assinatura V2 
é relativamente novo no Android, antes o padrão era a V1; a V2 veio junto com a versão 7.0 do 
Android, e de acordo com a documentação do Android devemos escolher esses dois tipos. Por fim, 
clique em Finish (finalizar). 
 
10.5 Publicando a sua aplicação no Google Play 
O processo para publicar uma aplicação na Google Play é considerado um processo bem 
trivial, basta entrar no site do Google Play console https://play.google.com/apps/publish/. Caso você 
 
 
192 
esteja logado na conta do Google já abrirá a página da Figura 10.12, abaixo, caso contrário você 
precisará logar a sua conta no Google, na qual a sua aplicação será associada na sua conta. 
 
Figura 10.12 - Tela de aceitação do contrato como desenvolvedor da Google Play 
Fonte: o autor 
Descrição da imagem: a imagem apresenta a tela do site com informações da conta da Google do usuário que está 
logado, com o valor a ser cobrado pela licença de desenvolvedor, com os termos de uso e um botão para continuar o 
pagamento. 
 
O processo para aceitar o contrato do desenvolvedor necessita de quatro passos. O 
primeiro é necessário fazer o login com uma conta Google, depois aceitar os termos de uso do 
contrato disponível em: https://play.google.com/about/developer-distribution-agreement.html, 
pagar a taxa de 25 dólares pelo aplicativo e, por fim, fornecer os detalhes da conta como é exibido na 
Figura 10.13 abaixo. 
 
 
 
193 
 
Figura 10.13 - Tela de pagamento, basta inserir o cartão de crédito e pagar 25 dólares. 
Fonte: o autor 
Descrição da imagem: a imagem apresenta a tela do site com as informações do cartão de crédito juntamente com o 
valor da licença para o pagamento. 
 
Após o pagamento do aplicativo confirmado e de realizar o cadastro das suas informações 
você pode realizar a publicação da sua aplicação. Em seguida, deve preencher um formulário com 
uma breve descrição da sua aplicação e enviar algumas telas dessa aplicação. Depois disso, deve 
preencher algumas informações do aplicativo e fazer o upload da APK assinada, escolher a categoria 
da sua aplicação e informar se essa aplicação é paga ou gratuita. 
Por fim, depois de publicar essa aplicação no Google Play, essa será disponibilizada 
imediatamente para qualquer outro usuário instalar. A cada nova versão dessa aplicação que você 
atualizar é preciso modificar os parâmetros versionCode e versionName, como mostrado na seção 
versionamento de aplicação. Assim, os usuários dessas aplicações serão notificados sobre a existência 
de uma nova versão, e assim podem realizar a atualização quando desejarem. 
 
 
194 
 
 
E aí, estudante, foi legal o caminho até aqui. O bom é que até aqui você aprendeu sobre: 
• Versionamento da aplicação 
• Compatibilidade para instalação 
• Assinatura da aplicação com certificado digital 
• Assinatura da aplicação para publicá-la no Google Play• Publicando a sua aplicação no Google Play 
 
Há! E antes de seguir a diante pergunte-se: 
Será que você captou as lições corretamente? 
caso não, é melhor revisar o conteúdo abordado antes de seguir para os próximos passos. 
 
 
Agora, o último passo é focar na avaliação do curso programador de dispositivos móveis. 
Vamos lá? 
 
 
Saiba mais sobre como publicar um Aplicativo Android na Play Store 2020 
https://www.youtube.com/watch?v=yY9hQhE18K4 
 
 
Pronto para inserir mais informações em seu banco de dados? 
Acesse o AVA e assista a vídeo aula sobre a competência 10. 
https://www.youtube.com/watch?v=yY9hQhE18K4
 
 
195 
Conclusão 
Olá novamente, desenvolvedor! Chegamos ao final de nossa jornada! Espero que os 
conhecimentos acumulados em nosso passeio tenham lhe ajudado a alcançar a compreensão das 
noções iniciais e essenciais do desenvolvimento de aplicativos para a plataforma Android e sejam a 
base para eventuais experiências. 
Não se acanhe em retornar para este e-book caso você tenha dúvidas em relação às 
noções iniciais do desenvolvimento de aplicativos para Android, pois o conhecimento necessário em 
lições futuras é cumulativo, ou seja, o que foi visto aqui não pode ser tratado de forma isolada: servirá 
como base em outras aplicações que você talvez queira experimentar fora das lições abarcadas neste 
material didático. 
Falando em experimentação, lhe incentivo a tentar de forma criativa utilizar os 
conhecimentos deste caderno para criar aplicações com propostas diferentes dos exemplos 
construídos aqui neste conteúdo. Desafie-se ir além! 
 
Cordialmente, Rebecca Linhares e Danilo de Sousa. 
 
 
 
 
 
 
 
 
 
 
196 
Referências 
LECHETA, Ricardo. Google Android. Aprenda A Criar Aplicações Para Dispositivos Móveis Com O 
Android SDK. São Paulo: Novatec, 2010. 
GLAUBER, Nelson. Dominado o Android. São Paulo: Novatec, 2015. 
LECHETA, Ricardo. Android Essencial com Kotlin. São Paulo: Novatec, 2018. 
GLAUBER, Nelson. Dominado o Android com Kotlin. São Paulo: Novatec, 2019. 
QUEIRÓS, Ricardo. Android Profissional. Desenvolvimento Moderno de Aplicações. Lisboa: FCA, 
2018. 
SCHILDT, Herbert. Java para iniciantes: crie, compile e execute programas Java rapidamente. Porto 
Alegre: Bookman, 2015. 
Site oficial de desenvolvedores Android: https://developer.android.com/?hl=pt-br 
 
 
 
 
197 
Minicurrículo do Professor 
 
Rebecca Linhares 
Mestre em Ciências da Computação no Centro de Informática (CIn) na universidade 
Federal de Pernambuco (UFPE). Possui graduação em Bacharelado em Sistemas de Informação pelas 
Faculdades Integradas Barros Melo (2009). Atualmente é professora do curso técnico de 
Desenvolvimento de Sistemas, na modalidade EAD, na Secretaria de Educação do estado de 
Pernambuco, professora formadora das disciplinas: Edição e Processamento de Imagens e 
Programação para Dispositivos Móveis, e conteudista da disciplina de Introdução a Programação para 
Dispositivos Móveis. 
 
Danilo de Sousa Barbosa 
Mestre em Engenharia da Computação na universidade Federal de Pernambuco (UPE), 
Especialização em Gestão e Qualidade em Tecnologia da Informação e Comunicação no Instituto 
Federal de Pernambuco (IFPE). Possui graduação em Bacharelado em Sistemas de Informação pela 
Universidade de Pernambuco (UPE). Atualmente possui doutorado em andamento em Ciência da 
Computação no Centro de Informática (CIn) da Universidade Federal de Pernambuco (UFPE) e 
professor de ensino a distância do curso técnico de Desenvolvimento de Sistemas da Escola Técnica 
Estadual Professor Antônio Carlos Gomes da Costa (ETEPAC) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	Introdução
	1. Competência 01 | Introduzir os conceitos básicos de um sistema operacional móvel, configurar e conhecer o ambiente de desenvolvimento
	1
	1.1 O que é o Android
	1.1.1 Sistema operacional Linux
	1.1.2 Código aberto e livre
	1.2 Arquitetura da plataforma
	1.3 Os diversos sabores do Android
	1.4 Google Play
	1.5 O ambiente de desenvolvimento
	1.5.1 Instalação do JDK
	1.5.2 Instalação e configuração do Android Studio
	1.6 Configuração do AVD no Android Studio
	2. Competência 02 | Formatar uma Activity para o Desenvolvimento, Utilizando Operadores Matemáticos
	2
	2.1 Conceitos Básicos
	2.1.1 Iniciando um novo projeto com Android Studio
	2.1.2 Estrutura de um projeto Android
	2.1.2.1 Arquivo AndroidManifest.xml
	2.1.2.2 Classe MainActivity
	2.1.2.3 Arquivo de Layout activity_main.xml
	2.1.3 Processo de compilação e execução de um projeto Android
	2.2 Variáveis
	2.3 Tipo de dados
	2.3.1 Tipo de dado primitivo
	2.3.2 Tipo de dado lógico
	2.3.3 Tipo de dado numérico Inteiros
	2.3.4 Tipo de dado numérico de ponto flutuante
	2.3.5 Tipo de dado de caractere
	2.3.6 Tipo de dado complexo: String
	2.4 Separadores
	2.5 Operadores
	2.5.1 Operadores Aritméticos
	2.5.1.1 Incremento e decremento
	2.5.2 Operadores Relacionais e Lógicos
	2.5.3 Operadores de atribuição
	2.5.3.1 Operadores de atribuições abreviadas
	3. Competência 03 | Formatar uma Activity para o desenvolvimento de instruções de controle de programa
	3
	3.1 Estruturas de controle condicional
	3.1.1 Estrutura if
	3.1.1.1 Estrutura if-else
	3.1.1.2 Estrutura if-else aninhada
	3.1.2 Estrutura Switch
	3.2 Estruturas de repetição
	3.2.1 Estrutura For
	3.2.2 Estrutura While
	3.2.3 Estrutura Do-While
	4.Competência 04 | Formatar uma Activity para utilização de Arrays
	4
	4.1 Arrays
	4.1.1 Arrays Unidimensionais
	4.1.2 Arrays Multidimensionais
	4.1.2.1 Arrays Bidimensionais
	5. Competência 05 | Conhecer o Activity em detalhes
	5
	5.1 Criando um novo projeto com Activity
	5.2 Conceito de Activity
	5.3 Ciclo de vida de uma Activity
	5.4 Navegabilidade entre Activity
	5.5 Navegabilidade Simples de uma Activity para outra
	5.6 Navegação entre telas com passagem de parâmetros
	6. Competência 06 | Manipular Action bar e temas
	6
	6.1 Criando um novo projeto com Action Bar
	6.2 Conceito de Action Bar
	6.3 Conceito de temas
	6.4 Customização de Action Bar com botão
	6.5 Modificando Action Bar com temas
	7. Competência 07 | Conhecer os conceitos de interface gráfica - gerenciadores de layout
	7
	7.1 Criando um novo projeto com a classe ViewGroup
	7.2 Conceito da classe View
	7.3 Conceito da classe ViewGroup
	7.3.1 LinearLayout
	7.3.2 ConstraintLayout
	7.3.3 RelativeLayout
	7.4 Dimensões dos componentes do layout
	8. Competência 08 | Conhecer os conceitos de interface gráfica – view
	8
	8.1 Criando um novo projeto com a classe Widget
	8.2 Conceito da classe Widget
	8.2.1 TextView
	8.2.2 EditText
	8.2.3 Imageview
	9. Competência 09 | Utilizar recursos avançados de view
	9
	9.1 Avanços da Widget
	9.1.1 Button
	9.1.2 ImageButton
	9.1.3 CheckBox
	9.1.4 RadioButton
	9.1.5 Spinner
	10. Competência 10 | Planejar e executar o compartilhamento do APK
	10
	10.1 Versionamento da aplicação
	10.2 Compatibilidade para instalação
	10.3 Assinatura da aplicação com certificado digital
	10.4 Assinatura da aplicação para publicá-la no Google Play
	10.5 Publicando a sua aplicação no Google Play
	Conclusão
	Referências
	Minicurrículo do Professor