E-Book Completo - Programação Introdução Ao Coding Mobile - COMPLETO - TELESAPIENS (Versão Digital)

INTRODUÇÃO INTRODUÇÃO
Introdução ao Coding Mobile

AO CODING AO CODING
MOBILE MOBILE
Organizador Luiz Fernando Corcini
Organizador Luiz Fernando Corcini
GRUPO SER EDUCACIONAL
gente criando o futuro

Introdução ao Coding
(Mobile)
Introdução ao Coding
(Mobile)
Créditos Institucionais
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
2018 by Telesapiens
Todos os direitos reservados
O AUTOR
Luiz Fernando Corcini
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.
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:
OBJETIVO OBSERVAÇÃO
Breve descrição do Breve descrição do
objetivo; + objetivo;
CITAÇÃO RESUMINDO
Parte retirada de um Resumo
texto; acumulativo das
últimas abordagens;
TESTANDO DEFINIÇÃO
Foco em um objeto Apresentação de
de estudo; um novo conceito;
IMPORTANTE ACESSE
As observações escritas Links úteis
têm que ser priorizadas; para fixação da
++
informação;
DICA SAIBA MAIS
Destaque para Informações
sugestões e novas adicionais sobre
informações; o conteúdo;
2018 by Telesapiens
Todos os direitos reservados
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................................................142
Passagem 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
ClasseActivitydaTela2.........................................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
12 Introdução ao coding mobile
01
UNIDADE
ESTRUTURA DE UM PROJETO ANDROID

Introdução ao coding mobile 13
INTRODUÇÃO
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ê!
OBJETIVOS
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:
1 Conhecer o sistema operacional Android, sua história,

características e requisitos;
2 Aprender a instalar e configurar os componentes básicos

do Android StudiO;
3 Entender as principais características da estrutura de

projetos na plataforma Android, suas funcionalidades de
seus principais arquivos;
4
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;
Android – Visão Geral

Dispositivos Móveis
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
Figura 1 – Quota de
Marcado Mundial de
S.O. para Smartphones.
Fonte: IDC – 05-2017.

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.
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.
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!
SAIBA MAIS
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
Agora que conhece um pouquinho da história do MOS

Android, vamos apresentar suas características.
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
3
IDC – International Data Corporation. Disponível em: https://www.idc.
com/promo/smartphone-market-share/os - Acessado em: 05-09-2018.
4
Sistemas 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.
5
Có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,
(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.
SAIBA MAIS
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.
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
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.
++
SAIBA MAIS
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.
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).
++
SAIBA MAIS
O código fonte do Android está disponível no site: https:// source.

android.com/.
Arquitetura da Plataforma
A arquitetura da plataforma Android está apresentada
esquematicamente na figura abaixo:
Figura 2- Esquema
básico da arquitetura da
APLICATIVOS Plataforma Android
Framewors
Serviços e
Bibliotecas
Bibliotecas e Serviços
nativos
Linux 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 facilitar o
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.
SAIBA MAIS
Para saber em detalhes como é a arquitetura da plataforma Android,

acesse: https://developer.android.com/guide/platform/
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.
6
JDK – Java Development Kit – Kit de desenvolvimento Java.
7
SDK – O Android SDK ou Kit de Desenvolvimento de Software para
Android é um pacote com diversas ferramentas utilizadas pelo Android
Studio e pelos desenvolvedores.
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.
OBSERVAÇÃO
+
Não se esqueça de aceitar os termos de licença antes de selecionar

o arquivo para fazer o download.
IMPORTANTE
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.
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
Selecione o diretório onde deve ser instalado o JDK e

clique NEXT;
Recomendo deixar o local do arquivo conforme
definido por padrão.

(2018)
Aguarde a Instalação....

(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:
Figura 9 – Tela para “Configurações

Avançadas”
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
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
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:
Figura 12 – Editando a variável Path

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
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).
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).
IMPORTANTE
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.
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” e a seguinte tela será

apresentada:
Figura 18 – Assistente de Instalação – Tela
2
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

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
Passo 8: Clique em “Next” e a processo de instalação

terá início, como mostra a figura abaixo:
Aguarde até a instalação ser completada.

Passo 10: Marque a opção para iniciar o aplicativo

Android Studio.
Passo 11: Clique em “Finish”. A seguinte tela
aparecerá:
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

(2018).


(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

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 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.

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

(2018).
A seguinte tela deverá ser apresentada:

Manager

(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:

Manager

(2018).
Passo 22: Clique em “Apply” e aguarde que a

atualização seja realizada;
Passo 23: Clique em “OK”.
IMPORTANTE
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)
Muito bem! Agora estamos prontos para testar o

ambiente de desenvolvimento Android.
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

Android, (2018).
Ao clicar no local marcado na figura acima, a seguinte

tela será apresentada:
Figura 33 – Criando um
projeto Android

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
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

(2018).
IMPORTANTE
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.
Figura 35 – Tela
que apresenta a
abrangência das API
disponíveis

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.
Figura 36 – Tela de seleção do

tipo de Activity do Aplicativo

(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

(2018).
O seu projeto será criado conforme as configurações que
você definiu e será apresentado na IDE8 do Android Studio,
conforme figura abaixo:
Figura 38 – IDE do Android Studio

(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

(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á
8
DE – 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
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)

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.

Android, (2018).
E clique em “Next”.
Figura 42 – Configuração do AVD

(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:
Figura 44 – Como fechar o AVD

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.

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.
SAIBA MAIS
Se quiser aprofundar seus conhecimento em programação para

dispositivos Android, acesse: https://developer.android.com/guide/
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.
É 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

Android, (2018).
Ao abrir a IDE Android Studio, normalmente a tela de Boas-

Vindas será a primeira a aparecer.
IMPORTANTE
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.
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.
Figura 47 – Tela
Principal do IDE
Android Studio

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,
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
barras de 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
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
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
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

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 que o 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
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.
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.
SAIBA MAIS
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
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
tratar apenas os que o arquivo da figura 50 apresenta. Para

saber mais, acesse: https://developer.android.com/guide/
topics/manifest/manifest-element
<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.
<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.
IMPORTANTE
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.
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 precisar usar 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
“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.

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).
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);
A pasta “res” será analisada agora e você terá, então,
uma visão da estrutura completa.
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

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

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
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
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.
Arquitetura Neutra e portável: É uma linguagem

criada para rodar em várias plataformas.
Alto Desempenho;
Interpretada;
IMPORTANTE
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.
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
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.
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).
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.
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.
IMPORTANTE
O Eclipse não precisa ser instalado. Uma vez descompactado, é só

clicar no arquivo eclipse.exe e mãos à obra!
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).

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

(2018).
Clique em “Workbench”, como mostrado na figura
acima.
Figura 61 – IDE

(2018).
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á!
UNIDADE
02
FUNDAMENTOS DA LINGUAGEM JAVA
PARA ANDROID
INTRODUÇÃO
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ê!
OBJETIVOS
1 Conhecer a sintaxe das instruções básicas do Java para

manipulação de variáveis e outros recursos elementares
da linguagem.
2 Entender as estruturas de controle e repetição de fluxo de

código na linguagem Java.
3 Aplicar os conceitos de programação orientada a objetos

na linguagem Java, com foco nas classes de objetos.
4 Compreender e aplicar os conceitos de polimorfismo,

classes abstratas e interfaces na linguagem Java.
Java Básico
Neste primeiro módulo aprenderemos a sintaxe básica
da linguagem de programação Java.
RESUMINDO
No primeiro módulo instalamos e configuramos todos os recursos

necessários para permitir criar, em seu computador, o ambiente
necessário para desenvolver projetos em Java.
Apesar do foco desta disciplina ser programação para

dispositivos móveis, o conteúdo apresentado nesta unidade
serve como base para programação em Linguagem Java de
maneira geral. Nossa estratégia aqui será criar pequenos
projetos e explorar e aprofundar os conhecimentos básicos
da sintaxe da linguagem um pouco em cada um deles. Vamos
então para nosso primeiro projeto.
O Primeiro Projeto Java

Para este primeiro projeto, abra o Eclipse (IDE
Integrated Development Environment), ou seja, Ambiente de
Desenvolvimento Integrado, e crie o seguinte “workspace”:
c:\java\Projeto_01, como mostrado na figura abaixo.
Figura 1 – Definição do ‘Workspace’ do primeiro projeto Java.
Fonte: Autor
RESUMINDO
O espaço de trabalho (workspace) é o local (diretório) onde será

gravado todos os arquivos necessários para que o seu projeto
funcione adequadamente.
Logo que você clicar no botão “Launch”, o espaço de
trabalho será criado na pasta “c:\java\Projeto_01” e o IDE Eclipse
será aberto, exatamente como mostrado na figura 2 (abaixo).
Repare que do lado esquerdo do IDE está o “Package
Explorer” (marcado com o número 1) cuja função é apresentar a
lista de classes, bibliotecas e demais arquivos (resources) que serão
necessários no seu projeto. No centro da IDE (marcado com o
número 2) é o local onde o código em linguagem Java será digitado.
Figura 2 – IDE Eclipse
Fonte: Autor
Clique no menu File -> New -> Project e o assistente
irá criar um novo projeto e será apresentado, como mostra a
figura 3:
Figura 3 – Criando novo Projeto Java
Fonte: Autor
Selecione a opção “Java Project”, como mostrado

acima (Figura 3) e clique NEXT. Uma nova tela (figura 4)
será apresentada.
Figura 4 – Nomeando o projeto
Fonte: Autor
Digite o nome para o seu projeto: “Exe1” e clique em

FINISH. A parte da Ide relativa ao Package Explorer deve
ficar como mostra a figura abaixo.
Figura 5 – Package Explorer do projeto
Exe1
Fonte: Autor
Note que o seu projeto Exe1 foi criado e possui duas subpastas:
A pasta “src” é onde serão incluídas as classes desenvolvidas
para o seu projeto. O termo “src” é a abreviação da palavra “source”,
que significa “fonte”, isto é, dentro desta pasta serão gravadas as classes
(código fonte) do seu projeto;
Dentro da pasta “JRE System Library” estão as bibliotecas de
classes que, como descrito anteriormente, permitem que a sua máquina
rode código Java, no sistema operacional escolhido.
Como você pode reparar, a pasta “src” está vazia, ou seja, seu projeto
está vazio. Nosso próximo passo é criar a primeira classe deste projeto.
A Primeira Classe Java

Agora siga os seguintes passos:
Clique no menu File -> New -> Package, para criar o primeiro
pacote (pasta) onde iremos inserir a primeira classe no seu projeto.
Digite: “exercicio1” para o nome do pacote, como mostra a figura
abaixo (Figura 6):
Figura 6 – Criando o primeiro
pacote para o projeto
Fonte: Autor
Clique FINISH e seu projeto deve ficar como o
mostrado na figura abaixo (Figura 7):
Figura 7 – Novo pacote criado.
Fonte: Autor
Dentro do pacote “exercicio1”, ficarão as classes
que iremos criar. Então, vamos criar nossa primeira classe,
finalmente !!!
Clique no menu File -> New -> Class, para criar a
primeira classe do nosso projeto, como mostra a figura abaixo
(Figura 8):
Figura 8 – Criando a primeira classe
Fonte: Autor
Note que o Pacote (Package) já está definido como

“exercicio1”, pois é dentro dele que a classe será criada.
Agora siga os seguintes passos:
Digite o nome para a classe: “Principal”;
Marque a opção: “public static void main(String[]
args), como mostrado na figura acima;
Deixe o restante como está e clique FINISH;
A classe “Principal” será criada dentro do pacote
“exercicio1” e o Eclipse deve mostrar algo parecido com a
figura abaixo (Figura 9):
Figura 9 – Primeira
classe criada.
Fonte: Autor
Note, na figura acima (Figura 9), que o Package

Explorer, onde vemos a classe: “Principal.java”, dentro do
pacote “exercicio1”, que está dentro da pasta “src” do projeto
“Exe1”, como definido acima.
Ao centro vemos o conteúdo da classe “principal.
java”. Esta classe será usada para digitar o código necessário
para o nosso primeiro projeto em Java. A figura abaixo (Figura
10) mostra em detalhes, o conteúdo da classePrincipal.java”,
para detalhamento.
Figura 10 – Classe Principal.java
Fonte: Autor
A linha 1 define que a classe “Principal.java” está

dentro do pacote “exercicio1”;
A linha 3 inicia a declaração da classe “Principal.
java”. O termo “public” define que a classe “Principal.
java” é pública. Classes, atributos e métodos podem ser
declarados como “public”, “protected” ou “private”. Veremos
mais detalhes sobre estes modificadores de acesso mais nas
próximas páginas, neste material.
IMPORTANTE
Uma classe deve sempre iniciar com abre chaves “{“ e finalizar
com fecha chaves “}”. Mais detalhes sobre as classes em Java serão
vistos nas próximas páginas neste material;
Nas linhas 5 a 9 é apresentado um bloco de comentário.

Sempre que for necessário fazer um comentário em bloco sobre
o código, deve-se utilizar o comando “/*” para iniciar o bloco
de comentário e “*/” para finalizá-lo. Digite seu nome e a data
de hoje dentro do bloco de comentário. É boa prática descrever
qual a função da classe que está a ser implementada.
Alguns programadores iniciantes concluem que inserir
comentários dentro do código Java é perda de tempo, porém,
programadores profissionais utilizam este recurso, pois ele
facilita a leitura do código, e em caso de alteração ou atualização,
principalmente quando o código que se precisa alterar ou corrigir
foi feito por outro programador.
Nas linhas 10 a 13 está declarado o método “main”. Este
é um método especial da classe. Ele sempre será o primeiro
método que será executado num programa Java, isto é, ele serve
como ponto de partida para a execução do projeto. Da mesma
forma que as classes, cada método declarado deve sempre iniciar
com abre chaves “{“ e será finalizado com fecha chaves “}”;
Note que não existe nenhum código dentro dele. Apenas
um comentário em linha. Os comentários em linha sempre são

iniciados com o comando “//”;
Digite o seguinte código dentro do método main:
Figura 11 – primeiro código em
Java.
Fonte: Autor
Na figura acima (Figura 11), o comando: “System.
out.println(...); ” é responsável por mostrar o texto que está
entre parênteses. Neste caso: “Meu primeiro código Java”, no
console do IDE;
Para executar o programa Java clique no botão “Run”,
mostrado na “Figura 11”.
O programa Java deve ser compilado, gerando
“bytecodes” e interpretado pela JVM, gerando o resultado no
Console, como mostrado na figura abaixo (Figura 12):
Figura 12 – Resultado da
execução do primeiro projeto
F o n t e :
Se você conseguiu o mesmo resultado que foi
apresentado na figura acima, parabéns! O primeiro passo está
dado!
Até o momento não estamos trabalhando com um
projeto Java-Android, mas sim com um projeto Java simples
(desktop), pois o objetivo desta Unidade 2 é apresentar a
linguagem Java, para que você possa implementar projetos
em dispositivos móveis na próxima unidade.
IMPORTANTE
A Linguagem Java diferencia letras maiúsculas de letras minúsculas.

Preste atenção em como você declara e usa as variáveis em seu
programa, assim evita perder tempo.
Estrutura Básica da Linguagem Java
“
Introdução
”
A linguagem de programação Java é concorrente,
baseada em classes, orientada a objetos e de
propósito geral. (MATTOS, 2007, p. 30).
Dessa definição, podem-se relacionar alguns conceitos

importantes, relacionados na tabela a seguir.
Estrutura de um Programa Java

Para o desenvolvimento dos exercícios desse material será
adotada a seguinte estrutura para um programa Java básico:
Projeto: Todo programa Java deve fazer parte de um
projeto;
Pacote: Cada projeto deve ter um ou mais pacotes. =
Cada pacote (Package) serve para organizar/separar as

classes com funções semelhantes;
Classes: Cada pacote deve ter uma ou mais classes;
Variáveis: Cada classe pode ter uma ou mais variáveis;
Atributos: Cada classe pode ter um ou mais atributos;
EXEMPLO
Métodos: Cada classe pode ter um ou mais métodos;
Para reforçar o entendimento do que foi exposto até o
momento, vamos treinar. Siga os seguintes passos:
Abra o Projeto Exe1, criado no item anterior;
Crie outro pacote, chamado: exercicio2.
Dentro deste novo pacote, crie uma classe Principal,
contendo o método MAIN.
Na Classe Principal, insira um comentário com o seu
nome e a data de hoje;
Dentro do método “main”, digite um código para mostrar
no console a seguinte frase: “Inicio do Exercicio2”;
Seguindo os mesmos passos apresentados no item anterior, a tela
do Eclipse deve ficar como mostrado na figura abaixo (Figura 13):
Figura 13 – Exemplo – Implementando
a Classe Java
Fonte: Autor
Identificadores
Dentro de um programa existem variáveis, constantes,
classes, objetos entre outros elementos. Para cada um desses
elementos é necessário definir um nome. Este é chamado de
identificador.
EXEMPLO
int x;
x = 0;
No código acima foi definida uma variável de nome
“x”, que recebe o valor 0 (zero). Então, para este caso, “x” é
o identificador de uma variável do tipo int (inteiro).
Para definir o nome de identificadores é necessário
seguir algumas regras:
Evite utilizar acentuação;
Letras maiúsculas são diferenciadas de letras
minúsculas;
Não pode conter espaços em branco;
Deve iniciar com uma letra ou caractere “_”;
Pode conter número a partir do segundo caractere;
Não pode conter caracteres de pontuação ou especiais,
tais como: “#”, “@”, “&”, “?”, “!”, “:”, etc;
Não pode ser uma palavra reservada (Veja no item
1.2.4);
Na tabela acima, “float” é uma palavra reservada da

linguagem Java para identificar um tipo de dado
Palavras Reservadas
As palavras Reservadas são utilizadas pelo sistema
como palavras chave e não podem ser utilizadas como
identificadores. São elas:
Você não precisa decorar estas palavras reservadas.

Durante o aprendizado você perceberá quando uma delas
aparecer. Mas, nunca utilize nenhuma dessas palavras para dar
nome a variáveis, classes, objetos ou qualquer elemento definido
pelo usuário em seu programa.
Obs: Todas são escritas em letras minúsculas.
Variáveis
Quando um programa é desenvolvido, normalmente
ele deve atender a uma ou mais necessidades do mundo real e
para tanto ele precisa modelar esta realidade o mais próximo da
exatidão possível. Para que o programa modele apropriadamente
a realidade, seus elementos (variáveis, métodos, classes, objetos,
etc.) devem estar definidos com o tipo adequado de dado.
EXEMPLO
Imagine que existe a necessidade de montar um programa
para somar dois números. Uma análise rápida permite perceber que
é necessário definir três variáveis: uma para o primeiro número,
outra para o segundo número e uma terceira variável para armazenar
a soma dos dois primeiros números. Então, no programa Java,
devem ser definidas três variáveis, mas, elas precisam ter seus tipos
também definidos, para que o programa se assemelhe o máximo da
realidade em questão. Estas variáveis não podem ser do tipo texto,
pois não se pode somar textos.
Também não podem ser do tipo inteiro, pois, com certeza,
em algum momento será necessário somar números com casas

