AlgoritmoI Apostila

2014
Apostila de Algoritmos I
Daniel Barbosa de Oliveira

Prof. Daniel Oliveira
Ilustrações
Figura 1 - Definição de algoritmo ............................................................................................................................ 8

Figura 2 - Arquitetura de Von Neumann................................................................................................................. 9
Figura 3 - Exemplo de instruções de máquinas ................................................................................................... 10
Figura 4 - Exemplo de um código em Assembly ................................................................................................... 10
Figura 5 - Processo de compilação ........................................................................................................................ 11
Figura 6 - Exemplo de um fluxograma .................................................................................................................. 12
Figura 7 - Fluxograma para cálculo da área de um retângulo .............................................................................. 13
Figura 8 - Exemplo de um fluxograma para determinação da maior idade ......................................................... 13
Figura 9 - Atribuição de variáveis em Fluxogramas .............................................................................................. 14
Figura 10 - Exemplo de fluxograma de cálculo de média nível Alto ..................................................................... 15
Figura 11 - Exemplo de cálculo de média detalhado ............................................................................................ 16
Figura 12 - Exemplo de um diagrama linear ......................................................................................................... 17
Figura 13 - Exemplo de sequência ........................................................................................................................ 17
Figura 14 - Exemplo de Estrutura condicional ...................................................................................................... 18
Figura 15 - Exemplo de Estrutura de repetição .................................................................................................... 18
Figura 16 - Exemplo de Case ................................................................................................................................. 19
Figura 17 - Exemplo de estrutura de dados .......................................................................................................... 26
Figura 18 - Definição de variável (Tonet,2004) ..................................................................................................... 27
Figura 19 - Processo de compilação de código fontes em Java ............................................................................ 30
Figura 20 - Arquitetura para execução do código Java ......................................................................................... 30
Figura 21 - Opções para obtenção do JDK ............................................................................................................ 31
Figura 22 - Opções de download do Eclipse ......................................................................................................... 32
Figura 23 - Tela de configuração de Workspace ................................................................................................... 32
Figura 24 - Tela inicial do Eclipse .......................................................................................................................... 33
Figura 25 - Ambiente do Eclipse para iniciar os trabalhos .................................................................................... 33
Figura 26 - Janela de perspectiva .......................................................................................................................... 34
Figura 27 - Outros tipos de perspectivas .............................................................................................................. 34
Figura 28 - Opção de troca de Workspace ............................................................................................................ 35
Figura 29 - Criação de um projeto Java ................................................................................................................. 35
Figura 30 - Selecionando o tipo de projeto no Eclipse.......................................................................................... 36
Figura 31 - Parâmetros inicias do projeto Java ..................................................................................................... 36
Figura 32 - Nome do projeto Java ......................................................................................................................... 37
Figura 33 - Tela de configuração final do projeto Java ......................................................................................... 37
Figura 34 - Package Explorer ................................................................................................................................. 38
Figura 35 - Usando o menu Show View ................................................................................................................ 38
Figura 36 - Criando uma nova classe..................................................................................................................... 39
Figura 37 - Parâmetros básicos para criação de classes ....................................................................................... 39
Figura 38 - Código inicial gerado pelo assistente de criação de classes ............................................................... 40
Figura 39 - Exemplo de código do primeiro projeto Java ..................................................................................... 40
Figura 40 - Janela de console com o resultado a execução do código ................................................................. 40
Figura 41 - Exemplo de código em Java ................................................................................................................ 41
Figura 42 - Exemplo de comentários de uma linha............................................................................................... 41
Pág.: 1/94
Figura 43 - Comentário de bloco........................................................................................................................... 41

Figura 44 - Método MAIN ..................................................................................................................................... 42
Figura 45 - Uso de chaves para delimitar blocos de código .................................................................................. 42
Figura 46 - Uso do ponto e vírgula para finalizar uma linha de código ................................................................ 42
Figura 47 - Exemplo endentação de código .......................................................................................................... 43
Figura 48 - Resultado da execução do exemplo de limites de valores para tipos numéricos .............................. 44
Figura 49 - Atribuição de valores .......................................................................................................................... 45
Figura 50 - Exemplo de erro com uso de variáveis não inicializadas .................................................................... 45
Figura 51 - Exemplos de compatibilidade de tipos ............................................................................................... 49
Figura 52 - Exemplo de falha entre conversão de tipos........................................................................................ 52
Figura 53 - Exemplo de tratamento de exceções.................................................................................................. 52
Figura 54 - Exemplo da classe Scanner ................................................................................................................. 55
Figura 55 - Uso do método next da classe Scanner .............................................................................................. 55
Figura 56 - Uso da classe Scanner ......................................................................................................................... 55
Figura 57 - Estrutura condicional .......................................................................................................................... 58
Figura 58 - Exemplo de expressão lógica com AND .............................................................................................. 61
Figura 59 - Exemplo de expressões relacionais com AND .................................................................................... 62
Figura 60 - Exemplo de operador OR .................................................................................................................... 62
Figura 61 - Tabela da verdade do operador AND ................................................................................................. 63
Figura 62 - Tabela da verdade do operador OR .................................................................................................... 63
Figura 63 - Loop pré-testados ............................................................................................................................... 70
Figura 64 - Loop pós-testado ................................................................................................................................ 71
Figura 65 – Array com 10 elementos .................................................................................................................... 80
Figura 66 - Representação de uma array multidimensional ................................................................................. 85
Figura 67 - Representação de uma matriz ............................................................................................................ 85
Figura 68 - Acessando posições dentro de um arranjo bidimensional ................................................................. 86
Figura 69 - Percorrendo uma array multidimensional .......................................................................................... 87
Pág.: 2/94
Quadros
Quadro 1 - Símbolos para construção de fluxogramas ......................................................................................... 13

Quadro 2 - Operadores aritméticos ...................................................................................................................... 22
Quadro 3 - Operadores relacionais ....................................................................................................................... 22
Quadro 4 - Operadores lógicos ............................................................................................................................. 23
Quadro 5 - Tabela verdade ................................................................................................................................... 23
Quadro 6 - Tipos de dados primitivos do Java ...................................................................................................... 43
Quadro 7 - Operadores para tipos numéricos ...................................................................................................... 45
Quadro 8 - Comparação entre operadores ........................................................................................................... 46
Pág.: 3/94
Exemplos
Exemplo 1 - Limites dos tipos numéricos.............................................................................................................. 44

Exemplo 2 - Declarando e inicializando uma variável........................................................................................... 45
Exemplo 3 - Exemplo de utilização de operadores com tipos numéricos ............................................................ 46
Exemplo 4 - System.Math constantes ................................................................................................................... 46
Exemplo 5 - System.Math Min e Max ................................................................................................................... 47
Exemplo 6 - System.Math Potência e raiz quadrada ............................................................................................ 47
Exemplo 7 - System.Math Logaritimo ................................................................................................................... 47
Exemplo 8 - Valores absolutos e arredondamentos ............................................................................................. 48
Exemplo 9 - System.Math: Trigonometria ............................................................................................................ 48
Exemplo 10 - System.Math: Números randômicos .............................................................................................. 49
Exemplo 11 - Cast .................................................................................................................................................. 50
Exemplo 12 - Cast .................................................................................................................................................. 50
Exemplo 13 - Exemplo de cast para operação de divisão ..................................................................................... 51
Exemplo 14 - Conversão de tipo para string ......................................................................................................... 51
Exemplo 15 - Exemplo de métodos para conversão de string para tipos numéricos ........................................... 51
Exemplo 16 - Exemplo de saída para console ....................................................................................................... 53
Exemplo 17 - Exemplo de saída para console ....................................................................................................... 53
Exemplo 18 - Uso de caracteres de escape para saída no console ....................................................................... 54
Exemplo 19 - Uso do comando printf ................................................................................................................... 54
Exemplo 20 - Mais um exemplo de uso do printf ................................................................................................. 55
Exemplo 21 - Exemplo das rotinas da classe Scanner para obter dados numéricos ............................................ 56
Exemplo 22 - Estrutura IF clássica ......................................................................................................................... 58
Exemplo 23 - Exemplo do IF com apenas uma linha............................................................................................. 59
Exemplo 24 - Uso de equals para comparação de strings .................................................................................... 59
Exemplo 25 - Exemplo de equalsIgnoreCase para comparação de string ............................................................ 60
Exemplo 26 - Exemplo de uso do Else ................................................................................................................... 60
Exemplo 27 - Exemplo e if/else aninhados ........................................................................................................... 61
Exemplo 28 - Exemplo de uso de IF / Else encadeados ........................................................................................ 64
Exemplo 29 - Exemplo de uso do switch / case .................................................................................................... 65
Exemplo 30 - Uso do switch/case mais avançado ................................................................................................ 66
Exemplo 31 - Estrutura do Loop While ................................................................................................................. 71
Exemplo 32 - Exemplo do loop while .................................................................................................................... 71
Exemplo 33 - Exemplo do uso do comando break dentro de um loop ................................................................ 72
Exemplo 34 - Estrutura do Loop Do...While.......................................................................................................... 72
Exemplo 35 - Exemplo do Loop Do..While ............................................................................................................ 73
Exemplo 36 - Uso do loop Do..While .................................................................................................................... 73
Exemplo 37 - Exemplo do loop do..while com loop while .................................................................................... 74
Exemplo 38 - Exemplo do loop FOR ...................................................................................................................... 75
Exemplo 39 – Exemplo do loop FOR descrente .................................................................................................... 75
Exemplo 40 - Exemplo de loop for com a variável de controle declarada fora do loop ....................................... 75
Exemplo 41 - Exemplo um pouco mais completo com loop For fonte: http://www.java-samples.com ............. 76
Exemplo 42 - Exemplo de criação e inicialização de uma array............................................................................ 80
Exemplo 43 - Formas de inicializar uma array ...................................................................................................... 81
Exemplo 44 - Exemplo de acessar posições de uma arry por loop ....................................................................... 81
Pág.: 4/94
Exemplo 45 - Percorrendo uma array de char ...................................................................................................... 81

Exemplo 46 - Exemplo de uma rotina de ordenação de array.............................................................................. 82
Pág.: 5/94
Sumário
Ilustrações ........................................................................................................................................................... 1
Quadros ............................................................................................................................................................... 3
Exemplos ............................................................................................................................................................. 4
Introdução ............................................................................................................................................................... 8
Algoritmos Computacionais ................................................................................................................................ 9
Fluxogramas ...................................................................................................................................................... 12
Exercícios....................................................................................................................................................... 20
Trabalhando com expressões ........................................................................................................................... 22
Modularização de expressões e precedência de operadores....................................................................... 25
Estrutura de dados ............................................................................................................................................ 25
Constantes ........................................................................................................................................................ 26
Variáveis ............................................................................................................................................................ 26
Tipos de dados .............................................................................................................................................. 27
Exercícios........................................................................................................................................................... 28
Java........................................................................................................................................................................ 29
Ambiente de desenvolvimento ......................................................................................................................... 31
Obtendo o Eclipse e instalando .................................................................................................................... 32
Perspectiva .................................................................................................................................................... 33
Workspace .................................................................................................................................................... 34
Criando um projeto ....................................................................................................................................... 35
Variáveis ............................................................................................................................................................ 41
Tipos numéricos ............................................................................................................................................ 45
Compatibilidade entre tipos ......................................................................................................................... 49
Interagindo com usuários ................................................................................................................................. 53
Exercícios........................................................................................................................................................... 57
Estrutura condicional ........................................................................................................................................ 58
A instrução IF................................................................................................................................................. 58
Comparação de strings.................................................................................................................................. 59
A instrução Else ............................................................................................................................................. 60
Aninhando a instrução if/else ....................................................................................................................... 61
Usando operadores AND e OR ...................................................................................................................... 61
Declaração switch/case................................................................................................................................. 64
Exercícios....................................................................................................................................................... 67
Estruturas de repetição ..................................................................................................................................... 70
Pág.: 6/94
Loop While .................................................................................................................................................... 71

Loop Do...While............................................................................................................................................. 72
Loop For ........................................................................................................................................................ 74
Exercícios....................................................................................................................................................... 77
Arrays ................................................................................................................................................................ 80
Exercícios....................................................................................................................................................... 83
Arrays multidimensionais.............................................................................................................................. 85
Exercícios....................................................................................................................................................... 88
Anexos ................................................................................................................................................................... 91
Anexo A ............................................................................................................................................................. 91
Anexo B ............................................................................................................................................................. 93
Referências............................................................................................................................................................ 94
Pág.: 7/94
Introdução
“É qualquer procedimento computacional bem definido que toma

algum valor ou conjunto de valores de entrada e produz algum valor
ou conjunto de valores de saída.” (Cormen)
Um algoritmo é uma sequência de passos logicamente organizados que realizam uma tarefa. Na realidade, em
vários momentos no nosso dia a dia utilizamos algoritmos para realização de tarefas rotineiras, por exemplo: a
troca de uma lâmpada, a troca de um pneu, preparação de um café e etc.
De forma geral um algoritmo é um procedimento computacional que com um conjunto de dados de entrada
realiza uma tarefa, resultando em um conjunto de dados de saída. Ou seja, um conjunto de passos
computacionais que recebe uma entrada e gera uma saída.
Entrada Algoritmo Saída
Figura 1 - Definição de algoritmo
No nosso dia a dia, utilizamos o princípio de algoritmos com muita frequência. Como por exemplo: a receita de
um bolo, a troca de um pneu furado, o uso de um determinado dispositivo ou aparelho, e, assim por diante.
Basicamente todos os procedimentos que são constituídos por um conjunto de regras e operações muito bem
definidas e ordenadas. Sendo realizadas em um número finito de etapas, constitui algoritmos.
Algoritmo 1: Bolo de Cenoura
Ingredientes:
2 cenouras grandes
1 xícara de óleo
2 xícaras de açúcar
4 ovos
2 xícaras de farinha de trigo
1 colher de sopa de fermento em pó
1 lata de leite condensado
Pág.: 8/94
4 colheres de chocolate em pó
2 colheres de sopa de margarina
Modo de Preparo:
1. Bata no liquidificador as cenouras, o açúcar, os ovos e o óleo até obter um creme.

2. Despeje esse creme em uma vasilha e acrescente a farinha.
3. Bata na batedeira por 4 minutos em velocidade alta.
4. Acrescente o fermento e misture.
5. Coloque em uma forma untada por uns 30 a 35 minutos.
6. Retire do forno e coloque a cobertura!
Algoritmos Computacionais
Um programa de computador nada mais é do que um algoritmo escrito em alguma linguagem de programação
que passa por um processo de compilação ou interpretação que traduz os comandos da linguagem em
instruções que o computador executa.
Todos os computadores e dispositivos computacionais tem uma estrutura bem parecida. Em, sua maioria são
constituídos por:
 UCP – Unidade Centro de Processamento

 Memória
 Dispositivo de entrada e saída
