Linguagem de Programação Orientada a Objetos

Prévia do material em texto

UFRA – UNIVERSIDADE FEDERAL 
RURAL DA AMAZÔNIA 
INSTITUTO CIBERESPECIAL 
 
 
 
 
 
 
 
TÉCNICAS DE PROGRAMAÇÃO EM JAVA 
 
 
 
 
Prof. D.Sc. Eng. Emerson Cordeiro Morais 
Belém-PA, Abril de 2011. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 2 
Sumário 
 
Capítulo I – Algoritmos e Linguagens de Programação ......................... 4 
1 Resolução de Problemas Computacionais ................................................................. 4 
2 Conceito Formal de Algoritmo .................................................................................. 4 
3 Linguagens de Programação ...................................................................................... 6 
4 Tipos de Linguagens .................................................................................................. 8 
5 Processos de Tradução .............................................................................................. 8 
5.1 Montadores (Assemblers) ................................................................................... 9 
5.2 Compiladores ...................................................................................................... 9 
5.3 Interpretadores .................................................................................................. 10 
5.4 Compiladores x Interpretadores ....................................................................... 11 
5.5 Processo de Tradução da linguagem Java ........................................................ 11 
Capítulo II – Conceitos Básicos de Programação .................................. 13 
1 Tipos Primitivos de Dados ...................................................................................... 13 
1.1 Tipos Numéricos .............................................................................................. 13 
1.2 Tipos Não-numéricos ....................................................................................... 13 
2 Identificadores ......................................................................................................... 14 
3 Variáveis .................................................................................................................. 14 
4 Constantes ................................................................................................................ 15 
5 Comando de Atribuição ........................................................................................... 15 
6 Entrada e Saída de Dados ........................................................................................ 16 
6.1 Comandos de Saída de Dados .......................................................................... 16 
6.2 Comandos de Entrada de Dados ....................................................................... 17 
7 Blocos e Comentários .............................................................................................. 20 
8 Operadores e Funções predefinidas ......................................................................... 20 
8.1 Operadores Aritméticos .................................................................................... 20 
8.2 Operadores Relacionais .................................................................................... 21 
8.3 Funções Matemáticas ....................................................................................... 21 
8.4 Operadores Lógicos .......................................................................................... 22 
8.5 Tabelas Verdade ............................................................................................... 22 
9 Ordem de Prioridade das Operações ....................................................................... 23 
Capítulo III – Estrutura de Controle Linear (ou de Sequência) ........... 24 
1 Estruturas de Controle ............................................................................................. 24 
2 Estrutura de Controle Linear ................................................................................... 24 
3 Reunião dos Conceitos na Formação do Primeiro Programa .................................. 25 
4 Exercícios Propostos ............................................................................................... 25 
Capítulo IV – Estrutura de Controle de Seleção ..................................... 29 
1 Conceito de Seleção ................................................................................................ 29 
2 Seleção Simples ....................................................................................................... 29 
3 Seleção Composta ................................................................................................... 30 
4 Seleção Encadeada .................................................................................................. 31 
5 Seleção de Múltipla Escolha ................................................................................... 33 
6 Exercícios Propostos ............................................................................................... 35 
Capítulo V – Estrutura de Controle de Repetição ................................... 39 
1 Conceito de Repetição ............................................................................................. 39 
2 Repetição com Variável de Controle ....................................................................... 40 
3 Repetição com Teste no Início ................................................................................ 41 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 3 
4 Repetição com Teste no Final ................................................................................. 43 
5 Exercícios Propostos ............................................................................................... 44 
Capítulo VI – Vetores e Matrizes .................................................................. 48 
1 Tipos Construídos .................................................................................................... 48 
2 Vetores ..................................................................................................................... 48 
3 Entrada, manipulação e saída de dados em Vetores ................................................ 49 
4 Matrizes Bidimensionais ......................................................................................... 51 
5 Entrada, manipulação e saída de dados em Matrizes .............................................. 52 
6 Exercícios Propostos ............................................................................................... 53 
Bibliografia ........................................................................................................ 56 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 4 
Capítulo I – Algoritmos e Linguagens de 
Programação 
 
1 Resolução de Problemas Computacionais 
Na fase de resolução do problema, será concentrada a tarefa de elaboração de um 
algoritmo para resolver um problema proposto. Somente depois da satisfação com a 
formulação de um algoritmo adequado é que se passará à implementação deste 
algoritmo em alguma linguagem de programação, o que representará a fase de 
implementação do problema. 
Dado um algoritmo suficientemente preciso, sua codificação em alguma 
linguagem de programação é direta. Nas fases anteriores descritas pode-se visualizar o 
conceito de semântica e sintaxe de programas, respectivamente. 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 1: Resolução do Problema e Programação. 
 
2 Conceito Formal de Algoritmo 
Um algoritmo computacional pode ser definido como: uma sequência finita de 
instruções bem definidas e não ambíguas, onde cada uma das quais pode serexecutada mecanicamente, num período de tempo finito e com uma quantidade de 
esforço finito (TREMBLAY & BUNT, 1983). 
Solução em 
forma de 
Algoritmo 
Solução como 
um programa 
de computador 
Problema 
Passo difícil 
Fase da 
resolução do 
problema 
Fase da 
implementação 
do problema 
Técn
Exem
 
indic
se en
Exem
9
9
9
9
9
9
Exem
9
9
9
9
9
9
9
Hanó
Exist
difer
para 
O ob
nicas de Pro
mplos Infor
Apesar d
cações dada
ncontrar ess
mplo 1: Tel
9 Retirar o
9 Aguarda
9 Colocar 
9 Discar o 
9 Falar ao 
9 Colocar 
mplo 2: Tro
9 Posicion
9 Selecion
9 Subir na
9 Retirar a
9 Colocar 
9 Descer d
9 Retirar a
Existem,
ói e Três Jes
O proble
tem três has
rentes (1-2-3
qualquer ha
bjetivo é tran
ogramação e
rmais de A
de o termo s
as para se c
a rua, por e
lefone públ
o fone do ga
ar o sinal son
o cartão no 
número de
telefone; 
o fone no g
oca de uma
nar a escada
nar uma nov
a escada; 
a lâmpada q
a nova lâmp
da escada; 
a escada. 
, inclusive, 
suítas e Trê
ema das To
stes (a-b-c),
3), os meno
aste, contan
nsferir os tr
em Java – P
Algoritmos
ser novo em
hegar a um
xemplo. 
lico a cartã
ancho; 
noro; 
local indica
sejado; 
gancho. 
a lâmpada 
a embaixo d
va lâmpada p
queimada do
pada no soq
alguns algo
ês Canibais.
orres de Han
, uma das qu
ores sobre o
nto que nunc
rês discos pa
rof. D.Sc. E
m si, o conc
ma determin
ão 
ado; 
queimada
a lâmpada q
para a subst
o soquete; 
quete; 
oritmos para
nói consiste
uais serve d
os maiores.
ca seja colo
ara outra ha
Eng. Emerso
 
ceito é certa
nada rua con
queimada; 
tituição; 
a problema
e em mover
de suporte p
 Pode-se m
ocado um di
aste. 
on Cordeiro
amente basta
nstituem um
s clássicos 
r três disco
para três dis
mover um di
isco maior s
o Morais 
ante familia
m algoritmo
como: Torr
os de uma T
scos de tama
isco de cad
sobre um m
5 
ar. As 
o para 
res de 
Torre. 
anhos 
da vez 
menor. 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 6 
Algoritmo 
 início 
 mover o disco 1 para a haste b; 
 mover o disco 2 para a haste c; 
 mover o disco 1 para a haste c; 
 mover o disco 3 para a haste b; 
 mover o disco 1 para a haste a; 
 mover o disco 2 para a haste b; 
 mover o disco 1 para a haste b; 
 fim 
Três jesuítas e três canibais precisam atravessar um rio; para tal, dispõem de um 
barco com capacidade para duas pessoas. Por medidas de segurança não se permite que 
em alguma margem a quantidade de jesuítas seja inferior à de canibais. Qual a 
sequência de passos que permitiria a travessia com segurança? 
Algoritmo 
 início 
 atravessar um jesuíta e um canibal; 
 voltar um canibal; 
 atravessar dois canibais; 
 voltar um canibal; 
 atravessar um jesuíta e um canibal; 
 voltar um canibal; 
 atravessar dois canibais; 
 voltar um canibal; 
 atravessar um jesuíta e um canibal; 
 fim 
3 Linguagens de Programação 
 Para realizar qualquer tarefa, por mais simples que seja, um computador precisa 
de instruções que o instruam como realizá-la. A maioria das máquinas opera 
representações binárias e essa não é certamente o melhor método de comunicação com 
os seres humanos. Linguagens de programação foram criadas para servir de interface 
entre o usuário e o computador, facilitando a comunicação entre uma pessoa com um 
problema e o computador que se deseja usar para resolvê-lo. 
 Uma LP (Linguagem de Programação) é uma linguagem destinada a ser usada 