decimais. Então, essas variáveis devem ser definidas como números
reais, isto é, que podem armazenar números positivos e negativos
e com casas decimais, se necessário. A figura abaixo (Figura 14)
mostra o segmento de código para executar a soma em questão.
Figura 14 – bloco de código para somar dois números.
Fonte: Autor
Como mostra o exemplo acima, cada variável definida
num programa Java será armazenada num local da memória e
deverá estar associada a um tipo de dado, para seu correto uso.
A linguagem Java permite a definição de dois tipos básicos de
dados para as variáveis, quais sejam: Simples e Composto.
Vamos a eles.
Tipos de Dados Simples
São dados que não podem ser divididos em tipos
primitivos. São eles:
INTEIROS
PONTO FLUTUANTE
BOOLEANO
CARACTERE
Para se definir uma variável com um tipo de dados

simples use a seguinte sintaxe:
<nome do tipo> <nome da variável>;
EXEMPLO
Figura 15 – Declaração de valoração de variáveis de
tipos de dados simples.
Fonte: Autor
Pode-se definir mais de uma variável do mesmo tipo,

da seguinte maneira:
Figura 16 – Declaração de variáveis do
mesmo tipo.
Fonte: Autor
Pode-se também definir um valor inicial para a variável

no momento em que ela é declarada, por exemplo:
Figura 17 – Declaração e valoração de variáveis.
Fonte: Autor
EXEMPLO
Imagine que precisamos desenvolver um programa
que faça a soma de dois números inteiros e apresente o
resultado no console. Para resolver esta questão, devemos
seguir os seguintes passos:
Para o projeto Exe1, no pacote exercicio2;
Dentro do método main, defina três variáveis do tipo
inteiro, com os seguintes nomes: Num1, Num2 e Result.
Atribua valores inteiros as variáveis Num1 e Num2 e
realize a operação de soma das duas, armazenando o resultado
na variável “Result”;
Mostre o seguinte resultado no console: “O resultado
da soma é: ...”. No lugar dos três pontos deve estar o valor
armazenado em Result.
Figura 18 – Exemplo de
código para somar dois
números inteiros.
Fonte: Autor
Melhorando o código: Com a ajuda de comentários,

pode-se facilitar a compreensão do código acima, da seguinte
maneira:
Figura 19 – O mesmo
código da figura 18 com a
inserção de comentários.
Fonte: Autor
Repare como fica muito mais fácil de ler o código na

figura 19, do que na figura 18. Agora, salve o projeto e execute-o.
O resultado apresentado no console deve ser o seguinte:
Figura 20 – resultado da
execução do código da figura
19.
Fonte: Autor
É importante notar que a atividade acima faz apenas

a soma de números inteiros. Caso seja colocado um valor
não inteiro para algumas das variáveis, um erro será gerado,
mostrando que o tipo de variável definido (int) não suporta
um valor que não seja inteiro.
Tipos de Dados Compostos

Dados Compostos, são tipos de dados que não estejam
entre os oito tipos primitivos (simples) de dados. Todos os
tipos compostos são classes. As variáveis do tipo composto
podem armazenar um dos seguintes valores:
Uma referência nula: “null”;
Uma referência para qualquer objeto cuja classe seja
compatível com o tipo da variável;
Armazenar uma referência para qualquer objeto
significa que a variável não armazena o valor que é atribuído
a ela, mas é um “ponteiro” que aponta para o endereço onde
está aquela instância de classe (objeto) e este endereço possui
o valor desejado. Os tipos “String” e “Arrays” são os tipos de
dados compostos mais comuns.
Os objetos definidos pelo usuário também são do tipo
referência. Veremos estes conceitos com mais detalhes no
decorrer deste material.
Conversão de Tipos
Durante o desenvolvimento do programa pode haver
necessidade de trocar (mudar) o tipo de dado de uma variável
para outro tipo. Esta troca é chamada de “conversão de tipos”
ou “casting”, em inglês, e tem a seguinte sintaxe:
(<tipo final>) <identificador>

ou
(<tipo final>) <expressão>
EXEMPLO
Neste exemplo, a variável “x” é do tipo inteiro e possui
como conteúdo o valor 10. Declara-se então uma variável
“b”, do tipo byte e faz-se uma conversão de tipo (casting)
para atribuir o conteúdo da variável “x” para a variável “b”.
int x = 10;
byte b;
b = (byte) x;
EXEMPLO
Exemplo utilizando expressão:
int x, y;
x = 10; y = 6;
byte b;
b = (byte) x + y;
Algumas conversões podem causar perda de
informação. Isto acontece quando se quer, por exemplo,
converter uma variável do tipo “double” para “int”, como
mostrado abaixo:
double PI = 3.141642;
int i;
i = (int) PI;
EXEMPLO
Imagine este cenário: Precisamos montar um bloco
de código que declare uma variável do tipo “double” com
valor igual a 12,34 e outra variável do tipo int. Por um motivo
qualquer, é necessário fazer a atribuição do valor da variável
do tipo “double” para a variável do tipo “int”, usando
conversão de tipos e é necessário apresentar o resultado no
console. Para resolver este problema, crie um novo pacote
no projeto Exe1, chamado de exercicio3 e, dentro deste
pacote, crie uma nova classe chamada Conversao_de_tipos.
Não esqueça que a classe precisa conter o método “main”. O
código seria mais ou menos assim:
Figura 21 – Exemplo de conversão
de tipos
Fonte: Autor
Repare que o valor 12,34 poderia ser definido como
“float” e não como “double”, porem o java não aceita a
atribuição de valores do tipo “float” em variáveis. Pesquise
por que isso acontece.
Salve a classe e execute-a. O resultado apresentado
deve ser o número “12”.
Perceba que a conversão de tipo “double” para “int”
teve como consequência a perda de informação!
Escopo de Variável
Segundo o dicionário Priberiam1, “escopo” significa o “limite
ou abrangência de uma operação”. Sendo assim, quando se
trata de escopo de variáveis em um código Java, é necessário
perceber que uma variável pode não ser válida em todo o
programa, mas sim, apenas dentro de uma classe ou de método

ou ainda que a variável pode ser válida apenas dentro de um
bloco de código dentro de um método. É importante destacar
também que uma variável declarada em Java deve estar numa
das três categorias apresentadas na tabela abaixo:
EXEMPLO
O código abaixo mostra a declaração de variáveis nas
categorias apresentadas na tabela 4.
Figura 22 – Exemplo
de declaração de
categorias de variáveis.
Fonte: Autor
Modificadores de Acesso
Relativamente às variáveis que são declaradas como
(categoria) Atributo:
De maneira geral, podem ser definidas como atributos
públicos (public), atributos privados (private) ou atributos
protegidos (protected). Um atributo declarado como
público pode ser acessado diretamente por outras classes
que instanciarem a classe que possui este tipo de atributo.
Isto não ocorre para o caso de atributos privados, que não
ficam acessíveis. Já os atributos declarados como protegidos

só poderão ser acessados por sub-classes e/ou classes que
estejam no mesmo pacote.
Atributos Públicos
Atributos do tipo “public” podem ser acessados por todas as
classes.
EXEMPLO
Para verificar esta afirmação, crie um novo pacote,
dentro do projeto Exe1, chamado de exercicio4. Dentro deste
pacote, crie uma classe chamada Mod_Publico (que não
deve conter o método “main”). O código deve ser como o
apresentado na figura abaixo:
Figura 23 – Exemplo de
Classe com atributo do tipo
público.
Fonte: Autor
Crie no mesmo pacote uma outra classe, chamada
“Principal” ( que deve conter o método “main”). O código
deve ser o mostrado na figura abaixo:
Figura 24 - Exemplo de
acesso à atributo do tipo
público
Fonte: Autor
Repare que no exemplo acima o atributo da classe Mod_publico

pode ser acessado diretamente, bastando para isso instanciar a classe.
Atributos Privados
Atributos do tipo “private” não pode ser acessado diretamente
por todas as classes.
EXEMPLO
Para verificar esta afirmação, siga os seguintes passos:
(1) dentro do pacote exercicio4, crie uma classe chamada
Mod_Privado (que não deve conter o método “main”). O
código deve ser como o apresentado na figura abaixo:
Figura 25 – Exemplo de Classe com
atributo do tipo privado.
Fonte: Autor
(2) Na classe “Principal”, criada no exemplo anterior,
modifique o código para que fique como mostrado na figura a seguir:
Figura 26 - Exemplo de acesso
à atributo do tipo público e
outro privado.
Fonte: Autor
IMPORTANTE
No exemplo acima, não foi possível acessar o atributo do tipo

privado. Para acessar este tipo de atributo é necessário utilizar os
métodos “getters” e “setters”.
Getters: métodos que permitem capturar os valores

dos atributos privados;
Setters: métodos que permitem definir os valores para
os atributos privados;
Neste exemplo vamos criar uma nova classe que

possua atributos do tipo privado, mas que também possuam
metodos “getters” e “setters.” Sendo assim, no mesmo pacote,
crie uma nova classe, chamada de “Mod_Privado2”, com o
seguinte conteúdo:
Figura 27 – Classes
com atributos privados
e métodos getters e
setters.
Fonte: Autor
Modifique o conteúdo da classe principal, para ficar
como mostrado na figura abaixo (Figura28):
Figura 28 - Exemplo de acesso
à atributo do tipo privado com
métodos getters e setters
Fonte: Autor
Operadores
A linguagem Java disponibiliza seis tipos de
operadores. Neste tópico iremos apresentar, descrever e
verificar como utilizar cada um deles.
Operadores Aritméticos
A regra de precedência dos operadores aritméticos

obedece a regra (de precedência) definida pela matemática
básica, com relação a operações aritméticas.
Operadores de Atribuição
Para a tabela abaixo, considere que a variável x tenha
sido declarada com valor inicial igual a 12.
Crie um novo pacote no projeto Exe1, chamado de

exercicio5. Dentro deste pacote, criar uma nova classe clamada
Operadores1 (que deve conter o método “main”). Dentro do
método “main”, siga as seguintes instruções (sem utilizar
operadores de atribuição): (1) Declare uma variável do tipo
inteiro; (2) Atribua o valor 10 a esta variável; (3) Some 3 e
armazene o resultado nela mesma; (4) Subtraia 1 e armazene o
resultado nela mesma; (5) Divida por 2 e armazene o resultado
nela mesma; (6) Multiplique por 7 e armazene o resultado nela
mesma; (7) Mostre o resultado no console.
Caso você tenha seguido exatamente como informado
acima, o seu código deve estar igual ao mostrado na figura
abaixo:
de código com
uso de operadores
aritméticos
F o n t e :
O valor apresentado no console deve ser: 42.
Crie uma nova classe, chamada Operadores2 que
realize os mesmos passos que o exemplo anterior, só que
desta vez, a utilizar apenas operadores de atribuição. Seu
código deve ficar assim:
Figura 30 – Exemplo de código
com uso de operadores de
atribuição.
Fonte: Autor
O valor apresentado no console deve ser: 42.

Operadores de Incremento e Decremento
Para a tabela abaixo, considere que a variável “x”
tenha sido declarada com o valor inicial igual a 2 e a variável
“y” tenha sido declarada com valor inicial igual a 0.
EXEMPLO
Crie uma nova classe, chamada Operadores3, e siga
os seguintes passos: (1) Declare duas variáveis (a e b) do tipo
inteiro; (2) Atribua o valor 10 para a variável a e 0 para a
variável b; (3) Mostre o valor das duas variáveis no console;
(4) Faça um pré-incremento na variável b e atribua o valor de
b em a; (5) Mostre o valor das duas variáveis no console; (6)
Faça um pós-decremento na variável b e atribua o valor de b
em a; (7) Mostre o valor das duas variáveis no console. Seu
código deve ficar assim:
de uso de operadores de
incremento e decremento.
Fonte: Autor
Operadores Relacionais
Para a tabela abaixo considere que as variáveis “x”
e “y” foram declaradas com valores iniciais iguais a 13 e 5,
respectivamente.
Operadores Booleanos
Para a tabela abaixo considere que as variáveis “x”
e “y” foram declaradas com valores iniciais iguais a 13 e 5,
respectivamente.
Operador Ternário
O operador ternário tem as mesmas características do
comando if-else (que veremos mais adiante). Sua sintaxe é a
seguinte:
<variável> = <condição>?<caso true>:<caso false>;
EXEMPLO
Imagine o seguinte bloco de código:
int num1 = 11;
int num2 = 12;
int num3;
num1 = (num1 >
num2)?num1:num2;
Se o resultado da condição “(num1>num2)” for

verdadeiro, a variável num3 recebe o valor de num1, caso
contrário, num3 recebe o valor de num2.
Estrutura de Controle de Seleção e de

Repetição
Introdução
Toda linguagem de programação precisa ter sua
estrutura de controle, que permite ao programador desenvolver
e controlar como o programa deve responder a determinadas
condições, quando em execução.
Estrutura de Controle de Seleção

Comando if
O controle de seleção “if” (que significa SE) permite
ao programador definir se um bloco de código será ou não
executado, dependendo do resultado de um teste, cujo
resultado pode ser verdadeiro ou falso. Caso o resultado do
teste seja verdadeiro, o bloco de código é executado, caso
contrário, o bloco de código não será executado.
A sintaxe do “if” é a seguinte:
if (teste)
{
Bloco de Código;
}
O teste é uma condição Booleana: isto é, qualquer

expressão que retorne como resultado os valores “true” ou
“false”.
EXEMPLO
int idade = 15;
if (idade <18)
{
System.out.println(“Não pode entrar”);
}
No exemplo acima, o teste é (idade < 18). A linha de

código “if (idade < 18)” deve ser lida da seguinte maneira:
“Se o valor da variável ‘idade’ for menor que 18”. Caso o
resultado deste teste seja verdadeiro, isto é, “true”, o bloco
de código logo abaixo do teste deve ser executado. Para
o caso do exemplo acima, se o valor da variável idade for
menor que 18, o programa deve mostrar no console a seguinte
mensagem: “Não pode entrar”. O bloco de código que deve
ser executado está limitado pelo abre chaves “{“ e pelo fecha
chaves “}”.
Comando if – else
Como foi visto no item anterior, o comando “if”
permite que um bloco de código seja executado se a condição
apresentada no teste for verdadeira. Porém, algumas vezes é
necessário definir o que o programa deve fazer caso o resultado
da condição apresentada no teste for falsa. Para estes casos,
utiliza-se o comando “else” (que significa SENÃO).
O comando “else” nunca pode ser utilizado sozinho,
mas sempre como complemento do comando “if”. A sintaxe
para o comando “if-else” é a seguinte:
Imagem Ilustrativa
Fonte: Pexels / pixabay

if (condição)
{
Bloco de código – deve ser executado se a condição
for verdadeira.
}
else
{
Bloco de código – deve ser executado se a
condição for falsa.
}
EXEMPLO
int idade = 15;
if (idade <18)
{
System.out.println(“Não pode entrar”);
}
else
{
System.out.println(“Pode entrar”);
}
Como pode ser observado no exemplo acima, o

programa pode apresentar dois tipos de mensagens. Caso a
condição resultante do teste (idade < 18) seja verdadeira (true),
o programa vai apresentar a mensagem: “Não pode entrar”, mas
caso o resultado da condição (idade < 18) for falsa (false), a
mensagem apresentada é: “Pode entrar”.
Condições mais elaboradas

As condições (testes) utilizados no comando “if” podem
ser bem mais elaborados que os exemplos apresentados acima.
Pode-se, por exemplo, concatenar expressões booleanas por
meio de operadores lógicos, como mostrado no exemplo abaixo.
EXEMPLO
int idade = 15;
boolean amigoDoDono = true;
if ((idade <18) && (amigoDoDono) == false)
{ System.out.println(“Não pode entrar”); }
else
{ System.out.println(“Pode entrar”); }
IMPORTANTE
Repare que o operador “=” é de atribuição e o operador “==” é de

comparação;
No exemplo acima, o teste a ser feito é formado

por duas condições (expressões booleanas). A primeira
é a verificação do valor da variável idade. A segunda é a
verificação da variável amigoDoDono.
Resumindo, os resultados das duas expressões devem
ser verdadeiros para que a mensagem apresentada seja: “Não
pode entrar”. Caso o resultado de uma das expressões seja
falsa, a mensagem apresentada será: “Pode entrar”.
O comando swicth
O comando “switch” pode substituir o comando “if-
else” para os casos em que existem muitas escolhas (seleções)
a serem feitas, isto é, utilize “if-else” quando precisar testar
diferentes variáveis e utilize “swicth” quando precisar
comparar uma variável com diversos valores. A sintaxe do
comando “swicth” é a seguinte:
swicth (<variável>)
{
case valor1:
bloco de código que deve ser executado se a variável
tiver valor = valor1;
break;
case valor2:
tiver valor = valor1;
break;
case valorN:
tiver valor = valorN;
break;
default:
bloco de código que deve se a variável não encontrar
nenhuma correspondência nos cases acima;
break;
}
IMPORTANTE
Os cases não podem testar valores booleanos, por isso, a Linguagem

Java não vai conseguir entender o que deve ser deito caso seja
digitada a seguinte linha de comando: “case valor1 >10:”.
EXEMPLO
int i = 3;
swicth (i)
{
case 1:
System.out.println(“i é igual a 1”);
break;
case 2:
System.out.println(“i é igual a 2”);
break;
default:
System.out.println(“i é diferente de 1 e diferente de 2”);
break;
}
Estrutura de Controle de Repetição

while
O comando “while” (que significa ENQUANTO)
permite que um bloco de código seja repetido um número
definido de vezes durante a execução do programa. Para
controlar quantas vezes o bloco de código deve ser repetido,
utiliza-se uma condição (teste). Por definição, enquanto o
resultado do teste for verdadeiro, o bloco de código deve ter
sua execução repetida.
A sintaxe para o comando “while” é a seguinte:
While (condição)
{
Bloco de código que deve ser executado enquanto a
condição for verdadeira.
}
EXEMPLO
int idade = 15;
while (idade <18)
{
System.out.println(idade);
idade = idade + 1;
}
No exemplo acima, o bloco de código será repetido até

