Programação Introdução ao Coding Mobile

Prévia do material em texto

Introdução ao Coding 
(Mobile)
Presidente do Conselho de Administração: 
Janguiê Diniz
Diretor-presidente: 
Jânio Diniz
Diretoria Executiva de Ensino:
Adriano Azevedo
Diretoria Executiva de Serviços Corporativos:
Joaldo Diniz
Diretoria de Ensino a Distância:
Enzo Moreira
Créditos Institucionais
Todos os direitos reservados
2018 by Telesapiens
Introdução ao Coding 
(Mobile)
Olá! Meu nome é Luiz Fernando Corcini. Sou formado em 
Engenharia Eletrônica, com especialização em Administração 
de TI, Mestre em Educação e Novas Tecnologias e Doutorando 
em Sistemas Tutores Inteligentes. Tenho experiência técnico-
profissional na área de desenvolvimento e gestão da produção 
de softwares nas áreas de Gerenciamento de Processos 
Empresariais. Uso os recursos disponibilizados pela Web há 
mais de 20 anos. Sou professor universitário há mais de 15 
anos, publiquei vários livros técnicos sobre assuntos voltados 
à área de informática. Fui convidado pela Editora Telesapiens 
a integrar seu elenco de autores independentes. Estou muito 
feliz em poder ajudar você nesta fase de muito estudo e 
trabalho. 
O AUTOR
Luiz Fernando Corcini
APRESENTAÇÃO
Olá. Meu nome é Manuela César. Sou a responsável pelo 
projeto gráfico de seu material. Esses ícones irão aparecer em 
sua trilha de aprendizagem significam:
RESUMINDO
Breve descrição do 
objetivo;
Breve descrição do 
objetivo;
Resumo 
acumulativo das 
últimas abordagens;
Parte retirada de um 
texto;
Foco em um objeto 
de estudo;
As observações escritas 
têm que ser priorizadas;
Destaque para 
sugestões e novas 
informações;
Informações 
adicionais sobre 
o conteúdo;
Links úteis 
para fixação da 
informação;
Apresentação de 
um novo conceito;
CITAÇÃO
TESTANDO
IMPORTANTE
DICA SAIBA MAIS
ACESSE
DEFINIÇÃO
+
OBJETIVO OBSERVAÇÃO
Todos os direitos reservados
2018 by Telesapiens
++
SUMÁRIO
UNIDADE 01
Android – Visão Geral......................................................15
Dispositivos Móveis...........................................................15
Android – Um pouco de História........................................16
Android – Características...................................................17
 Arquitetura da Plataforma........................................21
 Requisitos para o desenvolvimento de Apps...............22
Ambiente de Desenvolvimento Java para Mobile...........22
Instalar o JDK....................................................................23
 Configurando as Variáveis de Ambiente...................25
Instalar e Configurar o Android Studio...............................28
 Instando o Android Studio.......................................28
Configurar o Android SDK Manager..................................33
Testando o Ambiente de Desenvolvimento.........................35
Fechando a aplicação Android............................................41
Estrutura do Projeto Java-Android.................................42
Conhecendo a Interface Android Studio..............................43
 Tela de Boas Vindas.................................................43
 Tela Principal..........................................................44
 Demais Janelas de Ferramentas...............................47
Estrutura do projeto Java-Android......................................49
 Pasta Manifests........................................................50
 Pasta Java...............................................................55
 Pasta “res”..............................................................57
Java - Um pouco de história............................................58
A Tecnologia Java..............................................................59
 Esquema de execução de um programa em Java......60
 A Plataforma Java...................................................61
Entendendo, Instalando e Configurando o Ambiente Java..61
 Instalando o JDK....................................................62
 Instalando o IDE.....................................................62
 Testando o Eclipse...................................................63
UNIDADE 02
Java Básico........................................................................70
O Primeiro Projeto Java.....................................................70
 A Primeira Classe Java............................................73
Estrutura Básica da Linguagem Java..................................77
 Introdução................................................................77
 Estrutura de um Programa Java...............................77
 Identificadores.........................................................78
 Variáveis..................................................................80
 Tipos de Dados Simples............................................81
 Tipos de Dados Compostos......................................84
 Conversão de Tipos.........................................84
 Escopo de Variável..................................................86
 Modificadores de Acesso.........................................87
 Atributos Públicos..........................................88
 Atributos Privados..........................................88
 Operadores...............................................................90
 Operadores Aritméticos...................................91
 Operadores de Atribuição................................91
 Operadores de Incremento e Decremento.............92
 Operadores Relacionais................................93
 Operadores Booleanos..................................94
 Operador Ternário..................................................94
Estrutura de Controle de Seleção e de Repetição...........95
Introdução.........................................................................95
Estrutura de Controle de Seleção........................................95
 Comando if.............................................................95
 Comando if – else...................................................96
 Condições mais elaboradas....................................97
 O comando swicth...................................................98
Estrutura de Controle de Repetição..................................100
 while......................................................................100
 Controlando Loops................................................102
 O comando break...................................................102
 for.........................................................................102
 O comando continue............................................103
Classes em Java..............................................................104
Introdução.. .....................................................................104
Métodos...........................................................................105
Classes.............................................................................108
Polimormismo, Interface e Classes Abstratas................114
Polimorfismo...................................................................114
Interface...........................................................................118
 Declarando uma Interface.......................................118
Classes Abstratas..............................................................120
UNIDADE 03
Ciclo de vida do aplicativo Android e a Classe Activity..127
Introdução........................................................................127
Gerenciando aplicativos...................................................128
Ciclo de vida do aplicativo Android.................................129
A Classe Activity..............................................................131
Navegabilidade................................................................138
Introdução........................................................................138
Chamando a segunda Activity...........................................141
 Intenção de chamada...............................................141
 Evento de chamada................................................142Passagem de parâmetros entre telas..............................145
Inserindo componentes na tela.......................................150
Entendendo o Editor de Layout........................................151
TextView..........................................................................156
Pain Text..........................................................................159
Button..............................................................................160
Radio button.....................................................................161
Check box e Combo box..................................................163
UNIDADE 04
Tratamento de Eventos...................................................172
Definindo o Protótipo da Aplicação..................................172
Implementando a Aplicação..............................................173
 Preparando a Tela Principal...................................174
 Layout da Tela......................................................174
 Classe Activity da tela Principal...........................175
 Preparando a Tela2................................................176
 Layout da Tela2.....................................................176
 Classe Activity da Tela2.........................................177
 Preparando a Tela3................................................179
 Layout da Tela3....................................................179
 Classe Acticity da Tela3.......................................180
Capturando Resultados de uma Atividade....................181
Preparando as Telas da Aplicação.....................................184
Capturando a Seleção do Usuário.....................................186
Retornando o Item Selecionado........................................187
Chamando ações do sistema Android............................189
ACTION_VIEW..............................................................189
ACTION_PICK...............................................................192
ACTION_CALL..............................................................194
Layout de Tela................................................................196
Introdução........................................................................196
FrameLayout....................................................................196
LinearLayout ..................................................................199
 Relevância dos componentes.................................201
TableLayout.....................................................................203
 Atributo StretchColluns.........................................204
 Atributo ShrinkColluns.........................................207
 Combinando Layouts.............................................208
Introdução ao coding mobile12
UNIDADE
01
ESTRUTURA DE UM PROJETO ANDROID
Introdução ao coding mobile 13
 Seja bem-vindo(a) à Unidade 1 – Estrutura de um 
Projeto Android - da disciplina de Introdução ao Coding 
(Mobile). O conteúdo desta Unidade está dividido em 
quatro módulos. O primeiro módulo faz uma introdução 
a dispositivos móveis e ao sistema operacional Android, 
tratando um pouco sobre a história desse sistema, suas 
características e requisitos. No segundo Módulo explica 
passo a passo como instalar e configurar os componentes que 
formam o ambiente básico para iniciar seu aprendizado em 
programação móvel utilizando o Android Studio. Então temos 
o Módulo três, que apresenta as principais características 
da estrutura de projetos na plataforma Android, detalhando 
e explicando a funcionalidade de seus principais arquivos 
e classes, preparando o aluno para o desenvolvimento de 
aplicativos E, por fim, no último módulo desta Unidade 1, 
vamos apresentar a Plataformas Java de Desenvolvimento, 
um pouco de sua história, características, bem como o 
passo a passo para instalar o Ambiente de Desenvolvimento 
Integrado Java. É claro que existe muito mais a aprender, mas 
o aprofundamento de cada um destes conhecimentos pode ser 
feito acessando os links indicados durante o texto, no tópico 
[Saiba Mais]. Vamos começar? Excelente estudo para você! 
INTRODUÇÃO
Introdução ao coding mobile14
1
2
3
4
Olá! Se bem-vindo a nossa Unidade 1, e o nosso objetivo é 
auxiliar você no desenvolvimento das seguintes competências 
profissionais até o término desta etapa de estudos: 
OBJETIVOS
Conhecer o sistema operacional Android, sua história, 
características e requisitos;
Aprender a instalar e configurar os componentes básicos 
do Android StudiO;
Entender as principais características da estrutura de 
projetos na plataforma Android, suas funcionalidades de 
seus principais arquivos;
Conhecer a Plataforma Java de Desenvolvimento, um 
pouco de sua história, características, bem como o passo 
a passo para instalar o Ambiente de Desenvolvimento 
Integrado Java;
Introdução ao coding mobile 15
Android – Visão Geral
 Dispositivos móveis ou mobile devices, são pequenos 
computadores que normalmente cabem na palma da mão. Esses 
“computadores de mão” possuem uma tela que normalmente 
é sensível ao toque, para permitir ao usuário a entrada (input) 
de dados por meio de um miniteclado, apresentado na própria 
tela ou por meio de opções a serem selecionadas. A saída 
(output) pode ocorrer de várias formas, desde exibição de 
imagens, sons ou vídeos, até a execução de uma aplicação 
mais complexa, como envio ou recebimento de mensagens 
ou execução de programa especializado. Por se tratarem de 
minicomputadores, todos eles necessitam de um sistema 
operacional para gerenciar seu correto funcionamento e para 
que as várias aplicações possam ser executadas. 
 No entanto, apesar do avanço constante da tecnologia, 