por uma pessoa para expressar um processo através do qual um computador pode 
resolver um problema. Existem alguns paradigmas ou também chamados modelos, de 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 7 
linguagens de programação: Imperativo, Funcional, Lógico e Orientado a Objetos. Os 
quatro modelos de LP correspondem aos pontos de vista dos quatro componentes 
citados. A eficiência na construção e execução de programas depende da combinação 
dos quatro pontos de vista. Seguem os modelos respeitando a cronologia. 
O modelo Imperativo é baseado na perspectiva do computador. A execução 
sequencial de comandos e o uso de dados são conceitos baseados no modo como os 
computadores executam programas no nível de linguagem de máquina. As LPs 
imperativas são de fácil tradução. Um programa imperativo é equivalente a uma 
sequência de modificações de locações de memória. São exemplos de linguagens 
Imperativas: Fortran, Cobol, Ada, Perl, Basic, Pascal e C. 
O modelo Funcional focaliza o processo de resolução do problema. A visão 
funcional resulta em diversas funções que descrevem as operações que devem ser 
efetuadas para resolver o problema, inclusive adotando recursividade. Pode-se citar 
como exemplo de Linguagem Funcional: Lisp, Scheme, ML e Haskell. 
O modelo Lógico está relacionado à perspectiva da pessoa. O modelo encara o 
problema de uma perspectiva lógica através de um subconjunto do cálculo de 
predicados, levando a um processo de dedução automática. Um programa lógico é 
equivalente à descrição do problema expressa de maneira formal, similar à maneira que 
o ser humano raciocinaria sobre ele. Pode-se citar como exemplos: Prolog, Datalog e 
Mercury. 
O modelo Orientado a Objeto focaliza o problema, uma vez que a 
complexidade foi aumentada com o passar do tempo. No modelo OO a entidade 
fundamental é o objeto. Objetos trocam mensagens entre si e os problemas são 
resolvidos por objetos enviando mensagens uns para os outros. Os objetos do programa 
equivalem aos objetos da vida real. 
A primeira linguagem OO foi Smalltalk, desenvolvida em 1972, através de 
refinamentos da Linguagem Simula 67. Existem algumas linguagens híbridas: 
imperativas com características de Orientação a Objetos, como por exemplo: C++ 
(posteriormente C#), Visual Basic (posteriormente VB.NET) e Object Pascal (Delphi). 
Java já nasceu puramente Orientada a Objetos. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 8 
 
4 Tipos de Linguagens 
A linguagem de máquina é a linguagem que está intimamente ligada ao projeto 
lógico do computador. É a linguagem que ele entende desde que ele foi construído. A 
linguagem de máquina é a mais trabalhosa de todas, tem que se preocupar muito durante 
a programação, com os detalhes, o que torna esta tarefa bastante difícil. 
A linguagem simbólica foi um passo adiante na tentativa de simplificar a 
programação difícil da linguagem de máquina. A estrutura da linguagem simbólica 
ainda se mantém na linguagem de máquina, mas os códigos são substituídos por 
códigos mnemônicos, isto é, por códigos que empregam abreviações de nomes 
sugestivos que lembram a função da instrução, e os endereços e áreas de trabalho são 
mencionados por símbolos e nomes. É muito mais fácil trabalhar com codificação 
simbólica do que codificação numérica. Seguem exemplos de instruções aritméticas e a 
seguir, código equivalente em C e Assembly: 
 
A linguagem automática foi um passo decisivo na tentativa de obter uma 
linguagem bem próxima ao problema real. As estruturas destas linguagens são 
orientadas de modo que possam ser facilmente assimiladas por especialistas de várioscampos de atividades profissionais. Ex: Cobol, Pascal, Fortran, etc. 
 
5 Processos de Tradução 
Para representar mais facilmente o que se deseja, os programas não são escritos 
na linguagem que a máquina entende, mais sim em linguagens de mais alto nível. Para 
isso há necessidade de se traduzir ou converter esses programas em linguagem de 
máquina. Esse trabalho é feito automaticamente pelo próprio computador através de 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 9 
programas tradutores. A linguagem na qual o programa original é escrito é denominada 
linguagem fonte e a linguagem para a qual é convertido é denominada linguagem alvo. 
Tradutores são programas que convertem um programa de usuário escrito em 
uma linguagem para outra linguagem. Os tradutores podem ser montadores, 
compiladores ou interpretadores. 
 
5.1 Montadores (Assemblers) 
Montador é o programa que traduz programas em uma linguagem fonte 
simbólica para uma linguagem numérica de máquina. Essa tradução é a mais rápida e 
simples que existe, pois cada comando na linguagem simbólica produz exatamente uma 
instrução de máquina. A figura abaixo ilustra o fluxo básico de uma montagem, onde o 
programa escrito em linguagem fonte, chamado código fonte, é analisado e convertido 
instrução por instrução em um programa em linguagem binária de máquina, 
denominado código objeto. 
 
 
 
 
 
Figura 2: Processo de Montagem. 
 
5.2 Compiladores 
 Compiladores são programas que realizam a conversão de um programa escrito 
em linguagem de alto nível para um programa correspondente em linguagem de 
máquina. Na compilação, o programa original em linguagem fonte é analisado e 
traduzido para um programa equivalente descrito em linguagem de máquina. 
 Para um programa, que usa rotinas armazenadas em bibliotecas do compilador, 
possa ser executado, é necessário inserir no código objeto do programa os códigos já 
compilados dessas rotinas chamadas. Esse processo é feito na linkedição ou ligação e é 
realizado por um programa chamado ligador ou linkeditor. Linkeditor é um programa 
que tem como finalidade agregar rotinas (existentes em bibliotecas) referidas no 
programa objeto, mas que não estão nele incluídas. Uma vez o código executável ou 
Linguagem 
de Máquina 
Código 
Fonte 
Linguagem 
Assembly 
Código 
Objeto Montador 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 10 
módulo de carga é gerado, então o programa está pronto para ser executado pelo 
computador. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura3: Processo de Compilação. 
 
5.3 Interpretadores 
Interpretadores são programas tradutores que diferem dos compiladores porque 
não traduzem o programa fonte todo de uma vez, mas uma linha de cada vez. Cada linha 
do programa fonte é lida, traduzida para linguagem de máquina e imediatamente 
executada. 
Não é necessário gerar qualquer programa equivalente ao inicial, pois a 
interpretação se caracteriza por realizar as três fases (compilação, ligação e execução), 
comando a comando, do programa fonte. Na realidade, existe apenas um passo: 
executar uma instrução do programa fonte original. Tem a vantagem de ser um 
 
Compilador 
Código 
Fonte
Linguagem de 
Alto Nível
Código 
Objeto
Linguagem 
de Máquina
Linkeditor 
Código 
Executável
Linguagem 
de Máquina
Bibliotecas 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 11 
programa de menor tamanho e maior flexibilidade, porém tem a desvantagem de levar 
mais tempo, para executar um programa do que os compiladores, tornando-se 
ineficientes para grande quantidade de instruções ou dados. 
Não há produtos intermediários como o código objeto ou código executável, 
como acontece na compilação. Pelo método da interpretação cada comando do código 
fonte é lido pelo interpretador, é convertido em código executável e imediatamente 
executado, antes que o comando seguinte seja lido. 
 
 
 
 
 
 
 
Figura 4: Processo de Interpretação. 
 
5.4 Compiladores x Interpretadores 
A principal vantagem da interpretação sobre a compilação é sua capacidade de 
identificar e indicar um erro no programa fonte. Uma razoável desvantagem da 
interpretação é o consumo de memória, pois o código (geralmente grande) do 
interpretador deve permanecer na memória durante toda a execução, pois cada comando 
necessita do interpretador, ao contrário da compilação. 
Outra desvantagem da interpretação sobre a compilação consiste na 
possibilidade de uma mesma parte de um código fonte ter que ser interpretada tantas 
vezes quanto definidas na repetição, enquanto na compilação, isto acontece uma única 
vez. A mesma desvantagem acontece com programas que são executados 
frequentemente, pois na interpretação são convertidos toda vez que forem executados 
enquanto na compilação essa conversão acontece uma única vez. 
Há linguagens de programação cujas características estruturais são típicas de 
métodos de compilação, possuindo apenas compiladores. São exemplos deste tipo: 
Cobol, Fortran, Pascal e C. Há outras que possuem apenas interpretadores como o APL. 
 
5.5 Processo de Tradução da linguagem Java 
A linguagem de programação Java tem uma arquitetura diferente, o que fornece 
a seus programas mais portabilidade que outras linguagens de programação de alto 
Instrução 
Código 
Fonte 
Execução Interpretador 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 12 
nível. A compilação do código Java não gera código executável em algum sistema 
operacional. Em vez disso, gera um código “pseudo-executável”, chamado bytecode. 
Esse é uma espécie de código de baixo nível que não é linguagem de máquina de algum 
processador, nem faz interface específica com algum determinado sistema operacional. 
Para que esse código possa ser executado em algum (e ao mesmo tempo em 
qualquer) sistema operacional, é necessário que mais uma camada de software esteja 
instalada. A camada funciona como um sistema operacional genérico, deixando 
transparentes as particularidades do sistema operacional real. Essa camada de software 
é chamada de Máquina Java Virtual, ou Java Virtual Machine (JVM). 
A JVM faz a tradução dos bytecodes para código executável naquele sistema 
operacional. Isto faz com que um programa escrito em Java e que seja compilado para 
bytecode possa ser executado em qualquer máquina que tenha a JVM adequada 
instalada. Durante a execução, esse código será traduzido em tempo real para a 
linguagem proprietária e executado. A tradução em tempo real pode ser entendida como 
uma espécie de interpretação. Portanto, é difícil afirmar que a linguagem de 
programação Java seja uma linguagem puramente compilada ou interpretada. 
Essa característica da linguagem Java faz com que esta seja extremamente 
interessante para o uso na Internet, visto que o código Java que esteja presente em um 
site poderá ser executado em qualquer plataforma que contenha a JVM instalada. 
Normalmente, os browsers já contêm uma JVM para que possam trabalhar com sites 
que contenham programas Java. A Figura 5 apresenta as etapas necessárias para a 
execução de um programa Java. 
 
Figura 5: Processo de Tradução da Linguagem de Programação Java. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 13 
Capítulo II – Conceitos Básicos de 
Programação 
 
1 Tipos Primitivos de Dados 
Um tipo de dado primitivo corresponde ao conjunto de valores queuma 
variável, constante, expressão ou função pode assumir e o conjunto de operações que 
podem ser efetuadas sobre ele. Estes conjuntos de valores são definidos pelas 
linguagens de programação, sobre modelos matemáticos, que aproveitam as operações 
sobre estes modelos. No caso do estudo da linguagem Java será usado os tipos: 
 
1.1 Tipos Numéricos 
ƒ Inteiro: informação numérica que pertença ao conjunto dos números inteiros, sendo 
eles: positivos, negativos e o zero. Existem 4 (quatro) tipos: 
a) byte: tem capacidade de 8 bits (de -128 a 127); 
b) short: tem capacidade de 16 bits (de –32.768 a 32.767); 
c) int: tem capacidade de 32 bits (de -2.147.483.648 a 2.147.483.647); 
d) long: tem capacidade de 64 bits (de -9.223.372.036.854.775.808 a 
9.223.372.036.854.775.807); 
ƒ Real: informação numérica que pertença aos números reais, isto é, o conjunto dos 
inteiros mais os números fracionários. Existem 2 (dois) tipos: 
a) float: tem a capacidade de 32 bits (-3,4 x 10-38 a 3,4 x 1038). 
b) double: tem a capacidade de 64 bits (-1,7 x 10-308 a 1,7 x 10308). 
 