Estes componentes citados são conectados pelo o que nós denominados de barramento.
Figura 2 - Arquitetura de Von Neumann
A UCP ou unidade controladora é a parte mais importante do computador. Ela executa todos os cálculos,
execução de tarefas e processamento de dados. Qualquer processador executa um conjunto específico de
instruções denominado de linguagem de máquina.
Todo processador tem um conjunto de instruções que ele pode realizar. Estas instruções são denominadas de
código de máquina, que são representados por uma sequência de bits (zeros e uns). A quantidade desses bits
é limitada ao tamanho do registrador principal do processador (8 bits, 16, 32 ou 64).
Pág.: 9/94
Estas instruções são tarefas muito simples, como por exemplo, transferir uma informação de uma posição da
memória para o processador, somar dois números e etc. Normalmente, este conjunto de instruções binárias
(1s e 0s) é representado em um formato hexadecimal – ver Figura 3.
Figura 3 - Exemplo de instruções de máquinas
Normalmente trabalha-se com uma linguagem denominada de Assembly ou linguagem de montagem. Que é
na realidade uma representação das instruções de máquinas, mas, em um formato que seja humanamente
legível (Figura 4)
Figura 4 - Exemplo de um código em Assembly
Outra parte importante dessa arquitetura é a memória. É na memória que os dados que são armazenados, o
processador acessa um posição de memória, copia o conteúdo dela para um de seus registradores internos,
realiza as ações e operações necessárias e retorna (se for o caso) a informação alterada para memória.
A memória RAM (Random Access Memory – Memória de acesso aleatório), é “loteada” locais que são
endereçados através de um número inteiro. Quanto mais memória a máquina possuir, maior será a quantidade
desses endereços e consequentemente maior será o valor do endereço. Na Figura 4, temos na primeira coluna
da esquerda o endereço de memória. Como vimos anteriormente os processadores tem o que chamamos de
registradores. Estes registradores irão conter o endereço de memória de uma determinada informação, assim
sendo, o tipo de processador influi em quanto de memória pode ser endereçado pelo mesmo.
A quantidade de memória endereçável por um processador pode ser calculada através da seguinte fórmula:
2(𝑄𝑢𝑎𝑛𝑡𝑖𝑑𝑎𝑑𝑒 𝑑𝑒 𝐵𝑖𝑡𝑠 𝑑𝑜 𝑃𝑟𝑜𝑐𝑒𝑠𝑠𝑎𝑑𝑜𝑟)
Pág.: 10/94
Por exemplo um processador de 32 bits: 232 = 4.294.967.296 bytes ou 4Gbs. Mesmo que a máquina apresente
mais memória RAM, o processador simplesmente não conseguirá endereçar todos os endereços disponíveis. Já
um processador de 64bits consegue endereçar até 16 Terabytes.
Além da memória temos os dispositivos de entrada e saída de dados, que podem ser:
 Monitor
 Teclado
 Mouse
 Impressoras
Ou, qualquer dispositivo que possa receber dados e exibir dados. Para nós, seres humanos, temos a tendência
de imaginar que os computadores se resumem a apenas aos dispositivos de entrada e saída, pois, á através
dos mesmos que interagimos com os computadores.
Nos últimos anos estes dispositivos têm evoluído e novas formas desse tipo de dispositivo têm surgido. Por
exemplo, até alguns anos atrás os monitores eram considerados dispositivos apenas de saída, hoje, com o uso
de telas de touch isto mudou.
Assim, sendo, um programa de computador nada mais é do que a codificação de um algoritmo que contém
instruções para que um computador realize alguma tarefa. Evidentemente, não escrevemos os programas em
linguagem de máquina ou instruções de máquina. Utilizamos para isto linguagens, denominadas de alto nível.
As instruções escritas nessas linguagens são chamadas de código fonte. Este código
fonte passa por um processo de tradução para linguagem de máquina, chamado de
compilação.
Na Figura 5, vemos de forma geral o processo de compilação. Primeiro é criado o nosso

código fonte (em uma linguagem de alto nível). O código fonte passa por um processo
que analise se escrevemos as “palavras” da linguagem de forma correta e na ordem
correta (vamos ver mais a frente que as palavras de uma linguagem de programação,
são os seus comandos).
Após, o código fonte ter sido validado, é então, transformado no que se chama em
código intermediário. Este código intermediário é quase a linguagem de máquina, mas,
ainda faltam alguns ajustes. Este código então é otimizado e então transformado para
em código de máquina dando origem ao programa executável ou biblioteca.
Um ponto que deve ser realçado é que o processo de compilação e criação de código
sempre esta ligado a uma determinada arquitetura. Ou seja, é necessário a existência
de compiladores específicos para cada tipo de arquitetura.
Figura 5 - Processo de
compilação
Pág.: 11/94
Fluxogramas
Além das linguagens de programação (nosso principal foco), existe outra forma de representação dos
algoritmos (uma forma mais visual e mais simples de entendimento para iniciantes ou leigos), que são os
fluxogramas.
Os Fluxogramas ou Diagramas de Fluxo são uma representação gráfica que utilizam formas geométricas
padronizadas ligadas por setas de fluxo, para indicar as diversas ações (instruções) e decisões que devem ser
seguidas para resolver o problema em questão.
Na Figura 6, temos um exemplo de fluxograma para o cálculo de uma raiz quadrada. Como se pode notar
utilizam-se figuras para indicar os passos do algoritmo a ser executado no fluxo. Os símbolos utilizados na
construção de um fluxograma podem ser visto no Quadro 1, aonde é apresentado apenas os principais.
Figura 6 - Exemplo de um fluxograma
Símbolo Descrição Símbolo Descrição

Início/Fim Direção do Fluxo
Entrada de Dados Repetição
Atribuição,
Operação,
Processamento
Decisão
Pág.: 12/94
Imprimir / Saída
Quadro 1 - Símbolos para construção de fluxogramas
Esta forma de representação dos algoritmos é de grande utilidade para exemplificar e demonstrar os passos
necessários para a construção dos nossos algoritmos. Por exemplo, como ficaria um fluxograma para cálculo
da área de um retângulo?
Largura e
Inicio Largura * Altura Fim
Altura Àrea
Figura 7 - Fluxograma para cálculo da área de um retângulo
Outro exemplo seria como determinar se uma pessoa é maior ou não de idade?
Inicio Idade
Idade >= 18 Não

SIM
Maior de idade Menor de Idade
Fim
Figura 8 - Exemplo de um fluxograma para determinação da maior idade
Em muitas situações queremos guardar o resultado de alguma operação para ser utilizado ou testado mais a
frente no fluxograma. Para isto utilizamos o que nós chamamos de variáveis (vamos abordar este conceito
mais a frente). Dentro da representação dos fluxogramas utilizamos uma seta () para indicar o
armazenamento da informação na variável, por exemplo:
Pág.: 13/94
Inicio
N1  Nota N1
N2  Nota N2 M (N1+N2)/2
M >= 5
Sim
Reprovado
Aprovado
Fim
Figura 9 - Atribuição de variáveis em Fluxogramas
De forma geral, os fluxogramas são excelentes ferramentas para avaliação do fluxo de informação de um
sistema. Para se desenvolver um diagrama correto, devemos levar como procedimentos:
1) Os diagramas devem feitos e quebrados em níveis. Inicia-se com uma ideia geral, e, então aumenta-se
o detalhamento
2) Os fluxogramas devem ser desenvolvidos sempre, que possível, de cima para baixo e da esquerda para
a direita
3) É incorreto e proibido ocorrência de cruzamento das linhas de fluxo
Por exemplo, um fluxograma de cálculo de média final:
Pág.: 14/94
Figura 10 - Exemplo de fluxograma de cálculo de média nível Alto
O fluxograma da imagem anterior está em nível muito elevado. Não é possível entender pontos como: quantas
notas irão compor a média, qual a fórmula de cálculo da média e como se determinar a aprovação? Então, se
faz necessário, aumentar o nosso detalhamento.
Vamos agora, detalhar o processo de obtenção das notas:
Inicio
Obter N1
Obter N2
Calcular média e
determinar
aprovação
Fim
Pág.: 15/94
Ainda temos que detalhar como a média é calculada:
Inicio Obter N1 Obter N2
M  (N1 + N2) /2
Determinar
aprovação
Fim
Agora precisamos detalhar como é feita a determinação da aprovação:
Inicio Obter N1 Obter N2
M  (N1 +
N2) /2
SIM M >= 5 Não
Aprovado Reprovado
Fim
Figura 11 - Exemplo de cálculo de média detalhado

Pág.: 16/94
Um diagrama de fluxo aonde os elementos são executados de cima para baixo (top-down), sendo que cada
elemento tem apenas um único predecessor e um único sucessor é conhecido como digrama linear - Figura 12.
Figura 12 - Exemplo de um diagrama linear
Já digramas construídos para boa parte dos sistemas de processamento de dados, temos o que chamamos de
lógica estruturada. Nesse tipo de lógico temos elementos que simbolizam a sequência de ações, condições de
execução e repetição ou laço.
Na Figura 13, vemos o exemplo de representação gráfica de uma sequência. Nela temos a ordem em que
processos devem ser executados, mostrando assim a hierarquia em que as ações deverão ser realizadas.
Figura 13 - Exemplo de sequência
Já na Figura 14, vemos a representação de estrutura condicionais. Aonde dependendo dos testes lógicos
realizados (verdadeiro ou falso) o fluxo de execução do fluxograma é desviado.
Pág.: 17/94
Figura 14 - Exemplo de Estrutura condicional
Além das estruturas condicionais, temos as chamadas estruturas condicionais. Nelas um conjunto de ações são
repetidas até que alguma condição impeça ou pare a repetição, ver abaixo.
Figura 15 - Exemplo de Estrutura de repetição
Em situações aonde temos vários testes condicionais aninhados (como por exemplo a seleção de uma opção
em um menu), podemos utilizar uma estrutura denominada de case (ver abaixo)
Pág.: 18/94
Figura 16 - Exemplo de Case
Evidentemente não podemos descrever todo um sistema em seus detalhes, ou até mesmo uma rotina, em
apenas um único diagrama. A técnica deve ser utilizada é a chamada: Modularização. Para isto precisamos
realizar as seguintes etapas:
1) Decompor um diagrama em partes independentes

2) Dividir um problema complexo em problemas menores e mais simples
3) Verificar a correção de um módulo de blocos, independentemente de sua utilização como unidade em
processo maior.
Se, possível, a modularização deve ser desenvolvida em diferentes níveis. Partimos de um visão geral do
problema identificando os sistemas que irão compor a solução, para cada sistema quais os programas que o
irão compor e para cada programa quais serão seus módulos.
Pág.: 19/94
Exercícios
1) Dados os passos de cálculo abaixo montar um fluxograma para o mesmo

a. Início de programa
b. Ler a, b
c. Se a é diferente de 0 então
i. Calcula o valor de x, sendo que ax+b=0
d. Escrever “ O valor de x é ”, x
e. Senão escrever “Não há zero”
f. Fim de programa
2) Em uma escola, a média final é dada pela média aritmética de três notas. E a mesma tem o seguinte
esquema de avaliação:
Desenvolva um algoritmo que a partir da entrada das três notas mostre a situação do aluno. No caso do aluno
em recuperação e prova final, mostre também quanto o aluno irá precisar para passar. No caso da
recuperação a nota necessária para passar é dada por 10 – Média + 2 e na prova final é dado por 10 – Média.
3) Monte um fluxograma e um pseudocódigo capaz de resolver o cálculo da área de um trapézio

qualquer. Área do trapézio = (Base Maior + Base Menor) x Atura / 2
4) Em uma loja e CD´s existem apenas quatro tipos de preços que estão associados a cores. Assim os CD´s
que ficam na loja não são marcados por preços e sim por cores. Desenvolva o algoritmo que a partir a
entrada da cor o software mostre o preço. A loja está atualmente com a seguinte tabela de preços
Cor Preço
Verde 10,00
Azul 15,00
Amarelo 30,00
Vermelho 40,00
5) Desenvolva um algoritmo capaz e encontrar o menor dentre 3 números inteiros quaisquer dados pelo
teclado.
6) Desenvolva um algoritmo capaz de verificar se uns números inteiros, dados como entrada, é par ou
ímpar.
7) Elabore um algoritmo que leia as variáveis C e N respectivamente código e número de horas

trabalhadas de um operário. E calcule o salário sabendo-se que ele ganha R$ 10,00 por hora. Quando o
número de horas excederem a 50 calcule o excesso e pagamento armazenando-o na variável E, caso
Pág.: 20/94
contrário zerar tal variável. A hora excedente de trabalho vale R$ 20,00. No final do processamento
imprimir o salário total e o salário excedente.
8) A secretária de Meio Ambiente que controla o índice de poluição mantém 3 grupos que são altamente
poluentes do meio ambiente. O índice de poluição aceitável varia de 0,05 até 0,25. Se o índice sobe
para 0,3 as indústrias do 1º grupo são intimadas a suspenderem suas atividades, se o índice crescer
para 0,4 as indústrias do 1º e 2º grupo são intimadas a suspenderem suas atividades, se o índice
atingir 0,5 todos os grupos devem ser notificados a paralisarem suas atividades. Faça um algoritmo
que leia o índice de poluição medido e emita a notificação adequada aos diferentes grupos de
empresas.
Pág.: 21/94
Trabalhando com expressões
Para a construção de Algoritmos todas as expressões aritméticas devem ser linearizadas, ou seja, colocadas
em linhas. É importante também ressalvar o uso dos operadores correspondentes da aritmética tradicional
para a computacional.
Exemplo:
2 
 3  5  3  1 
(2/3+(5-3))+1=
Tradicional Computacional
Cada linguagem de programação tem um conjunto de operadores para a construção de expressões aritméticas
ou relacionais. As expressões relacionais são aquelas que o resultado é um valor lógico (verdadeiro ou falso –
true ou false).
Por exemplo, a expressão 1+1 é uma expressão aritmética que resultará em um valor. Já a expressão 1 > 2 (o
valor 1 é maior do que 2?) é uma expressão relacional, aonde são realizadas comparações.
OPERADORES ARITMÉTICOS OPERADORES

Adição +
Subtração -
Multiplicação *
Divisão /
Divisão Inteira \
Potência ^ ou Exp (base,expoente)
Módulo (resto da divisão) %
Quadro 2 - Operadores aritméticos
OPERADORES RELACIONAIS OPERADORES

Maior >
Menor <
Maior ou igual >=
Menor ou igual <=
Igual =
Diferente <>
Quadro 3 - Operadores relacionais
Nos quadros acima temos as representação dos operadores aritméticos e relacionais utilizados nas principais
linguagens de programação. Vale a ressalva que não serão os mesmos para todas as linguagens, existem
variações.
Além desses operadores ainda existem os operadores lógicos, que atuam apenas sobre os valores lógicos. Eles
são relacionados no Quadro 4.
Conjunção E (and) RETORNA VERDADEIRO SE AMBAS AS PARTES FOREM VERDADEIRAS.
Pág.: 22/94
Disjunção OU (or) BASTA QUE UMA PARTE SEJA VERDADEIRA PARA RETORNAR VERDADEIRO.
Disjunção Exclusiva XOU RETORNAR FALSO SE AMBOS OS LADOS FOREM IGUAIS E VERDADEIRO CASO
(XOR) CONTRÁRIO
NÃO (not) INVERTE O ESTADO, DE VERDADEIRO PASSA PARA FALSO E VICE-VERSA.
Quadro 4 - Operadores lógicos
No quadro abaixo temos alguns exemplo do uso desses conectivos
Os operadores lógicos atuam sobre os valores lógicos da seguinte forma (Quadro 5):
A B A E B A OU B NÃO (A) A XOR V
V V V V F F
V F F V F V
F V F V V V
F F F F V F
Quadro 5 - Tabela verdade
Alguns exemplos de expressões lógicas:
Pág.: 23/94
Vamos ver alguns exemplos de uso utilizando pseudocódigo:
Se (salario > 180) e (salário < 800) Então

Escrever 'Salário válido para financiamento'
Senão
Escrever 'Salário fora da faixa permitida para financiamento'
FimSe
Se (idade < 18) ou (idade > 95) Então

Escrever 'Você não pode fazer carteira de motorista'
Senão
Escrever 'Você pode possuir carteira de motorista'
FimSe
Se (idade > = 18) e (idade < = 95) e (aprovado_exame = 'sim') Então

Escrever 'Sua carteira de motorista estará pronta em uma semana'
Senão
Escrever 'Você não possui idade permitida ounão passou nos testes'
FimSe
Pág.: 24/94
Mas algum exemplos de operações lógicas:
Para A = Verdadeiro, B = Falso e C = Falso, as expressões abaixo fornecem os seguintes resultados:
Modularização de expressões e precedência de operadores
A modularização é a divisão da expressão em partes, proporcionando maior compreensão e definindo

prioridades para resolução da mesma. Em expressões computacionais usamos somente parênteses “( )” para
modularização. Assim:
((2 + 2)*4 +8)/ 2 = 12 é diferente de 2 + 2*4 +8/ 2 = 14
Além do fato do uso dos parênteses deve ser levada em conta a precedência dos operadores na resolução das
expressões aritméticas. A lista abaixo relaciona os operadores de maior precedência para os de menor
precedência:
 Parênteses e Funções
 Operadores Aritméticos na seguinte ordem:
 Potenciação: ^;
 Multiplicação e Divisão: *, /;
 Soma e Subtração: +, -;
 Operadores Relacionais: = ,<> ,> ,< ,>= ,<=;
 Operadores Lógicos na seguinte ordem: NAO, E, OU.