esses dispositivos móveis ainda possuem algumas 
características e limitações relevantes e que devem ser 
consideradas quando do desenvolvimento de aplicativos, 
como por exemplo: 
 Tamanho do ecrã ;
 Memória limitada (primária e secundária);
 Poder de processamento limitado;
 Baixo consumo de energia e 
 Conectividade limitada. 
 Por conta destas características, os sistemas 
operacionais para dispositivos móveis, ou mobile operating 
systems (MOS), em inglês, precisam ter características 
diferentes dos sistemas operacionais para desktops. 
 Relativamente aos MOS mais utilizados, tem-se que, 
segundo relatório apresentado pela empresa IDC3(em maio de 
2017), o Android domina aproximadamente 85% do mercado 
de dispositivos móveis, tendo como segundo lugar o iOS, com 
aproximadamente 15%, como podemos verificar na figura 
Dispositivos Móveis
Introdução ao coding mobile16
Figura 1 – Quota de 
Marcado Mundial de 
S.O. para Smartphones.
Fonte: IDC – 05-2017.
1 Sistema Operacional: É o conjunto de programas que gerenciam recursos, 
processadores, armazenamento, dispositivos de entrada e saída e dados da 
máquina e seus periféricos. Exemplos: Dos, Unix, Linux, Mac OS, OS-2, 
Windows, etc. Fonte: Site Professor João Barreto (UFSC). Disponível em 
:http://www.inf.ufsc.br/~j.barreto/cca/sisop/sisoperac.html) – Acessado 
em: 05-09-2018.
2 Ecrã: Superfície fluorescente sobre a qual se forma a imagem nos tubos 
catódicos (televisão, informática, etc.) = Tela. Fonte: Dicionário Priberam 
da Língua Portuguesa. Disponível em: https://www.priberam.pt/dlpo/ecrã 
- Acessado em 05-09-2018.
 Assim como os MOS, as linguagens de programação 
devem estar adaptadas para as restrições dos dispositivos 
móveis. Entre as linguagens atualmente utilizadas, podemos 
citar: Java, C#, OPL, Objective-C, Ruby, entre outras. 
Neste material, trabalharemos com o MOS Android e com a 
Linguagem de Programação Java.
Android – Um pouco de História
 A empresa norte-americana Google foi fundada por 
Larry Page e Sergey Brin em 4 de setembro de 1998. Desde 
o início, a missão da empresa era “organizar as informações 
mundiais e torná-las universalmente acessíveis”. O foco do 
Google sempre foi hospedar e desenvolver uma série de produtos 
e serviços baseados na internet. De acordo com Meirelles(2009), depois de muita caminhada e de já estarem famosos 
com seu sistema de busca inovador, entre outros serviços e 
produtos, resolveram comprar, em 2005, uma pequena empresa 
de “sistemas embarcados4 ” chamada Android Inc. e decidiram 
entrar também no ramo de smartphones. 
Introdução ao coding mobile 17
 Dois anos depois (em 2007), o projeto foi apresentado ao 
público e se mostrou mais ambicioso do que simplesmente um 
modelo específico de smartphone. Era um sistema operacional 
com código aberto (open-source5) para dispositivos móveis, 
baseado em Linux, com uma interface de programação em 
Java. O Android estava sendo lançado!
Deixo aqui o link para dois sites interessantes se você quiser 
saber mais sobre a história do sistema operacional Android e 
todas as suas versões: (1) http://www.dsc.ufcg.edu.br/~pet/jornal/
agosto2013/materias/historia_da_computacao.html e (2) https://
www.androidpit.com.br/historia-do-android
SAIBA MAIS
 Agora que conhece um pouquinho da história do MOS 
Android, vamos apresentar suas características.
3IDC – International Data Corporation. Disponível em: https://www.idc.
com/promo/smartphone-market-share/os - Acessado em: 05-09-2018.
4Sistemas Embarcados: O sistema embarcado, também chamado de 
sistema embutido, é um sistema microprocessado em que um computador 
está anexado ao sistema que ele controla. Um sistema embarcado pode 
realizar um conjunto de tarefas que foram predefinidas. O sistema é 
usado para tarefas específicas, e assim, através de engenharia é possível 
otimizar um determinado produto e diminuir o tamanho, bem como os 
recursos computacionais e o seu valor final. Fonte: Site Oficina da Net – 
Disponível em: https://www.oficinadanet.com.br/post/13538-o-que-sao-
sistemas-embarcados. Acessado em: 15/09/2018.
5Código aberto (open-source): É um software de utilização livre, para quem 
quiser. Todos podem contribuir com ele, seja no seu desenvolvimento, 
seja na correção de erros, seja na documentação, desde que a condição 
de liberdade seja mantida. Exemplos: Linux, Android, Apache, gcc, 
Android – Características
 Android não é uma linguagem de programação, mas sim 
um sistema operacional Linux multiusuário. Para programar 
aplicativos para os dispositivos móveis que utilizam o SO 
++
Introdução ao coding mobile18
(sistema operacional) Android, são necessárias a instalação 
e a configuração de um ambiente de desenvolvimento 
apropriado, descrito em detalhes mais adiante neste material. 
Os programas escritos no ambiente de desenvolvimento 
Android devem ser compilados juntamente com todos os 
arquivos disponibilizados (recursos) de maneira a gerar um 
arquivo com a extensão APK, que é o arquivo utilizado pelos 
dispositivos para instalar a aplicação Android. 
APK vem de “Android Package”, Arquivo de Pacote de Aplicativos. 
É o formato de arquivo utilizado pelo MOS Android para distribuição 
e instalação de aplicativos para dispositivos móveis.
SAIBA MAIS
 Uma vez instalado no dispositivo, cada aplicativo recebe 
um número de identificação único, chamado de ID do usuário, de 
maneira que cada ID se torna um usuário Linux gerenciado pelo 
sistema Android. Este, por padrão, executa cada uma das IDs em 
processos separados, isto é, para cada aplicação que está em execução 
no dispositivo, existe uma Máquina Virtual (VM) que a gerencia e 
monitora, permitindo a cada uma delas acesso apenas aos recursos 
necessários para executar suas tarefas e nada mais. Esta característica 
de isolar as aplicações cria um ambiente mais seguro e otimizado, 
onde os aplicativos acessam apenas os recursos de que precisam. 
 Para o caso de aplicativos que precisam acessar dados ou 
recursos de outros aplicativos, eles devem compartilhar a mesma ID 
de usuário e, desta maneira, podem ser executados em um mesmo 
processo ou até mesmo compartilhar a mesma VM. 
 Outros tipos de permissão, tais como acessar os dados 
gravados no dispositivo (contatos, telefones) ou acessar recursos, 
como câmera ou bluetooth, devem ser definidos pelo programador 
no momento do desenvolvimento e da instalação do aplicativo. 
 Cada aplicação Android é formada por componentes, que 
++
Introdução ao coding mobile 19
são como blocos de construção, executam tarefas específicas e têm 
sua própria identificação. Podem ser utilizados como pontos de 
entrada do usuário ou para integração entre aplicativos, no caso de 
dependência de recursos. Dentro de um dispositivo móvel, como o 
celular, podem existir vários aplicativos instalados e pode-se utilizá-
los (executá-los) com um simples toque, o que permite imaginar que 
dois ou mais aplicativos podem estar rodando (sendo executados) ao 
mesmo tempo.
 No gerenciamento de aplicativos realizado pelo Android, 
um desses aplicativos (que estão sendo executados) sempre estará 
visível e os outros estarão parados temporariamente (com status igual 
a paused) ou parados definitivamente (com status igual a stopped), 
mas, ainda assim, ocupando memória e outros recursos, em segundo 
plano. Um caso comum ocorre quando o usuário está verificando seus 
compromissos no aplicativo calendário/agenda e recebe uma ligação, 
por exemplo. Nesse cenário, o Android vai parar temporariamente 
(pause) o aplicativo calendário/agenda e colocá-lo em segundo 
plano, enquanto o aplicativo que permite o atendimento da ligação 
(chamada telefônica) é colocado em primeiro plano e executado. 
Quando a ligação for encerrada, o Android fecha o aplicativo 
“chamada telefônica” e reposiciona o aplicativo calendário/agenda 
para o primeiro plano, permitindo que o usuário dê sequência à sua 
consulta de compromissos.
 Tudo parece bem simples, não é mesmo?! Mas, não é bem 
assim! 
 Como comentado anteriormente, os recursos de um dispositivo 
móvel são bastante limitados e o Android pode fechar qualquer 
aplicação que não esteja em primeiro plano, isto no caso de esses 
recursos ficarem em situação crítica ou quando alguma configuração 
do dispositivo for alterada. Esse fato pode causar grandes problemas, 
como por exemplo, no caso de o Android precisar fechar o aplicativo 
calendário/agenda, enquanto o usuário do dispositivo está atendendo 
uma ligação. Isso fará com que todos os compromissos não sejam 
salvos e, por consequência, serão perdidos. 
Introdução ao coding mobile20
Quando um aplicativo é desenvolvido para os dispositivos que 
trabalham com o Android, a programação desse aplicativo deve 
prever que ele pode parar temporariamente, quando colocado em 
segundo plano, e seus estados (configurações, dados etc.) devem ser 
salvos para que o usuário possa retomá-los, caso necessário. 
SAIBA MAIS
 Para auxiliar nesse gerenciamento dos aplicativos, o 
Android trabalha basicamente com quatro tipos diferentes de 
componentes. São eles: 
 Atividades (Activities);
 Serviços (Services);
 Provedores de Conteúdo (Content Providers) e
 Receptores de Broadcast (Broadcast Receivers).
 Sendo que, cada um dos itens acima relacionados serve 
para propósitos distintos e possuem diferentes ciclos de vida.
 Conforme destacado por Ogliari e Brito, 