1.2 Tipos Não-numéricos 
ƒ Literal (char): informação composta por: caracteres alfanuméricos {‘0’... ‘9’}, 
{‘A’... ‘Z’}, {‘a’... ‘z’} ou especiais {‘%’, ‘&’, ‘<’, ‘+’, ‘#’, ‘®’, ‘@’, ...}. O tipo 
char tem capacidade de armazenamento de 16 bits. 
Obs1: Em Java, String é uma classe definida, não um tipo primitivo, mas é utilizado 
para armazenar cadeias de caracteres como o tipo de dado primitivo literal. 
Obs2: Em Java, os caracteres são representados entre apóstrofos (‘ ’). As cadeias de 
caracteres devem ser representadas entre aspas (“ ”). 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 14 
ƒ Lógico (boolean): informação que pode assumir apenas duas situações: true (1) ou 
false (0). O tipo boolean tem capacidade de armazenamento de 8 bits. 
 
2 Identificadores 
São os nomes das constantes, variáveis, tipos construídos e do programa e 
servem para a sua identificação no código fonte. Os identificadores devem acompanhar 
as seguintes regras de formação: 
a) Devem começar por um caractere alfabético, sublinhado (‘_’) ou cifrão (‘$’); 
b) Podem ser seguidos por mais caracteres, inclusive algarismos; 
c) Não podem utilizar caracteres especiais, exceto os citados anteriormente; 
d) Não poderá existir mais de um identificador, com o mesmo nome, no mesmo 
programa; 
e) Os nomes escolhidos não podem ser uma palavra reservada da linguagem 
Java; 
f) Os nomes escolhidos devem explicitar seus conteúdos; 
Obs: as letras podem ser maiúsculas ou minúsculas, porém a linguagem Java é Case 
Sensitive. 
 
3 Variáveis 
Uma informação é classificada como variável quando tem a possibilidade de ser 
alterada em algum instante no decorrer do programa. Em um ambiente computacional, 
as variáveis são guardadas na memória RAM. Visto que na memória existem inúmeras 
variáveis, precisa-se diferenciá-las, o que é feito através do nome da variável. 
Todo dado a ser armazenado na memória de um computador deve ser 
previamente identificado, ou seja, primeiro é necessário saber qual o seu tipo, para 
depois fazer a alocação de um espaço de memória para o seu armazenamento adequado. 
Cada variável, no entanto, pode guardar apenas uma informação de cada vez, sendo 
sempre do mesmo tipo. Os exemplos abaixo mostram como se deve declarar uma 
variável: 
float X; 
double Y,Z; 
char SEXO; 
 String NOME; 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 15 
 boolean RESPOTA; 
Alguns tipos de dados da linguagem Java têm particularidades. O tipo long deve 
ser identificado com a letra l, para não ser compactado pela linguagem em um tipo 
inteiro. A compactação ocorre como uma maneira de reduzir o uso de memória. 
Da mesma forma que tanta usar o mínimo de memória, a linguagem Java tenta 
utilizar o máximo de precisão possível. Assim, se um elemento do tipo float (7 casas de 
precisão após a vírgula) não for identificado com a letra f, a linguagem irá considerá-lo 
como um tipo double (15 casas de precisão após a vírgula), o que pode gerar vários 
erros de compilação e execução. 
int N = 4; 
long NUMERO = 456l; 
float PI = 3.14f; 
double TAMANHO = 3.873457486513793; 
 
4 Constantes 
Entende-se que uma informação é constante quando não sofre variações no 
decorrer da execução do programa. Em Java, uma constante é uma variável declarada 
com o modificador final. Modificadores são utilizados para modificar a atribuição de 
classes, variáveis ou métodos. A declaração de constantes será feita, por exemplo, da 
seguinte forma: 
final int preco = 45; 
final char resposta = ‘s’; 
final float pi = 3.1415f; 
As constantes devem ser declaradas como variáveis, cujo valor atribuído 
permanecerá inalterado ao longo do programa. Por isto, também são chamadas de 
variáveis somente leitura. 
 
5 Comando de Atribuição 
 Um comando de atribuição permite fornecer um valor a uma variável, onde o 
tipo dessa informação deve ser compatível com o tipo de variável. Este valor pode ser 
predefinido ou pode ser resultado de um processamento. Exemplos: 
 TOTAL = 34; 
 RESPOSTA = true; 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 16 
 TIMEBOM = “Clube do Remo”; 
 Uma característica das variáveis é a de que podem guardar valores diferentes em 
tempos diferentes. A habilidade de modificar os valores das variáveis é muito 
importante, e por isso, as vezes, pode-se verificar a presença de mesma variável em 
ambos os lados da linha de atribuição. Considere que esta aparição em ambos os 
membros têm significados diferentes no processamento do comando. O exemplo mostra 
a função da variável em cada um dos lados. 
 X = 1; 
 X = X + 1; 
 
 
 
 
 
6 Entrada e Saída de Dados 
Os cálculos do computador são de pouco valor a não ser que, primeiro, se possa 
fornecer os dados sobre os quais estes cálculos serão efetuados e, segundo, ver os 
resultados desses cálculos. Uma vez que as operações de entrada e saída são muito 
relacionadas à interação dos programadores, sua forma é altamente dependente da 
linguagem de programação específica. 
Todo algoritmo para computador possui comandos que levam a informação da 
memória principal do computador a seus periféricos e vice-versa. Os comandos que se 
fará uso para manusear entrada e saída de informações são mostrados a seguir. 
 
6.1 Comandos de Saída de Dados 
 O comando de saída é utilizado para mostrar dados na tela ou na impressora. É 
possível mostrar: conteúdo de qualquer variável; resultado de qualquer expressão; valor 
de qualquer constante. 
Os comandos de saída mais utilizados em Java são: System.out.println 
(mostra o seu conteúdo e passa para a linha de baixo) e System.out.print 
(mantém o cursor na mesma linha após mostrar a mensagem). Seguem alguns 
exemplos: 
Indica que um 
segundo valor 
será atribuído à 
variável X 
Indica que o 
primeiro valor 
da variável X 
será utilizado 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 17 
System.out.println(X); 
System.out.println (“Conteúdo de x =” + X); 
 
public class Primeiro { 
public static void main(String args[]){ 
 System.out.println(“Alô Mundo!”); 
} 
} 
Também podemos realizar a saída de dados utilizando elementos gráficos como 
segue no exemplo: 
import javax.swing.JOptionPane; 
public class Primeiro{ 
 public static void main(String args[]){ 
 JOptionPane.showMessageDialog(null,"Alô Mundo!"); 
 } 
} 
Outro problema encontrado na linguagem é em relação à formatação de saída de 
dados. Quando estamos trabalhando com tipos de dados reais, precisamos fazer a 
formatação desses números para definir aquantidade de casas decimais que devem ser 
mostradas. Segue exemplo utilizando o método DecimalFormat. 
DecimalFormat casas; 
casas = new DecimalFormat(“0.00”); 
System.out.println(“Média = ” + casas.format(media)); 
 Neste exemplo, a formatação permitirá que sejam mostradas duas casas decimais 
para o valor da variável media. Para utilização deste método, deve-se incluir o pacote de 
classes text, ou seja, import java.text.*; 
 
6.2 Comandos de Entrada de Dados 
O comando de entrada é utilizado para receber dados digitados pelo usuário. Os 
dados recebidos são armazenados em variáveis. Há de se ressaltar que o processo de 
associar valores às variáveis indicadas é semelhante à operação de atribuição em dois 
importantes aspectos: i) qualquer valor que a variável possua anteriormente será 
destruído; e ii) como na atribuição, é verificada a compatibilidade de tipo. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 18 
Uma das formas de entrada utilizada na Linguagem Java é por meio da classe 
Scanner, que requer a importação do pacote java.util.Scanner. Seguem alguns 
exemplos: 
int n1; 
Scanner dado; 
dado = new Scanner (System.in); 
n1 = dado.nextInt( ); 
 