Estrutura de dados
“Uma estrutura de dados é um meio para organizar e armazenar dados

com objetivo de facilitar o acesso e as modificações” (Cormen,2002).
As estruturas de dados e algoritmos são muito ligados. Não se pode estudar estruturas de dados sem
considerar os algoritmos associados a elas, assim como a escolha dos algoritmos em geral depende da
representação e da estrutura dos dados (ZIVIANI,1999).
Pág.: 25/94
De uma maneira bem informal podemos definir um programa de computador ou um software como sendo a
união entre um algoritmo e uma estrutura de dados. Na solução de problemas através de algoritmos devemos
também determinar qual a estrutura de dados será utilizada.
Figura 17 - Exemplo de estrutura de dados
Constantes
As constantes são valores (ou informações, dados) que não variam com o tempo. São valores fixos (não
variáveis). Como exemplo, são os números, letras, palavra e etc.
Variáveis
O conceito de variável é muito importante para a elaboração de algoritmos e os programas. Uma variável é um
espaço de memória do computador que é reservado para armazenar as informações ou dados utilizado pelo
programa de computador.
Como o próprio nome mostra, as variáveis tem seu valor não constante, ou seja, variável no tempo. Toda
variável tem um nome ou identificador, para facilitar (para nós humanos) a referência à mesma. Internamente
os computadores acessam a memória através de endereços numéricos, as linguagens de programação
simplificam esse processo associando aos endereços de memória nomes ou identificadores fornecidos pelos
programadores.
Podemos caracterizar uma variável como sendo uma caixa com conteúdo. No lado de fora dessa caixa temos
uma etiqueta com um identificador e o conteúdo da caixa é o valor dessa variável (que poder ser alterado
diversas vezes).
Pág.: 26/94
Figura 18 - Definição de variável (Tonet,2004)
Cada linguagem de programação tem suas próprias regras para a criação de identificadores.
Tipos de dados
Em linguagens de programação os dados têm certas características e uma das mais importantes é o seu tipo.
Números, textos, datas e outros tem uma forma peculiar de ser armazenado e representado pelos
computadores. O tipo do dado define a forma a armazenamento e representação da informação.
Os tipos de dados podem ser simples, ou seja, o valor é indivisível. Por exemplo, um número inteiro é um tipo
simples, um valor de tipo lógico (verdadeiro ou falso), uma letra (caractere), são tipos simples.
Os tipos estruturados em geral definem uma coleção de valores simples, ou um agregado de valores de tipos
diferentes (ZIVIANI,1999). Estes tipos são os vetores, matrizes e outros.
Os tipos de dados determina o conjunto de valores possíveis que uma variável ou expressão pode assumir. E,
também, quais operações poderão ser realizadas.
Atribuição
Atribuição é a ação de armazenar ou passar valor para um variável. Quando realizamos uma ação de atribuição
estamos “colocando” a informação no endereço de memória referenciado. Como foi visto no conteúdo de
fluxogramas utilizamos uma seta () para indicar esta ação. Mas, como iremos ver mais a frente existem
outros símbolos para indicar a atribuição.
Na ação de atribuição é importante saber se a informação que queremos armazenar na variável é compatível
com a mesma. Nesse momento o tipo de dado é analisado e caso não seja possível a ação não poderá ser
realizada. Ainda, é possível o chamamos de casting, ou, mudança do tipo de dado da informação para um tipo
de dado compatível.
Uma observação importante a ser feita em relação a atribuições é que na parte esquerda (a que vai "receber"
algo) não pode haver nada além da variável, ou seja, é só variável que "recebe" algum conteúdo, não é
possível ter um cálculo por exemplo, ou uma constante, recebendo alguma coisa. Por exemplo:
Ex.: nota1 + nota2  valor – Esta instrução está incorreta e não poderá ser realizada
Pág.: 27/94
Exercícios
1- Escreva as expressões na forma de computacional
b(3 x )
a. ae  2 
c
2 x 2  (3 x) ( x 1) x 1
b.  
2 x2
22 k
 45 
c. 2h    4h(3  h)  
 3x 
2b  4a 2  2 f 3
d. 
3  2a
1
 6 x  (2 y ) 3
e. 
39
2
2x  u 3
f. 
a  bc
2- Escreva as expressões em formato tradicional
a. a+b+(34+exp(e,9))/u-89^(1/2)=
b. 23+5/((7*a)/47)^(2/x)=
c. (12*x)/(36-9^x)^2=
3- Resolva as expressões lógicas
a. não (2^3 < √16 ou 15\2 < 10)
b. (6<8) ou (3>7) =
c. Não (2<3) =
d. (5>=6) ou (6<7) ou não (a+5-6=8) {sabendo-se que A=5}
e. (34>9 e 5+u = 34) ou (5=15/3 e 8>12) {sabendo-se que u=29}
f. 10%4 < 16%3
g. 2+8%7 >= 6- (8^(2/3))^(1/2)
h. 15\7 >= 27 % 5
Pág.: 28/94
Java
É uma linguagem de programação desenvolvida pela Sun Microsystem, que posteriormente foi comprada pela
Oracle. A sintaxe do Java é baseada no C/C++, mas, de forma diferente é uma linguagem altamente portável
entre plataformas.
A partir de 1991 que o Java passou a ser “visto” pelo público em geral quando a Netscape anunciou que seu
navegador iria suportar o Java para a execução de códigos (applets). Colocando assim, a internet em outro
patamar com informações dinâmicas e páginas com recursos que ainda não se havia visto até então.
Java hoje em dia está presente em vários dispositivos e soluções. Desde soluções empresariais até tablets e
celulares. Abaixo segue uma lista das principais tecnologias Java (Oracle,2011):
 Java SE – Java Standard Edition, versão para a disponibilização de soluções para desktops e servidores.
 Java EE - Java Enterprise Edition, conjunto de soluções para desenvolvimento corporativo.
 Java ME – Java for Micro Edition, ambiente para construção de soluções para dispositivos móveis e embarcados
em equipamentos como: celulares, tablets, PDAs, consoles de gerenciamento de TVs (receptores de TV digital) e
impressoras.
 JavaFX – nova tecnologia para desenvolvimento de aplicações RIA
 Java Card – Tecnologia java utilização de aplicações que irão ser executadas em smartcards e outros
equipamentos com capacidade de memoria e processamento reduzidos.
 Java TV – Plataforma Java ME, otimizada para ser executada em TVs e consoles de gerenciamento de TVs.
Mas, o grande objetivo do desenvolvimento do Java foi à portabilidade. Ou seja, o mesmo código sendo
executado em diferentes sistemas operacionais, sem a necessidade de rescrita ou recompilação. Mas como
isto é possível?
Isto é possível devido à existência da JVM (Java Virtual Machine):
 Máquina imaginária
 Emulada por software em máquina real
 Código armazenado em arquivos *.class
 Interpreta e executa programas Java
O processo de “criação” de códigos executáveis em java passa por duas etapas: uma primeira etapa aonde o
código escrito Java é traduzido (compilado) para uma linguagem intermediária (bytecode). A máquina virtual
Java é responsável pela execução dessa linguagem intermediária, para cada sistema operacional existe uma
máquina virtual própria que realizar a segunda etapa do processo de execução do código, que é a tradução do
bytecode para a linguagem de máquina do ambiente hospedeiro. Ver Figura 19.
Pág.: 29/94
Compilador
JDK
Código Fonte: Java Byte

Code
xxx.java xxx.class
JVM
Execução do
Interpreta o
código
Byte Code
Figura 19 - Processo de compilação de código fontes em Java
Na Figura 20, temos uma visão conceitual do nível de abstração do código em Java em relação ao hardware
aonde esse mesmo código será executado. Quando por exemplo, queremos exibir uma mensagem de texto no
console, simplesmente iremos chamar o comando apropriado no Java. A JVM traduz que este comando para
uma ou mais instruções para o sistema operacional hospedeiro (lembre-se vai existir uma JVM para cada
sistema operacional que irá executar as aplicações Java), e daí para frente é com SO.
JVM
Sistema
Operacional
BIOS
Hardware
Figura 20 - Arquitetura para execução do código Java
O uso de uma máquina virtual foi sem dúvida nenhuma um grande avanço para a criação de soluções
portáveis e multi-plataforma.
A linguagem Java é 100% orientada a objetos, mas, nesse texto não iremos levar isto em consideração e
iremos nos ater apenas a uma programação estruturada (não orientada a objetos).
Pág.: 30/94
A JVM é obtida ao se “instalar” o Java do site da Oracle

(http://www.oracle.com/technetwork/java/javase/downloads/index.html )
Ambiente de desenvolvimento:
 jdk: Java Development Kit (Figura 21)
Ambiente de produção:
 jre: Java Runtime Environment
Figura 21 - Opções para obtenção do JDK
Bem, existem dois tipos de distribuição do Java: JDK e o JRE. O primeiro JDK é voltado para instalação de
máquinas aonde iremos desenvolver soluções Java, pois, acompanha várias ferramentas e documentação
necessária para isto. Já o JRE é indicado para ser instalado em ambientes aonde iremos apenas executar as
soluções construídas. Evidentemente, esta é uma explicação bem simplificada, os puristas que me perdoem,
mas, inicialmente é o suficiente.
Ambiente de desenvolvimento
Um componente muito importante para o desenvolvimento de programas de computador é o ambiente de

desenvolvimento. Há 20 anos eram necessários vários outros programas para realizar a compilação do arquivo
executável: compilador, linkeditor, montador e etc. Com o passar do tempo foram sendo criados ambientes
integrados, aonde através de uma interface amigável é possível a compilação, teste e distribuição dos
aplicativos. Estes ambientes ficaram conhecidos com IDE (Integrated Development Environment).
Vamos utilizar uma IDE de livre distribuição que o Eclipse (http://www.eclipse.org/). O eclipse é uma
framework para integrar diferentes tipos de aplicações. Uma das linguagens que se pode desenvolver é o Java
através do JDT (Java Development Tooling).
O Eclipse trabalhar com plug-ins, facilitando a integração de novas linguagens e funcionalidades ao IDE.
Pág.: 31/94
Um usuário sempre trabalha no workbench, a parte "visível" da plataforma(GUI). A perspectiva escolhida

determina a aparência atual do workbench. A perspectiva é uma coleção conhecida como "views e editores"
que contribuem com ações especiais para o menu e a toolbar.
Obtendo o Eclipse e instalando
Na Figura 22, vemos a opção para baixar a versão desejada do Eclipse. Note uma vez instalado podemos incluir
novos recursos e até mesmo linguagens suportadas a IDE através do recurso de instalação de extensões na
mesma.
Figura 22 - Opções de download do Eclipse
Realizado o download, você deverá descompactar o arquivo no local aonde quiser e deverá localizar o arquivo
eclipse.exe (para ambiente Windows) e executá-lo. Você deverá ver a tela da Figura 23 para configuração do
chamado Workspace.
Figura 23 - Tela de configuração de Workspace
Como o próprio nome já diz, nessa tela (Figura 23) irá indicar para o Eclipse o local de trabalho. Que deverá ser
uma pasta, aonde a IDE irá manter nossos códigos fontes, parâmetros de configuração e outras informações
de trabalho. Podem-se ter vários Workspaces, mas, apenas um fica ativo por vez. Uma vez criado o Workspace,
você deverá uma tela como esta na Erro! Fonte de referência não encontrada..
Pág.: 32/94
Figura 24 - Tela inicial do Eclipse
Na Figura 25Erro! Fonte de referência não encontrada. temos o ambiente o Eclipse pronto para ser utilizado
para o desenvolvimento.
Figura 25 - Ambiente do Eclipse para iniciar os trabalhos
Perspectiva
O Eclipse tem o conceito de perspectivas, ou seja, pode-se definir a configuração das janelas e views de acordo
com o tipo de projeto ou com as configurações que melhor se adequem ao seu gosto.
Pág.: 33/94
Para abrir uma nova perspectiva no seu worbench faça:
1. Escolha 'Window -> Open Perspective' no menu principal:
Figura 26 - Janela de perspectiva
2. Escolha 'Other' para ver todas as perspectivas instaladas:
Figura 27 - Outros tipos de perspectivas
Workspace
O workspace ou espaço de trabalho é o local aonde serão armazenados os arquivos fontes, arquivos
compilados, informações de configuração e outros, que o Eclipse irá utilizar para cada usuário.
Na primeira vez que se executa o Eclipse, será pedido que você informe qual o local do Workspace a ser
utilizado (só é permitido utilizar um workspace por vez). Na Figura 28, vemos o caminho no menu do Eclipse
que possibilita a troca de workspace, o que fará com que o Eclipse se re-inicie.
Pág.: 34/94
Figura 28 - Opção de troca de Workspace
Criando um projeto
Na Figura 29, temos o caminho para criação de um projeto Java no Eclipse. Em algumas configurações do
Eclipse a opção Java Project pode não estar disponível, então selecione a opção Other e na janela que irá
aparecer digite com campo de texto: Java Project – selecione a opção conforme a Figura 30.
Figura 29 - Criação de um projeto Java
Pág.: 35/94
Figura 30 - Selecionando o tipo de projeto no Eclipse
Uma vez selecionado o tipo de projeto Java (se você estiver na janela como da Figura 30, selecione o botão
Next), a janela da Erro! Fonte de referência não encontrada. deverá ser exibida para informações dos
arâmetros iniciais do projeto Java.
Na janela de novo projeto Java devemos informar o nome

do projeto no campo de texto Project Name – Este nome irá
ser exibido na árvore de projetos (ver Figura 32). Abaixo do
nome do projeto pode-se ver a local físico do projeto do
disco.
Na mesma tela podemos informar para qual versão da JRE

iremos trabalhar. Nos exemplos, exercícios e etc, iremos
utilizar a JRE padrão instalado nas máquinas de trabalho.
No caso do exemplo (Figura 31), estamos com versão 1.6.
Informado este dados deve-se selecionar o botão Next.
Figura 31 - Parâmetros inicias do projeto Java
Pág.: 36/94
Figura 32 - Nome do projeto Java
Na Figura 33, temos a tela final de configuração do nosso projeto Java. Na aba Source vemos como será a
estrutura do projeto (esta mesma estrutura estará replicada fisicamente em disco no Workspace). Nas demais
abas têm opções mais avançadas que vão além do exigido nesse texto e vamos deixar para um segundo
momento. Selecionando o botão Finish para finalizar a criação do projeto.
Figura 33 - Tela de configuração final do projeto Java
Depois que o projeto é criado podemos ver a sua estrutura do Package Explorer(Figura 34).
Pág.: 37/94
Figura 34 - Package Explorer
Caso o Package Explorer não esteja sendo exibido vá até: Window -> Show View, e selecione o Package
Explorer(Figura 35). Nessa opção de menu podemos exibir todas as principais janelas do Eclipse.
Figura 35 - Usando o menu Show View
Para finalizar a criação do primeiro projeto java, devemos criar um arquivo .java (todo e qualquer programa
em Java tem que ter pelo menos uma classe). Não vamos agora entrar em por menores sobre a estrutura da
classe criada, vamos abordar isto mais a frente.
No package Explorer, selecione o nó src e com o botão direito do mouse selecione - Figura 36:
Pág.: 38/94
Figura 36 - Criando uma nova classe
Após a seleção da opção de uma nova classe será exibida a janela da Figura 37, aonde deve-se levar em conta
(nesse primeiro momento) apenas as informações marcadas de vermelho. Informa-se o nome da classe e
selecione a caixa de criação do método Main. Selecione o botão Finish para finalizar o assistente de criação de
classes.
Figura 37 - Parâmetros básicos para criação de classes
Após a finalização do assistente de criação de classes, a janela do editor irá ser exibida com o código inicial da
classe. Mais a frente vamos olhar com mais detalhe este código(Figura 38).
Pág.: 39/94
Figura 38 - Código inicial gerado pelo assistente de criação de classes
Para executar o seu projeto tecle CTRL+F11, o Eclipse irá exibir o processo de compilação e nada será exibido
na tela de console, pois, ainda não colocamos nenhum código que realize alguma tarefa interessante.
Na janela do editor altere o código colocando a linha de código em destaque na Figura 39. Note que o código
deve ser escrito exatamente como está no exemplo. A linguagem Java é case sensitive ou seja faz distinção
entre maiúsculas e minúsculas.
Figura 39 - Exemplo de código do primeiro projeto Java
Selecione as teclas CTRL+F11 e veja o resultado na janela de console do Eclipse como na Figura 40.
Figura 40 - Janela de console com o resultado a execução do código
Pág.: 40/94
Variáveis
Anteriormente falamos sobre tipos de dados e a definição do que são variáveis. Bem, vamos agora ver estas
definições dentro de um programa em Java.
Antes de tudo, precisamos entender a estrutura básica de um programa Java.
Figura 41 - Exemplo de código em Java
No inicio do nosso código de exemplo temos a declaração import, este comando é responsável por indicar ao
compilador Java aonde ele deverá “procurar” pelos comandos utilizados no código (uma definição bem inicial).
A classe Scanner (responsável pela captura das informações digitadas no teclado) é definida dentro do pacote
util que está dentro do pacote java – veja a definição e uso de pacotes no Anexo A . Se, não informamos o
import correto o compilador irá apresentar um erro, pois, não será possível localizar a definição da classe
Scanner.
Em java temos duas formas básicas para criar comentários:
1) Comentários de apenas uma linha utiliza: // . Por exemplo, Figura 42:
Figura 42 - Exemplo de comentários de uma linha
2) Comentários de várias linhas ou bloco utiliza o conjunto: /* */ - Figura 43
Figura 43 - Comentário de bloco
Pág.: 41/94
Avançando pelo código vemos a declaração de uma classe: public class CMain. Não é objetivo do texto abordar
orientação a objetos, mas, para não ficarmos totalmente sem uma explicação podemos resumir este trecho
como:
 public – esta palavra chave indica que a classe a ser definida poderá ser acessada por qualquer outro
