Apostila de Android Programando DO ZERO Android Studio

1
Aviso sobre esta apostila

Antes de iniciar a leitura deste material, veja esses avisos importantes:
Esse material NÃO PODERÁ SER DISTRIBUÍDO, em hipótese alguma, em

outros sites da Internet ou através outros processos/meios .
Esse material , em hipótese alguma, NÃO PODE SER COMERCIALIZADO

tanto pela Internet ou de forma impressa.
Se por acaso você encontrar este material sendo distribuído em outro site ou
sendo comercializado (sem ser pelo site oficial da apostila), por favor, entre em
contato com o autor (ver e-mail na primeira página).
2
Sobre o Autor da Apostila
Luciano Alves da Silva é Bacharelado em Ciência da Computação pela

UNISUAM e Pós-Graduado em Docência do Ensino Superior pelo Instituto A
Vez do Mestre (Universidade Cândido Mendes - UCAM). Possui conhecimento
e domínio das linguagens de programação Pascal, Java, C/C++, C#, Visual
Basic, Delphi, PHP e HTML. Já criou Ambientes de Desenvolvimento Integrado
(conhecidos como IDE) como o MakeWare (que trabalha com as linguagens
Pascal, C++ e Java) e o AlgoWare (interpretador de algoritmos).
É autor também dos seguintes livros, pela editora AGBOOK
- Aprenda Passo a Passo a Programar em Android – Guia Essencial para

Desenvolvedores
- Desenvolvendo Jogos com a Plataforma XNA 2ª Edição – Guia para

Desenvolvedores.
- Desenvolvendo Jogos com o Framework MONOGAME – Guia para

Desenvolvedores.
- Desenvolvendo Jogos 2D com Plataforma Java – Guia para

Desenvolvedores.
3
Apresentação
Atualmente, nos dias de hoje, vivemos conectados em um mundo em que se
predomina a tecnologia, e a tecnologia que vem ganhando força está
fortemente empregada e destacada nos dispositivos móveis (como
Smartphones e Tablets).
Os dispositivos móveis de hoje em dia fazem parte de nossas vidas, através

do uso mais comum que fazemos com eles no dia a dia (como acesso a
Internet, bate-papo, jogos, acesso a notícias e informações e etc.). Porém, tudo
isso que citei só é possível graças as aplicações presentes nesses
dispositivos.
Se você, que está lendo este material, não possui nenhum conhecimento sobre
desenvolvimento de aplicações para dispositivo móvel e queira um PONTAPÉ
INICIAL para a construção do seu próprio aplicativo, VOCÊ ESCOLHEU O
MATERIAL QUE IRÁ CAPACITÁ-LO A REALIZAR ESSE OBJETIVO.
Este material irá mostrar de forma SIMPLES, CLARA, DIDÁTICA e

MOTIVADORA, como construir DO ZERO uma aplicação para dispositivo
móvel, voltado para o sistema operacional que está ampliando a cada dia que
passa e que vem ganhando adepto de milhares e milhares de usuário ao redor
do mundo, a plataforma Google Android.
O material está organizado de tal forma que você possa compreender todo o
processo de construção de um aplicativo (de forma geral), com foco para a
plataforma Android. Na primeira parte iremos ver alguns conceitos e
fundamentos da informática, em seguida iremos aprender lógica de
programação e algoritmos , depois iremos aprender a linguagem Java (que é a
linguagem que será utilizada para o desenvolvimento no Android), e por fim,
desenvolver nossas aplicações para Android.
4
Índice analítico
Capitulo 1 Fundamentos sobre informática .................................................. 9
1.1) O que é um computador ? ....................................................................... 9
1.2) O que é um sistema operacional ? ........................................................ 10
1.3) O que é um dispositivo móvel ? ............................................................. 10
1.4) O que é linguagem binária ?.................................................................. 11
Capitulo 2 Lógica de programação e algoritmos ....................................... 12
2.1) O que é algoritmo ? ............................................................................... 12
2.2) O que é linguagem de programação ? .................................................. 15
2.3) O que é português estruturado (PORTUGOL) ? .................................. 16
2.4) Usando o Visualg .................................................................................. 17
2.4.1) Estrutura geral de um ALGORITMO ............................................... 18
2.4.2) Escrevendo nosso primeiro programa ............................................ 19
Capitulo 3 Gerenciando dados na memória................................................ 25
3.1) Como funciona a memória..................................................................... 26
3.2) Dados , informações e instruções ......................................................... 28
3.2.1) O que é dado ? ............................................................................... 28
3.2.2) O que é informação ?...................................................................... 28
3.2.3) O que é instrução ? ......................................................................... 29
3.3) Entrada, processamento e saída de informações ................................. 31
3.4) Variáveis e tipos de dados..................................................................... 31
3.4.1) Declarando variáveis ....................................................................... 33
3.4.2) Regras para declaração de variáveis .............................................. 35
3.5) Lendo dados via teclado ........................................................................ 38
3.6) Trabalhando com variáveis no Visualg .................................................. 39
3.7) O comando de atribuição....................................................................... 49
3.8) Operadores aritméticos e expressões ................................................... 52
Capitulo 4 Estrutura condicional ................................................................. 60
4.1) A estrutura SE/ ENTÃO ......................................................................... 60
4.2) A estrutura SE/ ENTÃO/SENÃO ........................................................... 67
4.3) Tabela de operadores relacionais ......................................................... 74
4.4) Operadores lógicos................................................................................ 75
4.4) A estrutura ESCOLHA/CASO ................................................................ 88
5
Capitulo 5 Estrutura de repetição ................................................................ 94
5.1) A estrutura de repetição ENQUANTO ................................................... 94
5.2) A estrutura de repetição REPEITA/ATÉ .............................................. 108
5.3) A estrutura de repetição PARA/FAÇA ................................................. 109
5.4) Observações a respeito dos loops de repetição .................................. 114
Capitulo 6 Trabalhando com Vetores ........................................................ 115
Capitulo 7 Trabalhando com Sub-rotinas ................................................. 128
7.1) O que é uma sub-rotina ? .................................................................... 128
7.2) O que é procedimento ? ...................................................................... 134
7.3) O que é são parâmetros ? ................................................................... 139
7.4) O que é são funções ?......................................................................... 145
7.5) Variáveis locais e variáveis globais ..................................................... 151
Capitulo 8 Lista de exercícios de algoritmos. ........................................... 154
8.1) Programação Sequencial .................................................................... 154
8.2) Variáveis .............................................................................................. 156
8.3) Estrutura condicional ........................................................................... 158
8.4) Estrutura de repetição ......................................................................... 165
8.5) Vetores ................................................................................................ 173
8.6) Sub-rotinas .......................................................................................... 178
Capitulo 9 Linguagem de programação Java ........................................... 183
9.1) O que é Java ? .................................................................................... 183
9.2) O que é Máquina Virtual Java ? .......................................................... 184
9.3) Compilação e Interpretação ................................................................. 185
9.3.1) O que é compilação ? ................................................................... 185
9.3.2) O que é interpretação ? ................................................................ 186
9.3.3) Vantagens e desvantagens da compilação e interpretação .......... 188
9.4) Modo híbrido ........................................................................................ 189
9.5) A ferramenta de desenvolvimento (Eclipse) ........................................ 191
9.6) Criando nosso primeiro projeto ............................................................ 200
9.7) Variáveis e tipos de dados................................................................... 210
9.7.1) Como declarar uma variável no Java ............................................ 210
9.7.2) Tipos de dados existentes na linguagem Java ............................. 211
9.7.3) Comando de atribuição ................................................................. 216
9.7.4) Leitura de dados via teclado ......................................................... 216
9.7.5) Operadores aritméticos ................................................................. 224
6
9.7.6) Observações gerais ...................................................................... 224
9.8) Estrutura condicional ........................................................................... 225
9.8.1) A estrutura IF ................................................................................ 225
9.8.2) A estrutura IF/ELSE ...................................................................... 226
9.8.3) Tabela de operadores relacionais ................................................. 228
9.8.4) Operadores lógicos ....................................................................... 228
9.8.5) A estrutura SWITCH/CASE ........................................................... 234
9.9) Estrutura de repetição ......................................................................... 236
9.9.1) A estrutura de repetição WHILE ................................................... 236
9.9.2) A estrutura de repetição DO/WHILE ............................................. 238
9.9.3) A estrutura de repetição FOR ....................................................... 240
9.10) Vetores (Arrays) ................................................................................ 245
9.11) Usando métodos ............................................................................... 247
9.11) Lista de Exercícios em Java .............................................................. 251
9.11.1) Programação Sequencial ......................................................... 251
9.11.2) Variáveis .................................................................................... 252
9.11.3) Estrutura condicional ............................................................... 255
9.11.4) Estrutura de repetição .............................................................. 262
9.11.5) Arrays ......................................................................................... 269
9.11.6) Métodos ..................................................................................... 275
Capitulo 10 Fundamentos sobre Programação Orientada a Objetos ..... 280
10.1) O que é Programação Orientada a Objetos ? ................................... 280
10.2) O que é uma classe ? ........................................................................ 280
10.3) O que é um atributo ? ........................................................................ 281
10.4) O que é um método ? ........................................................................ 282
10.5) O que são modificadores de escopo ? .............................................. 283
10.6) O que é um objeto ? .......................................................................... 285
10.7) O que é método construtor ? ............................................................. 285
10.8) Herança ............................................................................................. 295
10.9) Polimorfismo ...................................................................................... 297
Capitulo 11 Introdução a Plataforma Google Android ............................. 305
11.1) O que é o Google Android ? .............................................................. 305
11.2) Estrutural geral do Android ................................................................ 307
11.3) Versões do Android ........................................................................... 309
11.4) Para qual versão do Android devemos desenvolver as aplicações ? 311
7
11.4.1) Qual versão da plataforma é a mais utilizada no momento ? .... 311
Capitulo 12 Desenvolvendo nosso primeiro projeto no Android ............ 313
Conhecendo a estrutura geral de um projeto no Android Studio ................ 322
O diretório “app” (application).................................................................. 323
O diretório “res” (resources) .................................................................... 327
O diretório “drawable”.............................................................................. 327
O diretório “layout” .................................................................................. 327
O diretório “values” .................................................................................. 327
O diretório “mipmap” ............................................................................... 328
O diretório “menu” ................................................................................... 329
Visão geral da ferramenta de desenvolvimento ...................................... 329
Executando a nossa aplicação ................................................................... 331
Capitulo 13 Criando uma aplicação básica no Android ........................... 348
Capitulo 14 Conhecendo os componentes do Android ........................... 384
4.1) A paleta de componentes e suas widgets ........................................... 384
4.1.1) A seção “Widgets” ......................................................................... 385
4.1.2) A seção “Text Fields” .................................................................... 388
4.1.3) A seção “Layouts” ......................................................................... 389
4.1.4) A seção “Containers” ........................................................................ 391
4.1.5) A seção “Date & Time” .................................................................. 391
4.1.6) A seção “Expert” ........................................................................... 393
15.1) Criando uma aplicação Android para uma Lanchonete ..................... 394
15.2) Criando uma aplicação básica de compras ....................................... 405
15.3) Criando uma aplicação de locadora de filmes ................................... 412
15.4) Criando uma aplicação para visualização de imagens ...................... 425
15.5) Criando uma aplicação para jogos da Mega-Sena ............................ 440
15.6) Criando uma aplicação de Pesquisa de Opinião ............................... 456
Capitulo 16 Publicando as aplicações Android no Google Play ............. 483
Conclusão a respeito do material ............................................................... 487
8
Capitulo 1 Fundamentos sobre
informática
E
sse é um dos capítulos fundamentais para aqueles que nunca viram
programação para computadores na vida, que é os fundamentos da
informática. Irei focar aqui ao máximo direcionado para o
desenvolvimento de aplicações para dispositivos móveis. Bom, então vamos lá.
1.1) O que é um computador ?
Talvez para alguns que estejam lendo este material, essa pergunta pode até
parecer “desnecessária” (ou até mesmo inútil). Mas o intuito desta pergunta
não é somente falar o que é um computador, visto que todos usam no dia a dia,
mas sim mostrar como ele funciona, comparando-o com um dispositivo móvel.
Bom, um computador (que nós usamos no dia a dia) nada mais é do que uma
máquina de processamentos de dados e informações. Desde quando ligamos o
computador até o momento em que o desligamos, ele realiza vários
processamentos e tarefas. Vejamos a figura dele abaixo:
Computador – Máquina que usamos no nosso dia a dia
9
O computador é formado basicamente por :
HARDWARE : Muitos já ouviram e já sabem do que se trata este termo,

mas, para aqueles que ainda desconhecem essa palavra, HARDWARE
nada mais é do que a PARTE FÍSICA DO COMPUTADOR, ou seja, é
tudo o que é tangível (que podemos tocar). Exemplos de HARDWARE :
Mouse, Teclado, Monitor, Impressora e etc.
SOFTWARE : Muitos já ouviram falar e já sabem do que se trata esse

termo, mas, para aqueles que ainda desconhecem essa palavra,
SOFTWARE nada mais é do que a PARTE LÓGICA DO COMPUTADOR,
ou seja, os programas do computador (como o Windows, Word, Excel,
Firefox, Internet Explorer e etc.).
1.2) O que é um sistema operacional ?
Bom, para aqueles que desconhecem esse termo , o sistema operacional nada
mais é do que um software (programa) que prepara a máquina (computador)
para que nós usuários possamos interagir com o ele, através do uso de outros
softwares (como navegador, editor de textos e etc.). Um exemplo de sistema
operacional que mais utilizamos é o Windows (como o Windows 7 por
exemplo).
1.3) O que é um dispositivo móvel ?
Já que tivemos a oportunidade de ver o que vem a ser um computador, o que

seria um dispositivo móvel (como um Smartphone ou Tablet) ? Bom, não seria
nada de diferente. Um dispositivo móvel nada mais é do que um computador
em ESCALA REDUZIDA, e assim como um computador ele é formado por
HARDWARE (que seria todos os componentes físicos do nosso dispositivo
como câmera, teclado, tela e etc.) e SOFTWARE (como o Facebook,
WhatsApp, GPS, Skype e etc.). Como um computador, o dispositivo móvel
possui também o seu sistema operacional (como por exemplo, o sistema
operacional Android que utilizaremos aqui no material).
10
1.4) O que é linguagem binária ?
A linguagem binária nada mais é do que a linguagem do computador (assim

também como dos dispositivos móveis, que são computadores em escala
reduzida), ou seja, a linguagem que a máquina “entende” e se comunica com
os componentes. A linguagem recebe o nome de “binária” pelo fato dela ser
formado por apenas “0” e “1”.
Bom, de onde vem o termo “0” e “1” da linguagem do computador ? O

computador (dispositivo) quando ligado, é alimentado pela energia que passa
por ele (que do computador é vindo do estabilizador, e do dispositivo móvel é
vindo da bateria). A energia é distribuída pelos componentes do computador,
ou seja, onde não houver energia é “0” e onde houver eletricidade é “1”.
Bom, com isso encerramos os fundamentos básicos da informática , que nada

mais foi do que uma visão geral, que é muito importante saber para quem vai
começar a programar, pois precisa entender como funciona todo o universo do
computador.
11
Capitulo 2 Lógica de
programação e algoritmos
A
qui neste capítulo começamos a parte mais interessante deste material,
A PROGRAMAÇÃO. Neste material iremos aprender passo a passo
todos os conceitos sobre lógica de programação e algoritmos, que é A
BASE OBRIGATÓRIA para quem vai começar a desenvolver aplicações (tanto
para dispositivos móveis , computadores e etc.).
No dia a dia no computador, sempre estamos utilizando aplicações

(programas) para alguma finalidade (como o Word para digitarmos nossos
trabalhamos, o Excel para criarmos as nossas planilhas eletrônicas e etc.),
assim também como em nossos Smartphones (ou Tablets) estamos utilizando
os aplicativos presentes neles para alguma finalidade (como WhatsApp para
conversarmos com os nossos amigos, o Navegador (como FireFox, Chrome)
para visitarmos a Internet, o Instagram para compartilhar nossas fotos e etc.)
Agora você, em algum momento, já se perguntou alguma vez como foi feito um
programa de computador, esse que você utiliza no computador ou dispositivo
móvel ? Pois bem, para responder essa pergunta precisaremos saber
primeiramente, o que vem a ser ALGORITMOS.
2.1) O que é algoritmo ?
Em algum momento você já teve ter ouvido esse termo na sua vida
(possivelmente na matemática). E ainda existem muitas pessoas que
confundem o termo algoritmo com “logaritmo” (que é totalmente diferente, e
não tem nada a ver com algoritmo).
Para aqueles que já ouviram esse termo na matemática (ou que possivelmente
já usaram), quero esclarecer o seguinte : algoritmo em informática não tem
nada a ver com algoritmo que se ouviu (possivelmente) na matemática, ou
seja, PODEM FICAR TRANQUILOS que ninguém vai fazer cálculos
avançados, nada disso !
Algoritmo NA INFORMÁTICA é muito mais fácil e simples de se compreender.
12
Então, dando continuidade, algoritmos (na informática) nada mais são do que
um conjunto de passos e instruções que precisam ser seguidos para resolver
um determinado problema (ou chegar em algum objetivo).
Por incrível que pareça o significado da palavra ALGORITMO não aplica-se

somente na informática, usamos o algoritmo em nossas vidas diariamente.
Irei dar um exemplo bem prático disso. Vamos supor que você precise sair de
sua casa para ir até a farmácia que se encontra no centro da cidade, até aí
tudo bem. Agora eu pergunto: O que é que você precisa fazer para chegar até
a farmácia no centro da cidade ?
1) Você precisa se vestir

2) Sair de casa
3) Caminhar até o ponto de ônibus (supondo que você não tenha carro)
4) Pegar um ônibus que passe até o centro da cidade
5) Aguardar dentro do ônibus o mesmo chegar até o centro da cidade
6) Saltar do ônibus (quando o mesmo chegar ao centro da cidade)
7) Caminhar até a farmácia
8) Chegar dentro da farmácia
Acabamos de fazer o nosso PRIMEIRO ALGORITMO (da vida real). Que legal!
Como havia falado, o ALGORITMO é tudo aquilo que descreve uma sequência
de como atingir um objetivo (ou resolver um problema). Como podemos
observar a atividade “ir até a farmácia no centro da cidade” ela possui uma
série de passos que são executamos em uma sequência, uma após a outra,
para que o objetivo descrito seja alcançado, logo, REALIZAMOS UM
ALGORITMO.
Uma observação a respeito do ALGORITMO acima : Observem que foram

somente necessários 8 passos para que o objetivo “ir até a farmácia no centro
da cidade” fosse cumprido, porém, o mesmo algoritmo poderia ser feito usando
mais detalhes , que não foram mencionados na versão anterior. Vejamos no
exemplo a seguir o mesmo algoritmo com alguns detalhes (passos) a mais :
13
Algoritmo “ir para a farmácia do centro da cidade” (2ª versão)
1) Você precisa se vestir

2) Pegar as chaves da casa
3) Abrir a porta de casa
4) Sair da casa
5) Fechar a porta da casa
6) Caminhar até o ponto de ônibus (supondo que você não tenha carro)
7) Esperar um ônibus chegar
8) Ao chegar, dar sinal para que ele pare
9) Subir no ônibus
10) Aguardar dentro do ônibus o mesmo chegar até o centro da cidade
11) Saltar do ônibus (quando o mesmo chegar ao centro da cidade)
12) Caminhar até a farmácia
13) Chegar dentro da farmácia
Se observarmos essa nova versão do nosso algoritmo temos agora 13 passos

(diferente dos 8 passos da primeira versão). Agora eu pergunto: Qual versão
do algoritmo é a correta ? É a primeira ou a segunda ?
A resposta é : OS DOIS. Isso mesmo, as duas versões do algoritmo estão

PERFEITAMENTE CORRETAS.
Em ALGORITMOS não importa se você vai gastar 7 , 8, 10, 20 ou 30 passos

pra resolver um problema , e sim que você vai chegar no objetivo (usando 7, 8,
10, 20 ou quantos passos forem necessários).
Agora aplicando o conceito de algoritmos NA INFORMÁTICA, ele seria um

conjunto de instruções que são executados por um programa de computador
(desenvolvidos em linguagens de programação, que veremos mais pela frente),
que realiza tarefas determinadas.
14
Para um exemplo mais prático e dentro da realidade, quando abrimos o nosso
WhatsApp em nosso Smartphone (quando já estamos “logados” nele), ele
mostra a lista de contatos que você possui disponível. Agora a pergunta que
faço é : O que ele executou “por trás" para visualizarmos toda a nossa lista de
contatos ? UM ALGORITMO, ou seja, um conjunto de instruções (passos) para
podermos visualizar todos os contatos na tela do nosso dispositivo.
Mais um exemplo prático dentro da realidade. Quando você dar um duplo

clique no ícone do nosso navegador de Internet (seja ele o Firefox, Chrome e
etc.) no seu computador não é exibido em seguida o mesmo aberto
(normalmente com uma página inicial) ? Então, o que foi executado para que o
navegador fosse carregado : UM ALGORITMO, ou seja, um conjunto de
instruções (passos) para que o navegador fosse exibido na tela.
E ai, está entendo aos poucos o que vem a ser um algoritmo ? Com certeza
que sim! Esse é o TÓPICO MAIS IMPORTANTE que você deve saber para
desenvolver qualquer aplicação que seja (seja para Android ou até para PC).
2.2) O que é linguagem de programação ?
Uma linguagem de programação nada mais é do que um conjunto de regras

sintáticas que devem ser seguidas para que um programa de computador
possa ser construído.
Talvez não tenha ficado claro pra você o termo “regras sintáticas”. O termo
regras sintáticas em linguagem de programação significa que na linguagem de
programação você não pode escrever “qualquer coisa”, se não está errado.
Vejamos um exemplo clássico para demonstrar o que vem a ser linguagem de

programação e suas regras: Imagine que você (que é brasileiro) chegasse
para um turista alemão e perguntasse : Que horas são ?
Ele vai entender o que você disse ? COM CERTEZA NÃO!
15
Então você precisa se comunicar NO IDIOMA DELE (na linguagem dele), ou
seja, se você deseja perguntar que horas são , fale em alemão : “Wie spät ist
es ?”
Com certeza ele irá entender e vai responder (em alemão).
Na informática existem várias linguagens de programação que são utilizadas

para a construção de programas de computador como C#, Java, Delphi,
VB.NET e etc. Como nessa apostila iremos construir aplicações voltadas para
o Android, iremos focar o desenvolvimento na linguagem de programação Java
(que será visto mais pela frente).
2.3) O que é português estruturado (PORTUGOL) ?
Para quem vai começar a programar pela primeira vez, recomenda-se a

linguagem baseada em português estruturado (ou simplesmente PORTUGOL).
O PORTUGOL nada mais é do que uma linguagem de programação que utiliza

comandos e instruções EM PORTUGUÊS, voltados para quem está
começando a aprender a programar com algoritmos.
Existe diferença entre os termos “algoritmo” e “português estruturado” ?

Eu já vi algumas pessoas atribuindo o mesmo significado do termo “algoritmo”
para “português estruturado”. Na verdade é bom saber que existe uma
diferença entre os termos “algoritmo” e “português estruturado” (ou
PORTUGOL se preferirem).
Algoritmo na verdade somente é uma abstração (ou conceito), ou seja,
quando precisamos desenvolver uma série de passos, nos “mentalizamos”
esses passos em nossa cabeça em uma sequência (algoritmo propriamente
dito), para depois “traduzirmos” esses passos para uma linguagem de
programação (como o “português estruturado”), para ser executado pelo
computador para realizar as tarefas. Fica a dica!
16
2.4) Usando o Visualg
Para começarmos nosso primeiro contato com programação com algoritmos

(usando o português estruturado) faremos uso da ferramenta chamada
Visualg, que consiste em um pequeno interpretador de algoritmos baseado em
português estruturado, que executa linha a linha as instruções digitadas nelas.
Para usarmos o Visualg basta você fazer o download dele no seguinte link :
http://goo.gl/LGBCxt
Depois de realizar o download basta descompactar o arquivo “.ZIP” em um

local apropriado e executar o arquivo “Visualg.exe”. Veja o resultado na figura
seguinte :
Ferramenta Visualg
17
2.4.1) Estrutura geral de um ALGORITMO
Vamos ver agora uma visão geral da estrutura básica de uma algoritmo EM
PORTUGOL:
algoritmo "semnome" (1)

// Função :
// Autor :
// Data : 06/12/2014 (2)
// Seção de Declarações
var (3)
inicio (4)
// Seção de Comandos
fimalgoritmo (5)
1) Cabeçalho de declaração : Nesta linha especificamos o nome do nosso

programa, seguindo da seguinte sintaxe :
algoritmo <nome do programa>
2) Comentários : Se lembra que havia falado que em programação não se

pode escrever qualquer coisa ? Pois bem, no algoritmo existe um recurso
chamado comentário onde podemos escrever qualquer coisa referente à uma
observação ou comentário em geral de um comando ou programa. Todo
comentário começa com // (duas barras consecutivas) seguido do que você
gostaria de escrever. Todos os comentários normalmente ficam na cor verde.
3) Seção de declaração de variáveis : Veremos mais a frente.
4) Inicio : Aqui marcamos o início da execução dos comandos do nosso

algoritmo (onde o programa começa).
5) Fim : Aqui marcamos o fim da execução dos comandos do nosso algoritmo

(onde o programa realmente termina).
18
2.4.2) Escrevendo nosso primeiro programa
Com a ferramenta Visualg aberta vamos agora escrever o nosso primeiro

programa (algoritmo) em PORTUGOL.
Antes de entrarmos em detalhes de toda a estrutura geral do código do editor

do Visualg , saiba que os comandos principais do nosso algoritmo são
executados dentro do bloco inicio e fim_algoritmo (destacados em azul
abaixo) , ou seja, na seção de comandos. Veja o código abaixo:
inicio
Fimalgoritmo
Bom, para começarmos vamos criar um pequeno algoritmo em português

estruturado (PORTUGOL) no Visualg que exiba na tela a mensagem “Estou
aprendendo programação”. Tudo bem, mas como eu faço isso ?
O Visualg (assim como no PORTUGOL em geral), existe um pequeno
comando que exibe na tela uma mensagem ou conteúdo qualquer, chamado
escreva, cuja finalidade é mostrar um conteúdo na tela.
Para começarmos vamos colocar o nosso cursor abaixo do comentário
(destacado em verde) , conforme é mostrado na figura seguinte :
Colocar o cursor
aqui
Posicionando o cursor
E em seguida digite o seguinte comando abaixo:
19
Digitando o comando
Terminei. E agora o que eu faço ? Como faço para conferir a execução desse
comando que digitei ?
Para podemos executar o comando que escrevemos basta irmos no menu

“Algoritmo” / “Executar” (ou pressione e tecla “F9”) do Visualg. O resultado
você confere na figura seguinte:
Programa em execução – Exibindo a mensagem na tela
20
Muito bem! Você acaba de construir seu primeiro programa (algoritmo) usando
o PORTUGOL (português estruturado). PARABENS!!!
Acabamos de dar um GRANDE PASSO. Agora vamos dar continuidade aos

nossos passos para que você possa ser tornar UM BOM DESENVOLVEDOR.
Nesse exato momento vamos digitar mais uma linha de código abaixo do que
escrevemos. Para isso, vamos colocar nosso cursor abaixo da instrução que
digitamos anteriormente :
Posicionando o cursor abaixo da instrução anterior
Agora vamos digitar o seguinte comando abaixo , que está destacado :
Digitando o comando
Se executarmos o programa acima (pressionando a tecla “F9”) , teremos o

seguinte resultado:
21
Programa em execução – Ops, algo saiu errado
Se você observar a mensagem acima, ambas as frases sairam coladas uma

com a outra. Ué, mas o ideal não seria que cada frase fosse exibida uma
embaixo da outra ? Sim, seria o esperado, mas, o comando escreva do
Visualg não funciona dessa forma. Para uma melhor compreensão veja a
sequencia da execução do programa abaixo:
Execução da primeira linha (destacado em azul):
inicio
escreva("Estou aprendendo algoritmo ")
fimalgoritmo
Resultado
22
Execução da segunda linha (destacado em azul):
inicio
fimalgoritmo
Resultado
Olhando o algoritmo acima percebemos que as instruções são executadas em

sequencia, ou seja, é executado a primeira instrução, em seguida a segunda
instrução e etc.
Para solucionarmos esse problema basta substituirmos o comando escreva do

Visualg por escreval (isso mesmo escreval, o escreva com a letra “l” (“L” de
Lago) no final do comando). Vejamos o resultado :
Inicio
escreval("Estou aprendendo algoritmo ")
escreval("Estou aprendendo algoritmo ")
fimalgoritmo
Veja o resultado na figura seguinte:
Programa em execução
23
Acabamos de desenvolver mais um algoritmo, que exibe a seguinte mensagem
na tela “Estou aprendendo programação com a Apostila de Android”.
Com isso, podemos chegar a conclusão de que um algoritmo (programa) nada

mais é do que um conjunto de instruções que são executados em uma
sequencia, ou seja, uma instrução após a outra, e cada instrução executada
gera um resultado (como no caso na função escreva e escreval , que mostra
qualquer informação na tela do programa.)
24
Capitulo 3 Gerenciando dados
na memória
A
té agora conseguimos desenvolver programas (algoritmos) que somente
mostram mensagens na tela, porém, sabemos que um programa pode
realizar tarefas muito além do que desenvolvemos até agora. Uma das
tarefas primordiais que são realizadas por qualquer programa de computador e
o gerenciamento de dados em memória. Neste capítulo iremos compreender o
que vem a ser dados e como trabalhar com esses dados usando algoritmos
desenvolvidos para essa finalidade.
Qualquer programa ou aplicativo que utilizamos no dia a dia (seja ele no PC ou

em seu Smartphone ou Tablet) sempre gerencia dados na memória. Vou dar
um exemplo prático para que você possa compreender : Tudo o que a gente
digita no bloco de notas ou no Microsoft Word (antes de salvarmos no HD) fica
guardado na memória do computador (conhecido como memória RAM).
Quando salvamos o que fizemos no editor de texto (quando pressionamos o
CTRL+S ou CTRL+B, como é o caso do Word), tudo o que está na memória
RAM do computador é gravado no nosso HD.
Da mesma forma isso funciona também nos dispositivos móveis, por exemplo :
Quando você está jogando um jogo no Android que registra as pontuações a
media que você vai obtendo os itens (como no jogo “Jetpack joyride”), onde é
que fica guardado aquelas pontuações ? É óbvio, também na memória (do seu
dispositivo).
25
3.1) Como funciona a memória
A memória do nosso computador (ou dispositivo) funciona como se fosse um

armário onde nele existem milhares e milhares de gavetas (endereços), onde
cada uma delas guarda um conjunto de informações. Veja o exemplo nas
figuras em seguida:
MEMÓRIA DO DISPOSITIVO (TABLET)
Endereço 1 Endereço 2 Endereço 9000 Endereço 9001
0279 046 ... 121 000
Demonstração do funcionamento de uma memória
MEMÓRIA DO COMPUTADOR
Olha como as pontuações do jogo ficam na memória
26
Endereço 103 Endereço 104
... Olá, boa tarde !!! 1235 ...
Mais uma demonstração do funcionamento de uma memória
27
3.2) Dados , informações e instruções
Falei aqui nesse capítulo que todo programa de computador está sempre
trabalhando com dados na memória. Agora irei conceituar aqui alguns
conceitos a respeito de dados.
3.2.1) O que é dado ?
Dados (em informática) é tudo aquilo que precisa ser registrado em memória
pelo computador (ou programa) , para que futuramente possa ser processado,
normalmente chamado de elementos de entrada.
3.2.2) O que é informação ?
Informação (em informática) nada mais é do que o dado “processado”, ou seja,

o resultado armazenado em memória, normalmente chamado de elementos de
saída.
Para um exemplo mais prático veja a demonstração de um aplicativo em
Android abaixo:
Entrada
Dado : Número 10
Entrada
Dado : Número 8
Processamento (Gera a média)
Saída
Informação : Média 9
28
Na aplicação da figura anterior temos uma aplicação que consiste em uma
calculadora que realiza a média de dois números.
Observamos que o programa pede que o usuário digite dois números (que
seriam os meus dados). Para que a média seja calculada o botão “Calcular
média” deve ser pressionado, fazendo com que ele efetue o processamento
(ou seja, ele vai somar o primeiro número com o segundo número e depois irá
dividir a soma por 2) , gerando assim a média dos valores (que seria a minha
informação ou saída).
3.2.3) O que é instrução ?
A instrução nada mais é do que os dados que correspondem ao programa que

é carregado na memória. Após o programa ser carregado, o mesmo seja
executado. Veja a ilustração abaixo:
Endereço 1 Endereço 2 Endereço 3 Endereços Endereço 212 Endereço 213

... 3
00FAC01 1100AB39 AA0310B ... 001A00C4 00AAC89

FF C 5 A
Demonstração de um programa carregado na memória
29
MEMÓRIA DO SMARTPHONE
Endereço 1 Endereço 2 Endereço 3 Endereços Endereço 212 Endereço 213

... 3
FFBC00 AA00AA 990010 ... 0F0F012 00EF09
FE AC
Como um programa é carregado na memória do Smartphone
30
3.3) Entrada, processamento e saída de informações
A atividade de um programa de computador (ou do próprio computador em si) é

basicamente três etapas :
Entrada : É tudo aquilo que é fornecido pelo programa (através dele

mesmo ou por algum usuário) que será processado posteriormente.
Como é o caso do programa anterior, que recebeu do usuário dois
números.
Processamento : É tudo o que está relacionado a execução de tarefas,

que consiste em transformar os elementos de entrada em elementos de
saída. Como exemplo temos aquele botão “Calcular média” do programa
anterior, que lê os dois números fornecidos calculando através deles a
minha saída, que é a média.
Saída : É todo o resultado produzido através de um processamento

finalizado, como o caso do programa anterior que após clicarmos no
botão “Calcular média” fornece como resultado a média dos números, que
é exibido na aplicação.
3.4) Variáveis e tipos de dados
Aprendemos que tudo é carregado e gerenciado na memória do computador ,

cada dado e informação são armazenados em endereços ou posições de
memória, ótimo!. Agora, precisamos saber que na programação algumas
coisas possuem nomes “técnicos” (que vamos utilizar daqui por diante ou até
mesmo para sempre, como programadores).
Na programação chamamos posições ou endereços de memória de “variáveis”.

O nome técnico “variável” é utilizado pelo fato do endereço (ou posição) de
memória que guarda alguma informação (ou dado) utilizado por algum
programa ser “variável” , ou seja, pode ser alterado a qualquer momento
durante a execução da aplicação.
31
Na programação, a variável além de representar uma posição na memória
também possui um rótulo (nome) que identifica aquela posição de memória no
computador (ou dispositivo móvel). Veja um exemplo abaixo:
MEMÓRIA DO DISPOSITIVO
Variável Valor
: :
Biscoito
Biscoito Maizena Descrição
Maizena
: :
R$ 240,00 Valor R$ 240,00
: :
: :
Tipo da Despesa Alimentação
: :
Método de Pagamento Dinheiro
: :
Data da Despesa 27/01/13

: :
Banco do
Capital
Brasil
Cada variável assume uma posição na memória, e em cada posição de

memória é guardado um determinado valor, como podemos conferir na
ilustração acima.
32
Cada variável possui os seguintes tipos de dados abaixo:
Inteiro: Esse tipo de dados permite que seja armazenado somente dados
do tipo numérico inteiro (positivos e negativos) . Exemplo : 1, 20,-35,
12499 e etc.
Real: Esse tipo de dados permite que seja armazenado somente dados
do tipo numérico inteiro e fracionários (positivos e negativos) . Exemplo :
10, 0.00321, -1.900121 e etc.
String (ou texto) : Esse tipo de dados permite armazenar dados do tipo
texto (caracteres), podendo ser utilizado números, letras e símbolos.
Exemplo : “Luciano”, “Rua Ribeiro”, “Sou Programador”, “12.201”,
“#FicaDica”, “@apostilaandroid” e etc.
Lógico (ou Booleano) : Esse tipo de dados armazena somente dois

únicos valores, verdadeiro (true) ou falso (false).
3.4.1) Declarando variáveis
Em programação toda variável, antes de ser utilizada, precisa ser declarada

dentro do programa, através do conjunto de instruções destinadas para esse
fim Veremos como fazer isso no Visualg (e futuramente na linguagem Java e
Android) :
Sintaxe:
var
<variável1> : <tipo>
<variável2> : <tipo>
:
<variáveln> : <tipo>
33
Exemplo:
var
nome : caractere
idade : inteiro
tem_habilitacao : lógico
Descrevendo as declarações acima:
Observe que na primeira linha que declarei uma variável (ou seja, reservei um
espaço de memória no meu computador) chamada “nome”, que irá guardar
tudo o que é conteúdo do tipo “texto”. Obviamente, quando declaramos uma
variável chamada “nome”, devemos então armazenar, logicamente, nomes de
pessoas.
Então, quer dizer que se eu guardar qualquer coisa que não seja nome na
variável “nome” vai estar errado (ou o programa vai dar erro) ? Se você acabou
de fazer essa pergunta, fique tranquilo que não está errado e o programa não
irá dar erro nenhum.
Criei uma variável “nome” pois precisarei guardar nomes, mas, se eu

armazenar qualquer coisa dentro da minha variável “nome” como o valor
“1234”, ele irá armazenar o que você digitou sem erros, mas, você não criou a
variável nome pra guardar qualquer coisa não é mesmo ?
Na segunda linha do código declarei uma variável chamada “idade” que irá
armazenar valores do tipo “inteiro”.
Na terceira linha do código declarei uma variável chamada “tem_habilitacao”

que irá armazenar valores do tipo “lógico” (ou booleano).
Vejamos na demonstração a seguir como funciona isso na memória do

computador (ou dispositivo móvel) :
34
Memória
Var
Nome “Lucas”
nome : caractere
idade : inteiro
Idade 19
tem_habilitacao : lógico
tem_habilitacao verdadeiro
3.4.2) Regras para declaração de variáveis
1) Toda variável, quando declarada em um programa, não pode começar

em hipótese alguma com número em seu nome. Por exemplo, se eu
precisa guardar a nota a primeira nota de um aluno, jamais devo criar
uma variável chamada:
Var
1nota : real
ESTÁ ERRADO!!!
O correto seria escrever :
Var
nota1 : real
ESTÁ CORRETO!!!
Na verdade, todo o primeiro caractere do nome da variável jamais

deve ser um número. Do segundo caractere em diante no nome da
variável você pode colocar números ou letras, conforme a
necessidade. Veja alguns exemplos de nomes válidos : nota1, n1,
x90, media3, e etc.
35
2) Toda variável declarada não pode ter “espaço” no nome. Por exemplo
: Vamos supor que você precise declarar uma variável que vai guardar
o nome do aluno. Se você no algoritmo (PORTUGOL) declarar a
variável dessa forma:
var
nome aluno : caractere
ESTÁ ERRADO!!!
Está TOTALMENTE ERRADO. O que você pode resolver essa

situação de duas formas.
Primeiro: Declarar a variável “sem espaço” no nome, conforme
podemos conferir abaixo:
var
nomealuno : caractere
ESTÁ CORRETO!!!
Segundo: Usar o caractere underline “_”, que simula o espaço no

nome de uma variável:
var
nome_aluno : caractere
TAMBÉM ESTÁ CORRETO!!!
36
3) Toda variável declarada não pode ter o mesmo nome de uma palavra
reservada ou comando da linguagem de programação, ou seja, se
declararmos algo do tipo abaixo:
Var
escreva : caractere
ESTÁ ERRADO!!!
Está TOTALMENTE ERRADO. Isso porque escreva já é um comando

da linguagem de programação (do PORTUGOL) e já possui uma
finalidade específica, que é exibir mensagem na tela.
OBS: Nas linguagens de programação (isso você pode notar), toda

palavra reservada ou comando da linguagem fica destacado
(normalmente fica em negrito ou muda de cor ou fica sublinhado).
Basta ficar atento . Veja mais um exemplo de nome inválido para
variável :
var
inicio : caractere
TAMBÉM ESTÁ ERRADO!!!
O inicio é uma palavra reservada na nossa linguagem de

programação (PORTUGOL), que marca o início da execução das
instruções da linguagem, assim como fimalgoritmo que marca o fim do
escopo da execução das instruções do código.
37
4) Toda variável declarada não pode acento, caracteres especiais,
símbolos e etc. Vejamos um exemplo abaixo:
Var
formatação : caractere
ESTÁ ERRADO!!!
Se observamos a variável acima, ela possui um cedilha (“ç”) e uma letra

acentuada (“ã”), que não é permitido na maioria das linguagens de
programação. Evite isso ao máximo. Mais um exemplo :
Var
fone# : caractere
TAMBÉM ESTÁ ERRADO!!!
Se observarmos o nome acima, ele possui um símbolo especial, o símbolo do

“jogo da velha” (#), que também não é permitido em linguagem de
programação.
3.5) Lendo dados via teclado
Como vimos , as variáveis possuem a finalidade de armazenar valores. Agora a

pergunta que eu faço (e que você possivelmente já fez) é : Como eu faço pra
guardar um valor em uma variável ? Existem várias formas, porém, vou
começar com a forma mais básica de todas, onde iremos realizar a leitura de
dados “via teclado”. Com a leitura de dados “via teclado” podemos digitar o que
precisamos guardar no teclado para em seguida guardarmos o que digitamos
em uma variável.
38
Na linguagem de programação em PORTUGOL, existe um comando padrão
para a leitura de dados via teclado, que é o comando leia (presente também no
Visualg ) . Vejamos a sua sintaxe:
Sintaxe:
leia (<variável>)
3.6) Trabalhando com variáveis no Visualg
Com o Visualg aberto vamos escrever um algoritmo (programa em

PORTUGOL) que irá ler do teclado o nome do usuário e ao final , o nosso
programa deverá exibir o nome que foi lido do teclado (e que está armazenado
em uma variável). Eis o código do nosso algoritmo :
algoritmo "Ler nome"

// Função :
// Autor :
// Data : 04/11/2014
var
nome : caractere
inicio
escreva("Digite o seu nome : ")
leia (nome)
escreva ("Seu nome é ", nome)
fimalgoritmo
Ao executarmos o nosso programa, teremos o seguinte resultado:
39
Programa em execução – Aguardando o usuário digitar algo
Se observarmos o programa em execução acima, é mostrado a frase “Digite o

seu nome : ”, com um cursor piscando ao lado da mensagem. Nesse momento
o programa aguarda que você digite alguma coisa, neste caso, um nome.
Experimente digitar um nome e em seguida pressione ENTER. Vejamos o
resultado na figura seguinte:
Programa em execução – Aguardando o usuário digitar algo
40
Entendendo o código
A primeira instrução que é executada é a função escreva, que exibe a

mensagem “Digite o seu nome :”, conforme é destacado abaixo:
:
var
nome : caractere
inicio
leia (nome)
fimalgoritmo
Isso produz o seguinte resultado :
Em seguida, é executada a seguinte instrução :
:
var
nome : caractere
inicio
leia (nome)

fimalgoritmo
41
Que irá interromper a execução do programa, esperando você digitar algo e em
seguida pressionar ENTER. Vamos supor que você digite “Adriano” e em
seguida pressione ENTER, o que acontece ? Quando você PRESSIONA
ENTER , o que você digitou é armazenado dentro da variável que você passou
como parâmetro para a função leia , que neste caso é a variável “nome”. Veja
como acontece o processo:
Pressionou ENTER
Digitou : “Adriano”
MEMÓRIA
Guarda o que eu escrevi Nome
dentro da variável nome
“Adriano”
Em seguida, é executada a próxima instrução :
:
var
nome : caractere
inicio

leia (nome)
fimalgoritmo
42
Que mostra o seguinte resultado abaixo :
Programa em execução – Mostrando o conteúdo guardado na variável
Vamos entender como foi possível ver o conteúdo da variável. No comando

escreva (ou escreval) para visualizarmos o conteúdo de uma variável
devemos colocar a mesma fora das aspas (e separada por virgula, se além da
variável fomos exibir uma mensagem). Veja :
Se por acaso digitarmos o comando acima dessa forma abaixo :
escreva ("Seu nome é nome")
Teríamos o seguinte resultado:
Mostra uma String ao invés do

conteúdo da variável.
43
Desenvolvendo mais um algoritmo
Vamos desenvolver agora mais um algoritmo cujo objetivo é realizar a leitura

do nome e idade de um usuário e , em seguida, exibir as informações lidas na
tela.
Para o exercício acima serão utilizadas duas variáveis : nome (que será do tipo
caractere) e idade (que será do tipo inteiro pois, irá armazenar somente
números).
Eis o código do nosso algoritmo:
algoritmo "Ler nome e idade"

// Função :
// Autor :
// Data : 05/11/2014
var
nome : caractere
idade : inteiro
inicio
escreva("Digite seu nome : ")

leia(nome)
escreva("Digite sua idade : ")
leia(idade)
escreval("Seu nome é : ", nome)

escreval("Seu idade é : ", idade)
fimalgoritmo
Veja o resultado da execução na figura seguinte:
44
Execução PASSO A PASSO
Irei ilustrar aqui a execução passo a passo do nosso programa. Confira :
Inicio
Executando a primeira
instrução
leia(nome)

leia(idade)
45
Inicio

Executando a segunda
leia(nome)
instrução
leia(idade)
Pressionou ENTER
Digitou : “Lucas”
MEMÓRIA
Guarda o que eu escrevi Nome
dentro da variável nome
“Lucas”
46
Inicio
leia(nome)
Executando a terceira
instrução
leia(idade)
:
Executando a quarta
leia(idade)
instrução
Pressionou ENTER
Digitou : 28
MEMÓRIA
Guarda o que eu digitei Idade
na variável idade
28
47
Inicio

leia(nome)
leia(idade)
Executando a quinta
instrução
:
Inicio

leia(nome)
leia(idade)

Executando a sexta e
última instrução
:
48
E ai, está entendendo aos poucos como funciona um programa de computador
e sua execução PASSO A PASSO ? Com certeza que sim.
Aprendemos como definimos um valor para uma variável através do comando

de entrada de dados via teclado, mas, ainda não acabou, existe outro comando
que é muito utilizado para guardar valores em variáveis : O COMANDO DE
ATRIBUIÇÃO.
3.7) O comando de atribuição
O comando de atribuição serve para atribuirmos um valor diretamente à uma

variável, sem necessidade de fazer leitura de dados via teclado e etc. Veja a
sintaxe básica do comando de atribuição.
Sintaxe :
<Variável> <- <Valor>
Exemplo :
Nome <- "Luciano"
No comando acima dizemos que a variável “nome” recebe um conteúdo (no

formato texto), cujo valor é “Luciano”.
Vejamos um exemplo de algoritmo que utiliza o comando de atribuição:
algoritmo "Comando de atribuição"
var
nome : caractere
idade : inteiro
inicio
nome <- "Luciano"
idade <- 29
escreval("Nome : ", nome)
escreval("Idade : ", idade)
fimalgoritmo
49
Vamos conferir a execução passo a passo do nosso algoritmo:
var
nome : caractere
idade : inteiro
inicio Nome Idade
nome <- "Luciano" “Luciano”
idade <- 29
fimalgoritmo
var
nome : caractere
idade : inteiro
inicio Nome Idade
nome <- "Luciano" “Luciano” 29
idade <- 29

fimalgoritmo
50
var
nome : caractere
idade : inteiro
inicio
nome <- "Luciano"

idade <- 29
fimalgoritmo
var
nome : caractere
idade : inteiro
inicio
nome <- "Luciano"

idade <- 29
fimalgoritmo
51
3.8) Operadores aritméticos e expressões
No comando de atribuição utilizamos somente valores únicos, mas, se eu

quisesse atribuir uma expressão ou cálculo, é possível ? Sim , isso é possível
utilizando as expressões e operadores aritméticos. Vejamos na tabela abaixo
os operadores aritméticos permitidos no Visualg (no PORTUGOL de forma
geral):
Operador Descrição
+ Adição
- Subtração
* Multiplicação
/ Divisão
div Divisão inteira
mod Resto de uma divisão inteira
Os operadores div e mod da tabela acima só funciona com números inteiro.
Explicando o DIV e o MOD
O operador DIV é aquele que retorna uma divisão inteira. Por exemplo,
sabemos naturalmente que 5 dividido por 2 dá 2,5 , conforme podemos ver na
expressão abaixo:
5 / 2 = 2,5
Se utilizarmos o operador DIV teremos o seguinte resultado:
5 DIV 2 = 2
O resultado da expressão acima retorna 2 pois, como disse, o DIV retorna uma
divisão inteira , ou seja, ele irá IGNORAR o 0,5 (meio), retornando somente a
parte inteira da divisão.
52
O operador MOD é aquele que retorna o resto da divisão. Por exemplo,
sabemos naturalmente que 5 dividido por 2 dá 2,5 ou melhor, retorna 2 e
SOBRA 1. Veja abaixo:
5| 2
1 2
Se utilizarmos o operador MOD teremos o seguinte resultado:
5 MOD 2 = 1
O resultado da expressão acima retorna 1 pois, como disse, o MOD retorna o

RESTO DA DIVISÃO INTEIRA.
Vejamos um exemplo de algoritmo utilizando operadores aritméticos.
ALGORITMO : Desenvolver um programa EM PORTUGOL que irá ler dois

números inteiros. Em seguida , o programa deverá efetuar a soma dos dois
números , guardando o resultado em uma variável, e no final o programa
deverá exibir a soma obtida na tela.
Como podemos ler no enunciado do exercício, temos um programa que irá

precisar de TRÊS VARIÁVEIS. Duas para guardar cada número lido (do tipo
inteiro) , e outra variável para guardar a soma dos dois números (cada número
armazenado em uma variável) e no final , exibir o conteúdo dessa variável na
tela.
Vamos escrever o código do nosso algoritmo, conforme podemos ver em

seguida:
53
algoritmo "operadores aritmeticos"
var
numero1, numero2 : inteiro

soma : inteiro
inicio
escreva("Digite o primeiro número : ")

leia(numero1)
escreva("Digite o segundo número : ")
leia(numero2)
soma <- numero1 + numero2
escreva("A soma do número é : ", soma)
fimalgoritmo
:
inicio
leia(numero1)
leia(numero2)
Primeira instrução sendo executada.
54
:
inicio
leia(numero1)

leia(numero2)
Segunda instrução sendo executada.
Pressionou ENTER
Digitou : 10
MEMÓRIA
Guarda o que eu digitei numero1
na variável numero1
101
55
:
inicio

leia(numero1)
leia(numero2)
Terceira instrução sendo executada.
:
inicio

leia(numero1)
leia(numero2)
Quarta instrução sendo executada.
Pressionou ENTER
Digitou : 9
56
MEMÓRIA
Guarda o que eu digitei numero2
na variável numero2
9
:
inicio

leia(numero1)
leia(numero2)
escreva("A soma dos números é : ", soma)

Quinta instrução sendo executada.
fimalgoritmo
soma <- 10 + 9
MEMÓRIA
soma
soma <- 19 19
Guarda o valor na variável “soma”
57
inicio

leia(numero1)
leia(numero2)
escreva("A soma dos números é : ", soma)
fimalgoritmo
Última instrução sendo executada.
ALGORITMO : Desenvolver um programa EM PORTUGOL que irá ler dois

números inteiros. Em seguida , o programa deverá calcular a média dos dois
números , guardando o resultado em uma variável, e no final o programa
deverá exibir a média obtida na tela.
Como podemos ler no enunciado do exercício, temos um programa que irá

precisar de TRÊS VARIÁVEIS. Duas para guardar cada número lido (do tipo
inteiro) , e outra variável para guardar a média dos números e no final , exibir o
conteúdo dessa variável na tela.
Vamos escrever o código do nosso algoritmo, conforme podemos ver em

seguida:
58
algoritmo "operadores aritmeticos 2"
var

media : real
inicio

leia(numero1)
leia(numero2)
media <- (numero1 + numero2) / 2
escreva("A média dos números é : ", media)
fimalgoritmo
Vejamos o exemplo da execução do algoritmo acima na figura abaixo:
59
Capitulo 4 Estrutura
condicional
A
prendemos que a execução dos comandos de um programa segue uma
sequencia, como podemos conferir no algoritmo em PORTUGOL. Em
algumas circunstâncias, há algumas instruções que para serem
executadas precisam passar por uma avaliação condicional, ou seja, se uma
condição for satisfeita a instrução será executada, caso contrário não será
executada (ou será executada outra instrução). Para iremos utilizar o que nós
chamamos de estruturas condicionais (ou desvios condicionais).
4.1) A estrutura SE/ ENTÃO
A estrutura SE/ENTÃO executa uma determinada instrução caso a condição

avaliada seja satisfeita, caso contrário nenhuma instrução será executada.
Vejamos a sintaxe da estrutura abaixo:
Sintaxe:
Se (<condição>) Então
<instrução ou comandos a serem executados>
fimse
Exemplo : Vamos construir um algoritmo para ler um número do teclado e em

seguida verificar se ele é maior do que 10. Caso o número seja maior do que
10, mostrar a mensagem “ESSE NÚMERO É MAIOR DO QUE 10”.
Vejamos o código do nosso algoritmo a seguir:
60
algoritmo "estrutura condicional 1"
var
numero : inteiro
inicio
escreva("Digite um número : ")

leia(numero)
se(numero > 10) entao

escreva("Esse número é maior do que 10")
fimse
fimalgoritmo
Irei simular aqui duas execuções PASSO A PASSO do código acima. A

primeira irá considerar o número maior do que 10, a segunda execução será
considerado um número menor do que 10.
PRIMEIRA EXECUÇÃO : CONSIDERANDO O NÚMERO MAIOR QUE 10
inicio
escreva("Digite um número : ") Primeira instrução
leia(numero)

fimse
fimalgoritmo
61
inicio
leia(numero) Segunda instrução

fimse
fimalgoritmo
Pressionou ENTER
Digitou : 15
MEMÓRIA
Guarda o que eu digitei numero
na variável numero
15
62
inicio
leia(numero)
se(numero > 10) entao Terceira instrução

fimse
fimalgoritmo
A estrutura “se” avalia se a condição é verdadeira.

Como a variável “numero” assume o valor 15, e 15
é maior que 10, logo, a condição é verdadeira.
Sendo assim : é executada a instrução abaixo:
leia(numero)
escreva("Esse número é maior do que 10") Quarta instrução
fimse
fimalgoritmo
63
:
leia(numero)

Encerramento a
fimse
estrutura “fim se”
fimalgoritmo
Resultado final na tela :
SEGUNDA EXECUÇÃO : CONSIDERANDO O NÚMERO MENOR QUE 10
inicio
leia(numero)

fimse
fimalgoritmo
64
inicio

fimse
fimalgoritmo
Pressionou ENTER
Digitou : 7
MEMÓRIA
na variável numero
7
65
inicio
:
leia(numero)
se(numero > 10) entao Terceira instrução

fimse
fimalgoritmo
A estrutura “se” avalia se a condição é verdadeira.

Como a variável “numero” assume o valor 7, e 7 é
menor que 10, logo, a condição é falsa, ou seja, a
instrução dentro do “se” será ignorada. Sendo
assim :
leia(numero)

Encerramento a
fimse
estrutura “fim se”
fimalgoritmo
Resultado final na tela :
66
4.2) A estrutura SE/ ENTÃO/SENÃO
A estrutura SE/ENTÃO/SENÃO executa uma determinada instrução caso a

condição avaliada seja satisfeita, e outra instrução caso a condição NÃO SEJA
SATISFEITA. Vejamos a sintaxe da estrutura abaixo:
Sintaxe:
Se (<condição>) Então
<instrução ou comandos a serem executados SE A CONDIÇÃO FOR

VERDADEIRA>
Senão
<instrução ou comandos a serem executados SE A CONDIÇÃO FOR

FALSA>
fimse
Exemplo : Vamos construir um algoritmo para ler a média aritmética do aluno.

Caso a média lida do teclado seja maior ou igual a 7, o aluno está aprovado,
caso contrário o aluno está reprovado.
67
algoritmo "estrutura condicional 2"
var
media : real
inicio
escreva ("Digite a média do aluno : ")

leia(media)
se(media >= 7) entao
escreva("O aluno está aprovado")
senao
escreva("O aluno está reprovado")
fimse
fimalgoritmo
Irei simular aqui duas execuções PASSO A PASSO do código acima. A

primeira irá considerar média maior ou igual a 7, a segunda execução será
considerado uma média menor que 7.
PRIMEIRA EXECUÇÃO : CONSIDERANDO A MÉDIA MAIOR QUE 7
inicio
escreva ("Digite a média do aluno : ") Primeira instrução
leia(media)
68
inicio
leia(media) Segunda instrução
Pressionou ENTER
Digitou : 9
MEMÓRIA
Guarda o que eu digitei media
na variável media
9
69
inicio
leia(media)
se(media >= 7) entao Terceira instrução
A estrutura “se” avalia se a condição é verdadeira. Como a variável

“media” assume o valor 9 e 9 é maior ou igual a 7, a condição é
verdadeira. Sendo assim :
escreva("O aluno está aprovado") Quarta instrução
senao
fimse
70
senao
fimse Fim da estrutura “se”
fimalgoritmo
Resultado final:
SEGUNDA EXECUÇÃO : CONSIDERANDO A MÉDIA MENOR QUE 7
inicio
escreva ("Digite a média do aluno : ") Primeira instrução
leia(media)
71
inicio
leia(media) Segunda instrução
Pressionou ENTER
Digitou : 5
MEMÓRIA
Guarda o que eu digitei media
na variável media
5
72
inicio
leia(media)
se(media >= 7) entao Terceira instrução
A estrutura “se” avalia se a condição é verdadeira. Como a variável

“media” assume o valor 5 e 5 é menor que 7, a condição é falsa. Sendo
assim :
senao
escreva("O aluno está reprovado") Quarta instrução

fimse
73
:
senao
fimse Fim da estrutura “se”
fimalgoritmo
Resultado final:
4.3) Tabela de operadores relacionais
Dentro dos exemplos que desenvolvemos acima envolvendo a estrutura “se”,

utilizamos alguns operadores relacionais. Veja abaixo a lista de operadores
relacionais que podemos utilizar dentro de uma condição:
>= Maior ou igual
> Maior
<= Menor ou igual
< Menor
= Igual
<> Diferente
74
4.4) Operadores lógicos
Nas demonstrações envolvendo as estruturas condicionais “SE/ENTÃO” e

“SE/ENTÃO/SENÃO” trabalhamos sempre com uma condição. Mas, se eu
quisesse dentro de uma condição “se” avalia mais de uma condição (como por
exemplo verificar se um número é maior que 20 e também menor que 90) ?
Para isso utilizamos os operadores lógicos:
O operador lógico E
O operador lógico E é um operador que avalia mais de uma condição

(supondo, por exemplo, duas condições), retornando verdadeiro se todas as
condições avaliadas forem verdadeiras. Veja a tabela abaixo:
Condição 1 Condição 2 Operador E

Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso
Falso Verdadeiro Falso
Falso Falso Falso
O operador lógico OU
O operador lógico OU é um operador que avalia mais de uma condição

(supondo, por exemplo, duas condições), retornando verdadeiro se PELO
MENOS UMA DAS CONDIÇÕES avaliadas for verdadeira. Veja a tabela
abaixo:
Condição 1 Condição 2 Operador OU

Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Falso Falso Falso
75
O operador lógico NÃO
O operador lógico NÃO funciona como um INVERSOR LÓGICO de condições,

retornando verdadeiro se a condição for falso, e falso se a condição for
verdadeira. Veja o exemplo abaixo:
Condição Operador NÃO

Verdadeiro Falso
Falso Verdadeiro
Aplicando os operadores na prática
Exemplo : Vamos construir um algoritmo para ler um número inteiro qualquer, e

verificar se o mesmo é maior ou igual a 10 E menor ou igual a 90. Se a
condição for verdadeira (ou seja, se o número estiver dentro dessa faixa)
mostrar a mensagem “o número está dentro da faixa”, caso contrário mostrar a
seguinte mostrar a mensagem “o número está fora da faixa”.
Segue o código do algoritmo
algoritmo "operador logico 1"
var
numero : inteiro
inicio
leia(numero)
se((numero >= 10) e (numero <= 90)) entao

escreva("O número está dentro da faixa")
senao
escreva("O número está fora da faixa")
fimse
fimalgoritmo
76
Agora irei simular a execução desse programa em duas partes : A primeira irá
considerar o número dentro da faixa, a segunda execução um número fora da
faixa.
PRIMEIRA EXECUÇÃO : CONSIDERANDO O NÚMERO DENTRO DA FAIXA
algoritmo "operador logico 1"
var
numero : inteiro
inicio

leia(numero)
77
inicio

Pressionou ENTER
Digitou : 45
MEMÓRIA
na variável numero
45
78
:
leia(numero)
se((numero >= 10) e (numero <= 90)) entao Terceira instrução

senao
A estrutura “se” avalia se a condição é verdadeira. Como a variável “numero”

assume o valor 45 e 45 está dentro da faixa, a condição será verdadeira. OLHA
COMO A AVALIAÇÃO A FEITA, COM O USO DO OPERADOR “E” :
se((45 >= 10) e (45 <= 90)) entao
se((verdadeiro) e (verdadeiro)) entao
se(verdadeiro) entao
leia(numero)
escreva("O número está dentro da faixa") Quarta instrução

senao
79
SEGUNDA EXECUÇÃO : CONSIDERANDO O NÚMERO FORA DA FAIXA
inicio

leia(numero)
inicio

Pressionou ENTER
Digitou : 5
MEMÓRIA
na variável numero
5
80
:
leia(numero)
se((numero >= 10) e (numero <= 90)) entao Terceira instrução

senao
A estrutura “se” avalia se a condição é verdadeira. Como a variável “numero”

assume o valor 5 e 5 está fora da faixa, a condição será falsa. OLHA COMO A
AVALIAÇÃO A FEITA, COM O USO DO OPERADOR “E” :
se((5 >= 10) e (5 <= 90)) entao
se((falso) e (verdadeiro)) entao
se(falso) entao
:

senao
escreva("O número está fora da faixa") Quarta instrução
81
Exemplo : Vamos construir um algoritmo para ler uma determinada opção
oferecida pelo programa (Opção “a” para “Abrir” e “s” para “Salvar”). Se a
opção lida for válida, mostrar na tela “Opção selecionada válida”, caso contrário
mostrar “Opção inválida”.
Eis o código do nosso algoritmo:
algoritmo "operador lógico 2"
var
opcao : caractere
inicio
escreval("Escolha uma opção")

escreval(" ")
escreval("A - Abrir")
escreval("S - Salvar")
escreval(" ")
escreva("Qual sua opção : ")
leia(opcao)
se((opcao = "A") ou (opcao = "B")) entao

escreva("Opção selecionada válida")
senao
escreva("Opção inválida")
fimse
fimalgoritmo
Executando o nosso programa teremos a seguinte tela abaixo:
82
Quando digitamos uma opção válida (como por exemplo “A”), temos o seguinte
resultado:
Programa em execução – Opção válida
Como funciona a avaliação na estrutura condicional ? Quando digitamos a letra

correspondente a opção, ela fica armazenada dentro da variável opcao. Em
seguida, é executado o seguinte comando :
Sabemos que a variável opcao assume o valor “A”, logo :
se(("A" = "A") ou ("A" = "B")) entao
Isso resultada em :
se((verdadeiro) ou (falso)) entao
Que no final será :
se(verdadeiro) entao
A condição será verdadeira. Logo, será executada a instrução :
83
senao
fimse
fimalgoritmo
Veja o resultado:
Programa em execução – Opção válida
Agora executando novamente a opção , vamos supor que eu agora entre com
a opção “X” (“X” não é uma opção válida). Feito isso, será executada a
seguinte avaliação:
Sabemos que a variável opcao assume o valor “A”, logo :
se(("X" = "A") ou ("X" = "B")) entao
Isso resultada em :
se((falso) ou (falso)) entao
Que no final será :
se(falso) entao
A condição será falsa. Logo, será executada a instrução :
84
senão
fimse
fimalgoritmo
Veja o resultado:
Programa em execução – Opção inválida
Exemplo : Vamos construir um algoritmo para ler um determinado número

inteiro. Se esse número NÃO É MAIOR QUE 10, mostrar a mensagem “esse
número não é maior do que 10”, caso contrário mostrar “Esse número É
MAIOR QUE 10”.
Aqui neste exemplo estaremos agora utilizando o OPERADOR LÓGICO

“NÃO”. Veja o código do nosso programa:
85
algoritmo "operador lógico 3"
var
numero : inteiro
inicio

leia(numero)
se(nao(numero > 10))entao

escreva("Esse número NÃO É MAIOR QUE 10")
senao
escreva("Esse número É MAIOR QUE 10")
fimse
fimalgoritmo
Executando o programa acima teremos a seguinte tela abaixo:
Vamos experimentar digitarmos o número 5. Em seguida será executada a

seguinte avaliação:
Como sabemos que a variável numero assume o valor 5, logo :
se(nao(5 > 10))entao
Como 5 não é maior que 10, teremos como resultado dentro do parênteses :
se(nao(falso))entao
Como o “nao” é um INVERSOR LÓGICO, transformará o falso em verdadeiro.

Veja o resultado:
se(verdadeiro)entao
86
Feito isso será executada a seguinte instrução :
inicio

leia(numero)
senao
:
Que nos dará o seguinte resultado:
Agora, vamos executar novamente nosso programa. Ao ser solicitado o

número, vamos digitar o valor 16 e depois PRESSIONAR ENTER.
Em seguida será executada a seguinte avaliação:
Como sabemos que a variável “numero” assume o valor 5, logo :
se(nao(16 > 10))entao
Como 16 é maior que 10, teremos como resultado dentro do parênteses :
se(nao(verdadeiro))entao
Como o “não” é um INVERSOR LÓGICO, transformará o verdadeiro em falso.

Veja o resultado:
se(falso)entao
87
Feito isso será executada a seguinte instrução :
inicio

leia(numero)
senao
Que nos dará o seguinte resultado:
4.4) A estrutura ESCOLHA/CASO
A estrutura ESCOLHA/CASO é muito utilizada em questões de múltiplas

escolhas, ideal quando temos uma situação quando precisamos escolher
muitas opções (tipo “o” para novo, “a” para “abrir”, “s” para salvar, “i” para
imprimir) e etc. Com a estrutura SE/ENTÃO/SENÃO até é possível fazer isso,
mas com o ESCOLHA/CASO temos uma visão clara e fácil de entendermos o
que vai acontecer.
Veja a sintaxe da estrutura a seguir:
88
escolha(<variável>)
caso <valor1>
<instrucao1>
caso <valor2>
<instrucao2>
caso <valorn>
<instrucaon>
[ outrocaso
<instrução> ]
fimescolha
OBS: A estrutura em negrito na estrutura ESCOLHA/CASO é OPCIONAL, ou

seja, não somos obrigados a colocar aquela instrução. A estrutura em negrito
funciona como se fosse o SENÃO do ESCOLHA/CASO.
Exemplo : Vamos construir um programa que leia uma determinada opção, do

conjunto de opções oferecidas abaixo:
O – Novo
A – Abrir
S – Salvar
I – Imprimir
X – Sair
Caso o usuário digite uma das letras acima, mostrar a operação associada a
ela, caso contrário, mostrar “OPÇÃO INVÁLIDA”.
89
algoritmo "estrutura escolha/caso"
var
opcao : caractere
inicio
escreval("Escolha uma das opções abaixo")

escreval(" ")
escreval("O - Novo")
escreval("A - Abrir")
escreval("S - Salvar")
escreval("I - Imprimir")
escreval("X - Sair")
escreval(" ")
leia(opcao)
escolha(opcao)
caso "O"
escreva("Você escolheu NOVO")
caso "A"
escreva("Você escolheu ABRIR")
caso "S"
escreva("Você escolheu SALVAR")
caso "I"
escreva("Você escolheu IMPRIMIR")
caso "X"
escreva("Você escolheu SAIR")
outrocaso
escreva("OPÇÃO INVÁLIDA!!!")
fimescolha
fimalgoritmo
Executando o nosso programa teremos o seguinte resultado:
90
Vamos supor que como opção você digite “S” e em seguida PRESSIONE
ENTER. Na instrução seguinte será executada a seguinte avaliação:
:
escreval(" ")
leia(opcao)
escolha(opcao)
caso "O"
caso "A"
Que verifica qual opção foi selecionada, que neste caso foi a opção “S”. Sendo
assim, será avaliada e executada a instrução a seguir:
:
caso "O"
caso "A"
escreva("Você escolheu ABRIR")
caso "S"
escreva("Você escolheu SALVAR")
91
Veja o resultado na figura abaixo:
Agora executando novamente o programa vamos supor que como opção você
digite “Y”, e em seguida PRESSIONE ENTER. Ao fazer isso será executada a
seguinte avaliação :
:
escreval(" ")
leia(opcao)
escolha(opcao)
caso "O"
caso "A"
Que verifica qual opção foi selecionada, que neste caso foi a opção “Y”. Sendo
assim, como não existe nenhuma opção com “Y” será executado o seguinte
bloco:
:
caso "X"
escreva("Você escolheu SAIR")
outrocaso
fimescolha
92
Veja o resultado na figura abaixo:
E ai, está aprendendo aos poucos como se constrói um programa de

computador ? Com certeza que sim.
Pra você que deve estar entusiasmado com o que está aprendendo,
possivelmente já quer pular para o desenvolvimento com Android, mas
CALMA! Ainda temos muito que aprender para nos tornarmos bons
desenvolvedores de aplicações Android. Até aqui já foi um GRANDE PASSO
que demos, mais ainda temos que caminhar. Estamos chegando lá.
93
Capitulo 5 Estrutura de
repetição
A
té agora aprendemos a desenvolver programas que executam
instruções seguindo uma determinada sequência de passos (e alguns
passos para serem executados precisavam passar por uma avaliação
condicional).
Em algumas circunstâncias no nosso programa é preciso que uma determinada

instrução ou bloco de código seja executado mais de uma vez (como 5, 10,
1000 vezes e por ai vai). Como é possível realizar essa tarefa ? Através do uso
das estruturas de repetição (ou loops de repetição).
5.1) A estrutura de repetição ENQUANTO
A estrutura de repetição ENQUANTO repete um bloco de código enquanto uma

determinada condição for satisfeita (na verdade, verdadeira). Enquanto for
verdadeira, o bloco de códigos (ou a instrução) dentro da estrutura de repetição
ENQUANTO será executada sempre. No momento em que a condição da
estrutura de repetição ENQUANTO não for mais satisfeita (ou seja, for falsa), o
bloco de comandos dentro da estrutura não será mais executado.
Veja a sintaxe da estrutura abaixo:
enquanto (<condição>) faca
<bloco de comandos>
fimenquanto
Vamos fazer uma simulação onde eu tenha que imprimir valores na tela de 1
até 5, sabendo que os valores estarão armazenados em uma variável, sem
usar nenhum loop de repetição. Eis o código:
94
algoritmo "imprime na tela sem loop"
var
n : inteiro
inicio
n <- 1
escreval("Valor de n é ", n)
n <- n + 1
n <- n + 1
n <- n + 1
n <- n + 1
fimalgoritmo
Vamos conferir agora a execução passo a passo :
var
n : inteiro
inicio
MEMÓRIA
n
n <- 1
1
var
n : inteiro
inicio
n <- 1
95
var
n : inteiro
inicio
Incrementa o valor atual MEMÓRIA
:
de “n” com mais 1
n
n <- n + 1
2
var
n : inteiro
inicio
n <- n + 1
var
n : inteiro
inicio
:
n
n <- n + 1
3
:
inicio
n <- n + 1
96
var
n : inteiro
inicio
:
n
n <- n + 1
4
:
inicio
n <- n + 1
var
n : inteiro
inicio
:
n
n <- n + 1
5
97
var
n : inteiro
inicio
:
n <- n + 1
fimalgoritmo
98
Agora vamos desenvolver agora um algoritmo em PORTUGOL no Visualg que
utilize o loop de repetição ENQUANTO. Eis o código :
algoritmo "imprime na tela com loop"
var
n : inteiro
inicio
n <- 1
enquanto (n <= 5) faca
n <- n + 1
fimenquanto
fimalgoritmo
Vamos entender agora na execução PASSO A PASSO como funciona o loop

de repetição ENQUANTO.
var
n : inteiro
inicio MEMÓRIA
n
n <- 1 Primeira instrução
1
n <- n + 1
fimenquanto
fimalgoritmo
99
var
n : inteiro
inicio
n <- 1
enquanto (n <= 5) faca Segunda instrução
n <- n + 1
fimenquanto
fimalgoritmo
O loop ENQUANTO acima avalia se o valor

de “n” é menor ou igual a 5. Como a
condição acima é verdadeira, é executado a
próxima instrução
var
n : inteiro
inicio
n <- 1
escreval("Valor de n é ", n) Terceira instrução

n <- n + 1
fimenquanto
fimalgoritmo
100
var
n : inteiro
inicio
n <- 1

escreval("Valor de n é ", n) MEMÓRIA
n
n <- n + 1 Quarta instrução
2
fimenquanto
fimalgoritmo
var
n : inteiro
inicio
n <- 1

n <- n + 1 Quinta instrução. Fim da estrutura do loop.

Olha só o que acontece quando chegamos no
fimenquanto final da estrutura.
fimalgoritmo
Vejam só, voltamos de novo para o

: inicio do loop. Aqui perguntamos
n : inteiro novamente se “n” é menor ou igual
inicio a cinco. Como a condição é
n <- 1
verdadeira, entramos novamente
dentro do loop, executando os
enquanto (n <= 5) faca comandos dentro dele.
101
var
n : inteiro
inicio
n <- 1
escreval("Valor de n é ", n) Terceira instrução, pela

n <- n + 1 segunda vez.
fimenquanto
fimalgoritmo
var
n : inteiro
inicio
n <- 1

n
n <- n + 1 Quarta instrução,
pela segunda vez 3
fimenquanto
fimalgoritmo
102
var
n : inteiro
inicio
n <- 1

n <- n + 1 Quinta instrução, pela segunda vez. Fim da

estrutura do loop. Olha só o que acontece
fimenquanto novamente quando chegamos no final da
fimalgoritmo estrutura.
De novo voltamos para o início do

: loop. Aqui perguntamos novamente
n : inteiro se “n” é menor ou igual a cinco.
inicio Como a condição é verdadeira (pois
n <- 1
“n” é igual a 3), entraremos
novamente dentro do loop,
enquanto (n <= 5) faca executando os comandos dentro
dele.
:

n <- n + 1 terceira vez.
fimenquanto
fimalgoritmo
103
var
n : inteiro
inicio
n <- 1

n
pela terceira vez 4
fimenquanto
fimalgoritmo
var
n : inteiro
inicio
n <- 1

n <- n + 1 Quinta instrução, pela terceira vez. Fim da

estrutura do loop. Novamente, voltando para a
fimenquanto estrutura inicial do loop.
fimalgoritmo
Início do loop. Aqui perguntamos

novamente se “n” é menor ou igual
: a cinco. Como a condição é
n : inteiro
inicio
verdadeira (pois “n” é igual a 4),
entraremos novamente dentro do
n <- 1 loop:
104
var
n : inteiro
inicio
n <- 1

n <- n + 1 quarta vez.
fimenquanto
fimalgoritmo
var
n : inteiro
inicio
n <- 1

n
pela quarta vez 5
fimenquanto
fimalgoritmo
105
var
n : inteiro
inicio
n <- 1

n <- n + 1 Quinta instrução, pela quarta vez. Fim da

fimalgoritmo

: a cinco. Como a condição é
n : inteiro
inicio
verdadeira (pois “n” é igual a 5),
entraremos novamente dentro do
n <- 1 loop:

n <- n + 1 quinta vez.
fimenquanto
fimalgoritmo
106
var
n : inteiro
inicio
n <- 1

n
pela quinta vez 6
fimenquanto
fimalgoritmo
var
n : inteiro
inicio
n <- 1

n <- n + 1 Quinta instrução, pela quinta vez. Fim da

fimalgoritmo

: a cinco. AGORA A CONDIÇÃO
n : inteiro
inicio
TORNA-SE FALSA (pois “n” é igual a
6), logo, É ENCERRADO A EXECUÇÃO
n <- 1 DO LOOP.
107
Resultado final na tela:
5.2) A estrutura de repetição REPEITA/ATÉ
A estrutura de repetição REPITA/ATÉ repete um bloco de código até uma

determinada condição seja satisfeita (verdadeira) , ou seja, repete enquanto a
condição for falsa. Veja a sintaxe da estrutura abaixo:
repita
<bloco de comandos>
ate(<condição>)
Vamos desenvolver agora o mesmo exercício do loop anterior (ENQUANTO),

usando a estrutura REPITA/ATE. Eis o código :
algoritmo "loop repita/ate"
var
n : inteiro
inicio
n <- 1
repita
n <- n + 1
ate (n > 5)
fimalgoritmo
108
Executando o código anterior teremos o mesmo resultado do programa
anterior:
A execução passo a passo desse loop é similar ao do loop ENQUANTO. Para

acompanhar o passo a passo da execução desde loop, basta ir pressionando a
tecla F8.
5.3) A estrutura de repetição PARA/FAÇA
A estrutura de repetição PARA/FAÇA repete um determinado bloco de código

em um determinado número de vezes que você determinar na estrutura do
loop, ou seja, você pode determinar que um bloco de código repita 5 vezes, 6
vezes, 7 vezes e etc. Vejamos a sintaxe abaixo:
para <variável> de <valor inicial> ate <valor final> faça
<bloco de comandos>
fimpara
Se observarmos a estrutura acima, não existe uma condição maior que, menor
que e etc. O que existe é que o loop vai começar a repetir partindo de um valor
inicial “X” (que será armazenado em uma variável de controle) até um valor
final “Y”.
109
Vamos desenvolver agora o mesmo exercício do loop anterior (REPITA/ATE),
usando a estrutura PARA/FACA. A diferença desse exercício para os outros é
que só iremos repetir um bloco de comandos por três vezes (diferente de cinco
dos exercícios anteriores). Eis o código:
algoritmo "loop para/faca"
var
n : inteiro
inicio
para n de 1 ate 3 faca
escreval("O valor de n é ",n)
fimpara
fimalgoritmo
Para esse loop irei mostrar o PASSO A PASSO da execução, pois esse loop
merece um pouco de atenção.
var
n : inteiro MEMÓRIA
inicio
n
1
fimpara
Essa é a primeira instrução do nosso
fimalgoritmo programa, onde nela inicializamos o loop
PARA/FACA. A primeira que realizamos
quando o loop é executado pela primeira
vez é atribuir o valor inicial para a
variável de controle “n”, que no caso
será o valor 1.
110
var
n : inteiro Segunda instrução
inicio
fimpara
fimalgoritmo
var
n : inteiro
inicio
fimpara Terceira instrução, fim do loop PARA. Voltando

para o início do loop.
fimalgoritmo
var
n : inteiro
inicio
MEMÓRIA
Quando voltamos para o início do loop n
PARA, ele efetua automaticamente o 2
incremento da variável, ou seja, a
variável passa a assumir o valor “2”.
111
var
n : inteiro Segunda instrução,
inicio
pela segunda vez
fimpara
fimalgoritmo
var
n : inteiro
inicio
fimpara Terceira instrução pela segunda vez, fim do loop

PARA. Voltando para o início do loop.
fimalgoritmo
var
n : inteiro
inicio
MEMÓRIA
Quando voltamos para o início do loop n
PARA, ele efetua automaticamente o 3
incremento da variável, ou seja, a
variável passa a assumir o valor “3”.
112
var
n : inteiro Segunda instrução,
inicio
pela terceira vez
fimpara
fimalgoritmo
var
n : inteiro
inicio
fimpara Terceira instrução pela terceira vez, fim do loop

PARA. AQUI JÁ É ENCERRADO O LOOP.
fimalgoritmo
113
5.4) Observações a respeito dos loops de repetição
Se observarmos os loops de repetição que utilizamos nas demonstrações

realizadas anteriormente, os loops ENQUANTO e REPITA/ATE , repetem um
bloco de comandos enquanto as condições forem satisfatórias, ou seja, os
blocos de comandos dentro da estrutura do loop podem repetir 10, 100, 1000,
10000 vezes, se a condição para repetir a estrutura do loop for satisfeita.
Quando a condição não for mais satisfeita, o loop encerra a execução.
No loop de repetição ENQUANTO a avaliação é feita no INICIO DO LOOP, ou

seja, se ao executarmos o loop de repetição, já na avaliação, a condição não
for satisfeita, o loop NEM EXECUTA.
No loop de repetição REPEITA/ATE a avaliação é feita no FIM DO LOOP, ou

seja, caso exista a condição para o encerramento do loop, o mesmo será
executado PELO MENOS UMA VEZ.
No loop PARA/FACA já definimos quantas vezes um determinado bloco de

comandos será executado, ou seja, já existe um número certo de quantas
vezes precisaremos executar uma instrução (através da informação dos
valores iniciais e finais).
Se observarmos os loops utilizados, para as estruturas ENQUANTO e

REPITA/ATE é necessário a execução de uma instrução que possa mudar o
resultado da avaliação, na próxima leitura da condição (caso contrário, teremos
o que chamados de LOOP INFITIO, ou seja, UM LOOP QUE NÃO TERMINA
NUNCA). Já no caso do PARA/FACA, o valor da variável de controle já é
mudado automaticamente na estrutura do loop, sem a necessidade de uma
instrução para tal tarefa.
114
Capitulo 6 Trabalhando com
Vetores
A
té agora desenvolvemos programas (algoritmos) que são capazes de
armazenar informações na memória, porém, com uma quantidade de
dados bastante limitada (como por exemplo, gravar somente um nome,
duas notas, três médias e etc.) Porém, se eu quisesse agora guardar uma
quantidade bem grande de informações (considerando todas elas de um
mesmo tipo), como por exemplo : armazenar o nome de todos os 100
funcionários, armazenar a média de todos os 200 alunos. Para isso, faremos
uso de uma estrutura de dados conhecida como vetor (ou array).
Um vetor nada mais é do que uma variável (estrutura) que é capaz de

armazenar várias informações de um mesmo tipo, e cada informação
armazenada dentro do vetor é acessado através do seu índice. Veja a sintaxe
de um vetor abaixo:
var
<variável> : vetor[<limite>] de <tipo de dados>
Exemplo : Vamos supor que eu precise criar um programa que leia do teclado 3
nomes de alunos, e ao final o mesmo programa mostre os nomes lidos na tela.
Na primeira demonstração irei efetuar a leitura dos dados SEM USAR VETOR,
usando somente a técnica que aprendemos até agora.
Eis o código:
algoritmo "leitura de dados sem vetor"
var
nome1 : caractere
nome2 : caractere
nome3 : caractere
115
inicio
escreva("Digite o primeiro nome : ")

leia(nome1)
escreva("Digite o segunda nome : ")
leia(nome2)
escreva("Digite o terceiro nome : ")
leia(nome3)
escreval("Primeiro nome : ", nome1)
escreval("Segundo nome : ", nome2)
escreval("Terceiro nome : ", nome3)
fimalgoritmo
Executando nosso programa acima, vamos digitar os seguintes nomes:
Primeiro nome : Aline

Segundo nome : Bruno
Terceiro nome : Carlos
Feito isso teremos o seguinte resultado:
Programa em execução – Nomes lidos
116
Observarmos no código acima que cada variável guarda um nome (nome1
guarda o valor “Aline”, nome2 guarda o valor “Bruno” e nome3 guarda o valor
“Carlos”).
Agora vamos realizar o mesmo exemplo acima utilizando um vetor para

guardar os três nomes. Eis o código :
algoritmo "leitura de dados com vetor"
var
nome : vetor[1..3] de caractere

inicio
escreva("Digite o primeiro nome : ")

leia(nome[1])
escreva("Digite o segunda nome : ")

leia(nome[2])
escreva("Digite o terceiro nome : ")

leia(nome[3])
escreval("Primeiro nome : ", nome[1])

escreval("Segundo nome : ", nome[2])
escreval("Terceiro nome : ", nome[3])
fimalgoritmo
Se executarmos o nosso programa acima iremos ter o mesmo funcionamento

do programa anterior.
Se observarmos o código declaramos uma variável do tipo vetor de caracteres

com 3 posições, ou seja, em cada posição da nossa variável podemos
armazenar e guardar um conjunto de caracteres.
117
Porém, podemos dar uma melhorada em nosso código do programa acima,
utilizando como recurso a estrutura de repetição para diminuirmos o nosso
programa. Veja o resultado abaixo:
algoritmo "leitura de dados com vetor 2"
var

contador : inteiro
inicio
para contador de 1 ate 3 faca

escreva("Digite o ",contador," nome : ")
leia(nome[contador])
fimpara

escreval("O ",contador," nome e : ", nome[contador])
fimpara
fimalgoritmo
Execute o programa do código acima e também teremos o mesmo

funcionamento do algoritmo anterior.
Ah, se lembra que eu havia falado lá no início do nosso aprendizado a respeito

de algoritmos que não importa se um algoritmo tiver 5, 8, 10, 15 passos para
chegar em um objetivo, e que o importante é que ele cumpra a sua tarefa ?
Pois bem, está aqui um exemplo prática em PORTUGOL de três algoritmos
escritos de formas diferentes realizando a mesma tarefa.
118
Para melhor entendimento do código anterior usando loop de repetição, irei
simular a execução dele aqui nesse material a partir de agora.
MEMÓRIA
algoritmo "leitura de dados com vetor 2"
contador
var
1
contador : inteiro
inicio
para contador de 1 ate 3 faca Primeira instrução. Aqui

iniciamos o loop PARA,
atribuindo um valor inicial para
leia(nome[contador]) “contador”.
fimpara
:
inicio
escreva("Digite o ",contador," nome : ") Segunda instrução.
fimpara
:
Como “contador” assume “1”, logo :
escreva(“Digite o 1 nome” )
119
:
inicio
leia(nome[contador]) Terceira instrução.
fimpara
:
Pressionou ENTER
Digitou : “Aline”
MEMÓRIA
Guarda o que eu digitei nome
no vetor nome , na
“Aline” 1
primeira posição
2
120
:
inicio
Fim do loop PARA. Voltando
fimpara
agora para o início do loop.
inicio
Incrementa o valor de
“contator”.
MEMÓRIA
contador
121
:
inicio

Segunda instrução,
pela segunda vez.


Terceira instrução,
pela segunda vez.
fimpara
Pressionou ENTER
Digitou : “Bruno”
MEMÓRIA
no vetor nome , na
“Aline” 1
segunda posição
“Bruno” 2
122
:
inicio
Fim do loop PARA. Voltando
fimpara
agora para o início do loop.
inicio
Incrementa o valor de
“contator”.
MEMÓRIA
contador
123
:
inicio

Segunda instrução,
pela terceira vez.

:

Terceira instrução,
pela terceira vez.
fimpara
Pressionou ENTER
Digitou : “Carlos”
MEMÓRIA
no vetor nome , na
“Aline” 1
terceira posição
“Bruno” 2
“Carlos” 3
124
:
inicio
Fim do loop PARA.
fimpara
ENCERRAMOS POR AQUI.
:
inicio

fimpara

escreval("O ",contador," nome e : ", nome[contador])
fimpara
fimalgoritmo
Executando o loop destacado acima, teremos o seguinte resultado:
125
E ai, entendeu para que serve e como funciona um vetor ? Com certeza que
sim.
No momento só cadastramos três nomes na memória do computador, algo

simples de se fazer (tanto usando ou não vetores). Agora supondo que
utilizemos a forma de programação tradicional sem vetores, imagine que você
tenha que construir um programa para cadastrar 9 nomes. Como seria o nosso
código ? Veja abaixo:
algoritmo "cadastro 10 nomes sem vetores"
var
nome1, nome2, nome3, nome4, nome5, nome6, nome7,
nome8,nome9: caractere
inicio
escreva("Digite o 1 nome : ")
leia(nome1)
leia(nome2)
leia(nome3)
leia(nome4)
leia(nome5)
leia(nome6)
leia(nome7)
leia(nome8)
leia(nome9)
escreval("O 1 nome e : ",nome1)
fimalgoritmo
126
Se observarmos o código do programa anterior , ele é bastante grande
(imagine se tivéssemos que cadastrar 50 nomes ?). Agora vamos ver o mesmo
programa acima utilizando o recurso dos vetores.
algoritmo "cadastrando 10 nomes com vetor"
var
nome : vetor [1..10] de caractere
contador : inteiro
inicio

fimpara

escreval("O ",contador," nome e : ",nome[contador])
fimpara
fimalgoritmo
Executando o código acima teremos o mesmo comportamento do nosso

programa anterior.
E ai, aprendeu como se utiliza os vetores e para que serve eles ? Com certeza
que sim. Até aqui aprendemos os conceitos essenciais do desenvolvimento de
algoritmos, mas, ainda não acabou. Temos ainda muito pela frente.
127
Capitulo 7 Trabalhando com
Sub-rotinas
E
m alguns momentos durante o desenvolvimento do nosso programa
(algoritmo) precisaremos desenvolver códigos que envolvem uma certa
quantidade de linhas de comandos para realizar uma tarefa (por
exemplo, 10 linhas de código), até ai tudo bem. Agora , vamos supor que você
precise realizar essa mesma tarefa em vários pontos diferentes do seu
programa, será que eu vou ter que digitar novamente essas mesmas linhas de
código ? Para isso existe o que chamamos de sub-rotinas.
7.1) O que é uma sub-rotina ?
Uma sub-rotina nada mais é do que um bloco de código que é executado no

ponto em que o mesmo é chamado no programa. Cada sub-rotina possui um
nome e um bloco de comandos associados a ele.
Para compreendermos melhor o que vem a ser uma sub-rotina irei desenvolver
um exemplo onde mostrar todos os números entre 1 e 10. Vejamos abaixo um
código em PORTUGOL, sem o uso de sub-rotina :
algoritmo "mostra de 1 ate 10"
var
contador : inteiro
inicio
escreval("Mostrando todos os números entre 1 e 10")
escreval(contador)
fimpara
fimalgoritmo
128
Muito bem, o código do nosso programa anterior irá mostrar todos os números
entre 1 e 10. Agora , se essa atividade tivesse que se repetir várias e várias
vezes em pontos diferentes do meu programa ? Será que teriamos que
escrever o loop de repetição várias vezes , como podemos ver no código
abaixo ?
algoritmo "mostra de 1 ate 10"
var
contador : inteiro
inicio
escreval(contador)
fimpara

escreval(contador)
fimpara

escreval(contador)
fimpara

escreval(contador)
fimpara

escreval(contador)
fimpara
fimalgoritmo
Com certeza que não. Para isso devemos utilizar as sub-rotinas. Vejamos o
mesmo exemplo que desenvolvemos anteriormente, só que usando uma sub-
rotina própria para isso. Veja o código a seguir :
129
algoritmo "mostra de 1 ate 10 usando rotina"
procedimento Mostrar1Ate10()
var
contador : inteiro
inicio
escreval(contador)
fimpara
fimprocedimento
inicio
Mostrar1Ate10()
fimalgoritmo
Se executarmos o código acima, teremos o mesmo resultado do primeiro

código deste capitulo. Para melhor compreensão da execução de uma sub-
rotina, acompanhe a simulação da execução do código acima a seguir :
var
contador : inteiro
inicio
para contador de 1 ate 10 faca Primeira instrução.
escreval(contador)
fimpara
fimprocedimento
inicio
Mostrar1Ate10()
fimalgoritmo
130
var
contador : inteiro
inicio
escreval(contador)
fimpara
fimprocedimento
inicio
Mostrar1Ate10() Segunda instrução. Aqui temos uma sub-

Fimalgoritmo
rotina (também conhecida como
procedimento) chamada
“Mostrar1Ate10”. Nesse ponto ocorre
um desvio para o local onde se encontra
o procedimento. Veja só :
var
contador : inteiro
inicio
para contador de 1 ate 10 facaChegamos na estrutura do procedimento
escreval(contador) “Mostrar1Ate10”, cuja função é mostrar
fimpara
os números de 1 até 10. Vamos continuar
fimprocedimento
a sua execução:
:
var
contador : inteiro
inicio
Início da execução do
para contador de 1 ate 10 faca procedimento :
escreval(contador)
fimpara
131
var
contador : inteiro
inicio
para contador de 1 ate 10 faca Loop de repetição. Esse bloco

escreval(contador) destacado depois de
fimpara processado nos trará o
fimprocedimento seguinte resultado:
var
contador : inteiro
inicio

escreval(contador) Fim da execução do
fimpara procedimento. O que
acontece agora ? Acompanhe
fimprocedimento
a seta abaixo:
:
inicio
Voltamos para o ponto onde a
sub-rotina
escreval("Mostrando todos os números entrefoi
1 e chamada
10") para
continuarmos com o fluxo normal
Mostrar1Ate10()
Fimalgoritmo do programa.
132
inicio
Mostrar1Ate10()
Fim da execução do nosso
fimalgoritmo
algoritmo.
A princípio vimos como utilizar a rotina desenvolvida onde ocorre uma única
chamada dela no código. Se houvesse várias chamadas daquela tarefa
(mostrar todos os números entre 1 até 10) em pontos diferentes, agora usando
uma rotina, olha como seria mais fácil a compreensão do código :
var
contador : inteiro
inicio
escreval(contador)
fimpara
fimprocedimento
inicio
Mostrar1Ate10()
Mostrar1Ate10()
Mostrar1Ate10()
:
Mostrar1Ate10()
Mostrar1Ate10()
:
fimalgoritmo
Viu como se torna mais fácil ?
133
7.2) O que é procedimento ?
Um procedimento nada mais é do que uma sub-rotina, que foi o que utilizamos
agora pouco, que executa um bloco de código no ponto em que ele é chamado
(posso dizer que procedimento nada mais é do que outro nome que atribuímos
a sub-rotina). Vejamos a sintaxe da declaração do procedimento :
Sintaxe :
procedimento <nome do procedimento> (<parâmetros, se houver>)
[ var
<variavel1>,<variável2>,...,<variáveln> : <tipo>
]
inicio
<bloco de comandos>
fimprocedimento
OBS: Na sintaxe da declaração do procedimento acima, tudo o que estiver em

negrito e também em colchetes, significa que é “opcional”, ou seja, não
somos obrigados a declarar.
Vamos agora criar um algoritmo EM PORTUGOL que irá possuir uma rotina
para mostrar a mensagem “ESTOU APRENDENDO PROGRAMAÇÃO PARA
ANDROID”. Eis o código :
algoritmo "rotina mostrar mensagem"
procedimento MostrarMensagem()
inicio
escreval("ESTOU APRENDENDO PROGRAMAÇÃO PARA ANDROID")
fimprocedimento
inicio
escreval("Minha mensagem : ")
MostrarMensagem()
escreval("FIM...")
fimalgoritmo
134
Executando o programa do código anterior teremos o seguinte resultado:
Para reforçar novamente o entendimento do fluxo da execução do

procedimento, novamente irei mostrar aqui a execução PASSO A PASSO do
nosso código. Veja :
inicio
fimprocedimento
inicio
escreval("Minha mensagem : ") Primeira instrução:
MostrarMensagem()
escreval("FIM...")
fimalgoritmo
135
inicio
fimprocedimento
inicio
MostrarMensagem() Segunda instrução. Chamada

para o procedimento
escreval("FIM...")
“MostrarMensagem”.
fimalgoritmo
inicio
fimprocedimento
inicio Chegamos no procedimento

“MostrarMensagem”. Agora vamos
executá-lo.
inicio
fimprocedimento
inicio
Bloco “inicio” da nossa rotina.
136
inicio
fimprocedimento
Mostrando a mensagem na tela.
inicio
inicio
fimprocedimento Fim do procedimento. Voltando para o

ponto de chamada.
:
inicio
fimprocedimento
inicio

Nesse ponto volto a seguir o
MostrarMensagem() fluxo normal de execução do
algoritmo.
escreval("FIM...")
fimalgoritmo
137
inicio
fimprocedimento
inicio
MostrarMensagem()
escreval("FIM...") Mostra na tela a palavra “FIM”.
fimalgoritmo
inicio
fimprocedimento
inicio
MostrarMensagem()
escreval("FIM...")
fimalgoritmo Fim do programa.
138
7.3) O que é são parâmetros ?
Parâmetros nada mais são do que valores que são passados para as sub-
rotinas para a realização de algum processamento.
Vejamos abaixo a sintaxe da passagem de parâmetros (ou argumentos) para o

procedimento :
Sintaxe :
procedimento <nome da rotina>(<variável1> : <tipo>,...,<variáveln> :

<tipo>)
inicio
<bloco de comandos>
fimprocedimento
Para demonstrar o uso de parâmetros vamos criar um algoritmo para ler dois
números inteiros. Após a leitura dos números chamar uma rotina chamada
“Somar” para efetuar a soma dos dois números pelo teclado (passando os
mesmos via parâmetro na rotina). Eis o código :
algoritmo "rotina somar"
procedimento Somar(n1 : inteiro ; n2: inteiro)

var
s : inteiro
inicio
s <- n1 + n2
escreval("A soma é : ", s)
fimprocedimento
var
inicio
escreval("Digite o primeiro número : ")

leia(numero1)
escreval("Digite o segundo número : ")
leia(numero2)
Somar(numero1,numero2)
fimalgoritmo
139
Para a melhor compreensão do programa acima, irei simular a execução do
código :
var
inicio
leia(numero1)
leia(numero2) Primeira instrução.
fimalgoritmo

:
var
inicio
leia(numero1)
MEMÓRIA
escreval("Digite o segundo número : ") numero1
leia(numero2)
Somar(numero1,numero2) 9
fimalgoritmo
Segunda instrução. Vamos

nesse comando de leitura
digitar o número 9.
140
:
inicio

leia(numero1)
leia(numero2)
Terceira instrução.
fimalgoritmo

:
var
inicio
leia(numero1)
MEMÓRIA
leia(numero2) numero2
6
fimalgoritmo
Quarta instrução. Vamos

141
:
var
inicio
leia(numero1)
leia(numero2)
fimalgoritmo
Quinta instrução. Chamando a rotina “Somar”, passando como

parâmetro os dois números lidos do teclado.

var
s : inteiro
inicio
s <- n1 + n2
fimprocedimento
MEMÓRIA
Aqui chegamos na rotina “Somar”, n1 n2

recebendo como argumento os 9 6
números lidos do teclado.
142
var
s : inteiro
inicio Início do procedimento.
s <- n1 + n2

fimprocedimento
var
s : inteiro
inicio
Efetua a soma de “n1” com “n2”
s <- n1 + n2
e armazena o resultado em “s”
fimprocedimento
MEMÓRIA
S=9+6 s
S = 15 15
143
var
s : inteiro
inicio
s <- n1 + n2
escreval("A soma é : ", s) Mostra a soma na tela
fimprocedimento

:
s <- n1 + n2
fimprocedimento Fim do procedimento. Voltando

para o ponto de chamada.
:
inicio
leia(numero1)
leia(numero2)
Agora a gente segue o fluxo
normal do programa.
fimalgoritmo
144
7.4) O que é são funções ?
Uma função nada mais é do que um procedimento, cuja particularidade é a

capacidade de retornar um valor no ponto em que ele é chamado no programa.
Vejamos a sintaxe abaixo da declaração de uma função.
Sintaxe:
funcao <nome da função>(<parâmetros se houver>) : <tipo>
[ var
<variavel1>,<variável2>,...,<variáveln> : <tipo>
]
inicio
<bloco de comandos>
retorne <valor>
fimfuncao
OBS: Na sintaxe da declaração do procedimento acima, tudo o que estiver em

negrito e também em colchetes, significa que é “opcional”, ou seja, não
somos obrigados a declarar.
Para demonstrar o uso de funções vamos criar uma função chamada Somar
(como o do exemplo anterior), só que ao invés da função mostrar na tela a
soma dos números, ela irá “retornar” o valor da soma para uma variável. Eis o
código :
145
algoritmo "função somar"
funcao Somar(n1 : inteiro ; n2: inteiro) : inteiro

var
s : inteiro
inicio
s <- n1 + n2
retorne s
fimfuncao
var
resultado : inteiro
inicio

leia(numero1)
leia(numero2)
resultado <- Somar(numero1,numero2)
escreva("A soma é : ", resultado)
fimalgoritmo
Agora irei simular a execução desse algoritmo para entendermos como

funciona uma função. Acompanhe :
var
resultado : inteiro
inicio
leia(numero1)
leia(numero2)
:
Primeira instrução.
fimalgoritmo
146
:
var
resultado : inteiro
inicio
leia(numero1)
MEMÓRIA
escreval("Digite o segundo número : ") numero1
leia(numero2)
: 9
fimalgoritmo
Segunda instrução. Vamos


resultado : inteiro
inicio

leia(numero1)
leia(numero2)
Terceira instrução.
fimalgoritmo
147
:
var
resultado : inteiro
inicio
leia(numero1) MEMÓRIA
numero2
leia(numero2)
6

:
fimalgoritmo
Quarta instrução. Vamos


:
var
inicio
:
leia(numero2)

fimalgoritmo
Se observarmos a linha destacada EM PRETO acima

temos a atribuição de uma função (DESTACADA EM
VERDE) à uma variável. Uma função , como havia falado,
retorna um valor, porém, é preciso que a função processe
toda a sua execução para que ela possa retornar o valor
para a variável. Logo, vamos chamar a nossa função:
148
var
s : inteiro
inicio
MEMÓRIA
s <- n1 + n2
Aqui chegamos na função “Somar”, n1 n2
retorne s
recebendo como argumento os 9 6
números lidos do teclado.
fimfuncao
var
s : inteiro
inicio Início da função.
s <- n1 + n2
retorne s
fimfuncao
função Somar(n1 : inteiro ; n2: inteiro) : inteiro
var
s : inteiro
inicio
Efetua a soma de “n1” com “n2”
s <- n1 + n2
e armazena o resultado em “s”
retorne s
fimfuncao
MEMÓRIA
S=9+6 s
S = 15 15
149
função Somar(n1 : inteiro ; n2: inteiro) : inteiro
var
s : inteiro
inicio
s <- n1 + n2
Aqui nesta linha a função retorna
retorne s ,no ponto em que ela foi
chamada, o valor contido em “s”.
fimfuncao
Veja :

:
var
inicio
:
leia(numero2)

fimalgoritmo
MEMÓRIA
resultado
resultado <- 15
15
150
:
var
inicio
:
leia(numero2)

Mostrando o resultado
na tela.
fimalgoritmo
E ai, aprendeu como se utiliza uma função e sua finalidade ? Com certeza que
sim. Agora irei enfatizar algumas observações importantes que preciso falar a
respeito de procedimentos e funções à respeito das variáveis.
7.5) Variáveis locais e variáveis globais
Todos os programas que desenvolvemos até agora sempre trabalharam com

variáveis, até ai tudo bem. Porém, quando trabalhamos com procedimentos e
funções em um programa precisaremos saber e distinguir o que são variáveis
globais e locais e quando criar elas.
O que é uma variável global ?
Desde quando aprendemos a criar e utilizar variáveis, sempre trabalhamos

com variáveis globais. Uma variável global nada mais é do que uma variável
que é vista e enxergada por TODO O PROGRAMA (incluindo procedimentos e
funções).
151
O que é uma variável local ?
Uma variável local é aquela que é declarada e enxergada dentro do

procedimento ou função em que a mesma foi declara, existindo somente
durante a execução da rotina.
Vejamos o código de um algoritmo abaixo:
algoritmo "codigo fonte" Variável global “varGlobal”. Ela é considera

var
global pois foi declarada dentro da clausula
“var” e fora dos procedimento e funções e
varGlobal : inteiro é enxergada por todo o programa.
procedimento MostraSoma(n : inteiro)

var
somaProc : inteiro Variável local “somaProc”. Ela é
considera local pois foi declarada dentro
inicio
do procedimento “MostraSoma” e só é
somaProc <- varGlobal + n enxergada dentro da rotina, nunca fora
escreval(somaProc) dela.
fimprocedimento
funcao funcaoSoma(n : inteiro) : inteiro

var
somaFuncao : inteiro Parâmetro das rotinas (variável ”n”)
também são considerados variáveis
inicio
locais.
somaFuncao <- varGlobal + n
retorne somaFuncao
fimfuncao Variável local “somaFuncao”. Ela é

considera local pois foi declarada dentro
inicio
da função “funcaoSoma” e só é
varGlobal<-5 enxergada dentro da rotina, nunca fora
MostraSoma(12) dela.
escreval(funcaoSoma(7))
fimalgoritmo
152
Muito bem, até aqui concluímos uma etapa muito importante em nosso
aprendizado : A programação com algoritmos (que é a base para tudo).
Aprendemos técnicas essenciais a respeito sobre programação com algoritmos
(usando o português estruturado ou PORTUGOL), que será de grande
importância para o desenvolvimento de aplicações para a plataforma Android
(ou para qualquer outro segmento como PC, WEB e etc.).
153
Capitulo 8 Lista de exercícios
de algoritmos.
N
este capitulo iremos realizar uma série de exercícios a respeito de
programação com algoritmos que aprendemos até agora para reforçar
o nosso aprendizado. Os exercícios estarão dividido em categorias, de
forma a facilitar o aprendizado. Alguns exercícios já estarão resolvidos e outros
você terá que desenvolver. Bom sorte.
8.1) Programação Sequencial
Exercício 1 : Desenvolver um algoritmo para mostrar na tela a seguinte

mensagem : “ESSE É O MEU PRIMEIRO EXERCÍCIO”.
algoritmo "8.1) Exercício 1"
inicio
escreva("ESSE É O MEU PRIMEIRO EXERCÍCIO")
fimalgoritmo
Exercício 2 : Desenvolver um algoritmo para mostrar na tela a seguinte

mensagem : “EU SOU PROGRAMADOR”.
inicio
escreva("EU SOU PROGRAMADOR")
fimalgoritmo
154
Exercício 3 : Desenvolver um algoritmo para mostrar na tela a seguinte frase
popular :
“Os professores abrem a porta,

mas você deve entrar por você mesmo.”.
inicio
escreval("Os professores abrem a porta,")

escreval("mas você deve entrar por você mesmo...")
fimalgoritmo
Exercício 4 [RESOLVER]: Desenvolver um algoritmo para mostrar na tela a

seguinte frase popular :
“Um momento de paciência pode evitar um grande desastre,

Um momento de impaciência pode arruinar toda uma vida”.

“A informática esta interligada ao mundo

sobre as reações intergalaxias!
Bill Gates”
155
8.2) Variáveis
Exercício 1 : Desenvolver um algoritmo que leia do teclado duas notas de um

aluno. Ao final, o programa deverá mostrar a média das duas notas na tela:
var
nota1, nota2, media : real
inicio
escreva("Digite a primeira nota : ")

leia(nota1)
escreva("Digite a segunda nota : ")
leia(nota2)
media <- (nota1 + nota2) / 2
escreva("A média é ", media)
fimalgoritmo
Exercício 2 : Desenvolver um algoritmo que leia do teclado o salário base de

um funcionário. Com o salário base , calcule :
Vale transporte : salario base * 6%

INSS : salario base * 8%
Salário Líquido : salário base - vale transporte – INSS
Ao final, mostrar o salário líquido do funcionário:
var
salario_base, vale_transporte, inss, salario_liquido : real
inicio
escreva("Digite o salario base do funcionarío : ")

leia(salario_base)
vale_transporte <- salario_base * 0.06
inss <- salario_base * 0.08
salario_liquido <- salario_base - vale_transporte - inss
escreva("O salario liquido do funcionário é : ",salario_liquido)
fimalgoritmo
156
Exercício 3 : Desenvolver um algoritmo que leia do teclado uma temperatura
em Celsius. Em seguida , a temperatura deverá ser convertida para Fahrenheit.
A fórmula de conversão é : F = C * 1,8 + 32. No final, o programa deverá
mostrar a temperatura convertida para Fahrenheit:
var
celsius, fahrenheit : real
inicio
escreva("Digite a temperatura em Celsius : ")

leia(celsius)
fahrenheit <- celsius * 1.8 + 32
escreva("A temperatura convertida em Fahrenheit é : ",fahrenheit)
fimalgoritmo
Exercício 4 [RESOLVER]: Desenvolver um algoritmo que leia do teclado uma

temperatura em Celsius. Em seguida , a temperatura deverá ser convertida
para Kelvin. A fórmula de conversão é K = C + 273,15. No final, o programa
deverá mostrar a temperatura convertida para Kelvin:
Exercício 5 [RESOLVER]: Desenvolver um algoritmo que obtenha a área de

um triângulo. Para isso será necessária a leitura via teclado da base e da altura
do triângulo. A fórmula para obter a área do triângulo é : área = (base * altura) /
2. Ao final o programa deverá mostrar a área do triângulo na tela.
Exercício 6 [RESOLVER]: Desenvolver um algoritmo que leia do teclado o

preço de um produto e a quantidade a ser levada dele. Ao final o programa
deverá mostrar o valor total a ser pago.
157
8.3) Estrutura condicional
Exercício 1 : Desenvolver um algoritmo que leia do teclado o nome do aluno e

a sua média aritmética. Ao final o programa deverá mostrar o nome do aluno e
sua situação (se ele foi “aprovado” , caso a média dele seja maior ou igual a 7,
ou “reprovado”, se a média for menor que 7).
var
nome : caractere
media : real
inicio
escreva("Digite o nome do aluno : ")

leia(nome)
escreva("Média do aluno : ")

leia(media)

escreva("O aluno ",nome," está APROVADO")
senao
escreva("O aluno ",nome," está REPROVADO")
fimse
fimalgoritmo

sua situação :
“APROVADO”, Caso a média seja >= 7

“RECUPERAÇÃO”, Caso a média seja < 7 e maior ou igual que 4
“REPROVADO”, Caso a média seja < 4
158
var
nome : caractere
media : real
inicio
escreva("Digite o nome do aluno : ")

leia(nome)
escreva("Média do aluno : ")

leia(media)
//Se a média for maior ou igual a 7, o aluno está APROVADO

se(media >= 7) então
escreva("O aluno ",nome," está APROVADO")
senão
//Aqui já sabemos que a média é menor que 7 (não precisamos

//perguntar isso novamente)
//vamos ver se pelo menos a média é maior ou igual a 4, PARA QUE
//ELE FIQUE EM RECUPERAÇÃO
se(media >= 4) então
escreva("O aluno ",nome," está EM RECUPERAÇÃO")
senão
//Aqui já sabemos que a média é menor que 4, logo...ele ESTÁ

//REPROVADO
escreva("O aluno ",nome," está REPROVADO")
fimse
fimse
fimalgoritmo
159
Exercício 3 : Desenvolver um algoritmo que leia do teclado dois números
inteiros A e B. Após a leitura verificar se B e maior A, caso verdadeiro, exibir os
números nessa ordem : A, B. Caso B seja menor que A mostrar os números
nessa ordem : B, A.
var
a,b : inteiro
inicio
escreva("Digite o valor de A : ")

leia(a)
escreva("Digite o valor de B : ")
leia(b)
se(b > a) entao

escreval("Os números são : ", a," , ",b)
senao
escreval("Os números são : ", b," , ",a)
fimse
fimalgoritmo
Exercício 4 : Desenvolver um algoritmo que leia do teclado o salário de um

funcionário. Após a leitura calcular o novo salário do funcionário mediante as
seguintes condições abaixo:
Se salário <= 500 , novo salário = salario + 20%

Se salário > 500 e < 1000 , novo salário = salario + 15%
Se salário > 1000 , novo salário = salario + 10%
160
var
salario, novo_salario : real
inicio
escreva("Digite o salario do funcionário : ")

leia(salario)
se(salario <= 500) entao
novo_salario <- salario * 1.20
senao
se(salario <= 1000) entao
senao
fimse
fimse
escreva("O novo salário é : ",novo_salario)
fimalgoritmo
Exercício 5 : Desenvolver um algoritmo que leia uma temperatura em Celsius.

Em seguida, o programa deverá mostrar duas opções para o usuário , em que
o usuário deverá digitar 1 para converter a temperatura em Fahrenheit e 2 para
Kelvin. Escolhida a opção desejada, realizar a conversão da temperatura e ao
final mostrar o resultado.
161
var
celsius, temp : real
opcao : inteiro
inicio
escreva("Digite a temperatura em celsius : ")

leia(celsius)
escreval("Escolha a opção")
escreval("[1] - Converter para Fahrenheit")
escreval("[2] - Converter para Kelvin")
escreval(" ")
leia(opcao)
se(opcao = 1) entao
temp <- celsius * 1.8 + 32
escreva("A temperatura em Fahrenheit é : ",temp)
senao
temp <- celsius + 273,15
escreva("A temperatura em Kelvin é : ",temp)
fimse
fimalgoritmo
Exercício 6 : Desenvolver um algoritmo que leia a idade de um nadador e em

seguida, mostre a sua classificação, conforme podemos conferir abaixo:
infantil A = 5 - 7 anos
infantil B = 8-10 anos
juvenil A = 11-13 anos
juvenil B = 14-17 anos
adulto = maiores de 18 anos
162
var
idade : inteiro
inicio
escreva("Digite a idade do nadador: ")

leia(idade)
se((idade >= 5) e (idade <= 7)) entao

escreval("Classificação : INFANTIL A")
senao
se(idade <= 10) entao

escreval("Classificação : INFANTIL B")
senao

escreval("Classificação : JUVENIL A")
senao

escreval("Classificação : JUVENIL B")
senao
escreval("Classificação : ADULTO")
fimse
fimse
fimse
fimse
fimalgoritmo
163
sexo do usuário (“M” para masculino e “F” para feminino) e sua altura.
Obtido os dados, calcule e mostre o peso ideal desse usuário. Veja o
cálculo do peso ideal abaixo:
Peso ideal de homem = (72,7 x altura) - 58

Peso ideal da mulher = (62,1 x altura) - 44,7
Exercício 7 [RESOLVER]: Uma lanchonete vende os seus produtos, de

acordo com a tabela abaixo :
Código Item Preço

100 Cachorro Quente 1,10
101 Bauru Simples 1,30
102 Bauru com Ovo 1,55
103 Hambúrguer 1,20
Desenvolver um algoritmo que leia do teclado o código do item a ser

comprado e a sua quantidade. Ao final o programa deverá mostrar o valor
total da compra.
Exercício 8 [RESOLVER]: Desenvolver um algoritmo que leia do teclado dois

números inteiros A e B . Se o número A for maior que (B * 2), dividir o valor de
B com A e jogar o resultado em uma variável X. Se a condição for falsa,
multiplicar o valor de A com o valor de B e em seguida jogar o resultado em
uma variável X. Ao final deverá ser mostrado o valor contido em X.

salário base de um funcionário e o número de filhos que ele possui. Ao final o
programa deverá calcular e mostrar o valor do “Salário Família”, de acordo com
a tabela abaixo:
Condição Item
Salario Família = Nº Filhos *
Salário Base < 530
24,64
Salário Base < 810
19,48
Salário Base > 810 Salário Família = 0
164
8.4) Estrutura de repetição
Exercício 1 : Desenvolver um algoritmo que mostre todos os números entre 1

e 50 (usando o loop ENQUANTO).
var
contador : inteiro
inicio
contador <- 1
enquanto (contador <= 50) faca

escreval(contador)
contador <- contador + 1
fimenquanto
fimalgoritmo

e 50 (usando o loop REPITA).
var
contador : inteiro
inicio
contador <- 1
repita
escreval(contador)
ate(contador > 50)
fimalgoritmo
165
e 50 (usando o loop PARA).
var
contador : inteiro
inicio

escreval(contador)
fimpara
fimalgoritmo
Exercício 4 : Desenvolver um algoritmo que some todos os números entre 10

e 30 (usando loop PARA).
var
contador : inteiro
soma : inteiro
inicio
//Como iremos armazenar a soma dos números, a variável "soma"

//deverá começar com ZERO
soma <- 0
soma <- soma + contador
fimpara
escreva("A soma dos números entre 10 e 30 é : ",soma)
fimalgoritmo
166
Exercício 5 : Desenvolver um algoritmo que some e mostre :
Todos os números entre 10 e 50 (incluído pares e impares)

Todos os números pares somente entre 10 e 50
Todos os números impares somente entre 10 e 50
OBS : Usando o loop REPITA/ATE:
var
contador : inteiro
soma_todos : inteiro
soma_pares : inteiro
soma_impares : inteiro
inicio
//Como iremos armazenar a soma dos números, todas as variáveis de

//"soma" deverão começar com ZERO
soma_todos <- 0
soma_impares <- 0
soma_pares <- 0
soma_todos <- soma_todos + contador
//É um número par ?

se((contador mod 2) = 0) entao
soma_pares <- soma_pares + contador
senao
soma_impares <- soma_impares + contador
fimse
fimpara
escreval("A soma de todos números entre 10 e 50 é : ",soma_todos)

escreval("A soma dos números pares entre 10 e 50 é : ",soma_pares)
escreval("A soma dos números impares entre 10 e 50 é : "
,soma_impares)
fimalgoritmo
167
Exercício 6 : Desenvolver um algoritmo que leia um número inteiro “n”. Ao
final o programa deverá mostrar todos os números impares e pares entre 1 e
“n” (usar loop ENQUANTO).
var
contador : inteiro
n : inteiro
inicio

soma_impares <- 0
soma_pares <- 0
escreva("Digite um número inteiro qualquer : ")

leia(n)
contador <- 1
enquanto (contador <= n) faca
se((contador mod 2) = 0) entao

soma_pares <- soma_pares + contador
senao
soma_impares <- soma_impares + contador
fimse
fimenquanto
escreval("A soma dos números pares entre 1 e ",n,

" é : ",soma_pares)
escreval("A soma dos números impares entre 1 e ",n,
" é : ",soma_impares)
Fimalgoritmo
168
Exercício 7 : Desenvolver um algoritmo que leia do teclado 10 números
inteiros do teclado. Ao final o programa deverá mostrar o total de números
pares e impares lidos, como também a soma de todos os números impares e
pares lidos do teclado (usar loop PARA).
var
contador : inteiro
n : inteiro
conta_par : inteiro
conta_impar : inteiro
inicio

soma_impares <- 0
soma_pares <- 0
//Como iremos efetuar uma contagem nos números, todas as variáveis

//de "contagem" deverão começar com ZERO
conta_par <- 0
conta_impar <- 0
escreva("Digite o ",contador," número inteiro: ")

leia(n)
se((n mod 2) = 0) entao

soma_pares <- soma_pares + n
conta_par <- conta_par + 1
senao
soma_impares <- soma_impares + n
conta_impar <- conta_impar + 1
fimse
fimpara
escreval("O total de números pares lidos é : ",conta_par)

escreval("O total de números impares lidos é : ",conta_impar)
escreval("A soma dos números pares lidos é : ",soma_pares)
escreval("A soma dos números impares lidos é : ",soma_impares)
fimalgoritmo
169
Exercício 8 : Desenvolver um algoritmo que leia um número inteiro do teclado.
Em seguida o programa deverá calcular e retornar o fatorial do número lido.
Veja um exemplo abaixo do que seria um fatorial :
Fatorial do número 5 (5!) = 5 * 4 * 3 * 2 * 1 = 120

Fatorial do número 6 (6!) = 6 * 5 * 4 * 3 * 2 * 1 = 720
var
numero : inteiro
contador : inteiro
fatorial : inteiro
inicio
//Como o fatorial consiste no acumulo de várias multiplicações (e

//não soma)devemos iniciar a variável que irá armazenar o fatorial
//com o valor 1.
fatorial <- 1
escreva("Digite um numero inteiro qualquer : ")

leia(numero)
para contador de 1 ate numero faca

fatorial <- fatorial * contador
fimpara
escreva("O fatorial de ",numero," e : ",fatorial)
fimalgoritmo
170
Exercício 9 : Desenvolver um algoritmo que leia dois números inteiros do
teclado. Em seguida, o programa deverá mostrar uma lista de opção para
usuário referente a operação aritmética.
[1] – Para adição

[2] – Para subtração
[3] – Multiplicação
[4] – Divisão
Escolhendo uma das opções acima, mostrar o resultado da operação aritmética

escolhida . Ao final, o programa deverá perguntar ao usuário se ele deseja
continuar a fazer as contas ou não (respondendo “S” para continuar ou “N” para
sair).
var
numero1,numero2 : inteiro
resultado : real
opcao_aritmetica : inteiro
resposta : caractere
inicio
//Como o programa irá ocorrer dentro do loop

//iniciar variável de resposta com o valor "S"
resposta <- "S"
enquanto resposta = "S" faca

//Comando do Visualg que limpa a tela do programa
limpatela()
escreva("Digite o primeiro numero : ")
leia(numero1)
escreva("Digite o segundo numero : ")
leia(numero2)
escreval("Escolha a sua opção")

escreval("[1] - Adição")
escreval("[2] - Subtração")
escreval("[3] - Multiplicação")
escreval("[4] - Divisão")
escreval(" ")
leia(opcao_aritmetica)
171
escolha(opcao_aritmetica)
caso 1
resultado <- numero1 + numero2
caso 2
resultado <- numero1 - numero2
caso 3
resultado <- numero1 * numero2
caso 4
resultado <- numero1 / numero2
fimescolha
escreval("O resultado é : ",resultado)

escreval(" ")
escreva("Deseja continuar ? [S/N] : ")
leia(resposta)
fimenquanto
fimalgoritmo
Exercício 10 [RESOLVER]: Desenvolver um algoritmo que leia um número

inteiro do teclado, e ao final mostrar a tabuada do número lido (de 1 até 10) .
(usar o loop REPITA/ATE)

inteiro X e um outro número inteiro Y. Ao final o programa deverá calcular e
mostrar o resultado da potência XY . (usar o loop PARA)
Veja um exemplo de potência :
23 = 2 * 2 * 2 = 8

inteiro “n” qualquer. Ao final o programa deverá efetuar o seguinte calculo :
1 / 1 + 1 / 2 + 1/3 + 1/4 ......1/n.
Após o cálculo da expressão acima, mostrar o resultado na tela (usar o loop

ENQUANTO).
172
8.5) Vetores
Exercício 1 : Desenvolver um algoritmo para ler 10 números do teclado e

armazena cada número lido dentro do vetor. Em seguida, pegar cada número
armazenado dentro do vetor e fazer a seguinte operação :
Se numero for par , multiplicar o mesmo por 2, atualizando no vetor

Se numero for impar, multiplicar o mesmo ele por 3, atualizando no vetor
Ao final, mostrar o conteúdo do vetor na tela.
var
numeros : vetor[1..10] de inteiro
contador : inteiro
inicio
//Primeiro, armazenar todos os números lidos no vetor

escreva("Digite o ",contador," numero : ")
leia(numeros[contador])
fimpara
//Agora, efetuar o calculo seguindo o critério

//Se numero for par , multiplicar por 2
//Se numero for impar, multiplicar por 3
se((numeros[contador] mod 2) = 0) entao
numeros[contador] <- numeros[contador] * 2
senao
numeros[contador] <- numeros[contador] * 3
fimse
fimpara
//Agora, mostrar o conteúdo do vetor na tela

escreval(numeros[contador])
fimpara
fimalgoritmo
173
armazenar cada número lido dentro de um vetor. Em seguida, mostrar o
conteúdo do vetor na ordem INVERSA da leitura.
var
numeros : vetor[1..10] de inteiro
contador : inteiro
inicio
//Primeiro, armazenar todos os números lidos no vetor

escreva("Digite o ",contador," numero : ")
leia(numeros[contador])
fimpara
//Agora, mostrar o conteúdo do vetor na tela

para contador de 10 ate 1 passo -1 faca
escreval(numeros[contador])
fimpara
fimalgoritmo

armazenar cada número lido dentro do vetor A. Criar um vetor B que irá conter
todos os números presentes do vetor A multiplicados por 3, ou seja :
B[índice] = A[índice] * 3
Ao final o programa deverá apresentar todos os números presentes dentro do

vetor B.
var
A,B : vetor[1..10] de inteiro
contador : inteiro
inicio
escreva("Digite o ",contador," numero para o vetor A: ")
leia(A[contador])
B[contador] <- A[contador] * 3
fimpara
174
escreval("O ",contador," valor do vetor B é : ",B[contador])
fimpara
fimalgoritmo
Exercício 4 : Desenvolver um algoritmo para ler 20 nomes de alunos e suas

respectivas médias, sabendo que os nomes estarão armazenados em um vetor
e as médias dos alunos em outro vetor. Ao final o programa deverá mostrar na
tela o nome do aluno, sua média e sua situação (de acordo com a tabela
abaixo):
Condição Média
Média >= 7 APROVADO
Média >= 5 e Média < 7 RECUPERAÇÃO
Média < 5 REPROVADO
var
media : vetor[1..10] de real
contador : inteiro
inicio

escreva("Digite o nome do ",contador," aluno :")
escreva("Digite a média do ",contador," aluno :")
leia(media[contador])
fimpara

escreva("Nome : ",nome[contador],", Média : ",media[contador],
" ")
se(media[contador] >= 7) entao
escreval(", você está APROVADO")
senao
se(media[contador] >= 5) entao
escreval(", você está RECUPERAÇÃO")
senao
175
escreval(", você está REPROVADO")
fimse
fimse
fimpara
fimalgoritmo
Exercício 5 : Desenvolver um algoritmo para ler 20 nomes do teclado, sabendo

que esses nomes estarão armazenadas em um vetor. Em seguida, o programa
deverá ordenar o vetor de forma que os nomes estejam em ORDEM
CRESCENTE. No final o programa deverá mostrar os nomes ordenados na
tela.
var
temp : caractere
i, j : inteiro
inicio
para i de 1 ate 10 faca

escreva("Digite o ",i," nome :")
leia(nome[i])
fimpara
//Loop que ordenará os nomes EM ORDEM CRESCENTE

para j de (i + 1) ate 10 faca

//Verifica se os nomes estão desordenados
se(nome[i] > nome[j]) entao
//Ordena os nomes em ordem crescente
temp <- nome[i]
nome[i] <- nome[j]
nome[j] <- temp
fimse
fimpara
fimpara

escreval("O ",i," nome é :", nome[i])
fimpara
fimalgoritmo
176
Exercício 6 [RESOLVER]: Desenvolver um algoritmo para ler 20 nomes do
teclado, sabendo que esses nomes estarão armazenadas em um vetor. Em
seguida, o programa deverá ordenar o vetor de forma que os nomes estejam
em ORDEM DECRESCENTE. No final o programa deverá mostrar os nomes
ordenados na tela.
Exercício 7 [RESOLVER]: Desenvolver um algoritmo para ler 20 nomes de

funcionários e seus respectivos salários. Em seguida, o programa deverá
mostrar o nome do funcionário e seu salário reajustado de acordo com a tabela
abaixo :
Condição Média
Salario < 500 Reajuste = Salario 20%
Salario >= 500 Salario < 900 Reajuste = Salario 15%
Salário >= 900 Reajuste = Salario 10%
Exercício 8 [RESOLVER]: Desenvolver um algoritmo para preencher dois

vetores A e B, ambos com 10 posições, com valores numéricos inteiros. Criar
um vetor C que irá conter a soma dos valores dos vetores A e B, ou seja :
C[índice] = A[índice] + B[índice]
Ao final o programa deverá mostrar o conteúdo do vetor C na tela.
177
8.6) Sub-rotinas
Exercício 1 : Crie um procedimento que calcule e mostre o fatorial de um

número inteiro qualquer lido do teclado.
procedimento fatorial(n : inteiro)

var
i : inteiro
fat : inteiro
inicio
fat <- 1
para i de 1 ate n faca
fat <- fat * i
fimpara
escreva("O fatorial de ",n," é : ", fat)
fimprocedimento
var
numero : inteiro
inicio
escreva("Digite um numero inteiro : ")
leia(numero)
fatorial(numero)
fimalgoritmo
Exercício 2 : Crie uma função que calcule o fatorial de um número inteiro

qualquer lido do teclado. Ao final mostrar o fatorial do número lido na tela.
funcao fatorial(n : inteiro) : inteiro

var
i : inteiro
fat : inteiro
inicio
fat <- 1
para i de 1 ate n faca
fat <- fat * i
fimpara
retorne fat
fimfuncao
178
var
numero : inteiro
resultado : inteiro
inicio
escreva("Digite um numero inteiro : ")
leia(numero)
resultado <- fatorial(numero)
escreva("O fatorial do numero ",numero," é : ",resultado)
fimalgoritmo
Exercício 3 : Crie uma função parar converte uma temperatura em Celsius

(lida do teclado) em Fahrenheit. Ao final o programa deverá mostrar a
temperatura convertida na tela.
funcao converteFahrenheit(c : real) : real

inicio
retorne (c * 1.8) + 32
fimfuncao
var
celsius : real
temp_fahrenheit : real
inicio
escreva("Digite uma temperatura em Celsius : ")

leia(celsius)
temp_fahrenheit <- converteFahrenheit(celsius)
escreva("A temperatura convertida em Fahrenheit é :
",temp_fahrenheit)
fimalgoritmo
179
Exercício 4 : Crie uma função parar retornar a média das quatro notas de um
aluno lidas do teclado. Ao final a média (retornada pela função) deverá ser
mostrada na tela.
funcao calculaMedia(n1,n2,n3,n4 : real) : real
inicio
retorne (n1 + n2 + n3 + n4) / 4
fimfuncao
var
media : real
nota1, nota2, nota3, nota4: real
inicio
escreva("Digite a primeira nota : ")

leia(nota1)
escreva("Digite a segunda nota : ")
leia(nota2)
escreva("Digite a terceira nota : ")
leia(nota3)
escreva("Digite a quarta nota : ")
leia(nota4)
media <- calculaMedia(nota1,nota2,nota3,nota4)
escreva("A média do aluno é : ", media)

fimalgoritmo
Exercício 5 : Crie um procedimento parar mostrar um determinado mês na

tela, de acordo com o valor passado como parâmetro para a sub-rotina. Por
exemplo, se o valor passado para o procedimento for “1”, mostrar na tela
“Janeiro”. Se o valor for “2”, mostrar “Fevereiro” e assim por diante.
procedimento MostrarMes(num_mes : inteiro)
inicio
escolha (num_mes)
caso 1
escreval("Janeiro")
180
caso 2
escreval("Fevereiro")
caso 3
escreval("Março")
caso 4
escreval("Abril")
caso 5
escreval("Maio")
caso 6
escreval("Junho")
caso 7
escreval("Julho")
caso 8
escreval("Agosto")
caso 9
escreval("Setembro")
caso 10
escreval("Outubro")
caso 11
escreval("novembro")
caso 12
escreval("Dezembro")
outrocaso
escreval("Mês inválido")
fimescolha
fimprocedimento
var
numero_mes : inteiro
inicio
escreva("Digite um numero inteiro entre 1 e 12 : ")

leia(numero_mes)
escreva("O mês é : ")
MostrarMes(numero_mes)
fimalgoritmo
181
Exercício 6 [RESOLVER]: Crie uma função parar retornar um determinado
mês, de acordo com o valor passado como parâmetro para a sub-rotina. Por
exemplo, se o valor passado para a função for “1”, retornar “Janeiro”. Se o valor
for “2”, retornar “Fevereiro” e assim por diante. Ao final o programa deverá
mostrar o mês retornado pela função na tela.
Exercício 7 [RESOLVER]: Desenvolver um algoritmo para ler 15 números do

teclado, armazenando-os em um vetor. Após a leitura todos os números dentro
do vetor A deverão ser ordenados em ordem crescente, e essa operação de
ordenação deverá ser efetuado por um procedimento que deverá ser criado no
programa. Ao final, mostrar todos os valores ordenados.

nome do funcionário, o salário base dele, e o número de filhos que ele tem. Ao
final, com base no salário do funcionário, realizar os seguintes cálculos (que
deverão ser realizados, cada um, por uma função)
Salário Família (a ser calculado e retornado por uma função) : Veja os critérios
para o cálculo do Salário Família :
Condição Retorno
Salário Base < 539,08 Número de Filhos * 27,64
(Salário Base >= 539,08) e
Número de Filhos * 19,48
(Salário Base < 810,18)
Salário Base > = 810,18 0
INSS (a ser calculado e retornado por uma função) : Veja a fórmula para o
cálculo do INSS : INNS = Salário Base * 8%
VALE TRANSPORTE (a ser calculado e retornado por uma função) : Veja a

fórmula para o cálculo do VALE TRANSPORTE : VALE TRANSPORTE =
Salário Base * 6%
SALÁRIO LIQUIDO (a ser calculado e retornado por uma função) : Veja a

fórmula para o cálculo do SALÁRIO LIQUIDO : SALÁRIO LIQUIDO = SALARIO
BASE + SALARIO FAMILIA – INSS – VALE TRANSPORTE
Ao final o programa deverá mostrar na tela : SALÁRIO FAMILIA, INSS, VALE

TRANSPORTE E SALÁRIO LIQUIDO.
182
Capitulo 9 Linguagem de
programação Java
A
partir de agora iremos aprender neste capítulo a desenvolver programas
usando a linguagem Java, que é a linguagem que utilizamos para
desenvolver nossos programas no Android. Isso quer disse que já
vamos começar Android agora ? NÃO. Agora iremos conhecer somente a
linguagem de programação Java, e como desenvolver programas usando essa
linguagem voltado para Desktop (antes de começarmos a desenvolver para
Android).
Até o momento do nosso aprendizado , compreendemos como funciona os

algoritmos e como desenvolve-los através do português estruturado ou
PORTUGOL (que consiste em um conjunto de comandos e instruções em
português), de forma a entendermos como funciona e como se constrói um
programa de computador, que nada mais são do que um conjunto de etapas
que são executadas PASSO A PASSO, cujo objetivo é solucionar um problema
proposto.
Agora nós iremos mexer com uma linguagem de programação que está dentro
da realidade do dia a dia no desenvolvimento de aplicações, já que o
PORTUGOL nada mais é do que um PRÉ-REQUISITO no aprendizado de
desenvolvimento de programas (pois, teoricamente falando, ninguém constrói
softwares profissionais usando o português estruturado, já que ele possui
limitações se comparado a uma linguagem de programação usada no
mercado).
9.1) O que é Java ?
Muitas pessoas conceituam Java como linguagem de programação, outras

como plataforma de desenvolvimento. Mas , afinal de contas, o que é Java ?
Java possui vários significados hoje em dia, mas, em nosso aprendizado irei
conceituado como linguagem de programação (que consiste em um conjunto
de comandos que permite a construção de um programa de computador). E
183
assim como qualquer outra linguagem, possui suas regras de desenvolvimento
(palavras, sintaxes, instruções e etc.)
Se lembra do programa que desenvolvemos lá no Visualg que mostra uma

mensagem na tela (a frase “Estou aprendendo programação”) ? Como seria
esse mesmo programa escrito em linguagem Java ? Veja como seria:
public class Programa {
public static void main(String[] args) {
System.out.println("Estou aprendendo programação");
Fazendo uma analogia com o PORTUGOL, todos os comandos que ficam

dentro de inicio e fimalgoritmo são executados dentro da função main do
Java (na linguagem Java, tudo é executado dentro de funções, e a função
principal de um programa em Java é main).
Para exibirmos uma mensagem na tela usando a linguagem Java usamos o

comando System.out.println , que equivale ao comando escreval do Visualg.
E assim como no PORTUGOL (e nos algoritmos de maneira geral), todos os

comandos em Java são executados um após o outro (pois um programa em
Java (ou em qualquer outra linguagem) TAMBÉM É UM ALGORITMO).
9.2) O que é Máquina Virtual Java ?
Acho que você possivelmente já teve ter ouvido esse termo em algum lugar,
mas ainda desconhece do que se trata. O que vem a ser uma Máquina Virtual
Java ? Uma Máquina Virtual Java nada mais é do que uma plataforma (ou um
framework, melhor dizendo) que executa aplicações escritas em linguagem
Java. O computador não entende, diretamente, o código de um programa
escrito em Java, cabendo a Máquina Virtual Java (também chamada do JVM)
realizar essa tarefa. A Máquina Virtual Java pode ser baixada no site da
desenvolvedora (no site da Oracle, que irei mostrar mais adiante).
184
9.3) Compilação e Interpretação
Em desenvolvimento de programas de computador (ou para qualquer

plataforma que seja) você deverá se familiarizar com os seguintes termos :
Compilação e Interpretação.
9.3.1) O que é compilação ?
Compilação nada mais é do que o processo de você pegar um código fonte

escrito em linguagem de programação (conhecido como linguagem de alto-
nível, pelo fato de nós programadores que estamos estudando linguagens de
programação sabermos o que as instruções estão fazendo) e convertê-lo (ou
melhor, “traduzi-lo”) para a linguagem do computador (que é a linguagem de
binária ou, linguagem de baixo nível, que é a linguagem que o computador
entende, o famoso “0’ e “1”).
No Windows, todos os programas são arquivos executáveis (os famosos

arquivos de extensão “.EXE”) , que na verdade são programas cujas instruções
estão em linguagem binária, ou seja, na linguagem que o computador entende.
Como funciona o processo de compilação ?
Vamos supor que você esteja escrevendo um programa bem simples em uma
linguagem de programação (como por exemplo, EM LINGUAGEM “C’). O
computador NÃO ENTENDE nenhum comando escrito em linguagem C. Os
programas escritos em uma determinada linguagem são executados graças a
uma ferramenta chamada “Compilador” (que também é um programa), que
traduz tudo o que você escreveu (em linguagem “C”) para a linguagem que o
computador irá entender. Veja o processo abaixo:
#include <stdio.h>
int main (void){

printf(“Hello World\n”)
}
Programa em linguagem C
Compilador de Executável do
Linguagem C Windows.
185
OBS : Lembre-se, só para deixar reforçado : Se você estiver desenvolvendo
um programa em linguagem C, você deverá utilizar um compilador de
linguagem C, não de outra linguagem. Para cada linguagem existe uma
ferramenta (compilador) voltado para ela.
O processo de compilação do código do programa, uma vez executado, não

precisa ser executado de novo, pois, como podemos observar, a compilação
gera o nosso programa (arquivo “.EXE”, executável do Windows), em
linguagem binária, que pode ser executado quantas vezes for preciso, sem o
compilador e o código fonte (programa escrito em “C”, por exemplo).
Comparando a compilação com a VIDA REAL
Imagine que você, um cara brasileiro que fala português , precise passar uma
mensagem para um alemão (que está na sua frente, cara a cara). Já sabemos
de imediato que o alemão não irá entender nada do que você falar (em
português). Logo, precisaremos de um tradutor (um interprete, que será o
nosso “Compilador”).
A função do nosso tradutor é escrever tudo o que você está falando em

português para um papel, no idioma “alemão”, para que o nosso amigo alemão
possa entender o que você disse. Se por acaso o alemão esquecer a
mensagem que foi passada, basta que ele possa ler novamente no papel a
mensagem escrita no idioma dele (sem depender de você (brasileiro) e do
tradutor).
9.3.2) O que é interpretação ?
Interpretação, embora o termo se pareça e funcione como o processo de

“compilação”, age de forma diferente. A interpretação (como o próprio nome
diz) interpreta diretamente as instruções , sem a necessidade de gerar um
executável (um arquivo “.EXE”). Por exemplo : Não tem o Visualg, ? Pois bem,
ele é um INTERPRETADOR DE ALGORITMOS, que lê , interpreta e executa
todas as instruções escritas em PORTUGOL , sem gerar nenhum executável
(mostrando todos os resultados na tela).
186
Um exemplo bem clássico de interpretador, para aqueles que já ouviram falar,
temos o JavaScript (que não é Java), que executa em nossos navegadores de
Internet (Chrome, Firefox, Internet Explorer e etc.). Muitas páginas que a gente
visita na Web (podemos dizer, atualmente, todas elas) , possuem um código
JavaScript que executa instruções para dar alguma ação na página (ou vida,
interatividade). Vejamos um exemplo : Não tem o Facebook ? Pois bem, a
maioria do código dele é JavaScript. E o que o código JavaScript do Facebook
executa e processa ? Ah, o famoso chat (bate-papo), as notificações
automáticas que surgem lá em cima enquanto você está navegando pelo Face
(ou conversando com alguém) e etc.
Como funciona o processo de interpretação ?
Para demonstrar o processo de interpretação, vamos usar o nosso famoso

Visualg que utilizamos no aprendizado de algoritmos. Veja a ilustração abaixo:
algoritmo “Mensagem”
inicio
escreva(“Olá”)
fimalgoritmo
Algoritmo escrito no Visualg Interpretador

Visualg Resultado na
tela.
Comparando a interpretação com a VIDA REAL
Imagine que você, um cara brasileiro que fala português , precise passar uma
mensagem para um alemão (que está na sua frente, cara a cara). Já sabemos
de imediato que o alemão não irá entender nada do que você falar (em
português). Logo, precisaremos de um tradutor (um interprete, que será o
nosso “Interpretador”).
187
A função do nosso interprete é falar tudo o que você está falando em português
para o alemão, no idioma dele, para que o mesmo possa entender a
mensagem que você precisa passar. Se por acaso o alemão esquecer a
mensagem que foi passada, ele será obrigado a recorrer a você (o cara
brasileiro) e ao interprete (o nosso interpretador).
9.3.3) Vantagens e desvantagens da compilação e interpretação
Vamos ver agora algumas vantagens e desvantagens da compilação :
Vantagens :
- Uma vez compilado, o programa não depende mais do compilador

para executar
- a execução do arquivo compilado é mais rápida (pois já executa na

linguagem do computador)
- O código compilado não possui nenhum erro sintático (comandos

escritos de forma errada)
Desvantagens :
- O código compilado (programa) só executa no sistema operacional

em que o mesmo foi compilado (ou seja, se você está usando seu
programa no Windows, não é possível rodar o mesmo programa no
Linux e etc)
- Não é possível visualizar e corrigir o arquivo compilado, pois o

mesmo está escrito em linguagem binária (que só o computador
entende), ou seja, em linguagem de baixo nível.
188
Vamos ver agora algumas vantagens e desvantagens da interpretação :
Vantagens :
- É possível a leitura e compreensão do código fonte do programa

original, assim também como sua correção.
- Códigos interpretados, normalmente, são portáveis para outros

sistemas operacionais (ou seja, o seu programa pode rodar em
outros sistemas operacionais (como Windows, Linux, Mac e etc.),
desde que eles possuam o interpretador da linguagem, em que foi
escrito o seu código, instalado)
Desvantagens :
- O programa sempre depende do interpretador para executar
- a execução do arquivo compilado é mais lenta (pois o interpretador

irá sempre traduzir cada comando interpretado para a linguagem do
computador)
- O programa interpretado, caso possua algum erro sintático no meio

do código, é interrompido parando a execução do interpretador.
9.4) Modo híbrido
O modo híbrido combina os processos da compilação e interpretação juntos.

Um exemplo de linguagem que combina esse processo é a linguagem Java
(que iremos aprender nesse capítulo).
Java é uma linguagem do tipo WORA (Write Once Run Anywhere), ou seja,
você escreve uma única vez e pode executar em qualquer sistema operacional
(teoricamente falando). Isso é possível porque quando escrevemos um
programa em Java, o mesmo é compilado gerando o seu bytecode (que é o
executável do Java, processado somente pela Máquina Virtual Java , nunca
diretamente pelo sistema operacional). Para executarmos um programa Java
(um arquivo de extensão “.class” conhecido como bytecode) precisaremos da
Máquina Virtual Java, que irá processar nosso bytecode e executar nosso
programa escrito em Java.
189
Uma das características fortes na linguagem Java é a PORTABILIDADE, ou
seja, a capacidade de um programa em Java ser executado em vários sistemas
operacionais (Windows, Linux, Solaris, Mac e etc.) , desde que o sistema
operacional possua a Máquina Virtual Java Instalada.
Vejamos abaixo como funciona o modo híbrido :
public class Programa {

public static void main (String
args[]){
System.out.println(“Olá”);
}
}
Compilador de Java
Executável Java (.class)
JVM (Windows) - JVM (Linux) - JVM (Mac) -

Interpretador Interpretador Interpretador
190
9.5) A ferramenta de desenvolvimento (Eclipse)
Para o desenvolvimento das aplicações na linguagem Java iremos utilizar o

que nós chamados de IDE (ou Ambiente de Desenvolvimento Integrado). Uma
IDE é uma ferramenta que utilizamos para desenvolver programas de
computador em uma determinada linguagem (como é o caso da linguagem
Java). Uma IDE é constituída por uma série de recursos como editor de texto
sensível a sintaxe (ou seja, aquele que destaca os comandos, palavras
reservadas , textos e etc., assim como no Visualg), analisador dinâmico de
erros sintáticos em tempo de projeto (que já não existe no Visualg), é um
compilador da linguagem (que no caso do Visualg era um interpretador).
Uma das ferramentas mais famosas para o desenvolvimento de aplicações

Java muito popular hoje em dia é o Eclipse (que pode ser baixado em
www.eclipse.org).
Para o desenvolvimento das aplicações Android iremos fazer uso da

ferramenta Android Studio (mais detalhes da ferramenta no próximo capítulo).
Assim como qualquer ferramenta de desenvolvimento para a linguagem Java, o

Eclipse (como também o Android Studio) precisa que a Máquina Virtual Java
esteja instalada para trabalharmos com ele.
Minha máquina virtual Java está instalada ?
Bom, para você saber se você possui uma máquina virtual Java instalada, abra
o prompt de comando e digite o seguinte comando:
java –version
191
Verifique se o resultado foi “similar” ao que é mostrado abaixo:
Máquina virtual java instalada
Se observarmos as informações mostradas no console acima, certifique se a

versão é 1.7.x.x está instalada em sua máquina, conforme é destacado abaixo:
A versão do Java que utilizo para o desenvolvimento do livro é 1.7 (Java 7). Se
a versão que se encontra instalada em sua máquina é inferior ao utilizado no
material (como 1.6 ou 1.5), recomendo a atualização da máquina virtual (que
será mostrado como instalar daqui a pouco).
Agora, se a versão que encontra instalada em sua máquina for igual ou

superior ao utilizado no livro, PODE PULAR ESTÁ ETAPA e AVANCE PARA O
PRÓXIMO TÓPICO.
Agora se o resultado ao digitar o comando “java –version” no prompt do

comando for igual ao da figura seguinte :
192
Máquina virtual Java NÃO INSTALADA
Significa que sua máquina virtual , possivelmente, não está instalada em sua
máquina.
Para realizarmos o download o Java, visite o seguinte link abaixo:
http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-
1880260.html?ssSourceSiteId=otnpt
Feito isso deverá se abrir a seguinte página abaixo:
Página de download do Java 7
Procure pela versão mais recente do Java 7. Feito isso aceite os termos de
contrato e realize o download do arquivo de instalação, conforme é mostrado
abaixo:
193
Aceitando os termos de contrato e realizando o download
Feito isso deverá ser mostrado a seguinte caixa de diálogo :
Caixa de diálogo - Download
Após realizar o download, siga todo o passo a passo da instalação da máquina

virtual Java.
194
Com a máquina virtual Java instalada em seu computador, já podemos vamos
realizar o download da ferramenta Eclipse.
Abra o seu navegador e entre no seguinte endereço: www.eclipse.org. Feito

isso veremos a seguinte página:
Página inicial da ferramenta Eclipse
Clique agora no botão “DOWNLOAD” para podermos efetuar o download da

ferramenta. Feito isso, será aberta a seguinte página.
195
Role abaixo e encontre a opção destacada em verde. A versão que utilizarei
aqui do Eclipse será a versão de 32 Bits. Para realizar o download é só clicar
na opção destacada em azul.
Feito isso será aberta uma nova página. Para finalizar é só clicar no botão de
“DOWNLOAD”, conforme podemos ver na figura seguinte:
Feito isso será aberta a seguinte caixa de diálogo de download
196
Caixa de diálogo – Download do Eclipse
A instalação é bastante simples, basta descompactar o arquivo “eclipse-java-

mars-1-win32.zip” em um local apropriado (de preferência, a unidade “C:\”).
Ao descompactar o arquivo da aplicação, vamos executar a nossa aplicação ,

que se encontra dentro da pasta “eclipse”. O nome do executável é
“eclipse.exe”. Vejamos na figura em seguida:
Conteúdo do diretório “eclipse”
197
Para executarmos o Eclipse basta dar um duplo clique executável (conforme
indicado na figura anterior). Quando a ferramenta é executada pela primeira
vez, será solicitado um diretório de “Workspace” (diretório de trabalho), que é o
local no qual o Eclipse vai gerar os projetos (em, Java), conforme você confere
na figura seguinte:
Diretório do Workspace
Escolha o diretório desejado para seu “Workspace” e , caso você deseje que
ela seja definitivo, marque a opção “Use this as the default and do not ask
again”. Depois disso clique em “OK”.
Feito isso, o ambiente de programação Eclipse será carregado, conforme

demonstra a figura seguinte:
198
Ambiente de programação Eclipse
Se observarmos a janela que nos foi aberta é mostrada uma tela de

“Welcome!”. Para retirarmos essa tela basta fecharmos a guia “Welcome”
clicando no “X” , conforme podemos ver na figura abaixo:
Fechando a guia “Welcome”
199
Feito isso visualizaremos a seguinte janela em seguida :
Ambiente de desenvolvimento Eclipse
9.6) Criando nosso primeiro projeto
Vamos agora criar o nosso primeiro projeto para o desenvolvimento das nossas
aplicações em Java. Para criarmos um projeto basta irmos no menu
“File/New/Java Project”. Veja na figura abaixo:
Criando um novo projeto em Java
200
Feito isso será aberta a seguinte caixa de diálogo abaixo:
Caixa de diálogo – New Java Project
No campo “Project name” iremos digitar o nome do nosso projeto, que irá
conter todas as nossas aplicações desenvolvidas em Java. O nome do nosso
projeto irá se chamar “Programas em Java”, veja abaixo:
Digitando o nome do projeto
201
Feito isso basta clicarmos em “Finish” para que o projeto possa ser criado. Veja
o resultado na guia “Package Explorer”, conforme mostra a figura a seguir :
Projeto Java criado
Agora vamos criar nosso primeiro algoritmo (programa) em Java. Para isso,
clique com o botão direito do mouse sobre o nome do projeto e em seguida
selecione “New/Class” . Veja abaixo :
Criando uma nova classe
O que é uma classe ?
Classe é uma estrutura que irá conter todo o código do nosso programa em
Java. O conceito de “classe” vem da Programação Orientada a Objetos (POO),
que é o ponto forte da linguagem Java. Nesta apostila não irei focar nos
conceitos de Programação Orientada a Objetos (porém, recomendo “muito” a
202
leitura a respeito do assunto). Irei concentrar somente como desenvolver uma
aplicação em Java, fazendo comparações com algoritmos desenvolvidos em
PORTUGOL no Visualg, pra que possamos entender os fundamentos sobre
programação e desenvolvimento de aplicações.
Bom, feito o que se foi pedido teremos a seguinte tela abaixo:
Caixa de diálogo – New Java Class
No campo “Name” iremos digitar o nome da nossa classe, que irá se chamar
“PrimeiroPrograma” , veja :
203
Digitando o nome da classe
Depois disso vamos marcar a opção “public static void main(String[] args)”,
indicando que a nossa classe será um programa (pois também uma classe
pode ser somente uma estrutura que pode ser utilizada por outras classes que
venham a ser aplicações, como esta). Veja abaixo:
Definindo nossa classe como uma aplicação
Depois disso vamos clicar no botão “Finish” para que nossa classe possa ser
gerada. Eis o resultado :
Estrutura da aplicação (classe) em Java gerada
Todo o código que será executado em um programa em Java deve estar dentro
da função main (normalmente em linguagens de programação como Java não
se utiliza o termo “função”, como utilizamos em algoritmos, mais sim “método”,
que iremos utilizar a partir de agora)
204
Conceituando mais sobre método
Um método (na Programação Orientada a Objetos) é uma sub-rotina que é

declarada e estruturada dentro de uma classe , podendo esse método retornar
(funções) ou não (procedimentos) valores. O comportamento desses métodos é
igual ao que aprendemos sobre sub-rotinas no PORTUGOL, em algoritmos.
Na programação em Java, o método main sempre é o primeiro a ser

executado, logo, tudo o que a gente precisar executar , terá que ser
desenvolvido dentro desse método.
Irei fazer algumas observações do código gerado para a gente já ir aprendendo

algumas coisas. O código destacado abaixo :
Consiste em um comentário com várias linhas, que inicia sempre com “/*”
(barra seguido do asterisco), e finalizado com “*/” (asterisco seguido do barra).
Na linha destacada a seguir :
205
Consiste em um comentário mono linha, ou seja, de uma única linha (expresso
por duas barras seguidas “//”, como no Visualg)
Bom (sem muito papo), vamos construir nossa primeira aplicação em Java,
cuja finalidade é mostrar a seguinte frase na tela : “Estou aprendendo Java”.
Se lembra do comando escreva (e também escreval) do Visualg que imprimia

as frases na tela ? Pois bem, no Java para exibirmos uma mensagem na tela
utilizamos o comando System.out.println (comando um pouco grande não é
mesmo ?) para tal finalidade. Vamos digitar no nosso código em Java, dentro
do método main, a seguinte expressão destacada em seguida :
206
O comando que digitamos (em Java) acima imprime na tela a mensagem
“Estou aprendendo Java”. Se observarmos o código acima existe após a
instrução digitada um ponto e vírgula ( ; ), que finaliza a instrução daquela
linha.
Todas as instruções na linguagem Java devem ser finalizadas com ponto e

vírgula (haverá algumas exceções, que iremos aprender no desenvolver do
código)
Executando a nossa aplicação
Para executarmos uma aplicação em Java no Eclipse basta clicarmos na barra

de ferramentas, no seguinte botão em seguida :
Botão Run (para executarmos uma aplicação Java)
Outra alternativa é pressionar as teclas CTRL+F11.
207
Feito o que se foi pedido, poderá ser aberta a seguinte caixa de diálogo, caso o
arquivo não tenha sido salvo:
Caixa de diálogo – Save and Launch
Basta clicarmos em “OK” para que o nosso programa possa ser executado.
Ué, mas não se abriu nenhuma tela preta como no Visualg. Claro, no Eclipse é
um pouco diferente. O resultado da execução pode ser conferido na seção
“Console”, conforme é mostrado na figura em segudia :
208
Meus parabens. Você acaba de criar seu primeiro programa desenvolvimento

em linguagem de programação Java. Você acaba de dar mais um salto
importante no aprendizado sobre desenvolvimento de aplicações em Java (que
será muito importante, para o desenvolvimento de aplicações em Android).
Agora, se eu quisesse que a seguinte mensagem fosse exibida, na ordem a

seguir:
Estou aprendendo Java

com a Apostila de Android.
Eis o código :
public class PrimeiroPrograma {

/**
* @param args
*/
// TODO Auto-generated method stub
System.out.println("Estou aprendendo Java");
System.out.println("com a Apostila de Android");
}
}
209
Vejamos o resultado:
O princípio de execução dos programas em Java é igual ao do Visualg, não

muda (pois sendo em Java ou PORTUGOL, tudo é algoritmo, ou seja, tudo é
executado PASSO A PASSO).
9.7) Variáveis e tipos de dados
Assim como vimos na programação com algoritmos que utilizam variáveis no

PORTUGOL (usando o Visualg), no Java também é praticamente a mesma
coisa, não muda nada em relação aos conceitos. O que nós precisamos saber
é quais são os tipos de dados suportados pela linguagem e como se declara,
nada mais.
9.7.1) Como declarar uma variável no Java
Para declararmos uma variável no Java, é utilizado a seguinte sintaxe :
Sintaxe :
<tipo> <variável1>, <variável2>,...,<variável>;
Diferente do Visualg, não é preciso utilizar uma clausula chamada var (até
porque no Java essa palavra reservada não existe), para declararmos uma
variável, e se observarmos na sintaxe acima, primeiramente informamos o tipo
de dados para em seguida informar as variáveis que serão usadas no código.
210
9.7.2) Tipos de dados existentes na linguagem Java
Vejamos na tabela abaixo os tipos de dados mais comuns utilizados na

linguagem Java (fazendo uma breve comparação com o PORTUGOL, que
utilizamos no Visualg)
Tipo de dados Descrição

O tipo int no Java equivale ao tipo inteiro
lá do Visualg, ou seja, permite declarar
uma variável que armazene somente
int
números inteiros. Esse tipo permite
guardar valores inteiros que estejam
entre -2.147.483.648 até 2.147.483.647
O tipo long no Java equivale também tipo
inteiro lá do Visualg, ou seja, permite
declarar uma variável que armazene
somente números inteiros. A diferença
long do tipo long para o tipo int no Java é que
esse tipo tipo permite guardar valores
inteiros com representações numéricas
bem maiores, ou seja, valores que
estejam entre -263 e 263-1
O tipo short no Java também equivale ao
tipo inteiro lá do Visualg, ou seja, permite
short do tipo short para o tipo int no Java é
que esse tipo permite guardar valores
inteiros com representações numéricas
bem menores, ou seja, valores que
estejam entre –32.768 e 32.767
211
Tipo de dados Descrição
O tipo byte no Java também equivale ao
tipo inteiro lá do Visualg, ou seja, permite
byte
do tipo byte para o tipo int no Java é que
esse tipo permite guardar valores inteiros
com representações numéricas limitadas,
ou seja, valores entre 0 e 255.
O tipo float no Java equivale ao tipo real
lá do Visualg, ou seja, permite declarar
float
uma variável que armazene números
inteiros e quebrados (em 32 bits).
O tipo double no Java também equivale
ao tipo real lá do Visualg, ou seja, permite
double declarar uma variável que armazene
números inteiros e quebrados (em 64
bits).
O tipo String equivale ao tipo caractere
lá do Visualg, ou seja, permite guardar
String
textos, frases e caracteres de uma forma
geral.
O tipo char do Java, diferente do tipo
char String, guarda somente um único
caractere na memória.
O tipo boolean equivale ao tipo lógico lá
do Visualg, ou seja, permite guardar
boolean valores lógicos como true (que equivale
ao verdadeiro) e false (que equivale ao
falso)
Vejamos abaixo como declaramos as variáveis no Java :
String nome;
float nota1,nota2,nota3,nota4;
212
Para uma demonstração prática vamos criar uma nova classe no Java (da
forma como já foi mostrado). O nome da nossa classe irá se chamar
Variaveis1 (escrito tudo junto e sem acentos). Lembre-se de marcar a opção
“public static void main(String[] args)”
Vejamos como ficará o código da nossa aplicação abaixo:
public class Variaveis1 {
/**
* @param args
*/
String nome;
int idade;
nome = "Luciano";
idade = 29;
System.out.println("Meu nome é : " + nome);

System.out.println("Minha idade é " + idade);
Irei explicar agora PASSO A PASSO toda a execução do nosso programa. As

instruções abaixo :
String nome;
int idade;
Declara duas variáveis chamadas nome (tipo String) e idade (do tipo int), que
serão utilizadas dentro do programa.
213
Nas instruções a seguir :
nome = "Luciano";
idade = 29;
atribuímos as variáveis nome e idade os seus respectivos valores usando o

comando de atribuição do Java (que é presentado pelo sinal de igual “=”).
Nas instruções abaixo:

São exibidas as mensagens na tela, mostrando o nome e a idade do usuário.

Se observarmos uma das instruções acima, observe que existe um sinal de “+”
(soma), que separa a frase do conteúdo da variável a ser exibido. Veja :
Na verdade, o que está acontecendo é uma “concatenação” (ou seja, junção)

da frase com o conteúdo da variável a ser exibido na tela. No Java o processo
acontece dessa forma :
System.out.println("Meu nome é : " + "Luciano");
System.out.println("Meu nome é : Luciano");
O mesmo acontece na instrução seguinte , como podemos ver em seguida :
214
Feito isso, teremos o seguinte resultado abaixo:
Uma das características da linguagem Java em relação a declaração de

variáveis é que não é preciso declarar as variáveis em um determinado ponto
central do método, você pode declarar uma variável no momento em que você
precisa. Vejamos o código do programa abaixo:
String nome;
int idade;
nome = "Luciano";
idade = 29;

}
Observe que declaramos todas as variáveis lá no início do método . Também

poderíamos fazer desse forma :
String nome;
nome = "Luciano";
int idade;
idade = 29;

}
Agora as variáveis foram declaradas no momento em que elas realmente serão

utilizadas.
215
É possível também no Java atribuir os valores para uma variável já no
momento de sua declaração. Vejamos o código abaixo :
String nome;
nome = "Luciano";
int idade;
idade = 29;
Poderíamos também fazer desta forma :
String nome = "Luciano";

int idade = 29;
Mais rápido não é mesmo ?
9.7.3) Comando de atribuição
Conforme já havíamos visto agora no exemplo anterior (mas sendo reforçado

aqui), o comando de atribuição do Java é expressado dessa forma :
<variável> = <valor>;
Vejamos agora alguns exemplos abaixo :
nome = "Carlos";
idade = 42;
tem_habilitacao = true;
9.7.4) Leitura de dados via teclado
Na linguagem Java para realizarmos a leitura de dados via teclado devemos

fazer uso de uma classe da linguagem chamada Scanner . Dentro dessa
classe encontramos vários métodos (sub-rotinas) que realiza a leitura de dados
via teclado, para os mais diversos tipos de dados.
216
Como utilizar a classe Scanner
Primeiramente vamos criar uma nova classe dentro do nosso projeto chamada
Variaveis2 (lembre-se de marcar a opção “public static void main(String[]
args)”. Feito isso termos o seguinte código abaixo :
/**
* @param args
*/
Para utilizarmos a classe Scanner , primeiramente, precisaremos digitar a

seguinte linha de comando destacada abaixo, no início do arquivo :
import java.util.Scanner;
/**
* @param args
*/
O comando destacado que acabamos de escrever se trata da utilização de um

pacote. Pacotes em Java nada mais são do que bibliotecas, que possui, dentro
de cada uma delas, uma série de classes para finalidades específicas. Neste
caso, a classe Scanner encontra-se dentro do pacote “java.util”. Para
utilizarmos uma classe que se encontra dentro de um pacote devemos utilizar o
comando import, que possui a seguinte sintaxe :
import <pacote>.<classe>;
217
Logo, para utilizarmos a classe Scanner que se encontra no pacote “java.util”,
basta digitarmos :
Agora , caso queiramos utilizar todas as classes presentes dentro desse pacote
(incluindo também a classe Scanner), basta digitarmos :
import java.util.*;
Agora dentro do método main vamos digitar o seguinte comando destacado

abaixo :

Scanner teclado = new Scanner(System.in);
Observe que declaramos uma variável chamada teclado, que nessa

circunstância, chamaremos de “objeto”.
Porque chamar variável de objeto ?
Na linguagem Java, quando declaramos uma variável que não seja no tipo
int, float, double, boolean, char e etc (conforme a tabela de tipos de
dados) , normalmente chamamos de objetos.
Outra razão para chamarmos a variável teclado de objeto é pelo fato (e

presença) de usarmos a instrução new, que irá carregar o objeto
(manualmente) na memória.
De uma forma mais clara, todas as variáveis cujo tipos primitivos sejam de
acordo com a tabela mostrada (referente aos tipos de dados) chamamos
de variáveis (e observe que não é preciso usar o new para carrega-las na
memória).
Agora, qualquer variável que veja a fazer uso da instrução new para
carrega-la na memória, chamaremos de objeto.
218
Agora vamos digitar o restante do código, conforme podemos ver abaixo:

String nome;
System.out.println("Digite seu nome : ");
nome = teclado.nextLine();
System.out.println("Seu nome é : " + nome);
Irei explicar linha a linha o que cada comando está realizando. Na primeira
instrução :
Estou criando um objeto chamado teclado, que irá armazenar o que chamamos
de “instância da classe” Scanner na memória. E observe que na classe
Scanner existe um parâmetro que passamos (e que é padrão) , cujo valor é
“System.in”.
Na instrução seguinte:
String nome;
Criamos uma variável chamada nome, do tipo String (Observe que não é
preciso usar nenhuma instrução new para carregar na memória, por isso
chamamos de variável).
Na instrução seguinte :
Ocorre a leitura de dados via teclado, graças ao método nextLine (que lê

cadeias de caracteres do teclado), presente dentro do objeto teclado (que na
verdade está presente dentro da classe Scanner , pois o objeto teclado é do
219
tipo Scanner). Após a leitura dos dados via teclado, ocorre a atribuição do
valor lido para a variável nome. Veja abaixo como funciona o processo :
Aqui ocorre a interrupção da execução,

aguardando o usuário digitar alguma
coisa:
Pressionou ENTER
Digitou : “Lucas”
nome = “Lucas”;
Entendeu como funciona ?
220
Na instrução abaixo :
System.out.println("Seu nome é : " + nome);
Exibimos o nome lido do teclado na tela.
Bom, agora vamos acompanhar na prática a execução do nosso programa.

Quando executarmos o programa, será exibida a seguinte mensagem :
Programa em execução – Aguardando algo ser digitado
Bom, é agora ? Basta digitarmos meu nome e acabou ? Não. Naturalmente a

janela (seção “Console”) onde está sendo exibida a mensagem está “sem
foco”. Observe que não há nenhum cursor piscando acima (como acontecia lá
no Visualg). Para isso vamos clicar no local indicado, conforme mostra a figura
abaixo, até aparecer um cursor preto piscando :
Programa em execução – Janela recebendo foco
Agora sim. Basta digitarmos agora um nome qualquer (como por exemplo
“Rodrigo”), e em seguida pressionarmos ENTER, para conferirmos o resultado:
Programa em execução – Nome sendo exibido
221
Agora vamos supor que eu precise desenvolver um programa (algoritmo) em
Java para ler o nome de um aluno e as suas quatro notas, e no final o
programa deverá mostrar o nome do aluno e sua média. Para isso, vamos criar
uma nova classe chamada CalculaMedia no nosso projeto, com o seguinte
código abaixo:
public class CalculMedia {
String nome_aluno;
double nota1, nota2, nota3, nota4;
double media;
System.out.println("Digite o nome do aluno:");
nome_aluno = teclado.nextLine();
System.out.println("Digite sua primeira nota:");

nota1 = teclado.nextDouble();
System.out.println("Digite sua segunda nota:");

System.out.println("Digite sua terceira nota:");

System.out.println("Digite sua quarta nota:");

media = (nota1 + nota2 + nota3 + nota4) / 4;
System.out.println("O nome do aluno é : " + nome_aluno);

System.out.println("Sua média é : " + media);
222
Vejamos agora, antes de executar o programa , os comandos destacados
abaixo :
System.out.println("Digite sua primeira nota:");
System.out.println("Digite sua segunda nota:");
System.out.println("Digite sua terceira nota:");
System.out.println("Digite sua quarta nota:");
Observe que para as leituras dos dados referentes as notas escolares (que são
variáveis do tipo double) fizemos uso do método nextDouble (da classe
Scanner), responsável por ler números dessa natureza.
Realizando uma execução do programa, teremos o seguinte resultado :
223
Antes de prosseguirmos, vamos conhecer os todos métodos de leitura
referente para cada tipos de dados abaixo da classe Scanner:
Tipo de dados Método

Int nextInt()
long nextLong()
short nextShort()
float nextFloat()
double nextDouble()
byte nextByte()
String nextLine()
9.7.5) Operadores aritméticos
Assim como no PORTUGOL (Visualg), o Java também tem seus operadores

aritméticos que podemos utilizar na hora de realizar as nossos cálculos e tudo
mais. São eles :
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto de uma divisão inteira
9.7.6) Observações gerais
Todas as variáveis, comandos e palavras reservadas da linguagem Java são

“case sensitive”, ou seja, diferencia as palavras/letras maiúsculas das
minúsculas. Por exemplo, no Java as variáveis :
int numero, Numero, NUMERO;
São totalmente distintas, embora escritas com o mesmo nome. O que

diferencia é que uma foi escrito toda em minúsculo (numero) , outra totalmente
em maiúsculo (NUMERO) e a outra com a inicial da letra em maiúsculo
(Numero).
224
9.8) Estrutura condicional
Assim também como no PORTUGOL, o Java também trabalha com estruturas

condicionais, através das seguintes comandos que iremos aprender a seguir:
9.8.1) A estrutura IF
A estrutura condicional IF (semelhante a estrutura SE/ENTÃO do PORTUGOL)

executa um bloco de comandos caso uma determinada condição seja
satisfeita, senão, não executada absolutamente nada. Vejamos abaixo a
sintaxe da estrutura IF do Java:
Sintaxe :
if(<condicao>)
<comando a ser executado> ;
Vejamos uma demonstração abaixo:
if(numero > 10)

System.out.println(“Esse número é maior que 10”);
A frase do comando acima só será mostrada na tela se a condição “numero >

10” for verdadeira. Caso contrário, nada será exibido na tela.
O exemplo do IF acima só funciona quando executamos UMA ÚNICA

INSTRUÇÃO. Caso a gente precise executar MAIS DE UMA INSTRUÇÃO
DENTRO DE UMA CONDIÇÃO, devemos utilizar a seguinte sintaxe :
if(<condicao>)
{
<comando1> ;
<comando2> ;
:
<comandon> ;
Ou seja, todos os comandos devem estar entre abra e fecha colchetes { ... }
225
Vejamos um exemplo abaixo :
if(media >= 7)
{
System.out.println(“MEUS PARABENS!!!”);
System.out.println(“Você está aprovado.”);
9.8.2) A estrutura IF/ELSE
A estrutura condicional IF/ELSE (semelhante a estrutura SE/ENTÃO/SENÃO

do PORTUGOL) executa um bloco de comandos caso uma determinada
condição seja satisfeita, e outro bloco de comandos caso a condição não seja
satisfeita. Vejamos abaixo a sintaxe da estrutura IF/ELSE do Java:
Sintaxe :
if(<condicao>)
<comando a ser executado caso a condição seja verdadeira> ;
else
<comando a ser executado caso a condição seja falsa> ;
Exemplos:
if(numero > 10)

System.out.println(“Esse número é maior que 10”);
else
System.out.println(“Esse número é menor ou igual a 10”);
if(media >= 7)
{
System.out.println(“MEUS PARABENS!!!”);
System.out.println(“Você está aprovado.”);
}
else
{
System.out.println(“QUE PENA!!!”);
System.out.println(“Você foi reprovado.”);
}
226
EXEMPLO 1: Vamos construir um algoritmo para ler um número do teclado e
em seguida verificar se ele é maior do que 10. Caso o número seja maior do
que 10, mostrar a mensagem “ESSE NÚMERO É MAIOR DO QUE 10” (criar
uma classe chamada EstruturaIf1).
public class EstruturaIf1 {
int numero;
System.out.println("Digite um número : ");

numero = teclado.nextInt();
if(numero > 10)

System.out.println("Esse número é maior do que 10");
}
}
Exemplo 2: Vamos construir um algoritmo em Java para ler a média aritmética

de um aluno. Caso a média lida do teclado seja maior ou igual a 7, mostrar na
tela que o aluno está aprovado, caso contrário mostrar que está reprovado
(criar uma classe chamada EstruturaIf2).
public class EstruturaIf2 {

double media;
System.out.println("Digite a média do aluno : ");

media = teclado.nextDouble();
if(media >= 7)
System.out.println("Ele está aprovado");
else
System.out.println("Ele está reprovado");
227
9.8.3) Tabela de operadores relacionais
Dentro dos exemplos que desenvolvemos acima envolvendo a estrutura IF e

IF/ELSE do Java, utilizamos alguns operadores relacionais (assim também
como no PORTUGOL do Visualg). Veja abaixo a lista de operadores
relacionais que podemos utilizar dentro de uma condição:
>= Maior ou igual
> Maior
<= Menor ou igual
< Menor
== Igual
!= Diferente
Observe que na tabela de operadores acima destaquei dois operadores

relacionais que merecem nossa atenção. O operador de igualdade, por
exemplo, tem como símbolo dois iguais, um seguido do outro (“==”). Por
incrível que pareça não está errado, é assim que Java interpreta a igualdade.
O operador de diferente é formado pelo símbolo de exclamação seguido do

igual (“!=”), que por incrível que pareça, não está errado. É assim que o Java
interpreta essa operação.
9.8.4) Operadores lógicos
Nas demonstrações envolvendo as estruturas condicionais IF e IF/ELSE do

Java trabalhamos sempre com uma condição (assim também como no
PORTUGOL no Visualg). Mas, se eu quisesse dentro de uma condição IF
avaliar mais de uma condição (como por exemplo verificar se um número é
maior que 20 e também menor que 90) ? Para isso utilizamos os operadores
lógicos do Java:
228
O operador lógico && (E)
O operador lógico && do Java (que na verdade é o operador E) é um operador

que avalia mais de uma condição (supondo, por exemplo, duas condições),
retornando verdadeiro se todas as condições avaliadas forem verdadeiras.
Veja a tabela abaixo:
Condição 1 Condição 2 Operador &&

Verdadeiro Falso Falso
Falso Verdadeiro Falso
Falso Falso Falso
O operador lógico || (OU)
O operador lógico || do Java (que na verdade é o operador OU) é um operador

que avalia mais de uma condição (supondo, por exemplo, duas condições),
retornando verdadeiro se PELO MENOS UMA DAS CONDIÇÕES avaliadas
for verdadeira. Veja a tabela abaixo:
Condição 1 Condição 2 Operador ||

Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Falso Falso Falso
O operador lógico (!) NÃO
O operador lógico “!” (que na verdade é o operador NÃO) funciona como um

INVERSOR LÓGICO de condições, retornando verdadeiro se a condição for
falso, e falso se a condição for verdadeira. Veja o exemplo abaixo:
Condição Operador !
Verdadeiro Falso
Falso Verdadeiro
229
Aplicando os operadores na prática no Java
Exemplo : Vamos construir um algoritmo em Java para ler um número inteiro

qualquer, e verificar se o mesmo é maior ou igual a 10 E menor ou igual a 90.
Se a condição for verdadeira (ou seja, se o número estiver dentro dessa faixa)
mostrar a mensagem “o número está dentro da faixa”, caso contrário mostrar a
seguinte mostrar a mensagem “o número está fora da faixa” (criar uma classe
chamada OperadorLogico1).
public class OperadorLogico1 {
int numero;

if((numero >= 20) && (numero <=90))

System.out.println("O número está dentro da faixa");
else
System.out.println("O número está fora da faixa");
}
Exemplo 2: Vamos construir um algoritmo em Java para ler uma determinada

opção oferecida pelo programa (Opção “a” para “Abrir” e “s” para “Salvar”). Se
a opção lida for válida, mostrar na tela “Opçao selecionada válida”, caso
contrário mostrar “Opcao inválida” (criar uma classe chamada
OperadorLogico2).
230
String opcao ;
System.out.println("Escolha uma opção");

System.out.println(" ");
System.out.println("A - Abrir");
System.out.println("S - Salvar");
System.out.println("Qual sua opção : ");
opcao = teclado.nextLine();
//Converte todos os caracteres para maiúsculo

opcao = opcao.toUpperCase();
if((opcao.equals("A")) || (opcao.equals("B")))
System.out.println("Opção selecionada válida");
else
System.out.println("Opção inválida");
Quero chamar atenção aqui para duas linhas de comandos importantes.

Quando realizamos a leitura da opção, via teclado :
É executado na linha seguinte o comando abaixo :
O que significa essa atribuição ? Essa atribuição fará que a letra (opção)
informada, seja convertida para maiúscula caso a letra esteja minúscula pelo
método toUpperCase.
231
Vamos ver como todo esse processo funciona, conforme podemos ver abaixo:
Aqui ocorre a interrupção da execução,

aguardando o usuário digitar alguma
opção qualquer:
Pressionou ENTER
Digitou : “a”
opcao = “a” ;
Converte para
maiúsculo.
opcao = “A”;
Porque a conversa para maiúsculo foi necessária ?
Diferente do PORTUGOL do Visualg, o Java diferencia as palavras/letras

maiúsculas das minúsculas, ou seja, a letra “A” (maiúscula) é diferente de “a”
(minúsculo).
232
Agora na avaliação condição temos a seguinte expressão :
if((opcao.equals("A")) || (opcao.equals("B")))
Observe que para comparar se uma variável String do Java é igual a uma
determinada cadeia de caracteres (ou somente um único caractere), devemos
utilizar o método equals , pois o operador “==” não é correto para esse tipo de
situação (somente para tipo de dados String, pois para restante, se usa o “==”
normal).
Exemplo 3: Vamos construir um algoritmo em Java para ler um determinado

número inteiro. Se esse número NÃO É MAIOR QUE 10, mostrar a mensagem
“esse número não é maior do que 10”, caso contrário mostrar “Esse número É
MAIOR QUE 10” (criar uma classe chamada OperadorLogico3).
int numero;

if(!(numero > 10))

System.out.println("Esse número NÃO É MAIOR QUE 10");
else
System.out.println("Esse número É MAIOR QUE 10");
233
9.8.5) A estrutura SWITCH/CASE
A estrutura SWITCH/CASE (similar ao ESCOLHA/CASO do PORTUGOL que

aprendemos no Visualg) é muito utilizada em questões de múltiplas escolhas,
ideal quando temos uma situação quando precisamos escolher muitas opções
(tipo “o” para novo, “a” para “abrir”, “s” para salvar, “i” para imprimir) e etc. Com
a estrutura IF/ELSE até é possível fazer isso, mas com o SWTICH/CASE
temos uma visão clara e fácil de entendermos o que vai acontecer.
Veja a sintaxe da estrutura a seguir:
switch (<variável>)
{
case <valor1> : <instrução> break;
:
case <valorn> : <instrução> break;
[
default : <instrução>break;
]
OBS: A estrutura em negrito na estrutura SWITCH/CASE é OPCIONAL, ou

seja, não somos obrigados a colocar aquela instrução. A estrutura em negrito
funciona como se fosse o ELSE do IF.
Exemplo : Vamos construir um programa em Java que leia uma determinada

opção, do conjunto de opções oferecidas abaixo:
O – Novo
A – Abrir
S – Salvar
I – Imprimir
X – Sair
234
Caso o usuário digite uma das letras acima, mostrar a operação associada a
ela, caso contrário, mostrar “OPÇÃO INVÁLIDA”.
Vejamos o código do nosso algoritmo a seguir (criar uma classe chamada

SwitchCase1):
public class SwitchCase1 {
String opcao;
System.out.println("Escolha uma das opções abaixo");

System.out.println("O - Novo");
System.out.println("A - Abrir");
System.out.println("S - Salvar");
System.out.println("I - Imprimir");
System.out.println("X - Sair");
switch(opcao)
{
case "O" : System.out.println("Você escolheu NOVO");
break;
case "A" : System.out.println("Você escolheu ABRIR");
break;
case "S" : System.out.println("Você escolheu SALVAR");
break;
case "I" : System.out.println("Você escolheu IMPRIMIR");
break;
case "X" : System.out.println("Você escolheu SAIR");
break;
default : System.out.println("OPÇÃO INVÁLIDA"); break;
235
A execução desse programa é similar ao que nós aprendemos lá no Visualg.
Vejamos o resultado na figura abaixo :
9.9) Estrutura de repetição
Assim também como no PORTUGOL que aprendemos usando o Visualg, a

linguagem Java (como também todas as linguagens) possuem o que
chamamos de ESTRUTURAS DE REPETIÇÃO. Vamos conhecer agora as
estruturas de repetição oferecidas pela linguagem Java :
9.9.1) A estrutura de repetição WHILE
A estrutura de repetição WHILE (equivalente ao loop ENQUANTO lá do

Visualg) repete um bloco de código enquanto uma determinada condição for
satisfeita (na verdade, verdadeira). Enquanto for verdadeira, o bloco de códigos
(ou a instrução) dentro da estrutura de repetição WHILE será executada
sempre.
236
Veja a sintaxe da estrutura WHILE abaixo:
while (<condição>)
<instrução>;
A sintaxe acima é válida quando temos uma única instrução somente a ser
executada dentro do loop. Caso a gente precise executar mais de uma
instrução dentro do loop, usar a sintaxe abaixo :
while (<condição>)
{
<instrução1>;
<instrução2>;
:
<instruçãon>;
Vamos fazer um algoritmo em Java onde tenha que imprimir valores na tela de
1 até 5, sabendo que os valores estarão armazenados em uma variável. Eis o
código (criar uma classe chamada Loop1):
public class Loop1 {
int contador = 1;
while(contador <= 5)
{
System.out.println(contador);
contador++;
}
237
Assim como no Visualg, ele irá imprimir os números na tela, de 1 ate 5,
conforme podemos conferir na figura abaixo:
Programa em Execução
Agora gostaria de chamar atenção para a seguinte linha de código destacada

abaixo em nosso programa :
{
contador++;
O que faz esse “++” após a variável ? Esse “++” funciona como se fosse um
incremento de variável, ou seja, a linha destacada acima equivale a :
contador = contador + 1;
9.9.2) A estrutura de repetição DO/WHILE
A estrutura de repetição DO/WHILE (similar ao loop REPITA/ATE lá do Visualg,

mas, com o mesmo comportamento do ENQUANTO) repete um bloco de
código enquanto uma determinada condição for satisfeita. A diferença do DO/
WHILE para o WHILE do Java é que a pergunta é feita no fim do loop
(comparando-se ao loop REPITA/ATE do Visualg), mas sabendo que o loop só
permanecerá executando enquanto a condição for verdadeira.
238
Vejamos a sintaxe da estrutura DO/WHILE abaixo :
do
{
<instrução1>;
<instrução2>;
:
<instruçãon>;
}
while(<condição>);
Vamos desenvolver agora o mesmo exemplo anterior do algoritmo, usando

agora a estrutura D/WHILE (criar uma classe chamada Loop2).
int contador = 1;
do
{
contador++;
}
while(contador <= 5);
}
239
9.9.3) A estrutura de repetição FOR
A estrutura de repetição FOR (equivalente ao loop PARA/FACA lá do Visualg)

repete um bloco de código até uma certeza quantidade de vezes estipulados
no parâmetro do loop.
Vejamos a sintaxe do loop:
for(<inicialização ;<condição>;<incremento>)
<instrução>
O loop de repetição FOR é formado por três parâmetros que irei mencionar
aqui:
<inicialização> : Neste parâmetro inicializamos a variável de controle que

será ser controlada (incrementada) pelo loop.
<condição> : Neste parâmetro temos a condição que mantém o loop em

execução. Mesmo falando que o loop irá se repetir um certo número de
vezes, no FOR do Java o que determina isso é uma condição.
<incremento> : Neste parâmetro a variável é incrementa (podendo fazer

incremento de um em um, de dois em dois, ou melhor, de acordo com que
você escolher).
Vamos agora desenvolver o mesmo exemplo anterior usando o loop FOR do

Java (criar uma classe chamada Loop3) :
for(int contador = 1; contador <=5 ; contador++)

}
Código bem simples e fácil de escrever não ?
240
Bom, embora o código escrito em Java tenha consumido somente poucas
linhas de comando, será preciso mostrar para você como isso funciona (visto
que o loop FOR possui uma estrutura particularmente diferente do que
aprendemos no PORTUGOL do Visualg). Vamos a simulação :
}
A primeira instrução já começa
processando o loop de repetição “for”.
Bom, como estamos iniciando o loop “for” aqui, o primeiro

estágio a ser executado é a inicialização do loop. Isso envolve a
criação da variável contador (que só será vista dentro do loop) ,
assim como a sua inicialização com o valor 1. E depois.....(segue a
seta)
}
Temos a segunda etapa, onde avaliamos a condição
}
do loop. Como a condição é verdadeira, o loop é
iniciado.
241
} Aqui imprimimos o valor do “contador” na tela.
} O “loop” terminou. E agora ???

}
}
Voltamos agora para o início do
} loop.
Aqui nessa etapa, incrementamos a variável

“contador” (passo de 1 para 2).
242
}
Novamente voltamos para a avaliação da condição do
}
loop. Como a condição AINDA É VERDADEIRA,
entramos dentro do bloco novamente.
} Aqui imprimimos o valor do “contador” na tela.
} O “loop” terminou. E agora ???

}
243
}
Voltamos agora para o início do
} loop.
Vamos supor aqui que antes do incremento da

variável “contador” a mesma assumisse o valor
“5” (supondo que já foi incrementado várias
vezes). Agora ela irá passar de “5” para “6”.
}
Novamente voltamos para a avaliação da condição do
}
loop. AGORA A CONDIÇÃO TORNA-SE FALSA, pois o
valor da variável “contador” é acima de 5, finalizando
o loop.
244
9.10) Vetores (Arrays)
Assim também como no Visualg, utiliza-se muito os vetores na linguagem Java.

O termo mais empregado utilizado ao se trabalhar com esse tipo de estrutura é
“array”, portanto, iremos enfatizar o termo “array” para tratarmos os vetores.
Sintaxe para a declaração de um vetor:
<tipo> <variável>[ ] = new <tipo>[<número de elementos];
Vejamos um exemplo abaixo:
double media[ ] = new double[9];
Observando (e interpretando) a declaração do nosso vetor acima, criamos um

“array” chamado média para armazenar 9 valores na memória.
No Java , diferente do Visualg , toda a primeira posição do array assume o

índice “0” (ZERO). Veja como as posições são interpretadas na declaração
acima :
Posição 1 2 3 4 5 6 7 8 9
Índice 0 1 2 3 4 5 6 7 8
Então, se eu tenho um vetor de 8 posições, cada elemento será indexado de 0

a 7. Se eu tenho um array de 10 posições, ele será indexado de 0 a 9. Se eu
tenho um vetor de “n” posições, ele será indexado de 0 até n-1.
Acessando cada posição (supondo um array de 9 posições) :
media[0] = 10; //Grava na primeira posição

media[1] = 9; //Grava na segunda posição
media[2] = 6; //Grava na terceira posição
media[3] = 7.5; //Grava na quarta posição
media[4] = 7.5; //Grava na quinta posição
media[5] = 8; //Grava na sexta posição
media[6] = 7.5; //Grava na sétima posição
media[7] = 9; //Grava na oitava posição
media[8] = 7.5; //Grava na nona posição
245
Para utilizarmos os arrays do Java na prática, vamos desenvolver um algoritmo
para ler 10 nomes de alunos e suas respectivas médias. Ao final, mostrar o
nome de cada aluno e sua respectiva situação (aprovado se a média for >= 7 e
reprovado caso contrário). Criar uma classe chamada Array1 :
public class Array1 {
//Se são 10 posições, especificar no índice 9

String nome[] = new String[10];
double media[] = new double[10];
for(int contador = 0; contador < 10 ; contador++)

{
System.out.println("Digite o nome do " + (contador + 1) +
" º aluno : ");
nome[contador] = teclado.nextLine();
System.out.println("Digite sua média :");
media[contador] = teclado.nextDouble();
teclado.nextLine();
}
for(int contador = 0; contador < 10 ; contador++)

{
System.out.println("O nome do " + (contador + 1) + " º
aluno : é " + nome[contador]);
if(media[contador] >= 7)
System.out.println("Você ESTÁ APROVADO");
else
System.out.println("Você ESTÁ REPROVADO");
246
9.11) Usando métodos
O conceito de método é igual ao aplicado as sub-rotinas (procedimentos e

funções) usados no PORTUGOL no Visualg, não muda absolutamente nada.
Utiliza-se o conceito (palavra) método pelo fato de estarmos trabalhando com

Linguagem Orientada a Objetos, (pois Java é puramente Orientado a Objeto),
onde a palavra sub-rotina não é muito utilizada (mesmo sabendo que um
método nada mais é do que uma rotina).
Existem dois tipos de métodos na linguagem Java : os que não retornam

valores (void) e os que retornam valores (qualquer coisa que não seja void).
Um método que não retorna valor é declarado e especificado com void.

Vejamos a sintaxe da declaração de um método abaixo:
void <nome do método>()

{
<instruções>
}
Vejamos um exemplo abaixo:
void MostrarBomDia()
{
System.out.println(“Bom dia”);
}
247
Vamos agora criar um algoritmo em Java que irá possuir uma rotina para
mostrar a mensagem “ESTOU APRENDENDO PROGRAMAÇÃO PARA
ANDROID”. Criar uma classe chamada Metodo1 :
public class Metodo1 {
static void MostrarMensagem()

{
System.out.println("ESTOU APRENDENDO PROGRAMAÇÃO PARA ANDROID");
}
MostrarMensagem();
}
Gostaria de chamar atenção aqui para a palavra static usada antes da palavra
void. Por padrão no Java, quando chamamos algum método dentro de um
outro método cuja declaração é especificada como static, o método chamado
também deve ser declarado como static.
Usando parâmetros nos métodos
Assim também como nas sub-rotinas, também é possível trabalhar com

parâmetros nos métodos do Java. Vejamos abaixo como é feita a declaração :
void <nome do método>(<tipo> <variável>, <tipo> variável2>,...,<tipo>

<variável>)
{
<instruções>
}
Para demonstrar o uso de parâmetros vamos criar um algoritmo em Java para

ler dois números inteiros. Após a leitura dos números chamar uma rotina
chamada “Somar” para efetuar a soma dos dois números pelo teclado
(passando os mesmos via parâmetro na rotina). Criar uma classe chamada
Metodo2 :
248
static void Somar(int n1, int n2)

{
int resultado = n1 + n2;
System.out.println("A soma é : " + resultado);

}
int numero1, numero2;
System.out.println("Digite o primeiro número : ");
numero1 = teclado.nextInt();
System.out.println("Digite o segundo número : ");
Somar(numero1, numero2);
O outro tipo de método que havia abordado são os que retornam valores.
Vejamos abaixo como declarar a sua estrutura :
<tipo> <nome do método>(<parâmetros, se houver>)

{
<instruções>
return <valor>;
}
Para demonstrar o uso de funções vamos criar uma função chamada Somar
(como o do exemplo anterior), só que ao invés da função mostrar na tela a
soma dos números, ela irá “retornar” o valor da soma para uma variável. Criar
uma classe chamada Metodo3 :
249
static int Somar(int n1, int n2)

{
int resultado = n1 + n2;
return resultado;
}
int numero1, numero2;
System.out.println("Digite o primeiro número : ");
System.out.println("Digite o segunda número : ");
int somaNumeros = Somar(numero1,numero2);
System.out.println("A soma é : " + somaNumeros);

}
250
9.11) Lista de Exercícios em Java
Neste tópico iremos realizar uma série de exercícios a respeito de

programação com algoritmos em Java que aprendemos até agora para reforçar
o nosso aprendizado. Os exercícios estarão dividido em categorias, de forma a
facilitar o aprendizado. Alguns exercícios já estarão resolvidos e outros você
terá que desenvolver. Bom aprendizado.
9.11.1) Programação Sequencial
Exercício 1 : Desenvolver um algoritmo em Java para mostrar na tela a

seguinte mensagem : “ESSE É O MEU PRIMEIRO EXERCÍCIO EM JAVA”.
public class Exercicio_Programacao_Sequencial_1 {
System.out.println("ESSE É O MEU PRIMEIRO EXERCÍCIO EM JAVA.");
Exercício 2 : Desenvolver um algoritmo em Java para mostrar na tela a

seguinte mensagem : “EU SOU PROGRAMADOR”.
System.out.println("EU SOU PROGRAMADOR.");
Exercício 3 : Desenvolver um algoritmo para mostrar na tela a seguinte frase

popular :
“Os professores abrem a porta,

mas você deve entrar por você mesmo.”.
251
System.out.println("Os professores abrem a porta,");

System.out.println("mas você deve entrar por você mesmo.");

“Um momento de paciência pode evitar um grande desastre,

Um momento de impaciência pode arruinar toda uma vida”.

“A informática esta interligada ao mundo

sobre as reações intergalaxias!
Bill Gates”
9.11.2) Variáveis
Exercício 1 : Desenvolver um algoritmo que leia do teclado duas notas de um

aluno. Ao final, o programa deverá mostrar a média das duas notas na tela:
public class Exercicio_Variaveis_1 {
double nota1, nota2, media;
252
System.out.println("Digite a primeira nota : ");
System.out.println("Digite a segunda nota : ");

media = (nota1 + nota2) / 2;
System.out.println("A média é : " + media);
Exercício 2 : Desenvolver um algoritmo que leia do teclado o salário base de

um funcionário. Com o salário base , calcule :
Vale transporte : salario base * 6%

INSS : salario base * 8%
Salário Líquido : salário base - vale transporte – INSS
Ao final, mostrar o salário líquido do funcionário:
double salario_base, vale_transporte,inss,salario_liquido;

System.out.println("Digite o salario base do funcionarío : ");

salario_base = teclado.nextDouble();
vale_transporte = salario_base * 0.06;
inss = salario_base * 0.08;
salario_liquido = salario_base - vale_transporte - inss;
System.out.println("O salario liquido do funcionário é : " +
salario_liquido);
253
Exercício 3 : Desenvolver um algoritmo que leia do teclado uma temperatura
em Celsius. Em seguida , a temperatura deverá ser convertida para Fahrenheit.
A fórmula de conversão é : F = C * 1,8 + 32. No final, o programa deverá
mostrar a temperatura convertida para Fahrenheit:
double celsius , fahrenheit;
System.out.println("Digite a temperatura em Celsius : ");

celsius = teclado.nextDouble();
fahrenheit = celsius * 1.8 + 32;

System.out.println("A temperatura em Fahrenheit é : " +
fahrenheit);
Exercício 4 [RESOLVER]: Desenvolver um algoritmo que leia do teclado uma

temperatura em Celsius. Em seguida , a temperatura deverá ser convertida
para Kelvin. A fórmula de conversão é K = C + 273,15. No final, o programa
deverá mostrar a temperatura convertida para Kelvin:
Exercício 5 [RESOLVER]: Desenvolver um algoritmo que obtenha a área de

um triângulo. Para isso será necessária a leitura via teclado da base e da altura
do triângulo. A fórmula para obter a área do triângulo é : área = (base * altura) /
2. Ao final o programa deverá mostrar a área do triângulo na tela.

preço de um produto e a quantidade a ser levada dele. Ao final o programa
deverá mostrar o valor total a ser pago.
254
9.11.3) Estrutura condicional

sua situação (se ele foi “aprovado” , caso a média dele seja maior ou igual a 7,
ou “reprovado”, se a média for menor que 7).
public class Exercicio_Condicional_1 {
String nome;
double media;
System.out.println("Digite o nome do aluno: ");

System.out.println("Digite a sua média : ");

System.out.println("O nome do aluno é : " + nome);
if(media >= 7)
System.out.println("Ele está APROVADO");
else
System.out.println("Ele está REPROVADO");
255
sua situação :
“APROVADO”, Caso a média seja >= 7

“RECUPERAÇÃO”, Caso a média seja < 7 e maior ou igual que 4
“REPROVADO”, Caso a média seja < 4
String nome;
double media;
System.out.println("Digite o nome do aluno: ");


if(media >= 7)
{
System.out.println("O aluno" + nome + " está APROVADO");
}
else
{
if(media >= 4)
{
System.out.println("O aluno" + nome + " está EM
RECUPERAÇÃO");
}
else
{
System.out.println("O aluno" + nome + " está EM
REPROVADO");
}
}
256
Exercício 3 : Desenvolver um algoritmo que leia do teclado dois números
inteiros A e B. Após a leitura verificar se B e maior A, caso verdadeiro, exibir os
números nessa ordem : A, B. Caso B seja menor que A mostrar os números
nessa ordem : B, A.

int a,b;
System.out.println("Digite o valor de A");

a = teclado.nextInt();
System.out.println("Digite o valor de B");

b = teclado.nextInt();
if(b > a)
{
System.out.println("Os números são : " + a + "," + b);
}
else
{
System.out.println("Os números são : " + b + "," + a);
}
}
Exercício 4 : Desenvolver um algoritmo que leia do teclado o salário de um

funcionário. Após a leitura calcular o novo salário do funcionário mediante as
seguintes condições abaixo:
Se salário <= 500 , novo salário = salario + 20%

Se salário > 500 e < 1000 , novo salário = salario + 15%
Se salário > 1000 , novo salário = salario + 10%
257
double salario,novo_salario;
System.out.println("Digite o salário do funcionário : ");

salario = teclado.nextDouble();
if(salario <= 500)

novo_salario = salario * 1.2;
else
if(salario <= 1000)
else
System.out.println("O novo salário do funcionário é : " +

novo_salario);
Exercício 5 : Desenvolver um algoritmo que leia uma temperatura em Celsius.

Em seguida, o programa deverá mostrar duas opções para o usuário , em que
o usuário deverá digitar 1 para converter a temperatura em Fahrenheit e 2 para
Kelvin. Escolhida a opção desejada, realizar a conversão da temperatura e ao
final mostrar o resultado.
int opcao;
double temp_convertida;
double celsius;
System.out.println("Digite a temperatura em Celsius : ");

celsius = teclado.nextDouble();
258
//O símbolo \n equivale a uma quebra de linha
System.out.println("Escolha sua opção de conversão\n");
System.out.println("[1] - Fahrenheit");
System.out.println("[2] - Kelvin\n");
System.out.println("Qual a sua opção : ");

opcao = teclado.nextInt();
if(opcao == 1)
{
temp_convertida = celsius * 1.8 + 32;
System.out.println("A temperatura convertida em Fahrenheit
é : " + temp_convertida);
}
else
{
temp_convertida = celsius + 273.15;
System.out.println("A temperatura convertida em Kelvin é :
" + temp_convertida);
}
Exercício 6 : Desenvolver um algoritmo que leia a idade de um nadador e em

seguida, mostre a sua classificação, conforme podemos conferir abaixo:
infantil A = 5 - 7 anos
infantil B = 8-10 anos
juvenil A = 11-13 anos
juvenil B = 14-17 anos
adulto = maiores de 18 anos
259
int idade;
System.out.println("Digite a idade do nadador :");

idade = teclado.nextInt();
if((idade>=5) && (idade <= 7))

{
System.out.println("Classificação : INFANTIL A");
}
else
{
if(idade <= 10)
{
System.out.println("Classificação : INFANTIL B");
}
else
{
if(idade <= 13)
{
System.out.println("Classificação : JUVENIL A");
}
else
{
if(idade <= 17)
{
System.out.println("Classificação : JUVENIL B");
}
else
{
System.out.println("Classificação : ADULTO");
}
}
}
}
}
}
260
sexo do usuário (“M” para masculino e “F” para feminino) e sua altura.
Obtido os dados, calcule e mostre o peso ideal desse usuário. Veja o
cálculo do peso ideal abaixo:
Peso ideal de homem = (72,7 x altura) - 58

Peso ideal da mulher = (62,1 x altura) - 44,7
Exercício 7 [RESOLVER]: Uma lanchonete vende os seus produtos, de

acordo com a tabela abaixo :
Código Item Preço

100 Cachorro Quente 1,10
101 Bauru Simples 1,30
102 Bauru com Ovo 1,55
103 Hambúrguer 1,20
Desenvolver um algoritmo que leia do teclado o código do item a ser

comprado e a sua quantidade. Ao final o programa deverá mostrar o valor
total da compra.
Exercício 8 [RESOLVER]: Desenvolver um algoritmo que leia do teclado dois

números inteiros A e B . Se o número A for maior que (B * 2), dividir o valor de
B com A e jogar o resultado em uma variável X. Se a condição for falsa,
multiplicar o valor de A com o valor de B e em seguida jogar o resultado em
uma variável X. Ao final deverá ser mostrado o valor contido em X.

salário base de um funcionário e o número de filhos que ele possui. Ao final o
programa deverá calcular e mostrar o valor do “Salário Família”, de acordo com
a tabela abaixo:
Condição Item
Salário Base < 530
24,64
Salário Base < 810
19,48
Salário Base > 810 Salário Família = 0
261
9.11.4) Estrutura de repetição

e 50 (usando o loop WHILE).
public class Exercicio_Repeticao_1 {
int contador = 1;
{
contador++;
}

e 50 (usando o loop DO/WHILE).
int contador = 1;
do
{
contador++;
}
while(contador <= 50);
262
e 50 (usando o loop FOR).
for(int contador = 1; contador <= 50 ; contador++)

{
}
}
}
Exercício 4 : Desenvolver um algoritmo que some todos os números entre 10

e 30 (usando loop PARA).
//Lembre-se : como iremos armazenar a soma dos números, a

//variável "soma"deverá começar com ZERO
int soma = 0;

{
soma = soma + contador;
}
System.out.println("A soma dos números é : " + soma);
}
}
Exercício 5 : Desenvolver um algoritmo que some e mostre :
Todos os números entre 10 e 50 (incluído pares e impares)

Todos os números pares somente entre 10 e 50
Todos os números impares somente entre 10 e 50
OBS : Usando o loop DO/WHILE:
263
//Lembre-se : como iremos armazenar a soma dos números, as

// variáveis deverão começar com ZERO
int soma_todos = 0, soma_pares = 0, soma_impares = 0;

{
soma_todos = soma_todos + contador;
//É um número par
if((contador % 2) == 0)
soma_pares = soma_pares + contador;
else
soma_impares = soma_impares + contador;
}
System.out.println("A soma de todos os números entre 10 e 50 é :
" + soma_todos);
System.out.println("A soma de todos os números pares entre 10 e
50 é : " + soma_pares);
System.out.println("A soma de todos os números impares entre 10
e 50 é : " + soma_impares);
Exercício 6 : Desenvolver um algoritmo que leia um número inteiro “n”. Ao

final o programa deverá mostrar todos os números impares e pares entre 1 e
“n” (usar loop WHILE).
// Lembre-se : como iremos armazenar a soma dos números, as

// variáveis deverão começar com ZERO
int soma_pares = 0, soma_impares = 0;
int n;
264
System.out.println("Digite um número inteiro :");
n = teclado.nextInt();
for (int contador = 1; contador <= n; contador++) {
// É um número par
if ((contador % 2) == 0)
soma_pares = soma_pares + contador;
else
soma_impares = soma_impares + contador;
}
System.out.println("A soma de todos os números pares entre 10 e

" + n + " é : "+ soma_pares);
System.out.println("A soma de todos os números impares entre 10
e " + n + " é : " + soma_impares);
}
}
Exercício 7 : Desenvolver um algoritmo que leia do teclado 10 números

inteiros do teclado. Ao final o programa deverá mostrar o total de números
pares e impares lidos, como também a soma de todos os números impares e
pares lidos do teclado (usar loop FOR).
// Lembre-se : como iremos armazenar a soma e contagem dos

//números, as variáveis deverão começar com ZERO
int conta_par = 0, conta_impar = 0, soma_par = 0, soma_impar =

0;
int numero;

{
System.out.println("Digite o " + contador + " número :");
if((numero % 2) == 0)
{
conta_par++;
soma_par= soma_par + numero;
}
265
else
{
conta_impar++;
soma_impar= soma_impar + numero;
}
}
System.out.println("Total de números pares : " + conta_par);

System.out.println("Total de números impares : " + conta_impar);
System.out.println("Soma dos números pares : " + soma_par);
System.out.println("Soma dos números impares : " + soma_impar);
}
}
Exercício 8 : Desenvolver um algoritmo que leia um número inteiro do teclado.

Em seguida o programa deverá calcular e retornar o fatorial do número lido.
Veja um exemplo abaixo do que seria um fatorial (usar o WHILE) :
Fatorial do número 5 (5!) = 5 * 4 * 3 * 2 * 1 = 120

Fatorial do número 6 (6!) = 6 * 5 * 4 * 3 * 2 * 1 = 720
int fatorial = 1;
int numero;
System.out.println("Digite um numero inteiro :");

int contador = 1;
while (contador <= numero)

{
fatorial = fatorial * contador;
contador++;
}
System.out.println("O fatorial de " + numero + " é : " +

fatorial);
}
}
266
Exercício 9 : Desenvolver um algoritmo que leia dois números inteiros do
teclado. Em seguida, o programa deverá mostrar uma lista de opção para
usuário referente a operação aritmética.
[1] – Para adição

[2] – Para subtração
[3] – Multiplicação
[4] – Divisão
Escolhendo uma das opções acima, mostrar o resultado da operação aritmética

escolhida . Ao final, o programa deverá perguntar ao usuário se ele deseja
continuar a fazer as contas ou não (respondendo “S” para continuar ou “N” para
sair).Usar o loop WHILE :
double numero1,numero2;
double resultado = 0;
int opcao;
String resposta = "S";
while(resposta.equals("S"))
{
System.out.println("Digite o primeiro numero : ");
numero1 = teclado.nextDouble();
System.out.println("Digite o segundo numero : ");

numero2 = teclado.nextDouble();
System.out.println("Escolha a sua opção\n");

System.out.println("[1] - Adição");
System.out.println("[2] - Subtração");
System.out.println("[3] - Multiplicação");
System.out.println("[4] - Divisão\n");

opcao = teclado.nextInt();
switch(opcao)
{
case 1 : resultado = numero1 + numero2; break;
case 2 : resultado = numero1 - numero2; break;
case 3 : resultado = numero1 * numero2; break;
case 4 : resultado = numero1 / numero2; break;
}
267
System.out.println("O resultado da operação é : " +
resultado);
//Limpa o buffer o ultimo valor lido do teclado

teclado.nextLine();
System.out.println("\nContinua ? [S/N]");
resposta = teclado.nextLine();
resposta = resposta.toUpperCase();
}
}
}

inteiro do teclado, e ao final mostrar a tabuada do número lido (de 1 até 10) .
(usar o loop DO/WHILE)

inteiro X e um outro número inteiro Y. Ao final o programa deverá calcular e
mostrar o resultado da potência XY . (usar o loop FOR)
Veja um exemplo de potência :
23 = 2 * 2 * 2 = 8

inteiro “n” qualquer. Ao final o programa deverá efetuar o seguinte cálculo :
1 / 1 + 1 / 2 + 1/3 + 1/4 ......1/n.
Após o cálculo da expressão acima, mostrar o resultado na tela (usar o loop

WHILE).
268
9.11.5) Arrays

armazena cada número lido dentro do vetor. Em seguida, pegar cada número
armazenado dentro do vetor e fazer a seguinte operação :
Se numero for par , multiplicar o mesmo por 2, atualizando no vetor

Se numero for impar, multiplicar o mesmo por 3, atualizando no vetor
Ao final, mostrar o conteúdo do vetor na tela.
public class Exercicio_Array_1 {
int numero[] = new int[10];

//Lembre-se: se tenho um array de 10 posições
//os elementos serão indexados de 0 a 9. OK ?
for(int contador = 0 ; contador < 10 ; contador++)

{
System.out.println("Digite o " + (contador + 1) +
" numero");
numero[contador] = teclado.nextInt();
if((numero[contador] % 2) == 0)
numero[contador] = numero[contador] * 2;
else
numero[contador] = numero[contador] * 3;
}
{
System.out.println("O valor do " + (contador + 1) +
" numero é : " + numero[contador]);
}
269
armazenar cada número lido dentro de um vetor. Em seguida, mostrar o
conteúdo do vetor na ordem INVERSA da leitura.
int numero[] = new int[10];


{
" numero");
numero[contador] = teclado.nextInt();
}
for(int contador = 9 ; contador >= 0 ; contador--)
{
System.out.println("O valor do " + (contador + 1) +
"numero é : " + numero[contador]);
}

armazenar cada número lido dentro do vetor A. Criar um vetor B que irá conter
todos os números presentes do vetor A multiplicados por 3, ou seja :
B[índice] = A[índice] * 3
Ao final o programa deverá apresentar todos os números presentes dentro do

vetor B.
270
int A[] = new int[10];

int B[] = new int[10];

{
" numero");
A[contador] = teclado.nextInt();
B[contador] = A[contador] * 3;
}
for(int contador = 0 ; contador < 10; contador++)
{
System.out.println("O " + (contador + 1) + " valor do
vetor B é : " + B[contador]);
}
Exercício 4 : Desenvolver um algoritmo para ler 10 nomes de alunos e suas

respectivas médias, sabendo que os nomes estarão armazenados em um vetor
e as médias dos alunos em outro vetor. Ao final o programa deverá mostrar na
tela o nome do aluno, sua média e sua situação (de acordo com a tabela
abaixo):
Condição Média
Média >= 7 APROVADO
Média >= 5 e Média < 7 RECUPERAÇÃO
Média < 5 REPROVADO
271

double media[] = new double[10];

{
System.out.println("Digite o nome do " + (contador + 1) +
" aluno : ");
media[contador] = teclado.nextDouble();
}

{
{
System.out.println("O aluno " + nome[contador] +
" possui a média " + media[contador] + " e ESTÁ
APROVADO");
}
else
{
{
System.out.println("O aluno " +
nome[contador] + " possui a média " +
media[contador] + " e ESTÁ EM RECUPERAÇÃO");
}
else
{
System.out.println("O aluno " +
nome[contador] + " possui a média " +
media[contador] + " e ESTÁ REPROVADO");
}
}
}
272
Exercício 5 : Desenvolver um algoritmo para ler 20 nomes do teclado, sabendo
que esses nomes estarão armazenadas em um vetor. Em seguida, o programa
deverá ordenar o vetor de forma que os nomes estejam em ORDEM
CRESCENTE. No final o programa deverá mostrar os nomes ordenados na
tela.

{
" nome : ");
for(int i = 0; i < 9 ; i++)

{
for(int j = i + 1; j < 10 ; j++)
{
//Verifica se nome[i] é maior do que nome[j]
if(nome[i].compareTo(nome[j]) > 0)
{
//Ordena os nomes
String temp = nome[i];
nome[i] = nome[j];
nome[j] = temp;
}
}
}
System.out.println("Exibindo os nomes em ORDEM CRESCENTE\n\n");

{
System.out.println(nome[contador]);
273
Exercício 6 [RESOLVER]: Desenvolver um algoritmo para ler 20 nomes do
teclado, sabendo que esses nomes estarão armazenadas em um vetor. Em
seguida, o programa deverá ordenar o vetor de forma que os nomes estejam
em ORDEM DECRESCENTE. No final o programa deverá mostrar os nomes
ordenados na tela.
Exercício 7 [RESOLVER]: Desenvolver um algoritmo para ler 20 nomes de

funcionários e seus respectivos salários. Em seguida, o programa deverá
mostrar o nome do funcionário e seu salário reajustado de acordo com a tabela
abaixo :
Condição Média
Salario < 500 Reajuste = Salario 20%
Salario >= 500 Salario < 900 Reajuste = Salario 15%
Salário >= 900 Reajuste = Salario 10%
Exercício 8 [RESOLVER]: Desenvolver um algoritmo para preencher dois

vetores A e B, ambos com 10 posições, com valores numéricos inteiros. Criar
um vetor C que irá conter a soma dos valores dos vetores A e B, ou seja :
C[índice] = A[índice] + B[índice]
Ao final o programa deverá mostrar o conteúdo do vetor C na tela.
274
9.11.6) Métodos
Exercício 1 : Crie um método que calcule e mostre o fatorial de um número

inteiro qualquer lido do teclado.
public class Exercicio_Metodo_1 {
static void fatorial(int n)

{
int fat = 1;
for(int contador = 1 ; contador <= n ; contador++)
fat = fat * contador;
System.out.println("O fatorial de " + n + " é : " + fat);

}
int numero;

fatorial(numero);
Exercício 2 : Crie um método que calcule e retorne o fatorial de um número

inteiro qualquer lido do teclado. Ao final mostrar o fatorial na tela.
static int fatorial(int n)

{
int fat = 1;
for(int contador = 1 ; contador <= n ; contador++)
fat = fat * contador;
return fat;
}
275
int numero;

int resultado = fatorial(numero);
System.out.println("O fatorial de " + numero + " é : " +

resultado);
}
Exercício 3 : Crie uma função parar converte uma temperatura em Celsius

(lida do teclado) em Fahrenheit. Ao final o programa deverá mostrar a
temperatura convertida na tela.
funcao converteFahrenheit(c : real) : real

inicio
retorne (c * 1.8) + 32
fimfuncao
var
celsius : real
temp_fahrenheit : real
inicio
escreva("Digite uma temperatura em Celsius : ")

leia(celsius)
temp_fahrenheit <- converteFahrenheit(celsius)
escreva("A temperatura convertida em Fahrenheit é :
",temp_fahrenheit)
fimalgoritmo
276
Exercício 4 : Crie um método parar retornar a média das quatro notas de um
aluno lidas do teclado. Ao final a média (retornada pelo método) deverá ser
mostrada na tela.
static double calcularMedia(double n1, double n2, double n3, double

n4)
{
return (n1 + n2 + n3 + n4) / 4;
}
double nota1, nota2, nota3, nota4;
System.out.println("Digite a primeira nota");

System.out.println("Digite a segunda nota");
System.out.println("Digite a terceira nota");
System.out.println("Digite a quarta nota");
System.out.println("A média é : " + calcularMedia(nota1, nota2,

nota3, nota4));
}
277
Exercício 5 : Crie um método parar mostrar um determinado mês na tela, de
acordo com o valor passado como parâmetro para a sub-rotina. Por exemplo,
se o valor passado para o procedimento for “1”, mostrar na tela “Janeiro”. Se o
valor for “2”, mostrar “Fevereiro” e assim por diante.
static void MostrarMes(int num_mes)

{
switch (num_mes) {
case 1: System.out.println("Janeiro");break;
case 2: System.out.println("Fevereiro");break;
case 3: System.out.println("Março");break;
case 4: System.out.println("Abril");break;
case 5: System.out.println("Maio");break;
case 6: System.out.println("Junho");break;
case 7: System.out.println("Julho");break;
case 8: System.out.println("Agosto");break;
case 9: System.out.println("Setembro");break;
case 10: System.out.println("Outubro");break;
case 11: System.out.println("Novembro");break;
case 12: System.out.println("Dezembro");break;
default : System.out.println("MÊS INVÁLIDO");break;
}
}
int mes;
System.out.println("Digite um número [1-12] :");

mes = teclado.nextInt();
MostrarMes(mes);
}
278
Exercício 6 [RESOLVER]: Crie uma função parar retornar um determinado
mês, de acordo com o valor passado como parâmetro para a sub-rotina. Por
exemplo, se o valor passado para a função for “1”, retornar “Janeiro”. Se o valor
for “2”, retornar “Fevereiro” e assim por diante. Ao final o programa deverá
mostrar o mês retornado pela função na tela.
Exercício 7 [RESOLVER]: Desenvolver um algoritmo para ler 15 números do

teclado, armazenando-os em um vetor. Após a leitura todos os números dentro
do vetor A deverão ser ordenados em ordem crescente, e essa operação de
ordenação deverá ser efetuado por um procedimento que deverá ser criado no
programa. Ao final, mostrar todos os valores ordenados.

nome do funcionário, o salário base dele, e o número de filhos que ele tem. Ao
final, com base no salário do funcionário, realizar os seguintes cálculos (que
deverão ser realizados, cada um, por uma função)
Salário Família (a ser calculado e retornado por uma função) : Veja os critérios
para o cálculo do Salário Família :
Condição Retorno
Salário Base < 539,08 Número de Filhos * 27,64
(Salário Base >= 539,08) e
Número de Filhos * 19,48
(Salário Base < 810,18)
Salário Base > = 810,18 0
INSS (a ser calculado e retornado por uma função) : Veja a fórmula para o
cálculo do INSS : INNS = Salário Base * 8%
VALE TRANSPORTE (a ser calculado e retornado por uma função) : Veja a

fórmula para o cálculo do VALE TRANSPORTE : VALE TRANSPORTE =
Salário Base * 6%
SALÁRIO LIQUIDO (a ser calculado e retornado por uma função) : Veja a

fórmula para o cálculo do SALÁRIO LIQUIDO : SALÁRIO LIQUIDO = SALARIO
BASE + SALARIO FAMILIA – INSS – VALE TRANSPORTE
Ao final o programa deverá mostrar na tela : SALÁRIO FAMILIA, INSS, VALE

TRANSPORTE E SALÁRIO LIQUIDO.
279
Capitulo 10 Fundamentos
sobre Programação Orientada a
Objetos
A
té aqui aprendemos as técnicas fundamentais de desenvolvimento de
aplicações usando a linguagem de Java (com ela já é possível
desenvolvermos nossas aplicações para Android), mas, antes de
começarmos por definitivo a programação com Android, vamos aprender
algumas técnicas muito importantes que havia citado durante o
desenvolvimento de aplicações em Java : A Programação Orientada a Objetos
(POO).
10.1) O que é Programação Orientada a Objetos ?
Desde quando começamos a programar com algoritmos usando o

PORTUGOL, seguimos um modelo conhecido como PROGRAMAÇÃO
ESTRUTURADA, onde nós temos um programa devidamente estruturado com
as suas instruções , e cada comando é executado em uma sequência, um após
a outro. Um modelo primitivo e básico de programação.
A Programação Orientada a Objetos (modelo adotado pela linguagem Java) ,

nada mais é do que a evolução da programação estruturada, onde utilizamos
objetos e classes como unidade básica de dados e ações de um programa.
10.2) O que é uma classe ?
Classe em Programação Orientada a Objetos nada mais é do que uma

abstração ou projeto de como um objeto é feito. Como podemos observar, todo
programa escrito em Java fica “encapsulado” dentro de uma classe (a classe
main). A classe possui naturalmente é seguinte estrutura:
280
Sintaxe :
class <nome da classe>

{
<estrutura>
}
10.3) O que é um atributo ?
Um atributo de uma classe nada são é do que as variáveis que são declaradas
dentro dela. Para que vocês possam entender claramente o que vem a ser
atributo, traduzindo isso para o PORTUGOL do Visualg, seriam as variáveis
globais que são acessadas pelas sub-rotinas (chamadas aqui de métodos).
Um atributo está relacionado as propriedades, características de uma classe.

Para que você possa ter uma ideia, vamos imaginar um carro, um carro
qualquer. Quais seriam as propriedades de um carro por exemplo ? Nós temos:
cor, modelo, placa ,ano e etc.
Vejamos abaixo a sintaxe da declaração de atributos (variáveis) de uma classe:
Sintaxe :

{
<tipo> <nome do atributo>;
<tipo> <nome do atributo2>;
:
<tipo> Nome do atributo n>;
}
Exemplo : Não tem o exemplo que demos agora do carro ? Vejamos como isso
seria estruturado em uma classe, com os seus devidos atributos :
class Carro
{
String modelo;
String cor;
String placa;
int ano;
}
281
10.4) O que é um método ?
Reforçando mais uma vez aqui, só que agora de uma forma bem mais clara, os
métodos nada mais são do que as funções (sub-rotinas) que são declaradas
dentro da classe, que executam alguma ação.
Voltando ao exemplo do carro : Nós temos lá o nosso o veículo certo ? Quais

seriam as possíveis ações desse veículo ? Vejamos algumas : Andar para
frente, Andar para trás, Virar para direita, Virar para esquerda e etc.
Vejamos agora abaixo a sintaxe da declaração de um método (claro, mesmo já

sabendo que já havíamos utilizado no capítulo anterior):
Sintaxe :

{
<tipo> <nome do método1>(<parâmetros, se houver>)

{
<instruções>;
}
<tipo> <nome do método2>(<parâmetros, se houver>)

{
<instruções>;
}
:
<tipo> <nome do métodon>(<parâmetros, se houver>)
{
<instruções>;
}
282
Vejamos abaixo um exemplo da classe Carro (citada anteriormente) declarada
com os seus respectivos métodos (incluindo também seus atributos)
class Carro
{
String modelo;
String cor;
String placa;
int ano;
void andarPraFrente()
{
void andarPraTras()
{
void virarPraDireita()
{
void virarPraEsquerda()
{
10.5) O que são modificadores de escopo ?
Os modificadores de escopo são palavras reservadas que definem o grau de

visibilidade dos atributos e métodos e uma classe. São eles :
public : Esse modificador define que todos os atributos e métodos

especificados com essa palavra possuam escopo “publico”, sendo visível
e acessado tanto pela classe onde os mesmos foram declarados e por
outros programas.
283
private : Esse modificador define que todos os atributos e métodos
especificados com essa palavra possuam escopo “privado”, sendo visível
e acessado somente pela classe onde os mesmos foram declarados,
nunca por outros programas.
protected : Esse modificador define que todos os atributos e métodos

especificados com essa palavra possuam escopo “private”, sendo visível
e acessado somente pela classe onde os mesmos foram declarados e
também por suas classes derivadas (técnica conhecida como herança,
que iremos aprender logo mais).
OBS: Por padrão, é muito comum utilizamos esses modificadores também para
classes, como o public por exemplo.
Como utilizar os modificadores de escopo:
<modificador> class <nome da classe>

{
<modificador> <tipo> <atributo>;
<modificador> <tipo> <método>() { }
}
Vejamos um exemplo de como aplicar os modificadores (supondo o uso da

classe Carro) :
public class Carro

{
private String modelo;
private String cor;
private String placa;
private int ano;
public void andarPraFrente() { }

public void andarPraTras() { }
public void virarPraDireita() { }
public void virarPraEsquerda() { }
284
10.6) O que é um objeto ?
Um objeto nada mais é do que uma instância de classe carregada na memória.

Quando criamos uma classe, a gente só cria a estrutura dela. Para podermos
utiliza-la em nosso programa precisamos instanciá-la, ou seja, criar um objeto.
E por incrível que pareça, já fizemos isso, veja :
<classe> <variável> = new <classe>();
Se lembra que já usamos a palavra new ? Então, ela serve para criar instância
de classe (objeto) na memória.
Não tem o Scanner que utilizamos para ler os dados do teclado ? Então, aquilo
na verdade é uma classe, que possui uma série de métodos (como nextInt,
nextDouble, nextLine e etc), onde cada um realiza uma determinada tarefa. E
ai, as coisas estão ficando mais claras para você agora ? Com certeza que sim.
Então quando a gente escreve isso :
Estamos criando a instância da classe Scanner na memória, que iremos

controlar pelo objeto teclado .
10.7) O que é método construtor ?
Um método construtor nada mais é do que um método da classe que é

executado ASSIM QUE A CLASSE É INSTÂNCIADA NA MEMÓRIA. O
mesmo, para ser um construtor, deve possuir OBRIGATORIAMENTE o mesmo
nome da classe (e por padrão, sempre public). Vejamos a sintaxe da
declaração :

{
public <nome da classe> (<parâmetros, se houver)
{
285
Vejamos um exemplo :
public class Carro

{
int ano_do_carro;
public Carro(int ano)

{
ano_do_carro = ano;
}
}
Criando o objeto na memória (baseado na classe acima):
//Usando o construtor default

Carro carro = new Carro();
//Usando o construtor que definimos
Carro carro_velho = new Carro(1951);
Demonstrando na prática o uso da programação orientada a objetos
Para demonstrarmos o uso da programação orientada a objetos no Java vamos

supor uma classe chamada Triangulo, que possui as seguintes propriedades
(atributos) : base e altura. Como método nossa classe teria uma função
chamada calculaArea, que será responsável por calcular a área do triângulo.
Primeiramente, vamos criar uma classe chamada Triangulo dentro do Eclipse,

conforme instruções abaixo :
Clique com o botão direito sobre o nome do nosso projeto e em seguida

selecione “New/Class”.
286
Feito isso irá se abrir aquela caixa de diálogo, beleza ? Vamos agora digitar no
campo “Name” o nome da nossa classe que vai se chamar Triangulo.
Depois VAMOS DESMARCAR A OPÇÃO “public static void main(String[ ]

args)” (caso esteja marcada), pois essa classe não será uma aplicação. Veja
como deve ficar abaixo :
Opção desmarcada
Feito isso clique em “Finish” para gerarmos a classe Triangulo.
Agora vamos criar o código da nossa classe, conforme podemos ver abaixo :
public class Triangulo {
private double base;

private double altura;
public void setBase(double b)

{
base = b;
}
public void setAltura(double a)

{
altura = a;
}
public double calculaArea()

{
return (base + altura) / 2;
}
287
Uma metodologia muito comum utilizada na Programação Orientada a Objetos
é definir todos os atributos com o escopo private (como realizamos para base
altura) e criar um método para cada atributo, de escopo public , para
podermos acessar/modificar cada um deles (como é o caso do método
setBase (que modifica o atributo base) e setAltura (que modifica o atributo
altura) que criamos na classe).
Bom, agora vamos criar uma classe chamada ExemploPOO1 em nosso

projeto. Essa classe será uma aplicação, ou seja, irá possuir o método main.
Vejamos abaixo o código da nossa classe :
public class ExemploPOO1 {
//Usando o construtor default da classe

Triangulo triangulo = new Triangulo();
System.out.println("Digite a base do triângulo : ");

double base = teclado.nextDouble();
System.out.println("Digite a altura do triângulo : ");
double altura = teclado.nextDouble();
triangulo.setBase(base);
triangulo.setAltura(altura);
System.out.println("A área do triangulo é : " +

triangulo.calculaArea());
Voltando aquela nossa velha prática, irei simular passo a passo a execução do
nosso programa acima, para que possamos entender como todo esse processo
da programação orientada a objetos funciona.
288
//Usando o construtor default da classe
Triangulo triangulo = new Triangulo();
Aqui criamos a instância da classe Triangulo, que irá

ser gerenciada pela variável (objeto) teclado. Na
memória temos a seguinte estrutura :
Objeto Triângulo
base altura
0 0
public void setBase(double b) { ... }
public void setAltura(double b) { ... }
public int calculaArea (double b) { ... }
289
:
Cria a instância da classe Scanner , responsável por ler os

dados digitados do teclado pelo usuário.
Mostra a mensagem na tela : “Digite a base do triângulo”
:
double base = teclado.nextDouble();
Realiza a leitura dos dados via teclado. Vamos supor que

digitamos para a variável “base” o valor “12” e
pressionamos ENTER, teremos o seguinte resultado:
base
12
290
Mostra a mensagem na tela : “Digite a altura do triângulo”
Realiza a leitura dos dados via teclado. Vamos supor que

digitamos para a variável “altura” o valor “3” e
pressionamos ENTER, teremos o seguinte resultado:
altura
291
:
Dispara o método “setBase” da classe Triangulo, instanciada

na memória.
public void setBase(double b)

{
base = b;
Atribui o valor do
}
parâmetro “b” ao
atributo “base”.
Objeto Triângulo
base altura
12 0
292
:
Dispara o método “setAltura” da classe Triangulo, instanciada

na memória.
public void setAltura(double a)

{
altura = a;
}
Atribui o valor do parâmetro “a” ao

}
atributo “altura”.
Objeto Triângulo
base altura
12 3
293
:
System.out.println("A área do triangulo é : " +

triangulo.calculaArea());
Mostra o cálculo da área do triangulo na

tela. Mas antes....(segue a seta)
Dispara o método calculaArea da classe

Triangulo.

:
public double calculaArea()
{
return (base + altura) / 2;
}
}
Aqui será calculado a área do triângulo que é (base x

altura) / 2.
System.out.println("A área do triangulo é : " + 7.5);
E ai, está endentando como funciona todo o processo ? com certeza que sim.
294
10.8) Herança
Herança em linguagem de programação é uma técnica em que uma

determinada classe (conhecida como subclasse ou classe filho) herda todos os
métodos e atributos de uma outra classe (conhecida como super classe ou
classe pai). Vejamos a sintaxe de uma classe que adota a técnica de herança.
Sintaxe :
public class <nome subclasse> extends <nome da super classe>

{
<métodos e atributos>
}
Vejamos o seguinte exemplo : Suponhamos que temos os seguintes

transportes como carro e caminhão. Quais seriam as características comuns
eles ? Óbvio, todos eles são veículos.
Logo, vamos supor uma classe genérica chamada Veiculo, conforme abaixo :
public class Veiculo

{
public int ano;
public String cor;
public String modelo;
public String fabricante;
public void Andar () { ... }

public void Parar () { ... }
295
Conforme havia falado, o carro é um veículo correto ? Vamos então agora criar
uma classe chamada Carro cujas propriedades (atributos) e métodos serão
herdados da classe Veiculo :
public class Carro extends Veiculo

{
public class Carro

{
Automaticamente aqui,
public int ano;
dizemos que a classe Carro irá public String cor;
herdar todos os métodos e public String modelo;
atributos da classe Veículo, ou public String fabricante;
seja, implicitamente temos a
public void Parar () { ... }
seguinte estrutura ao lado: }
O caminhão é um veículo correto ? Vamos então agora criar uma classe

chamada Caminhao cujas propriedades (atributos) e métodos serão herdados
da classe Veiculo :
public class Caminhao extends Veiculo

{
public int num_eixos;
}
public class Caminhao

{
Automaticamente aqui,
public int ano;
dizemos que a classe public String cor;
Caminhão irá herdar todos os public String modelo;
métodos e atributos da classe public String fabricante;
public int num_eixos;
Veículo, ou seja,
implicitamente temos a public void Parar () { ... }
seguinte estrutura ao lado: }
Observe que uma propriedade especifica (unicamente) de um caminhão é o

seu número de eixos, logo, devemos declarar dentro da classe Caminhao.
296
10.9) Polimorfismo
Polimorfismo é quando um determinado objeto possui comportamentos

distintos de acordo com a instância carregada. E o polimorfismo acontece
graças ao uso da técnica de herança.
Essa parte do polimorfismo requer MUITA ATENÇÃO para compreendermos o

seu uso e importância. Irei mostrar PASSO A PASSO, de uma forma
minuciosa, como funciona o POLIMORFISMO.
Primeiramente vamos criar uma classe chamada Animal (que não irá possuir
nenhum método main), com o seguinte código abaixo :
public class Animal {
public void Ruido()

{
System.out.println("Qualquer ruído...");
}
}
Essa é uma classe genérica, que será utilizada por uma outra classe (que
iremos desenvolver a seguir). A classe que desenvolvemos representa um
animal qualquer, que pode emitir qualquer ruído (representado pelo método
chamado Ruido).
Agora vamos desenvolver uma classe chamada Gato, que irá herdar todos os
métodos/atributos da classe Animal. Segue o código :
public class Gato extends Animal {
public void Ruido()

{
System.out.println("Miau...");
}
}
Observe que na classe Gato (derivado da classe Animal), definimos um método

chamado Ruido. Mas perai, esse método já não existe na classe Animal ? Sim, ele
já existe. Quando definimos um método que já existe na classe base (classe pai)
estamos criando uma nova versão dele, que será utilizado quando a instância da
classe Gato estiver em uso.
297
Agora vamos criar uma nova classe que irá utilizar todas as classes que
definimos até agora. O nome da nossa classe irá se chamar ExemploPOO2
(essa irá possuir o método main). Segue o código :
Animal animal = new Animal();

animal.Ruido();
Como podemos ver na classe acima, temos um código absolutamente

(absurdamente) simples. Se executarmos o programa acima ele irá nos mostrar
na tela a seguinte frase :
298
A execução foi bastante simples não é mesmo ? Pois bem, agora na classe
que desenvolvemos (a classe ExemploPOO2) vamos adicionar o seguinte
trecho de código destacado em azul abaixo:

animal.Ruido();
animal = new Gato();

animal.Ruido();
Se observarmos o seguinte trecho de código inserido, conforme é mostrado

abaixo :
Temos uma atribuição que aparentemente está errada, porém, por incrível que
pareça, a atribuição está correta. O nosso objeto (a variável animal), que
declaramos como um tipo Animal, recebe como atribuição uma instância da
classe Gato. Isso é permitido ? Sim, isso é permito. Isso ocorre porque a
classe Gato herda todos os métodos e atributos da classe Animal, logo, o
comando acima será executado sem problemas.
Seria ERRADO se tivéssemos “o contrário”, ou seja, se tivéssemos um objeto

do tipo Gato recebendo uma instância da classe Animal, pois via regra,
nenhum objeto pode receber instância de classes cujas as mesmas sejam
classes superiores (ou classes pai), ou seja :
Gato gato = new Animal(); // ESTÁ TOTALMENTE ERRADO. GRAVE ISSO.
299
Bom, para entendermos de vez como funciona o POLIMORFISMO, acompanhe
passo a passo a execução do nosso programa abaixo :
animal.Ruido();
Cria a instância da classe Animal que será

representado pelo objeto animal
animal.Ruido();
Chama o método Ruido da classe Animal.
public class Animal {
public void Ruido()

{
System.out.println("Qualquer ruído...");
}
}
Imprime na tela a mensagem “Qualquer ruído...”.
300
animal.Ruido();
animal.Ruido();
Cria a instância da classe Gato que será

representado pelo objeto animal

:
animal.Ruido();
“animal “ é um objeto do tipo Animal, mas, na instrução

anterior carregamos dentro desse objeto a instância da classe
Gato, logo, iremos chamar o método “Ruido” da classe Gato.
public void Ruido()

{
}
}
Imprime na tela a mensagem “Miau...”.
301
Vejamos abaixo o resultado da execução do nosso programa :
Então POLIFORMISMO é isso : Um método que assume comportamentos

diferentes de acordo com a instância carregada.
Agora vamos voltar para a classe Gato para adicionarmos o seguinte método
destacado em azul abaixo :
public void Ruido()

{
}
public void PuloDoGato()
{
System.out.println("Pulo do gato...");
}
}
Observe que declaramos acima um método chamado PuloDoGato, que só

existe somente dentro da classe Gato, muito bem. Agora dentro da classe
onde estamos desenvolvendo o nosso exercício, vamos digitar a seguinte linha
de código destacada em azul abaixo :

animal.Ruido();
animal.Ruido();
animal.PuloDoGato();
}
}
302
Agora, se observarmos la no editor do Eclipse , ocorreu o seguinte erro :
Erro na linha de código marcada em vermelho
Por que o erro está acontecendo ?
Vamos analisar o código (errado) acima. O método PuloDoGato somente

existe dentro da classe Gato, e o objeto (variável) animal é do tipo Animal (que
não possui nenhuma implementação de PuloDoGato).
Com a técnica do POLIMORFISMO nós podíamos acessar o método Ruido

tanto da classe Animal quanto da classe Gato (de acordo com a instância).
Agora, como acessar o método PuloDoGato que só existe na classe Gato ?
Para isso, devemos aplicar o que chamamos de “cast”, ou seja, converter um
objeto de um determinado tipo para outro. Como ? Utilizando a seguinte
sintaxe:
((<classe>) objeto).<método a ser chamado>()
Veja como deveríamos fazer para chamar o método PuloDoGato (da classe
Gato) no código abaixo :
((Gato)animal).PuloDoGato();
303
Vejamos abaixo o código final do nosso programa :

animal.Ruido();
animal.Ruido();
((Gato) animal).PuloDoGato();
}
}
O resultado da execução do programa você confere na figura
Agora sim. Até aqui aprendemos todas as técnicas essenciais e importantes da

linguagem de programação Java, que é a base para o desenvolvimento do
Android. Com isso, encerramos o nosso aprendizado sobre linguagem de
programação Java para a partir daqui , neste ponto, iniciarmos o nosso
primeiro desenvolvimento com a plataforma Google Android, para que
possamos construir nossas aplicações para o sistema operacional mais popular
e utilizado no dia a dia.
304
Capitulo 11 Introdução a
Plataforma Google Android
M
uito bem. Este possivelmente deve ser para você um dos capítulos
mais esperados, pois é a partir dele que iremos conhecer e ter o
nosso primeiro contato com desenvolvimento para a plataforma
Google Android. Veremos nesse capítulo uma introdução à plataforma e as
suas características fundamentais.
11.1) O que é o Google Android ?
O Android é uma plataforma desenvolvida pela Google voltada para

dispositivos móveis, totalmente aberta é livre (Open Source), que foi divulgada
em 5 de novembro de 2007. Inicialmente o sistema Android foi desenvolvido
pelo Google e atualmente essa plataforma é mantida pela OHA (Open
Handset Alliance. Visite o link : http://www.openhandsetalliance.com), um grupo
constituído por aproximadamente 84 empresas as quais se uniram para inovar
e acelerar o desenvolvimento de aplicações e serviços, com o objetivo e
trazer aos consumidores uma experiência mais rica em termos de recursos,
menos dispendiosa em ternos financeiros para o mercado móvel.
Um dos primeiros SmartPhones que ofereceu suporte a esse sistema

operacional foi o G1 da empresa T-Mobile. Confira na imagem seguinte:
305
G1 - T-Mobile
Atualmente o sistema Android se encontra hoje disponível tanto em

SmartPhones quanto nos Tablets. Confira abaixo alguns dos dispositivos
encontramos hoje no mercado com o sistema operacional Android:
SmartPhone Samsung Galaxy S3
306
Tablet Samgung Galaxy Note
11.2) Estrutural geral do Android
Para desenvolvermos uma aplicação para Android será necessário obtermos

um Kit de desenvolvimento para Android (conhecido como Android SDK). A
nossa ferramenta de desenvolvimento que iremos utilizar aqui em nossa
apostila e a ferramenta Android Studio.
Possivelmente você já deve ter pensado : Será que eu vou ter que comprar um
Smartphone ou Tablet na loja agora (correndo) para poder desenvolver e
executar minhas aplicações feitas no Android ? NÃO. O Kit de
desenvolvimento para Android (o Android Studio) já oferece um emulador de
Android, onde podemos executar e conferir todas as aplicações que
desenvolvermos para a plataforma.
307
Vejamos agora os recursos oferecidos pelo Android SDK :
Application framework: Permite a reutilização e substituição de

componentes ;
Dalvik virtual machine: É uma Máquina Virtual Java (JVM) voltada para
dispositivos móveis ;
Browser Integrado baseado no webkit engine ;
Gráficos Otimizados O Android é constituído por bibliotecas 2D e 3D

baseada na especificação OpenGL ES 1.0 ;
SQLite: Sistema Gerenciador de Banco de Dados (SGBD) já embutido no

Android para guardar dados ;
Suporte multimídia: A plataforma já oferece para áudio, vídeo e formatos

de imagem (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF) ;
Telefonia GSM (dependente de hardware) ;
Bluetooth, EDGE, 3G, e WiFi (dependente de hardware) ;
Câmera, GPS, compasso, e acelerômetro (dependente de hardware) ;
Rico ambiente de desenvolvimento : isso envolve as ferramentas de

depuração, memória, performance e um um emulador de dispositivo
Android (conforme já havia citado) ;
308
11.3) Versões do Android
Cada dispositivo móvel (Smartphone ou Tablet) com o sistema Android

instalado possui uma determinada versão dele. Atualmente são encontradas
várias versões do Android (algumas bastante populares e outras obsoletas).
Vejamos na lista abaixo todas as versões do Android que existem (ou que já
existiram, como os mais antigos) :
Data de
Versão Code Name API Level Logotipo
lançamento
30 de abril de
1.5 Cupcake 3
2009
15 de
1.6 Donut 4 setembro de
2009
11 de janeiro
2.1 Eclair 7
de 2010
20 de maio de
2.2 Froyo 8
2010
06 de
2.3.x Gingerbread 9-10 dezembro de
2010
309
Data de
Versão Code Name API Level Logotipo
lançamento
22 de
3.x Honeycomb 11-13 fevereiro de
2011
19 de outubro
4.0.x Icecream Sandwish 14-15
de 2011
09 de julho de
4.1-4.3 Jelly Bean 14-18
2012
31 de outubro
4.4 KitKat 19
de 2013
04 de
5.x.x Lollipop 21-22 novembro de
2014
Outubro de
6.0 Marshmallow 23
2015 *
OBS : No momento da atualização deste material, a versão “Marshmallow” do

Android estava para ser lançada em outubro de 2015 (período em que essa
apostila estava sendo atualizada).
310
11.4) Para qual versão do Android devemos desenvolver as aplicações ?
Quando desenvolvemos uma aplicação para um determinado sistema

operacional, normalmente, precisamos fazer a seguinte pergunta : Para qual
versão do S.O devemos desenvolver ?
Considero esse um dos pontos mais importantes que devemos refletir antes de
desenvolvermos uma aplicação. Como neste material iremos desenvolver
aplicações voltados para a plataforma Android, devemos pensar para qual
versão da plataforma precisamos desenvolver.
11.4.1) Qual versão da plataforma Android é a mais utilizada no momento ?
Para falar a respeito dessa situação, irei mostrar aqui um gráfico que mostra
quais versões do Android são as mais usadas no mundo todo :
Gráfico de Estatística a respeito do S.O Android mais usado
O gráfico da estática acima foi feito em setembro de 2015, onde nele podemos
observar que as versões do Android mais utilizadas são o Kitkat (versão 4.4),
Jelly Bean (versão 4.1 – 4.3) e o Lollipop (Versão 5.0). As versões mais
antigas do Android como Eclair (versão 2.1) e Donut (versão 1.6) já nem são
mais citadas e faladas hoje em dia, e durante a atualização dessa apostila,
conforme já havia falado, a versão 6.0 (Marshmallow) do Android estava
prestes de ser lançada.
311
Hoje em dia, se fomos em alguma loja para comprar um aparelho (Smartphone
ou Tablet Android) iremos adquiri-lo com o S.O Android versão 4.3 para cima.
Se olharmos por esse ponto de vista, devemos pensar em desenvolvermos
nossa aplicação utilizando, como base, a versão 4.3.
1.3.2) O Publico
Um outro fator muito importante , e que destaco aqui , é a questão O

PUBLICO. Nesse fator , a questão S.O deveria ser deixada “teoricamente” de
lado, visto que muitos usuários ainda possuem aparelhos Android com uma
versão mais antiga (como a versão 2.3 e 2.2), logo, devemos pensar também
nesses usuários para “usufruir” das nossas aplicações desenvolvidas.
1.3.3) Qual prioridade devemos dar : Publico ou Versão do S.O ?
Agora a questão é : Como combinar a questão PUBLICO e VERSÃO do S.O

para desenvolvermos a aplicação ? Se você pretende desenvolver uma
aplicação Android simples (como um pequeno sistema de cadastro), podemos,
se quisermos, dar prioridade a questão PUBLICO, procurando desenvolver
sua aplicação Android para uma versão mais antiga, porém, ainda NÃO
OBSOLETA . Agora se você desenvolver uma aplicação Android cheia de
muitos recursos, cujos componentes só existem em versões mais atuais do
sistema, devemos dar prioridade a questão VERSÃO do S.O.
312
Capitulo 12 Desenvolvendo
nosso primeiro projeto no
Android
N
este capítulo iremos aprender passo a passo como construir a nossa
primeira aplicação para a plataforma Google Android, através do uso da
linguagem de programação Java e outros recursos oferecidos pelo
Android Studio.
Muito bem, vamos desenvolver agora (depois de muita espera) nossa primeira
aplicação para a plataforma Google Android.
A ferramenta que utilizaremos aqui nesta apostila para criarmos as nossas

aplicações em Android é a IDE Android Studio. Para uma ABORDAGEM
COMPLETA da instalação e configuração da ferramenta visite o link :
https://goo.gl/MgImX8 (baixe o tutorial e faça a instalação passo a passo
antes de prosseguir com este material).
Depois de tudo configurado e instalado, vamos executar a nossa ferramenta de

desenvolvimento Android Studio. Quando a ferramenta é executada pela
primeira vez e nenhum projeto anterior é criado nele, é exibida a seguinte tela
abaixo:
313
Caixa de diálogo – Quick Start
Para criarmos um novo projeto no Android Studio basta clicar no botão “Start a
new Android Studio project”, conforme indicado na figura em seguida:
Criando um novo projeto
Feito isso será aberta a seguinte caixa de diálogo , conforme mostra a próxima
figura:
314
Criando um novo projeto no Android Studio
Na caixa de diálogo acima informarmos o nome da nossa aplicação

(Application Name), o nome da empresa (Company Domain) e o local onde o
mesmo será salvo (Project location).
No campo “Application Name” vamos definir o nome da nossa aplicação, que

irá se chamar “HelloWorld” (sem aspas, é claro). No campo “Company Domain”
vamos digitar “usuario.android” (expresso como nome de pacote Java). Agora
em “Project location” , que indica onde o projeto será criado, fica por sua
escolha, PORÉM, o diretório (caminho) que você escolher não deverá conter
espaços em branco, fica a dica . Vejamos como ficou na figura abaixo :
315
Observe que um dos campos, que ainda não citei acima , é preenchido
automaticamente (o campo “Package name”). Ele é formado pelo nome da
aplicação “concatenado” com o nome do campo “Company Domain”. Vejamos
abaixo :
O campo “Package name”
Depois de preencher as informações acima necessárias, clique no botão “Next”

para continuarmos. Feito isso será exibida a seguinte tela abaixo:
316
No formulário acima especificamos para quais dispositivos iremos desenvolver

as nossas aplicações. Nesta apostila estaremos desenvolvendo aplicações
para Smartphones e Tablets Android em geral, logo, deixaremos a opção
“Phone and Tablets” marcada (as opções de TV e Android Wear só é destinada
para sistemas Android cuja versão seja 5.x, o Lollipop).
Observe que em “Mininum SDK” é especificada a versão mínima do Android

instalada para desenvolvimento das aplicações, que neste caso é a versão
4.0.3 que instalamos através do Android SDK. Deixaremos esta opção
selecionada (até porque também só existe essa opção).
Na próxima tela (clicando em “Next”) é aberto o seguinte formulário abaixo :
317
Criando uma nova Activity
Toda classe (arquivos “.java”) na plataforma Android, que representa uma

aplicação, é considerada uma “atividade” (Activity). Para isso, precisamos
definir uma atividade que vai representar a nossa aplicação Android. Para isso
vamos criar uma nova atividade “em branco” (Blank Activity), conforme a opção
selecionada na figura acima.
Com a opção “Blank Activity” selecionada, vamos clicar no botão “Next” e

surgirá a seguinte tela abaixo :
318
Informações da Activity
Na seção acima definimos o nome da nossa atividade (Activity Name) assim

como o nome do arquivo XML que vai representar a tela da nossa aplicação
(Layout Name), o título que será exibido na aplicação (Title) e o nome do
arquivo que irá gerenciar os itens de menus a serem exibidos na aplicação
(Menu Resource Name). Por padrão o nome da “Activity” é “MainActivity”, e o
nome do arquivo de layout é “activity_main”. Vamos alterar as informações
conforme os dados abaixo :
Activity Name : HelloActivity

Layout Name : activity_hello
Title : Hello Android
Menu Resource Name : menu_hello
Vamos conferir como ficou na figura seguinte :
319
Informações da Activity
Por padrão, como na primeira seção, quando mudamos o conteúdo do campo

“Activity Name”, o campo “Layout Name” é alterado automaticamente. Caso
deseje você poderá escolher outros nomes para o campo alterado
“automaticamente” sem afetar o nome da atividade.
Depois disso, clique em “Finish” para nosso projeto possa ser gerado. O
resultado você confere na figura seguinte:
320
Projeto criado
Se por caso for exibido a seguinte mensagem abaixo :
Mensaegem de erro
Feche esta caixa de diálogo e prossiga para a próxima etapa.
321
Conhecendo a estrutura geral de um projeto no Android Studio
A primeira coisa que visualizamos que nos chama atenção é a tela do

dispositivo com a frase “Hello world”, conforme podemos conferir na figura
seguinte:
Visualização da tela do dispositivo
Se observamos a figura anterior, ao lado da tela do dispositivo temos uma

paleta de componentes disponíveis que podemos utilizar para construir as
nossas aplicações. Explicarei mais em detalhes no próximo capítulo.
Se visualizarmos o lado esquerdo, existe uma seção chamada “Project”, onde

nela existe uma pasta chamada “app” (que é o nosso projeto), constituído por
vários subdiretórios , que por sua vez, possui seus respectivos arquivos,
conforme demonstra a figura seguinte:
322
Visualização dos diretórios do projeto
Irei comentar agora toda a estrutura de um projeto Android. Ele é composto por
várias pastas e arquivos, cada um com uma finalidade em especifico.
O diretório “app” (application)
Vamos começar conhecendo primeiramente o diretório “app” (application).

Dentro desse diretório temos todos os arquivos principais de nossa aplicação,
distribuído pelos seus diretórios. Ao expandirmos o diretório “app” temos as
pastas “manifest” e “java”. Dentro da pasta “manifest” temos o arquivo
“AndroidManifest.xml”, com o seguinte código abaixo :
323
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android.usuario.helloandroid" >
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".HelloActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
</application>
</manifest>
Esse arquivo é considerado o “sistema nervoso” do Android, é através dele que

definimos todas as permissões e configurações primordiais de nossa aplicação
para que a mesma seja executada (não iremos fazer nenhuma modificação
nesse arquivo).
Dentro da pasta “java” temos as nossas classes (arquivos “.java”) que fazem
parte da nossa aplicação. Observe que dentro da nossa pasta existem dois
pacotes de mesmo nome (“android.usuario.helloandroid”), sendo o último
voltado para testes, onde dentro dele existe uma classe chamada
“AndroidTest.java” , com o seguinte conteúdo abaixo :
324
Visão geral do arquivo “ApplicationTest.java”
No primeiro pacote existe um arquivo chamado “HelloActivity.java” , que é a

classe principal do programa, que é através dela que definimos todos os ações
da nossa aplicação :
Visão geral do arquivo “HelloActivity.java”
O arquivo aberto acima (HelloActivity.java) possui o seguinte conteúdo:
package android.usuario.helloandroid;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
325
public class HelloActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_hello);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is
//present.
getMenuInflater().inflate(R.menu.menu_hello, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
Diferentemente das aplicações comuns em Java (J2SE), toda classe que

representa uma aplicação Android deve ser derivada da classe Activity
(atividade), conforme você pode ver através do seguinte trecho de código:
public class HelloActivity extends Activity {

:
326
A classe “HelloActivity” possui como método principal o onCreate. A primeira
linha de código presente neste método faz chamada ao método onCreate da
classe base (a classe Activity), conforme podemos conferir abaixo:
Logo após esse método vem o método setContentView, responsável por exibir
a tela da minha aplicação baseado nos layouts “xml". Por padrão ele chama o
arquivo “activity_hello.xml”.
O diretório “res” (resources)
Dentro da estrutura de um projeto Android existe um diretório chamado “res”

(resources), onde dentro dele colocamos todos os recursos que podemos
utilizar em um programa Android (como imagens, sons, músicas e etc). Vamos
conhecer os subdiretórios existentes dentro dessa pasta e a finalidade de cada
um deles.
O diretório “drawable”
O diretório “drawable” presente dentro da pasta “res” do nosso projeto possui

uma única finalidade : armazenar imagens que serão visualizadas dentro de
uma aplicação Android. Uma coisa que precisa ser reforçada aqui é que os
arquivos de imagens presentes nessa pasta não podem estar escritos de
qualquer forma. Os arquivos a serem copiados dentro desse diretório devem
possuir somente letras minúsculas (de “a” até “z”), números (de “0” a “9”) e
underline (“_”).
O diretório “layout”
O diretório “layout” armazena todos os arquivos referentes as telas de uma

aplicação Android, que normalmente são arquivos “.xml”. Para aqueles que
conhecem a programação de HTML com JavaScript para a construção de
páginas Web, no Android é similar, é a combinação de Java com XML para a
construção de aplicativos Mobile.
O diretório “values”
Um dos recursos que o Android permite que usemos na construção das telas
de nossa aplicação são “constantes”. Como bom programador que todos nós
327
somos, sabemos que uma “constante” nada mais é do que um endereço de
memória que vai armazenar um determinador valor, que será único até o fim da
execução do programa. Mas, o que isso tem a ver com as telas da nossa
aplicação ? Vou explicar.
Normalmente usamos constantes para armazenar valores fixos que,

naturalmente, estarão presentes na maior parte do seu programa. É muito
comum criarmos um título como nome de uma aplicação (como por exemplo :
“Alpha Software”), que vai estar presente na maioria das telas (ou em todas) da
sua aplicação. Imagine você digitar “manualmente” o nome de seu software em
todas as telas da sua aplicação, seria um processo trabalhoso você não acha
? Agora imagine “futuramente” que você precise “mudar” o nome de sua
aplicação ? Você terá novamente o mesmo trabalho para digitar em cada tela o
nome da nova aplicação, sem dúvida. Usando constantes, você não terá esse
trabalho.
Dentro dessa pasta temos os seguintes arquivos:
- “strings.xml” : Esse arquivo guarda constantes relacionadas à nossa

aplicação em geral (como o nome da aplicação, o título que vai aparecer na
aplicação e etc.).
- “dimen.xml” : Esse arquivo guarda constantes relacionadas as dimensões

que podemos utilizar em nossa aplicação.
- “styles.xml” : Esse arquivo guarda constantes relacionadas à estilos que

podemos utilizar em nossa aplicação.
O diretório “mipmap”
O diretório “mipmap” possui a mesma características do diretório “drawable” (

armazenar imagens) , porém, o mesmo foi destinado a armazenar nesta pasta
328
somente imagens referentes ao ícone da nossa aplicação Android, que possa
se comportar em várias resoluções de tela.
O diretório “menu”
Nesse diretório é armazenado o arquivo responsável por gerenciar e exibir os

itens de menu em noss aplicação. Por padrão o arquivo que contem os itens de
menu possui a seguinte estrutura abaixo :
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
tools:context=".HelloActivity">
<item android:id="@+id/action_settings"
android:title="@string/action_settings"
android:orderInCategory="100" android:showAsAction="never" />
</menu>
Os itens de menu podem ser adicionados através do uso das tags específicas
do XML para esse propósito (veremos isso mais adiante).
Visão geral da ferramenta de desenvolvimento
Acabamos de entender e conhecer acima toda a estrutura de diretórios de um

projeto Android no Android Studio. Agora vamos dar uma visão geral na nossa
ferramenta de desenvolvimento (IDE) para a plataforma Android.
329
(6)
(1)
(4)
(2)
(3)
(5)
Visão geral da ferramenta de desenvolvimento
Vamos entender as numerações indicadas na figura anterior :
Na indicação (1) temos a paleta de componentes onde os mesmos estão

separados por seções. As seções são : Widgets , Text Fields, Layouts ,
Containers, Date e Time , Expert e Custom (Componentes personalizados,
normalmente criados pelo usuário e entre outros recursos).
Na indicação (2) temos um preview de como ficará a interface da nossa

aplicação quando a mesma for executada, nessa interface podemos arrastar e
soltar os componentes (indicados por (1)) , construindo assim a nossa
aplicação.
Na indicação (3) temos as propriedades do componente (Properties). Quando

selecionamos um componente, as suas propriedades são visualizadas e assim,
conforme nossa necessidade, podemos alterá-las.
Na indicação (4) temos uma seção chamada “Component Tree”. Nessa seção
podemos ver , de forma hierárquica, todos os componentes que estão
presentes na tela da nossa aplicação
330
Na indicação (5) podemos alternar entre o modo gráfico (“Design”, onde temos
a visualização da tela da aplicação) e o modo XML (“Text”, onde visualizamos o
código XML do arquivo, que corresponde a estrutura que forma a tela de nossa
aplicação).
Na indicação (6) podemos alterar os temas que podemos utilizar em nossa

aplicação Android, orientação da tela do dispositivo (retrato ou paisagem),
resolução da tela do dispositivo e etc. A maioria das opções disponíveis nessa
seção só terá efeito em tempo de projeto. É necessário configurar as mesmas
opções para que elas aconteçam em tempo de execução (quando você
executa o emulador ou dispositivo real), de acordo com a necessidade.
Executando a nossa aplicação
Agora que já tivemos uma visão geral da ferramenta de desenvolvimento e do

projeto em Android (com toda a sua estrutura de diretórios e arquivos),
podemos a partir de agora executarmos a nossa aplicação. Mas antes de
executarmos a nossa aplicação, irei fazer alguns comentários. Observe que
quando criamos um projeto em Android, na tela do dispositivo já tem um
componente TextView (situado na paleta de componentes , dentro da seção
“Widgets”) onde nele é exibida a frase “Hello world”. Quando executarmos a
nossa aplicação através do emulador, ela sairá idêntica como está sendo
exibida no projeto (uma tela “em branco” com a frase “Hello world”).
Como fazer para executarmos a nossa aplicação ? Para executarmos a nossa

aplicação basta irmos no menu “Run” / “Run ‘app’ " (ou pressionar as teclas
SHIFT+F10) . Uma outra forma também é clicando no botão pressente na
barra de ferramentas :
331
Botão “Run” do Android Studio
Feito isso será aberta a seguinte caixa de diálogo em seguida :
Caixa de diálogo – Choose device
Para executarmos a nossa aplicação iremos fazer uso de um dispositivo virtual

(conhecido como “Android Virtual Device”), porém, esse dispositivo virtual não
está criado (lembre-se : simplesmente baixamos através do Android SDK a
332
imagem do sistema Android 4.0.3 ,mas, ainda não efetuamos nenhuma
configuração e criação de dispositivo).
Vamos nesse exato momento criar um dispositivo virtual que irá executar as
nossas aplicações Android. Para criarmos um dispositivo basta clicarmos no
botão (...) presente ao lado do campo “Android virtual device”, conforme indica
a figura a seguir :
Criando um novo dispositivo

Feito isso será aberta a seguinte caixa de diálogo abaixo :
Android Virtual Device Manager
333
Vamos clicar agora no botão “Create a virtual device”. Feito isso será aberta a
seguinte tela :
Virtual Device Configuration
Na guia “Category” vamos deixar marcado a opção “Phone”, conforme é

mostrado na figura a seguir :
Escolhendo a categoria
334
Como modelo de smatphone utilizado para executar as nossas aplicações
selecione a opção “3.2 QVGA (ADP2)”,conforme indicado na figura abaixo :
Selecionado o modelo
Agora vamos clicar no botão “Next” para avançarmos para a próxima etapa,
conforme indica a próxima figura:
335
Muito bem, nesta seção escolhemos o sistema Android que iremos utilizar , que
no caso será o que baixamos através do Android SDK (a versão 4.0.3 Ice
Cream Sandwish). Primeiramente, certifique-se de que a opção “Show
downloadable system images” ESTA DESMARCADA, se estiver marcada,
DESMARQUE (já que não iremos fazer nenhum donwload de imagem
nenhuma) :
Deixar esta opção DESMARCADA
Já que iremos fazer do sistema de imagem do Android 4.0.3 que baixamos,

basta simplesmente clicarmos em “Next” para avançarmos para a próxima tela,
conforme mostra a figura a seguir :
336
No campo “ADV Name” vamos especificar o nome do nosso dispositivo virtual,

que se chamará “Emulador” . Logo, vamos digitar “Emulador” (sem aspas, é
claro).
As demais configurações vamos deixá-las como está (default). Feito isso,
vamos clicar no botão “Finish” para que o nosso dispositivo virtual possa ser
gerado. Vejamos a figura abaixo :
337
Dispositivo virtual criado
Agora vamos fechar a janela da figura acima e em seguida na caixa de diálogo

“Choose Device” vamos selecionar o nosso emulador criado, conforme
podemos ver na figura seguinte :
338
Selecionando o emulador
Depois de selecionarmos o emulador a ser executado basta clicarmos no botão

“OK”. Feito isso nosso emulador irá executar, conforme mostra a figura
seguinte :
339
Emulador do Android em Execução
No início da execução do emulador mostra o título Android, conforme você vê

na figura acima. Depois vem um outro título escrito “Android”, um pouco maior
e cinza , com uma animação. Esse processo normalmente demora em torno
de 2 a 10 minutos (dependendo da sua máquina. É recomendável que você
tenha no mínimo 1GB de memória e um processador bem rápido para um bom
desempenho da execução) para a aplicação ser exibida, mesmo sendo essa
aplicação algo muito simples.
Passado o tempo que citei acima, será mostrada a nossa aplicação em

execução, conforme podemos ver na figura seguinte:
340
Emulador do Android em Execução
Esse emulador já vem com uma série de recursos como Navegador,

Aplicações de demonstração, Mapas, Lista de contatos e etc.
Se você neste exato momento fechou o emulador após a execução da

aplicação, vou te dizer uma coisa: “Não era para você ter feito isso”. Se você
esperou muito tempo para ver essa aplicação em execução, ao executar
novamente a aplicação, possivelmente você vai esperar o mesmo tempo. Ao
executar pela primeira vez o emulador, e caso vá executar outros programas,
minimize o emulador ao invés de fechar, pois se você esperou muito tempo
para executar esse programa, com ele minimizado, ao executar outro
programa, o Android Studio vai fazer uso do emulador já aberto em vez de abrir
outro, com isso a aplicação levará em torno de 7 a 12 segundos em média
para ser executada. Nunca esqueça isso!
341
Bom, vamos fazer algumas modificações em nossa aplicação. Minimize o
emulador e vamos no projeto. Para começar vamos mudar o texto que está
sendo exibido na tela. Selecione o texto (componente TextView), conforme
demonstra a figura seguinte:
Componente selecionado
Se observarmos no lado direito, temos as propriedades do componente

selecionado, conforme demonstra a figura seguinte:
Propriedades do componente selecionado (TextView)
342
Para alterarmos o conteúdo do texto, devemos alterar a propriedade “text”
(conforme você pode ver na figura acima). Se você observar, o conteúdo que
está dentro dessa propriedade é “@string/hello_world”. Mas espere ai, o que
significa esse expressão se o conteúdo que está sendo exibido é uma frase ?
Essa expressão significa que o conteúdo exibido na tela está dentro de uma
“constante”.
Quando vimos a estrutura de um projeto Android, nós conferimos que dentro

dele existe um diretório chamado “values”, onde dentro do mesmo havia um
arquivo que guardava constantes em geral certo ? Esse arquivo é o
“strings.xml”. Dentro desse arquivo existe uma constante chamado
“hello_world” que armazena a seguinte frase “Hello World”, logo, o conteúdo
exibido por esse componente na tela na verdade é o conteúdo da constante
“hello_world”, situado dentro do arquivo “strings.xml”, por isso o uso da notação
“@string/hello_world”.
Vamos abrir o arquivo “strings.xml” para visualizarmos seu conteúdo, conforme

demonstra a figura seguinte :
O arquivo “strings.xml”
Se observamos o conteúdo dele, temos disponíveis 3 constantes “pré-

definidas” e uma delas e a constante “hello_world”.
Na estrutura XML do arquivo “strings.xml” vamos adicionar uma nova constante

chamada “frase”, com o seguinte conteúdo “Estou aprendendo Android”. Veja
como ficará conforme indica a figura seguinte :
343
Constante criada
Agora vamos voltar para o arquivo “activity_hello.xml” simplesmente clicando

na guia de arquivos, conforme demonstra a figura seguinte:
A guia “actitivy_hello.xml”
Agora vamos na propriedade “text” e em seguida clique no botão (...) que está
aparecendo ao lado do conteúdo da propriedade. Veja abaixo :
344
Alterando o conteúdo da propriedade
Feito isso será aberta a seguinte caixa de diálogo abaixo :
Caixa de diálogo – Resources
Observe que nessa caixa de diálogo temos todas as constantes que existem
dentro do arquivo “strings.xml”, incluindo a nossa constante “frase” que
345
acabamos de criar. Vamos selecionar a nossa constante e em seguida clique
no botão “OK”. O resultado você confere em seguida :
Conteúdo modificado
Depois de alterar o conteúdo da TextView vamos executar novamente a

aplicação, podemos fazer isso realizando o mesmo procedimento já explicado
anteriormente. Possivelmente ao executar a aplicação novamente, deverá ser
exibida essa caixa de diálogo :
Caixa de diálogo – Choose Device

346
Bom, vamos continuar a usar o emulador que já está aberto (identificado por
“emulator-5554”, no campo “Serial Number”). Vamos marcar a opção “Use
same device for future launches” :
Marcar esta opção
Depois de marcar, clique em “OK” para executarmos a nossa aplicação.

Vejamos o resultado :
Aplicação em execução
E ai, está aprendendo aos poucos como se desenvolve uma aplicação em

Android ? Com certeza que sim. Esse na verdade foi um pontapé inicial. No
próximo capítulo iremos desenvolver uma aplicação bem básica, baseado no
que já desenvolvemos com PORTUGOL (no Visualg) e com Java.
347
Capitulo 13 Criando uma
aplicação básica no Android
N
o capítulo anterior nós demos nosso primeiros passos no
desenvolvimento com a plataforma Google Android usando a
ferramenta Android Studio. Agora, iremos construir uma aplicação
básica usando os componentes essenciais oferecidos pelo Android SDK.
A aplicação que iremos desenvolver consiste em um conversor de

temperaturas (conforme já havíamos desenvolvido anteriormente no
PORTUGOL e com Java), em que iremos digitar (informar) para o nosso
aplicativo uma temperatura em Celsius, para que no final o mesmo converta e
exibida a temperatura em Fahrenheit.
Bom, mãos a obra. Crie um novo projeto no Android Studio indo no menu
“File/New Project”.
Com a caixa de diálogo aberta, vamos preencher os campos conforme abaixo:
Agora vamos preencher os campos, conforme abaixo:
Application Name : ConverteTemperatura
Company Domain : app.android
Project location : (Fica a sua escolha)
Confira como ficou na figura seguinte:
348
Caixa de diálogo – Create New Project
Agora na próxima seções avance (clicando em “Next”, e deixando as

configurações conforme já vistas nas opções padrões) até chegarmos na
opção de definição da nossa Activity. Chegando nessa parte, preencha as
informações da Activity a ser criada, de acordo com as informações a seguir:
Activity Name : ConverteTemperaturaActivity
Layout Name : activity_converte_temperatura
Title : Converte Temperatura
Resource Menu Name : converte_temperatura
349
Vejamos como ficou ja figura seguinte :
Informações preenchidas
Depois de preenchidas as informações, vamos criar o nosso projeto clicando

no botão “Finish”. Feito isso o nosso projeto será criado.
350
Projeto criado com sucesso
Bom, o que iremos fazer agora ? Primeiramente, vamos remover esse

componente TextView (a frase “Hello World”) da tela do dispositivo,
simplesmente selecionando o componente na e em seguida pressionando a
tecla “DELETE”. Vejamos o resultado :
Componente TextView removido da tela
Muito bem. Se observarmos ao lado nos temos a nossa paleta de

componentes, onde são disponibilizados uma serie de componentes (também
conhecidos como Widgets) do Android que podemos utilizar em uma aplicação
a ser construida. Vejamos na figura seguinte :
351
Paleta de componentes do Android – Em destaque
Se observarmos a paleta de componentes, ela é organizada e distribuída em

várias seções (como “Widgets”, “Text Fields”, “Layouts” e etc). Na seção que
está aberta (a seção “Widgets”) vamos selecionar o componente Medium Text
(que nada mais é do que um TextView com tamanho de fonte um pouco
maior), conforme podemos ver na indicação (1) da imagem seguinte.
Ao selecionar o componente, clique e MANTENHA O BOTÃO DO MOUSE

PRESSIONADO sobre ele e ARRASTE até a tela do nosso dispositivo,
conforme podemos ver na índicação (2) da figura seguinte :
352
Arrastre e solte o componente
aqui.
(1)
Clique e MANTENHA O BOTÃO

DO MOUSE PRESSIONADO. (2)
Adicionando o componente na tela
Como resultado, temos um componente inserido na nossa tela :
Componente inserido na tela
Beleza, aprendemos como adicionarmos um componente na tela do nosso

dispositivo.
Agora vamos na propriedade text do nosso componente inserido (na guia

“Properties”. Certifique-se se o componente está selecionado) para digitarmos
a seguinte frase : “Digite a temperatura em Celsius”. Confira como ficou :
353
Frase inserida na propriedade Text
Vejamos o resultado na tela do dispositivo :
Resultado após modificação na propriedade Text
Muito bem, agora vamos adicionar um componente do tipo campo de texto (ou
caixa de texto) do Android, conhecido como EditText (podemos dizer que sua
utilização é bastante similar ao método nextLine que aprendemos no Java).
354
Onde se encontra o componente EditText ?
Esse componente se encontra na paleta de componentes, dentro da seção

“Text Fields”.
Para visualizarmos todos os componentes dentro dessa seção, basta seguir o

que se pede nas imagens a seguir :
Encontre a guia “Text Fields”, na paleta

de componentes.
Feito isso podemos ver todos

os componentes daquela
seção.
355
Poxa, estou vendo vários componentes de campos dentro da seção “Text
Fields”. Qual deles é o componente EditText que você havia mencionado ?
Resposta : TODOS ELES.
Todos os componentes da seção “Text Fields” são widgets do tipo EditText. A

diferença em cada componente EditText presente na seção “Text Fields” é que
cada um deles irá aceitar uma determinada categoria de valores (como o
“Password” que funciona como um campo só para senhas, ou o “Number” que
só irá aceitar números e etc.).
Como iremos trabalhar com temperaturas, iremos digitar somente valores

numéricos (valores reais), logo, o componente (widget) mais apropriado para
isso será o componente “Number (Decimal)”. Veja abaixo :
Componente Number (Decimal)
Agora siga as instruções que são exibidas na imagem a seguir :
356
Arrastre e solte o componente
DO MOUSE PRESSIONADO.
aqui.
Adicionando o componente Number (Decimal)
Resultado :
Componente inserido
Muito bem. Agora , o que você precisa saber é que iremos trabalhar com esse
componente dentro do nosso código em Java (para obtermos os valores que
são digitados dentro dele, similar ao que fazíamos com o método nextDouble).
Um costume que iremos adotar aqui (a partir de agora e para sempre na

programação com Android) é que todo componente (widget) a ser utilizado via
código de Java terá um nome (identificador) atribuído a ele.
357
No Android, todos os componentes possuem uma propriedade chamada “Id”,
cuja finalidade é definirmos um nome para o mesmo, de forma a facilitar a sua
identificação, caso seja necessário manipula-lo via programação.
Vamos definir uma “Id” para o nosso componente que adicionamos. Para isso,
basta dar um duplo clique sobre o componente. Feito isso, será aberta uma
pequena caixa de diálogo a seguir :
Caixa de diálogo
No campo “Id” vamos digitar uma nova “Id” para o nosso componente, que vai
se chamar “edtemperatura” (sem aspas, é claro). Veja o resultado :
Mudando o nome do componente
Pressione ENTER para que as alterações tenham o seu devido efeito.
358
Agora vamos adicionar um componente do tipo Button, onde nele iremos clicar
para que o mesmo realize a conversão e mostre o resultado na tela (através de
uma caixa de diálogo, que iremos aprender a utiliza-la logo mais).
Onde se encontra o componente Button ?
O componente Button se encontra dentro da guia “Widgets” (a mesma onde se

encontrava o componente TextView). Para adicionarmos o componente
Button basta seguir as instruções a seguir (conforme já foi mostrado e que
reforço aqui novamente) :

DO MOUSE PRESSIONADO. Arrastre e solte o componente
aqui.
359
Com o componente selecionado vamos guia “Properties” e expanda a
propriedade “Layout Parameters”, conforme podemos conferir na figura abaixo :
Expandindo a propriedade “Layout Parameters”
Nessa propriedade vamos alterar a largura (Width) do nosso componente

Button. Na propriedade layout:width troque o valor de “wrap_content” para
“match_parent”. Isso fará com que a largura do nosso componente ocupe toda
a largura do dispositivo. Veja o resultado :
360
OBS : Na propriedade layout:width também temos a opção “fill_parent”, que
praticamente tem o mesmo efeito do “match_parent”.
Agora vamos atribuir uma “Id” ao nosso componente Button (da forma como já
foi mostrado). O nome do nosso componente será “btconverter” (sem aspas, é
claro).
E para finalizar, na guia “Properties”, procure pela propriedade text do

componente Button para digitarmos a seguinte frase “Converter temperatura”
(sem aspas). Vejamos o resultado :
Título atribuído ao componente Button
Antes de prosseguirmos com o desenvolvimento (praticamente finalizado, a

respeito da interface da aplicação), é preciso esclarecer uma coisa, como fonte
de conhecimento.
A tela que visualizamos e que acabamos de construir nada mais é do que uma
estrutura baseada na linguagem XML. O que seria esse tal de XML ? Esse
XML (Extensive Markup Language) nada mais é do que uma linguagem de
marcação, baseada em “tags” (rótulos), onde cada uma delas define um
componente a ser exibido, uma propriedade a ser aplicada e etc.
Vamos ver agora o que existe “por trás” dessa tela que acabamos de
desenvolver.
361
Clique na guia “Text”, conforme podemos ver na figura abaixo :
Selecionando a guia destacada
Feito isso teremos o seguinte resultado:
362
Código XML da tela da aplicação
Que código “louco” é esse todo colorido que estamos acabando de ver ? Ah,
esse é o código XML , que é responsável por gerar aquela tela “bonita” que
acabamos de construir no nosso projeto.
Nas figuras a seguir, vamos acompanhar e descobrir o que cada código (“tags”)
do XML representa la na tela de nossa aplicação.
363
A estrutura RelativeLayout representa a tela onde os
componentes são inseridos (a nossa tela branca, conforme
indicação da seta abaixo)
364
A estrutura TextView representa a mensagem que
escrevemos na tela da nossa aplicação (a frase “Digite a
temperatura em Celsius), conforme a seta abaixo :
365
A estrutura EditText representa o campo onde iremos
digitar a nossa temperatura,conforme mostra a seta abaixo :
366
A estrutura Button representa aquele botão que iremos
apertar para que a temperatura seja convertida :
Entendeu melhor agora como a coisa funciona ? Com certeza que sim.
Agora vamos voltar para o modo gráfico, clicando na guia “Design”, conforme
mostra a figura a seguir :
367
Selecionando o modo Design
Bom, agora vamos manipular os componentes inseridos na tela através da

programação com Java (agora colocaremos em prática todo o aprendizado que
adquirirmos com programação).
Uma forma que uso bastante para visualizar a classe principal da aplicação e
seguindo os seguintes passos abaixo , conforme mostra as imagens :
1) Localize o nome da nossa classe “ConverteTemperatura”, conforme

mostra a figura abaixo :
368
Clique no local indicado e selecione “Open ConverteTemperatura”, conforme é
mostrado na figura abaixo :
Abrindo a classe ConverteTemperatura
Feito isso, teremos o seguinte resultado:
Código da classe em exibição
369
Agora sim, chegou o momento de colocarmos tudo o que aprendemos na
prática com Java agora o Android.
A primeira linha de código que iremos inserir será a linha de importação de

pacotes (a clausula import, aquela que aprendemos para usar a classe
Scanner do Java), que vamos precisar para importarmos todas as classes
referentes aos componentes inseridos na tela da aplicação.
A linha de código é exibida, expanda a seção de importação de pacotes,

conforme mostra a figura a seguir :
Expandindo a seção de declaração de pacotes
Após a realização da tarefa acima, vamos digitar as seguintes linhas de código

destacadas a seguir :
370
Pacotes declarados
Os pacotes “android.widget” e “android.view” são os mais comuns do Android,

onde dentro deles possuem as classes dos respectivos componentes que
foram inseridos na tela (mais para o pacote “android.widget”). Já o pacote
“android.app” possui uma classe que iremos utilizar para exibir mensagens na
tela (que o caso, será o resultado da conversão), a classe AlertDialog.
Agora dentro da seção de declração de atributos da classe, digite o seguinte

código destacado em seguida :
Atributos declarados
Os atributos que declaramos acima irá representar (e manipular) os

componentes que adicionamos na tela do nosso dispositivo.
371
Agora dentro do método onCreate vamos escrever as seguinte linhas de
código destacadas abaixo :
Instruções inseridas
Vamos entender agora as instruções que acabamos de inserir agora. A

instrução :
edtemperatura = (EditText) findViewById(R.id.edtemperatura);
Irá atribuir para ao objeto edtemperatura (do tipo EditText) o controle do

componente chamado “edtemperatura” que adicionamos la na tela do nosso
dispositivo, através do método findViewById. Observe que o componente que
adicionamos la na tela do dispositivo é reconhecido no Java através da
seguinte notação abaixo :
R.id.<nome do componente>
Ou seja, se eu tenho um componente chamado “edcalcular” la na tela do

dispositivo, ele no código Java é referenciado como “R.id.edcalcular”. Vejamos
a tabela em seguida para entendermos melhor:
372
Nome do componente Como ele é referenciado no código Java
(Na tela do dispositivo) (usando o findViewById)
edtemperatura R.id.edtemperatura
btconverter R.id.btconverter
btsalvar R.id.btsalvar
Na instrução a seguir :
btconverter = (Button) findViewById(R.id.btconverter);
Irá atribuir para ao objeto btconverter (do tipo Button) o controle do

componente chamado “btconverter” que adicionamos lá na tela do nosso
dispositivo, através do método findViewById.
Agora, dando continuidade, vamos adicionar o seguinte código destacado

abaixo :
setContentView(R.layout.activity_converte_temperatura);
btconverter.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
double tempcelsius =
Double.parseDouble(edtemperatura.getText().toString());
double tempfahrenheit = tempcelsius * 1.8 + 32;
}
});
373
O código que inserimos aparentemente parece um pouco “complexo”, mas irei
explicar para você. Observe que estamos executando um método chamado
setOnClickListener :
@Override
:
O que faz esse método (que praticamente existe em todos os componentes

Android) ? Ele cria um evento (ou seja , uma ação) que será disparado toda
vez que o nosso botão for clicado. Isso quer dizer que toda vez que o botão
“Converter temperatura” for clicado ele irá executar um bloco de código,
responsável pela conversão da temperatura.
O código responsável pela conversão está sendo desenvolvido dentro do

método onClick, que deve ficar sempre dentro do método
setOnClickListener:
@Override
}
});
Dentro do método onClick, temos a seguinte linha de comando :
Que é responsável por obter do componente edtemperarura o conteúdo

digitado “convertido” para um valor numérico, através do método parseDouble
da classe Double.
374
A conversão torna-se obrigatória , pois, mesmo que a gente digite um número
dentro da caixa de texto, ele estará no formato texto, sendo necessário a sua
conversão para o formato numérico, caso o valor que estiver dentro da caixa
precisar passar por alguma operação aritmética.
Bom, agora vamos dar continuidade ao nosso desenvolvimento do código.

Dentro do método onClick vamos digitar o seguinte código destacado em
seguida:
@Override
AlertDialog.Builder dialogo = new

AlertDialog.Builder(ConverteTemperaturaActivity.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("A temperatura em Fahrenheit é " +
tempfahrenheit);
dialogo.setNeutralButton("OK", null);
dialogo.show();
});
Irei explicar agora as linhas de código que estão destacadas acima.
A primeira instrução abaixo :

AlertDialog.Builder(ConverteTemperaturaActivity.this);
Cria uma instância da classe AlertDialog, que é responsável por exibir

mensagens na tela do dispositivo Android.
375
Na próxima instrução:
Definimos o título que será exibido na caixa de diálogo, através do método

chamado setTitle.
dialogo.setMessage("A temperatura em Fahrenheit é " +

tempfahrenheit);
Definimos a mensagem que será exibida na tela do dispositivo, através do

método setMessage. Na próxima instrução :
Usamos o método setNeutralButton para mostrar aquela botão “OK” que

sempre aparece na caixa de mensagem. E por último :
dialogo.show();
Usamos o método show , para exibirmos na tela a mensagem mostrando a

temperatura convertida.
Bom, vamos executar agora a nossa aplicação Android. O resultado você

confere na figura seguinte :
376
Com o uso do teclado, vamos digitar no campo referente à temperatura um

valor númerico, que corresponde à uma temperatura em Celsius. Veja abaixo :
Temperatura digitada
377
Em seguida vamos clicar no botão “Converter temperatura”, e teremos o
seguinte resultado :
Aplicação em execução – Resultado na tela
E ai, aprendeu como se desenvolve uma aplicação em Android bem básica ?

Com certeza que sim.
Conforme eu já havia feito em outros capitulos (tanto em Java e no

PORTUGOL), irei mostrar aqui o passo o passo do processo de execução do
código de uma aplicação Android.
Bom, conforme havia falado, a execução de um programa em Android começa

pelo método onCreate. Então, vamos a execução passo a passo :
378
Chama o método onCreate da classe Activity , na qual a

nossa classe deriva.
O método setContentView carrega a tela da nossa

aplicação.
Carregamos os objetos que iremos manipular na aplicação Android.
379
:
btconverter.setOnClickListener(new
View.OnClickListener() {
@Override
Double.parseDouble(edtemperatura.getText().
toString());

AlertDialog.Builder
(ConverteTemperaturaActivity.this);
dialogo.setMessage("A temperatura em Fahrenheit é
" + tempfahrenheit);
dialogo.show();
}
});
}
Aqui definimos para o objeto btconverter (que representa o botão que

está na tela) um método que será disparado toda vez que o mesmo for
clicado, através do setOnClickListener.
380
Aplicação em execução. Agora vamos digitar o
valor correspondente a temperatura no campo
indicado pela seta abaixo :
381
Depois de digitada a temperatura desejada, vamos clicar no
botão “Converter temperatura”.
Se lembra que adicionamos um evento que será executado

toda vez que o botão for clicado ? Logo, apoós o clique será
executado o método onClick que definimos no código java :
Double.parseDouble(edtemperatura.getText().
toString());

AlertDialog.Builder
(ConverteTemperaturaActivity.this);
dialogo.setMessage("A temperatura em Fahrenheit é
" + tempfahrenheit);
dialogo.show();
382
A execução do bloco de código dentro do método onClick irá
nos mostrar o seguinte resultado :
Neste capítulo aprendemos a construir uma pequena aplicação básica ,

baseada nos exercícios que desenvolvemos na programação com algoritmos
com PORTUGOL e Java.
No próximo capítulo iremos conhecer alguns componentes (widgets) básicos

que formam uma aplicação Android.
383
Capitulo 14 Conhecendo os
componentes do Android
T oda aplicação Android normalmente é formado por um ou mais widgets,

que são componentes gráficos que constituem uma aplicação. A partir
de agora iremos conhecer os widgets básicos disponíveis e oferecidos
pela plataforma Android, para o desenvolvimento das aplicações. De acordo
com alguns widgets que fomos conhecendo, vamos desenvolver aplicações
que demonstrem o uso deles.
No capítulo anterior aprendemos a desenvolver nossa primeira aplicação em

Android, algo absolutamente simples. Agora vamos conhecer melhor a paleta
de componentes onde nela estão disponíveis todos os widgets que podemos
utilizar em uma aplicação (todos eles separados por categorias).
4.1) A paleta de componentes e suas widgets
A ferramenta de desenvolvimento do Android SDK nos oferece uma gama de

componentes (ou widgets, como preferirem) que podemos utilizar em uma
aplicação a ser construída. Podemos conferir esses widgets na paleta
mostrada pela figura seguinte:
384
A paleta de componentes
Conforme havia falado, os componentes estão distribuídos nas mais diversas

seções presentes na paleta de componentes. Vamos conhecer as seções
desta paleta e os componentes nela presentes.
4.1.1) A seção “Widgets”
Nesta seção estão disponíveis os componentes mais básicos que podem ser
utilizados em uma aplicação Android, são eles:
TextView : Componente que funciona como se fosse uma Label (“rotulo”),

onde nele podemos mostrar alguma informação, mensagem e etc Na nossa
primeira aplicação tivemos a oportunidade de usarmos esse componente. Ele
385
está disponível em quatro estilos (Plain , Large, Medium e Small). Veja os
ícones desse componente na imagem seguinte:
Ícones do componente TextView (Versão normal, large, medium e small)
Button : Componente que representa um botão onde podemos clicar nele e

também atribuir ações que podem ser executadas caso isso aconteça. Ele se
encontra nas versões normal e small (pequena): Veja seu ícone na paleta de
componentes :
Ícones do componente Button (Versão normal e small)
CheckBox : Esse componente funciona como uma opção, onde nele podemos
marcá-lo e desmarcá-lo. Veja o ícone do componente abaixo:
Ícone do componente CheckBox
RadioButton : Esse componente funciona como uma opção, normalmente

utilizado quando temos uma situação onde devemos escolher uma entre várias
opções (como numa prova de múltipla escolha). Veja o ícone desse
componente na paleta de componentes :
Ícone do componente RadioButton
Spinner : Esse componente nada mais é do que uma caixa de combinação

(também conhecido como Combo Box). Nesse componente podemos adicionar
vários itens que poderão ser selecionados pelo usuário através do mesmo.
Veja o ícone desse componente na figura seguinte:
386
Ícone do componente Spinner
ProgressBar : Esse componente exibe uma barra de progresso na tela e está

disponível em 3 versões (normal e large (giratórias) e horizontal (barra)). Veja
seus ícones abaixo:
Ícone do componente ProgressBar
RatingBar : Esse componente é bastante utilizado para fazer sistemas de

votações e classificações (aqueles sistemas em que você define se uma coisa
é ruim, regular, boa, ótima e etc). Veja o ícone do componente na figura
seguinte:
Ícone do componente RatingBar
ImageView : Esse componente simplesmente serve para exibir imagens que

se colocam nele. Os formatos de imagens suportados por esse componente
são : PNG, JPEG, BMP, GIF. Veja o ícone desse componente em seguida:
Ícone do componente ImageView
ImageButton : Esse componente é derivado do componente Button só que ao

invés de exibir um texto dentro dele, exibe uma imagem. Os formatos de
387
imagens suportados por esse componente são : PNG, JPEG, BMP, GIF. Veja o
ícone desse componente abaixo:
Ícone do componente ImageButton
Gallery : Esse componente funciona como uma galeria de imagens, onde nele
podemos adicionar várias imagens e ao mesmo, visualiza-las. Veja o ícone
desse componente abaixo:
Ícone do componente Gallery
4.1.2) A seção “Text Fields”
Nesta seção estão disponíveis todos os componentes baseados em caixas de

texto, e todos eles são baseados no componente EditText. Vamos ver alguns
desses componentes abaixo:
Plain Text: Esse é o modelo de caixa de texto “padrão”, que permite a

digitação de qualquer tipo de caractere. Veja seu ícone abaixo:
Ícone do componente Plain Text
Person Name: Esse modelo de caixa de texto permite a digitação de nomes

pessoais (colocando a inicial de cada palavra em maiúsculo). Veja seu ícone
abaixo:
Ícone do componente Plain Text
388
Password: Esse modelo de caixa de texto permite a digitação de senhas e
está disponível tanto na versão alfanumérica quanto na numérica (Numeric).
Veja os ícones de componente abaixo:
Ícones do componente Password (na versão normal e numérica)
E-mail: Esse modelo de caixa de texto permite a digitação de e-mail. Veja o

ícone de componente abaixo:
Ícone do componente E-mail
Phone: Esse modelo de caixa de texto permite a digitação de telefones. Veja o

ícone de componente abaixo:
Ícone do componente Phone
Multiline Text : Esse modelo de caixa de texto permite várias linhas de texto,
de acordo com a nossa necessidade. Veja o ícone desse componente abaixo:
Ícone do componente Multiline Text
4.1.3) A seção “Layouts”
389
Nesta seção estão disponíveis estruturas de layouts que podemos utilizar em
nossas aplicações para organizar a disponibilidade dos componentes dentro da
tela, no dispositivo. Vejamos esses componentes:
LinearLayout : Essa estrutura (conforme já havia mencionado) organiza os

componentes dentro dela de forma que os mesmos sejam distribuídos de forma
horizontal (um ao lado do outro) ou vertical (um abaixo do outro), de acordo
com a necessidade. Veja os ícones desse componente:
Ícones do componente LinearLayout (horizontal e vertical)
RelativeLayout : Essa estrutura (conforme também já havia mencionado)

organiza os componentes dentro dela de forma que os mesmos sejam
distribuídos livremente na tela (em qualquer ponto em que você desejar,
relativo a outros componentes que , possivelmente, estejam na tela). Veja os
ícones desse componente:
Ícone do componente RelativeLayout
TableLayout: Essa estrutura organiza os componentes dentro dela de forma

como se estivessem em uma tabela (com o auxílio de um componente útil, o
TableRow, também presente nesta seção). Veja o ícone desse componente
abaixo:
Ícone do componente TableLayout
390
4.1.4) A seção “Containers”
Nesta seção estão disponíveis componentes que naturalmente funciona como

complementos (compostos) para outros componentes. Vejamos os
componentes dessa seção :
ListView : Esse componente funciona como uma lista onde nele podemos
adicionar itens e visualizar os mesmos (conhecido em algumas ferramentas de
desenvolvimento como “ListBox”). Vejamos o ícone desse componente:
Ícone do componente ListView
RadioGroup : Esse componente nada mais é do que um estrutura constituída

(por padrão) por três RadioButtons , que podem ser distribuídos de forma
horizontal e vertical. Veja o ícone desse componente na figura seguinte:
Ícone do componente RadioGroup
VideoView : Esse componente serve para reproduzir vídeos que queiramos

visualizarmos através dele. Veja o ícone desse componente abaixo:
Ícone do componente VideoView
4.1.5) A seção “Date & Time”
Nesta seção estão disponíveis os componentes que trabalham com data e

hora. Vejamos os componentes abaixo:
391
TimePicker : Esse componente é muito útil , nele podemos estipular ou definir
uma determinada hora, de acordo com a nossa necessidade. Veja o ícone
desse componente em seguida:
Ícone do componente TimePicker
DatePicker : Esse componente é muito útil , nele podemos estipular ou definir

uma determinada data, de acordo com a nossa necessidade. Veja o ícone
desse componente abaixo:
Ícone do componente DatePicker
Chronometer : Esse componente nada mais é do que um cronometro digital,

que podemos utilizá-lo de acordo com a nossa necessidade . Ele é derivado do
componente TextView. Vejamos seu ícone abaixo:
Ícone do componente Chronometer
AnalogClock : Esse componente nada mais é do que um relógio analógico

que mostra a hora do sistema. Vejamos seu ícone abaixo:
Ícone do componente AnalogClock
DigitalClock : Esse componente nada mais é do que um relógio digital

(também derivado do TextView) que mostra a hora do sistema. Vejamos seu
ícone abaixo:
392
Ícone do componente DigitalClock
4.1.6) A seção “Expert”
Nesta guia estão componentes de categorias miscelâneas (mistas) , que

envolvem manipulação de animações e efeitos de transição e etc. Vamos ver
alguns componentes
ViewFlipper : Esse componente funciona como se fosse uma estrutura de

layout para elementos, onde cada elemento é exibido (e também ocultado)
usando um efeito de transição. Vejamos seu ícone abaixo:
Ícone do componente ViewFlipper
AutoCompleteTextView : Esse componente é muito útil quando queremos

que durante a digitação de um conteúdo , o mesmo apresente sugestões de
palavras (muito comum nas aplicações de hoje em dia). Veja seu ícone abaixo :
Ícone do componente AutoCompleteTextView
Neste capítulo tivemos a oportunidade de conhecer os componentes básicos e

essenciais da plataforma Android. No próximo capitulo iremos construir
diversas aplicações que façam uso da maioria dos componentes descritos
nessa seção.
393
Capitulo 15 Desenvolvendo
mais aplicações para Android
C
om base do que já foi visto no capítulo anterior, onde tivemos a
oportunidade de conhecermos os componentes que formam uma
aplicação Android, vamos agora dar inicio a construção de um conjunto
de aplicações para Android para enriquecer o nosso conhecimento à respeito
sobre o desenvolvimento de aplicações para a plataforma, utilizando alguns
dos componentes citados .
15.1) Criando uma aplicação Android para uma Lanchonete
Baseado no que já estudamos na programação com algoritmos, vamos criar

uma aplicação Android voltada para uma lanchonete, onde nela informaremos
o código de um produto a ser escolhido e a quantidade a ser adquirida. Ao final
o programa deverá mostrar o valor total da compra. Simples não ?
Aparentemente pelo enunciado sim, mas agora iremos “traduzir” tudo isso que
foi explicado para uma aplicação.
Primeiramente, vamos criar um novo projeto no Android Studio, de acordo com

os seguintes dados abaixo :
Application Name: AplicacaoLanchonete
Company Domain: app.android
Activity Name: LanchoneteActivity
Title : Aplicacao Lanchonete
Menu Resource Name : menu_lanchonete
394
Após criarmos o nosso projeto vamos selecionar o componente TextView
(escrito com a frase “Hello World”) para alterarmos a propriedade Text. Na
propriedade text vamos digitar a seguinte frase : “Bem vindo a lanchonete
ServeTudoMix, aqui você encontra as mais diversas variedades.”
Feito isso, vamos agora alterar o tamanho do nosso texto, através da

propriedade textSize. Digite o valor “16sp” (sem aspas, claro). Vejamos o
resultado :
Aplicação em desenvolvimento
Agora vamos inserir abaixo desse texto um componente do tipo TextView . em

seguida , altere as seguintes propriedades conforme a tabela abaixo :
Propriedade Valor
text Confira o código dos produtos
textSize 16sp
Confira o resultado :
395
Ainda no mesmo texto, procure pela propriedade layout:margin e expanda as

suas sub-propriedades, conforme podemos ver em seguida :
Expandindo as propriedades
Após expandirmos, vamos na propriedade top para digitarmos “10dp”. Feito

isso pressione ENTER e confira o resultado :
396
Aplicação em desenvolvimento – O texto se afasta
Agora, vamos adicionar os seguintes textos (componentes TextView) ,

seguindo as formatações apresentadas pelas tabelas a seguir :
TextView
Propriedade Valor
text 1001 – Cachorro Quente ($ 5,00)
textSize 16sp
layout:margin (top) 10dp
TextView
Propriedade Valor
text 3001 – X – Tudo (R$ 10,00)
textSize 16sp
Vejamos o resultado na figura a seguir :
397
Aplicação em desenvolvimento:
Agora vamos inserir os seguintes componentes, na sequência abaixo :
TextView
Propriedade Valor
text Informe o código
textSize 16sp
textColor #0000ff
OBS : A propriedade destacada acima (textColor) permite-nos definir uma cor

para o nosso texto. Por padrão, o valor das cores são expressos no formato
hexadecimal. O valor “#0000ff” equivale a cor azul.
EditText (Number Decimal)
Propriedade Valor
id edcodigo
layout:width match_parent
398
TextView
Propriedade Valor
text Quantidade
textSize 16sp
textColor #0000ff
OBS : A propriedade destacada acima (Text Color) permite-nos definir uma

cor para o nosso texto. Por padrão, o valor das cores são expressos no formato
hexadecimal. O valor “#0000ff” equivale a cor azul.
EditText (Number Decimal)
Propriedade Valor
id edquantidade
Button
Propriedade Valor
id btcalcular
text Calcular Preço
Depois de inseridos todos os componentes, confira o resultado na figura a

seguir :
399
Como já havia falado, toda tela da aplicação consiste em um código XML certo
? Confira agora o código XML (que é gerado quando vamos inserindo os
componentes) que produz toda a tela da figura acima :
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".LanchoneteActivity">
<TextView android:text="Bem vindo a lanchonete ServeTudoMix, aqui você

encontra as mais diversas variedades" android:layout_width="wrap_content"
android:layout_height="wrap_content"
400
android:textSize="16sp"
android:id="@+id/textView" />
<TextView
android:layout_width="wrap_content"
android:text="Confira código os produtos"
android:id="@+id/textView2"
android:layout_below="@+id/textView"
android:layout_alignParentLeft="true"
android:layout_marginTop="10dp" />
<TextView
android:text="1001 – Cachorro Quente ($ 5,00)"
android:layout_below="@+id/textView2"
<TextView
android:text="3001 – X – Tudo (R$ 10,00)"
<TextView
android:text="Informe o código"
android:singleLine="true"
android:textColor="#0000ff"
android:paddingTop="15dp" />
<EditText
android:id="@+id/edcodigo"
android:layout_alignParentLeft="true" />
<TextView
401
android:text="Quantidade"
android:layout_below="@+id/edcodigo"
android:singleLine="false"
android:paddingTop="15dp"
android:textColor="#0000ff" />
<EditText
android:id="@+id/edquantidade"
android:layout_centerVertical="true"
<Button
android:text="Calcular"
android:id="@+id/btcalcular"
android:layout_below="@+id/edquantidade"
</RelativeLayout>
Depois de realizada toda a tarefa solicitada, vamos salvar o nosso arquivo

(CTRL+S).
Agora vamos inserir o código dentro da classe LanchoneteActivity (o arquivo

“LanchoneteActivity.java”), de acordo como é mostrado abaixo :
package android.app.aplicacaolanchonete;
import android.view.View;
import android.widget.*;
import android.view.*;
import android.app.*;
public class LanchoneteActivity extends Activity {
EditText edcodigo, edquantidade;
Button btcalcular;
@Override
402
setContentView(R.layout.activity_lanchonete);
edcodigo = (EditText) findViewById(R.id.edcodigo);
edquantidade = (EditText) findViewById(R.id.edquantidade);
btcalcular = (Button) findViewById(R.id.btcalcular);
btcalcular.setOnClickListener(new View.OnClickListener() {
@Override
int codigo =
Integer.parseInt(edcodigo.getText().toString());
int quantidade =
Integer.parseInt(edquantidade.getText().toString());
int total = 0;
if((codigo == 1001) || (codigo == 3001))

{
if(codigo == 1001)
total = 5 * quantidade;
else
MostrarMensagem("O preço total é R$ " + total +
",00");
}
else {
MostrarMensagem("Código inexistente. Tente novamente.");
}
}
});
}
public void MostrarMensagem(String mensagem)

{
AlertDialog.Builder(LanchoneteActivity.this);
dialogo.setMessage(mensagem);
dialogo.show();
}
403
@Override
//present.
getMenuInflater().inflate(R.menu.lanchonete, menu);
return true;
}
Depois de digitado o código acima vamos executar a nossa aplicação. O

resultado a gente confere na figura abaixo:
Se observarmos o código de nossa aplicação acima, foi criado um método

chamado MostraMensagem , cuja finalidade é mostrar uma mensagem ,
usando a classe AlertDialog, uma forma de facilitar a escrita do código da
aplicação, pois, as mensagens são exibidas em duas circunstâncias diferentes
. Uma é quando o código existe (exibindo o cálculo final da compra) :
404
if((codigo == 1001) || (codigo == 3001))
{
if(codigo == 1001)
else
MostrarMensagem("O preço total é R$ " + total +
",00");
}
E outra é quando o código não existe, informando ao usuário o ocorrido :
if((codigo == 1001) || (codigo == 3001))

{
if(codigo == 1001)
else
MostrarMensagem("O preço total é R$ " + total + ",00");

}
else {
MostrarMensagem("Código inexistente. Tente novamente.");
15.2) Criando uma aplicação básica de compras
Agora, para aprimorar mais os nossos conhecimentos, vamos desenvolver uma

aplicação básica que consiste em um pequeno sistema básico de compras. Até
agora, nós utilizamos os componentes TextView,EditText e Button. Nesta
aplicação que iremos desenvolver iremos utilizar um componente chamado
CheckBox, que consiste em um componente onde marcamos e desmarcamos
uma determinada opção (que utilizaremos para marcar os itens a serem
comprados). Segue abaixo os dados da aplicação a ser construída :
Application Name: AplicacaoCompras
Activity Name: CompasActivity
405
Layout Name : activity_compras
Title : Aplicacao Compras
Menu Resource Name : menu_compras
Após a criação do projeto, exclua o título “Hello World” da tela e sem seguida
coloque os seguintes itens, na sequencia abaixo :
TextView
Propriedade Valor
text Escolha seu produto
textSize 16sp
padding (bottom) 15dp
Feito o que se foi pedido, adicione os seguintes componentes na sequencia:
CheckBox
Propriedade Valor
text Arroz (R$ 2,69)
id chkarroz
CheckBox
Propriedade Valor
text Leite (R$ 5,00)
id chkleite
CheckBox
Propriedade Valor
text Carne (R$ 9,70)
id chkcarne
406
CheckBox
Propriedade Valor
text Feijão (R$ 2,30)
id chkfeijao
Button
Propriedade Valor
text Total das compras
id bttotal
407
Vamos acompanhar agora como ficou o código XML da nossa aplicação :
tools:context=".ComprasActivity">
<TextView
android:text="Escolha o seu produto"
android:id="@+id/textView"
android:layout_alignParentTop="true"
android:singleLine="false"
android:textSize="16dp"
android:paddingBottom="15dp" />
<CheckBox
android:text="Arroz (R$ 2,69)"
android:id="@+id/chkarroz"
android:checked="false" />
<CheckBox
android:text="Leite (R$ 5,00)"
android:id="@+id/chkleite"
android:layout_below="@+id/chkarroz"
<CheckBox
android:text="Carne (R$ 9,70)"
android:id="@+id/chkcarne"
android:layout_below="@+id/chkleite"
408
<CheckBox
android:text="Feijão (R$ 2,30)"
android:id="@+id/chkfeijao"
android:layout_below="@+id/chkcarne"
<Button
android:text="Total das compras"
android:id="@+id/bttotal"
android:layout_below="@+id/chkfeijao"
</RelativeLayout>
Agora dentro da classe ComprasActivity (o arquivo “ComprasActivity.java”)

vamos digitar o seguinte código mostrado em seguida :
package android.app.aplicacaocompras;
import java.text.DecimalFormat;
import android.widget.*;
import android.view.*;
import android.app.*;
public class ComprasActivity extends Activity {
CheckBox chkarroz, chkleite, chkcarne, chkfeijao;
Button bttotal;
@Override
setContentView(R.layout.activity_compras);
chkarroz = (CheckBox) findViewById(R.id.chkarroz);
chkleite = (CheckBox) findViewById(R.id.chkleite);
chkcarne = (CheckBox) findViewById(R.id.chkcarne);
chkfeijao = (CheckBox) findViewById(R.id.chkfeijao);
409
bttotal = (Button) findViewById(R.id.bttotal);
bttotal.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
double total = 0;
if (chkarroz.isChecked())
total += 2.69;
if (chkleite.isChecked())
total += 5.00;
if (chkcarne.isChecked())
total += 9.7;
if (chkfeijao.isChecked())
total += 2.30;

AlertDialog.Builder(ComprasActivity.this);
DecimalFormat df = new DecimalFormat("0.##");
dialogo.setMessage("Valor total da compra : R$ "
+ df.format(total));
dialogo.show();
}
});
@Override
//present.
getMenuInflater().inflate(R.menu.compras, menu);
return true;
}
Dentro do código que digitamos dentro do método onClick (que será disparado
toda vez que o botão for clicado) existem algumas expressões na linguagem
410
Java que preciso explicar como funciona (embora seja até fácil de se
compreender).
Em algumas linhas de código do onClick encontramos a seguinte expressão :
total += 2.69;
Talvez você deva estar se perguntando : O que é esse “+=” (sinal de “mais”
seguido de igual juntos) ? O que está ocorrendo nessa linha nada mais é do
que um incremento, ou seja :
total = total + 2.69;
De uma forma bem mais simplificada.

Também estamos fazendo uso de uma classe chamada DecimalFormat, cuja
finalidade é formatar os números mostrando casas decimais, ideal para valores
monetários.
Executando a nossa aplicação teremos o seguinte resultado abaixo :
411
Está aplicação é bastante simples, basta selecionar os itens e em seguida
clicar no botão “Total das compras” para que você possa o valor total de suas
compras.
15.3) Criando uma aplicação de locadora de filmes
Agora iremos construir uma aplicação que vai consistir em um sistema de

locadora, onde o usuário poderá escolher um filme de seu interesse (que esteja
disponível na locadora), e a quantidade de dias que o mesmo ficará com o
filme.
O sistema terá os seguintes critérios:
Todos os filmes novos que chegaram a locadora e que estão disponíveis

para alugar custarão R$ 5,00 o dia. Já os mais antigos custarão R$ 3,50.
Se o número de dias para ficar com o filme for acima de 3, aplicar 15% de
desconto no valor do preço do aluguel.
Se o usuário que for alugar filme, tiver cadastro na locadora, aplicar 10%
de desconto no valor do aluguel.
No total, a locadora estará disponibilizando os seguintes filmes, conforme

a tabela abaixo:
Nome do filme Lançamento

Transformers : A era da extinção Sim
Capitão América : Soldado Inveral Sim
Divergente Sim
Os Vingadores Não
Thor : Mundo Sombrio Não
Sem Escalas Não
Neste projeto iremos utilizar dos componentes novos, um conhecido como

RadioButton, que funciona como um botão de opção, muito utilizado em
questões de múltipla escolha, e o outro componentes é o Spinner, que
412
funciona como uma lista onde podemos cadastrar valores e também
visualizarmos para selecionar, agregado à um componente do tipo TextView.
Vamos criar então a nossa aplicação. Eis aqui os dados do nosso projeto :
Application Name: AplicacaoLocadora
Activity Name: LocadoraActivity
Layout Name : activity_locadora
Title : Aplicacao Locadora
Menu Resource Name : menu_locadora
Depois de criarmos o nosso projeto vamos remover o componente TextView

(“Hello World”) da tela, para adicionarmos os seguintes componentes, na
sequencia :
TextView
Propriedade Valor
Bem vindo a locadora FilmeMax, onde
você encontra todos os
text
filmes (lançamentos e antigos) para
a sua escolha
textSize 16sp
TextView
Propriedade Valor
text Escolha um filme abaixo:
textSize 16sp
413
Spinner
Propriedade Valor
id spnfilmes
TextView
Propriedade Valor
text Já é cadastro ?
textSize 16sp
Vejamos abaixo como ficará o layout da nossa tela.
Agora vamos adicionar um componente do tipo RadioGroup (que consiste em

um grupo de RadioButtons . Ele se encontra na guia “Containers”) que iremos
utilizar em nosso projeto. Arrastando e soltando o componente, teremos o
seguinte resultado :
414
Por padrão, o componente RadioGroup (na Android Studio que estou usando)
fica vazio. Agora, vamos adicionar dentro desse RadioGroup dois
componentes do tipo RadioButton, um embaixo do outro, como podemos ver
na figura seguinte :
RadioButton inserido dentro do RadioGroup
415
Agora para cada RadioButton, definir as seguintes propriedades abaixo :
RadioButton (radioButton)
Propriedade Valor
id rbtsim
text Sim
checked (marcar opção)
RadioButton (radioButton2)
Propriedade Valor
id rbtnao
text Não
Eis o resultado:
Selecione agora o componente RadioGroup e modifique as seguintes

propriedades abaixo:
RadioGroup
Propriedade Valor
layout:height wrap_content
416
orientation horizontal
Agora vamos continuar o desenvolvimento da nossa aplicação. Vamos inserir
os seguintes componentes na sequencia:
TextView
Propriedade Valor
text Dias :
textSize 16sp
padding (top) 10dp
EditText (Number)
Propriedade Valor
id eddias
Button
Propriedade Valor
id bttotal
text Total
Após efetuar o que se foi pedido, teremos o seguinte resultado que podemos
conferir na figura a seguir:
417
Muito bem, acabamos de construir a nossa interface, porém, está faltando uma
coisa : colocar a lista de filmes dentro do componente Spinner. A lista dos
filmes que iremos selecionar no componentes estarão armazenadas dentro do
um arquivo XML, que está dentro do diretório “values” (o arquivo “strings.xml”).
Para isso vamos no diretório “values” e lá vamos dar um duplo clique no

arquivo “strings.xml”. Eis o resultado :
418
Arquivo “strings.xml”
Dentro do código XML, insira a estrutura destacada em azul conforme é exibida

abaixo :

<resources>
<string name="app_name">Aplicacao Locadora</string>

<string name="hello_world">Hello world!</string>
<string name="action_settings">Settings</string>
<string-array name="listafilmes">
<item >Transformers : A era da extinção</item>
<item >Capitão América : Soldado Inveral</item>
<item >Divergente</item>
<item >Os Vingadores</item>
<item >Thor : Mundo Sombrio</item>
<item >Sem Escalas</item>
</string-array>
</resources>
Depois de realizada as alterações, salve o arquivo.
419
Agora vamos voltar para o nosso projeto que estávamos desenvolvendo. Dê
um clique no componente Spínner para selecionarmos e em seguida vamos
alterar a seguinte propriedade abaixo:
Spinner
Propriedade Valor
entries @array/listafilmes
Na propriedade entries definimos os elementos de entrada que são os itens no

nosso componente (que estão dentro do “array” chamado “listafilmes”)
Depois de realizar a tarefa acima, vamos salvar a nossa aplicação. Vejamos

agora o código XML da nossa aplicação:
tools:context=".LocadoraActivity">
<TextView
android:text="Bem vindo a locadora FilmeMax, onde você
encontra todos os filmes (lançamentos e antigos)
para a sua escolha"
<TextView
android:text="Escolha um filme abaixo:"
420
<Spinner
android:id="@+id/spnfilmes"
android:entries="@array/listafilmes" />
<TextView
android:text="Já é cadastrado ?"
android:layout_below="@+id/spnfilmes"
<RadioGroup
android:layout_width="fill_parent"
android:orientation="horizontal"
android:id="@+id/radioGroup">
<RadioButton
android:text="Sim"
android:id="@+id/rbtsim"
android:checked="true" />
<RadioButton
android:text="Não"
android:id="@+id/rbtnao"
</RadioGroup>
<TextView
android:text="Dias"
android:layout_below="@+id/radioGroup"
android:textSize="16sp" />
<EditText
421
android:id="@+id/eddias"
<Button
android:text="Total"
android:id="@+id/bttotal"
android:layout_below="@+id/eddias"
</RelativeLayout>
Agora, dentro da classe LocadoraActivity (o arquivo “LocadoraActivity.java”),

vamos digitar o seguinte código a seguir :
package android.app.aplicacaolocadora;
import java.text.DecimalFormat;
import android.app.AlertDialog;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.Spinner;
public class LocadoraActivity extends Activity {
Spinner spnfilmes;
RadioButton rbtsim;
EditText eddias;
Button bttotal;
int indexFilme;
@Override
setContentView(R.layout.activity_locadora);
indexFilme = 0;
spnfilmes = (Spinner) findViewById(R.id.spnfilmes);

rbtsim = (RadioButton) findViewById(R.id.rbtsim);
eddias = (EditText) findViewById(R.id.eddias);
422
bttotal = (Button) findViewById(R.id.bttotal);
bttotal.setOnClickListener(new View.OnClickListener() {
@Override
int dias = Integer.parseInt(eddias.getText().toString());
double preco_filme;
if(indexFilme < 3)
preco_filme = 5.00;
else
preco_filme = 3.50;
double total = preco_filme * dias;
if(rbtsim.isChecked())
total = total - (total * 0.1);
if(dias > 3)
DecimalFormat df = new DecimalFormat("#.00");

AlertDialog.Builder(LocadoraActivity.this);
dialogo.setMessage("O valor total é R$ " +

df.format(total));
dialogo.show();
}
});
spnfilmes.setOnItemSelectedListener(new
AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view,
int position, long id) {
indexFilme = position;
423
@Override
public void onNothingSelected(AdapterView<?> arg0) {
});
}
Agora irei explicar algumas linhas de código do nosso programa.
No código do nosso programa declaramos uma variável chamada indexFilme,

que é responsável por armazenar o índice do filme selecionado. Na lista , os 3
primeiros filmes são lançamentos (ou seja, será cobrado o valor de R$ 5,00).
Já o restante, são filmes que são antigos (que serão cobrados por R$ 3,50).
Dentro do nosso programa estamos trabalhando com um componente do tipo

Spinner, que é controlado pela variável (objeto) spnfilmes. Toda vez que um
filme for selecionado, um evento é executado, através do método
setOnItemSelectedListener que define uma ação (método) a ser executada
toda vez que um item for selecionado. Vejamos a linha de comando abaixo :
spnfilmes.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener()
{
@Override
}
Toda vez que um filme é selecionado, atribuímos para a variável indexfilme o

índice do filme selecionado , que fica armazenado no parâmetro position,
sabendo que os filmes que são lançamentos são os 3 primeiros (ou seja,
indexados como “0”, “1”, “2”. Se lembra que todo índice no array começa com
zero ?)
No código do nosso programa existe a seguinte linha de comando :
if(rbtsim.isChecked())
424
Que verifica se se a opção “sim” (referente a pergunta do cadastrado do
usuário) está marcada (através do método isChecked, que possui essa
finalidade).
Agora vamos executar a nossa aplicação, para conferirmos o resultado,

conforme é mostrado abaixo:
15.4) Criando uma aplicação para visualização de imagens
Agora, para aprimorarmos mais os nossos conhecimentos sobre o

desenvolvimento Android, iremos construir uma aplicação que irá visualizar
imagens na tela, através do uso do componente ImageView (voltado para está
finalidade).
425
Como será a nossa aplicação ?
A nossa aplicação será inspirada no site “adorocinema.com”, onde nela

podemos ver tudo a respeito dos filmes que estão cinema (e os que irão
estrear).
Com a aplicação que iremos desenvolver, poderemos escolher os filmes que

estão em estreia no cinema para visualizarmos a capa/imagem do filme , seu
nome e sua sinopse.
Application Name: AplicacaoAdoroCinema
Activity Name: AplicacaoActivity
Layout Name : activity_aplicacao
Title : Adoro Cinema
Menu Resource Name : menu_aplicacao
No arquivo que acompanha este material, copie para dentro da pasta

“drawable” (situado dentro do diretório “res” do projeto), as seguintes imagens :
“banner_filme_capitao_america.png”, “top_titulo_adorocinema.png” ,
“banner_filme_transformers.png”, “banner_filme_divergente.png”,
“banner_filme_os_vingadores.png”, “banner_filme_thor.png” e
“banner_filme_sem_escalas.png”.
Para copiar os arquivos para dentro do diretório “drawable” do projeto, basta

selecionar todos os arquivos citados no diretório onde você extraiu todos os
arquivos que serão utilizados na apostila. Em seguida basta você selecionar o
diretório “drawable” no seu projeto, conforme você vê em seguida:
426
Diretório selecionado
Feito isso, basta pressionar “CTRL+V”. Logo em seguida será exibida a

seguinte caixa de diálogo:
Caixa de diálogo - Copy
Clique em “OK” e pronto, todas as imagens estarão disponíveis para uso.
427
Arquivos copiados
OBS : Sobre o nome das imagens
Quando trabalhamos com imagens (arquivos de forma geral), não podemos

sair atribuindo qualquer nome de qualquer forma. Existe uma serie de regras
que você precisa saber, são elas :
Só são permitidos caracteres : a-z (minúsculo somente), 0-9 e o “_”
(underline)
Não é permitido espaço em nome de arquivos
Para o desenvolvimento deste projeto irei trabalhar com a Skin “Nexus S” (cuja
resolução é 480x800 hdpi). Para alterar a Skin basta seguir o procedimento a
figura a seguir:
428
Mudando a Skin
Depois de adicionar as imagens, remova o componente TextView (frase “Hello

World”) da tela do nosso dispositivo. Feito isso vamos alterar as propriedades
do nosso componente RelativeLayout (a tela do programa), de acordo com a
tabela abaixo (para selecionar a tela, basta clicar na região branca do display) :
RelativeLayout
Propriedade Valor
padding (left) (DEIXAR EM BRANCO)
padding (top) (DEIXAR EM BRANCO)
padding (right) (DEIXAR EM BRANCO)
padding (bottom) (DEIXAR EM BRANCO)
Agora vamos arrastar um componente do tipo ImageView (situado dentro da

guia “Widgets” da paleta de componentes). Feito isso vamos na guia
429
“Properties” para encontrarmos a propriedade “src”, conforme é indicado na
figura a seguir:
Localizando a propriedade “src”
Clique no botão reticências (...) ao lado da propriedades. Feito isso será aberta
a seguinte caixa de diálogo a seguir :
Nessa caixa de diálogo vamos escolher a imagem que queremos que seja
exibida no componente. Vamos escolher a imagem “top_titulo_adorocinema” e
em seguida clique em “OK”. Vejamos o resultado na figura abaixo :
430
Caixa de diálogo – Resources
Agora vamos selecionar a imagem “top_titulo_adorocinema” e em seguida

clique em “OK”. Vejamos o resultado na figura seguinte:
431
Agora, vamos inserir o seguintes componentes na sequencia :
TextView (Medium Text)
Propriedade Valor
text Escolha um filme
Spinner
Propriedade Valor
id spnfilmes
Agora vamos inserir um componente ImageView e na propriedade src vamos

apontar para a imagem “banner_filme_transformers”. Veja o resultado na figura
a seguir :
432
Com a imagem inserida, vamos alterar a seguinte propriedade dela abaixo:
ImageView
Propriedade Valor
id imgBanner
Agora vamos adicionar os seguintes componentes na sequencia :
TextView
Propriedade Valor
id txtnomefilme
text Transformers : A era da extinção
Button
Propriedade Valor
id btsinopse
text Ver sinopse do filme
433
Eis o resultado :
Agora dentro do arquivo “strings.xml” vamos digitar o seguinte conteúdo dentro

da estrutura XML destacada em azul mostrada a seguir:

<resources>
<string name="app_name">Aplicacao AdoroCinema</string>

<string name="action_settings">Settings</string>
<string name="hello_world">Hello world!</string>
<string-array name="nomedosfilmes">
<item >Transformers : A era da extinção</item>
<item >Capitão América : Soldado Inveral</item>
<item >Divergente</item>
<item >Os Vingadores</item>
<item >Thor : Mundo Sombrio</item>
<item >Sem Escalas</item>
</string-array>
434
<string-array name="sinopsedosfilmes">
<item>Após o confronto entre Autobots e Decepticons,todos os robôs
desaparecem. Cade (Mark Wahlberg) encontra um caminhão
abandonado, ele jamais poderia imaginar que o veículo é na
verdade Optimus Prime, o líder dos Autobots. Muito menos que,
ao ajudar a trazê-lo de volta à vida, Cade e sua filha Tessa
entrariam na mira das autoridades americanas.
</item>
<item>Dois anos após os Vingadores, Steve Rogers continua seu

dedicado trabalho com a agência S.H.I.E.L.D.
Em parceria com Natasha Romanoff , ele é obrigado a enfrentar
um poderoso e misterioso inimigo chamado Soldado Invernal.
</item>
<item>Na futurística Chicago, Beatrice completa 16 anos, e ela tem

que escolher entre as diferentes facções que a cidade está
dividida.Elas são cinco, e cada uma representa um valor
diferente, como honestidade, generosidade, coragem e outros.
</item>
<item>Loki retorna à terra enviado pelos chitauri, para dominar os

humanos. Com a promessa de que será o soberano do planeta, ele
rouba o cubo cósmico dentro de instalações da S.H.I.E.L.D. No
intuito de contê-lo Nick Fury convoca um grupo de pessoas com
grandes habilidades, mas que jamais haviam trabalhado juntas.
</item>
<item>Enquanto Thor liderava as últimas batalhas para conquistar a

paz entre os Nove Reinos, o maldito elfo negro Malekith
acordava de um longo sono, sedento de vingança para levar
todos para a escuridão eterna. Alertado do perigo , o herói
precisa contar com a ajuda dos companheiros em um plano
audacioso para salvar o universo do grande mal.
</item>
<item>Durante um voo de Nova York a Londres, o agente Neil Marks

recebe uma série de mensagens SMS , dizendo que um passageiro
será morto a cada 20 minutos caso US$ 150 milhões não sejam
transferidos para uma conta bancária.
</item>
</string-array>
</resources>
Depois de realizadas as alterações no arquivo “strings.xml”, salve o arquivo.
435
Agora vamos voltar para o nosso projeto, e no componente Spinner vamos
alterar a seguinte propriedade abaixo:
Spinner
Propriedade Valor
entries @array/nomedosfilmes
Depois de realizada a alteração acima, vamos salvar as mudanças feitas no

nosso projeto.
Agora vamos na classe AplicacaoActivity (o arquivo “AplicacaoActivity.java”)

para digitarmos o seguinte código abaixo:
package android.app.aplicacaoadorocinema;
import android.app.AlertDialog;
import android.content.res.Resources;
import android.widget.AdapterView;
import android.widget.ImageView;
import android.widget.Spinner;
import android.widget.TextView;
public class AplicacaoActivity extends Activity {
ImageView imgBanner;
Spinner spnfilmes;
Button btsinopse;
TextView txtnomefilme;
int indexFilme = 0;
String[] sinopsedosfilmes;
String[] nomedosfilmes ;
@Override
436
setContentView(R.layout.activity_aplicacao);
spnfilmes = (Spinner) findViewById(R.id.spnfilmes);
imgBanner = (ImageView) findViewById(R.id.imgBanner);
txtnomefilme = (TextView) findViewById(R.id.txtnomefilme);
btsinopse = (Button) findViewById(R.id.btsinopse);
Resources res = getResources();
sinopsedosfilmes = res.getStringArray(R.array.sinopsedosfilmes);
nomedosfilmes = res.getStringArray(R.array.nomedosfilmes);
btsinopse.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {

AlertDialog.Builder(AplicacaoActivity.this);
dialogo.setTitle("Sinopse");
dialogo.setMessage(sinopsedosfilmes[indexFilme]);
dialogo.show();
}
});
spnfilmes.setOnItemSelectedListener(new
AdapterView.OnItemSelectedListener() {
@Override
switch (indexFilme) {
case 0: imgBanner.setImageResource
(R.drawable.banner_filme_transformers);break;
(R.drawable.banner_filme_capitao_america);break;
(R.drawable.banner_filme_divergente);break;
(R.drawable.banner_filme_os_vingadores);break;
(R.drawable.banner_filme_thor);break;
(R.drawable.banner_filme_sem_escalas);break;
}
txtnomefilme.setText(nomedosfilmes[indexFilme]);
}
@Override
public void onNothingSelected(AdapterView<?> arg0) {
437
}
});
}
@Override
//present.
getMenuInflater().inflate(R.menu.aplicacao, menu);
return true;
}
Depois de digitarmos o código da nossa classe, vamos executar a nossa

aplicação. O resultado você confere na figura abaixo:
Agora irei explicar algumas linhas de código do nosso programa. A instrução :
Resources res = getResources();
438
É responsável por carregar dentro do objeto res todos os recursos necessários
que serão utilizados para gerenciar o conteúdo do arquivo “strings.xml” (além
de outros recursos a mais) através do método getResources.
sinopsedosfilmes = res.getStringArray(R.array.sinopsedosfilmes);
Carrega para dentro do array sinopsedosfilmes todo o conteúdo do “string

array” sinopsedosfilmes (definido através de uma estrutura XML dentro do
arquivo “strings.xml”), através do método getStringArray, do objeto res. Na
próxima instrução :
nomedosfilmes = res.getStringArray(R.array.nomedosfilmes);
Carrega para dentro do array nomedosfilmes todo o conteúdo do “string array”

nomedosfilmes (definido através de uma estrutura XML dentro do arquivo
“strings.xml”), através do método getStringArray, do objeto res.
Observe que quando nos referimos a um “string array” definido no arquivo

“strings.xml”, usamos a seguinte notação :
R.array.<nome do string array>
Dentro do método onItemSelected (do objeto Spinner), temos a seguinte

bloco :
switch (indexFilme) {
(R.drawable.banner_filme_transformers);break;
(R.drawable.banner_filme_capitao_america);break;
(R.drawable.banner_filme_divergente);break;
(R.drawable.banner_filme_os_vingadores);break;
(R.drawable.banner_filme_thor);break;
(R.drawable.banner_filme_sem_escalas);break;
439
Que é responsável por carregar a imagem (banner) do filme selecionado dentro
do componente ImageView, através do método setImageResource, de acordo
com o índice do filme.
Quando é carregado uma imagem dentro do ImageView através do método

setImageResource, o nome da imagem deve estar na seguinte notação :
R.drawable.<nome da imagem>
O parâmetro <nome da imagem> corresponde ao nome da imagem que

colocamos dentro da pasta “drawable”.
15.5) Criando uma aplicação para jogos da Mega-Sena
A próxima aplicação que iremos desenvolver, consiste em uma aplicação de

jogos para Mega-Sena, ou seja, um aplicação que irá dar palpites de números
(gerados aleatoriamente) que podem ser jogados na MegaSena.
Application Name: AplicacaoMegaSena
Activity Name: MegaSenaActivity
Layout Name : activity_mega_sena
Title : Mega Sena
Menu Resource Name : menu_mega_sena
Para esta aplicação vamos ALTERAR A SKIN para o modelo “Nexus-S”,

conforme já havia sido mostrado.
Vamos agora remover o componente TextView da tela, e em seguida copie a

imagem “top_titulo_mega_sena.png” (que acompanha este material) para
dentro da pasta “drawable” do nosso projeto.
440
Feito isso arraste um componente ImageView para dentro da tela, e em
seguida defina para a propriedade src a imagem “top_titulo_mega_sena”
(conforme já foi mostrado). Vejamos o resultado :
Agora vamos na guia “Layouts” para selecionarmos e arrastarmos um

componente LinearLayout (Vertical) para dentro da tela, conforme mostra a
figura a seguir :
441
Eis o resultado :
Com o componente selecionado, vamos alterar a seguinte propriedade baixo :
LinearLayout
Propriedade Valor
background #00A853
Com essa propriedade definimos a cor de fundo a ser exibida no componente

inserido. Vejamos o resultado na figura seguinte :
Ué ? Ainda continua de cor branca
Se nós observarmos a estrutura LinearLayout que acabamos de inserir, a cor

de fundo não fez efeito. A razão pela qual isso aconteceu é porque não há
nenhum componente dentro da estrutura.
442
Agora vamos inserir um componente TextView (Medium Text) dentro da
estrutura LinearLayout que acabamos de inserir. Vejamos a operação sendo
realizada na figura a seguir :
Arrastrando com sucesso
Com o texto dentro do componente, vamos alterar a sua propriedade abaixo:
TextView (Medium Text)
Propriedade Valor
textColor #ffffff
Gostaria de um palpite para seu jogo?
text Clique no botão abaixo para gerar um
palpite para você. Boa sorte.
padding (top) 10dp
443
Vejamos o resultado na figura seguinte :
Agora vamos adicionar uma estrutura LinearLayout (Horizontal) abaixo da

estrutura LinearLayout (Vertical) que adicionamos anteriormente. Feito isso
vamos alterar as suas propriedades :
LinearLayout
Propriedade Valor
background #E0E0E0
gravity center
Agora dentro da estrutura que adicionamos acima, vamos adicionar os

seguintes componentes na sequencia :
TextView (Large Text)
Propriedade Valor
id txtnum1
text 00
textColor #02A650
444
padding (top) 20dp
padding (left) 10dp
padding (right) 10dp
Propriedade Valor
id txtnum2
text 00
textColor #02A650
padding (top) 20dp
padding (left) 10dp
Propriedade Valor
id txtnum3
text 00
textColor #02A650
padding (top) 20dp
padding (left) 10dp
Propriedade Valor
id txtnum4
text 00
textColor #02A650
padding (top) 20dp
padding (left) 10dp
445
Propriedade Valor
id txtnum5
text 00
textColor #02A650
padding (top) 20dp
padding (left) 10dp
Propriedade Valor
id txtnum6
text 00
textColor #02A650
padding (top) 20dp
padding (left) 10dp
Vejamos o resultado na figura a seguir
446
:
Agora vamos inserir um Button com as seguintes propriedades abaixo:
Button
Propriedade Valor
id btgerarpalpite
text Gerar palpite
Vejamos o resultado na figura seguinte:
447
Agora para finalizar selecione o componente RelativeLayout referente a tela

principal onde todos os componentes foram adicionados para modificar as
seguintes propriedades abaixo:
RelativeLayout
padding (top) (DEIXAR EM BRANCO)

padding (bottom) (DEIXAR EM BRANCO)
padding (left) (DEIXAR EM BRANCO)
padding (right) (DEIXAR EM BRANCO)
Vejamos o resultado na figura a seguir:
448
Vejamos o código XML da tela da nossa aplicação :
android:layout_height="match_parent" tools:context=".MegaSenaActivity">
<ImageView
android:id="@+id/imageView"
android:src="@drawable/top_titulo_mega_sena" />
<LinearLayout
android:orientation="vertical"
android:layout_below="@+id/imageView"
android:background="#00A853"
android:id="@+id/linearLayout">
449
<TextView
android:textAppearance="?android:attr/textAppearanceMedium"
android:text="Gostaria de um palpite para seu jogo?
Clique no botão abaixo para gerar um palpite
para você. Boa sorte."
android:textColor="#ffffff"
</LinearLayout>
<LinearLayout
android:orientation="horizontal"
android:layout_below="@+id/linearLayout"
android:background="#E0E0E0"
android:gravity="center"
android:id="@+id/linearLayout2">
<TextView
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="00"
android:id="@+id/txtnum1"
android:textColor="#02A650"
android:paddingLeft="10dp"
android:paddingRight="10dp"
<TextView
android:text="00"
<TextView
android:text="00"
450
<TextView
android:text="00"
<TextView
android:text="00"
<TextView
android:text="00"
</LinearLayout>
<Button
android:text="Gerar palpite"
android:id="@+id/btgerarpalpite"
android:layout_below="@+id/linearLayout2"
</RelativeLayout>
451
Agora na classe MegaSenaActivity (o arquivo “MegaSenaActivity.java”) vamos
digitar o seguinte código abaixo:
package android.app.aplicacaomegasena;
import java.util.ArrayList;
public class MegaSenaActivity extends Activity {
Button btgerarplapite;
TextView txtnum1, txtnum2, txtnum3, txtnum4, txtnum5, txtnum6;
ArrayList<Integer> aNumerosGerados;
@Override
setContentView(R.layout.activity_mega_sena);
aNumerosGerados = new ArrayList<Integer>();

txtnum1 = (TextView) findViewById(R.id.txtnum1);
btgerarplapite = (Button) findViewById(R.id.btgerarpalpite);
btgerarplapite.setOnClickListener(new View.OnClickListener() {
@Override
int numero_gerado;
String str_numero_gerado;
aNumerosGerados.clear();
for(int indice = 1; indice <= 6 ; indice++)

{
//Gera um número aleatório entre 1 e 60
numero_gerado = (int) Math.round(Math.random()
* 59) + 1;
//O número aleatóro gerado já foi sorteado
//anteriormente ?
452
while(aNumerosGerados.indexOf(numero_gerado) != -1)
{
//Sorteia um novo numero aleatório, diferente
numero_gerado = (int) Math.round(Math.random() *
59) + 1;
}
aNumerosGerados.add(numero_gerado);
if(numero_gerado < 10)

str_numero_gerado = "0" +
String.valueOf(numero_gerado);
else
str_numero_gerado = String.valueOf(numero_gerado);
//Mostra os números sorteados na aplicação
switch (indice) {
case 1: txtnum1.setText(str_numero_gerado);break;
}
}
}
});
}
@Override
//present.
getMenuInflater().inflate(R.menu.mega_sena, menu);
return true;
}
Depois de escrever o código da classe acima, vamos executar o nosso

programa. O resultado você confere na figura em seguida :
453
Agora irei explicar alguns trechos de código da aplicação desenvolvida. A

instrução :
ArrayList<Integer> aNumerosGerados;
Declara um objeto do tipo ArrayList (que consiste em um array de tamanho

dinâmico , ou seja, que pode aumentar de tamanho conforme a necessidade do
uso) chamado aNumerosGerados, que irá armazenar os números sorteados .
OBS : Esse ArrayList é uma classe.
A instrução :
numero_gerado = (int) Math.round(Math.random() * 59) + 1;
Gera um número aleatório entre 1 e 60, graças a função Math.random em

conjunto com a função Math.round.
454
No loop de repetição abaixo :
while(aNumerosGerados.indexOf(numero_gerado) != -1)
{
//Sorteia um novo numero aleatório, diferente
numero_gerado = (int) Math.round(Math.random() *
59) + 1;
}
É verificado, logo no inicio, se o numero sorteado já existe, através do método

indexOf do objeto aNumerosGerados. Se a função retornar um valor diferente
de -1, significa que o número sorteado já existe, logo, dentro do loop é gerado
um novo número para sorteio.
Após o loop temos a seguinte instrução :
aNumerosGerados.add(numero_gerado);
Que adiciona dentro do objeto ArrayList o número sorteado, através do

método add.
Na próxima instrução :
if(numero_gerado < 10)

str_numero_gerado = "0" + String.valueOf(numero_gerado);
else
str_numero_gerado = String.valueOf(numero_gerado);
O número sorteado é convertido para String (texto), através do método

ValueOf da classe String. Se o número for menor que 10, por exemplo 8, o
valor da String resultante (que será armazenado em str_numero_gerado) será
: “08”, pela atribuição :
str_numero_gerado = "0" + String.valueOf(numero_gerado);
455
Na estrutura switch/case abaixo :
switch (indice) {
São exibidos nos componentes do tipo TextView o valor dos números

sorteados , através do método setText de cada componente TextView
presente.
15.6) Criando uma aplicação de Pesquisa de Opinião
Agora iremos desenvolver uma aplicação de Pesquisa de Opinião para

Android. Nesse aplicativo o usuário responde a três perguntas relacionadas a
informática (cada pergunta com as suas opções de resposta), são elas :
1) Qual navegador de Internet que você mais usa ?
a) Internet Explorer
b) Firefox
c) Chrome
d) Outros
2) Qual rede social que você mais utiliza o seu dia a dia ?
a) Facebook
b) Twitter
c) Google+
d) Outros
456
3) Qual aplicativo para Bate-Papo para Android que você mais usa ?
a) Whatsapp
b) Messenger
c) Skype
d) Outros
Cada pergunta feita para o usuário estará em uma tela da aplicação, ou seja,
se iremos realizar três perguntas para o usuário estará em uma tela. Haverá
também uma quarta tela onde nela serão mostradas as perguntas com as suas
devidas respostas , juntamente com uma mensagem de agradecimento por
participar da pesquisa de opinião.
Bom, vamos criar agora o nosso projeto onde iremos construir a nossa
aplicação de pesquisa de opinião. Segue os dados do projeto :
Application Name: AplicacaoPesquisaOpiniao
Activity Name: PesquisaOpiniaoActivity
Layout Name : tela_pergunta_1
Title : Pesquisa Opiniao
Menu Resource Name : menu_pesquisa_opiniao
Após criar o projeto, vamos copiar os arquivos

“top_titulo_pesquisa_opiniao.png” , “fundo_tela_pesquisa_opiniao.png” e
“fundo_tela_pesquisa_opiniao_final.png” para dentro da pasta “drawable” do
nosso projeto que acabamos de criar.
Para esta aplicação iremos trabalhar também com a Skin do “Nexus S”. Troque
a Skin conforme já foi mostrado.
457
Para facilitar (e acelerar) a construção da nossa tela, vamos abrir a guia
referente ao código XML da tela (referente ao arquivo “tela_pergunta_1.xml”)
para substituirmos o código existente pelo seguinte código abaixo :
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/LinearLayout1"
android:background="@drawable/fundo_tela_pesquisa_opiniao"
tools:context=".PesquisaOpiniaoActivity" >
<ImageView
android:id="@+id/imageView1"
android:src="@drawable/top_titulo_pesquisa_opiniao" />
<TextView
android:text="1) Qual navegador de Internet que você mais usa ?"
android:textAppearance="?android:attr/textAppearanceMedium" />
<RadioGroup
android:id="@+id/rgropcoes_pergunta_1"
android:layout_height="wrap_content" >
<RadioButton
android:id="@+id/rbtopcao1_p1"
android:checked="true"
android:text="Internet Explorer" />
<RadioButton
android:text="Firefox" />
<RadioButton
android:text="Chrome" />
<RadioButton
458
android:text="Outros" />
</RadioGroup>
<Button
android:id="@+id/bt_pergunta2"
android:text="Ir para segunda pergunta" />
</LinearLayout>
Depois de realizado a tarefa, salve o arquivo.
459
Conforme havia falado, nossa aplicação será formada por 4 telas diferentes, a
primeira tela já foi desenvolvida. Agora, como fazer para adicionar mais uma
tela a nossa aplicação :
Para adicionarmos mais uma tela em nosso projeto, basta clicar com botão
direito sobre a pasta “layout” (a mesma pasta onde se encontra o arquivo
“tela_pergunta_1.xml”), e em seguida selecionar “New/Layout resource file”.
Veja na figura abaixo:
Criando uma nova tela
Feito isso será aberta a caixa de diálogo, conforme mostra a figura seguinte :
460
Caixa de diálogo – New Android XML File
No campo “File name” vamos digitar o nome da nossa tela que se chamada
“tela_pergunta_2” (sem aspas e sem a extensão XML, pois a mesma já fica
implícita). Na seção “Root Element” certifique-se se a opção “LinearLayout”
está marcada. Depois disso basta clicar no botão “Finish” para gerarmos a
nossa tela.
Veja verá que surgirá uma nova tela da aplicação Android toda EM BRANCO.
Agora vamos na guia referente ao código XML da segunda tela da nossa
aplicação para digitarmos a seguinte estrutura a seguir:
<ImageView
461
<TextView
android:text="2) Qual rede social que você mais utiliza o seu
dia a dia ?"
<RadioGroup
<RadioButton
android:text="Facebook" />
<RadioButton
android:text="Twitter" />
<RadioButton
android:text="Google+" />
<RadioButton
</RadioGroup>
<Button
android:id="@+id/bt_pergunta3"
android:text="Ir para terceira pergunta" />
</LinearLayout>
Eis o resultado :
462
Segunda tela da nossa aplicação
Agora, de acordo como já foi mostrado, vamos criar mais uma tela para a
nossa aplicação (o arquivo “tela_pergunta_3.xml”). O arquivo referente à tela
da nossa aplicação terá o seguinte código a seguir:
<ImageView
463
<TextView
android:text="3) Qual aplicativo para Bate-Papo para Android que você
mais usa ?"
<RadioGroup
<RadioButton
android:text="WhatsApp" />
<RadioButton
android:text="Messenger" />
<RadioButton
android:text="Skype" />
<RadioButton
</RadioGroup>
<Button
android:id="@+id/btterminarpesquisa"
android:text="Terminar pesquisa" />
</LinearLayout>
464
Eis o resultado:
Terceira tela da nossa aplicação
Agora vamos criar uma nova tela chamada “tela_finalizacao.xml” , dentro da

pasta “layouts” do nosso projeto. Segue abaixo o código XML da tela :
<ImageView
android:src="@drawable/top_titulo_pesquisa_opiniao_final" />
465
<TextView
android:paddingBottom="10dp"
android:text="OBRIGADO PELA PARTICIPAÇÃO!"
<TextView
android:text="1) Qual navegador de Internet que você mais usa ?"
android:textColor="#000000"
<TextView
android:id="@+id/txtresposta1"
android:text="RESPOSTA"
android:textColor="#0026FF"
<TextView
android:text="2) Qual rede social que você mais utiliza o seu dia a
dia ?"
<TextView
<TextView
android:text="3) Qual aplicativo para Bate-Papo para Android que você
mais usa ?"
<TextView
466
android:paddingBottom="10dp"
android:textAppearance="?android:attr/textAppearanceMedium"
<Button
android:id="@+id/btfecharaplicacao"
android:text="Finalizar aplicação" />
</LinearLayout>
Eis o resultado :
Última tela da nossa aplicação
467
Agora dentro do nosso pacote “android.app.aplicacaopesquisaopiniao”
(presente dentro da pasta “java”), vamos criar uma classe chamada Resposta (
sem método main, até porque que no Android não trabalha e nem usa esse
método). Para criarmos uma classe no Android Studio basta clicarmos com o
botão direito sobre o nome do pacote citado e selecionar “New” / “Java Class”.
Veja na figura a seguir:
Criando uma nova classe
Feito isso será aberta a seguinte caixa de diálogo a seguir:
Caixa de diálogo – Create New Class
No campo “Name” vamos digitar o nome da nossa classe, que irá se chamar
Resposta. Feito isso clique em “OK” para que a classe possa ser criada.
com o seguinte código abaixo :
package android.app.aplicacaopesquisaopiniao;
public class Resposta {
public String resposta1;
468
Agora, dentro do mesmo pacote, vamos criar uma classe chamada

TelaFinalizacao, com o seguinte código em seguida :
package com.example.aplicacaopesquisaopiniao;
import android.webkit.WebView.FindListener;
public class TelaFinalizacao {
PesquisaOpiniaoActivity activity;
Button btfecharaplicacao;
TextView txtresposta1,txtresposta2,txtresposta3;
Resposta resp;
public TelaFinalizacao(PesquisaOpiniaoActivity act,Resposta r)

{
activity = act;
resp = r;
}
public void CarregarTela()

{
activity.setContentView(R.layout.tela_finalizacao);
txtresposta1 = (TextView)
activity.findViewById(R.id.txtresposta1);
txtresposta1.setText(resp.resposta1);
btfecharaplicacao = (Button)
activity.findViewById(R.id.btfecharaplicacao);
469
btfecharaplicacao.setOnClickListener(new View.OnClickListener()
{
@Override
//Fecha a aplicação
activity.finish();
}
});
}

TelaPergunta3, com o seguinte código em seguida :
import android.widget.RadioGroup;
public class TelaPergunta3 {
Button btterminarpesquisa;
Resposta resp;
TelaFinalizacao tela_finalizacao;
RadioGroup rgropcoes_pergunta_3;
RadioButton rbtopcaoEscolhida;
public TelaPergunta3(PesquisaOpiniaoActivity act, TelaFinalizacao

tela, Resposta r)
{
activity = act;
resp = r;
tela_finalizacao = tela;
}

{
470
activity.setContentView(R.layout.tela_pergunta_3);
btterminarpesquisa = (Button)
activity.findViewById(R.id.btterminarpesquisa);
rgropcoes_pergunta_3 = (RadioGroup)
activity.findViewById(R.id.rgropcoes_pergunta_3);
btterminarpesquisa.setOnClickListener(new View.OnClickListener()
{
@Override
rbtopcaoEscolhida = (RadioButton)
activity.findViewById(rgropcoes_pergunta_3.
getCheckedRadioButtonId());
resp.resposta3 =
rbtopcaoEscolhida.getText().toString();
tela_finalizacao.CarregarTela();
}
});

Button btpergunta_3;
Resposta resp;
471
TelaPergunta3 tela_pergunta_3;
public TelaPergunta2(PesquisaOpiniaoActivity act, TelaPergunta3 tela,

Resposta r)
{
activity = act;
resp = r;
tela_pergunta_3 = tela;
}

{
btpergunta_3 = (Button)
activity.findViewById(R.id.bt_pergunta3);
btpergunta_3.setOnClickListener(new View.OnClickListener() {
@Override
activity.findViewById(rgropcoes_pergunta_2.
resp.resposta2 =
rbtopcaoEscolhida.getText().toString();
tela_pergunta_3.CarregarTela();
}
});
472
Button btpergunta_2;
Resposta resp;
TelaPergunta2 tela_pergunta_2;
public TelaPergunta1(PesquisaOpiniaoActivity act, TelaPergunta2 tela,

Resposta r)
{
activity = act;
resp = r;
tela_pergunta_2 = tela;
}

{
btpergunta_2 = (Button)
activity.findViewById(R.id.bt_pergunta2);
@Override
activity.findViewById
473
(rgropcoes_pergunta_1.
resp.resposta1 = rbtopcaoEscolhida.getText().
toString();
}
});
Agora dentro da nossa classe PesquisaOpiniaoActivity , vamos digitar o

seguinte código a seguir :
public class PesquisaOpiniaoActivity extends Activity {
TelaPergunta3 tela_pergunta3;
Resposta resposta;
@Override
resposta = new Resposta();

tela_finalizacao = new TelaFinalizacao(this, resposta);
tela_pergunta3 = new TelaPergunta3(this, tela_finalizacao, resposta);
tela_pergunta2 = new TelaPergunta2(this, tela_pergunta3, resposta);
tela_pergunta1.CarregarTela();
474
@Override
//present.
getMenuInflater().inflate(R.menu.pesquisa_opiniao, menu);
return true;
}
Depois de realizarmos todas as tarefas, vamos executar a nossa aplicação. O

Resultado você confere na figura a seguir :
Se observarmos a aplicação acima, é mostrado a primeira pergunta para o

nosso usuário. Vamos escolher como opção para a primeira pergunta o
“Firefox”. Em seguida, clique no botão “Ir para segunda pergunta”. Feito isso
veremos a próxima tela a seguir :
475
Se observarmos a aplicação acima, é mostrado a primeira pergunta para o

nosso usuário. Vamos escolher como opção para a primeira pergunta o
“Firefox”. Em seguida, clique no botão “Ir para segunda pergunta”. Feito isso
veremos a próxima tela a seguir :
476
Se observarmos a aplicação acima, é mostrado a segunda pergunta para o

nosso usuário. Vamos manter como opção o item “Facebook”. Em seguida,
clique no botão “Ir para terceira pergunta”. Feito isso veremos a próxima tela a
seguir :
477
Se observarmos a aplicação acima, é mostrado a terceira pergunta para o

nosso usuário. Vamos selecionar a opção o item “Skype”. Em seguida, clique
no botão “Terminar pesquisa”. Feito isso veremos a próxima tela a seguir :
478
Observe na aplicação acima que podemos ver todas as respostas de cada uma
das perguntas que nos foi feita. Agora , clique no botão “Finalizar aplicação”
para que a aplicação seja encerrada.
Entendendo a execução da nossa aplicação
Para entendermos a execução PASSO A PASSO de nossa aplicação, vamos

começar indo pela classe PesquisaOpiniaoActivity.
Na seção de declaração de atributos abaixo :
Resposta resposta;
479
Declaramos todos os objetos que irão representar todas as telas de nossa
aplicação , incluindo também um objeto chamado resposta que irá armazenar
as respostas do usuário.
Dentro do método onCreate temos o seguinte conjunto de instruções abaixo :
resposta = new Resposta();
tela_finalizacao = new TelaFinalizacao(this, resposta);

tela_pergunta3 = new TelaPergunta3(this, tela_finalizacao, resposta);
Onde carregamos todas as instâncias das classes referentes as telas da nossa

aplicação (incluindo também a instância da classe que irá armazenar a
reposta).
Observe que as classes que representam as telas da nossa aplicação foram

carregadas na ordem inversa de exibição (ou seja, comecei a carregar a
instância da classe da ultima tela (a classe TelaFinalizacao) , depois a classe
da penúltima tela (TelaPergunta3) e assim por diante). A razão pela qual isso
foi necessário é porque a instância que representa tela da pergunta corrente
sempre vai depender da instância da tela da próxima pergunta.
Na instrução a seguir :
tela_pergunta1.CarregarTela();
É responsável por carregar a tela referente a primeira pergunta pelo método

CarregarTela. Agora vamos dentro da classe TelaPergunta1 visualizar o
método CarregarTela (que foi disparado agora) :

{
btpergunta_2 = (Button) activity.findViewById(R.id.bt_pergunta2);
480
@Override
(rgropcoes_pergunta_1.getCheckedRadioButtonId());
resp.resposta1 = rbtopcaoEscolhida.getText().toString();
}
});
Dentro do método CarregaTela temos a seguinte instrução a seguir :
Que obtém o controle do objeto RadioGroup presente na tela da aplicação,

referente a primeira pergunta.
Agora dentro do método onClick referente ao botão btpergunta2 temos a

seguinte instrução abaixo :
(rgropcoes_pergunta_1.getCheckedRadioButtonId());
Olhando assim parece meio confuso, mas , irei esclarecer para você. O método
getCheckedRadioButtonId (da classe RadioGroup) retorna o nome do
componente RadioButton que foi selecionado. Por exemplo, supondo que
estamos na primeira tela e que o item selecionado tela sido “Firefox” (cujo o
nome do componente que representa esta opção seja rbtopcao2_p1), a
instrução mencionada anteriormente equivale a :
481
rbtopcaoEscolhida = (RadioButton) activity.findViewById
(R.id.rbtopcao2_p1);
Na instrução seguinte nos temos :
resp.resposta1 = rbtopcaoEscolhida.getText().toString();
Que retorna para o atributo resposta1 da classe Resposta, a opção escolhida

na tela da pergunta. Na instrução seguinte :
É carregado a tela da segunda pergunta na tela.
O código referente as classes TelaPergunta2 e TelaPergunta3 são similares a

classe citada agora. Vamos então para o código da classe TelaFinalizacao.
Dentro do método onClick da classe temos o seguinte método :
activity.finish();
Que é responsável por fechar a aplicação , já que a pesquisa já foi encerrada.
482
Capitulo 16 Publicando as
aplicações Android no Google
Play
A
té agora aprendemos a desenvolver as aplicações voltadas para a
plataforma Android utilizando o emulador oferecido pelo Android SDK.
Mas agora, como nós fazemos para publicar as nossas aplicações na
loja virtual de aplicativos do Android, o Google Play. Neste capítulo iremos
aprender passo a passo como realizar esta tarefa.
Quem aqui já pensou em desenvolver uma aplicação Android para distribui-la,

permitindo que outras pessoas possam utilizá-la (seja um utilitário, jogo e etc) ?
Pois bem, isso já permitindo utilizando um serviço, ou melhor, uma loja virtual
de aplicativos do Android, o “Google Play”. Para acessarmos o “Google Play”
basta acessarmos o seguinte link : https://play.google.com/store.
Veja o WebSite conforme é demonstrado na figura seguinte:
483
Site do “Google Play”
Neste site podemos “publicar” e distribuir nossas aplicações Android, mas ,

para que suas aplicações possam ser instaladas através deste site, você
precisa acessar o site acima através do seu Smartphone ou Tablet (caso
contrário, a aplicação não poderá ser instalada).
Para publicarmos um aplicativo no “Google Play”, devemos primeiramente ter

uma conta criada no “Google”. Caso você não tenha uma conta no Google é
preciso que você crie uma conta para tal propósito. Se você já tem uma conta
no Google, basta acessar o seguinte link para começarmos a publicar nossas
aplicações: http://developer.android.com/distribute/index.html.
Veja o conteúdo na figura seguinte:
484
Site dos desenvolvedores do Android
Depois de carregado o site acima, clique no botão “Developer Console” (que na

verdade vai redirecioná-lo para o link https://play.google.com/apps/publish/).
Caso você não esteja logado, será solicitado que você digite seu login e senha
para continuar o processo. Feito isso será aberta a seguinte tela conforme você
pode conferir na figura seguinte:
485
Android Developer Console
Para publicar nossas aplicações no “Google Play” devemos preencher os

campos informados na página acima, aceitar os termos do “Contrato de
distribuição do desenvolvedor” do “Google Play” e pagar uma taxa de
US$25,00 (aproximadamente R$50,00) através do “Google Wallet”. Feito isso
você poderá publicar suas aplicações que poderão ser distribuídas tanto de
graça quanto pagas.
486
Conclusão a respeito do
material
Pois é MEU CARO, chegamos aqui ao final da nossa “Apostila de Android :

Programando DO ZERO”. Esse material foi o nosso PONTO DE PARTIDA
inicial para o desenvolvimento de aplicações para a plataforma Google Android,
aprendemos bastante coisa com ele.
Antes de iniciarmos a programação com Android, que é o foco do material,

começamos primeiramente com alguns conceitos básicos sobre informática e
computador (incluindo também ai os dispositivos móveis), pois, sem esses
conceitos , muita coisa a gente não ia entender pela frente.
No capítulo seguinte aprendemos lógica de programação e algoritmos, que é a

base (o mais importante PRÉ-REQUISITO) fundamental para a programação
com Android, pois, sem esse aprendizado, não seríamos capazes de
desenvolver uma linha de comando que fosse . Aprendemos o que vem a ser
programação sequencial, condicional, estruturas de repetição, rotinas, vetores
e etc, que são elementos fundamentais do aprendizado sobre programação.
Em seguida, aprendemos todos os fundamentos da linguagem de programação

Java (que a linguagem de desenvolvimento padrão do Android) , e no capítulo
seguinte aprendemos a desenvolver aplicações voltadas para a plataforma
Android, através dos mais diversos exemplos abordados nesta apostila.
Para reforçar mais o aprendizado sobre a plataforma Android, recomendo

fortemente a leitura e aquisição do meu material “Apostila de Android :
Programação Básica” (Visite o site www.apostilaandroid.net), para uma
extensão e aprimoramento do seu conhecimento.
Espero que meu material lhe tenha sido útil
Um forte abraço
Luciano, o autor
487

Apostila de Android Programando DO ZERO Android Studio

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

Apostila de Android Programando DO ZERO Android Studio

Enviado por

Direitos autorais:

Formatos disponíveis

1

Aviso sobre esta apostila

Esse material NÃO PODERÁ SER DISTRIBUÍDO, em hipótese alguma, em

Esse material , em hipótese alguma, NÃO PODE SER COMERCIALIZADO

Luciano Alves da Silva é Bacharelado em Ciência da Computação pela

É autor também dos seguintes livros, pela editora AGBOOK

- Aprenda Passo a Passo a Programar em Android – Guia Essencial para

- Desenvolvendo Jogos com a Plataforma XNA 2ª Edição – Guia para

- Desenvolvendo Jogos com o Framework MONOGAME – Guia para

- Desenvolvendo Jogos 2D com Plataforma Java – Guia para

Os dispositivos móveis de hoje em dia fazem parte de nossas vidas, através

Este material irá mostrar de forma SIMPLES, CLARA, DIDÁTICA e

1.1) O que é um computador ?

Computador – Máquina que usamos no nosso dia a dia

HARDWARE : Muitos já ouviram e já sabem do que se trata este termo,

SOFTWARE : Muitos já ouviram falar e já sabem do que se trata esse

1.2) O que é um sistema operacional ?

1.3) O que é um dispositivo móvel ?

Já que tivemos a oportunidade de ver o que vem a ser um computador, o que

A linguagem binária nada mais é do que a linguagem do computador (assim

Bom, de onde vem o termo “0” e “1” da linguagem do computador ? O

Bom, com isso encerramos os fundamentos básicos da informática , que nada

No dia a dia no computador, sempre estamos utilizando aplicações

2.1) O que é algoritmo ?

Algoritmo NA INFORMÁTICA é muito mais fácil e simples de se compreender.

Por incrível que pareça o significado da palavra ALGORITMO não aplica-se

1) Você precisa se vestir

Uma observação a respeito do ALGORITMO acima : Observem que foram

1) Você precisa se vestir

Se observarmos essa nova versão do nosso algoritmo temos agora 13 passos

A resposta é : OS DOIS. Isso mesmo, as duas versões do algoritmo estão

Em ALGORITMOS não importa se você vai gastar 7 , 8, 10, 20 ou 30 passos

Agora aplicando o conceito de algoritmos NA INFORMÁTICA, ele seria um

Mais um exemplo prático dentro da realidade. Quando você dar um duplo

2.2) O que é linguagem de programação ?

Uma linguagem de programação nada mais é do que um conjunto de regras

Vejamos um exemplo clássico para demonstrar o que vem a ser linguagem de

Ele vai entender o que você disse ? COM CERTEZA NÃO!

Com certeza ele irá entender e vai responder (em alemão).

Na informática existem várias linguagens de programação que são utilizadas

2.3) O que é português estruturado (PORTUGOL) ?

Para quem vai começar a programar pela primeira vez, recomenda-se a

O PORTUGOL nada mais é do que uma linguagem de programação que utiliza

Existe diferença entre os termos “algoritmo” e “português estruturado” ?

Para começarmos nosso primeiro contato com programação com algoritmos

Depois de realizar o download basta descompactar o arquivo “.ZIP” em um

algoritmo "semnome" (1)

1) Cabeçalho de declaração : Nesta linha especificamos o nome do nosso

algoritmo <nome do programa>

2) Comentários : Se lembra que havia falado que em programação não se

3) Seção de declaração de variáveis : Veremos mais a frente.

4) Inicio : Aqui marcamos o início da execução dos comandos do nosso

5) Fim : Aqui marcamos o fim da execução dos comandos do nosso algoritmo

Com a ferramenta Visualg aberta vamos agora escrever o nosso primeiro

Antes de entrarmos em detalhes de toda a estrutura geral do código do editor

Bom, para começarmos vamos criar um pequeno algoritmo em português

E em seguida digite o seguinte comando abaixo:

Para podemos executar o comando que escrevemos basta irmos no menu

Programa em execução – Exibindo a mensagem na tela

Acabamos de dar um GRANDE PASSO. Agora vamos dar continuidade aos

Posicionando o cursor abaixo da instrução anterior

Agora vamos digitar o seguinte comando abaixo , que está destacado :

Se executarmos o programa acima (pressionando a tecla “F9”) , teremos o