float x; 
Scanner dado; 
dado = new Scanner (System.in); 
x = dado.nextFloat( ); 
 
String nome; 
Scanner dado; 
dado = new Scanner (System.in); 
nome = dado.next( ); 
 
É importante salientar que todas as entradas são recebidas pela linguagem Java 
como um conjunto de caracteres. Assim, estes caracteres deverão ser convertidos por 
funções de conversão de tipos. Seguem algumas dessas funções: 
FUNÇÃO FUNCIONALIDADE 
next( ) Aguarda uma entrada em formato String com uma única palavra. 
nextLine( ) Aguarda uma entrada em formato String com uma ou várias palavras. 
nextInt( ) Aguarda uma entrada em formato número inteiro. 
nextByte( ) Aguarda uma entrada em formato número inteiro. 
nextShort( ) Aguarda uma entrada em formato número inteiro. 
nextLong( ) Aguarda uma entrada em formato número inteiro. 
nextFloat( ) Aguarda uma entrada em formato número fracionário. 
nextDouble( ) Aguarda uma entrada em formato número fracionário. 
 
Outra possibilidade é a utilização de caixas de diálogo disponibilizadas pelo 
pacote gráfico javax.swing. Seguem exemplos: 
Um valor inteiro digitado pelo 
usuário será armazenado na 
variável n1. 
Um valor real digitado pelo 
usuário será armazenado na 
variável x. 
Um valor literal digitado pelo 
usuário será armazenado na 
variável nome. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 19 
Exemplo1: 
import javax.swing.JOptionPane; 
public class ExEntrada { 
 public static void main(String args[]){ 
 String nome; 
 nome = JOptionPane.showInputDialog("Qual o seu Nome?"); 
 JOptionPane.showMessageDialog(null, "O seu nome é " + 
nome); 
 } 
} 
Exemplo2: 
import javax.swing.JOptionPane; 
public class ExSoma{ 
 public static void main (String args []){ 
 int valor1, valor2, soma; 
 valor1 = Integer.parseInt(JOptionPane.showInputDialog 
("Qual o primeiro valor?")); 
 valor2 = Integer.parseInt(JOptionPane.showInputDialog 
("Qual o segundo valor?")); 
 soma = valor1 + valor2; 
 JOptionPane.showMessageDialog(null, "Resultado " + 
soma); 
 } 
} 
Neste caso, também existe a necessidade de funções de conversão de tipos. 
Seguem alguns exemplos: 
FUNÇÃO FUNCIONALIDADE 
Integer.parseInt( ) Converte um parâmetro literal em formato número inteiro. 
Byte.parseByte( ) Converte um parâmetro literal em formato número inteiro. 
Short.parseShort( ) Converte um parâmetro literal em formato número inteiro. 
Long.parseLong( ) Converte um parâmetro literal em formato número inteiro. 
Float.parseFloat( ) Converte um parâmetro literal em formato número real. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 20 
Double.parseDouble( ) Converte um parâmetro literal em formato número real. 
 
7 Blocos e Comentários 
 Um bloco pode ser definido como um conjunto de ações com uma função 
definida; neste caso, um algoritmo pode ser visto como um bloco. Delimita-se o bloco 
por um início ({) e um fim (}). 
{ 
 . 
 . {sequência de ações} 
 . 
} 
Comentários são textos que podem ser inseridos em programas com o objetivo 
de documentá-los. Eles são ignorados no processo de tradução. Com este objetivo, 
devemos utilizar os símbolos /* */ ou // (encerrado automaticamente no final da linha). 
 
8 Operadores e Funções predefinidas 
A Linguagem Java possui operadores e funções predefinidos destinados a 
cálculos matemáticos. Alguns são apresentados a seguir: 
 
8.1 Operadores Aritméticos 
OPERADOR OPERAÇÃO 
+ Adição 
- Subtração 
* Multiplicação 
/ Divisão* 
% Resto da divisão inteira 
++ Incremento de 1 em relação ao valor atual 
-- Decremento de 1 em relação ao valor atual 
 
* A divisão pode ser inteira ou real. Só será divisão real se ao menos um dos operandos 
for real, caso contrário será uma divisão inteira. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 21 
8.2 Operadores Relacionais 
Um operador relacional, ou simplesmente relação, é uma comparação realizada 
entre dois valores de mesmo tipo básico. 
 
OPERADOR OPERAÇÃO 
== Igual 
!= Diferente 
> Maior 
< Menor 
>= Maior ou Igual 
<= Menor ou Igual 
 
8.3 Funções Matemáticas 
Além das operações básicas anteriormente citadas, pode-se usar nas expressões 
aritméticas algumas funções da matemática, tais como: 
 
FUNÇÃO FUNCIONALIDADE 
Math.ceil(X) Arredonda o número real X para o inteiro superior 
Math.floor(X) Arredonda o número real X para o inteiro inferior 
Math.round(X) Arredonda o número real X para o inteiro mais próximo 
Math.sqrt(X) Calcula a raiz quadrada de X 
Math.cbrt(X) Calcula a raiz cúbica de X 
Math.pow(X, Y) Calcula a potenciação da base X elevada ao expoente Y 
Math.cos(X) Calcula o cosseno de X (sendo X em radianos) 
Math.sin(X) Calcula o seno de X (sendo X em radianos) 
Math.tan(X) Calcula a tangente de X (sendo X em radianos) 
Math.abs(X) Retorna o valor absoluto de X 
Math.log10(X) Obtém o logaritmo na base 10 de X 
Math.log(X) Obtém o logaritmo natural (na base e) de X 
Math.exp(X) Obtém o número e elevado ao expoente X 
Math.PI Retorna o valor de π 
Math.toDegrees(X) Converte o valor de X de radianos para graus 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 22 
Math.toRadians(X) Converte o valor de X de graus para radianos 
Math.max(X, Y) Retorna o maior dos dois valores X e Y 
Math.min(X, Y) Retorna o menor dos dois valores X e Y 
Math.random( ) Retorna um valor real aleatório >= 0 e < 1 
 
Math.signum(X) 
Retorna 0 se o argumento real X é igual a zero; retorna 1 se o 
argumento é maior do que zero; ou retorna -1 se o argumento 
é menor do que zero 
 
A linguagem Java possui muitas outras funções matemáticas que podem ser 
observadas detalhadamente na documentação da classe Math. 
 
8.4 Operadores Lógicos 
Serão utilizados três conectivos básicos para a formação de novas preposições a 
partir de outras já conhecidas. Os operadores lógicos são: 
 
OPERADOR OPERAÇÃO 
! Negação (Não) 
&& Conjunção (E) 
|| Disjunção (Ou) 
 
8.5 Tabelas Verdade 
Tabela Verdade é o conjunto de todas as possibilidades combinatórias entre os 
valores de diversas variáveis lógicas, as quais se encontram em apenas duas situações. 
8.5.1 Operação Negação 
A !A 
Verdadeiro Falso 
Falso Verdadeiro 
 
8.5.2 Operação Conjunção 
A B A && B 
Verdadeiro Verdadeiro Verdadeiro 
Verdadeiro Falso Falso 
Falso Verdadeiro Falso 
Falso Falso FalsoTécnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 23 
8.5.3 Operação Disjunção 
A B A || B 
Verdadeiro Verdadeiro Verdadeiro 
Verdadeiro Falso Verdadeiro 
Falso Verdadeiro Verdadeiro 
Falso Falso Falso 
 
9 Ordem de Prioridade das Operações 
Durante a execução de uma expressão que envolve vários operadores, é 
necessária a existência de prioridades, caso contrário poder-se-á obter valores que não 
representam o resultado esperado. É a seguinte a hierarquia que a linguagem Java segue: 
1. Operações embutidas em parênteses mais internos; 
2. Funções matemáticas; 
3. Potenciações; 
4. Multiplicações e/ou divisões; 
5. Adições e/ou subtrações; 
6. Atribuições; 
7. Operadores relacionais; 
8. Operadores lógicos de negação; 
9. Operadores lógicos de conjunção e de disjunção; 
Deve-se lembrar sempre, que na ausência de ordem de prioridade, as operações 
são realizadas da esquerda para a direita. 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 24 
Capítulo III – Estrutura de Controle 
Linear (ou de Sequência) 
 
1 Estruturas de Controle 
Na criação de programas em Java, utilizamos os conceitos de: bloco lógico, 
entrada e saída de dados, variáveis, constantes, atribuições, expressões e operadores 
lógicos, relacionais e aritméticos, bem como comandos que traduzam estes conceitos de 
forma a representar um conjunto de ações. 
Para que este conjunto de ações se torne viável, deve existir uma perfeita relação 
lógica intrínseca ao modo pelo qual as ações são executadas, ao modo pelo qual é regido 
o fluxo de execução do programa. 
Através das estruturas básicas de controle do fluxo de execução, a saber: linear, 
seleção e repetição, e da combinação delas, podemos criar programas para solucionar 
nossos problemas. 
 
2 Estrutura de Controle Linear 
A estrutura linear de um programa corresponde ao fato de que o conjunto de 
ações primitivas será executado em uma sequência de cima para baixo e da esquerda 
para a direita, isto é, na mesma ordem em que foram escritas. Nenhuma das instruções 
deixará de ser executada e cada uma dessas instruções será executada apenas uma vez. 
A seguir é ilustrado o modelo de um programa linear. 
import nome_do_pacote_das_classes; 
public class Nome_da_Classe{ 
 public static void main (String args []){ 
Instrução 1; 
 Instrução 2; 
 ... 
 Instrução n; 
 } 
} 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 25 
Convencionaremos que as ações serão seguidas por ponto-e-vírgula (;), que 
objetiva separar uma ação da outra e auxiliar a organização sequencial das ações, pois 
após encontrar um (;) deveremos executar o próximo comando da sequência. 
 