código que necessite chama-la ou seja e de acesso público
 class – como esperado esta palavra chave define que vamos criar uma classe e após esta palavra
chave temos o nome da classe propriamente dito.
Dentro da classe criada no exemplo tem mais coisas “estranhas”, temos a seguinte declaração:
public static void main(String[] args)
O que vem a ser isto? Bem, na linha acima temos a definição do chamamos de método (mais uma vez este
conteúdo está fora do escopo desse texto). Um método, em poucas palavras, definem ações que as classes
podem realizar – comportamento dos objetos. Todos nossos programas aqui terá que ter este método,
próprio assistente de criação de classes do Eclipse cria esta estrutura (ver Figura 37). Este é o método principal
(main do inglês), é o ponto de partida para execução do nosso código pela máquina virtual Java.
Como iremos trabalhar com uma abordagem não

orientada a objetos (um sacrilégio!) todo nosso
código vai estar sempre localizado dentro do método
MAIN (ver Figura 44).
É uma fonte de erro muito comum para os alunos

Figura 44 - Método MAIN começarem a codifica fora do método main, prestem
muita atenção no local em que o seu código será
introduzido. Isto irá poupar muita dor de cabeça.
Após a criação da classe temos o caractere “{“, no Java todo bloco de código deve ser envolvido entre um
conjunto de “{“ e “}”. Ou seja, para cada “{“ temos que ter um correspondente “}”.
Figura 45 - Uso de chaves para delimitar blocos de código
Outra questão importante na codificação do Java (herança do C/C++) é uso do caractere “;” como terminador
de instrução. Em Java o “;” finaliza uma idéia.
Figura 46 - Uso do ponto e vírgula para finalizar uma linha de código
Pág.: 42/94
Se olharmos a Figura 45 e compararmos com a Figura 46 podemos ficar em dúvida: Por que a instrução if não
tem “;” no final? A instrução if (com veremos mais frente) irá delimitar um bloco de código e por isso não
utiliza o terminador “;” – outras instruções de bloco (como os repetidores) tem o mesmo comportamento.
Uma boa prática (isto não é uma regra) é a endentação do código através do uso de espaços e tabulações. Isto
facilita a leitura e entendimento do código - Figura 47.
Figura 47 - Exemplo endentação de código
Depois de tudo isto dito, podemos retomar ao assunto de variáveis. As variáveis são usadas para armazenar
informações durante o processamento de programas. O Java usa nove tipos diferentes de tipos de dados -
Quadro 6.
Tipo Descrição
boolean Pode assumir o valor true ou o valor false
char Caractere em notação Unicode de 16 bits. Serve para a armazenagem de dados alfanuméricos –
armazenamento de um único caractere. Também pode ser usado como um dado inteiro com
valores na faixa entre 0 e 65535.
byte Inteiro de 8 bits. Pode assumir valores entre -128 a 127.
short Inteiro de 16 bits. Os valores possíveis cobrem a faixa de -2-15=-32.768 a 215-1=32.767
int Inteiro de 32 bits. Pode assumir valores entre -2.147.483.648 a 2.147.483.647.
long Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre -263 e 263-1.
float Representa números em notação de ponto flutuante normalizada em precisão simples de 32 bits
em conformidade com a norma IEEE 754-1985. O menor valor positivo representável por esse tipo é
1.40239846E-46 e o maior é 3.40282347E+38
double Representa números em notação de ponto flutuante normalizada em precisão dupla de 64 bits em
conformidade com a norma IEEE 754-1985. O menor valor positivo representável é
4.94065645841246544e-324 e o maior é 1.7976931348623157e+308
String O tipo string não é um tipo primitivo mais se comporta como. Este tipo é utilizado para armazenar
cadeias de caracteres como nomes, frases, palavras e etc.
Quadro 6 - Tipos de dados primitivos do Java
No exemplo abaixo temos um código que irá exibir os valores limites dos tipos de dados numéricos em Java,
como no quadro acima:
Pág.: 43/94
public class CMain {
public static void main(String[] args) {
System.out.println("Tipos de dados em Java: \n" +

"\nMenor Byte: " + Byte.MIN_VALUE +
"\nMaior Byte: " + Byte.MAX_VALUE +
"\nMenor Short Int: " + Short.MIN_VALUE +
"\nMaior Short Int: " + Short.MAX_VALUE +
"\nMenor Int: " + Integer.MIN_VALUE +
"\nMaior Int: " + Integer.MAX_VALUE +
"\nMenor Long: " + Long.MIN_VALUE +
"\nMaior Long:" + Long.MAX_VALUE +
"\nMenor Float: " + Float.MIN_VALUE +
"\nMaior Float: " + Float.MAX_VALUE +
"\nMenor Double: " + Double.MIN_VALUE +
"\nMaior Double: " + Double.MAX_VALUE);
Exemplo 1 - Limites dos tipos numéricos
Figura 48 - Resultado da execução do exemplo de limites de valores para tipos numéricos
A declaração de uma variável em Java, sempre é feita através da seguinte estrutura: <TIPO> <NOME
(IDENTIFICADOR>, por exemplo:
Ex. int i; => Declara uma variável do tipo inteira cujo o nome é i.
Para atribuirmos um valor a uma variável usamos o operador “=” (ou igual simples), como no exemplo da
Figura 49 - Atribuição de valores.
Pág.: 44/94
Figura 49 - Atribuição de valores
Na primeira linha temos a declaração da variável e na segunda linha temos a chamada inicialização da variável
(a primeira vez que ela recebe algum valor). Em Java não podemos “trabalhar” com uma variável sem antes
inicializa-la. Isto é devido ao fato de que quando declaramos uma variável, apenas separamos um espaço de
memória para seu uso, mas, qualquer que seja o valor que já exista nesse local ainda permanece lá (ou seja,
um lixo qualquer) - Figura 50.
Figura 50 - Exemplo de erro com uso de variáveis não inicializadas
O processo de declaração e inicialização pode ocorrer em apenas uma única linha:
int i = 10;
Exemplo 2 - Declarando e inicializando uma variável
Tipos numéricos
Com os tipos numéricos em Java: tipos inteiros (byte, short, int e long) e tipos de ponto-flutuante (float e
double) podemos realizar todas as operações:
Operação Descrição
= Operadores de atribuição
==, != Operadores de igualdade e diferença
<, <=, >, >= Operadores de desigualdade
+, -, *, /, % Adição, subtração, multiplicação, divisão e módulo.
+=, -=, *=, /=, %= Operadores de atribuição com adição, subtração, multiplicação, divisão e módulo.
++, -- Incremento e decremento
~ Operador lógico de negação
&, | Operadores lógicos E, OU
Quadro 7 - Operadores para tipos numéricos
Pág.: 45/94
O Java, assim como outras linguagens tem operadores que simplificam a escrita. Não existe nenhum ganho de
desempenho no uso deles e sim redução de escrita.
Operador simplificado Operação equivalente

x += 5 x=x+5
x -= y x=x-y
x *= 2 x=x*2
z /= 4 z=z/4
Quadro 8 - Comparação entre operadores
Abaixo mais um exemplo de código abaixo:
public class CMain {

byte j = 60;
short k = 24;
int l = 30;
long m = 12L;
long resultado = 0L;
resultado += j; // resultado = 60 (0 mais 60)

resultado += k; // resultado = 84 (60 mais 24)
resultado /= m; // resultado = 7 (84 dividido por 12)
resultado -= l; // resultado = -23(7 menos 30)
resultado = -resultado; // resultado = 23 ( -(-23) )
resultado %= m; // resultado = 11 (resto de 23 div. 12)
}
}
Exemplo 3 - Exemplo de utilização de operadores com tipos numéricos
System.Math
Além desses operadores evidentemente existem outras operações (mais complexas) que podem ser realizadas
com tipos numéricos. No Java estas operações são definidas dentro de uma classe especial chamada de Math.
Nela as operações são categorizadas da seguinte forma:
 Máximo e Mínimo;
 Potências e Raízes;
 Logaritmo;
 Arredondamentos e Valores Absolutos;
 Trigonometria;
 Números Randômicos.
Constantes
A classe Math possui duas constantes que são o Π (pi) e E (base de logaritmos naturais ou neperianos) cada
uma com o valor de 3,141592653589793 e 2.718281828459045, respectivamente.
public class ComprimentoCirculo {

float raio = 2.4f;
double comprimento = 2 * raio * Math.PI;
System.out.println(comprimento);
}
}
Exemplo 4 - System.Math constantes
Pág.: 46/94
Máximo e Mínimo
Como o título já sugere, a classe Math de Java possui dois métodos que retornam o maior e o menor valor de
seus argumentos. Esses métodos são max() e min().
public class MenorMaior {
float precoProdutoA[] = { 11.2f, 15.12f };
float precoProdutoB[] = { 19.7f, 20 };
System.out.println("O maior preço do produto A é " + Math.max(precoProdutoA[0], precoProdutoA[1]));
System.out.println("O menor preço do produto B é " + Math.min(precoProdutoB[0], precoProdutoB[1]));
}
}
Exemplo 5 - System.Math Min e Max

Potências e raízes
Podemos fazer cálculos de potência e raízes com facilidade usando os métodos disponíveis em Math.
 pow (base, expoente) - calcula a potência da base elevada ao expoente.
 sqrt (número) - calcula a raíz quadrada de um número
 cbrt (número) - calcula a raiz cúbica de um número
 exp (expoente) - calcula o valor da constante de Euler (E) elevado ao expoente
public class PotenciasRaizes {

System.out.println("1 MB tem " + Math.pow(2, 10) + " KB");
System.out.println("A raiz quadrada de 121 é " + Math.sqrt(121)
+ " e a raiz cúbica de 1331 também é " + Math.cbrt(1331));
}
}
Exemplo 6 - System.Math Potência e raiz quadrada
Logaritmo
Na classe Math encontramos funções para cálculo de logaritmo natual, na base de 10 e a soma do número
mais 1. Tais métodos são:
 log (número) - logaritmo natural de um número.
 log10 (número) - logaritmo natural de um número na base 10
 log1p (número) - logaritmo natural de um número somado a 1. Esse método retorna um resultado
mais confiável se o número em questão for muito próximo a 0 ou um número fracionado. Ou seja, o
resultado não é o mesmo entre os métodos log1p (0.1f) e log (1+0.1f).
public class Exemplo {

float nr = 0.1f;
System.out.println("Resultado 1: " + Math.log(nr+1));
System.out.println("Resultado 2: " + Math.log1p(nr));
}
}
Exemplo 7 - System.Math Logaritimo
Arredondamentos e Valores Absolutos

Formas de arredondar um de ponto-flutuante (float e double) transformando-o em um número inteiro e
também como obter o valor absoluto de qualquer número.
Pág.: 47/94
 abs (número) - retorna o valor absoluto do mesmo tipo do parâmetro (ex.: inteiro retorna int positivo,
decimal retorna float positivo, etc)
 ceil (decimal) - este método retorna o valor decimal do parâmetro sem a parte fracionada. Ex.: 2.1 será
2, 6.0 será 6, 10.8 será 10. Realiza o truncamento do número.
 floor (decimal) - este método retorna o primeiro inteiro após o valor decimal. Ex.: 2.1 será 3, 6.0 será
6, 10.8 será 11.
 round (decimal) - retorna o arredondamento aritmético do número decimal passado como parâmetro.

float nr = -5.75f;
System.out.println("Absoluto: " + Math.abs(nr) +
"\nInteiro mais baixo: " + Math.ceil(nr) +
"\nInteiro mais alto: " + Math.floor(nr) +
"\nArredondamento: " + Math.round(nr));
}
}
Exemplo 8 - Valores absolutos e arredondamentos
Trigonometria
A maioria da funções da classe Math são trigonométricas, ângulo em radianos.
 sin (ângulo) - seno
 cos (ângulo) – cosseno
 tan (ângulo) - tangente
 asin (ângulo) – arco seno
 acos (ângulo) – arco cosseno
 atan (ângulo) – arco tangente
 sinh (ângulo) – seno hiperbólico.
 cosh (ângulo) – cosseno hiperbólico.
 tanh (ângulo) – tangente hiperbólica.
 hypot (x , y) - retorna o valor da hipotenusa, ou, basicamente, a distância entre dois pontos
fundamentada na fórmula » [sqrt (pow(x, 2) + pow(y,2))].
 toRadians (ângulo) - retorna um valor aproximado de radianos de acordo com o ângulo medido em
graus.
 toDegrees (raio) - retorna um valor aproximado de graus de acordo com o ângulo medido em raios.
public class Hipotenusa {

double ponto1 = 30;
double ponto2 = 40;
System.out.println("A distancia entre o "
+ ponto1 + " e o " + ponto2 + " é "
+ Math.hypot(ponto1, ponto2));
}
}
Exemplo 9 - System.Math: Trigonometria
Pág.: 48/94
Números Randômicos
O método random() retorna um valor double em 0.0 e 1.0 (deve-se levar em contar que não é uma quantidade
infinita de números, uma vez que o double tem um limite de casas decimais. Para conseguirmos um valor
limite ou um alcance (comumente chamado de range) delimitado, devemos fazer pequenas operações
matemáticas. Essas operações são simples e podem ser resumidas da seguinte maneira.
 O limite inferior, ou valor inicial (start value) será sempre somado ao número randômico.
 O limite superior, ou alcance (range) será sempre o limite superior subtraído o limite inferior e
depois multiplicado ao número randômico.
Por exemplo, se quisermos que um número randômico sempre fique entre 5 e 10, procederíamos da seguinte
maneira:
1. O menor número possível é 5, portanto ele será nosso start value ou limite inferior.
2. O maior número possível é 10, então 10 será nosso limite superior.
3. Como temos ambos os limites (inferior e superior) devemos criar um alcance (range). Para obtermos
isso, subtrairemos o limite superior com o limite inferior (10-5=5).

int limiteInferior = 5;
int limiteSuperior = 10;
int alcance = limiteSuperior - limiteInferior;
double nrRandomico = Math.random();
System.out.println("O número randômico escolhido entre 5 e 10 foi "
+ Math.round(limiteInferior + nrRandomico * alcance));
}
}
Exemplo 10 - System.Math: Números randômicos
Compatibilidade entre tipos
É muito comum pensarmos que todos os tipos numéricos são iguais no sentido do que armazenar. Como foi
visto anteriormente, cada tipo numérico tem um limite de informação que pode ser armazenada, isto é devido
ao fato de as variáveis são posições de memória do computador e a mesma é limitada.
Tendo isto em conta, se tenho um tipo de dados inteiro simples (int) o espaço de memória separado para
armazenar este valor pode ser utilizado para armazenar valores do tipo short e byte, pois, requerem menos
espaço de memória do que o int. Mas, não
poderíamos armazenar um tipo long dentro do
espaço reservado para um int ou qualquer tipo
menor do que o mesmo. Uma boa dica é
sempre se perguntar se o tipo “cabe” dentro do
outro.
No exemplo ao lado (e isto já foi usado

anteriormente), na declaração da variável j, usei
o valor 10L para inicializar a variável. Bem, o
significa isto?
Figura 51 - Exemplos de compatibilidade de tipos