que o valor da variável “idade” se torne igual ou maior que 18,
por isso, dentro do bloco de repetição deve ser colocado uma
linha de comando que altere o valor da variável que está sendo
testada. Caso a linha de comando “idade = idade + 1;” seja
retirada do programa, o valor da variável idade não irá se alterar
e o programa executará o bloco de código indefinidamente, o
que fará com que o programa trave (entre em loop eterno).
Observando o código do exemplo, verifica-se que
primeiro é definido o valor da variável idade como sendo o
valor 15. Depois faz-se um teste, que deve ser lido da seguinte
maneira: “Enquanto o valor da variável idade for menor que
18, execute o bloco de código”. Como o resultado deste teste é
verdadeiro, o bloco de código é executado e o número 15 deve
aparecer no console. A linha seguinte faz com que o valor da
variável idade passe de 15 para 16. O bloco de código acaba
e o teste é feito novamente. Como 16 ainda é menor que 18,
o bloco de código é executado mais uma vez. O número 16 é
mostrado no console e a variável idade tem seu valor alterado
para 17. O bloco de código acaba e o teste é feito novamente.
Como a condição ainda é verdadeira, o número 17 é
apresentado no console e o valor da variável idade passa para
18. O bloco de código acaba e o teste é feito mais uma vez.
Como dessa vez o resultado do teste é falso, o bloco de código
não é mais executado e o programa segue para as linhas de
código que por ventura existam abaixo deste bloco de código.
for
O comando “for” e outro comando de repetição (loop)
que permite repetir um determinado bloco de código enquanto
a condição for verdadeira. Porém, o “for” trata a condição de
maneira um pouco diferente do comando “while”, apresentado
acima. A sintaxe do comando “for” é a seguinte:
for (inicialização; condição; incremento)
{
Bloco de código que deve ser executado enquanto a condição
for verdadeira.
}
Como pode ser notado pela sintaxe acima, o comando

“for” possui três parâmetros:
Inicialização: permite ao programador declarar e
inicializar uma variável;
Condição: permite ao programador definir a condição
que deve ser testada a cada repetição (loop);
Incremento: permite ao programador definir qual
deve ser o incremento que a variável deve receber em cada
repetição (loop);
EXEMPLO
for (int i = 0; i < 10 ; i++)
{
S y s t e m . o u t .
println(i);
}
No exemplo acima, o programa irá apresentar no
console os números de 0 (zero) a 9 (nove).
Controlando Loops
O comando break
Como foi verificado nos itens acima, os laços

de repetição (loops) precisam de condições para serem
executados. Porém, existe casos em que se faz necessário
parar uma repetição se determinada condição for encontrada.
Para resolver este problema, utiliza-se o comando “break”.
EXEMPLO
int x, y;
x = 0; y = 50;
for (int i = x; i < y; i ++)
{
if (i%19 == 0)
{
System.out.println(“Achei um
número divisível por 19 entre x e y”);
break;
}
}
No exemplo acima, o programa quer localizar o

primeiro número, entre 0 e 49 que seja divisível por 19.
Repare que se o comando “break” for retirado do código, o
programa vai apresentar no console todos os números entre 0
e 49 que sejam divisíveis por 19, mas não é isso que se quer.
O que se quer é apenas o primeiro. Por isso, uma vez que
o primeiro número divisível por 19 foi encontrado, utiliza-
se o comando “break” para abortar a execução do laço de
repetição (for), pois ele não é mais necessário.
O comando continue
Em outros casos, faz-se necessário permitir que o
laço de repetição não execute o loop para uma determinada
condição. Nestes casos, utiliza-se o comando continue.
EXEMPLO
for (int i = 0; i < 100 ; i ++)
{
if ( i > 50 && i < 60)
{
continue;
}
System.out.println(i);
}
No exemplo acima, o programa vai mostrar os

números de 0 a 50 e de 60 a 99, pois quando os valores da
variável i forem maiores que 50 e menores que 60, o “loop”
será ignorado.
No desenvolvimento de um programa mais complexo ou
aprimorado, normalmente utiliza-se não apenas um tipo de
estrutura de controle, mas sim uma mescla das várias descritas
acima. É muito comum utilizar uma estrutura de controle de
seleção (if) dentro de uma estrutura de controle de repetição
(for ou while).
IMPORTANTE
Toda a base da programação está no entendimento dos conceitos de

estrutura de controle apresentados nesta unidade. É praticamente
impossível construir qualquer bloco de código significativo sem
dominar esses conceitos. Por isso, para que você realmente aprenda
a programar não passe para o próximo módulo sem ter entendido
muito bem os conceitos apresentados aqui.
Classes em Java
Introdução
Como foi estudado na disciplina de Introdução ao Coding
Web, uma classe é composta por Nome, Lista de Atributos

e Lista de Métodos. Os atributos, como visto anteriormente
neste material, são as variáveis de Instância. Os métodos e, por
fim, as classes propriamente ditas, serão tratadas neste tópico.
Métodos
Um Método de uma Classe define o comportamento
que a classe deve ter quando este Método for chamado numa
mensagem.
Quando uma Classe recebe uma mensagem, esta
mensagem normalmente informa qual método ela deve
executar. A Classe, então, redireciona a execução do programa
para o código que está contido dentro do método chamado.
Quando o bloco de código daquele método acaba, o programa
retorna à execução do programa para a linha de código seguinte
a que chamou o método.
O termo “chamar um método” é utilizado neste material
para dizer que o código que está contido dentro daquele método
deve ser executado.
Para declarar um método público em Java utilizamos a
seguinte sintaxe:
public <tipo de retorno> <nome do método>
{
Bloco de código que deve ser executado quando este
método foi chamado.
}
Onde:(1) O termo “public” define que o método pode
ser acessado por outras classes que instanciarem a classe
que contem este método. Caso se queira tornar este método
inacessível para outras classes, é necessário substituir o termo
“public” por “private”; (2) O <tipo de retorno> informa ao
programa se qual o tipo de dado que o método irá retornar
quando for executado. Para o <tipo de retorno> pode-se
utilizar qualquer um dos tipos primitivos ou compostos
(também chamados de tipos de referência). Caso o método não