3 Reunião dos Conceitos na Formação do Primeiro Programa 
Neste momento todos os conceitos apresentados até aqui serão utilizados na 
formação do primeiro programa, apenas com o intuito de junção de idéias, que em 
princípio, estavam soltas. 
O programa deve realizar a entrada de duas notas escolares e calcular a média 
dessas notas. 
import javax.swing.JOptionPane; 
public class Media{ 
 public static void main (String args []){ 
 int valor1, valor2; 
 double media; 
 valor1 = Integer.parseInt(JOptionPane.showInputDialog 
("Qual o primeiro valor?")); 
 valor2 = Integer.parseInt(JOptionPane.showInputDialog 
("Qual o segundo valor?")); 
 media = (valor1 + valor2)/2.0f; 
 JOptionPane.showMessageDialog(null, "Resultado " + 
media); 
 } 
} 
 
4 Exercícios Propostos 
E301 – Preparar um programa que dada a entrada do cateto oposto (CO) e do cateto 
adjacente (CA), calcular a hipotenusa (HIP) de um triângulo retângulo. Sabe-se que pelo 
Teorema de Pitágoras: 
 
 
 
 222 COCAHIP += 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 26 
E302 – Calcule a área (A) e o perímetro (p) de um círculo, tendo como entrada o raio. 
Pela Geometria Euclidiana Plana, sabe-se: 
 
 
 
E303 – Desenvolver um programa para ler uma temperatura na escala Celsius (Tc), 
convertê-la e apresentá-la na escala Farenheit (Tf). Pela Termometria, sabe-se: 
 
 
 
E304 – Preparar um programa para calcular o volume de uma esfera em que o raio é um 
valor lido. Pela Geometria Euclidiana Espacial, sabe-se: 
 
 
 
E305 – Uma equação quadrática apresenta a seguinte forma: AX 2 + BX + C, sendo A, B 
e C os coeficientes quadrático, linear e angular, respectivamente, da equação de 2º grau. 
Realizar a entrada dos três coeficientes, calcular e imprimir na tela o discriminante (Δ) 
da equação quadrática. Sabe-se que: 
 
 
E306 – Calcular a área de um triângulo, utilizando a fórmula de Heron (Matemático 
Grego Herão de Alexandria), dada abaixo. A entrada será composta pelos três lados 
válidos de um triângulo (L1, L2 e L3). A fórmula utiliza o conceito de semiperímetro 
(s), também dado abaixo. 
 
 
 
E307 – Ler dois valores para as variáveis A e B, e efetuar a troca dos valores de forma 
que a variável A passe a possuir o valor da variável B e a variável B passe a possuir o 
valor da variável A. Ao final da troca mostrar na tela os seus novos valores. 
E308 – Uma família deseja realizar uma viagem de férias e precisa calcular: a 
quantidade de litros de combustível que será utilizada e o valor total gasto com 
 2RA ⋅= π e R2p ⋅⋅= π 
 32
5
Tc9Tf +⋅= 
3
R4V
3⋅⋅= π 
CA4B 2 ⋅⋅−=Δ
2
3L2L1Ls ++= e )3Ls()2Ls()1Ls(sA −⋅−⋅−⋅= 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 27 
combustível. Sabe-se que o automóvel possui um desempenho capaz de realizar 12 
quilômetros com um litro de combustível. Como entradas, serão informados: o tempo 
total de viagem e a velocidade média impressa durante a mesma. Sabe-se que o litro da 
gasolina custa R$ 2,93. Pela Cinemática, sabe-se: 
 
 
 
E309 – Efetuar o cálculo e a apresentação do valor de uma prestação em atraso, 
utilizando a fórmula abaixo descrita. Dados informados pelo usuário: o valor principal 
da prestação, a taxa de juros que será aplicada (em porcentagem) e o tempo de atraso 
(em dias). 
 
 
 
E310 – Construir um algoritmo que efetue o cálculo do salário líquido de um professor. 
Para resolver este problema, deve-se realizar a entrada de alguns dados, tais como: 
nome do professor, valor da hora-aula, número de horas trabalhadas no mês, percentual 
de desconto do imposto de renda e valor do desconto de INSS. Em primeiro lugar, deve-
se calcular o salário bruto, multiplicando as horas trabalhadas pelo valor da hora aula. 
Depois, devemos aplicar o percentual de desconto de Imposto de Renda sobre este 
salário bruto para gerar um salário com desconto aplicado. Após este passo, deve-se 
calcular o salário líquido subtraindo este último do valor do desconto do INSS. Como 
saída de dados, deve-se emitir o nome do professor juntamente com o seu salário bruto e 
líquido. 
E311 – Desenvolver um programa que realize a entrada das abscissas e ordenadas de 
dois pontos quaisquer A(x1, y1) e B(x2, y2) e calcule a distância entre estes pontos. 
 
 
E312 – Levando em consideração Progressões Aritméticas e Geométricas, desenvolver 
um algoritmo no qual o usuário informe: o primeiro termo a1, a razão q e a posição do 
termo a ser encontrado n. O algoritmo deverá devolver o n-ésimo (an) termo em ambas 
as séries. 
 
dT
dSVm
→
→ = 
100
TEMPOSTAXADEJUROVALORVALORPRESTAÇÃO ××+= 
( ) ( )212212 yyxxDIST −+−= 
)1(
Aritmética Progressão
1 −⋅+= nqaan 11
Geométrica Progressão
−⋅= nn qaa
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 28 
E313 – O custo ao consumidor de umcarro novo é a soma do preço de fábrica com o 
percentual de lucro do distribuidor e dos impostos aplicados ao preço de fábrica. Faça 
um programa que receba o preço de fábrica de um veículo, o percentual de lucro do 
distribuídos e o percentual de impostos, calcule e mostre: 
a) O valor correspondente ao lucro do distribuidor; 
b) O valor correspondente aos impostos; 
c) O preço final do veículo. 
E314 – Construa um algoritmo que calcule a quantidade de latas de tinta e o custo de 
uma obra de pintura interna em um tanque cilíndrico sem tampa, onde são fornecidos a 
altura e o raio desse cilindro. Sabe-se que: 
a) A lata de tinta custa R$ 50,00; 
b) Cada lata contém 5 litros; 
c) Cada litro de tinta pinta 3 metros quadrados. 
E315 – Informar o valor de N notas escolares (três, por exemplo: X1, X2 e X3) e calcular 
o desvio padrão do conjunto. 
 
 
 
 
 
 
 
 
 
 
 
 
 
⎥⎥⎦
⎤
⎢⎢⎣
⎡ ⎟⎠
⎞⎜⎝
⎛⋅−⋅−= ∑ ∑= =
N
i
N
i
ii XN
X
N
dp
1
2
1
2 1
1
1 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 29 
Capítulo IV – Estrutura de Controle de 
Seleção 
 
1 Conceito de Seleção 
 Apesar de se conseguir solucionar problemas e transformá-los em programas, os 
recursos da estrutura linear são muito limitados, pois haverá momentos em que um 
determinado valor dentro de um programa necessitará ser tratado para se efetuar um 
processamento mais adequado. 
 Uma estrutura de seleção permite a escolha de um grupo de ações e estruturas a 
ser executado quando determinadas condições, representadas por expressões lógicas, 
são ou não satisfeitas. Desta forma, conseguimos aplicar desvios condicionais aos 
programas capacitando-os a executar ou não um conjunto de instruções. 
 
2 Seleção Simples 
 
Sintaxe da estrutura: 
 
if (condição){ 
 Instrução 1; 
 Instrução 2; 
 ... 
 Instrução n; 
}//fim do if 
 
<condição> é uma expressão lógica, que quando verificada, pode gerar um 
resultado falso ou verdadeiro. Se <condição> for verdadeira, então o “bloco verdade” 
será executado; caso contrário (<condição> for falsa) o comando será encerrado. 
 Verificar-se-á, agora, o seguinte exemplo, para se analisar a estrutura de seleção 
simples: 
 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 30 
import javax.swing.JOptionPane; 
public class Notas1{ 
 public static void main (String args []){ 
 float nota1, nota2; 
 double media; 
 nota1 = Float.parseFloat(JOptionPane.showInputDialog 
("Qual a primeira nota?")); 
 nota2 = Float.parseFloat (JOptionPane.showInputDialog 
("Qual a segunda nota?")); 
 media = (nota1 + nota2)/2; 
 if (media >= 5.0f){ 
 JOptionPane.showMessageDialog(null, "Você está 
aprovado”); 
 } 
 } 
} 
 
3 Seleção Composta 
 
Sintaxe de estrutura: 
 
if (condição){ 
 Instrução 1; 
 Instrução 2; 
 ... 
 Instrução n1; 
}//fim do if 
else{ 
Instrução 1; 
 Instrução 2; 
 ... 
 Instrução n2; 
}//fim do else 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 31 
 Se a <condição> for satisfeita, então apenas o “bloco verdade” será 
executado, caso contrário, somente o “bloco falsidade” é o que será executado. Segue 
uma melhoria do programa anterior, levando em consideração duas possibilidades: 
aprovado ou reprovado. 
 