Pág.: 49/94
Para constantes numéricas ou literais (o valor constante é um valor que não se altera e valores informados
diretamente no código fonte é um exemplo, só será alterado se o código fonte for alterado) precisamos indicar
ao compilador qual tipo de dado deverá ser utilizado para armazenar o valor na memória (lembre-se que os
tipos de dados determinam entre outras coisas o espaço de memória reservado para o valor). Por padrão toda
constante inteira (números inteiros) são armazenados com int e todos os números com partes fracionárias são
armazenadas com double.
Para alterarmos este comportamento padrão do compilador podemos utilizar sufixos pré-definidos, na
linguagem para isto:
 Constantes inteiras l ou L – ex.: 32I ou 32L

 Float: f ou F. Ex.: 32f ou 32F
 Double: d ou D. Ex.: 32d ou 32D
O uso de sufixos é muito útil em relação a valores que são fixos ou escritos diretamente no código. Mas,
quando estamos trabalhando com variáveis?
A forma mais usual, é colocar na frente da variável o nome do tipo (entre parênteses) para o qual deseja-se
converter o conteúdo da variável :
double d = 3.213;
float f;
f = d; // Erro
f = (float)d; // OK
}
}
Exemplo 11 - Cast
Este tipo de conversão é também conhecido como sendo conversão explícita, ou seja, aquela em que
informamos de forma explícita qual conversão o compilador deverá realizar. Existe também a chamada
conversão implícita, aquela aonde o compilador realiza a conversão da “melhor forma possível”.
Conversões implícitas ocorrem principalmente quando existe alto nível de compatibilidade entre os tipos. Por
exemplo, ao se atribuir uma variável inteira de 32bits a uma variável inteira longa de 64 bits – aplicando a
regra de que um tipo “cabe” dentro do outro fica mais fácil para entender que se for o inverso teremos que
fazer uma conversão explícita.

int i = 10;
long j;
j = i; //OK
i = j; //Erro
i = (int)j; //OK - Apenas de conteúdo de J for inteiro de 32 Bits
}
}
Exemplo 12 - Cast
Dica: Os tipos em Java e o comportamento da linguagem em relação pode gerar uma situação inusitada
quando trabalhamos com a divisão numérica. Se, em uma operação de divisão ambos os operandos forem
Pág.: 50/94
inteiros o resultado da operação também será inteiro, ou seja, ocorrerá um truncamento do número se a
divisão não for inteira. Mas, se os operandos forem de tipos diferentes o resultado será do tipo de maior
precisão ou tamanho. Veja o exemplo:

int i = 1;
int j = 2;
System.out.println(i / j); // Resultado = 0

System.out.println(i / (double)j); // Resultado = 0,5
}
}
Exemplo 13 - Exemplo de cast para operação de divisão
Quando trabalhamos com tipos alfanuméricos, como por exemplo: String, podemos ter a seguinte situação:
O operador “+” quando está envolvido

public static void main(String[] args) { com tipo alfanumérico realiza uma
String str = "1001"; operação de concatenação e não de
str = str + 5;
adição. Então, ao se somar um valor
System.out.println(str); // Saída: 10015
} numérico o que é feito: o valor numérico
} sofre uma conversão implícita para um
Exemplo 14 - Conversão de tipo para string valor alfanumérico (o inteiro 5 vira o
caractere 5 no exemplo) e então é realiza a
concatenação.
E o inverso, é possível utilizar o conteúdo de uma variável string como sendo um valor numérico (isto será
muito utilizado quando estivermos desenvolvimento programas que obtenham valores digitados pelo
usuário)? Sim, é possível, mas nem sempre é possível a conversão direta para isto teremos que utilizar
algumas funções:
String str = "100";
System.out.println( Byte.parseByte(str) );
System.out.println( Integer.parseInt(str) );
System.out.println( Long.parseLong(str) );
System.out.println( Float.parseFloat(str) );
System.out.println( Double.parseDouble(str) );
}
}
Exemplo 15 - Exemplo de métodos para conversão de string para tipos numéricos
O que ocorreria se o conteúdo da variável str for incompatível em alguma conversão. Nesse caso teremos um
erro em tempo de execução e o programa irá ser abortado - Figura 52. Este tipo de erro é chamado de
exceção ou exception (não é escopo desse texto abordar este assunto – isto é está ficando muito frustrante!),
Pág.: 51/94
na Figura 53, temos um exemplo de como tratar de forma elegante este tipos de erros (existe muito mais
conteúdo para isto, mas, agora não é o momento).
Forma bem geral, e simples, todos os erros que ocorram dentro de um bloco try (tentativa) é capturada por
um bloco catch e o erro é informado através de um objeto do tipo Exception.
Figura 52 - Exemplo de falha entre conversão de tipos
Figura 53 - Exemplo de tratamento de exceções
Pág.: 52/94
Interagindo com usuários
Uma parte importante dos programas é entrada e saída de dados. Como pode ser percebido nos exemplo
anteriores o principal comando para saída (na tela de console) é o: println – este comando está dentro da
classe out que está no pacote System, por isso o escrevemos dessa forma: System.out.println. Como a
documentação do Java (ORACLE,2012) diz: fluxo padrão de saída. Ficando aberto e pronto para o uso.
Normalmente utilizando em aplicações padrões.
Como o próprio nome deixa claro, a classe out é responsável por rotinas de saída, no nosso caso (o que irá
abordar todo este texto) iremos utilizar as rotinas de saída no console. No Java podemos construir aplicativos
de janela, applets (para páginas html) e Web, mas, nosso foco são aplicativos de console.
Quais são as principais rotinas para impressão na console:
 print(<<texto>>): Imprime o texto sem gerar um nova linha. Um próximo comando print irá continuar
da posição de onde este parou.
 println(<<texto>>): Imprime o texto e gera uma quebra de linha. Um próximo comando print ou
println irá continuar da nova linha.

System.out.println("Saída Padrão ");
System.out.print("usando ");
System.out.print("o método ");
System.out.print("print");
}
}
Exemplo 16 - Exemplo de saída para console
Tanto para o método print ou println podemos passar qualquer tipo de variável que o mesmo irá realizar a
conversão para o tipo String e exibir na saída.
public class Exemplo{
int inteiro = 200;
float decimal = 0.5f;
char letra = 'J';
System.out.println ("Valor:" + inteiro);
System.out.println ("Valor:" + decimal);
System.out.println ("Valor:" + letra);
}
}
Exemplo 17 - Exemplo de saída para console
Podemos ainda informar (como parte do texto a ser exibido) caracteres especiais que serão interpretados
pelos comandos print e println da seguinte forma:
 \n - pula uma linha
Pág.: 53/94
 \t - cria uma tabulação (o mesmo que apertar a tecla TAB)

 \b - retorna o cursor um caractere
 \r - retorna o cursor ao início da linha

System.out.print("Algoritmos I:\t"); // cria uma tabulação
System.out.print("prof. Daniel Oliveira\n"); //pula uma linha
System.out.print("Sinistro!\r"); // cursor no início da linha
}
}
Exemplo 18 - Uso de caracteres de escape para saída no console
É possível ainda aplicar algum tipo de formatação na saída de valores numéricos, para isto deve ser utilizado o
método printf – imprimir formatando. Este método utiliza do que chamamos de placeholders ou espaços
reservados. Veja o exemplo:
System.out.printf("%d %(d %+d %05d\n", 3, -3, 3, 3);

System.out.printf("Formato Padrão de ponto flutuante: %f\n", 1234567.123);
System.out.printf("Ponto Flutuante com virgulas: %,f\n", 1234567.123);
System.out.printf("Formato padrão de ponto flutuante negativo: %,f\n", -1234567.123);
System.out.printf("Formatação de ponto flutuante negativo: %,(f\n", -1234567.123);
System.out.printf("Alinhando valores positivos e negativos:\n");
System.out.printf("% ,.2f\n% ,.2f\n", 1234567.123, -1234567.123);
Exemplo 19 - Uso do comando printf
O primeiro parâmetro passado para a função é uma string, dentro dessa string temos marcadores especiais
que são inicializados com caractere %, para cada marcador desse deve haver uma variável ou valor (listado
após a string) para ser colocado nessa posição (placeholder).
Os placeholders tem o seguinte formato: %[flags][width][.precision]conversion
 Flags:
o '-' : justificado a esquerda
o '^' : caixa alata
o '+' : valor sinalizado
o '0' : força zeros a direita ou esquerda
 Width: comprimento do número
 Precision: precisão do número – casas decimais
 Conversion:
o 'd': inteiro
o 'o': octal
o 'x': hexadecimal
o 'f': notação decimal para ponto-flutuante
o 'g': notação científica
o 'a': hexadecimal com expoentes
o 'c': caractere
o 's': string
Pág.: 54/94
o 'b': valor lógico "true" ou "false".
Mais um exemplo utilizando o printf como saída:
int a = 5, b = 15, c = 255;

double x = 27.5, y = 33.75;
System.out.printf("a = %d b = %x c = %o\n", a, b, c);

System.out.printf("x = %2$f y = %1$g\n", x, y);
System.out.printf("a = %3$d b = %1$x c = %2$o\n", a, b, c);
Exemplo 20 - Mais um exemplo de uso do printf
Além da saída precisamos de uma forma de obter as informações dos usuários. Para isto vamos trabalhar com
uma classe especial que é Scanner. Na Figura 54, temos um exemplo da utilização da classe Scanner. Como
esta classe está definida dentro do pacote util que por sua vez está definido no pacote java, é necessário
sempre a introdução da declaração import como
na linha 1.
Na linha 5 temos a construção padrão de uma

variável scan que é do tipo Scanner (classes
definem novos tipos!) e em seguida temos um
novo comando: new – de forma bem direta, este
comando é usado apenas com classes para criar
Figura 54 - Exemplo da classe Scanner os objetos (vou parar por aqui!), a linha 5 será
utilizada como uma “receita de bolo” e sempre a
construiremos dessa forma.
Na linha 7 temos a declaração de uma varável do tipo String

(variável Nome) que recebe o resultado da rotina next. Ao
executar esta linha de código será exibido um cursor no
console e o usuário poderá digitar o que desejar até que
pressione a tecla ENTER – ver Figura 55.
Figura 55 - Uso do método next da classe Scanner Quando se digita o Enter, todo os texto digitado é passado para
a variável Nome e na linha 8 o seu conteúdo é impresso na no
console .
Figura 56 - Uso da classe Scanner
Pág.: 55/94
E quando necessitarmos de obter valores numéricos? Classe Scanner tem rotina para isto, obtendo as
informações digitadas e tenta converter para o tipo especifico que necessitamos, caso não seja possível um
erro irá ocorrer (uma exceção).
import java.util.*;

Scanner scan = new Scanner(System.in);
System.out.print("Informe seu nome:");

String Nome = scan.nextLine(); //Obter uma frase inteira
System.out.print("Sua idade:");
int Idade = scan.nextInt(); //Obter um valor inteiro
System.out.print("Sua altura:");
double altura = scan.nextDouble(); //Obter um double
System.out.println(Nome);
System.out.println(Idade);
System.out.println(altura);
}
}
Exemplo 21 - Exemplo das rotinas da classe Scanner para obter dados numéricos
Além das rotinas acima, temos ainda outros para os tipos byte, long. Veja no Anexo B, informações sobre
como utilizar JOptionPane.
Pág.: 56/94
Exercícios
1) Faça um programa que leia três valores inteiros, e calcule e exiba a sua média ponderada. A primeira nota
tem peso 2, a segunda tem peso 3 e a terceira tem peso 5.
2) Realizarei uma viagem de vários dias em meu automóvel, e gostaria de saber a quilometragem média por
litro de gasolina. Para isto, anotarei a quilometragem no velocímetro ao sair de viagem, e depois ao
chegar. Também vou somar toda a gasolina que comprar para o carro. Você poderia fazer um programa
que me desse, com estes dados, quantos km fiz, em média, por litro de gasolina?
3) Faça um programa que leia o nome de um piloto, uma distância percorrida em km e o tempo que o piloto
levou para percorrê-la (em horas). O programa deve calcular a velocidade média em km/h, e exibir a
seguinte frase: A velocidade média de XX foi YY km/h, onde XX é o nome do piloto, e YY é a velocidade
média.
4) Em uma pizzaria, cada refrigerante custa R$1,80 e uma pizza mista grande custa R$25,00 mais R$ 3,50 por
tipo de cobertura pedida (queijo, presunto, banana, etc.). Uma turma vai à pizzaria e pede uma
determinada quantidade de refrigerantes e uma pizza grande com uma determinada quantidade de
coberturas. Faca um programa que calcula a conta e, sabendo que a será informada a quantidade de
pessoas, quanto que cada um deve pagar. Lembre-se dos 10% do garçom.
5) A conversão de graus Fahrenheit para Celsius é obtida pela fórmula abaixo. Faça um algoritmo que leia um
valor em graus Centígrados e imprima seu correspondente em graus Fahrenheit.
6) Fazer um programa que leia um número inteiro e mostre o seu triplo, sua metade, a sua raiz
cúbica, e por fim, o número elevado a potência fracionária 2/3.
7) Construa um algoritmo que, tendo como dados de entrada dois pontos quaisquer no plano,
P(x1,y1) e P(x2,y2), escreva a distância entre eles. A fórmula que efetua tal cálculo é:
8) Elaborar um algoritmo que lê 2 valores a e b e os escreve com a mensagem: "São múltiplos" ou

"Não são múltiplos".
9) Desenvolva um algoritmo que receba o valor de raio e calcule a área e comprimento da

circunferência
10) Faça um programa que receba um valor que é o valor pago, um segundo valor que é o preço do
produto e retorne o troco a ser dado.
11) Faça um programa que receba o valor do quilo de um produto e a quantidade de quilos do
produto consumida calculando o valor final a ser pago.
Pág.: 57/94
Estrutura condicional
Normalmente qualquer algoritmo apresenta algum tipo de condição para a sua execução, por exemplo, vamos
examinar o fluxograma da Figura 57 - Estrutura condicional aonde temos uma rotina que irá calcular a raiz real
Cálculo de Raiz Real
de um número. Não podemos calcular a raiz real de
qualquer número, é necessário verificar se o
número informado é positivo ou não.
Dependendo do resultado da pergunta dentro do

Obter valor
losango o nosso algoritmo tomará uma caminho ou
outro.
Estruturas condicionais impõem caminhos

Sim >= 0 ? Não
alternativos aos algoritmos, mas, sempre
dependente de uma condição lógica: verdadeiro ou
falso.
Exibe mensagem de
Calcula raiz
erro Iremos utilizar estruturas condicionais sempre
quadrada real quando for necessário realizar um ação ou não
realizar de acordo com um teste de condições que
resultarão em verdadeiro ou falso.
Fim
Exibe resultado
Figura 57 - Estrutura condicional
A instrução IF
No Java a estrutura condicional mais simples utiliza apenas um comando if (“se” em inglês - Exemplo 22).