precise ter retorno, utiliza-se o termo “void”. Caso o método
possua algum tipo de retorno, a última linha do método a ser
executada é o comando “return” acompanhado da variável que
armazena o valor que deve ser retornado; (3) Para o <nome
do método> utiliza-se qualquer identificador válido que ainda
não tenha sido utilizado para declarar outros elementos nesta
mesma classe.
O nome do método deve sempre ser sucedido por abre e
fecha parênteses “()”, caso não tenha parâmetros. Caso contrário
os parâmetros devem ser declarados entre os parênteses.
EXEMPLO
Para este exemplo, crie um novo pacote, chamado de
exercicio6. Dentro deste pacote, crie uma classe chamada
de Principal (que deve conter o método “main”. O conteúdo
desta classe deve ser a seguinte:
Figura 32 – Exemplo de chamada
de método.
F o n t e :
Explicando o exemplo acima:
1 - Quando o programa acima é executado, o primeiro método a
ser chamado quando é o método “main” (linha 12) conforme já
foi dito anteriormente, neste material.
2 - Dentro do método “main”, três variáveis são declaras (linhas
13 a 15) e têm seus tipos e valores definido. São elas: a, b e c.
3 - Na linha 16 existe uma chamada ao método soma, passando
como parâmetros as variáveis a e b.
4 - A execução do programa passa para a linha 5, onde o método
soma (que foi chamado na linha 16) recebe os dois parâmetros,
como sendo “X” e “Y”. Isto quer dizer que apenas dentro do
método soma() a variável “a” será chamada de “X” e a variável
“b” será chamada de “Y”.
5 - O método soma() executa a operação de adição das suas duas
variáveis e armazena o resultado na variável “resultado”. (linhas
8). A última linha do método soma (linha 9) faz o retorno da
soma das variáveis (return resultado).
6 - A execução do programa retorna para a linha 16, onde o
resultado da soma é atribuído à variável c, dentro do método
“main”.
7 - Na linha seguinte (linha 17) o programa executa um comando
para mostrar no console o resultado calculado pelo método soma.
EXEMPLO
Como segundo exemplo de chamada de método,
implemente na os métodos subtração, multiplicação e divisão
para as mesmas variáveis a e b e teste o resultado do programa.
Seu código deve ficar assim:
Figura 33 – Exemplo 2 de
chamada de métodos.
Fonte: Autor
Classes
Como foi verificado anteriormente, neste material, a
Programação Java é baseada em Classes. Isto quer dizer que
toda a estrutura da programação Java está baseada no envio e
recebimento de mensagens entre as classes, isto é, uma classe
a chamar a outra através de métodos.
Para melhor entendimento do que seja uma classe e de
como podemos cria-las utilizando a linguagem Java, imagine
a classe CALCULADORA especificada na figura abaixo
(Figura 34).
Repare que esta classe possui apenas um atributo,

chamado ‘resultado’ e possui quatro métodos, uma para cada
operação matemática básica.
Para implementar esta classe, siga os seguintes passos:
1 - Crie um novo pacote (package), chamado Calculadora
e uma classe principal (com o método main) dentro dele. A
figura abaixo mostra como deve ficar o Package Explorer do
seu projeto.
Figura 35 – Pacote Calculadora
Fonte: Autor
Não apague os outros pacotes (exercicio1 e exercicio2),

pois é muito interessante que você tenha um histórico da sua
evolução em programação Java, mas nosso foco agora será o
Pacote Calculadora.
2 - Agora, crie uma nova classe, chamada “calc”, dentro do
pacote Calculadora. Mas nesta classe NÃO marque a opção:
“public static void main(String[] args)”. O Package Explorer

deve ficar assim:
Figura 36 – Pacote Calculadora com duas
classes
Fonte: Autor
3 - Clique duas vezes sobre a classe principal.java e o Eclipse

exibirá a seguinte tela:
Figura 37 – Classe Principal.java – com o
método MAIN
Fonte: Autor
Repare que esta classe possui o método: “public static

void main(String[ ] args)”. Como você deve ter percebido, o
nome do método é simplesmente “main” e tem como atributo
o “array” do tipo “String”, chamado “args”.
4 - Clique duas vezes sobre a classe calc.java e o Eclipse deve
mostrar a seguinte tela:
Figura 38 – Classe Calc – sem o método
MAIN
Fonte: Autor
Repare que a classe “Calc” não deve ter o método
“main”. Este método só deve estar presente na classe principal
do pacote.
Para implementar o exemplo, o nosso trabalho consiste
em traduzir o “desenho” representado na figura 34 (da classe
calculadora) para dentro do código Java – classe “Calc”.
Figura 39 – Exemplo da
tarefa a ser realizada
Fonte: Autor
EXEMPLO
Vamos demonstrar passo a passo a implementação da
classe calculadora:
1 - Acrescente um bloco de comentário padrão e declare o
atributo na classe “calc”.
Figura 40 – Exemplo – parte I
Fonte: Autor
2 - Acrescente os métodos descritos na figura 39 na classe “calc”.
Figura 41 – Exemplo – Parte II
Fonte: Autor
Note que o código apresentado acima deve apresentar

4 indicações de erros. Para identificar o motivo da indicação
de erro, pare o ponteiro do mouse sobre cada um dos erros
e verifique os respectivos motivos. O erro deve ser como
mostrado na figura abaixo (Figura 42):
Figura 42 – Identificação de
erro do código.
Fonte: Autor
Note que o problema está no fato de que nós escrevemos
um método que deveria retornar uma variável do tipo “double” e
não escrevemos a linha de código para que este retorno seja feito.
Dessa forma, a própria “IDE” apresenta opções para corrigir o
problema: Podemos adicionar o comando return ou mudar o tipo
de retorno do método para ‘void’, como se pode ver na figura 42.
Para o nosso caso, a solução mais adequada é inserir o
comando “return”. O nosso código fica, então, como mostrado
na figura abaixo:
Figura 43 – Código corrigido
Fonte: Autor
A partir de agora, o que falta é apenas inserir as
funcionalidades para cada método.
IMPORTANTE
Para o método divisão() é preciso verificar primeiro se o denominador é

diferente de zero, para evitar erro do programa em tempo de execução,
pois, como você deve saber, não existe resultado para a divisão por zero.
Figura 44 – métodos implementados na
classe Calc
Fonte: Autor
Neste ponto do exemplo, o código da classe “calc” já

está pronto, pois o atributo e os métodos já estão corretamente
declarados e implementados. Resta agora implementar a
classe “MAIN”, para que a mesma instancie a classe “Calc”
faça a chamada dos métodos (envie as mensagens para a
classe).
Para que a classe “MAIN” envie uma mensagem,
chamando o método soma() da classe “calc”, a classe “MAIN”
deve primeiro instanciar a classe “calc”, como mostrado na
figura abaixo.
Figura 45 – Classe principal a

instanciar a classe Calc
Fonte: Autor
Note que para se instanciar uma classe, isto é, criar um
objeto, deve-se usar a seguinte notação:
<tipo da classe> <nome do objeto> = new <nome da
Onde:
<tipo da classe> tem a mesma função que o <tipo da
variável> utilizado nos tópicos anteriores, neste material;
<nome do objeto> é o nome que o programador dará
para o objeto que está sendo criado;
<new> é uma palavra reservada que informa ao
programa que o programador está criando uma nova instância
de uma classe;
<nome da classe> é o nome que o programador deu
para a classe que ele está querendo instanciar. Sempre deve
ser seguindo de abre e fecha parênteses “()”;
Para o caso em estudo, a linha de código que instancia
a classe “calc” é a seguinte:
Calc C = new Calc();
A partir desta linha o programa entende que existe um
objeto chamado “C” e que o mesmo foi instanciado a partir
da classe “Calc”. Em seguida, utilizamos o objeto “C” para
chamar os métodos da classe à qual ele faz referência.
Muito bem. Execute o programa e verá que o resultado
da soma será apresentado no console.
Agora siga os mesmos procedimentos apresentados
para o processo de soma de duas variáveis e implemente
os códigos para que o método “MAIN” da classe Principal
execute a subtração, multiplicação e divisão.
Imagine que precisamos criar um novo método,

chamado “média()”, na classe “calc” para calcular a média
entre dois números inteiros. Lembre-se que este método deve
receber dois parâmetros do tipo especificado. O Código deve
ficar mais ou menos assim:
Figura 46 – método media()
Fonte: Autor
Agora faça uma chamada ao método “media()”, a

partir do método “main” da classe principal.
Figura 47 – inserindo a chamada ao
método media() na classe MAIN
Fonte: Autor
Polimormismo, Interface e Classes Abstratas

Polimorfismo
O polimorfismo ocorre quando o programa é implementado
de maneira que “o mesmo método” pode responder de diferentes
formas.
Da mesma maneira como fizemos quando este conceito
foi apresentado para a linguagem PHP (introdução ao Coding
Web – Unidade 4), entendemos como necessário a apresentação da
definição formal. Aqui está:
Polimorfismo é a capacidade da implementação de
operações de maneira diferente da definida originalmente na classe
base. Dall’Oglio (2016) destaca ainda que,
“
O significado da palavra polimorfismo nos

remete a “muitas formas”. Polimorfismo
em orientação a objetos é o princípio que
permite que classes derivadas de uma
mesma superclasse tenham métodos iguais
(com a mesma nomenclatura e os mesmos
”
parâmetros), mas comportamentos diferentes,
redefinidos em cada uma das classes filhas. -
(DALL’OGLIO, 2016)
Seguindo esta ideia, usaremos aqui o mesmo exemplo

que trabalhamos com PHP. Isso permite a você perceber
as similaridades e diferenças entre as duas linguagens de
programação para tratar este conceito.
EXEMPLO
Imagine o cenário representado pelo diagrama abaixo:
Figura 48 – representação gráfica da herança entre duas
classes.
Fonte: Autor
Primeiro vamos implementar a classe Conta.
Para implementar esta classe, crie um novo pacote
no projeto Exe01, chamado exercicio7. Dentro deste pacote,
crie uma classe Conta, sem o método “MAIN”, declare os
atributos e implemente os métodos, de acordo com a figura
48, acima. O seu código deve ficar mais ou menos assim:
Figura 49 – Classe Conta
Fonte: Autor
Agora que temos a classe Conta, crie uma nova classe,
no mesmo pacote ‘exercicio7’, chamado Conta_Poupanca.
Esta classe deve ser uma subclasse da classe Conta
(figura 49). Ser uma subclasse significa herdar as características
e comportamentos da classe mãe (ou super classe).
IMPORTANTE
Caso você não se recorde do conceito de herança entre classes, que

foi visto na disciplina de “introdução ao coding Web”, aqui vai,
novamente: Herança é a propriedade que permite que uma classe
(filha ou subclasse) herde atributos (características) e métodos
(comportamentos) de outra classe (mãe ou superclasse).
Conforme podemos verificar na figura 48, a subclasse

ContaPoupança deve conter um método ‘sacar’ com a mesma
assinatura (mesmo nome e argumentos) que a classe mãe
(Conta). Para usar a herança, em Java, utiliza-se a palavra
reservada ‘extends’. A classe (filha) ContaPoupança deve
ficar mais ou menos assim:
Figura 50 – Conta Poupança.
Fonte: Autor
Para o conteúdo do método sacar da classe ContaPoupança
podemos imaginar que o Valor não pode ser maior que o Saldo da
conta, verificação que não acontece na classe Conta (figura 49).
Então, nosso código fica mais ou menos assim:
Figura 51 – Classe Conta Poupança.
Fonte: Autor
Note que esta classe ContaPoupança herda (extends)

da classe Conta, criada anteriormente. Repare também que
a classe filha “contaPoupanca” possui um método com o
mesmo nome (método sacar()) que a classe mãe “conta”,
mas o conteúdo do método sacar na classe mãe e diferente do
conteúdo do método sacar na classe filha.
Para testar o funcionamento da classe “conta” e da
classe “contaPoupanca”, crie uma nova classe no mesmo
pacote ‘exercicio7’ com o nome de Principal (que deve ter o
método MAIN) com o seguinte código:
Figura 52 – Classe Principal (com método
MAIN) para testar as classes Conta e
ContaPoupança.
Fonte: Autor
Note que o método Sacar(Valor), apresentado na figura

acima verifica se a quantia a ser sacada é maior que o valor do saldo
da conta. A resposta apresentada no console deve ser o seguinte:
Figura 53 – Resultado da execução do códido da
figura 52.
Fonte: Autor
Interface
Uma interface é um tipo composto (ou referência) em
Java. Pode ser considerada como uma classe com métodos
abstratos. Alguns tutoriais java, como por exemplo o site
TutorialPoint , consideram que escrever uma interface é similar
a escrever uma classe, porém, uma classe deve descrever os
atributos e comportamentos de um objeto e a interface, por sua
vez, contém a descrição dos comportamentos que uma classe
deve implementar.
A lista a seguir apresenta algumas características de
uma interface que não podem ser esquecidas quando queremos
utilizá-las adequadamente:
Uma interface não pode ser instanciada;
Uma classe não pode herdar (extends) as características
ou comportamentos de uma interface, mas pode implementá-las
(implement);
Todos os métodos de uma interface devem ser abstratos;
Uma interface não pode conter atributos instanciáveis;
Uma interface pode herdar (extends) de outra interface;
Declarando uma Interface
Para declarar uma interface devemos utilizar a palavra-
chave: “interface”.
Imagine que, no exemplo que utilizamos para a classe
Conta, quiséssemos fazer algumas modificações, como por
exemplo: fazer com que a Classe Conta não mais contivesse
qualquer código, mas apenas a declaração dos métodos
(comportamentos) necessários para todos os tipos de contas que

nela estivessem baseadas. Nossa Classe Conta ficaria assim:
Figura 54 – Interface
Conta
Fonte: Autor
Esta interface Conta foi criada num novo pacote,

chamado exercicio8, no mesmo projeto exe01.
Se criarmos uma classe que implemente (implements)
a interface Conta, ela deve ser assim:
ContaCorrente
Fonte: Autor
Repare que ao lado da marcação da linha3 existe uma

“x” a indicar que ali existe um erro. Se pararmos o ponteiro
do mouse sobre o “x”, teremos a seguinte informação:
ContaCorrente
Fonte: Autor
Note que a IDE informa a você que para que a classe

ContaCorrente seja executada sem erros, deve implementar
os métodos da classe Conta.
Legal, não é?! Isto permite que você crie uma espécie de
‘contrato’, no sentido de exigir que os programadores que, por
ventura, queiram implementar a interface que você criou para
um determinado negócio, devam implementar determinados
métodos obrigatórios para o correto funcionamento.
Classes Abstratas
Como você deve lembrar, já apresentamos este
conceito quando estudamos a linguagem PHP, na disciplina
de Introdução ao Coding Web – Unidade 4. Assim como o
PHP, a linguagem Java também permite o recurso de utilizar
classes estruturais para servir de base para a criação de outras
classes mais especializadas.
IMPORTANTE
Uma classe abstrata não pode ser instanciada diretamente; apenas

servir de base para criação de novas classes. (DALL’OGLIO,
2016). Para definir uma classe abstrata em Java, utiliza-se a palavra
reservada abstract antes da definição da classe em si.
Diferente do que acontece com a interface, uma classe

qualquer pode herdar as características e comportamentos da
classe abstrata.
Mas, da mesma forma que acontece com a interface,
a classe abstrata pode conter métodos abstratos com o intuito
de assegurar que as suas classes filhas implementem todos os
métodos necessários para seu correto funcionamento.
Como visto no tópico relativo às interfaces, os
métodos abstratos têm a função de servir de molde para os
métodos da classe filha (extends) da classe abstrata ou (para
o caso das interfaces) de servir de molde para as classes que
a implementam (implements).
Imagine que você queira transformar a interface
Conta, apresentada na figura 54 numa classe abstrata. Crie
um novo pacote, chamado exercicio9 e, dentro dele, crie
uma classe, sem o método “MAIN”. Antes de apertar o botão
“FINISH”, selecione a opção ‘abstract’, como mostrado na
figura abaixo:
Figura 57- Criando uma classe
Fonte: Autor
Dentro da classe Conta, insira o seguinte conteúdo:
Figura 58 –
Classe abstrata
Fonte: Autor
Note que apenas dois métodos são abstratos, o que

significa que a classe abstrata conta pode superclasse de uma
classe ContaCorrente, por exemplo. Esta subclasse poderá
herdar (extends) do atributos e métodos já implementados
na classe Conta e deverá obrigatoriamente implementar o
conteúdo dos métodos abstratos ‘Depositar’ e ‘Sacar’.
Bem. Foi uma longa caminhada e espero que este

material tenha ajudado você a entender os conceitos básicos
da programação em linguagem Java. É claro que existe
muito mais a ser estudado, caso você queira se tornar um
expert em programação Java e nosso intuito aqui não foi de
esgotar o assunto, mas sim de apresentar o que pensamos
serem os conceitos fundamentais.
Verifique os links e livros indicados nas referências
bibliográficas, com destaque para os livros de Deitel (2003)
e Mattos (2007).
03
UNIDADE
GERENCIANDO APP ANDROID

INTRODUÇÃO
Seja bem-vindo(a) à Unidade 3 – Gerenciando app
Android, da disciplina de Introdução ao Coding (Mobile).
Nesta unidade usaremos os conhecimentos adquiridos nas
duas primeiras unidades e aprenderemos a criar e gerenciar
uma aplicação básica em Java-Android. O conteúdo desta
Unidade está dividido em quatro módulos. No primeiro
módulo, você entenderá como funciona o ciclo de vida da
aplicação mobile android e como implementar uma classe
Activity. No módulo 2, estudaremos sobre navegabilidade,
isto é, como implementar uma aplicação android com várias
telas e como fazer uma tela chamar a outra. No terceiro,
aprenderemos a passar parâmetros entre uma tela e outra da
aplicação, permitindo assim uma aplicação mais complexa
e robusta. Finalmente, no módulo 4, veremos como inserir
alguns dos componentes básicos em uma aplicação Android,
para que a mesma fique mais interativa. É claro que existe
muito mais para 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ê!
OBJETIVOS
1 Entender o ciclo de vida de um aplicativo desenvolvido

para Android e à classe Activity.
2 Aplicar os recursos da linguagem Java, para proporcionar

a navegabilidade de aplicativos para dispositivos móveis,
baseados no Android.
3 Compreender como transmitir parâmetros entre as telas

de um aplicativo desenvolvido na linguagem Java para
dispositivos móveis Android.
4 Formatar telas de aplicativos para dispositivos móveis

baseados no sistema operacional Android.
Ciclo de vida do aplicativo Android e a

Classe Activity
Agora que você já está com os ambientes de
desenvolvimentos Java-Android instalados e configurados em
seu computador (visto na Unidade 1) e já tem certa familiaridade
com a linguagem Java (visto na Unidade 2), podemos na Unidade
3 chegar ao entendimento de como funcionam as apps Android.
Introdução
A maioria das aplicações Android necessita de uma
interface que permita a interação com o usuário. Conhecida
também como UI (user interface), ela pode ser formada por
uma ou mais telas, onde devem ser apresentados os elementos
(botões, caixas de texto, figuras, animações, caixas de seleção
etc.). É importante destacar que cada atividade (classe activity)
representa uma única tela (UI) do aplicativo e é responsável por
gerenciar (tratar) os eventos que o usuário pode gerar em cada
um dos elementos apresentados nela, como por exemplo, o ato
de clicar em um botão, digitar um texto ou selecionar um item.
Para o caso de aplicações que precisem ter mais de
uma tela, será necessário ter mais de uma atividade, ou seja,
é necessário implementar uma atividade para cada tela. Por
exemplo, um aplicativo de e-mail deve ter uma atividade que
mostre a lista de e-mails, outra responsável por permitir que o
usuário digite um novo e-mail e ainda outra com a função de
mostrar o conteúdo do e-mail para que o usuário possa lê-lo.
Apesar das atividades de uma mesma aplicação trabalharem
juntas para compor as funcionalidades de um aplicativo, elas são
independentes umas das outras e podem, caso a configuração do
aplicativo permita, serem iniciadas individualmente.
Uma característica especial dos aplicativos do Android é
que uma aplicação pode iniciar qualquer componente instalado no
aplicativo e utilizar seus recursos, se assim estiver configurado.
++
SAIBA MAIS
Uma nova aplicação pode precisar capturar uma foto utilizando o

dispositivo de câmera. Esta nova aplicação pode utilizar um aplicativo
existente para realizar essa tarefa e capturar o resultado sem ter que
implementá-la, isto é, utilizando os recursos de uma aplicação já existente.
Para tanto, a nova aplicação precisa apenas ser capaz de iniciar a atividade
de captura de foto da outra aplicação, sem a necessidade de incorporá-la
ou de estar ligada a ela de alguma forma. Deste modo, quando a atividade
de captura de foto for finalizada, a foto é retornada para a nova aplicação
e pode ser tratada e utilizada como o programador determinar.
Um detalhe importante a se considerar é que, pelo fato
de cada aplicação rodar em processos separados, com restrição
de acesso, uma aplicação não pode iniciar diretamente outra.
Para fazer isto, ela manda uma mensagem para o sistema
Android indicando a intenção de iniciar a outra atividade e
este sim pode decidir se atende ou não a essa intenção. Cada
mensagem de intenção passada para o sistema Android é
chamada de “intent” e será tratada em detalhes mais adiante,
neste material, bem como os processos de ativação de
componentes.
Gerenciando aplicativos
É importante entender que os dispositivos móveis
precisam gerenciar cuidadosamente a utilização de seus
recursos, principalmente a memória, pois normalmente, tais
recursos são bem limitados. O sistema operacional gerencia
as aplicações na forma de uma pilha – stack applications ou,
em português, pilha de aplicações. A aplicação que está no
topo da pilha é a que está sendo executada e visualizada. As
outras permanecem com status de "paradas temporariamente"
(pause) ou "paradas definitivamente" (stop) e não podem
ser visualizadas até que voltem a estar no primeiro lugar, no
topo da pilha. O aplicativo com status pause ou stop pode, a

qualquer momento, ser descartado (encerrado) pelo sistema
operacional para liberar mais memória, em casos em que a
utilização desse recurso atinja um limite crítico.
Cada aplicativo tem seu ciclo de vida bem definido e
pode ter vários estados (status) desde o início de sua execução
até ser descartado pelo usuário ou pelo próprio sistema
operacional. O tópico a seguir apresenta como funciona o
ciclo de vida de uma aplicação.
Ciclo de vida do aplicativo Android
Para os dispositivos móveis que utilizam a plataforma
Android, o ciclo de vida dos aplicativos deve seguir as seguintes
etapas:
Quando o usuário clica sobre o ícone da aplicação, ela
é criada e passa a utilizar recursos do sistema operacional do
dispositivo. O termo “criar” (create), neste contexto, não tem
o sentido de “implementar” ou “desenvolver”, mas sim de
“instanciar”, isto é, ser executado e passar a ocupar um espaço
de memória e utilizar recursos do sistema.
Quando um aplicativo é executado, ele chama o
método onCreate, que é obrigatório e é executado
uma única vez durante o ciclo de vida da aplicação.
Esse método define o que deve ser feito, qual
a interface utilizada e quais os componentes dessa
interface.
Para entrar em operação e poder ser utilizado, o
aplicativo, depois de criado, precisa ser iniciado. Quando isto
acontece, o método onStart é chamado. Ele não é obrigatório,
mas pode-se utilizá-lo para capturar o evento de inicialização da
aplicação.
O aplicativo deve, então, ser colocado no topo da pilha
de aplicativos, para poder ser visualizado e controlado pelo
usuário. Esse evento pode ser capturado pelo método onResume.
Caso outro aplicativo seja iniciado, o aplicativo anterior
é parado temporariamente (paused) e vai para o segundo lugar
da pilha de aplicativos. Este evento é capturado pelo método

onPause, que pode ser implementado para salvar o estado
(atributos) do aplicativo, antes que ele passe para a situação de
parado temporariamente. Esse é um método muito útil, pois,
caso a aplicação volte ao topo da pilha, é necessário saber
qual era a sua situação e quais eram seus dados antes de ser
temporariamente parado.
Para voltar a utilizar o aplicativo que está parado
temporariamente, este deve voltar ao topo da pilha.
Mas isso só acontece se o outro aplicativo que tomou
seu lugar no topo da pilha for descartado ou parado
temporariamente. Quando isso acontece, o método
onResume entra em ação novamente.
O aplicativo que está parado temporariamente (paused)
pode ser parado definitivamente (stop). O método que captura
este evento é o onStop.
o Uma vez parado, o usuário só conseguirá utilizar novamente o
aplicativo se reiniciá-lo. Se isso acontecer, o método onRestart
será chamado, capturando assim o evento e passando o controle
para o método onStart.
O aplicativo pode, depois de parado, ser retirado da
pilha, isto é, ser descartado. Quando isso acontece, o método
onDestroy é chamado e o ciclo de vida da aplicação termina.
Para ter acesso a esse aplicativo depois dele ter sido
retirado da pilha, o usuário deve recriá-lo, fazendo
com que outro ciclo de vida tenha início.
O diagrama de transição de estado, abaixo, representa este ciclo:
Figura 1
– Ciclo de
Vida dos
Aplicativos
Android
Fonte:
Autor
Para o entendimento da figura acima, segue a legenda:

1. método onCreate – chamado quando o usuário clica sobre o
ícone da aplicação;
2. método onStart – chamado quando a aplicação se torna
visível para o usuário;
3. método onResume – chamado quando a aplicação está no
topo da pilha;
4. método onPause – chamado quando a aplicação sai do topo
da pilha e fica parada temporariamente, por causa da execução
de outra aplicação;
5. método onResume – chamado quando a aplicação que foi
parada temporariamente volta a ser requisitada;
6. método onStop – chamado quando a aplicação está sendo
encerrada;
7. método onRestart – chamado quando a aplicação precisa ser
iniciada outra vez;
8. método onDestroy – chamado para encerrar a execução da
aplicação;
9. método onDestroy – neste caso, a aplicação está sendo
encerrada não pelo usuário, mas sim pelo SO para liberar
memória;
10. aplicação descartada.
Todos esses métodos listados acima fazem parte da
classe activity, que é utilizada pelo sistema operacional Android
para ajudar a gerenciar esse ciclo de vida dos aplicativos. O
tópico a seguir apresenta mais detalhes sobre esta classe.
A Classe Activity
A classe activity define as atividades do projeto. É a
classe mãe ou a superclasse que define as características e os
comportamentos básicos para qualquer atividade criada para
o projeto. Cada atividade é responsável por fornecer uma tela
onde o usuário pode interagir para realizar alguma ação, como
digitar um número de telefone, tirar uma foto, ler um e-mail,
incluir, alterar ou excluir os dados de um contato. A interface
criada na atividade pode preencher a tela inteira do dispositivo,
o que normalmente acontece, ou pode flutuar sobre outras telas.

Com base no exposto nos itens anteriores, sobre os
métodos do ciclo de vida de um app Android, a Classe Activity
pode ser representada, segundo o padrão UML, da seguinte
maneira:
Figura 2 – Representação gráfica da Classe Activity
Fonte: Autor
Naturalmente, como não se tratou dos atributos, a lista
de atributos da classe Activity ainda é desconhecida, por isso
foi colocada como sendo “...”. Da mesma forma, pode ser que
a classe activity tenha mais métodos que os mencionados; por
isso, após o método onDestroy, também foi colocado “...”.
EXEMPLO
Abra o Android Studio e crie um novo projeto, clicando
no item “Start a new Android Studio Project”, destacado em
vermelho na figura abaixo:
Figura 3 – Criando um novo projeto
Android
Fonte: app Android (2018)

Defina o nome da aplicação como App1_U3, a dizer
que esta é nossa primeira aplicação criada na Unidade 3 desta
disciplina, conforme mostrado na figura abaixo:
Figura 4 – Definindo o
nome da aplicação

Deixe os demais campos como estão e clique em
"Next". A tela a seguir deve ser apresentada:
Figura 5 –
Definindo o
dispositivo Android
para o projeto
Fonte: app Android

(2018)
Marque a opção "Phone and Tablet" e selecione a
"API15", como mostrado na figura acima e clique em "Next".
IMPORTANTE
Caso você não se recorde o motivo pelo qual está a fazer estas
seleções, reveja o material da Unidade 1 desta disciplina.
A tela a seguir deve aparecer:
Figura 6 – Adicionando a
Activity para o projeto
Selecione a "Empty Actvity" e clique em "Next". A

tela a seguir deve ser apresentada;
Figura 7 Configurando a Activity

Deixe os nomes como estão e clique em "Finish". O
projeto será carregado.
O Código da classe Activity do projeto deve ser como
Figura 8
– Classe
Activity do
projeto
Fonte: app
Android
(2018)
Com os conhecimentos que você adquiriu na Unidade

2 sobre linguagem Java, você pode entender o código acima,
senão vejamos:
A linha 1 define o pacote onde se encontra a classe
Activity que estamos a visualizar;
A linha 6 declara a classe MainActivity (Atividade
principal) que irá gerenciar a tela principal do nosso aplicativo,
pois, conforme vimos anteriormente, neste material, cada tela
é gerenciada por uma classe Activity.
Importante também verificar que a classe MainActivity
herda (extends) características e comportamentos da classe
AppCompatActivity.
Na linha 8 existe uma expressão a informar que o
método abaixo é uma sobrescrita. Usa-se @Override toda
vez que você substituir um método. Seu uso, conforme Singh
(2017), fornece dois benefício: (1) Para ter certeza que você
realmente está a substituir o método que deseja, pois, caso você
cometa um erro comum ao digitar incorretamente um nome
de método ou não corresponder corretamente aos parâmetros,
você será avisado de que o método não substitui como você
pensa. (2) Torna o seu código mais fácil de entender, porque
é mais óbvio quando os métodos são sobrescritos.
A linha 9 mostra o método onCreate sendo declarado.
Este é o método que copia o método da classe mãe
AppCompatActivity.
Na linha 10 ocorre a chamada ao método onCreate da
classe mãe;
Na linha 11 é definido o layout para a activity que está
a ser criada.
Verificando o conteúdo da classe MainActivity, descrita
acima, pode-se perceber que apenas o método onCreate está sendo
utilizado, pois ele é o único obrigatório. Como vimos acima,
existem outros seis métodos que completam o ciclo de vida de uma
aplicação, que podem ser utilizados para permitir ao programador
maior controle sobre a aplicação que está desenvolvendo.
Se você executar a aplicação, o resultado deve ser o

Figura 9 – AVD da execução do projeto

Exemplo a seguir apresenta o código que deve ser
implementado no seu projeto (na classe MainActivity) para
dar uma noção do funcionamento da atividade quando a
mesma possui todos os métodos para o controle do ciclo de
vida da aplicação.
EXEMPLO
Implemente o seguinte código na sua classe
MainActivity:
Figura 10 – Exemplo dos
métodos de gerenciamento
de aplicações de app
Android

O código acima não tem função prática alguma,

a não ser permitir que você entenda o funcionamento do
gerenciamento do ciclo de vida de aplicativos Android. Salve
e execute a aplicação. Para verificar o resultado, abra a janela
chamada "Run", como mostrado na figura abaixo e verifique
os itens destacados em vermelho.
Figura 11 – Resultado da
execução do código do
exemplo.

O AVD deve estar como mostra a figura abaixo:
Figura 12 – AVD do exemplo

Para verificar o resultado da execução dos métodos,
clique em um dos botões destacados em vermelho (na figura
acima).
IMPORTANTE
Compare o resultado apresentado na janela “Run” com o diagrama

de transição de estado (figura 1).
Navegabilidade
Introdução
Aplicativos mais complexos normalmente possuem
mais de uma tela ou precisam chamar outros aplicativos para
executarem uma função especializada. Este tópico mostra
como criar novas telas (activity) para um mesmo aplicativo,
como navegar entre elas e também como permitir que a tela
de um aplicativo (activity) chame outro aplicativo (activity).
Os métodos utilizados para iniciar uma nova (tela)
activity são os seguintes: startActivity e startActivityForResult.
Lembre-se de que cada tela de um aplicativo é uma classe
Activity e que a linguagem Java diferencia letras maiúsculas
de letras minúsculas. Dessa forma, o método “startActivity”
não pode ser escrito como: “startactivity”.
A decisão da utilização de um desses dois métodos
deve recair sobre a seguinte questão: a tela (activity1) que
está chamando a outra (activity2) precisa de algum retorno
ou vínculo para poder continuar suas atividades, depois que
a tela chamada (activity2) for fechada? Em caso de resposta
positiva, deve-se utilizar o método startActivityForResult.
Mas se esse não for o caso e a tela (Activity1) que está
chamando a outra (activity2) não precisar de nenhum vínculo
ou retorno, deve-se utilizar o método startActivity. As figuras
abaixo representam graficamente esses dois casos:
Uso do método startActivity

Figura 13 – A
Activity1 não
precisa de retorno da
Activity2, depois que
a última for fechada
e o foco retornar para
a primeira.
Fonte: app Android

(2018)
Uso do método startActivityForResult:

Figura 14 – A Activity1
precisa de retorno da
Activity2, depois que a última
for fechada e o foco retornar
para a primeira.
Para entender melhor algumas características

necessárias para a correta navegabilidade entre telas de um
aplicativo Android, verifique o exemplo a seguir:
EXEMPLO
Crie um novo projeto Android, chamado App2_U3 nos
mesmos moldes que o App1_U3. Para fazer isso você pode
fechar o projeto App1_U3, que está aberto ou, selecionar a
opção do menu File->New -> New Project..., como mostra a
figura abaixo:
Figura 15 – Criando o
projeto App2_U3
Note que este novo projeto, a exemplo do anterior,

possui apenas uma activity (tela), chamada de MainActivity
ou tela principal. Crie mais duas telas (Empty Activity)
dentro do novo projeto (pacote App2_U3) com as seguintes
características:
Primeira tela: Nome da Atividade: Tela2;
Segunda Tela:Nome da Atividade: Tela3.
Para fazer isso, clique com o botão direito do mouse
sobre a app e selecione new->Activity->Empty Activity,
conforme mostra a figura abaixo:
Figura 16 – Inserindo nova activity no projeto
O seu projeto deve ficar como mostra a figura abaixo:

Figura 17 – Projeto com três activity ou telas

Salve, execute o projeto e verifique se apenas a atividade
principal fica visível e as duas outras atividades (tela2 e tela3)
não estão acessíveis. Para verificar o por que disso acontecer,
precisamos analisar o arquivo AndroidManifest.xml, que
deve estar como o código mostrado a seguir:
Figura 18 – Arquivo AndroidManifest.
xml do projeto App2_U3.

Repare que apenas a atividade principal (MainActivity),
na linha 12, possui o <intent-filter>. Este fragmento de código
tem dois atributos: (1) ação (action), cuja função é definir se a

atividade pode ser uma atividade principal do aplicativo. (2)
categoria (category), que define se o usuário pode iniciar a
atividade diretamente, do menu de aplicativos.
Para ter acesso ao menu de aplicativos basta clicar
sobre a região marcada em vermelho, na figura abaixo,
e arrastar para cima. Os aplicativos implementados até o
momento estão destacados em azul.
Figura 19 – Abrir o menu de
aplicativos
Chamando a segunda Activity

Intenção de chamada
Para chamar a segunda tela (atividade) da aplicação,
é necessário utilizar o objeto Intent. Esse objeto será descrito
em detalhes no próximo módulo, portanto aqui será feita
apenas uma breve introdução de sua sintaxe, para permitir o
correto funcionamento da aplicação em questão.
Para declarar uma chamada à outra atividade do
mesmo aplicativo, usa-se o seguinte fragmento de código:
Intent a = new Intent(this, Tela2.class);

startActivity(a);
Nesse fragmento, pode-se verificar, na primeira linha, a

declaração de um objeto Intent “a”, que define uma intenção de
iniciar uma nova atividade, chamada Tela2.class. e, na segunda
linha, a utilização do comando startActivity indicando como
parâmetro a intenção de chamada. Como foi visto no princípio
deste tópico, o comando startActivity inicia uma atividade e
não espera retorno algum dela.
Evento de chamada
Normalmente, a chamada a outra atividade ocorre
como consequência de um evento realizado pelo usuário, como
clicar em um botão ou qualquer outra interação do usuário com
o layout, definida pelo programador. Desta forma, a simples
implementação do código mostrado no item acima (Intent) não
vai iniciar nenhuma nova atividade, pois não foi definido o
evento que dispara esta ação. Apesar de o assunto layout ser
tratado mais adiante neste material, segue abaixo o fragmento
de código que mostra como inserir um botão e permitir que ele
“escute” e reaja, executando a chamada desejada:
Button b = new Button(this);
b.setText = “ok”;
As duas linhas de código acima declaram um objeto
do tipo Button (botão) e definem “ok” como sendo o texto
que deve aparecer no botão. Porém, a aplicação precisa
saber que este botão deve ser “ouvido” quando for clicado,
para executar alguma nova tarefa. Desta forma, insere-se a
seguinte linha de código ao fragmento acima:
b.setOnClickListener(this);
Com essa linha adicionada ao código, quando o botão
for clicado, o método onClick será chamado e dentro dele pode-
se declarar a intenção (Intent) de chamar a nova tela. Toda
vez que se permite que um botão reaja a um clique, deve-se
implementar o método onClick para definir o que ele deve fazer
quando for clicado. Desta forma, dentro da própria atividade,
deve-se criar um método onClick, da seguinte forma:
public void onClick(View v) {

Intent i = new Intent(this, Tela2.class);
startActivity(i);
}
Modificando o código do exemplo anterior (App2_U3)
para incluir um botão na atividade principal (MainActivity) que
chame a atividade 2 (tela2), conforme explicado acima. O botão
deve ter como rótulo o texto: “Clique Aqui”. Neste exemplo
modificaremos também o código da segunda atividade (Tela2)
para que apresente a seguinte mensagem na caixa de texto: “Esta
é a segunda tela da aplicação”. O código completo da atividade
da Tela Principal do aplicativo deve ficar da seguinte maneira:
Figura 20 -Código para o exemplo acima

Veja que foi necessário inserir várias linhas e modificar
algumas outras. Não se preocupe em entender tudo isso agora.
Este exemplo foi apenas para você entender as bases da
funcionalidade de apps Android. Perceba também que na linha
21, da figura acima, o método startActivity é utilizado para
chamar a atividade 2 (tela2) da aplicação. Ela foi utilizada por
que a tela principal não precisa, neste caso, de retorno.
Se você salvar e executar, o AVD deve ser parecer com o
Figura 21 – Resultado do
exemplo acima
Note que, ao abrir, a tela principal mostra o botão que

preenche todo o espaço definido no layout. Clicando sobre
o botão, a segunda tela é apresentada (toda em branco).
Conforme já estudamos, logo que a segunda tela é aberta,
primeira tela é parada temporariamente (pause) e fica em
segundo plano. Neste momento, ambas as telas ocupam
espaço na memória e recursos do dispositivo. Pressionando a
tecla voltar, destacada com um quadrado vermelho, na figura
acima, e a segunda tela é parada temporariamente (pause),
parada definitivamente (stop) e, por fim, destruída (destroy),
e a primeira tela volta para o primeiro plano (resume).
Neste momento, apenas a tela principal ocupa espaço
na memória e nos recursos do dispositivo. Pressionando mais
uma vez a mesma tecla "Voltar", a primeira tela é parada
temporariamente (pause), parada definitivamente (stop) e, por
fim, destruída (destroy), liberando toda a memória utilizada
para a aplicação.
Você pode estar a pensar: “Um botão que ocupa todo
o espaço da tela não adianta muita coisa. Seria interessante
colocar mais componentes numa mesma tela!”
Perfeito! Você tem toda a razão! Logo aprenderemos
como fazer isso! Um passo de cada vez! No próximo tópico
veremos como fazer uma tela "conversar" com a outra por
meio de parâmetros e logo em breve, veremos como manipular
layouts. Sigamos em frente!
Passagem de parâmetros entre telas

A passagem de parâmetros estudada neste tópico
não cria vínculo entre as telas. O foco é passar um ou mais
parâmetros para a próxima tela e não o retorno de parâmetros,
por isso o método utilizado ainda será o startActivity, não o
startActivityForResult.
Para passar parâmetros entre telas, é necessário
utilizar o objeto Bundle (android.os.Bundle). A palavra
bundle pode ser traduzida como “pacote” ou “embrulho”, e
essa é exatamente a sua função, isto é, servir um embrulho
ou pacote que contém os dados que precisam ser passados
de uma atividade para outra. Para definir um objeto do tipo
Bundle, utiliza-se a seguinte sintaxe:
Bundle <nome do pacote> = new Bundle;

Um exemplo seria:
Bundle pacote_de_dados = new Bundle;
Porém, é necessário definir o conteúdo desse "pacote
de dados" e, para tanto, precisa-se utilizar o comando
putString, da seguinte forma:
pacote_de_dados.putString(“msg”, “Olá”);
Na linha de código anterior, um dado do tipo string
chamado “msg” e de conteúdo “Olá” está sendo adicionado
ao "pacote de dados". Podem ser adicionados vários dados
a um mesmo "pacote de dados". Porém, uma vez que o
seu conteúdo esteja definido, é necessário incorporá-lo em
uma intenção de chamada, pois ele de nada vale se não for
passado adiante. Dessa forma, utiliza-se o método putExtras
para incorporar o "pacote de dados" a uma Intent, da seguinte
forma:
i.putExtras(pacote_de_dados); startActivity(i);
O código completo fica assim:
…
{
//declara a intenção “i” para chamar outra tela (activity)
Intent i = new Intent(this, tela2.class);
//declara um pacote de dados que deve ser enviado para a
tela a ser chamada
Bundle pacote_de_dados = new Bundle();
//determina que o conteúdo do pacote de dados é um dados
chamado “msg” //cujo conteúdo é “Olá”.
//insere o pacote de dados na intenção de chamada “i”
i.putExtras(pacote_de_dados);
//chama a nova atividade, definida pela intenção “i”.
startActivity(i);
}
Muito legal, não é? Agora você já sabe como passar
parâmetros para uma nova tela. Mas isso é só o começo!
Acompanhe o exemplo abaixo para esclarecer melhor como
funciona todo o processo.
EXEMPLO
Crie um novo projeto de app, chamado App3_U3. A
Activity principal deve ser do tipo "Empty Activity", com o
nome de Principal. Depois de aberto, o código da tela principal
(classe Principal.java) do seu projeto deve se parecer com o
Figura 22 – App3_U3 – Código da
classe Principal.java

A primeira coisa a fazer é alterar o código acima para que o
mesmo fique idêntico ao apresentado na figura 20. Pode-se
destacar que, na figura 22, foram destacados em vermelho os
"imports" de bibliotecas e o método onCreate, para que você

perceba claramente as alterações necessárias. A figura abaixo
mostra o código da figura 22 com as alterações necessárias
para ficar igual ao código da figura 20. Atenção para as
modificações destacadas em vermelho.
Figura 23 - App3_U3 – Código da classe Principal.java

Muito bem. O próximo passo é inserir as modificações referentes
à passagem de parâmetros entre telas. O nosso código fica assim:
Figura 24 - App3_U3
– Código da classe
Principal.java
Fonte: app Android

(2018)
Em vermelho estão destacadas as linhas que foram

alteradas ou incluídas.
Explicando o código: Ao ser iniciado, o aplicativo
deve executar a função onCreate, na linha 14, como já foi
explicado no ciclo de vida das Apps Android. Dentro deste
método onCreate um botão "b" é criado e para ele é definido
o texto “Clique Aqui” (linha 15). Na linha 16 é definido que
este botão deve "escutar" uma ação de click, isto é, a partir
da execução desta linha de código, o botão "b" deve reagir, a
chamar o método onClick, quando for clicado.
Em sendo chamado, o método onclick executa as
seguintes atividades: (repetimos o código para que você
perceba e visualize todas as etapas)
//declara a intenção “i” para chamar outra tela (activity)
Intent i = new Intent(this, tela2.class);
//declara um pacote de dados que deve ser enviado para a
tela a ser chamada
Bundle pacote_de_dados = new Bundle();
//determina que o conteúdo do pacote de dados é um dado
chamado “msg”,
cujo conteúdo é “Olá”.
//insere o pacote de dados na intenção de chamada “i”
i.putExtras(pacote_de_dados);
//chama a nova atividade, definida pela intenção “i”.
startActivity(i);
Você deve ter percebido que, depois de toda esta
explicação, ainda não existe a tela2, necessária para o correto
funcionamento do código acima.
Então, não seja por isso! Vamos inserir uma nova tela
(activity) chamada de tela 2. Ela deve ter o seguinte código:
Figura 25 - App3_U3 – Código da classe Tela2.java

Explicando o Código da figura 25: Ao ser criada, a tela2 deve
executar o código que está definido dentro do método onCreate,
como você já sabe. Na linha 13 deste código é definido uma caixa
de texto (TextView), de nome txt. Na linha 14 é definida uma
variável, de nome "msg_recebida" e à ela é atribuído o conteúdo
vazio. Na linha 15 é definido um objeto Intent que, neste caso, serve
para capturar a intenção de chamada realizada pela tela principal.
Na linha 16 faz-se a verificação se a intenção de chamada capturada
não está vazia (nula). Caso não seja nula, é executada a linha 18,
que captura um suposto pacote, enviado pela tela principal, nesta
intenção de chamada. Perceba que o pacote pode estar vazio, isto
é, a intenção de chamada pode existir, mas não necessita de possuir
parâmetros. Esta verificação é feita na linha 19 e, caso exista algum
pacote de dados embutido nesta intenção de chamada, o mesmo é
capturado na linha 21. Por fim, a linha 24 define o conteúdo para
a caixa de texto “txt” definida no início do código e, na linha 25, o
layout, composto por esta caixa de texto, é apresentado na tela do
dispositivo. Salve e execute o código. O resultado é apresentado na
figura abaixo:
Figura 26 – Resultado do exemplo

– Passagem de parâmetros entre
telas
Fonte: app Android
Que tal? Espero que esteja a perceber como tudo

(conceitos e códigos) estudados nas unidades 1 e 2 desta
disciplina estão a ser aplicados nesta unidade.
Vamos em frente!
Inserindo componentes na tela

O Android Studio permite trabalhar com uma grande
variedade de componentes. Neste material apresentaremos os
mais comuns.
Conforme visto anteriormente, a estrutura dos projetos
Android separa o layout (interface com o usuário) do código
responsável pela ação, reação e regras de negócio tratadas
pela tela, sendo o primeiro definido em um arquivo xml e o
último em uma classe Activity (em linguagem Java).
Para melhor entendimento deste módulo, vamos criar
um novo projeto no Android Studio. Isso você já sabe fazer,
mas, para sedimentar o conhecimento, vamos apresentar todos
os passos em detalhes, como mostrado a seguir:
1 - Abra Android Studio e crie uma nova Aplicação Android;
2 - Defina o nome da App como “App4_U3”;
3 - Selecione o dispositivo Phone and Tablet e a API15:
Android 4.0.3 IceCreamSandwich;
4 - Escolha uma “Empty Activity”, exatamente como foi feito
nos exemplos anteriores e dê o nome de Principal.
5 - Depois do projeto estar carregado, clique em executar
(Run), selecione o AVD para exibir a app e o resultado deve

ser como mostrado na figura abaixo:
Figura 27 – AVD do exemplo.
Até aqui, imagino que você já saiba fazer. Vamos,

então, aprofundar nosso conhecimento.
Entendendo o Editor de Layout

Neste ponto é necessário explicar como funciona o
editor de layout disponibilizado pelo Android Studio, bem
como verificar como cada alteração de layout numa Activity
(tela da app) impacta no código xml correspondente. Sendo
assim, selecione o arquivo xml referente ao layout da nossa
aplicação, clicando em app -> res -> layout, e selecionando
o arquivo activity_principal.xml, como mostrado na figura
abaixo:
Figura 28 – Selecionando o arquivo xml de layout da tela

do dispositivo.

Ao selecionar o arquivo de layout, conforme mostrado

na figura acima, o Android Studio apresenta o Editor de Layout.
Este editor permite que você crie o layout desejado cada uma
das telas de sua aplicação, clicando e arrastando elementos para
um "preview" de tela do AVD escolhido. O Editor de Layout
deve do nosso app é mostrado na figura abaixo.
Figura 29 – Editor de
Layout do app
Fonte: app Android

(2018)
Na parte superior, da figura acima, está destacado em
vermelho o AVD, a API e o tema que estaremos a utilizar
neste projeto. É bem possível que o tema do seu projeto ainda
não esteja definido como na figura 29, por isso, clique sobre
o tema e selecione para ficar igual ao apresentado na referida
figura, pois assim, os resultados apresentados neste material
serão os mesmos que você obterá no seu computador.
Ao clicar no tema, uma tela de seleção será apresentada
e, então, selecione o tema "Light", como mostrado na figura
abaixo.
Figura 30 – Seleção de tema para
a app

No canto inferior esquerdo da figura 29, há duas abas

em destaque. A primeira (Design), que está a ser exibida na
referida figura, mostra o editor de layout, enquanto a segunda
(Text), mostra o arquivo xml correspondente ao layout. Ao
clicar na aba "Text", você terá uma visão do arquivo xml,
conforme mostrado na figura abaixo.
Figura 31 – Arquivo xml correspondente ao layout da tela do app
Como foi comentado anteriormente neste material,

cada tela (activity) possui um arquivo xml de layout. Note que
o elemento "TextView", que visualizamos na figura 29, com
o conteúdo "Hello World", aparece no arquivo xml (da linha
9 até a linha 16) e que o conteúdo do mesmo está definido na
linha 12. Experimente trocar o conteúdo deste elemento para
"Tela Principal", da seguinte maneira:
Android:text = “Tela Principal”
Depois de alterado, clique na aba Design e veja o que
acontece. O resultado deve ser como mostrado na figura abaixo:
Figura 32 – Apresentação do
layout do app

Perceba também que o conteúdo do atributo "text",
destacado em vermelho, do lado direito da figura acima também
foi alterado. Agora faça outro teste: Altere o conteúdo da caixa
de texto (destacada em vermelho) para "Tela Principal da App" e

pressione a tecla ENTER. Este ato terá duas consequências: (1)
o conteúdo do elemento "TextView", destacado em vermelho,
no lado esquerdo da figura 32, que está posicionado no meio
da tela do AVD será alterado e, clicando na aba "Text" você
perceberá que o arquivo xml também foi alterado na linha 12,
conforme mostrado na figura abaixo:
Figura
33 –
Elemento
TextView
Fonte: app
Android
(2018)
A conclusão é óbvia, mas precisa ser destacada aqui: Qualquer

alteração no arquivo xml causa alterações no layout do app ou em
algum atributo de um dos componentes da tela do app. E qualquer
alteração no layout do app ou em qualquer atributo dos elementos
que compõem a tela do app causa alterações no arquivo xml.
Você deve ter percebido que o Editor de Layout do Android
Studio pode fazer muito mais do que apresentamos até agora. Não se
preocupe. Vamos passo a passo, aprofundando-nos no decorrer desta
Unidade e da próxima.
Uma vez que você já percebeu um pouco do Editor de Layout
e sua relação com o arquivo xml, vamos em frente para entender
como inserir componentes na tela do app.
Primeiro, precisamos mudar o layout da tela. Se olharmos com
atenção na figura 31 – linha 2 – perceberemos que o layout definido
até o momento para o nosso app é o ConstraintLayout.
Vamos mudar esta especificação para um tipo de layout mais
simples e de mais fácil entendimento neste momento: LinearLayout.
Para isso, clique na aba "Design" e verifique a janela chamada
"Componente Tree" ou, em português: Árvore de Componentes". Ela
deve mostrar todos os componentes ou elementos que estão presentes
na tela da sua app até o momento e deve estar como mostrado na
figura abaixo.
Figura 34 – Árvore de componentes do app
Clique com o botão direito do mouse sobre o referido

layout e selecione o item "Convert View..." e uma tela com
os layouts disponíveis será apresentada. Nesta nova tela,
selecione o "LinearLayout" e clique no botão "Apply", como
mostrado na figura a seguir:
Figura 35 – Alterando o
Layout da tela da app
A janela que apresenta a "Árvore de Componentes"

deve ser alterada para informar que o layout para a app
passou a ser definido como LinearLayout (horizontal). Porém,
queremos que a orientação dos componentes seja vertical, por
isso, clique uma vez, com o botão esquerdo do mouse sobre o
referido layout e altere o atributo orientação, como destacado
em vermelho na figura abaixo:
Figura 36 – Alterando a
orientação do layout para
“vertical”
Fonte: app Android

(2018)
Se você clicar na aba "Text", verá seguinte código xml:

Figura 37 – Arquivo xml
da tela da app depois de
ter o layout definido para
LinearLayout

IMPORTANTE
Os tipos de layout e suas características serão vistos mais adiante neste

material, então, por agora, estamos apenas a introduzir o assunto.
Perceba a diferença deste arquivo (figura 37) para o

arquivo xml da figura 31.
Agora que o layout da tela está devidamente configurado,
precisamos aprender a inserir componentes na nossa app.
TextView
O componente TextView é um rótulo ou uma etiqueta
(label) onde podemos escrever um texto que pode ser lido, mas
não pode ser alterado pelo usuário do app.
Neste subtópico iremos, primeiramente, deletar o
componente Textview que já existe (apenas para praticar) e
adicionar um novo.
Para deletar o componente TextView (ou qualquer outro
que você deseje): (1) clique na aba “Design” para visualizar
o Editor de Layout do AVD; (2) clique sobre o componente
TextView, cujo texto é “Tela principal da App” e pressione a
tecla “delete” em seu teclado.
Para inserir o novo componente TextView: Selecione,
na janela “Palette” (que fica acima da janela “Component
Tree”) o componente Text -> TextView, conforme destacado
em vermelho na figura abaixo:
Figura 38 – Janela Palette

Clique e arraste o componente para a tela do AVD.

Note que, ao soltar o componente sobre a tela do AVD, ele
se adequa ao tamanho da tela e fica posicionado na parte
superior da mesma, como mostra a figura abaixo:
Figura 39 – TextView
inserido na tela do AVD
Fonte: app Android

(2018)
Repare que, se você clicar sobre o componente TextView
Inserido, aparecerá, do lado direito da tela, destacado com
retângulo vermelho uma janela com as propriedades (atributos)
deste componente.
Podemos identificar claramente que o componente
possui um identificador único, chamado ID, cujo valor é
TextView2. Possui também duas propriedades parecidas,
chamadas de layout_width e layout_height, as quais
definem as propriedades de largura e altura do componente,
respectivamente. Para cada uma destas duas propriedades,
podemos ter 3 valores diferentes, a saber: (1) match_parent:
que define que o objeto deve ter a mesma largura (width) e/ou
altura (height) do componente no qual ele está contido. Para este
caso em específico, sabemos que o componente TextView está
contido no componente LinearLayout. Podemos provar isso
ao analisar a janela "Component Tree" que destaca claramente
esta característica. (2) outro valor possível é wrap_content. Se
este valor for escolhido para esta propriedade, a largura (width)
e/ou altura (height) do componente TextView será ajustado ao
tamanho do texto que ele possui. Importante destacar que se
o componente não tiver valor para a propriedade texto, isto
é, se a propriedade "text" estiver vazia, o componente ficará
invisível. (3) podemos clicar nos três pontos “...” que estão à
direita da ca caixa de combinação e selecionar um dos itens
apresentados numa tela especial.
Logo depois destas propriedades, existe uma propriedade
chamada "text" que define o texto que o componente TextView

irá apresentar na tela do AVD. Defina para esta propriedade
o seguinte valor: “Bem vindo ao meu app. Digite seu nome e
clique em OK para entrar.” e pressione ENTER.
O texto que você acabou de digitar aparecerá em uma
única linha no AVD, mas você pode clicar sobre o componente
e alterar a largura ou altura do mesmo, para ficar parecido com
a figura abaixo:
Figura 40 – Componente
TextView no Editor de
Layout

Salve e execute o aplicativo. O resultado deve ser
como mostrado na figura abaixo:
Figura 41 – Componente TextView
com o aplicativo em execução

Note que você pode alterar outras propriedades do
componente TextView, tais como tipo, cor e tamanho da
fonte, entre outras, como mostra a figura abaixo:
Figura 42 – Propriedades do componente TextView

Muito bem. A frase que aparece no componente

TextView nos dá uma deixa para aprendermos inserir dois
novos componentes: o Plain Text e o Button. Então vamos lá!
Pain Text
O Plain Text é uma caixa de texto que permita ao
usuário digitar algo. Ele tem os mesmos atributos que o
componente TextView e mais um, chamado de Input Type,
que define o tipo de dado que este componente vai receber.
Podemos definir o conteúdo da propriedade "text" como
vazio, afinal, o usuário vai digitar o seu nome ali.
Para incluir este componente, siga o mesmo método
que usou para inserir o componente TextView. Salve e execute
o app. A tela do AVD deve ficar assim:
Figura 43 – AVD com TextView e Plain Text
Note que: (1) o atributo android:text (no arquivo xml

correspondente) foi definido como “” (vazio). Isso faz sentido,
pois o objetivo desse componente é receber um texto e não o
apresentar. Mas você pode alterar esta propriedade para dar
uma dica ao usuário, caso você queira. (2) Este componente,
chamado android:inputtype, responsável por definir o tipo
de dado que o componente irá receber. Pode conter valores
como text, date, time, datetime, numberDecimal, number e
textPassword, entre outros. (3) Você também pode alterar
outras propriedades, conforme mostrado na figura abaixo:
Figura 44 – Propriedades do componente PlainText
Button
Agora precisamos inserir um botão com o texto “OK”.
Para isso, selecione o item Button -> Button, na janela Palette,
como mostrado na figura abaixo.
Figura 45 – Inserindo um Botão

Insira o botão na tela, altere seu tamanho e troque o
valor de sua propriedade "text" de "Button" para "OK".
Ao salvar e executar, o app deve ficar mais ou menos
assim:
Figura 46 – AVD com TextView, Plain Text e
Button

Antes de passarmos para o próximo componente,

clique na aba "Text" e verifique o arquivo xml correspondente
a esta activity que acabamos de fazer. Ela deve estar parecida
com a figura abaixo:
Figura 47 –
Arquivo xml
correspondente
ao AVD da figura
44
Fonte: app
Android (2018)
Repare como cada componente está descrito no código

xml: o layout e cada um dos componentes.
Radio button
Existem muitas opções de componentes, como você
pode reparar na janela Palette, apresentada na figura abaixo:
Figura 48 – Janela Palette

Mas, antes de inserir mais componentes, como o
Radio Button, vamos criar outra Activity (tela) para a nossa
app. Esta Activity deve ser chamada de "Tela2" e deve ser

uma Empty Activity. Depois de criada a nova Activity, não
esqueça de mudar o layout para LinearLayout (vertical),
assim como fizemos com a Activity Principal.
Isto posto e realizado, podemos inserir o radio button.
Para tanto, selecione o item Buttons e perceba que existem dois
componentes que inicial com o nome Radio: RadioGroup e
RadioButton. Primeiro selecione o RadioGroup e arraste para
a tela do AVD. Depois selecione 3 componentes RadioButton
e arraste para o interior do RadioGroup que você acabou
de inserir. Seu projeto deve ficar como mostrado na figura
abaixo:
Figura 49 – Inserindo
Radio Buttons na Activity

Para melhorar o layout desta activity, selecione o
componente RadioGroup, defina ambos os valores das
propriedades layout_width e layout_height para para "wrap_
content". Sua tela deve ficar assim:
Figura 50 – Melhorando o layout da figura 46

Repare que todos os componentes RadioButtons tem o
mesmo valor para a propriedade "text". Clique no primeiro e
defina esta propriedade para “Aluno”, defina para o segundo

o valor “Professor” e para o terceiro o valor “Outro”. Sua tela
deve ficar assim:
Figura 51 – Projetando a Activity 2 da app.

Vamos inserir agora um TextView com o seguinte
texto: “Qual é sua posição nesta instituição?” Podemos
imaginar que este app seja direcionado para uma determinada
instituição de ensino.
Clique e arraste o componente TextView de maneira que ele
fique acima do RadioGroup. A tela deve ficar assim:

Não esqueça que você pode alterar outras propriedades,
tais como espaçamento, cor, tipo e tamanho de fonte, entre
outras, em todos os componentes.
Check box e Combo box
Para inserir estes componentes, use os mesmos
recursos aprendidos até o momento. Sua tela deve ficar como
mostrado na figura abaixo

Bom, você já deve ter percebido a quantidade de

componentes que pode utilizar para montar uma app. Então,
use sua imaginação, monte um aplicativo ao seu estilo!
Alterando as propriedades de cada componente você
pode criar um app mais amigável e legível. Use sua imaginação!
Figura 54 – Alterando propriedades de cada elemento da
tela.
No caso do elemento ComboBox, ele está definido

como Container ->"Spinner" na janela Palette, como mostrado
na figura abaixo:
Figura 55 – Componente ComboBox
Outro aspecto importante: Para definir seu conteúdo é

necessário criar um Array de opções no arquivo strings.xml,
dentro da pasta values. Sua localização é mostrada na figura a
seguir:
Figura 56 – Localização do arquivo string.xml

Neste caso, precisamos inserir um array com os
valores “masculino” e “feminino” dentro deste arquivo. Para
tanto clique sobre este arquivo digite o seguinte código:
Figura 57 – Arquivo string.xml

Note que o que você precisa digitar este destacado em
vermelho. O que está em azul é outro exemplo para você perceber
como o processo segue o mesmo padrão. Uma vez que você
tenha digitado o código do arquivo xml, conforme apresentado
na figura acima, volte para o Editor de Layout da tela 2 e clique
no componente combobox (spinner) e verifique suas propriedades
Uma delas será a "entries". Clique no botão ao lado desta
propriedade, e você verá mais ou menos como mostra a figura
abaixo:
Figura 58
– Criando
valores para o
componente
ComboBox
Fonte: app
Android (2018)
Em destaque vermelho, na figura acima, podemos verificar

que ao clicar no link da propriedade "entries", a tela "Resources" é
apresentada. Do lado esquerdo, selecione a opção "Array",
destacado em azul e você terá acesso a todos os arrays definidos no
arquivo string.xml, dentre os quais aparece o array que trata sobre
o "estado civil" e outro que trata sobre "sexo". Clique duas vezes
sobre o array que fornece as opções de "sexo" e a tela será fechada.
Finalmente, para testar se tudo está a funcionar, salve o seu projeto
e execute-o. Note que apenas a primeira tela (Principal) aparece e,
aparentemente não temos como acessar a tela 2 para verificar os
demais componentes. Existem duas soluções possíveis: (1) você
fazer o mesmo processo que fizemos no módulo 2 desta unidade ou
você pode fazer a seguinte alteração:
a. Abra o arquivo AndroidManifest.xml. Ele deve se parecer como
o mostrado abaixo:
Figura 59 – Arquivo AndroidManifest.xml

Note que, destacado em vermelho estão os comandos
que permitem ao AndroidStudio saber qual das telas deve ser a
primeira a ser aberta quando o aplicativo for executado.
b. Faça uma alteração neste código para que o <intent-filter>,
que estudamos na primeira Unidade desta disciplina, passe da
tela Principal para a tela2, da seguinte maneira:
Figura 60 – Alterando a tela inicial do aplicativo
Salve o arquivo e execute a aplicação. Você verá que a

tela2 será apresentada e deve se parecer com a figura abaixo:
Figura 61 – Tela 2 da aplicação

Bem, decerto que já vimos muita coisa. Não esqueça de testar,
criar, inventar, modificar as propriedades e verificar seus efeitos.
Na próxima unidade veremos como tratar os eventos gerados
por cada um dos componentes vistos nesta unidade. Não se esqueça
de se aprofundar nos conhecimentos, acessando as referências
apresentadas. Abraço e até a próxima Unidade desta disciplina.
UNIDADE
04
DESENVOLVENDO APP PARA ANDROID
INTRODUÇÃO
Seja bem-vindo(a) à Unidade 4 – Desenvolvimento de
App para Android - da disciplina de Introdução ao Coding
(Mobile). O conteúdo desta Unidade está dividido em
quatro módulos. No primeiro módulo vimos como codificar
e tratar eventos acionados pelo usuário e pela máquina em
aplicativos Android, por meio da linguagem Java Mobile. No
segundo Módulo como tratar dados provenientes das mais
diversas atividades em um aplicativo Android. No módulo
três, aprendemos a invocar ações dos recursos residentes no
sistema operacional Android. E, por fim, no último módulo
desta Unidade 4, vamos desenhar projetar e desenhar
telas para aplicativos móveis, aplicando-lhes técnicas de
usabilidade e recursos disponíveis no sistema Android, por
meio da linguagem Java Mobile.
É 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ê!
OBJETIVOS
1 Codificar e tratar eventos acionados pelo usuário e pela

máquina em aplicativos Android, por meio da linguagem
Java Mobile;
2
Obter e tratar dados provenientes das mais diversas
atividades em um aplicativo Android, por meio da
linguagem Java Mobile;
3 Invocar ações dos recursos residentes no sistema

operacional Android;
4
Projetar e desenhar telas para aplicativos móveis,
aplicando-lhes técnicas de usabilidade e recursos
disponíveis no sistema Android, por meio da linguagem
Java Mobile;
Tratamento de Eventos
O termo “evento”, no contexto desta disciplina, pode
ser definido como a ação do usuário sobre algum componente
apresentado na tela, isto é, podemos considerar que a cada
interação do usuário com o aplicativo em geral um evento
que pode ser identificado e tratado.
++ SAIBA MAIS
A maioria dos aplicativos desenvolvidos para dispositivos móveis

necessita da interação do usuário para seu funcionamento correto.
O usuário deve fazer escolhas, clicar em botões, selecionar itens em
uma lista ou marcar a opção desejada.
No último módulo da unidade anterior (Unidade 3)

aprendemos como inserir componentes (tais como TextView,
Spinner, CheckBox, entre outros) na tela (Activity) da
aplicação Android. Agora vamos aprender como tratar os
eventos que o usuário pode realizar com estes componentes.
Para tanto, vamos criar uma aplicação simples. Siga com
atenção os passos descritos abaixo.
Definindo o Protótipo da Aplicação

Todo projeto precisa de um protótipo, no qual podemos
entender o funcionamento do app e quais componentes são
necessários para que ele seja executado adequadamente.
Sendo assim, a Figura 1, apresenta o protótipo do projeto
exemplo que usaremos para tratar os eventos:
Figura 1 – Protótipo
da Aplicação Android
Fonte: Autor
Percebe-se, pela Figura 1, que nossa aplicação será
composta por três telas (activity). Na primeira tela (Principal)
vamos precisar utilizar três tipos de componentes: (1) Dois
TextView; (2) Um Plain Text; (3) Um Button.
Na segunda tela vamos precisar de 4 tipos de componentes:
(1) Seis do tipo TextView; (2) Dois do tipo Plain Text; (3) Dois do
tipo Option Buton; (4) Um do tipo Button.
E, por fim, na terceira tela, precisaremos destes tipos de
componentes: (1) Dois do tipo TextView; (2) Dos do tipo Button;
(3) Um do tipo Plain Text.
Implementando a Aplicação
Para implementar a aplicação, abra o Android Studio e crie
uma nova aplicação, chamada App_Evento_U4, com uma ‘Empty
Activity’, chamada Principal. Depois do projeto estar carregado
na IDE Android Studio, insira mais duas telas (Empty Activity)
em seu projeto, com os nomes de Tela2 e Tela3, respectivamente.
Seu projeto deve ficar assim (Figura 2):
Figura 2 – Telas da aplicação
Fonte: Autor
Repare, na Figura 2, que cada tela (classe Activity.java)

possui um arquivo xml (layout) correspondente. Trataremos
cada uma delas a partir de agora.
Preparando a Tela Principal

Layout da Tela
Abra o arquivo que corresponde ao layout da Tela
Principal (activity_principal.xml) e insira os componentes
conforme (Figura 1). O código xml deve ficar assim (Figura 3):
layout da tela Principal
Fonte: Autor
Salve e execute o aplicativo. O AVD deve ser
apresentado com o que mostra a Figura 4:
Figura 4 – Resultado do AVD para tela Principal
Fonte: Autor
Classe Activity da tela Principal

Os eventos que devem acontecer na tela Principal são:
Ao clicar no botão OK, o aplicativo deve capturar o
nome do usuário digitado na caixa de texto e passa-lo como
parâmetro para a tela 2.
IMPORTANTE
Perceba que o usuário pode clicar no botão OK sem digitar qualquer

nome na caixa de texto correspondente e este “erro” precisa ser tratado.
Sendo assim, primeiro precisamos permitir ao
aplicativo “ouvir” o clique do mouse sobre o botão. Isto é
chamado de evento “listener”, que você já aprendeu na
última unidade desta disciplina. Mas, se você está em dúvida,
verifique o código abaixo (Figura 5):
Figura 5 – Classe Activity para a
tela Principal
Fonte: Autor
Neste ponto, precisamos destacar dois casos:
1 - Repare que, na linha 25, para que possamos capturar
o nome que o usuário escreveu, precisamos saber o nome
do componente em que ele escreveu o nome: “txt_nome”.
Demos este nome por que é uma caixa de texto (txt) que
supostamente terá como conteúdo o nome do usuário
(nome). Por isso “txt_nome”. O nome do componente foi
dado quando montamos o arquivo xml do layout da tela

Principal (linha 19 – Figura 3)
2 - Repare que, na linha 28, existe uma verificação: Se o
conteúdo da caixa de texto onde o usuário deve digitar seu
nome está vazia, apresenta uma mensagem de aviso: Não
executa a intenção de chamada para a tela2, isto é, caso o
usuário esqueça de digitar o seu nome e clicar no botão OK,
o aplicativo deve se comportar como mostrado na Figura 6,
a seguir:
Figura 6 – Mensagem de aviso quando o nome
do usuário é deixado em branco e o botão OK é
pressionado.
Fonte: Autor
Preparando a Tela2
Layout da Tela2
Conforme mostrado na (Figura 1), a tela2 possui
vários componentes, e um deles deve receber o nome do
usuário. Podemos imaginar que seja possivelmente o primeiro
componente “TextView”, o qual contém o texto ‘Olá’.
Primeiramente, vamos montar o arquivo xml que
define o layout da tela2. O código deve ser como mostrado na
Figura 7:
Figura 7
– Código
xml do
layout da
tela2
F o n t e :
Autor
Figura 8 – Resultado do AVD para tela2
Fonte: Autor
Note que o nome do usuário ainda não está aparecendo.
Precisamos tratar isso na classe java correspondente à tela2.
Classe Activity da Tela2
Agora que temos o layout da tela2 implementado,
precisamos implementar o código java para que a mesma receba
o parâmetro relativo ao nome do usuário. Também apresente logo
após a palavra ‘Olá’, e capture os dados digitados nos campos
apresentados quando o usuário clicar no botão ‘Seguir’.

Primeiro, vamos capturar o parâmetro, ou seja, o pacote de
dados enviado pela tela Principal. Para isso, usamos os métodos:
1 - getIntent() – para capturar a intenção de chamada;
2 - getExtras() – para recuperar o pacote de dados enviado;
3 -getSting() – para recuperar o parâmetro enviado;
Veja como mostra a Figura 9:
Figura 9 – Código java
da tela2 para capturar o
parâmetro enviado pela
tela Principal
Fonte: Autor
Figura 10 – Tela2
capturando o dado
enviado pela tela
Principal
Fonte: Autor
Repare, no código java (Figura 9) que para inserir o conteúdo
enviado por parâmetro para a tela2, na caixa de texto que contém
a palavra “olá”, precisamos saber o nome deste componente, que,
neste caso, é “TextView5”. Ficaria muito mais fácil de se programar
se o nome dado a este componente fosse algo que lembrasse do

que ele trata, como por exemplo: “txt_ola”, não concorda? Foi por
isso que, na (Figura 7), destacado em vermelho escolhemos nomes
¹mnemônicos para os componentes que precisamos manipular.
Bem, agora que capturamos os dados enviado pela tela
Principal e o apresentamos na tela2, precisamos tratar o evento de
clique no botão “Seguir”, na tela2. Da mesma forma que aconteceu
na tela Principal, precisamos prever que o usuário pode “esquecer”
de preencher os campos e clicar direto no botão “Seguir”.
Figura 11 – Código
java da tela2 para
capturar e enviar
os dados de peso
e altura digitados
pelo usuário
Fonte: Autor
Repare que na Figura 11, nas linhas 48, 49 e 50, três
parâmetros são enviados para a tela3, quais sejam: nome,
altura e peso do usuário.
Vamos tratar, enfim, da tela3.
Preparando a Tela3
Layout da Tela3
Dando os nomes corretos aos componentes que serão
utilizados, o arquivo xml da tela3, fica como mostrado na
Figura 12:

do layout da tela3.
Fonte: Autor
Repare que nas linhas 12, 18 e 32 (Figura 12), foram dados

os nomes mnemônicos para os componentes, pois eles serão
usados pelo código java.
Classe Acticity da Tela3
A Figura 13, apresenta o código java da classe activity que
representa a tela3.
Figura 13 –
Código java da
tela3.
Fonte: Autor
O Resultado deve ser como mostrado na Figura 14:
Figura 14 – Resultado
da aplicação
Fonte: Autor
Capturando Resultados de uma Atividade

Como foi comentado anteriormente, a função do objeto
“Intent” é a de declarar a intenção de iniciar outra atividade a partir de
uma já em execução.
Utilizando o objeto Intent, a atividade em execução pode:
1 - Especificar qual outra atividade ela deseja iniciar – item que
veremos neste tópico;
2 - Descrever o tipo de ação que ela deseja realizar – item que veremos
no tópico 3 deste material.
O sistema Android localiza a atividade apropriada para
realizar a tarefa definida pela ação.
Como foi visto, também, nos tópicos anteriores, é possível
passar dados para a atividade que vai ser iniciada com o objeto
Bundle (embrulho ou pacote de dados) e receber retorno dela,
fazendo uso dos métodos startActivity() e startActivityForResult().
Até o momento, todos os exemplos apresentados utilizaram somente
o método starActivity().
Agora que já foi compreendido como chamar uma nova
atividade e como inserir alguns componentes nela, a aplicação pode
se tornar mais complexa e pode haver a necessidade de capturar o
retorno de uma atividade iniciada. Para tanto, utiliza-se o método
starActivityForResult() no lugar do método starActivity().
Um exemplo comum para esse caso acontece quando o
usuário necessita escolher um de seus contatos (da lista de contatos)
para executar alguma ação com ele, como mandar uma mensagem,
fazer uma ligação ou fazer qualquer coisa com a informação deste
contato.
A utilização do método startActivityForResult() faz com que
a atividade que foi iniciada, ao ser concluída, retorne um resultado na
forma de Intent para a atividade que a iniciou.
Para iniciar o estudo, crie um novo projeto Android com as

seguintes características:
Nome da aplicação: “App_Intent_U4”.
Nome da atividade: “Principal”.
Na classe Atividade Principal defina os seguintes
componentes:
o Um label (TextView) com o atributo text = “Esta é a Tela
Principal”.
o Um Botão (Button) com o atributo text = “Seguir para a
Próxima Tela”.
o Um label (textView) com o atributo text = “captura retorno”.
Quando o botão for clicado, deve ser chamada uma nova tela
(classe Atividade) chamada “Tela2”, com as seguintes características:
Nome da atividade: “Tela2”.
Na segunda tela (Tela2), defina o seguinte componente:
o TextView com o atributo text = “Esta é a segunda Tela do
App”.
Não se esqueça de mudar o tipo de layout para LinearLayout
e definir sua orientação como “vertical”.
Implementando o código xml para o layout das duas telas
descritas acima temos:
Para Tela Principal (Figura 15):
Figura 15: Código
xml para o layout da
tela Principal
Fonte: Autor
Para a Tela 2 (Figura 16):

Figura 16
– Código
xml para o
layout da
segunda
tela do
aplicativo
Fonte: Autor
Implementando o código java para as duas telas
teremos:
Para a tela principal (Figura 17):
Figura 17 –
Código java
para a tela
principal
Fonte: Autor
Para a Tela2 (Figura 18):
Figura 18 –
Código java
para a Tela2
Fonte: Autor
Salve e execute a aplicação. O resultado deve ser o

mostrado na Figura 19:
Figura 19 – Resultado da execução do aplicativo.
Fonte: Autor
Preparando as Telas da Aplicação

O próximo passo é modificar a Segunda Tela para que
a mesma contenha algum componente que, ao ser selecionado
pelo usuário envie um retorno para a tela Principal. Podemos,
num exemplo básico, montar uma lista das Estações do Ano,
permitindo assim que o usuário selecione uma delas e este valor
(da escolha do usuário) seja capturado e retornado.
Para tanto, altere o código do arquivo layout xml da
Tela2 para que o mesmo fique da seguinte maneira (Figura 20):
Figura 20 – Novo código xml para a tela2
Fonte: Autor
Observe que o atributo android: entries (linha 28)
do componente ListView é um array e deve ser definido
no arquivo strings.xml, na subpasta res/values, da mesma
maneira que foi feito quando inserimos o combobox para
selecionar o sexo do usuário. O arquivo strings.xml deve ficar
como mostra a Figura 21:
Figura 21 -Arquivo
strings.xml
Fonte: Autor
E, por fim, a segunda tela deve ficar, como mostra a
Figura 22:
Figura 22 – Resultado Tela2 depois das

últimas alterações
Fonte: Autor
Capturando a Seleção do Usuário

Agora é necessário aprender como capturar o item
selecionado da lista de estações (componente ListView). Para
tanto, modifique o código java da tela2 para ficar conforme
mostra a Figura 23:
Figura 23 –
Código java para
capturar a opção
selecionada pelo
usuário
Fonte: Autor
Fazendo estas alterações, salvando e executando o

aplicativo, teremos o seguinte resultado (Figura 24):
Figura 24 -
Resultado da
captura da
escolha do
usuário
Fonte: Autor
Repare que ao clicar na opção ‘Inverno’, na tela do

meio, esta opção aparece em destaque na tela à direita, por
alguns segundos e depois some. Ao selecionar outra opção
(Estação), esta será apresentada. Isto acontece por que, no
método onItemClick() (linha 21- 26) temos um comando
Toast.makeText responsável por esta ação.
Explicando melhor o que acontece dentro deste
método onItemClick():
Na linha 23, a estação escolhida pelo usuário é
capturada do objeto View e passada para um objeto lbl do
tipo TextView;
Na linha 24, o conteúdo deste objeto é transformado
em string e passado para uma variável chamada ‘texto’;
Na linha 25, o método makeText(), do objeto Toast
é responsável por apresentar uma mensagem de popup
temporária.Este método possui três parâmetros: (1) o
contexto da aplicação; (2) o texto a ser exibido; (3) a duração
da mensagem.
Retornando o Item Selecionado

Agora que o projeto está funcionando adequadamente,
é hora de utilizar o método startActivityForResult() para
permitir que a Segunda Tela (Tela2) devolva (retorne) o
resultado selecionado pelo usuário para a Tela Principal. Para
tanto, modifique o código da Tela Principal para que fique
como mostra na Figura 25:
Principal.java
modificada para
reconhecer o retorno
Fonte: Autor
E, por fim, modifique o código da Segunda Tela para
que ela fique como mostra, Figura 26:
Figura 26 – Classe Tela2.java
modificada para enviar item
selecionado pelo usuário como
retorno para a classe Principal.
java
Fonte: Autor
Salvando e executando o aplicativo, temos o seguinte
resultado (Figura 27):
Figura 27 –
Resultado da
captura do item
selecionado pelo
usuário
Fonte: Autor
Explicando o código:
Na primeira Tela: No método onClick() em vez de
utilizar o comando starActivity(), foi utilizado o comando
startActivityForResult(), pois para este caso, queremos tratar o
resultado da escolha do usuário na Segunda Tela. Os parâmetros
desse comando sempre serão o objeto Intent e o número 0 (zero).
Para tratar o resultado escolhido pelo usuário, implementou-se
o método onActivityResult(), que sempre deve ser declarado
quando o comando startActivityForResult() for utilizado. Dentro
deste método (onActivityResult()), faz-se o teste para verificar
se o objeto Intent foi retornado. Caso não tenha sido retornado,
isto é, caso a Segunda Tela tenha sido fechada sem que o usuário
escolha algum item, a mensagem mostrada será: “Nenhum item
selecionado.”. Mas caso o usuário escolha algum item antes
de fechar a Segunda Tela, o valor escolhido é atribuído a um
variável texto e mostrada na tela.
Na classe Segunda Tela: A modificação acontece no
método onItemClick() que, em vez de mostrar o resultado
escolhido pelo usuário, declara um objeto Intent para o qual é
atribuído o valor escolhido pelo usuário. Este objeto é devolvido
à Tela Principal, pelo método setResut, que terá acesso ao mesmo
logo que esta tela for fechada, e isto acontece quando o método
finish() é executado.
Chamando ações do sistema Android

Como foi comentado no início do tópico anterior,
o objeto Intent também pode chamar ações e permitir que
o sistema Android escolha qual aplicativo deve executá-lo.
Apresentaremos neste tópico algumas ações que o objeto Intent
suporta.
ACTION_VIEW
A ação Intent.ACTION_VIEW é a ação mais comum
utilizada pelos programadores para mostrar dados para o usuário.
Imagine que seu aplicativo precisa, em um determinado

momento, abrir o navegador em algum site específico. Isto pode
ser feito com o ACTION_VIEW, da seguinte maneira:
Uri endereco = Uri.parse(“http://www.google.com”);
Intent i = new Intent(Intent.ACTION_VIEW, endereco);
startActivity(i);
Para verificar o funcionamento desta ação do objeto
intent, crie um novo projeto no Android Studio, chamado App_
ACTION_U4, com uma Empty Activity chamada Principal. Ela
deve conter um botão que, ao ser clicado, abre o navegador na
página definida pela variável ‘endereco’.
O Código xml do layout da aplicação deve ficar como
mostrado na Figura 28:
xml para o exemplo
Fonte: Autor
O código java deve ficar como mostra, Figura 29:
Figura 29 – Código Java para o
exemplo
Fonte: Autor
Salvando e executando o aplicativo, tem-se o seguinte

resultado (Figura 30):
do exemplo
F o n t e :
Ainda utilizando a ação Intent.ACTION_VIEW, pode-

se iniciar o aplicativo agenda de contatos da seguinte forma:
Uri contato = Uri.parse("content://com.android.
contacts/contacts/1");
Intent i = new Intent(Intent.ACTION_VIEW, contato);
startActivity(i);
O número ‘1’ na primeira linha do código acima indica
qual ‘id’ do contato deve ser visualizada.
IMPORTANTE
Para que esta chamada retorne o contato solicitado, deve-se entrar

no aplicativo correspondente e cadastrar alguns contatos. Caso
contrário, o aplicativo ‘lista de contatos’ avisará que não existe
contato cadastrado para ser visualizado.
Para listar todos os contatos, a primeira linha do
código acima não deve ter o identificador do contato.
Crie uma nova “Empty Activity” em seu projeto,
com o nome de Lista_Contatos e insira o código apresentado
acima em um botão, da seguinte forma (Figura 31):
Figura 31 –
Visualizando o
primeiro contato
da lista de contatos
Fonte: Autor
Executando o aplicativo, temos o seguinte resultado (Figura
32):
do exemplo
F o n t e :
ACTION_PICK
Diferente do “ACTION_VIEW” que apenas permite a
visualização dos contatos, como mostrado no tópico anterior, o
“ACTION_PICK”, além de permitir a visualização dos contatos,
permite também que o usuário selecione um deles e, ao fazer isso,
a atividade lista de contatos é fechada e o contato selecionado é
retornado para a atividade anterior.
Para o melhor entendimento de como o “ACTION_PICK”
funciona, verifique o exemplo abaixo.
Crie uma nova tela (Empty Activity) em seu projeto, e dê
a ela o nome de Tela2. Dentro dela, crie um botão (button1) e
atribua a ela a função “Listener”, para que, ao ser clicado, ele abra
a tela de contatos para que o usuário possa selecionar um deles.
O código xml fica desta forma (Figura 33):
xml do layout da tela2
Fonte: Autor
O código java deve ser como mostrado na, Figura 34:

Figura 34 –
Código java da
tela2
Fonte: Autor
Repare que diferente do que aconteceu no exemplo

utilizando o “ACTION_VIEW”, neste caso não se indica o
número do contato a ser exibido (linha 23).
Ao ser executado, o aplicativo deve se comportar da
maneira apresentada na Figura 35:
da utilização do
ACTION_PICK
Fonte: Autor
ACTION_CALL
Outra ação importante é o “Intent.ACTION_CALL”,
responsável por fazer ligações telefônicas para um contato
especificado.
Sua utilização deve ser como mostra abaixo:
Uri telefone = Uri.parse(“tel:99999999”);
Intent i = new Intent(Intent.ACTION_CALL,
telefone);
startActivity(i);
Para o melhor entendimento de como o “ACTION_
EXEMPLO
Crie uma nova tela (Empty Activity) em seu projeto, e
dê a ela o nome de Tela3. Dentro dela, crie um botão (button1)
e atribua a ela a função “Listener”, para que, ao ser clicado,
ele possa iniciar a atividade de ‘fazer chamada telefônica’.O
código xml fica desta forma (Figura 36):
xml do layout da tela3
Fonte: Autor
O código java deve ser como mostrado na Figura 37:
Figura
37 –
Código
j a v a
para o
exemplo
Fonte:
Autor
Ao ser executado, o aplicativo deve se comportar da
maneira apresentada na Figura 38:
Figura 38 –
resultado para
a utilização
de ACTION_
CALL
++
Fonte: Autor
SAIBA MAIS
Para conhecer outras ações que podem ser executadas pelo objeto
intente, acesse: http://developer.android.com/reference/android/
content/Intent.html
Layout de Tela
Introdução
Como foi apresentado até o momento, sempre que uma
tela (classe atividade) é definida, é necessário também definir
o arquivo xml que corresponde ao seu layout. Durante todo o
material, foi utilizado o layout <LinearLayout> para facilitar
a compreensão e a disposição simples que ele permite.
Este módulo trata dos tipos de layout mais importantes
permitidos pelo sistema Android, para se configurar
uma aplicação. São eles: FrameLayout, LinearLayout e
TableLayout.
IMPORTANTE
Nas aplicações atuais, um layout bem definido é muito importante

para chamar a atenção do usuário. Por isso, além de ter um código
que funcione corretamente (sem erros e com as regras de negócio
bem determinadas), o desenvolvedor não pode esquecer de tratar o
layout do aplicativo como algo essencial para o sucesso do produto.
FrameLayout
Este é o tipo mais comum de layout, onde o componente
sempre é posicionado no canto superior esquerdo da tela e,
caso exista mais de um componente, um sobrepõe o outro.
Dependendo do tamanho (propriedades altura e
largura) do componente, definidos pelo usuário, o mesmo
pode preencher toda a tela.
EXEMPLO
Crie uma nova app, chamada “AppLayout1_U4”, com
uma Empty Activity. Dentro do arquivo xml que define o
layout da activity, insira o seguinte código, como mostra na
Figura 39:
do Exemplo
Fonte: Autor
Salve a arquivo, execute a aplicação e verifique o

resultado. Ele deve se parecer com o da Figura 40:
Figura 40 – Frame Layout
Fonte: Autor
Note que a componente imagem, sobrepôs o
componente texto e que a cor de fundo do layout foi definida
pelo atributo “android:background” (linha 6) que, para este
caso, recebeu o valor "@android:color/holo_orange_light”.
Outro item importante a ser notado está na linha 20:
A propriedade “src” define a imagem a ser usada. Esta
imagem deve estar definida na pasta res-> mipmap, como
destaca a Figura 41:
Figura 41 – Local onde devem ser

armazenadas as imagens que podem ser
utilizadas no aplicativo
Fonte: Autor
À primeira vista, pode parecer que este tipo de layout
não tem muita utilidade, porém, se alterarmos um pouco o
tamanho e disposição dos componentes da tela, você vai
perceber que ele pode ser bastante útil. Veja só, neste exemplo:
EXEMPLO
Crie uma nova Empty Activity na sua aplicação e insira o código
abaixo (Figura 42) no arquivo xml que define o layout da tela.
da utilização do
FrameLayout
Fonte: Autor
Depois de salvar e executar esta Activity, temos o
seguinte resultado, Figura 43:
Figura 43 – Resultado do uso de FrameLayout
Fonte: Autor
Antes de passar para o próximo tipo de layout, é
necessário dar destaque à ‘linha 14’ do código xml acima, o
qual determina a imagem a ser usada: “android_logo1”. Esta
imagem não vem com a IDE Android Studio, como acontece
com algumas outras e, para utilizá-la, é necessário inseri-la
na pasta “res->mipmap”, da seguinte forma:
1 - Grave a imagem que deseja inserir no seu aplicativo em
algum local na sua máquina (de preferência no formato png);
2 - Clique sobre a imagem, com o botão direito do mouse e
selecione a opção copiar;
3 - Clique sobre a pasta ‘mipmap’, com o botão direito do
mouse e selecione a opção colar;
Para inserir a imagem na tela use o código xml
“android:src:@mipmap/android_logo1” , a destacar que
“android_logo1” é o nome da imagem.
LinearLayout
Este tipo de layout é utilizado para organizar os
componentes na vertical ou na horizontal. A orientação dos
componentes é definida pelo atributo “android:orientation”,
o qual pode ter o valor “horizontal” ou “vertical”.
EXEMPLO
Crie uma nova Empty Activity em sua aplicação e
escreva o seguinte código no arquivo xml correspondente ao
layout desta tela (Figura 44):
do uso de LinearLayout
(Vertical)
Fonte: Autor
Salve e execute a aplicação. O resultado deve ser como
apresentado na Figura 45:
Figura 45 – Resultado do exemplo do uso de
LinearLayout(vertical)
Fonte: Autor
Repare que a componente imagem foi posicionada
abaixo (orientação vertical) do componente texto, a cor
(imagem) de fundo do layout foi definida pelo atributo
“android:background” que, para este caso, recebeu o valor “@
drawable/ic_launcher_background” e a cor do texto foi definida
pelo “atributo android:textColor”, como sendo branca.
Alterando a orientação do LinearLayout para horizontal,
teremos o seguinte resultado (Figura 46):
Figura 46 - Resultado do exemplo do uso de

LinearLayout(vertical)
Fonte: Autor
Relevância dos componentes

Dentro do layout do tipo LinearLayout você pode
determinar o espaço que cada componente deve ocupar na
tela pela importância (relevância) definida para o mesmo. O
atributo responsável por definir esta característica (relevância)
é o “android:layout_weight” que por padrão, vale 0 (zero) para
todos os componentes. Nota-se, então que, por padrão, todos
os componentes possuem relevâncias idênticas, porém, essa
propriedade pode ser alterada para valores inteiros maiores que
zero. Quanto maior o número definido para este atributo, maior
o espaço que o componente ocupará na tela do aplicativo.
EXEMPLO
Imagine que você queira diferenciar o espaço ocupado
pelos componentes de uma tela cujo projeto de layout é
Figura 47 – Projeto de layout do exemplo
Fonte: Autor
O Código xml da tela será apresentado, conforme Figura 48:

xml do layout da tela
do exemplo
Fonte: Autor
É importante destacar aqui algumas linhas de código da
Figura 48:
Na linha 5 e 6 foram definidas o espaçamento dos
componentes, para que os mesmos não fiquem ‘grudados’ às
margens esquerda e direita da tela do dispositivo;
Nas linhas 11, 15 e 21 foram definidos os ‘textos’ que
aparecem na caixa de texto, a informar o que o usuário deve digitar.
Na linha 19 é definido que a terceira caixa de texto deve
ocupar maior espaço que os demais componentes da tela;
Na linha 26 é definido que o componente botão deve ficar
alinhado à direita.
Salve e execute este código. O resultado deve ser o
apresentado, como na Figura 49:
Figura 49 – Resultado do exemplo
Fonte: Autor
TableLayout
Este tipo de layout é utilizado para organizar os
componentes em linhas e colunas, simulando uma tabela. É
o tipo ideal de layout para construir formulários. Cada linha
da tabela é definida pela tag “TableRow” e, dentro dela, cada
componente incluído é considerado como uma coluna.
EXEMPLO
Crie uma nova Empty Activity em seu projeto.
Queremos, neste caso que a tela tenha o seguinte layout:
Figura 50 – Protótipo
de tela para o uso de
TableLayout
Fonte: app Android
Na (Figura 50) acima, temos uma tabela com duas

linhas e duas colunas. O seguinte código xml (Figura 51),
pode ser usado para resolver esta questão:
Figura 51 –
Código xml
para o exemplo
da utilização do
FrameLayout
Fonte: app
Android (2018)
Note que as linhas 9 e 10 declaram as células da
primeira linha da tabela e as linhas 13 e 14 as células da
segunda linha da tabela.
O resultado do código acima pode ser visualizado na
Figura 52:
Figura 52 – Resultado do exemplo do uso do FrameLayout
Atributo StretchColluns
Muitas vezes é necessário expandir as colunas para
forçar o preenchimento de toda a tela do dispositivo. Nestes
casos utiliza-se o atributo “StrechColluns”. Crie uma nova
“Empty Activity” em seu projeto e para o seu código xml
relativo ao layout, copie o código da Figura 53:
Figura 53 - Exemplo do uso
do atributo StretchColluns
no TableLayout
Fonte: app Android

(2018)
Repare que o atributo “android:stretchColumns”
(linha 7) define que a primeira coluna deve se expandir para
que a “tabela” preencha toda a largura da tela. O Atributo
“android:layout_gravity” (linha 15) está sendo utilizado
apenas na “linha 1 – coluna 2” para forçar o conteúdo desta

célula a ficar alinhado à direita. Os atributos ‘background’
estão a ser usados, nas linhas 12, 14, 20 e 23 para permitir
melhor visualização do comportamento das células da tabela,
como mostra a Figura 54:
Figura 54 – Resultado do exemplo do uso do
atributo StretchColluns no TableLayout

Para melhor fixação dos conhecimentos, acompanhe o
exemplo abaixo.
Imagine que você precisa montar uma tela com as
seguintes características:
Na tela deve constar, uma tabela com 3 linhas e 2
colunas;
A primeira linha deve conter:
Na primeira coluna um label “Digite seu login”;
Na segunda coluna uma caixa de texto para que o
usuário digite o login.
A segunda linha deve conter:
Na primeira coluna um label “Digite sua senha”.
Na segunda coluna uma caixa de texto para que o
usuário digite a senha.
A terceira linha deve conter:
Na primeira coluna um botão “Validar”.
Na segunda coluna um botão “Cancelar”
O Código xml para o layout deve ser parecido com o

xml para o layout da
tela do exemplo
Fonte: app Android

(2018)
Salve e execute esta activity. O resultado deve ser o

seguinte (Figura 56):
Figura 56 – Resultado do código xml para
o layout da tela do exemplo
Fonte: app Android

IMPORTANTE
Verifique o que precisa ser alterado no código ou na estrutura dos

componentes da activity acima (Figura 56), para que a componente
que apresenta a senha apresente apenas asteriscos quando o usuário
nela digitar.
Atributo ShrinkColluns
Em outros casos, as colunas precisam ser contraídas
para que o conteúdo das mesmas caiba na tela.
EXEMPLO
O Código xml (Figura 57), apresenta o caso em que
uma célula possui um conteúdo muito grande e precisa ser
adaptado à tela.
Figura 57 –
Exemplo do
uso do atributo
ShrinkColluns
Fonte: app
Android (2018)
A resultado deve ser consta na Figura 58:

Figura 58 – Resultado do Exemplo do
uso do atributo ShrinkColluns

Combinando Layouts
Quando necessário, pode-se combinar os tipos de
layouts na mesma tela. Verifique o exemplo, onde são
combinados “TableLayout” e “LinearLayout”, na Figura 59:
Figura 59 – Código xml que combina TableLayout e LinearLayout

O resultado é mostrado na Figura 60:

Figura 60 – Resultado do código xml que combina
TableLayout e LinearLayout
Como você deve ter percebido, dá pra fazer muito mais com
os app Android. Mas, por esta unidade é só. Não deixe de
verificar as referências bibliográficas para aprender mais. Isto
é só o começo e a aprendizagem não podem parar!!
Muito obrigado por ter acompanhado todo o processo até
aqui. Estamos à disposição. Sucesso pra você!
REFÊRENCIAS
ANDROID. Documentation Guide. Android Developers, 2018.
Disponivel em: <https://developer.android.com/guide/topics/
manifest/manifest-intro>. Acesso em: 15 Set. 2018.
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis:

Copyleft Pearson Education, 2008. 89 p. Disponivel em: <http://
www.faeterj-rio.edu.br/downloads/ bbv/0031.pdf>. Acesso em: 06
Set. 2018.
CORDEIRO, F. Android Studio. 3. ed. [S.l.]: AndroidPro, 2016.
CORDEIRO, F. Android Aprendiz. [S.l.]: AndroidPro, 2017. 37 p.

Disponivel em: <https://www.androidpro.com.br/>. e-Book.
MEIRELLES, A. Smartphones, Guia Prático - Android. Hardware.

com.br, 2009. Disponivel em: <https://www.hardware.com.br/
livros/smartphones/android.html>. Acesso em: 05 Set. 2018.
OGLIARI, R.; BRITO, R. Android LifeCycle: ciclo de vida de

uma aplicação Android. DevMedia, 2014. Disponivel em: <https://
www.devmedia.com.br/android-lifecycleciclo-de-vida-de-uma-
aplicacao-android/29991>. Acesso em: 15 Set. 2018.
PEREIRA, A. P. O que é XML? TecMundo’, 2009. Disponivel em:
<https://www. tecmundo.com.br/programacao/1762-o-que-e-xml-.
htm>. Acesso em: 14 Set. 2018.
CLARO, D., & SOBRAL, J. (2008). Programação em JAVA.

Florianópolis, SC: Copyleft Pearson Education. Acesso em 06
de Set. de 2018, disponível em http:// www.faeterj-rio.edu.br/
downloads/bbv/0031.pdf
CORDEIRO, F. (2016). Android Studio (3 ed.). AndroidPro.
CORDEIRO, F. (2017). Android Aprendiz. AndroidPro. Fonte:

https://www. androidpro.com.br/
DALL’OGLIO, P. (2016). PHP - Programando com Orientação a
Objetos (3 ed.). SP, SP, Brasil: Novatec Editora. Acesso em 30 de
Ago. de 2018
DEITEL, H., & DEITEI, P. (2003). Java, como programar (4 ed.).

Porto Alegre: Bookman.
GOSLING, J., & McGILTON, H. (1995). The Java Language

Environment. Mountain View,, California, EUA: Sun Microsystems,
Inc.
MATTOS, E. (2007). Programação de softwares em Java. SP:

Digerati Books.
MEIRELLES, A. (2009). Smartphones, Guia Prático - Android.

Acesso em 05 de Set. de 2018, disponível em Hardware.com.br:
https://www.hardware.com.br/livros/ smartphones/android.html
ORACLE.COM. (2018). Java Documentation. Acesso em 13 de

Set. de 2018, disponível em Oracle: https://docs.oracle.com/javase/
tutorial/getStarted/intro/definition.html
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis:

Copyleft Pearson Education, 2008. 89 p. Disponivel em: <http://
www.faeterj-rio.edu.br/downloads/ bbv/0031.pdf>. Acesso em: 06
Set. 2018.
CORDEIRO, F. Android Studio. 3. ed. [S.l.]: AndroidPro, 2016.
CORDEIRO, F. Android Aprendiz. [S.l.]: AndroidPro, 2017. 37 p.

Disponivel em: <https://www.androidpro.com.br/>. e-Book.
DALL’OGLIO, P. PHP - Programando com Orientação a Objetos.

3. ed. SP: Novatec Editora, 2016. ISBN 978-85-7522-465-6. Acesso
em: 30 Ago. 2018.
DEITEL, H. M.; DEITEI, P. J. Java, como programar. 4. ed. Porto

Alegre: Bookman, 2003.
GOSLING, J.; MCGILTON, H. The Java Language Environment.

Mountain View,: Sun Microsystems, Inc, 1995.
MATTOS, E. Programação de softwares em Java. SP: Digerati
Books, 2007.
MEIRELLES, A. Smartphones, Guia Prático - Android. Hardware.

com.br, 2009. Disponivel em: <https://www.hardware.com.br/
livros/smartphones/android.html>. Acesso em: 05 Set. 2018.
ORACLE.COM. Java Documentation. Oracle, 2018. Disponivel

em: <https://docs. oracle.com/javase/tutorial/getStarted/intro/
definition.html>. Acesso em: 13 Set. 2018.
SINGH, C. @Override annotation in Java. JAVA TUTORIAL,

2017. Disponivel em: <https://beginnersbook.com/2014/07/
override-annotation-in-java/>. Acesso em: 03 Out. 2018.

E-Book Completo - Programação Introdução Ao Coding Mobile - COMPLETO - TELESAPIENS (Versão Digital)

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

E-Book Completo - Programação Introdução Ao Coding Mobile - COMPLETO - TELESAPIENS (Versão Digital)

Enviado por

Direitos autorais:

Formatos disponíveis

INTRODUÇÃO INTRODUÇÃO

Introdução ao Coding Mobile

GRUPO SER EDUCACIONAL

gente criando o futuro

Olá! Meu nome é Luiz Fernando Corcini. Sou formado em

ESTRUTURA DE UM PROJETO ANDROID

1 Conhecer o sistema operacional Android, sua história,

2 Aprender a instalar e configurar os componentes básicos

3 Entender as principais características da estrutura de

Android – Visão Geral

Fonte: IDC – 05-2017.

Android – Um pouco de História

Dois anos depois (em 2007), o projeto foi apresentado ao

Deixo aqui o link para dois sites interessantes se você quiser

Agora que conhece um pouquinho da história do MOS

(sistema operacional) Android, são necessárias a instalação

APK vem de “Android Package”, Arquivo de Pacote de Aplicativos.

são como blocos de construção, executam tarefas específicas e têm

Quando um aplicativo é desenvolvido para os dispositivos que

Para auxiliar nesse gerenciamento dos aplicativos, o

Toda aplicação Android pode ser formada por

O código fonte do Android está disponível no site: https:// source.

Para saber em detalhes como é a arquitetura da plataforma Android,

Requisitos para o desenvolvimento de Apps

Ambiente de Desenvolvimento Java para

Fonte: Print da tela do Java

Fonte: Print da tela

Não se esqueça de aceitar os termos de licença antes de selecionar

O arquivo mostrado na figura acima é a última versão disponível

Fonte: Print da tela do Java (2018)

Fonte: Print da tela do Java (2018)

Selecione o diretório onde deve ser instalado o JDK e

Figura 7 - Instalando o JDK

Fonte: Print da tela do Java

Fonte: Print da tela do Java

Figura 9 – Tela para “Configurações

Fonte: Print da tela do Java (2018)

Passo 3: Clique no botão “Variáveis de Ambiente”, como

Fonte: Print da tela do Java (2018)

Passo 4: Crie uma nova “Variável do Sistema” com

Fonte: Print da tela do Java (2018)

Passo 5: Clicar em OK, na tela da figura acima;

Figura 12 – Editando a variável Path

Fonte: Print da tela do Java (2018)

Fonte: Print da tela do Java

Passo 10: Depois de clicar em OK, reinicie o

Fonte: Print da tela do prompt

Ainda no Prompt do DOS, digite outro comando:

Fonte: Print da tela do prompt do DOS,

Instalar e Configurar o Android Studio

Instando o Android Studio

Fonte: Print da tela do

Caso seu Sistema operacional seja 64 bits, clique no botão de

O arquivo a ser baixado tem o seguinte nome “android-

Fonte: Print da tela do Android, (2018).

Passo 3: Clique em “Next” e a seguinte tela será

Fonte: Print da tela do Android, (2018).

Passo 4: Verifique se o checkbox da opção “Android

Fonte: Print da tela do Android, (2018).

Passo 6: Escolha o local onde o aplicativo deve ser

Fonte: Print da tela do Android, (2018).

Passo 8: Clique em “Next” e a processo de instalação

Fonte: Print da tela do Android, (2018).