import javax.swing.JOptionPane; 
public class Notas2{ 
 public static void main (String args []){ 
 float nota1, nota2; 
 double media; 
 nota1 = Float.parseFloat(JOptionPane.showInputDialog 
("Qual a primeira nota?")); 
 nota2 = Float.parseFloat (JOptionPane.showInputDialog 
("Qual a segunda nota?")); 
 media = (nota1 + nota2)/2; 
 if (media >= 5.0f){ 
 JOptionPane.showMessageDialog(null, "Você está 
aprovado”); 
 } 
 else { 
 JOptionPane.showMessageDialog(null, "Você está 
reprovado”); 
 } 
 } 
} 
 
4 Seleção Encadeada 
 Podemos agrupar várias alternativas a fim de inspecionar uma ou mais 
condições. Geralmente tal estrutura é formada quando uma determinada instrução ou 
bloco de ações deve ser executado se um conjunto de possibilidades ou combinações de 
situações for satisfeito. 
 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 32 
Sintaxe da estrutura: 
 
if (condição 1){ 
 Instrução 1; 
}//fim do if 
else if (condição 2){ 
Instrução 2; 
 Instrução 3; 
 Instrução 4; 
}//fim do if 
else if (condição 3){ 
Instrução 5; 
}//fim do if 
else{ 
Instrução 6; 
}//fim do senão 
 
 Se <condição 1> for satisfeita, então a instrução 1 será executada, caso 
contrário, a <condição 2> será inspecionada e se for satisfeita, então o bloco de 
ações (instrução 2, instrução 3, instrução 4) será executado, caso contrário a 
<condição 3> será verificada e se for satisfeita, a instrução 5 será executada, caso 
contrário a instrução 6 é que será executada. Segue uma melhoria do programa anterior, 
levando em consideração três possibilidades: aprovado, reprovado ou recuperação. 
 
import javax.swing.JOptionPane; 
public class Notas3{ 
 public static void main (String args []){ 
 float nota1, nota2; 
 double media; 
 nota1 = Float.parseFloat(JOptionPane.showInputDialog 
("Qual a primeira nota?")); 
 nota2 = Float.parseFloat (JOptionPane.showInputDialog 
("Qual a segunda nota?")); 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 33 
 media = (nota1 + nota2)/2; 
 if (media >= 8.0f){ 
 JOptionPane.showMessageDialog(null, "Você está 
aprovado direto”); 
 } 
 else if (media >= 4.0f){ 
 JOptionPane.showMessageDialog(null, "Você 
está de recuperação”); 
} 
else{ 
 JOptionPane.showMessageDialog(null, "Você 
está reprovado”); 
 } 
 } 
} 
 
5 Seleção de Múltipla Escolha 
 Quando uma única variável pode assumir diversos valores e que as instruções a 
serem executadas dependam do valor armazenado nesta variável, pode-se usar a 
estrutura de seleção de múltipla escolha. Estas situações são classificadas como 
mutuamente exclusivas, isto é, se uma situação for executada, as demais não serão. 
Seria uma forma mais compacta da Seleção encadeada. 
 
Sintaxe da estrutura: 
 
switch (variável){ 
case valor 1: lista de comandos; 
 break; 
case valor 2: lista de comandos; 
 break; 
... 
default: lista de comandos; 
} 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 34 
Exemplo: Construa um programa que, tendo como dados de entrada o custo de 
produção de um produto e um código de origem, emita o preço final ao consumidor, 
levando em consideração os custos de impostos. Código de Região de Origem: 
1- Sul (20%) 
2- Norte (21%) 
3- Sudeste (15%) 
4- Centro-Oeste (23%) 
5- Nordeste (19%) 
 