“
”
Toda aplicação Android pode ser formada por 
uma ou mais Activities. Estas Activities são, na 
verdade, pequenas “atividades” executada uma 
de cada vez. A maneira mais fácil de entender 
as Activities é associar cada tela a uma Activity. 
Para controlar todas estas Activities, já que 
apenas uma Activity pode ser executada de cada 
vez, existe a Activity Stack, ou pilha de Activity.
(OGLIARI e BRITO, 2014).
++
Introdução ao coding mobile 21
O código fonte do Android está disponível no site: https:// source.
android.com/.
SAIBA MAIS
Arquitetura da Plataforma
 A arquitetura da plataforma Android está apresentada 
esquematicamente na figura abaixo:
Figura 2- Esquema 
básico da arquitetura da 
Plataforma Android
Fonte: (CORDEIRO, 
 Onde: (De acordo com o mesmo autor)
 Aplicativos: São os aplicativos e jogos desenvolvidos 
em Java;
 Frameworks, serviços bibliotecas: geralmente, 
também escritos em Java e servem para facilitaro 
desenvolvimento de aplicativos e jogos. 
 Bibliotecas e serviços nativos: são recursos que já 
vêm com o Android, para serem utilizados pelo desenvolvedor. 
 Linux é a base de tudo e inclui todos os drivers de 
hardware e redes (Bluetooth, câmeras, USB, GPS’s etc), 
sistemas de arquivos e processamento.
Para saber em detalhes como é a arquitetura da plataforma Android, 
acesse: https://developer.android.com/guide/platform/
SAIBA MAIS
Linux
Bibliotecas e Serviços 
nativos
Framewors
Serviços e
Bibliotecas
APLICATIVOS
++
++
Introdução ao coding mobile22
Requisitos para o desenvolvimento de Apps
 Para desenvolver aplicativos para o Android, são 
necessários alguns requisitos: 
 Conhecer as bases da programação em linguagem Java;
 Conhecimento básico sobre arquivos XML;
 Montar o ambiente de desenvolvimento, que consiste 
em: 
 Instalar e configurar o JDK6 ;
 Instalar e configurar o Android Studio;
 Configurar o SDK7 Manager;
 Vamos começar nossa aventura montando o ambiente 
de desenvolvimento.As bases da programação Java e dos 
conhecimentos necessários em arquivos XML serão apresentados 
durante o material em situação e profundidade oportunas, para 
que você possa tirar o máximo proveito e desenvolver com 
tranquilidade aplicações para dispositivos móveis.
 Dito isso, seguimos em frente com a mostrar como 
preparar o ambiente para desenvolvimento Java para Mobiles.
Ambiente de Desenvolvimento Java para 
Mobile
 Antes de desenvolver qualquer aplicação para 
dispositivos móveis faz-se necessário instalar e configurar 
o ambiente de desenvolvimento. Você já pode ir se 
acostumando, pois este é um procedimento normal para a 
maioria das linguagens de programação e para a maioria dos 
ambientes. Sendo assim, execute atentamente cada passo 
apresentado neste tópico, para que, ao terminar cada etapa, 
tenha baixado, instalado e configurado adequadamente o 
ambiente de desenvolvimento. 
6JDK – Java Development Kit – Kit de desenvolvimento Java.
7SDK – O Android SDK ou Kit de Desenvolvimento de Software para 
Android é um pacote com diversas ferramentas utilizadas pelo Android 
Studio e pelos desenvolvedores.
Introdução ao coding mobile 23
Instalar o JDK
 Como os aplicativos desenvolvidos para funcionar no 
MOS Android são desenvolvidos em linguagem Java, faz-se 
necessário instalar o kit de desenvolvimento Java, o qual pode 
ser encontrado para download em vários sites. Um deles é o 
que segue: http://www.oracle.com/technetwork/java/javase/
downloads/index.html
 Ao copiar e colar esta URL, seu navegador abrirá um 
site da ORACLE, como mostrado na figura abaixo:
Figura 3 – Baixando o JDK – Parte 
I
Fonte: Print da tela do Java 
(2018), Própria.
 Selecione (clique sobre) a palavra “download”, apresentada 
na figura acima, e uma nova tela será apresentada, permitindo 
que você escolha o arquivo para download referente ao sistema 
operacional da sua máquina, como mostrado na figura abaixo.
Figura 4 – Baixando 
o JDK – Parte II
Fonte: Print da tela 
do Java (2018)
 Para este material, será considerado que o sistema 
operacional de seu computador é o Windows 10 (64bits). 
Faça o download e execute o arquivo.
Não se esqueça de aceitar os termos de licença antes de selecionar 
o arquivo para fazer o download. 
OBSERVAÇÃO
+
Introdução ao coding mobile24
O arquivo mostrado na figura acima é a última versão disponível 
quando este material foi escrito. Pode ser que, quando você for instalar 
o JDK em seu computador, já exista uma versão mais atualizada.
IMPORTANTE
 Logo que o arquivo seja baixado, você deverá executá-
lo. Uma tela, como a mostrada abaixo, deve aparecer. Proceda 
conforme indicado: 
Figura 5 – Instalando o JDK
Fonte: Print da tela do Java (2018)
 Clique em NEXT;
Figura 6 - Instalando o JDK
Fonte: Print da tela do Java (2018)
 Selecione o diretório onde deve ser instalado o JDK e 
clique NEXT;
 Recomendo deixar o local do arquivo conforme 
definido por padrão.
Introdução ao coding mobile 25
Figura 7 - Instalando o JDK
Fonte: Print da tela do Java 
(2018)
 Aguarde a Instalação....
Figura 8 - Instalando o JDK
Fonte: Print da tela do Java 
(2018)
 JDK instalado com sucesso. Clique em CLOSE.
Configurando as Variáveis de Ambiente
 Após a instalação completa do JDK, configure as 
variáveis de ambiente necessárias para o computador conseguir 
localizar o aplicativo instalado. Os passos apresentados 
abaixo servem para o Sistema Operacional Windows 10.
 Passo 1: Acesse o Painel de Controle;
 Passo 2: Selecione a opção Sistema e Segurança -> 
Sistema -> Configurações avançadas do sistema e a seguinte 
tela será apresentada:
Introdução ao coding mobile26
Figura 9 – Tela para “Configurações 
Avançadas”
Fonte: Print da tela do Java (2018)
 Passo 3: Clique no botão “Variáveis de Ambiente”, como 
mostrado na figura acima, e a seguinte tela será apresentada:
Figura 10 – Variáveis de Ambiente
Fonte: Print da tela do Java (2018)
 Passo 4: Crie uma nova “Variável do Sistema” com 
o nome: JAVA_HOME e como valor da variável coloque 
o caminho onde foi instalado o JDK, como apresentado na 
figura abaixo:
Figura 11 – Criação de nova variável do 
sistema
Fonte: Print da tela do Java (2018)
 Passo 5: Clicar em OK, na tela da figura acima;
 Passo 6: Localize na lista de variáveis da figura 9, 
a variável de nome “Path” e clique duas vezes sobre ela. A 
seguinte tela será apresentada:
Introdução ao coding mobile 27
Figura 12 – Editando a variável Path
Fonte: Print da tela do Java (2018)
 Passo 7: Clique no botão “Novo” e digite o endereço 
do arquivo javac.exe, que é: “C:\Program Files\Java\
jdk1.7.0_04\bin” ou, se preferir: “%aJAVA_HOME%\bin”, 
como mostrado na figura acima.
 Passo 8: Clique em OK;
 Passo 9: Crie uma nova variável com o nome: 
CLASSPATH e coloque como valor da variável: “C:\Program 
Files\Java\jdk1.7.0_04\lib\”, como mostrado na figura abaixo:
Figura 13 – Criando a variável 
CLASSPATH
Fonte: Print da tela do Java 
 Passo 10: Depois de clicar em OK, reinicie o 
computador para que as alterações tenham efeito.
Muito bem, aparentemente o JDK está instalado, mas é bom 
fazer um teste, não é mesmo? Então vamos lá.
Para verificar se o JDK foi instalado corretamente e que o seu 
computar o está reconhecendo, entre no “Prompt do DOS” e 
digite o seguinte comando: “java –version”. O resultado deve 
ser parecido com o apresentado na figura abaixo:
Figura 14 – Testando a 
instalação do JDK
Fonte: Print da tela do prompt 
do DOS, (2018).
Introdução ao coding mobile28
 Ainda no Prompt do DOS, digite outro comando: 
“javac – version”. O resultado deve ser parecido com o 
apresentado na figura abaixo:
Figura 15 – Testando a instalação do 
JDK
Fonte: Print da tela do prompt do DOS, 
(2018).
Instalar e Configurar o Android Studio
 Neste tópico iremos instalar e configurar a ferramenta 
oficial de desenvolvimento Android do Google: o Android 
Studio. Siga os passos relacionados abaixo.
Instando o Android Studio
 Passo 1: Baixe o Android Studio;
 O link para baixar a ferramenta é: https://developer.
android.com/studio/?hl=pt-br. Ao clicar no link, aparecerá no 
navegador o seguinte cabeçalho de tela.
Figura 16 – Cabeçalho da 
tela do site oficial do Android 
Studio
Fonte: Print da tela do 
Android, (2018).
Caso seu Sistema operacional seja 64 bits, clique no botão de 
download, caso contrário, clique em “Download Options” e 
selecione o link para a versão 32 bits e siga as instruções do 
instalador.
IMPORTANTE
Introdução ao coding mobile 29
 O arquivo a ser baixado tem o seguinte nome “android-
studio-ide-173.4907809-windows.exe”. (na versão 64 bits, mas pode 
variar conforme o sistema operacional utilizado em seu computador).
 Passo 2: Execute o arquivo baixado
 Ao clicar duas vezes sobre ele, o assistente de instalação 
do Android Studio será iniciado, apresentando a seguinte tela:
Figura 17 – Primeira tela do Assistente de 
Instalação do Android Studio
Fonte: Print da tela do Android, (2018).
 Passo 3: Clique em “Next” ea seguinte tela será 
apresentada:
Figura 18 – Assistente de Instalação – Tela 
2
Fonte: Print da tela do Android, (2018).
 Passo 4: Verifique se o checkbox da opção “Android 
Studio” está marcada e marque também o checkbox da opção 
“Android Virtual Device”. 
 Passo 5: Clique em “Next”.
Figura 19 – Assistente de Instalação – Tela 3
Fonte: Print da tela do Android, (2018).
Introdução ao coding mobile30
 Passo 6: Escolha o local onde o aplicativo deve ser 
instalado. (Recomendo que deixe o padrão). 
 Passo 7: Clique “Next”.
Figura 20 – Assistente de Instalação – Tela 
4
Fonte: Print da tela do Android, (2018).
 Passo 8: Clique em “Next” e a processo de instalação 
terá início, como mostra a figura abaixo:
Figura 21 – Assistente de Instalação – Tela 5
Fonte: Print da tela do Android, (2018).
 Aguarde até a instalação ser completada.
 Passo 9: Clique em “Next”.
Figura 22 – Assistente de Instalação – Tela 6
Fonte: Print da tela do Android, (2018).
 Passo 10: Marque a opção para iniciar o aplicativo 
Android Studio.
 Passo 11: Clique em “Finish”. A seguinte tela 
aparecerá:
Introdução ao coding mobile 31
Figura 23 – Assistente de Instalação 
– Tela 7
 Fonte: Print da tela do Android, 
(2018).
 Passo 12: Selecione a opção para “Não importar 
configurações” (Do not import settings) e clique em “OK”. A 
instalação foi finalizada.
Vamos agora para configuração do Android Studio.
Configurando o Android Studio
 Após clicar em “OK” (Passo 12) da instalação, a tela 
do assistente de configuração irá aparecer.
Figura 24 – Tela do Assistente de 
Configuração – Tela 1
Fonte: Print da tela do Android, 
(2018).
 Passo 13: Clique em “Next”.
Figura 25 – Tela do Assistente de 
Configuração – Tela 2
Fonte: Print da tela do Android, 
(2018).
 Passo 14: Mantenha marcada a opção “Standard” 
para que a instalação aconteça com as configurações e opções 
padrão
Introdução ao coding mobile32
Figura 26 – Tela do Assistente de 
Configuração – Tela 3
Fonte: Print da tela do Android, (2018).
 Passo 16: Selecione a aparência desejada para a interface. 
Recomendo a opção “Dracula”, por que possui fundo mais 
escuro e por isso cansa menos a visão.
 Passo 17: Clique em “Next”.
Figura 27 – Tela do Assistente de 
Configuração – Tela 4
Fonte: Print da tela do Android, (2018).
 Passo 18: Clique em “Finish”. 
 Depois de instalado e configurado, a tela de boas-
vindas do Android Studio deve ficar assim:
Figura 28 – Tela da ferramenta Android 
Studio depois de instalada em seu 
computador.
Fonte: Print da tela do Android, (2018).
 Passo 15: Clique em “Next”.
Introdução ao coding mobile 33
 Antes de começar um novo projeto com esta 
ferramenta, precisamos verificar o SDK Manager
Configurar o Android SDK Manager
 Passo 19: Clique no botão “Configure” e na opção 
“SDK Manager”, conforme apresentado na figura abaixo:
Figura 29 – Configurando o SDK 
Manager
Fonte: Print da tela do Android, 
(2018).
A seguinte tela deverá ser apresentada:
Figura 30 – Configurando o SDK 
Manager
Fonte: Print da tela do Android, 
(2018).
 Passo 20: Selecione a guia SDK Platform e os itens 
apresentados na figura acima: da API Level 14 até a 28.
 Passo 21: Clique na guia SDK Tools e marque os itens 
apresentados na figura abaixo:
Introdução ao coding mobile34
Figura 31 – Configurando o SDK 
Manager
Fonte: Print da tela do Android, 
(2018).
 Passo 22: Clique em “Apply” e aguarde que a 
atualização seja realizada;
 Passo 23: Clique em “OK”.
Certifique-se de que os seguintes pacotes estejam listados como 
“Instalados” na coluna Status:
 Tools > Android SDK Tools 
 Tools > Android SDK Platform-tools 
 Tools > Android SDK Build-tools 
 SDK Platform (versão mais recente) > SDK Platform 
 SDK Platform (versão mais recente) > ARM EABI v7a 
System Image
 Extras > Android Support Repository 
 Extras > Android Support Library 
 Extras > Google Repository 
 Extras > Google USB Driver (necessário apenas em 
sistemas Windows)
IMPORTANTE
 Muito bem! Agora estamos prontos para testar o 
ambiente de desenvolvimento Android.
Introdução ao coding mobile 35
Testando o Ambiente de Desenvolvimento
 Para montar o nosso primeiro projeto Android, 
clique em “Start a new Android Studio Project”, conforme 
apresentado na tela abaixo:
Figura 32 – Novo projeto 
Android
Fonte: Print da tela do 
Android, (2018).
 Ao clicar no local marcado na figura acima, a seguinte 
tela será apresentada:
Figura 33 – Criando um 
projeto Android
Fonte: Print da tela do 
Android, (2018).
 Em “Application Name” (Nome do aplicativo) digite 
“Meu primeiro App”, deixando os demais itens como estão e 
clique em “Next”.
 Na tela apresentada na figura abaixo, marque apenas o 
checkbox referente ao item “Phone and Tablet” e selecione, na 
combobox (caixa de combinação) o item: “API 15: Android 
Introdução ao coding mobile36
4.0.3 (IceCreamSandwich), exatamente como está destacado 
em vermelho.
 Note que esta tela permite configurar o dispositivo 
para o qual você deseja desenvolver o projeto Android e que, 
além da opção que marcamos (Phone and Tablet), também 
permite outras opções, tais como dispositivos chamados de 
“weareble”, “android TV”, entre outros.
Figura 34 – Criando um projeto 
Android
Fonte: Print da tela do Android, 
(2018).
Sempre que você estiver a selecionar um tipo de dispositivo para o 
projeto, precisa definir qual a API mínima que o referido dispositivo 
deve possuir para rodar/suportar adequadamente o executável do 
projeto. Caso você tenha alguma dúvida sobre qual API deve ser 
selecionada, clique no link “Help me choice”, destacado em branco, 
na figura acima. Ao clicar neste link, uma nova tela será apresentada 
(ver figura abaixo), onde você poderá verificar qual a abrangência 
da API que deseja selecionar.
IMPORTANTE
Introdução ao coding mobile 37
Figura 35 – Tela 
que apresenta a 
abrangência das API 
disponíveis
Fonte: Print da tela 
do Android, (2018).
 Analisando a figura acima, verificamos que se 
selecionarmos a API 25 para o nosso projeto, estaremos 
a implementar uma aplicação que terá apenas 1,5% dos 
dispositivos capazes de executá-la. Se selecionarmos a API 
21, nossa abrangência aumenta para 50% dos dispositivos 
atualmente no mercado. E para ter uma abrangência garantida 
para a maioria dos dispositivos, escolhemos a API 15, que nos 
dá praticamente 100% de abrangência para a nossa aplicação.
 Dessa forma, depois de selecionada a API 15 para o 
dispositivo “Phone and Tablet”, clique em “Next”.
 A próxima tela a ser apresentada (figura abaixo) 
permite selecionar a Activity padrão para seu aplicativo. A 
Activity é um módulo único e independente que normalmente 
está relacionada diretamente com uma tela de interface de 
usuário e suas funcionalidades correspondentes. Não se 
preocupe em entender completamente este conceito neste 
momento, pois, trataremos detalhadamente do mesmo mais 
adiante neste material. Por enquanto basta entender que cada 
Activity representa uma tela do aplicativo que estamos a 
desenvolver.
Introdução ao coding mobile38
Figura 36 – Tela de seleção do 
tipo de Activity do Aplicativo
Fonte: Print da tela do Android, 
(2018).
 Selecione uma “Empty Activity”, como mostra a 
figura acima e clique em “Next”.
 A tela a seguir permite que você defina o nome da 
Activity e o nome do Layout para a sua aplicação. 
 Activity Name: Isso dá à sua Activity um nome para 
se referir no código. Uma classe .java será criada e usará o 
conteúdo desse campo de texto para dar um nome à classe. 
(CORDEIRO, 2017)
 Layout Name: Define o nome do arquivo XML que 
contém as configurações do Layout que será exibido para o 
usuário do aplicativo. 
 Por enquanto deixe com os nomes padrões e clique em 
“Finish”.
Figura 37– Tela de configuração da 
Activity do Aplicativo
Fonte: Print da tela do Android, 
(2018).
O seu projeto será criado conforme as configurações que 
você definiu e será apresentado na IDE8 do Android Studio, 
conforme figura abaixo:
Introdução ao coding mobile 39
 8DE– Integrated Development Environment - Ambiente de desenvolvimento 
Intregrado - que permite ao programador o acesso a uma interface amigável 
de desenvolvimento que facilita, organiza e otimiza o desenvolvimento, teste e 
Figura 38 – IDE do Android Studio
Fonte: Print da tela do Android, 
(2018).
 Muito bem. Agora falta pouco! Depois de todo 
este trabalho, o que precisamos é ver se o aplicativo está a 
funcionar corretamente, certo?
 Para isto, clique no menu “Run” e selecione o primeiro 
item: “Run app”. Uma nova tela será apresentada, conforme a 
figura a seguir:
Figura 39 – Tela para seleção do 
dispositivo virtual Android
Fonte: Print da tela do Android, 
(2018).
 Repare que a lista de dispositivos virtuais conectados 
está vazia (<none>) e, por isso, caso você clique em “OK”, 
uma mensagem de erro será apresentada, a informar que 
nenhum dispositivo virtual foi selecionado.
 Pois bem, então precisamos criar um dispositivo 
virtual para rodar a nossa aplicação exemplo. 
 É importante perceber que o Android Studio está 
Introdução ao coding mobile40
a simular uma aplicação em um dispositivo móvel, mas 
seu computador, mesmo sendo um notebook, não é um 
“dispositivo móvel” tal como um celular ou um tablet. Por isso, 
precisamos permitir que o Android Studio faça a simulação 
deste dispositivo ou seja, precisamos criar um Dispositivo 
Virtual Android ou, em inglês, um “Android Virtual Device”. 
 Para isso, clique no botão “Create New Virtual Device” 
e selecione o dispositivo “Phone” - “Nexus 4”, conforme 
mostrado na figura abaixo:
Figura 40 – Criando o AVD 
(Android Virtual Device)
Fonte: Print da tela do 
Android, (2018).
 Clique em “Next” e faça o download da API 28, 
conforme mostrado na figura abaixo:
Figura 41 – Carregando 
as API necessárias para o 
aplicativo.
Fonte: Print da tela do 
Android, (2018).
 E clique em “Next”.
Introdução ao coding mobile 41
Figura 42 – Configuração do AVD
Fonte: Print da tela do Android, 
(2018).
 Escolha um nome qualquer para o seu AVD, bem como 
a orientação inicial e clique em “Finish”.
 Se tudo estiver de acordo, aparecerá um emulador do 
dispositivo android a executar seu primeiro app, conforme 
figura abaixo:
Figura 43 – AVD a executar a sua primeira app mobile.
Fonte: Print da tela do celular, (2018).
 Pois então...
 Não foi tão difícil assim, não é mesmo?! Agora que 
você tem seu primeiro projeto a funcionar num dispositivo 
virtual android, quer dizer que tudo está instalado e 
configurado corretamente. 
Fechando a aplicação Android
 Precisamos executar mais duas atividades para 
concluir esta etapa:
 Primeiro: Feche o AVD (Android Virtual Device), 
clicando no “x” que está localizado no canto superior direito 
da barra lateral, apresentada na figura 34, colocado em 
destaque na figura abaixo:
Introdução ao coding mobile42
Figura 44 – Como fechar o AVD
Fonte: Print da tela do celular, (2018).
 Segundo: Fechar o Projeto teste adequadamente. 
Para isso, clique no menu “File” e selecione o item “Close 
Project”, como mostra a figura abaixo:
Figura 45 – Fechando o projeto corretamente.
Fonte: Print da tela do celular, (2018).
 Podemos assim, passar para a próxima fase do nosso 
aprendizado: Entender o funcionamento e os recursos 
disponibilizados pela interface Android Studio e, em seguida, 
aprender os fundamentos da linguagem Java e detalhar passo a 
passo cada etapa realizada até o momento no desenvolvimento 
de aplicativos para dispositivos móveis. 
Se quiser aprofundar seus conhecimento em programação para 
dispositivos Android, acesse: https://developer.android.com/guide/
SAIBA MAIS
Estrutura do Projeto Java-Android
 Antes de darmos sequência no aprendizado e 
implementação de programas para dispositivos móveis 
utilizando Java-Android é importante entender os 
recursos disponibilizados pela interface do Ambiente de 
Desenvolvimento Integrado (IDE) Android Studio, bem como 
seu funcionamento.
++
Introdução ao coding mobile 43
 É importante destacar também que a interface 
utilizada neste material não é a única maneira de se 
desenvolver aplicativos Java para dispositivos móveis. 
Poderíamos, por exemplo, ter instalado o próprio ambiente de 
desenvolvimento Java, instalando o JDK na sua última versão 
disponível (atualmente é a versão 10), disponível na página 
da Oracle.com (empresa proprietária do Java). Trataremos 
mais sobre este assunto no item 4 deste material. Neste item 
exploraremos a interface Android Studio.
Conhecendo a Interface Android Studio
 Como você deve ter percebido na primeira app que 
desenvolvemos juntos no item 2.4 deste material, a interface 
da IDE Android Studio possui uma grande variedade de telas 
e funções. Vamos apresentar as mais relevantes que você vai 
precisar utilizar nos exemplos e exercícios no escopo deste 
material.
Tela de Boas Vindas
Figura 46 - tela de Boas-
vindas
Fonte: Print da tela do 
Android, (2018).
Ao abrir a IDE Android Studio, normalmente a tela de Boas-
Vindas será a primeira a aparecer. 
Introdução ao coding mobile44
Isto só não vai acontecer caso você tenha fechado a IDE sem antes 
fechar o projeto. Para este caso, a IDE abrirá e carregará diretamente 
o projeto que estava aberto. 
IMPORTANTE
 Caso isso tenha acontecido com você, feche 
corretamente o projeto, como indicado no item 2.5 e terá 
acesso a tela de Boas-Vindas, conforme apresentado na figura 
acima.
 Não está errado fechar diretamente a IDE sem fechar 
antes o projeto. Estamos a proceder assim desta vez para ter 
acesso a todas as telas e funcionalidades relevantes para o 
escopo deste material.
 Repare que a tela de Boas-Vindas está dividida em 
duas colunas, a saber: 
 A coluna da esquerda apresenta a lista dos últimos 
projetos trabalhados recentemente;
 A coluna da direita fornece uma lista de possibilidades, 
das quais destacamos os dois primeiros: (1) Iniciar um novo 
projeto Android Studio e (2) Abrir um projeto Android Studio 
existente. 
Clique no projeto teste, na coluna da esquerda para ter acesso 
a tela principal do projeto.
Tela Principal
 É de se referir que o layout e a configuração dos painéis 
da tela principal variam conforme o gosto de desenvolvedor 
e também de acordo com as ferramentas utilizadas da última 
vez que o projeto foi aberto.
Introdução ao coding mobile 45
Figura 47 – Tela 
Principal do IDE 
Android Studio
Fonte: Print da tela 
do Android, (2018).
 Na figura acima, destacamos os seguintes itens:
 A – Barra de Menus: Barra tradicional com as opções 
de salvar, abrir, importar, exportar, navegar, executar, etc. 
Veremos os mais relevantes no decorrer deste material e nas 
próximas unidades que compõe este e-book. Neste momento, 
é importante destacar alguns itens dessa barra de menus: 
 Menu File: 
 New – Permite a criação de um novo projeto, classe, 
activity, módulo, entre outros. Aprenderemos a trabalhar com 
cada um desses itens no decorrer do material;
 Open – Permite abrir um projeto existente;
 Close Project – Fecha o projeto em uso;
 Settings – Apresenta uma nova tela que permite 
configurações de aparência e comportamento da IDE, tais como 
tamanho, cor e tipo de fonte do código, cor de fundo da IDE, entre 
outras;
 Project Structure – Apresenta uma nova tela que permite 
configurar características tais como a localização do Android SDK 
e JDK, bem como verificar as versões do Android, entre outras.
 Save All – Salva todos as janelas de código abertas;
 Exit – Fecha a IDE sem fechar o projeto. Caso algum 
projeto esteja aberto, o mesmo será carregado da próxima vez que 
a IDE for aberta;
 Menu Edit - Dá acesso as funções tradicionais de “Undo” 
(desfazer) e “Redo” (refazer), bem como copiar, colar, recortar, 
Introdução ao coding mobile46
colar, selecionar tudo e localizar.
 Menu View: 
 Tool Window – Permite acesso as janelas da IDE, tais 
como: Logcat, Project, Favorites, Structure, entre outras;
 Demais itens - Permitem a visualização de alterações 
recentes, bem como a ativação ou desativação da visualização das 
barrasde ferramentas, status, navegação e botões.
 Menu Navigate: permite o direcionamento do ponteiro 
de ação do editor para uma determinada classe, linha de aviso de 
erro, etc.
 Menu Code: Atalhos para a geração de código ou inserção 
de comentários (em linha ou em bloco), entre outras coisas. 
Veremos esses itens com mais detalhes quando estivermos a tratar 
do código java do projeto.
 Menus Analyze, Refactor e Build: Veremos mais adiante;
 Manu Run: Permite a execução do projeto em modo 
normal ou em modo “debug”;
 Menu Tools: Permite acesso ao SDK Manager, AVD 
Manager, editor de temas
 Menus VCS, Windows e Help: Veremos mais adiante;
 B – Barra de Navegação: permite mover entre os arquivos, 
subpastas e pastas que compõem o projeto. Segue o mesmo 
princípio da barra de navegações do Windows Explorer;
 C – Barra de Ferramentas: É composta por botões que 
servem como atalho para as funções que são utilizadas com mais 
frequência. Pode ser personalizada, clicando com o botão direito 
na barra e selecionando a opção “Menus and Tollbars”;
 D - Janela do Editor de Código: Exibe o conteúdo (código) 
do arquivo no qual o programador está a trabalhar no momento. 
Quando estiver a trabalhar com várias janelas (arquivos) de 
código, cada um deles será representado por uma aba, seguindo 
o mesmo princípio dos navegadores na internet. Exploraremos 
melhor os detalhes desta janela no decorrer deste material;
 E – Janela de Ferramentas de Projeto: Fornece uma visão 
hierárquica da estrutura do arquivo de projeto, permitindo a 
Introdução ao coding mobile 47
navegação para arquivos e pastas específicos para serem abertos. 
A configuração padrão é a visualização Android que é o modo a 
ser utilizado no restante deste material. Exploraremos melhor os 
detalhes desta janela no decorrer deste material;
 F – Barra de Status e demais Janelas de ferramentas: 
 Barra de Status: exibe mensagens informativas sobre o 
projeto e as activities do Android Studio;
 Janelas de Ferramentas: localizado no canto esquerdo, 
permite acesso a uma variedade de janelas que apresentam dados 
importantes sobre o projeto. Veremos mais sobre elas no item 
3.1.3 deste material.
Demais Janelas de Ferramentas
 Para ter acesso as demais Janelas de ferramentas 
disponibilizadas pela IDE, pare o ponteiro do mouse sobre 
o ícone localizado no canto inferior esquerdo da mesma, 
conforme mostra a figura abaixo. 
Figura 48 – Lista das Janelas de Ferramentas disponibilizadas pela 
IDE.
Fonte: Print da tela do android
 Como se pode verificar a IDE fornece uma grande 
variedade de janelas de ferramentas. As mais utilizadas, de 
acordo com Cordeiro (2016), são as seguintes:
 Janela Project: Uma visualização que fornece uma visão 
geral da estrutura de arquivos que compõe o projeto, permitindo 
uma navegação rápida entre os arquivos. 
 Janela Structure: Fornece uma visão de alto nível 
da estrutura das classes atualmente exibidas no editor. Essa 
informação inclui uma lista de itens, tais como classes, métodos 
e variáveis no arquivo. 
 Janela Build Variants: Fornece uma maneira rápida 
Introdução ao coding mobile48
de configurar diferentes tipos de compilação para o projeto 
atual (por exemplo, diferentes versões para debug e liberação 
de versões do aplicativo, ou várias compilações para atingir 
diferentes categorias de dispositivos).
 Janela TODO: Fornece um lugar para os itens que ainda 
têm de ser concluídos no projeto. 
 Janela Messages: Os dados da janela de Messages são 
gerados a partir do sistema de compilação Gradle, e podem ser 
úteis para identificar as causas de problemas na compilação de 
projetos.
 Janela Android Monitor: Esse recurso possibilita o acesso 
ao sistema de debug do Android. Dentro desta janela, podemos 
executar tarefas básicas de debug como monitorar a saída de 
log de um aplicativo em execução, tirar screenshots e vídeos do 
aplicativo, e parar um processo.
 Janela Android Model: A janela Android Model exibe 
uma lista completa das configurações do seu projeto. Estes 
podem variar de configurações mais óbvias, tais como a versão 
do SDK alvo, para coisas mais escondidas tais como regras da 
configuração de compilação.
 Janela Terminal: É uma janela de terminal do sistema 
na qual o Android Studio está em execução. No Windows essa 
interface é o prompt de comando.
 Janela Run: Essa ferramenta torna-se disponível quando 
um aplicativo está em execução e fornece uma visualização dos 
resultados da execução, junto a opções para parar ou reiniciar 
um processo em execução. 
 Janela Event Log: A janela Evento Log exibe mensagens 
relacionadas a eventos e atividades realizadas no Android Studio. 
 A compilação bem-sucedida de um projeto, por exemplo, 
ou o fato de que um app está sendo executado serão mostrados 
dentro dessa janela.
 Janela Gradle Console: Usada para exibir todas as saídas 
do sistema Gradle enquanto os projetos são compilados dentro 
do Android Studio. Isso inclui informações sobre o sucesso ou 
Introdução ao coding mobile 49
insucesso do processo de desenvolvimento, assim como avisos 
ou detalhes de qualquer erro.
 Janela Gradle: Mostra as tarefas do Gradle que compõem 
a configuração do projeto. Essa janela lista as tarefas que estão 
envolvidas na compilação dos vários elementos do projeto em 
um aplicativo Android. 
Estrutura do projeto Java-Android
 Este tópico trata do reconhecimento de alguns 
arquivos e características importantes para o entendimento da 
estrutura básica do projeto Java-Android. Serão tratados neste 
momento apenas os arquivos e características relevantes para 
o entendimento do projeto, os demais arquivos características 
existentes na estrutura serão apresentados oportunamente.
 Para verificar a estrutura do projeto, abra o Android 
Studio e crie um novo projeto com as seguintes características:
 Na tela “Create Android Project”:
 o Defina o “Application Name”: AppEstrutura;
 Na tela “Target Android Device”:
 o Marque a opção “Phone and Tablets”
 o Selecione a API 15;
 Na tela “Add an Activity to Mobile”:
 o Selecione: Empty Activity;
 Na tela “Configure Activity”:
 o Defina o “Activity Name”: Principal;
 o Define o “Layout Name”: activity_principal;
 Clique em “Finish” e aguarde a criação do projeto;
 Uma vez que o projeto esteja criado, a janela de 
ferramenta de projeto deve estar como apresentada na figura 
abaixo:
Figura 49 – Tela de ferramentas de projeto
 Fonte: Print da tela do Android, (2018).
Introdução ao coding mobile50
 Note que a estrutura de pastas do projeto possui duas pastas 
“raiz”: (1) app e (2) Gradle Scripts. A pasta “app” é composta por 
três subpastas: (a) pasta “manifests”; (b) pasta “java”; (e) pasta 
“res”. São estas pastas a serem verificadas aqui
Pasta Manifests
 Dentro da pasta Manifests existe um arquivo chamado 
AndroidManifests.xml. Todo aplicativo java-android deve ter um 
arquivo com exatamente este mesmo nome. Pode ser um projeto 
que você mesmo desenvolveu (ou está a desenvolver) ou pode ser 
um projeto de outrem. Ele é o “manifesto do aplicativo”, o qual 
contém informações essenciais sobre o aplicativo cujo código 
estamos a analisar. Para você talvez esteja a estranhar o nome 
“manifesto”, saiba que, segundo o dicionário priberam , manifesto 
é um substantivo masculino cujo significado é: “Exposição 
(geralmente escrita) em que se manifesta o que é preciso ou o que 
se deseja que se saiba a respeito de algo”. Muito bem. Usando a 
definição supracitada, podemos inferir que o arquivo “manifesto 
do aplicativo” tem função de conter informações necessárias (que 
devem ser passadas para o MOS Android) para que o aplicativo 
seja corretamente executado. De maneira geral, segundo o 
próprio a própria documentação fornecida pelo site da Android 
(ANDROID, 2018), o arquivo do manifesto serve para:
 Nomear (identificar unicamente) o pacote Java para o 
aplicativo;
 Descrever os componentes do aplicativo;
 Declarar as permissões que o aplicativo deve ter para 
acessar partes protegidas da API;
 Declarar as permissões queo aplicativo deve ter para 
interagir com outros aplicativos;
 Declarar qual a API mínima necessária para a correta 
execução do aplicativo;
Listar as bibliotecas às quais o aplicativo necessita estar vinculado 
para funcionar adequadamente;
 Pois bem. Agora que você sabe o que é e para que serve 
Introdução ao coding mobile 51
o arquivo referente ao manifesto do aplicativo, vamos analisar 
sua estrutura do mesmo. A figura abaixo (figura 50) apresenta 
uma cópia do AndroidManifest.xml do projeto que estamos a 
desenvolver. Ele deve ser idêntico ao do seu projeto.
Figura 50 – Arquivo AndroidManifest.xml
Fonte: Print da tela do Java, (2018).
 Algumas considerações preliminares: O arquivo manifesto 
é um arquivo no formato XML (eXtensible Markup Language) que, 
conforme aponta Pereira (2009), é uma linguagem de marcação 
recomendada pela W3C para a criação de documentos com dados 
organizados hierarquicamente, assim como faz o HTML, porém, 
seu diferencial é ser “extensível”, isto é, permite ao utilizador 
definir seus próprios conjuntos de elementos de marcação.
 Você deve se lembrar que quando estudamos HTML, 
utilizamos conjuntos de TAGs ou marcadores pré-definidos, tais 
como <body></body>, <h1></h1>, etc. 
 Com XML é possível criar nossos próprios marcadores. 
Você pode criar um marcador como, por exemplo: <inicio></
inicio>, <pessoa></pessoa>, etc. Para o caso do arquivo 
AndroidManifest.xml, apresentado na figura 50, acima, podemos 
identificar alguns marcadores definidos por quem elaborou esta 
solução para o desenvolvimento de aplicativos para dispositivos 
móveis. 
Introdução ao coding mobile52
 Note que a linha número 1 possui um cabeçalho. Todos 
os arquivos XML precisam ter este cabeçalho a informar ao 
navegador ou ao MOS Android que o arquivo a ser lido está no 
formato XML. Ao passar para o conteúdo do arquivo, veja que, 
na linha 2 existe um marcador chamado <manifest>, o qual inicia 
o documento e, consequentemente, também o finaliza, pois temos 
na linha 21 o fechamento do mesmo marcador. Na linha 5 temos 
o marcador <application> que é fechado na linha 19. Também 
temos o marcador <activity> na linha 12 e que é fechado na linha 
18.
Se você estiver interessado em saber mais sobre as características 
dos arquivos XML, acesse: https://www.tecmundo.com.br/
programacao/1762-o-que-e-xml-.htm
SAIBA MAIS
 Vamos verificar quais são e para que servem os 
marcadores (as TAGs) apresentados na figura 50, abaixo:
 <manifest> - é o elemento raiz de todo arquivo 
AndroidManifest.xml. 
 Deve definir o namespace do Android, cujo atributo, 
segundo (ANDROID, 2018) pode ser sempre definido como: 
"http://schemas.android.com/apk/res/android".
 Deve identificar o pacote (package) ao qual a aplicação 
pertence. O nome completo deste pacote é definido quando 
estamos a criar um projeto no Android Studio. O nome do 
pacote também representa, conforme (ANDROID, 2018), a 
identificação (ID) da aplicação, o qual deve ser único e será 
o identificador da sua aplicação caso queira publicá-la na 
Google Play.
 Deve conter pelo menos uma aplicação (representado 
pelo marcador <application>).
 Existem muitos outros elementos que podem estar 
contidos dentro do marcador <manifest>. Aqui estamos a 
++
Introdução ao coding mobile 53
 <application> - É a declaração da aplicação. 
 Este elemento deve conter todos os subelementos que 
declaram cada um dos componentes da aplicação e também 
pode conter atributos que afetem estes componentes. São 
exemplos de atributos: icon, label, permission, process, etc
 Atributos
 android:allowBackup – Determina se o aplicativo 
em questão participa ou não da infraestrutura de backup e 
restauração. Pode ser setado para verdadeiro (true) ou falso 
(false);
 android:icon – define um ícone para a aplicação 
como um todo e um ícone padrão para cada componente da 
aplicação. Deve ser setado como uma referência para uma 
fonte de imagem apontada pelo elemento @drawable/icon 
(que veremos mais adiante);
 android:label – define uma etiqueta (label) legível 
para a aplicação como um todo e uma etiqueta (label) padrão 
para cada componente da aplicação;
 android:roundIcon – A partir do versão 8 do MOS 
Android foi introduzido ícones adaptativos que podem ter os 
mais variados formatos. Um deles é o formato arredondado, 
por isso: roundIcon. Para saber mais sobre os ícones 
adaptativos, acesse: https://developer.android.com/guide/
practices/ui_guidelines/icon_design_adaptive;
 android:supportsRtl – declara se sua aplicação suporta 
layouts “Right-to-Left”. Podem ser definidos como verdadeiro 
(true) ou falso (false);
 android:theme – Define um tema padrão para todas 
as atividades (telas) contidas na aplicação, apesar de que 
atividades individuais que usem este atributo podem sobrepor-
se à definição padrão.
tratar apenas os que o arquivo da figura 50 apresenta. Para 
saber mais, acesse: https://developer.android.com/guide/
topics/manifest/manifest-element
Introdução ao coding mobile54
 <activity> - Declara uma atividade, isto é, uma 
interface (tela) visual para o usuário. Uma aplicação pode ter 
várias telas e cada uma delas deve ser representada por um 
elemento <activity> distinto dentro do arquivo do manifesto.
 Atributos: android:name – define o nome da atividade;
 <intent-filter> - A intent é um objeto de mensagem que 
pode ser usado para solicitar uma ação de outro componente 
de aplicativo. (ANDROID, 2018). O <intent-filter> especifica 
o tipo de intent uma atividade, serviço ou receiver está apto 
a responder. Explicando melhor: Um intent-filter declara 
o que uma atividade ou serviço pode fazer e quais tipos 
de “broadcasts” um “receiver” pode manipular. Veremos 
mais profundamente sobre ele nas próximas unidades deste 
material. Para já, temos que no caso da figura 50, aparecem 
dois subelementos: (1) action; (2) category.
action – adiciona uma ação ao elemento intent-filter (que 
pode possuir um ou mais elementos de ações). No caso em 
estudo, temos que a ação é definida como MAIN. Esta ação 
(MAIN) informa ao MOS Android que esta é a atividade 
principal da aplicação.
 category – adiciona um nome de categoria ao elemento 
intent-filter. No caso em estudo, temos que a categoria 
foi declarada como Launcher (iniciar, lançar, começar, 
empreender). Isto informa ao MOS Android que a atividade 
deve estar visível no launcher do dispositivo móvel. 
 Finalizamos a análise do arquivo de manifesto do 
aplicativo. Passamos agora para a próxima pasta.
Não se preocupe se tudo isso ainda parece meio confuso pra você. 
Estamos na fase inicial. Trabalharemos em detalhes cada um destes 
elementos e outros mais para que você possa se sentir confiante ao 
desenvolver uma aplicação para dispositivo móvel.
IMPORTANTE
Introdução ao coding mobile 55
Pasta Java
 A pasta Java possui, normalmente, três subpastas. 
A primeira contém as classes (arquivos .java) referentes às 
activities (telas) da sua aplicação e demais classes que você 
por ventura precise desenvolver em uma aplicação mais 
sofisticada. As outras duas pastas são pastas de testes e não 
trataremos delas neste material. Vamos, então para a classe 
Principal.java, que deve conter a estrutura da nossa activity. 
A figura 51 mostra o conteúdo desta classe.
 Eu sei que ainda não estudamos a linguagem Java, 
inclusive, esse será o tema que inicia no próximo tópico desta 
unidade 1 e será aprofundado no decorrer da unidade 2 desta 
disciplina. 
Figura 51 – Classe 
Principal.java
Fonte: Print da tela do Java, 
(2018).
 Mas, apesar disso, precisamos fazer aqui algumas 
considerações.
 Na linha 1, a palavra reservada “package” define em que 
pacote esta classe está declarada. Um pacote pode conter várias classes 
que devem estar separados por assunto ou aplicação, assim como 
separamos arquivos de documentos numa pasta ou pacote documentos 
e arquivos de imagens numa pasta ou pacote de imagens;
 Na linha 3, a palavra reservada “import” declara quais são as 
bibliotecas que esta nossa classe Principal vai precisarusar para que seja 
executada adequadamente pelo MOS Android. As classes importadas 
não aparecem por motivos de organização de código, mas se você 
clicar nos “...” que estão logo depois da palavra “import” poderá ver 
quais são as classes necessárias para fazer este projeto ser executado;
 Na linha 6, a classe principal está a ser definida. A palavra 
reservada “class” define que Principal é uma classe. A palavra reservada 
Introdução ao coding mobile56
“public” define que esta classe pode ser instanciada por qualquer 
outra que a utilize, sem precisar ser um classe filha. (Exatamente 
como vimos quando estudamos PHP). A palavra reservada “extends” 
declara que a classe Principal (nossa classe) deve estender (herdar) 
as características (atributos) e os comportamentos (métodos) da classe 
AppCompatActivity.
 Na linha 8, a palavra reservada @Override informa que o 
método que está na linha abaixo (onCreate) é um método que está 
a fazer sobreposição10 de um método já existente na classe mãe 
(AppCompatActivity).
 Na linha 9, o método onCreate é definido. Ele é responsável 
por carregar os layouts e outras operações de inicialização. Veremos 
com mais detalhes este método quando estudarmos o ciclo de vida 
completo da Activity.
 A palavra reservada “void” declara que este método não 
retorna qualquer valor e a palavra reservada “protected” define 
que este método não pode ser acessado por qualquer classe, mas 
sim apenas pelas classes filhas desta que estamos a criar. 
Note também que o método onCreate possui um parâmetro. Não 
se preocupe com ele agora. Estudaremos com detalhes quando 
tratarmos do ciclo de vida de uma activity.
 
 o R indica a pasta “res” (abreviatura para resource);
 o layout é o nome da subpasta da pasta “res”;
 o activity_principal é o nome do arquivo (activity_principal.
xml);
 Na linha 10, a palavra reservada “super” indica que 
o método onCreate original (definido na classe mãe) deve 
ser chamado e executado. Veremos mais sobre estas palavras 
reservadas a partir da próxima unidade.
 Na linha 11, o método setContentView será chamado. Ele 
tem a função de apresentar um conteúdo na tela. Este conteúdo 
é definido por um layout que está declarado no argumento ou 
parâmetro deste método (R.layout.activity_principal).
 A pasta “res” será analisada agora e você terá, então, 
uma visão da estrutura completa.
Introdução ao coding mobile 57
Pasta “res”
 É a pasta de recursos (resources) da sua aplicação Android.
 Pasta Drawable: Onde serão armazenados todos os recursos 
de imagens para o seu aplicativo;
 Pasta Layout: onde ficararão armazenados todos os layouts 
que você for utilizar em cada uma das activities (telas) de sua 
aplicação. Dentro desta pasta existe um arquivo chamado activity_
principal.xml, do qual comentamos a pouco. Este arquivo define 
o layout da única activity que você tem, por enquanto, em sua 
aplicação. A figura abaixo mostra o conteúdo do referido arquivo. 
Trataremos em detalhes desse arquivo na unidade 3 deste material.
Figura 52 – Arquivo de Layout – activity-principal.xml
Fonte: Print da tela do Java, (2018).
 Pasta mipmap: local onde são armazenados todos os 
ícones utilizados em sua aplicação. Existem duas subpastas: (1) 
ic_launcher e (2) ic_launcher_round, onde você pode verificar 
os arquivos .png utilizados na sua aplicação;
Pasta Values: possui três arquivos, como mostrado na figura 
abaixo:
Figura 53 – Arquivo de Layout – 
activity-principal.xml
Fonte: Print da tela do Java, (2018).
 colors.xml: É recomendado que você registre aqui todas as 
cores que você pretende utilizar dentro da sua aplicação. Depois 
de registrado aqui neste arquivo a cor pode ser referenciada nos 
arquivos de layouts de cada uma das telas (activities) de sua 
Introdução ao coding mobile58
aplicação. Uma vez que você queira alterar a cor que você utilizou 
em 10 layouts por exemplo é só trocar aqui e os layouts que fazem 
referência a esta cor serão alterados automaticamente;
 o strings.xml: tem o mesmo funcionamento que o arquivo 
de cores explicado acima. É onde devem ser registrados todos os 
textos estáticos da sua aplicação. Antes de definir um texto para um 
botão ou um texto para um label, defina-o aqui e use a referência 
aqui definida nos layouts. Uma vez que você mude aqui o texto do 
botão que era “Alterar” para “Editar” todos os botões das telas que 
fazem referência a este texto serão alterados automaticamente;
 styles.xml: Define o estilo de sua aplicação. Aqui serão 
definidos características como tamanho, margem, cor de fundo, 
etc. e da mesma forma que acontece com o arquivo de strings ou 
de cores, usa apenas a referência a este estilo dentro dos layouts. 
 Quando você alterar um parâmetro de margem ou cor 
de fundo aqui neste arquivo estará automaticamente alterando 
em todas as telas (activities) da sua aplicação que a eles fazem 
referência.
 Agora que você entendeu um pouco como funciona 
a estrutura de uma aplicação Java-Android, vamos aos 
fundamentos da programação Java para dispositivos móveis.
Fundamentos do Java para Mobile
 Este tópico tem como função apresentar um pouco da 
história de como surgiu a Linguagem de Programação Java e 
permitir ao aluno entender como funciona a sua plataforma 
de desenvolvimento.
Java - Um pouco de história
 Era o ano de 1991 e a empresa Sun Microsystems 
trabalhava num projeto chamado “Green Project”, cujo 
objetivo era desenvolver uma nova plataforma para a 
computação interativa. O resultado desse projeto foi a 
criação do handheld StarSeven (cujo símbolo era “*7”). Era 
um dispositivo com tela sensível ao toque (touchscreen) 
que controlava uma variedade de aparelhos domésticos. Na 
Introdução ao coding mobile 59
verdade, pode-se dizer que se tratava de um controle remoto 
sofisticado que tinha a capacidade de controlar uma grande 
variedade de aparelhos domésticos disponíveis na época, 
apresentando uma interface animada, numa tela colorida de 
cinco polegadas, de LCD, sensível ao toque.
 A linguagem de programação desenvolvida para o 
StarSeven foi denominada de Linguagem “Oak”, que em 
português quer dizer “carvalho”. Ela tinha este nome porque, 
segundo a lenda, era a árvore que um dos criadores da 
linguagem, James Gosling, via de sua janela.
 Bem, este projeto não deu muito certo e foi abandonado, 
pois, segundo alguns, estava bem à frente de seu tempo, mas a 
Linguagem Oak, por ser independente de plataforma, tornou-
se de grande interesse para a Sun e foi retrabalhada, ajustada 
e moldada por uma equipe de engenheiros para se tornar, 
depois de dois ou três anos de pesquisa, a primeira versão da 
Linguagem Java.
 Em 23 de maio de 1995, foi anunciado que a tecnologia 
Java estava disponível, na sua primeira versão, incorporada 
no navegador Netscape.
A Tecnologia Java
 Quando se fala em Tecnologia Java está a fazer 
referência à Linguagem Java e a Plataforma Java.
A Linguagem Java
 A Linguagem Java é uma linguagem de alto nível. 
Abaixo estão relacionadas algumas de suas características:
 Orientada a Objetos;
 Para ambientes distribuídos: Um sistema distribuído 
é um conjunto de computadores independentes que aparenta 
ao usuário ser um único computador. Exemplo: Sistema de 
reserva de passagens aéreas, Serviços da internet.
Introdução ao coding mobile60
 Arquitetura Neutra e portável: É uma linguagem 
criada para rodar em várias plataformas.
 Alto Desempenho;
 Interpretada;
 Vale destacar aqui a diferença entre linguagens de programação 
Interpretadas e Compiladas:
 Linguagem Interpretada: é uma linguagem de programação 
onde o programa (código-fonte) é lido (executado) por um 
interpretador que o interpreta diretamente, durante a execução, isto 
é, não existe o executável do programa. Exemplos: Java, C#, ASP.
 Linguagem Compilada: é uma linguagem de programação 
cujo código fonte é traduzido pelo compilador, gerando um arquivo 
executável do programa (linguagem de máquina) que é executado 
diretamente pelo processador ou pelo sistema operacional. 
Exemplos:C, C++,Delphi.
IMPORTANTE
Esquema de execução de um programa em Java
 Quando um programa em Java é escrito, ele é gravado 
em um arquivo texto com extensão .java. O compilador lê este 
arquivo e o transforma em um arquivo “.class”. Este processo 
é chamado de Compilação. A JVM (Java Virtual Machine) lê 
(interpreta) este arquivo “.class” e executa o programa. Este 
processo é chamado de Execução. A figura abaixo ilustra o 
processo de execução de um programa Java.
Figura 54 – Processo de 
execução de um programa 
Fonte: Adaptado pelo 
autor do processo do Java 
 Quando o programa.java é compilado, o resultado 
é um arquivo.class (bytecodes) que é a linguagem de 
Introdução ao coding mobile 61
máquina que a JVM consegue entender. Os bytecodes são 
então processados (interpretados) pela JVM que executa o 
programa em seu computador. Caso o sistema operacional do 
seu computador seja o Windows, você vai precisar de uma 
JVM para o Windows. 
 Caso você esteja trabalhando com um computador 
cujo sistema operacional seja o MacOS, precisará de uma 
A Plataforma Java
 É o nome dado ao ambiente computacional que 
permite desenvolver aplicativos utilizando a linguagem Java. 
A grande vantagem desta plataforma é que ela não está presa 
a um único sistema operacional ou a um único hardware.
 Atualmente, existem 3 plataformas Java principais11:
 Java SE: Java Standard Edition – permite desenvolver 
e implantar aplicações em desktops e servidores;
 Java EE: Java Enterprese Edition – permite desenvolver 
aplicações corporativas e para a internet;
 Java ME: Java Micro Edition – permite desenvolver 
aplicações para dispositivos móveis;
 O próximo tópico deste material mostra, passo a passo, 
como montar um ambiente de desenvolvimento Java para as 
aplicações que serão desenvolvidas durante este curso.
Entendendo, Instalando e Configurando o 
Ambiente Java
 Antes de começar a programar em linguagem Java, é 
necessário preparar o ambiente de desenvolvimento, que é 
composto basicamente por: JDK13 e IDE14 . 
 A tabela abaixo esclarece e relembra alguns conceitos 
necessários para o correto entendimento deste material.
Introdução ao coding mobile62
Tabela 1 – Conceitos 
importantes
Fonte: o autor (2018).
 Precisamos instalar ambas as ferramentas (JDK e IDE) 
em nosso computador.
Instalando o JDK
 O processo de instalação do kit de Desenvolvimento 
Java já foi explicado no item 2.1 desta unidade, caso você 
tenha realizado todas as atividades desta unidade até aqui, 
não precisará reinstalá-la. Pode passar para o próximo passo. 
Mas é importante lembrar que se você quiser apenas trabalhar 
com a Linguagem Java em outro computador em que não 
instalou os itens relacionados no módulo 2, deverá executar o 
item 2.1 antes de continuar por aqui.
Instalando o IDE
 Iremos trabalhar com o IDE Eclipse Photon, que pode 
ser encontrado no seguinte endereço da internet: http://www.
eclipse.org/downloads/
Figura 55 – Baixando a IDE
Fonte: Tela Splash do Eclipse 
Photonm, (2018).
Introdução ao coding mobile 63
Figura 56 – Baixando a IDE
Fonte: Tela Splash do Eclipse 
Photonm, (2018).
 Selecione o pacote: Eclipse IDE for Java EE Developers 
e a versão do seu sistema operacional (32 ou 64 bits). Para este 
material, iremos trabalhar com a versão 64 bits.
Figura 57 – Baixando a IDE
Fonte: Tela Splash do 
Eclipse Photonm, (2018).
 Baixe o arquivo: eclipse_jee_photon-R-win32-x86_64.
zip e descompacte-o no mesmo diretório em que está o jdk. 
Para o caso deste material é o diretório: “c:\program files\
java\”. A pasta eclipse será criada dentro deste diretório.
O Eclipse não precisa ser instalado. Uma vez descompactado, é só 
clicar no arquivo eclipse.exe e mãos à obra!
IMPORTANTE
Testando o Eclipse
 Para ter certeza que tudo (todas as instalações e 
descompactações) ocorreram de acordo com o esperado, 
segue uma lista de testes necessários, antes de prosseguir:
 Execute o arquivo eclipse.exe. Uma tela como a 
mostrada abaixo deve aparecer:
Figura 58 – Tela Splash do Eclipse Photon
Fonte: Tela Splash do Eclipse Photonm, (2018).
Introdução ao coding mobile64
 Logo em seguida, o eclipse irá solicitar que seja informado 
qual o caminho para o “workspace”, como mostrado na figura abaixo:
Figura 59 – Selecionar o Diretório de 
Trabalho
Fonte: Tela Splash do Eclipse Photonm, 
(2018).
 O “workspace” significa “espaço de trabalho” e 
define o endereço (diretório e pasta) onde serão colocados 
todos os arquivos do seu projeto. Podem ser criados vários 
“workspaces”, um para cada projeto que seja desenvolvido. 
Para este teste, digite o endereço: “c:\Teste” e clique em OK.
 O Eclipse irá criar uma pasta com o nome especificado, 
no local especificado. Neste caso: a pasta é “Teste”, o local é 
“c:\”. O Eclipse irá carregar as bibliotecas necessárias e a tela, 
como a mostrada na figura abaixo, será apresentada:
Figura 60 – Tela de abertura do Eclipse
 Fonte: Tela Splash do Eclipse Photonm, 
(2018).
 Clique em “Workbench”, como mostrado na figura 
acima.
Figura 61 – IDE 
Fonte: Tela Splash do Eclipse Photonm, 
(2018).
Introdução ao coding mobile 65
 Este é o ambiente de desenvolvimento integrado ou 
IDE do Eclipse. Neste ambiente serão escritos os códigos 
em Java para os programas que estão propostos neste 
material. Com a evolução do material, serão apresentadas as 
funcionalidades necessárias desta interface.
 Para finalizar, (1) minimize a janela do Eclipse; (2) 
abra o Windows Explorer; (3) verifique que a pasta “Teste” 
foi criada no drive “c:\”; (4) abra a pasta “Teste” e verifique 
que o Eclipse criou toda a estrutura de pastas e arquivos para 
que seu projeto possa funcionar.
 Feche o Eclipse e delete a pasta “Teste” no Windows 
Explorer, pois ele foi criado apenas para este primeiro 
exemplo teste. Nos exercícios propostos neste material serão 
utilizados outros “workspaces”.
 Muito bem! Depois de tudo isso você deve estar com 
seu computador em condições de desenvolver em Java e em 
Java para dispositivos móveis, foco desta disciplina.
 Sei que você deve estar “louco” para aprender mais! 
Mas não podemos colocar tudo em uma única unidade, não 
é verdade? Precisamos fazer como nos filmes e anunciar “As 
cenas dos próximos capítulos” !!
 Espero que você tenha gostado. A aprendizagem não 
pode parar! Na próxima unidade veremos a estrutura básica 
da linguagem Java. Até lá!
Introdução ao coding mobile 67
UNIDADE
02
FUNDAMENTOS DA LINGUAGEM JAVA 
PARA ANDROID
Introdução ao coding mobile68
 Seja bem-vindo (a) à Unidade 2 – Fundamentos da 
Linguagem Java para Android - da disciplina de Introdução 
ao Coding (Mobile). Nesta unidade trataremos os conceitos 
fundamentais de programação Java necessários para que 
você possa desenvolver aplicativos nesta linguagem. É de 
se referir que, apesar do foco da disciplina ser programação 
para dispositivos móveis, os conceitos apresentados nesta 
unidade serão úteis mesmo para programação Java em 
qualquer ambiente. O conteúdo desta Unidade está dividido 
em quatro módulos. No primeiro módulo apresentamos a 
sintaxe das instruções básicas do Java para manipulação de 
variáveis e outros recursos elementares da linguagem. No 
módulo 2 estudaremos as estruturas de controle e repetição 
de fluxo. No módulo 3 aprenderemos como trabalhar com 
classes em Java e, finalmente, no módulo 4, trabalharemos 
conceitos fundamentais da programação orientada à objeto, 
como polimorfismo, classes abstratas e interfaces. É claro 
que existe muito mais a aprender, mas o aprofundamento 
de cada um destes conhecimentos pode ser feito acessando 
os links indicados durante o texto, no tópico [Saiba Mais]. 
Vamos começar? Excelente estudo para você!
 
INTRODUÇÃO
Introdução ao coding mobile 69
1
2
3
4
Olá! Se bem-vindo a nossa Unidade 2, e o nosso objetivo é 
auxiliar você no desenvolvimento das seguintes competências 
profissionais até o término desta etapa de estudos: 
OBJETIVOS
Conhecer a sintaxe das instruções básicas do Java para 
manipulação de variáveis