int i = 5;
if (i == 5)
{
System.out.println("Valor igual a 5.");
}
}
}
Exemplo 22 - Estrutura IF clássica
Nesse exemplo temos uma estrutura clássica do comando if. O teste lógico realizado é se o conteúdo da
variável “i” é igual a cinco: i == 5. O operador relacional para teste de igualdade no Java (e em várias
Pág.: 58/94
linguagens baseadas no C) é o chamado double equal ou igual duplo (==) e não o igual simples (=) que é o
operador de atribuição.
O teste lógico do if vem logo em seguida ao comando e entre parênteses, depois do teste lógico temos um
bloco de código, e, como em Java todo bloco de código é iniciado com um abre chaves “{“ e finalizado por um
fecha chaves “}”. Repararam que não “;” no comando if?
Na realidade o comando if é formado pelo teste lógico e caso este teste for verdadeiro uma instrução é
executada. Sendo que essa instrução pode ser apenas uma única linha de código (nesse caso o conjunto de {} é
opcional) ou bode ser um bloco com várias linhas de código, com inclusive outras instruções condicionais.

int i = 5;
if (i == 5)
System.out.println("Valor igual a 5.");
}
}
Exemplo 23 - Exemplo do IF com apenas uma linha
Resumindo, se o teste lógico do comando if for verdadeiro, então a instrução seguida ao comando será
realizada. Podendo esta instrução ser apenas uma linha ou um bloco (delimitado pelo para de {}) de código.
Comparação de strings
Vimos que o operador de teste de igualdade é o “==”, este operador poder ser utilizado para todos os tipos de
dados vistos até agora com exceção da String. Deve-se ser usado o método equals para realizar a comparação
entre strings, veja o exemplo abaixo:

System.out.print("Informe uma cor");

String Cor = scan.next();
if (Cor.equals("azul"))
{
System.out.print("Minha cor preferida também é o azul.");
}
}
}
Exemplo 24 - Uso de equals para comparação de strings
No exemplo anterior comparamos o conteúdo da variável Cor com o valor “azul”. O método equals é sensível a
caixa, ou seja, ele diferencia maiúscula de minúsculas. Para comparações não sensíveis a caixa deve ser usado
o método equalsIgnoreCase.
Pág.: 59/94
import java.util.*;


if (Cor.equalsIgnoreCase("azul"))
{
}
}
}
Exemplo 25 - Exemplo de equalsIgnoreCase para comparação de string
A instrução Else
Bem, e se a condição de teste da instrução if for falsa? Caso seja necessário uma ação nessa situação existe a
declaração else (“senão” em inglês). Se a instrução else for usada em conjunto com a instrução if, a linha de
comando ou código de bloco (aqui vale os mesmos parâmetros da instrução if) será executada se a condição
for falsa.
import java.util.*;


if (Cor.equalsIgnoreCase("azul"))
{
}
else
{
System.out.print("A cor escolhida não foi o azul!");
}
}
}
Exemplo 26 - Exemplo de uso do Else
A instrução else sempre deverá ser utilizada em conjunto da instrução if. Mas, as instrução if, pode ser
utilizada sem a instrução else.
Pág.: 60/94
Aninhando a instrução if/else
Após uma instrução if ou else podemos ter uma linha de comando ou um bloco de comandos. Como as
instruções if são também comandos, podemos ter uma instrução seguida da outra, veja o exemplo.
import java.util.*;

System.out.print("Informe um inteiro entre 1 e 3:");
int Numero = scan.nextInt();
if (Numero == 1)
System.out.println("Você informou o número 1.");
else if (Numero == 2)
else if (Numero == 3)
else
System.out.println("Número inválido.");
}
}
Exemplo 27 - Exemplo e if/else aninhados
Usando operadores AND e OR
O expressão de teste da instrução if pode ser simples (como foi visto nos exemplos anteriores) ou pode ser
resultado de uma expressão bem mais complexa. Para a construção de expressões lógicas com mais de um
termos temos que usar os chamados conectivos lógicos:
 Operador AND = &&

 Operador OR = ||
Vamos imaginar um algoritmo que receba um número inteiro e verifica se o mesmo é maior ou igual a 10 e
menor ou igual a 100. Como ficaria a expressão para este teste?
Figura 58 - Exemplo de expressão lógica com AND
Pág.: 61/94
Figura 59 - Exemplo de expressões relacionais com AND
Vamos alterar o algoritmo para indicar se o número indicado é igual a 10 ou 100:
Figura 60 - Exemplo de operador OR
Pág.: 62/94
Abaixo temos a tabela da verdade para o operador AND:
Figura 61 - Tabela da verdade do operador AND
Abaixo temos a tabela da verdade para o operador OR:
Figura 62 - Tabela da verdade do operador OR
Pág.: 63/94
Declaração switch/case
O uso de if/else encadeados pode ser bem confuso para se manter o código fonte. Por exemplo, vamos
desenvolver um algoritmo que simule um menu de uma aplicação:
import java.util.*;

System.out.println("Menu");
System.out.println("\t 1 - Opção 1");
System.out.print("Informe uma opção:");
int opcao = scan.nextInt();
if (opcao == 1){
System.out.print("Opção 1 selecionada");
}
else
{
if (opcao == 2)
{
}
else
{
if (opcao == 3)
{
}
else
{
if (opcao == 4)
{
}
else
{
System.out.print("Operação inválida");
}
}
}
}
}
}
Exemplo 28 - Exemplo de uso de IF / Else encadeados
No exemplo acima é fácil notar que à medida que a quantidade de opções aumenta, mais intricado e difícil de
entender o código fica. Para situações como esta, é indicado o uso da estrutura switch/case. Nessa estrutura
Pág.: 64/94
um teste de igualdade é realizado em uma variável (switch) e para da possível valor dessa variável (case) é
realizado uma ação.
Além das palavras chaves switch e case, ainda compõe esta estrutura:
 break – usado dentro do bloco de código do case. Este comando indica que o processamento do
switch deve ser interrompido e a execução do código deverá continuar a partir da primeira linha após
o final do switch. Se, por exemplo, omitirmos um break, o comando case imediatamente após será
executado (mesmo que o conteúdo da variável não execute este case).
 default – este seria o comando else dessa estrutura e é opcional. Se o valor da variável de teste do
switch não corresponder a nenhum case, então, se houver um default definido, o código dentro do
default é executado.
import java.util.*;

System.out.println("Menu");
System.out.print("Informe uma opção:");
int opcao = scan.nextInt();
switch(opcao)
{
case 1:
System.out.print("Opção 1 selecionada.");
break;
case 2:
break;
case 3:
break;
case 4:
break;
default:
System.out.print("Opção inválida!");
}
}
}
Exemplo 29 - Exemplo de uso do switch / case
Duas coisas tem que ser consideradas ao usar o switch:
1) O switch trabalha apenas com os tipos primitivos: int, short, byte e char
2) Não é possível o uso de expressões booleanas (lógicas) no switch.
No Exemplo 30, temos um algoritmo mais complexo que para determinar a quantidade de dias do mês,
levando-se em conta se o ano é bissexto ou não.
Pág.: 65/94
import java.util.*;

System.out.print("Informe um mês:");
int mes = scan.nextInt();
System.out.print("Informe um ano:");
int ano = scan.nextInt();
int numDays = 0;
switch (mes) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDays = 30;
break;
case 2:
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || (ano % 400 == 0))
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Mês inválidos.");
break;
}
System.out.println("Número de dias = " + numDays);
}
}
Exemplo 30 - Uso do switch/case mais avançado
Pág.: 66/94
Exercícios
1. Faça um programa que verifique se um número é impar.
2. Faça um programa que receba o valor do salário de uma pessoa e o valor de um financiamento
pretendido. Caso o financiamento seja menor ou igual a 5 vezes o salário da pessoa, o programa
deverá escrever "Financiamento Concedido"; senão, escreverá "Financiamento Negado".
Independente de conceder ou não o financiamento, o programa escreverá depois a frase "Obrigado
por nos consultar."
3. Dois carros percorreram diferentes distâncias em diferentes tempos. Sabendo que a velocidade média
é a razão entre a distância percorrida e o tempo levado para percorrê-la, faça um programa para ler as
distâncias que cada carro percorreu e o tempo que cada um levou, e indique o carro que teve maior
velocidade média.
4. Faça um programa que leia o nome e idade de duas pessoas e imprima o nome da pessoa mais nova, e
seu ano de nascimento (o programa deve funcionar corretamente para qualquer que seja o ano atual).
5. Leia um nome e duas notas dadas a um aluno e imprima: nome, média e “aprovado”, “reprovado” ou
“recuperação”, de acordo com as regras abaixo:
 Reprovado, se média maior igual a zero e menor que 5;
 Recuperação, se média maior igual a 5 e menor que 7;
 Aprovado, se média maior igual a 7 e menor igual a 10.
6. Tendo como dados de entrada a altura e o sexo de uma pessoa, construa um algoritmo que calcule seu
peso ideal, utilizando as seguintes formulas:
 Para homens: (72.7 * Altura) - 58
 Para mulheres: (62.1 * Altura) - 44.7
7. Leia um salário bruto e imprima o salário bruto, o desconto e salário líquido, após os descontos do
imposto de renda, que será calculado da seguinte maneira:
Salário Imposto Dedução

Até 1.372,81 Isento
Acima de 1.372,81 até 2.743,25 15% 205,92
Acima de 2.743,25 27,5% 548,82
Pág.: 67/94
8. A loja Constrói em Partes produz dois tipos de hastes: cobre e alumínio. Cada haste de cobre é vendida
por R$ 2,00, e cada haste de alumínio é vendida por R$ 4,00. O desconto dado dependerá da
quantidade de hastes compradas, conforme tabela abaixo. Fazer um algoritmo para ler a quantidade
comprada de cada tipo de haste e imprima o total pago.
Quantidade comprada (duas hastes juntas) Percentual de descontos

Abaixo de 5 0
Entre 5 e 15 10
Entre 16 e 20 15
Acima de 20 20
9. Uma empresa de energia elétrica trabalha com 3 tipos de consumidores: I – Industrial; C – Comercial;
R – Residencial. Fazer um algoritmo para ler o tipo de consumidor (‘I’, ‘C’ ou ‘R’), a quantidade de
energia consumida, e calcular e imprimir qual será o valor pago. Para calcular o valor pago, verificar a
tabela abaixo.
Tipo de Consumidor Cálculo

Industrial 0.68 ∗ Consumo + 34
Comercial 0.37 ∗ Consumo + 45
Residencial 0.77 ∗ Consumo – 22
10. Faça um programa que receba 2 valores e retorne o maior entre eles.
11. Faça um programa que receba 4 valores e retorne o menor entre eles.
12. Faça um programa que receba 3 valores que representarão os lados de um triângulo e verifique se os
valores formam um triângulo e classifique esse triângulo como:
a. Equilátero (3 lados iguais);
b. Isósceles (2 lados iguais);
c. Escaleno (3 lados diferentes).
Lembre-se que: Em qualquer triângulo, tem-se a<b+c, b<a+c e c<a+b.
13. Utilize a estrutura if para fazer um programa que retorne o nome de um produto a partir do código do
mesmo. Considere os seguintes códigos:
 001: Parafuso;
 002: Porca;
 003: Prego;
 Para qualquer outro código indica: Diversos.
Pág.: 68/94
14. Um banco concederá um crédito especial aos seus clientes, variável com o saldo médio no último ano.
Faça um algoritmo que leia o saldo médio de um cliente e calcule o valor do crédito de acordo com a
tabela abaixo. Mostre uma mensagem informando o saldo médio e o valor do crédito.
Saldo médio Percentual
De 0 a 200 Nenhum crédito
De 201 a 400 20% do valor do saldo médio
De 401 a 600 30% do valor do saldo médio
Acima de 601 40% do valor do saldo médio
15. Um usuário deseja um algoritmo onde possa escolher que tipo de média deseja calcular a partir de
três notas. Faça um algoritmo que leia as notas, a opção escolhida pelo usuário e calcule a média.
a. Aritmética
b. Ponderada com pesos 3,3,4
3
c. Harmônica: 𝐻 = 1 1 1
( + + )
𝑁𝑜𝑡𝑎1 𝑁𝑜𝑡𝑎2 𝑁𝑜𝑡𝑎3
16. Um vendedor necessita de um algoritmo que calcule o preço total devido por um cliente. O algoritmo
deve receber o código de um produto e a quantidade comprada e calcular o preço total, usando a
tabela abaixo.
Código do Produto Preço unitário
1001 5,32
1324 6,45
6548 2,37
0987 5,32
7623 6,45
17. Escrever um algoritmo que lê a hora de início de um jogo e a hora do final do jogo (considerando
apenas horas inteiras) e calcula a duração do jogo em horas, sabendo-se que o tempo máximo de
duração do jogo é de 24 horas e que o jogo pode iniciar em um dia e terminar no dia seguinte.
Pág.: 69/94
Estruturas de repetição
Em muitas situações é necessário que nossos algoritmos repitam uma ou mais vezes um conjunto de
instruções. Por exemplo, o desenvolvimento de um algoritmo que irá ordenar uma lista de números inteiros.
Será necessário percorrer vários elementos dessa lista várias vezes até finalmente a mesma esteja ordenada
da forma como queremos. Chamamos de iteração a cada vez que a estrutura de repetição é executada.
As estruturas de repetição são formadas por duas partes lógicas: condição(expressão lógica) e o corpo
(conjunto de código que é executado a cada iteração) do loop. A condição é testada a cada iteração para
verificar se é necessária a execução do código contido no corpo do loop ou não.
Os loops podem ser categorizados da seguinte forma:
 Indeterminados
 Determinados
Nos loops determinados é possível saber quantas vezes ocorrerá à repetição. Já, os loops indeterminados a
sua execução é realizada enquanto uma determinada condição for verdadeira.
Os loops indeterminados podem ser classificados de duas formas:
 Pré-testados
 Pós-testados
Os loops pré-testados (ver Figura 63) verificam a condição antes de qualquer coisa, desta forma o código
contido dentro do corpo do loop poderá nunca ser executado caso a condição resultar em um valor falso.
Condição Executa o corpo do

Sim
verdadeira ? loop
Não
Figura 63 - Loop pré-testados
Pág.: 70/94
Os loops pós-testados (Figura 64) verificam a condição após a execução do código contido no corpo do loop.
Assim, nesse tipo de loop o corpo do loop é executado pelo menos uma vez.
Executa o corpo do
loop
Sim
Condição
verdadeira ?
Não
Figura 64 - Loop pós-testado
Loop While
Este é um tipo de loop do tipo pré-testado indeterminado, a sua estrutura básica é:
while(<Condição lógica>)
{
///Comandos
}
Exemplo 31 - Estrutura do Loop While
O termo while vem do inglês que traduzido é enquanto. Ou seja, enquanto uma determinada condição for
verdadeira execute o corpo do loop.
int x= 10;
while( x < 20 ){
System.out.print("x : " + x );
x++;
System.out.print("\n");
}
}
}
Exemplo 32 - Exemplo do loop while
Pág.: 71/94
Analisando o Exemplo 32, temos um código que irá imprimir na tela os valores da variável x de 10 até 19 (Por
que não 20? Veja a condição de teste do loop.).
Dica: Loops indeterminados tem uma característica que pode ser perigosa, eles podem simplesmente nunca
parar e entrar no que chamamos de loop infinito, bastando para isto que a condição de teste de parada
sempre seja verdadeira. Se, no exemplo anterior a linha de código que incrementa a variável x por omitida o
loop nunca irá parar.
Dica: Além do teste de parada retornar um valor falso, podemos realizar uma parada “forçada” da execução
do loop. Bastando para isto utilizar o comando break dentro do corpo do loop. Ao ser executado este
comando dentro do corpo do loop a execução do loop é para imediatamente e o a primeira linha
imediatamente após o loop é executada. Ver Exemplo 33.