import javax.swing.JOptionPane; 
public class PrecoFinal{ 
 public static void main (String args []){ 
 int regiao; 
 float valor; 
 valor = Float.parseFloat(JOptionPane.showInputDialog 
("Informe o valor de custo do produto?")); 
 regiao = Integer.parseInt (JOptionPane.showInputDialog 
("1-Sul\n2-Norte\n3-Sudeste\n4-Centro-Oeste\n5-Nordeste\n 
Informe a região:")); 
 switch(regiao){ 
 case 1: 
 JOptionPane.showMessageDialog(null, "Preço do 
Produto na Região Sul = R$” + (valor*1.21)); 
 break; 
 case 2: 
 JOptionPane.showMessageDialog(null, "Preço do 
Produto na Região Norte = R$” + (valor*1.20)); 
 break; 
 case 3: 
 JOptionPane.showMessageDialog(null, "Preço do 
Produto na Região Sudeste = R$” + (valor*1.15)); 
 break; 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 35case 4: 
 JOptionPane.showMessageDialog(null, "Preço do 
Produto na Região Centro-Oeste = R$” + (valor*1.23)); 
 break; 
 case 5: 
 JOptionPane.showMessageDialog(null, "Preço do 
Produto na Região Nordeste = R$” + (valor*1.19)); 
 break; 
 default: JOptionPane.showMessageDialog(null, "Região 
Inválida!!! Entre Novamente!!!”); 
 } 
 } 
} 
 
6 Exercícios Propostos 
E401 – Desenvolver um programa que realize a entrada do raio de uma esfera. Deve-se 
realizar tratamento de exceção sobre a entrada. Isto é, se o raio for válido (maior do que 
zero), deve-se calcular e apresentar na tela o volume da esfera, caso contrário, o cálculo 
não será realizado e apenas uma mensagem de erro será exibida ao usuário. Sabe-se 
que: 
 
 
 
E402 – Preparar um programa para realizar a entrada dos três coeficientes de uma 
equação quadrática, a saber: A, B e C; e calcular e imprimir as raízes da equação 
quadrática: X1 e X2, se as mesmas forem reais. Caso sejam imaginárias, apresentar 
mensagem de erro na tela. Sabe-se que: 
 
 
 
E403 – O Greenpeace deseja desenvolver um programa para controlar o índice de 
poluição das cidades. Para isto, guarda duas listas (A e B) de empresas que contribuem 
para o aumento da poluição. Mensalmente, é medido in loco, o índice de poluição (varia 
A2
Bx1
Δ+−= e 
A2
Bx2
Δ−−= 
3
R4V
3⋅⋅= π 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 36 
obrigatoriamente entre 0 e 1) que será a entrada única do programa e o mesmo deverá 
emitir as seguintes mensagens: 
“Tudo normal!”, caso o índice fique entre 0,00 e 0,30; 
“Fechar as empresas da lista A!”, caso o índice ultrapasse 0,30; 
“Fechar as empresas da lista A e B!”, caso o índice ultrapasse 0,40; 
“Evacuar a cidade! Socorro!”, caso o índice ultrapasse 0,50. 
E404 – Elaborar um programa para ler três números inteiros A, B e C. Caso existam 
números iguais, uma mensagem de erro para o usuário deve ser emitida. Caso contrário, 
encontrar o maior, o menor e o médio elemento entre eles. 
E405 – Desenvolver um programa para dada a entrada de três lados de um triângulo (A, 
B e C), primeiramente verificar a sua possível formação, lembrando que cada lado deve 
ser inferior a soma dos outros dois lados. Em caso afirmativo de formação, classificar o 
triângulo em: equilátero, isósceles ou escaleno. 
E406 – Tendo como dados de entrada a altura e o sexo de uma pessoa, construa um 
programa que calcule e escreva o seu peso ideal, utilizando as seguintes fórmulas: 
 Para homens: (72,7 x H) - 58 
 Para mulheres: (62,1 x H) - 44,7, sendo H a altura lida. 
E407 – Elabore um programa que, dada a idade do nadador, classifique-os em uma das 
seguintes categorias, sendo que qualquer outra idade deve ser tratada como exceção: 
 infantil A: 4 a 7 anos 
 infantil B: 8 a 10 anos 
 juvenil A: 11 a 13 anos 
 juvenil B: 14 a 17 anos 
 profissional: 18 a 39 anos 
sênior: 40 a 99 anos 
E408 – Escreva um programa que converta notas quantitativas em notas qualitativas de 
acordo com a tabela abaixo: 
Nota Quantitativa Nota Qualitativa 
0 a 2 Sem rendimento 
>2 a 4 Mau 
>4 a 6 Regular 
>6 a 8 Bom 
>8 a 10 Excelente 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 37 
E409 – Escreva um programa cuja saída seja o número de dias em um mês, usando 
como entrada o número do mês (1 a 12) e o ano, se necessário. O programa deve tratar 
corretamente os anos bissextos. 
E410 – Um sebo está fazendo uma promoção para pagamento à vista em que o 
comprador pode escolher dois critérios de pagamento: 
Critério A: R$ 2,50 por livro + R$ 75,00 de taxa fixa. 
Critério B: R$ 5,00 por livro + R$ 25,00 de taxa fixa. 
Faça um programa em que o usuário digite a quantidade de livros que deseja comprar e 
o programa diga qual é a melhor opção de compra. 
E411 – Faça um programa que receba o código correspondente ao cargo de um 
funcionário e seu salário atual e mostre o cargo, o valor do aumento e seu novo salário. 
Os cargos estão na tabela abaixo: 
Código Cargo Percentual 
1 Escriturário 50% 
2 Secretário 35% 
3 Caixa 20% 
4 Gerente 10% 
5 Diretor Não tem aumento 
 
E412 – Um endocrinologista deseja controlar a saúde de seus pacientes, e para isso, se 
utiliza o índice de massa corporal (IMC). Sabendo que o IMC é calculado através da 
fórmula IMC = peso/altura2, crie um algoritmo que apresente o nome do paciente e a 
faixa de risco, baseado na seguinte tabela: 
IMC Faixa de Risco 
Abaixo dos 20 Abaixo do peso 
A partir dos 20 até 25 Normal 
A partir dos 25 até 35 Excesso de peso 
A partir dos 35 até 50 Obesidade 
A partir dos 50 Obesidade Mórbida 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 38 
E413 – Um comerciante calcula o valor de venda, tendo em vista a tabela abaixo. Crie 
um algoritmo que entre com o valor da compra e o nome do produto. O programa 
deverá imprimir o nome do produto e o valor da venda. 
 
Valor da compra Valor da Venda 
Valor < 10,00 Lucro de 70% 
 10,00 <= Valor < 20,00 Lucro de 60% 
 20,00 <= Valor <= 40,00 Lucro de 50% 
Valor > R$ 40,00 Lucro de 30% 
 
E414 – Escreva um programa que leia um peso (massa) no planeta Terra e o número de 
um planeta e imprima o valor do seu peso (massa relativa) neste planeta. A relação de 
planetas é dada a seguir, juntamente com o valor das gravidades nos referidos planetas. 
# Gravidade local Planeta 
1 3,78 Mercúrio
2 8,60 Vênus 
3 3,72 Marte 
4 22,90 Júpiter 
5 9,05 Saturno 
6 7,77 Urano 
7 11,00 Netuno 
8 0,30 Plutão 
Para calcular o peso no planeta use a fórmula: 
 
 
 
E415 – Desenvolver um programa que simule um empréstimo em um banco. Como 
entradas serão necessários: valor a ser emprestado (P), tempo de empréstimo em meses 
(n), taxa de juros ao mês em porcentagem (i) e se o modelo é juros simples ou juros 
compostos. As saídas deverão ser em R$: o montante a ser pago (S) e o valor das 
parcelas (V). 
 
 
81,9
planeta
terraplaneta
g
PP ⋅= 
n
SV
niPS
=
⎟⎠
⎞⎜⎝
⎛ ⋅+⋅=
100
1
Simples Juros 
 
n
SV
iPS
n
=
⎟⎠
⎞⎜⎝
⎛ +⋅=
100
1
Compostos Juros
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 39 
Capítulo V – Estrutura de Controle de 
Repetição 
 
1 Conceito de Repetição 
 Na estrutura linear sabemos que os comandos são executados uma única vez e 
um após o outro (de cima para baixo). Com o estudo da seleção, acrescenta-se a 
possibilidade de escolher instruções a serem executadas, mas cada instrução continua 
sendo executada apenas uma vez, no máximo. Em programação é frequentemente 
necessário repetir a execução de um grupo de instruções, ou mesmo repetir a execução 
de todo o programa, para diferentes valores de dados. 
 
 Figura 6: “Boa” aplicação do conceito de repetição. 
 
Em programação, uma sequência de instruções executada repetidas vezes é 
chamada de laço (ou loop). Um laço é constituído por uma sequência de instruções, o 
corpo do laço, e por uma estrutura que controla a repetição deste corpo, especificando 
quantas vezes ele terá de ser repetido. 
 As instruções que constituem o corpo de um laço podem ser executadas qualquer 
número de vezes (até mesmo nenhuma), mas este número é finito. Existem erros 
semânticos que podem provocar a execução interminável do corpo do laço, caso que se 
diz que o laço é infinito. 
 Existem três estruturas que permitem a especificação de laços em linguagem 
Java: for, while e do while. 
Os laços de repetição podem ser classificados em laços determinados ou laços 
indeterminados. Os laços determinados são aqueles na qual podemos definirquantas 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 40 
vezes o corpo do laço irá se repetir antes da execução. Nos laços indeterminados isto 
não é possível, pois o número de repetições irá depender da entrada do usuário. 
 
2 Repetição com Variável de Controle 
A estrutura de repetição com variável de controle repete a execução do bloco um 
número fixo de vezes através da manipulação de uma variável do tipo inteira, pois ela 
possui limites fixos. O número de repetições do bloco será determinado por: valor 
inicial da variável, condição de parada e valor do incremento ou decremento. 
 Na estrutura for, usar-se-á o conceito de variável de controle, que será uma 
variável v que será incrementada ou decrementada após a repetição de um bloco de 
acordo com o valor deste incremento. 
 
Sintaxe da estrutura: 
 
for(v = vi; v <= vf; v++){ 
 instrução 1; 
 instrução 2; 
instrução 3; 
 ... 
instrução n; 
} 
Onde: 
Vi: valor inicial; e Vf: valor final 
 
A estrutura Para só aceita repetições determinadas e nestes casos será a estrutura 
mais conveniente. Usar-se-á o exemplo da soma dos 100 primeiros números inteiros e 
positivos. 
 
import javax.swing.JOptionPane; 
public class Soma100_1{ 
 public static void main (String args []){ 
 int numero,soma; 
 soma = 0; 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 41 
 for (numero=1; numero<=100; numero++){ 
 soma = soma + numero; 
 } 
 JOptionPane.showMessageDialog(null, "Soma = ”+soma); 
 } 
} 
3 Repetição com Teste no Início 
 Consiste numa estrutura de controle de fluxo que permite executar de forma 
repetitiva uma instrução (ou bloco de instruções) enquanto uma determinada expressão 
lógica tiver o valor verdadeiro, porém, sempre verificando antes de cada execução se é 
permitido repetir o mesmo trecho. 
 
Sintaxe da estrutura: 
 
while (condição){ 
 instrução 1; 
 instrução 2; 
instrução 3; 
 ... 
instrução n; 
} 
 
Enquanto a condição for satisfeita, as instruções de 1 a n serão repetidas, caso 
contrário, o comando é abandonado (sai do laço). Se já da primeira vez o resultado for 
falso, os comandos serão executados nenhuma vez. 
 A estrutura de repetição com teste no final while pode ser usada para construir 
laços determinados ou indeterminados. Seguem alguns exemplos de como estes tipos de 
laços funcionam: 
 
Exemplo para laços determinados: Construir um programa para calcular a soma dos 
100 primeiros números inteiros e positivos. 
 
import javax.swing.JOptionPane; 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 42 
public class Soma100_2{ 
 public static void main (String args []){ 
 int numero = 1, soma = 0; 
 while (numero <= 100){ 
 soma = soma + numero; 
 numero = numero + 1; 
 } 
 JOptionPane.showMessageDialog(null, “Soma” = +soma); 
 } 
} 
 
Exemplo para laços indeterminados (uso de finalizadores ou flags): Construir um 
programa que, dado um conjunto de valores inteiros positivos, determinar o maior valor 
do conjunto. O valor 0 (zero) é usado como finalizador do conjunto de entrada. 
import javax.swing.JOptionPane; 
public class MaiorElemento_1{ 
 public static void main (String args []){ 
 int valor, maior; 
 valor = -1; 
 maior = 0; 
 while (valor != 0){ 
 if (valor > maior) { maior = valor; } 
 valor = Integer.parseInt(JOptionPane.showInputDialog 
(“Informe um novo valor (0 para sair):”)); 
 } // fim do laço 
 if (maior == 0){ 
JOptionPane.showMessageDialog(null, "Não foram 
entrados valores válidos”); 
 } 
 else{ 
 JOptionPane.showMessageDialog(null, "Maior = ”+maior); 
 } 
} 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 43 
4 Repetição com Teste no Final 
 Consiste numa estrutura que permite que um bloco ou uma ação primitiva seja 
repetida até que uma determinada condição não seja satisfeita. Tem a mesma finalidade 
do comando while. Porém, a diferença básica entre as estruturas while e do while é que 
nesta última, o bloco é executado pelo menos uma vez independentemente da validade 
da condição, pois a inspeção da condição só é feita após a execução do bloco ou ação 
primitiva. 
Da mesma forma que a estrutura while, a estrutura do while também serve para 
construir laços determinados e indeterminados. Far-se-á os mesmos exemplos para 
podermos comparar as duas estruturas. 
Sintaxe da estrutura: 
do{ 
 instrução 1; 
 instrução 2; 
instrução 3; 
 ... 
instrução n; 
} while (condição); 
 
Exemplo para laços determinados: Construir um programa para calcular a soma dos 
100 primeiros números inteiros e positivos. 
import javax.swing.JOptionPane; 
public class Soma100_3{ 
 public static void main (String args []){ 
 int numero = 1, soma = 0; 
 do{ 
 soma = soma + numero; 
numero = numero + 1; 
 } while (numero <= 100); 
 JOptionPane.showMessageDialog(null, “Soma = ”+soma); 
 } 
} 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 44 
Exemplo para laços indeterminados (uso de finalizadores ou flags): Construir um 
programa que, dado um conjunto de valores inteiros positivos, determinar o maior valor 
do conjunto. O valor 0 (zero) é usado como finalizador do conjunto de entrada. 
import javax.swing.JOptionPane; 
public class MaiorElemento_2{ 
 public static void main (String args []){ 
 int valor, maior; 
 valor = -1; 
 maior = 0; 
 
 
 do{ 
 if (valor > maior) { maior = valor; } 
 valor = Integer.parseInt(JOptionPane.showInputDialog 
(“Informe um novo valor (0 para sair):”)); 
 } while (valor != 0); // fim do laço 
 if (maior == 0){ 
JOptionPane.showMessageDialog(null, "Não foram 
entrados valores válidos”); 
 } 
 else{ 
 JOptionPane.showMessageDialog(null, "Maior = ”+maior); 
 } 
} 
 
5 Exercícios Propostos 
E501 – Preparar um algoritmo para ler 15 números inteiros e verificar quantos deles são 
pares. 
E502 – Sendo H = 1 + 1/2 + 1/3 +...+ 1/(N – 1) + 1/N, prepare um algoritmo para gerar 
o número H, onde o número N é fornecido pelo usuário. 
E503 – Escrever um programa que imprima a soma dos inteiros ímpares de 1 até N, 
onde N deve ser fornecido como entrada e testado para ser um número ímpar maior que 
1. 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 45 
E504 – Para dado um valor N, inteiro, calcular o fatorial de N. Sabe-se que por 
definição: 0! = 1 e não existe fatorial de número negativo. 
 
 
E505 – Preparar um programa que informe 50 notas escolares do tipo real de uma turma 
e calcule a média desta turma. Porém, o programa tem que fazer tratamento máximo de 
exceção da entrada, isto é, cada vez que o usuário digitar uma nota menor que zero ou 
maior do que dez, esta nota deve ser desconsiderada e a mesma nota deverá ser 
solicitada novamente. 
E506 – Calcular a soma dos 50 primeiros termos da série: 
 
 
E507 – O matemático Fibonacci em 1202 formulou e resolveu o problema de 
reprodução de coelhos através da sequência: 1, 1, 2, 3, 5, 8, 13, 21, 34,... Percebemos a 
seguinte relação de recorrência: an+1 = an-1 + an. Escreva um algoritmo que gere a 
impressão da série de Fibonacci até o trigésimo termo. 
E508 – Escreva um algoritmo para ler um conjunto de fichas, contendo cada uma a 
altura e o código do sexo de uma pessoa (1 = masculino e 2 = feminino), calcule e 
escreva: a maior altura entre as mulheres e a média de altura entre os homens. A última 
ficha contém o código do sexo = 3, que não deve ser considerada. 
E509 – Escrever um programa que calculea seguinte soma: 
 
 
 
E510 – O valor aproximado de pi pode ser calculado usando a série abaixo até o 
vigésimo termo: 
 
 
 
 
E511 – Fazer um programa que dada a entrada do expoente x, calcule o valor de ex 
através da série até o décimo termo: 
 
( ) ( ) 12...21! ⋅⋅⋅−⋅−⋅= NNNN 
...
9
4
7
3
5
2
3
1 +−+−=S 
1
2...
48
2
49
2
50
2 50321 +++ 
3
33333
32 
...
9
1
7
1
5
1
3
1
1
1
×=
−+−+−=
S
S
π
 
...
!3!2!1
321
0 xxxxe x +++= 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 46 
E512 – Uma empresa de energia elétrica está interessada em um relatório contendo: 
• A média da quantidade de energia gasta por todos os consumidores residenciais, 
comerciais e industriais, separadamente; e 
• O código do assinante que consumiu a maior quantidade de energia residencial; 
 Para isto é feita a leitura de fichas contendo: código do assinante, quantidade de 
energia e a categoria (1 = residencial, 2 = comercial e 3 = industrial). O final do 
conjunto de assinantes é dado por um código de assinante igual a 0 (zero). 
E513 – Um número primo é aquele que somente é divisível por ele mesmo e pela 
unidade. Desenvolver um programa que dada a entrada de um número, informar se ele é 
primo ou não. 
E514 – Faça um programa que receba o valor de um carro e mostre uma tabela com os 
seguintes dados: preço final, quantidade de parcelas e o valor da parcela. Considere o 
seguinte: 
• O preço final para compra à vista tem desconto de 10%; 
• A quantidade de parcelas e os percentuais e acréscimo encontram-se no quadro a 
seguir: 
Quantidade 
de Parcelas 
Percentual de 
Acréscimo 
6 3% 
12 6% 
18 9% 
24 12% 
30 15% 
36 18% 
42 21% 
48 24% 
54 27% 
60 30% 
 
E515 – Uma empresa de telefonia deseja calcular as contas telefônicas de seus 
assinantes. A cobrança de seus serviços é feita da seguinte maneira: 
a) Tarifa básica: 
• Telefone residencial (código 1): R$ 20,00 
• Telefone comercial (código 2): R$ 70,00 
b) Serviço de telefonia: 
• R$ 1,20 por minuto excedente (acima de 90 minutos). 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 47 
c) Serviço de internet: 
• R$ 5,00 por dia. 
Na entrada de dados teremos: 
• Código do assinante; 
• Tipo do telefone (comercial ou residencial); 
• Número de minutos registrados e número de dias de uso da Internet. 
Faça um programa que leia os dados de um conjunto de assinantes (o código do 
assinante igual a zero encerra a entrada de dados), calcule e imprima: 
• Para cada assinante, o total de sua conta; 
• Valor da maior conta e o código do assinante que a pagou; 
• Valor médio arrecadado por assinante no mês. 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 48 
Capítulo VI – Vetores e Matrizes 
 
1 Tipos Construídos 
 Retornando ao conceito de tipos de dados, podemos notar que foi feita uma 
divisão, a fim de tornar mais simples a classificação das informações. Podemos 
perceber, também, que a quantidade de tipos de dados estipulados (tipos primitivos) não 
é suficiente para representar toda e qualquer informação que possa surgir. Como estes 
recursos de representação são escassos, poderíamos resolver o problema se existissem 
mais tipos de dados ou, ainda melhor, se esses tipos pudessem ser “construídos”, à 
medida que se fizessem necessários. 
 A partir de agora, apresentar-se-á uma técnica de programação que permitirá 
trabalhar com o agrupamento de várias informações dentro de uma mesma variável. 
Vale salientar que este agrupamento ocorrerá obedecendo sempre ao mesmo tipo de 
dado, isto é, cria-se um novo dado que é homogêneo. 
 
2 Vetores 
 Um vetor é uma coleção de variáveis de um mesmo tipo que compartilham o 
mesmo nome e que ocupam posições consecutivas de memória. Cada variável da 
coleção denomina-se elemento e é identificada por um índice. 
 
 
 Figura 7: Representação de um vetor. 
 
Sua utilização mais comum está vinculada à criação de tabelas. Caracteriza-se 
por ser definida uma única variável dimensionada com um determinado tamanho. A 
dimensão de um vetor é constituída por constantes inteiras e positivas. Os nomes dados 
aos vetores seguem as mesmas regras de nomes utilizados em variáveis simples. A 
sintaxe para a declaração de um vetor é: 
 
Sintaxe da estrutura: 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 49 
<tipo> <identificador>[]; ou 
<tipo>[] <identificador>; 
 
 Algumas linguagens permitem determinar o primeiro índice do vetor. Em Java, 
porém, o primeiro índice é sempre 0 (zero). Assim, um vetor com tamanho n tem 
índices que variam de 0 a n–1. 
Em Java, os vetores são objetos, permitindo o uso de atributos (propriedades) e a 
aplicação de métodos. Com isso, além da declaração, é necessário criar esse objeto na 
memória, determinando seu tamanho, para poder utilizá-lo (n). Essa criação pode ser 
feita utilizando-se o operador new. 
 
<tipo> <identificador>[] = new <tipo_primitivo>[n]; ou 
<tipo>[] <identificador> = new <tipo_primitivo>[n]; 
 
Em orientação a objetos a criação de um objeto é chamada instanciação. O 
operador new associado ao nome da classe chama o método construtor dessa classe, 
responsável pela inicialização de um novo objeto e sua alocação na memória. Todo tipo 
primitivo de dados possui uma classe empacotadora de tipo correspondente, no pacote 
Java.lang. 
 
3 Entrada, manipulação e saída de dados em Vetores 
Uma variável simples somente pode conter um valor por vez. No caso dos 
vetores, estes poderão armazenar mais de um valor por vez, pois são dimensionadas 
exatamente para este fim. Por consequência, a manipulação dos elementos de um vetor 
ocorrerá de forma individualizada, pois não é possível efetuar a manipulação de todos 
os elementos do conjunto ao mesmo tempo. 
Apresentamos, a seguir, um exemplo de um vetor usado para guardar os nomes 
dos meses do ano. 
 
String meses[ ] = new String[12]; 
meses[0] = “Janeiro”; 
meses[1] = “Fevereiro”; 
... 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 50 
meses[10] = “Novembro”; 
meses[11] = “Dezembro”; 
 Outra forma de declarar e inicializar um vetor em Java é pelo uso da 
inicialização direta, que consiste em incluir ambas as operações em uma única 
instrução, por exemplo, a linha de código: 
int meses[ ] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12} 
Tanto a entrada como a saída de dados manipulada com um vetor é processada 
passo a passo, um elemento por vez. Estes processos são executados com o auxílio de 
um laço de repetição para manipulação de todos os índices do vetor. Verificar-se-á 
agora uma aplicação de um vetor: desenvolver um programa para calcular a média geral 
de uma turma de cinquenta alunos. 
 
import javax.swing.JOptionPane; 
public class Media_Turma{ 
 public static void main (String args []){ 
 final int tamanho = 50; 
 float notas[] = new float [tamanho]; 
 float somaNotas = 0, media; 
 int contNotas = 0; 
 for (int i=0; i<tamanho; i++){ 
 notas[i]=Float.parseFloat(JOptionPane.showInputDialog 
(“Informe a”+ (i+1)+ “a. Nota:”)); 
 if (notas[i]>=0.0f && notas[i]<=10.0f){ 
 contNotas++; 
 somaNotas = somaNotas + notas[i]; 
 } 
 } 
 if (contNotas == 0){ 
 JOptionPane.showMessageDialog(null, “Não foram 
entrados dados válidos!!!”); 
 } 
 
 
Técnicas de Programação em Java – Prof. D.Sc. Eng. Emerson Cordeiro Morais 51 
 else{ 
 media = somaNotas/contNotas; 
 JOptionPane.showMessageDialog(null,