int x= 10;
while( x < 20 ){
x++;
if (x % 2 == 0 && x >= 12)

break;
}
}
}
Exemplo 33 - Exemplo do uso do comando break dentro de um loop
Qual seria o resultado da execução do exemplo anterior?
Loop Do...While
No Exemplo 34, temos a estrutura desse loop. Este é um loop indeterminado (já vimos anteriormente qual o
significado desse termo) e pós-testado.
do
{
//Comandos
}while(<Condição lógica>);
Exemplo 34 - Estrutura do Loop Do...While
Se traduzirmos do inglês as palavras Do e While temos: Faça e Enquanto. Faça alguma coisa (o código dentro
do corpo do loop) enquanto alguma coisa for verdadeira (a condição lógica).
Pág.: 72/94
É fácil notar que nesse loop que o código no seu interior é executado pelo menos uma vez. Este tipo de loop é
muito útil em situações aonde queremos garantir que o código no interior do loop seja executado pelo menos
uma vez.

int x= 10;
do{
x++;
}while( x < 20 );
}
}
Exemplo 35 - Exemplo do Loop Do..While
No Exemplo 35, temos um código que irá imprimir números de 10 a 19 no console. Este exemplo faz a mesma
coisa que o Exemplo 32.
Dica: Na realidade tudo que fazemos com o loop while podemos fazer com loop do...while e vice versa.
Vamos analisar um exemplo um pouco mais complexo (ver Exemplo 36). Aqui temos um código que irá conter
quantos inteiros maiores do que zero o usuário informou.
1 import java.util.*;
2 public class Exemplo{

3 public static void main(String[] args) {
4 int conta = 0,valor;
5 Scanner scan = new Scanner(System.in);
6 do{
System.out.print("Informe um inteiro positivo e zero para encerrar:");
valor = scan.nextInt();
if (valor > 0)
{
conta++;
}
7 }while( valor != 0 );
8 System.out.print("Você informou " + conta + " números.");

9 }
10 }
Exemplo 36 - Uso do loop Do..While
Pág.: 73/94
A execução do loop é encerrada quando o usuário informa o valor zero. (linha 6). Ainda nesse exemplo vamos
analisar o seguinte:
1. O que ocorreria se a declaração da variável conta fosse feita dentro do corpo do loop?
2. Por que foi necessário inicializar a variável conta para zero?
3. O que ocorrerá se for informado um número inteiro negativo?
Vamos reescrever o código do exemplo anterior utilizando agora o loop while:
import java.util.*;

int conta = 0,valor = 1;
while ( valor != 0)
{
System.out.print("Informe um inteiro positivo e zero para encerrar:");
valor = scan.nextInt();
if (valor > 0)
{
conta++;
}
System.out.print("Você informou " + conta + " números.");

}
}
Exemplo 37 - Exemplo do loop do..while com loop while
Quais são as diferenças entre os dois exemplos?
Loop For
Até agora vimos loops categorizados como indeterminados, já este o loop for tem a seguinte estrutura:
for(inicialização; Expressão lógica; atualização)

{
//Comandos
}
A estrutura desse loop é bem diferente dos demais, aqui temos uma variável de controle do loop que deverá
ser inicializada, a cada iteração do loop será feito um teste lógico com ela e também a cada iteração esta
variável irá sofrer uma alteração do seu valor. Se, o teste lógico resultar em um valor falso o loop é encerrado.
Pág.: 74/94

for(int x = 10; x < 20; x++){
}
}
}
Exemplo 38 - Exemplo do loop FOR
No Exemplo 38, temos um código que irá imprimir os valores de 10 a 19. Podemos também utilizar a estrutura
do loop for para gerar contagens inversas, partindo de um valor superior ir decrementando a variável de
controle até atingir o limite inferior desejado – veja Exemplo 39.
for(int i=10;i>=0;i--)
{
System.out.println(i);
}
Exemplo 39 – Exemplo do loop FOR descrente
Em todos os exemplos vistos até agora com Loop for, a variável de controle é declarada e inicializada dentro
da declaração do loop, assim, esta variável só será “visível” dentro do corpo do loop. E, não poderá ser
acessada fora do bloco. Mas, nada impede que seja utilizada uma variável já declarada, reescrevendo o
exemplo anterior:
int i;
for(i=10;i>=0;i--)
{
System.out.println(i);
}
System.out.print("A variável i é visivel fora do loop:" + i);
Exemplo 40 - Exemplo de loop for com a variável de controle declarada fora do loop
Pág.: 75/94
Vamos a um exemplo um pouco mais complexo:

int num;
boolean isPrime = true;
System.out.print("Informe um número inteiro:");
num = scan.nextInt();
for(int i=2; i < num/2; i++) {

if((num % i) == 0) {
isPrime = false;
break;
}
}
if(isPrime)
System.out.println("Primo");
else
System.out.println("Não primo");
Exemplo 41 - Exemplo um pouco mais completo com loop For

fonte: http://www.java-samples.com
Pág.: 76/94
Exercícios
1) Construa um algoritmo que calcule o fatorial de um número inteiro positivo.
2) Codificar o algoritmo para imprimir os N primeiros números naturais pares
3) A conversão de graus Fahrenheit para centígrados é obtida pela fórmula C = 5/9 (F-32). Escreva
um algoritmo que calcule e escreva uma tabela de graus centígrados em função de graus Fahrenheit
que variem de 32 a 212 de 1 em 1. A tabela deverá ser semelhante à mostrada abaixo:
Graus Fahrenheit Graus Celsius
32 0
33 0.6
34 1.1
... ...
212 100
4) Escrever um algoritmo que calcule a média obtida por uma turma de "n" alunos na primeira prova
do semestre, onde o valor de n será informado pelo usuário.
5) Escrever um algoritmo que, dada uma sequência de valores inteiros e positivos, determine qual é a
média aritmética dos valores pares. O valor 0 (zero) indica o término dos dados de entrada, ou seja,
o programa termina quando for informado o valor 0(zero).
6) Codifique o algoritmo que leia dois números inteiro e positivo e apresente o resultado do
primeiro número elevado ao segundo número (exemplo: 24 = 2*2*2*2 = 16). Não utilizar o método
pow do package Math.
7) Escrever um algoritmo que lê um valor n e outro valor m, e calcula a tabuada de n de 1 até m.
Exemplo: Supor que o usuário informe os seguintes valores: n=8 e m=12. Então tem-se:
1x8=8
2 x 8 = 16
...
. . .
12 x 8 = 96
8) Fazer um algoritmo para calcular a soma de todos os múltiplos de 7 entre 100 e 500.
9) Faça um algoritmo que imprima os números inteiros decrescentes compreendidos entre 100 e 10.
10) Faça um algoritmo que imprima a tabuada do número 5 da seguinte maneira:
5x0=0
5x1=5
5x2=10
...
5x10=50
11) Faça um algoritmo que imprima a soma dos números ímpares compreendidos entre 10 e 100.
Pág.: 77/94
12) Codificar o programa abaixo, para que determine os valores de y, tal que y = (3+2x+6x²)
/(1+9x+16x²) para x variando de 1,0 até 5,0 em intervalos de 0,1 unidades
13) Faça um algoritmo que imprima o valor de S da seguinte série:
1 2 3 4 30
S     
60 58 56 54 2
14) Faça um algoritmo que imprima o valor de H da seguinte série:
1 3 5 7 99
H     
1 2 3 4 50
15) Faça um algoritmo que leia um número inteiro e positivo N e imprima o valor de S da seguinte
série:
S = 1 + 1/2 + 1/3 + ... + 1/N
16) Faça um algoritmo que imprima a soma dos 20 primeiros termos da serie abaixo, onde o
denominador representa o fatorial do número.
100 99 98 97
   
0! 1! 2! 3!
17) Programa para calcular e imprimir o volume e o raio da esfera com o raio variando de 1 a 10
usando a estrutura de repetição
18) Escreva um algoritmo para ler 2 valores (se o segundo valor informado for ZERO, deve ser lido
um novo valor, ou seja, para o segundo valor não pode ser aceito o zero – exibindo uma
mensagem de erro) e imprimir o resultado da divisão do primeiro pelo segundo.
19) Faça um algoritmo que leia a altura de 10 pessoas e imprima média destas alturas. Imprima
também quantas alturas maiores que 1.60 e quantas menores que 1.30.
20) Faça um algoritmo que leia os dados de cada empregado: nome, salário por dia e número de dias
trabalhados de uma firma de 10 empregados. Imprima o salário total a ser pago aos empregados
e a média dos salários.
21) Faça um algoritmo que leia a altura e o sexo de 100 pessoas e imprima:
- Quantos homens e mulheres foram medidas;
- Quantos homens acima de 1,70;
- A média das alturas das mulheres.
22) Codifique um algoritmo para determinar o maior número em N números diferentes dados.
Pág.: 78/94
23) Codifique um algoritmo para calcular e imprimir o menor dentre N valores lidos.
24) Faça um programa de que determinar quais números são primos entre os inteiros 1 e N. Aonde N
será informado pelo usuário.
25) Codificar um algoritmo que simule o jogo de adivinhação: o jogador 1 escolhe um número entre 1
e 10; o jogador 2 insere números na tentativa de acertar o número escolhido pelo jogador 1.
Quando ele acertar, o algoritmo deve informar que ele acertou o número escolhido pelo jogador
1 em x tentativas (quantidade de tentativas do jogador 2).
26) Supondo que a população de um país A seja da ordem de 98.000.000 de habitantes, com uma
taxa anual de crescimento de 3,5% e que um país B tenha uma população de
aproximadamente 200.000.000 habitantes com uma taxa anual de crescimento de
1,5%. Escreva um algoritmo que calcule iterativamente, quantos anos serão necessários para que
a população do país A, ultrapasse ou iguale a população do país B, mantidas as
taxas de crescimento.
27) Um determinado material radioativo perde metade de sua massa a cada 50 segundos. Dada a
massa inicial, em gramas, fazer um programa que determine o tempo necessário para que a
massa se torne menor que 0,5 grama. Escreva o massa inicial, a massa final e o tempo em horas,
minutos e segundos.
Pág.: 79/94
Arrays
Array ou arranjo é uma estrutura de dados que contém em seu interior um número fixo de valores e de
mesmo tipo. O tamanho de uma array é determinado no momento da sua criação e permanece constante
após a sua criação. São objetos que representam um agrupamento contínuo de posições de memória, sendo
que o tipo dos elementos contidos em uma array pode ser um tipo primitivo ou não - Figura 65.
Índice do
primeiro
elemento
0 1 2 3 4 5 6 7 8 9
Comprimento da Array é de 10 elementos
Figura 65 – Array com 10 elementos
Cada item dentro de uma array é chamado de elemento, e cada elemento de uma array é acessado através de
um índice. Sendo que o elemento inicial é indicado pelo índice zero – ver Figura 65.
1. int[] anArray;
2. //Alocando uma array com 10 elementos
3. anArray = new int[10];
4. //Inicializando a array
5. anArray[0] = 100;
6. anArray[1] = 200;
7. anArray[2] = 300;
8. anArray[3] = 400;
9. anArray[4] = 500;
10. anArray[5] = 600;
11. anArray[6] = 700;
12. anArray[7] = 800;
13. anArray[8] = 900;
14. anArray[9] = 1000;
Exemplo 42 - Exemplo de criação e inicialização de uma array
No Exemplo 42, temos um código que declara uma array (linha 1) , na linha 3 temos a alocação da array e a
partir da linha 5 a 14 temos o código aonde inserimos os elementos nas posições indicadas pelos índices.
É possível perceber que para declarar uma array é no formato: tipo[] – o conjunto “[]” indica que estamos
declarando uma array. Cada conjunto deste refere-se a uma dimensão da array. As arrays de apenas uma
dimensão têm também um nome especial: vetor.
Outros exemplos de declaração de arrays:
Pág.: 80/94
 byte[] anArrayOfBytes;
 short[] anArrayOfShorts;
 long[] anArrayOfLongs;
 float[] anArrayOfFloats;
 double[] anArrayOfDoubles;
 boolean[] anArrayOfBooleans
É possível também colocar o conjunto de colchetes na frente do nome da variável da array, assim: int
anArray[]; No Exemplo 43, temos outras formas de declarar e inicializar uma array.
int[] anArray = new int[10];

anArray[0] = 100;
anArray[1] = 200;
anArray[2] = 300;
int[] anArray2 = {
100, 200, 300,
400, 500, 600,
700, 800, 900, 1000
};
Exemplo 43 - Formas de inicializar uma array
Intrinsicamente o uso de array está vinculado ao uso de estruturas de repetição para percorrer os elementos
de uma array - Exemplo 44.
int[] anArray = new int[10];
for(int i=0;i<anArray.length;i++)
{
anArray[i] = i;
}
Exemplo 44 - Exemplo de acessar posições de uma arry por loop
No exemplo anterior, temos um loop do tipo for para percorrer uma array inicializando seus elementos. Mas,
na declaração do loop for temos algo interessante: anArray.length – esta propriedade especial da array
retorna a quantidade de elementos dessa array.
No Exemplo 45, temos um código que declara e inicializa uma array de char e a percorre exibindo seus
elementos na tela.
char[] myArray = { 'a', 'b', 'c' };
for (int i = 0; i < myArray.length; i++) {

System.out.println(myArray[i]);
}
Exemplo 45 - Percorrendo uma array de char
Pág.: 81/94
Abaixo temos outro exemplo, que utilizando um algoritmo simples ordena uma array com 10 elementos
aleatórios:
double[ ] nums = new double[10];
for(int i = 0; i < nums.length; i++) {

nums[i] = Math.round(Math.random( ) * 100);
}
for(int i = 0; i < nums.length; i++) {

int min = i; //indice do menor elemento
//Busca o menor elemento d i-ésima posição até o fim da array

for(int j = i; j < nums.length; j++) {
if (nums[j] < nums[min])
{
min = j;
}
}
// realiza a troca entre os elementos

double tmp;
tmp = nums[i];
nums[i] = nums[min];
nums[min] = tmp;
}
for(int i = 0; i < nums.length; i++){

System.out.println(nums[i]);
}
Exemplo 46 - Exemplo de uma rotina de ordenação de array
 A rotina do exemplo anterior é aplicável em qualquer situação ou conjunto de números?
Pág.: 82/94
Exercícios
1) Solicite ao usuário 5 números inteiros, guarde-os em um vetor e em seguida imprima-os na tela. Em

seguida conte quantos elementos são negativos e informes ao usuário.
2) Leia um vetor de 10 elementos e em seguida ache a posição do elemento de valor m (dado pelo
usuário) no vetor. Caso o elemento não exista no vetor informe ao usuário.
3) Faça um programa que carregue um vetor de seis elementos numéricos inteiros, calcule e mostre:
a. A quantidade de números pares;
b. Quais os números pares;
c. A quantidade de números ímpares;
d. Quais os números ímpares.
4) Faça um programa que carregue um vetor com dez números reais, calcule e mostre a quantidade de
números negativos e a soma dos números positivos desse vetor
5) Solicite ao usuário n números inteiros (onde n também é fornecido pelo usuário), guarde os em um
vetor e em seguida imprima-os na tela. Caso o n fornecido pelo usuário seja maior que o tamanho
máximo do vetor, peça para que ele digite um n menor.
6) Leia um vetor de 10 elementos e em seguida ache a posição do elemento m (dado pelo usuário) no
vetor. Caso o elemento não exista no vetor informe ao usuário.
7) Solicite ao usuário dois vetores de n números (n também é fornecido pelo usuário) e em seguida
calcule a soma dos vetores, elemento a elemento, em um terceiro vetor.
8) Leia um vetor com 20 elementos. A seguir, troque o primeiro elemento com o último, o segundo com
o penúltimo, etc, até o décimo com o décimo primeiro.
9) Faça um programa que obtenha N números (podem ser inteiros ou não). Após obter os N números,
seu programa deverá exibir o menor, o maior e a média dos valores informados.
10) Faça um algoritmo que leia a altura de moças inscritas em um concurso de beleza. Para finalizar será
digitado zero na altura. Imprima as duas maiores alturas.
11) Dada uma seqüência de n números, imprimi-la na ordem inversa à da leitura.
12) Faça um algoritmo que leia a altura de 1000 pessoas e imprima a maior, a menor, a média destas
alturas. Imprima também quantas alturas maiores que 1.60 e quantas menores que 1.30.
13) Fazer um algoritmo para ler 20 números reais e calcular e imprimir o desvio-padrão e a variância,
utilizando a seguinte fórmula:

1 N

N 1

xi  x 
2
Seguir os seguintes passos:
1. Calcular o valor médio .

Pág.: 83/94
2. Para cada valor xi , calcula-se a diferença entre xi e o valor médio .

3. Calcula-se o quadrado dessa diferença.
4. Encontra-se a soma das diferenças dos quadrados.
5. Divide-se este resultado pelo número de valores (N). Esta quantidade é a variância.
6. Tome a raiz quadrada deste resultado. Este novo valor é o desvio-padrão.
14) Dados dois vetores de n elementos, calcule o seu produto escalar. (O produto escalar de dois vetores
v1 e v2 é dado por: produto = v1[0]*v2[0]+ v1[1]*v2[1]+... +v1[n]*v2[n]).
15) Leia 2 vetores com 10 elementos cada. Considerando cada vetor como sendo um conjunto,crie um
terceiro vetor, que seja a união dos dois primeiros, e um quarto, que seja a intersecção entre os dois
primeiros.
16) Desenvolva um programa em Java que receba do usuário n números inteiros positivos (aonde n será
informado pelo usuário) e os armazene em um vetor. Para cada elemento desse vetor deverá ser
cálculo do fatorial e o resultado deverá ser armazenado em outro vetor. Depois imprima cada um dos
elementos de cada vetor.
17) Vetor suavizado é uma técnica utilizada para cálculos de configuração de cores, para 50 elementos
reais, conforme regra abaixo. Ler os valores do vetor V e calcular e imprimir o vetor suavizado S.
S[I]=(V[I-1]+V[I]+V[I+1])/3, se I <> 1 e I <> 50;
S[I]=(V[I]+V[I+1])/2, se I = 1;
S[I]=(V[I-1]+V[I])/2, se I = 50;
18) Construa um algoritmo que preencha um vetor com N elementos (aonde N será informado pelo
usuário) utilizando a série de Fibonacci. Após isto imprima o conteúdo do vetor na tela. Exemplo de
valores da série: {1,1,2,3,5,8,13,21,34,55,89,144,233,377,...}
Pág.: 84/94
Arrays multidimensionais
Até agora vimos arrays de apenas uma única dimensão, também denominados de vetores. Mas, podemos ter
os chamados arranjos de várias dimensões. Imagine que cada elemento de um vetor seja outro vetor, e cada
elemento desse vetor seja também outro vetor, e, assim por diante. Ou seja, arranjos com mais de uma
dimensão são na realidade arranjos de arranjos – ver Figura 66.
Arranjo
Multi
0 0 1 ... N
1 0 1 ... N
...
0 1 ... N
N
Figura 66 - Representação de uma array multidimensional
Quando o arranjo armazenado em cada elemento tem a mesma quantidade de elementos podemos ter uma
estrutura que é associada a uma matriz. Muitas vezes, arranjos multidimensionais são associados a matrizes,
mas, eles podem ter estruturas bem diferenciadas. Na Figura 67, temos a representação uma array com 3
linhas (vetor de três de elementos) e 5 colunas (cada elemento do vetor de 3 elementos é um arranjo com
cinco elementos).
Figura 67 - Representação de uma matriz
A declaração de uma matriz utiliza também os colchetes, assim como os vetores. Utiliza-se um par de
colchetes ([]) para cada dimensão a ser incluída na matriz. Por exemplo:
int minhaMatriz [][] = new int [3][5];
Pág.: 85/94
Na linha de código acima, temos o seguinte: uma array de inteiros (todos os elementos de todos arranjos
nessa array deverão ser inteiros). Sendo que teremos um arranjo de 3 elementos (linhas) e cada arranjo
alocado nesse arranjo será de 5 elementos (colunas).
Cada elemento no array a é identificado por uma expressão de acesso ao array da forma: a [ linha ] [coluna]:
Figura 68 - Acessando posições dentro de um arranjo bidimensional
Como os arrays unidimensionais, os arrays multidimensionais podem ser inicializados na sua declaração:
int[][] Matriz = {{1,2},{3,4}};
Os valores do inicializados são agrupados por linha entre chaves. O compilador conta o número de
inicializadores de array aninhados (representado por conjuntos de chaves dentro das chaves externas) na
declaração de array para determinar o número de linhas no array Matriz.
Pelo fato de arrays multidimensionais sejam arranjos de arranjos, podemos ter estruturas bem mais flexíveis:
int[][] b = {{1,2},{3,4,5}};
• Cria um array de inleiros b com dois elementos (determinados pelo número de inicializadores de array
aninhados) que representam as linhas do array bidimensíonal.
• Cada elemento de b é uma referência a um array unidimensional de variáveis int.
• O array da linha O (zero) é um array unidimensional com dois elementos (1 e 2)
• E o array da linha 1 é um array unidimensional com três elementos (3,4 e 5)
Pág.: 86/94
No Figura 69, temos um código mostrando uma forma de percorrer agora estes arranjos. Reparem que para
cada “dimensão” extra temos uma estrutura de repetição aninhada dentro de outra – mas uma vez, são
arranjos de arranjos.
Figura 69 - Percorrendo uma array multidimensional
Pág.: 87/94
Exercícios
1) Elaborar um algoritmo que lê uma matriz M(6,6) e um valor A e multiplica a matriz M pelo
valor A, exiba o resultado.
2) Escreva um algoritmo que lê uma matriz M(5,5) e calcula as somas:
a. Da linha 4 de M
b. Da coluna 2 de M
c. Da diagonal principal
d. De todos os elementos da matriz M
Escrever essas somas e a matriz.
3) Escrever um algoritmo que lê uma matriz A(5,5) e a escreva. Verifique, a seguir, quais os
elementos de A que estão repetidos e quantas vezes cada um está repetido. Escrever cada
elemento repetido com uma mensagem dizendo que o elemento aparece X vezes em A.
4) Escrever um algoritmo que lê uma matriz M(10,10) e a escreve. Troque, a seguir:

a. a linha 2 com a linha 8
b. a coluna 4 com a coluna 10
c. a linha 5 com a coluna 10.
Escreva a matriz assim modificada.
5) Faça um algoritmo que calcule a média dos elementos da diagonal principal de uma matriz
10 X 10 de inteiros.
6) Faça um algoritmo que gere a seguinte matriz:

111111
122221
123321
123321
122221
111111
7) Faça um algoritmo que leia uma matriz 4x9 de inteiros. calcule e mostre a soma das linhas
pares da matriz.
8) Faça um algoritmo que leia uma matriz 50x50 de números reais. A seguir, multiplique
cada linha pelo elemento da diagonal principal daquela linha. Mostre a matriz após as
multiplicações.
9) Faça um programa que leia duas matrizes 3x3 e realize a soma da duas e a multiplicação das mesmas.
Deverá ser exibido as duas matrizes originais, a matriz de soma e a matriz de multiplicação.
10) Escrever um algoritmo que lê uma matriz M(12,13) e divida todos os 13 elementos de
cada uma das 12 linhas de M pelo maior elemento em módulo daquela linha. Escrever a
matriz lida e a modificada.
11) Faça um programa em java tenha a saída como da imagem:

Pág.: 88/94
12) Suponha que você tenha uma array como da imagem abaixo:
Faça um programa em Java que irá produzir a transposição da mesma. Como a figura:
Pág.: 89/94
13) Faça um programa em Java que permita que dois usuários jogue o Jogo da Velha, a cada iteração de
forma alternada o jogador deverá indicar a posição a ser preenchida pelo “X” ou “O”. Por exemplo:
Os jogadores, de maneira, alternada deverá informar um número de 1 a 9

(representando cada posição da array). E, assim, sucessivamente até
termos um vencedor.
Exemplo, de sequência de ações:
Pág.: 90/94
Anexos
Anexo A
Hierarquia do Eclipse
1º) Workspace - é a área de trabalho que pode conter vários projetos (aplicações).
2º) Project - é um espaço que pode conter um agrupamento de pacotes (package).
3º) Package - agrupamento de classes afins - se não definido, usa o pacote default . Normalmente cada
programa seu ficará num Package;
4º) Class - uma classe escrita dentro de um arquivo. Normalmente, os primeiros programas são compostos
por apenas uma classe.
Criação do primeiro programa: Os seguintes passos mostram a criação do projeto, pacote e classe,
respectivamente nos botões:
Obs: se estes botões não aparecem, selecione a opção “Java” dentro do botão “Open Perspective” acima e à
direita.
Criação do projeto:
i Clique no botão “New Java Project” (ou selecione pelo menu: File - New - Project - Java Project - Next)
ii digite: ‘Programas Algoritmo I’ (primeira letra sempre em maiúsculo).
iii Finish
Criação do pacote:
i Selecione o projeto que acabou de ser criado (janela Package Explorer à esquerda)
ii Clique no botão “New Java Package” (ou selecione pelo menu: File - New - Package)
iii Digite: ‘exercicio01’ (primeira letra sempre em minúsculo).
iv Finish
Pág.: 91/94
Criação da classe:
i Clique no botão “New Java Class” - Class (ou selecione pelo menu: File - New - Class)
ii Em name digite: Principal, para o nome da classe (primeira letra sempre em maiúsculo).
iii Como esta classe é de execução final então ela deve possuir o método main( ). Para isto
marque a caixa: public static void main (String[] args)
iv Finish
v Aparecerá o seguinte código:
public class Principal {
/**
* @param args
*/
// TODO Auto-generated method stub
Pág.: 92/94
Anexo B
Uma outra forma de interagir com usuário (exibição de mensagens e obtenção de valores) é o
uso da classe JOptionPane. Esta é uma classe que faz parte da biblioteca swing do Java
(componentes visuais do Java).
Para utilizar esta classe para obter informações é necessário o uso do método
ShowInputDialog, que diferentemente do scanner todas as informações são retornadas em
string e devem ser convertidas para os tipos necessários.
Para utilizar esta classe é necessário o seguinte comando de import:
import javax.swing.JOptionPane;
String name = "";

int age = 0;
name = JOptionPane.showInputDialog(null, "Informe o seu nome: ");

age = Integer.parseInt(JOptionPane.showInputDialog(null, "Informe a idade: "));
JOptionPane.showMessageDialog(null,
"Oi " + name + ". Você tem "
+ age + " anos!");
Pág.: 93/94
Referências
CORMEN, Thomas H.; LEISERSON, Charles Eric.; RIVEST, Ronald L.; STEIN, Clifford. Algoritmos:
teoria e prática. Rio de Janeiro Campus, 2002. 916 p. ISBN 9788535209266
DEITEL, Harvey M.; DEITEL, Paul J. Java: como programar. 6. ed. São Paulo: Prentice Hall, 2005.
1110 p. ISBN 9788576050193
GOODRICH, Michael T.; TAMASSIA, Roberto,. Estruturas de dados e algoritmos em Java. 2. ed.
Porto Alegre, RS: Bookman, 2004. 584 p. ISBN 8536300434
Néki,Tecnhnologies; Eclipse User Guide. Disponível em:

http://hotwork.sourceforge.net/hotwork/manual/eclipse/eclipse-user-guide.html. Acesso em:
Janeiro, 2012
TIEXPERT,Programação Java. Disponivel em:

http://www.tiexpert.net/programacao/java/math.php. Acesso em: Janeiro,2012
TONET, Bruno; KOLIVER, Cristian. Introdução aos Algoritmos. Disponível em:

http://dein.ucs.br/napro/Algoritmo/manuais/ManualVisualg.pdf. Acesso em: Mar. 2004
ORACLE. Oracle Technology Network for Java Developers. Disponível em: <
http://www.oracle.com/technetwork/java/index.html>. Acesso em: 16 Agosto de 2011.
ZIVIANI, Nivio. Projeto de algoritmos : com implementações em Pascal e C. 4. ed. São Paulo:
Pioneira, 1999. 267 p. ISBN 8522101744
Pág.: 94/94

AlgoritmoI Apostila

Enviado por

Dados do documento

Descrição original:

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

AlgoritmoI Apostila

Enviado por

Direitos autorais:

Formatos disponíveis

2014

Daniel Barbosa de Oliveira

Figura 1 - Definição de algoritmo ............................................................................................................................ 8

Figura 43 - Comentário de bloco........................................................................................................................... 41

Quadro 1 - Símbolos para construção de fluxogramas ......................................................................................... 13

Exemplo 1 - Limites dos tipos numéricos.............................................................................................................. 44

Exemplo 45 - Percorrendo uma array de char ...................................................................................................... 81

Loop While .................................................................................................................................................... 71

“É qualquer procedimento computacional bem definido que toma

Entrada Algoritmo Saída

Figura 1 - Definição de algoritmo

Algoritmo 1: Bolo de Cenoura

1. Bata no liquidificador as cenouras, o açúcar, os ovos e o óleo até obter um creme.

 UCP – Unidade Centro de Processamento

Figura 2 - Arquitetura de Von Neumann

Figura 3 - Exemplo de instruções de máquinas

Figura 4 - Exemplo de um código em Assembly

2(𝑄𝑢𝑎𝑛𝑡𝑖𝑑𝑎𝑑𝑒 𝑑𝑒 𝐵𝑖𝑡𝑠 𝑑𝑜 𝑃𝑟𝑜𝑐𝑒𝑠𝑠𝑎𝑑𝑜𝑟)

Na Figura 5, vemos de forma geral o processo de compilação. Primeiro é criado o nosso

Figura 6 - Exemplo de um fluxograma

Símbolo Descrição Símbolo Descrição

Entrada de Dados Repetição

Quadro 1 - Símbolos para construção de fluxogramas

Figura 7 - Fluxograma para cálculo da área de um retângulo

Idade >= 18 Não

Maior de idade Menor de Idade

Figura 8 - Exemplo de um fluxograma para determinação da maior idade

Figura 9 - Atribuição de variáveis em Fluxogramas

Por exemplo, um fluxograma de cálculo de média final:

Figura 10 - Exemplo de fluxograma de cálculo de média nível Alto

Vamos agora, detalhar o processo de obtenção das notas:

Ainda temos que detalhar como a média é calculada:

Inicio Obter N1 Obter N2

Agora precisamos detalhar como é feita a determinação da aprovação:

Inicio Obter N1 Obter N2

SIM M >= 5 Não

Figura 11 - Exemplo de cálculo de média detalhado

Figura 12 - Exemplo de um diagrama linear

Figura 13 - Exemplo de sequência

Figura 14 - Exemplo de Estrutura condicional

Figura 15 - Exemplo de Estrutura de repetição

Figura 16 - Exemplo de Case

1) Decompor um diagrama em partes independentes

1) Dados os passos de cálculo abaixo montar um fluxograma para o mesmo

3) Monte um fluxograma e um pseudocódigo capaz de resolver o cálculo da área de um trapézio

7) Elabore um algoritmo que leia as variáveis C e N respectivamente código e número de horas

Trabalhando com expressões

OPERADORES ARITMÉTICOS OPERADORES

OPERADORES RELACIONAIS OPERADORES

Conjunção E (and) RETORNA VERDADEIRO SE AMBAS AS PARTES FOREM VERDADEIRAS.

Quadro 4 - Operadores lógicos

No quadro abaixo temos alguns exemplo do uso desses conectivos

A B A E B A OU B NÃO (A) A XOR V

Quadro 5 - Tabela verdade

Alguns exemplos de expressões lógicas:

Vamos ver alguns exemplos de uso utilizando pseudocódigo:

Se (salario > 180) e (salário < 800) Então

Se (idade < 18) ou (idade > 95) Então

Se (idade > = 18) e (idade < = 95) e (aprovado_exame = 'sim') Então

Mas algum exemplos de operações lógicas:

Para A = Verdadeiro, B = Falso e C = Falso, as expressões abaixo fornecem os seguintes resultados:

Modularização de expressões e precedência de operadores

((2 + 2)4 +8)/ 2 = 12 é diferente de 2 + 24 +8/ 2 = 14