Apostila de Fluxograma Programação Java

Prévia do material em texto

UNIVC FLUXOGRAMA Linguagem de Programação 
Prof: Douglas Tybel 
07/03/2012 
 
 2 
 
SUMÁRIO 
INTRODUÇÃO ................................................................................................... 3 
LÓGICA .............................................................................................................. 5 
ALGORITMOS ................................................................................................... 6 
REPRESENTAÇÃO ........................................................................................ 7 
Fluxograma convencional ............................................................................ 7 
USO DA INFORMACÃO .................................................................................. 14 
Regras de controle ........................................................................................ 14 
Exercício .................................................................................................... 15 
TIPOS DE DADOS ........................................................................................ 15 
DECLARAÇÃO DE VARIAVEL ..................................................................... 18 
EXPRESSÕES ............................................................................................. 19 
Expressões aritméticas .............................................................................. 19 
Expressões lógicas .................................................................................... 20 
Atribuição de dados ...................................................................................... 21 
CONSTRUÇÃO DE UM ALGORITMO ............................................................. 22 
Algoritmo sequencial ..................................................................................... 22 
algoritmo com seleção .................................................................................. 24 
Seleção simples ......................................................................................... 24 
Seleção composta ..................................................................................... 26 
Seleção encadeada ................................................................................... 27 
Seleção de múltipla escolha ...................................................................... 28 
Repetição contada ........................................................................................ 29 
EXERCÍCIOS ................................................................................................... 31 
RESPOSTAS ................................................................................................... 33 
REFERÊNCIAS ................................................................................................ 35 
 
 3 
 
INTRODUÇÃO 
 
Para entendermos um pouco mais sobre lógica de programação, vamos 
conhecer um pouco sobre a história de como tudo começou. Segundo 
(ANSELMO, 2005, p. 5), tudo se iniciou no ano de 1980 quando a palavra de 
ordem era “Codificação”. A maior preocupação era quanto ao escrever 
programas e, dos programas, escrever sistemas para computadores. Quanto 
mais, melhor. Linguagens como Fortran, Algol, Cobol, Pascal e C estavam no 
auge, e o programador era considerado “Amo e Senhor”. 
O mesmo autor continua a descrever que em uma escala rápida de 
desenvolvimento, no ano de 1985, os Dados passaram a ser objeto da 
atenção, descobriu a Structure Query Language (SQL) e ferramentas case 
passariam a “fazer” todo o trabalho da codificação de forma totalmente 
automatizada. 
Segundo (ANSELMO, 2005), em meados de 1990, o foco é na “Produtividade”, 
surgindo então o Client/Server e conceitos sobre Rapid Application 
Development (RAD) e, após cinco anos em 1995 todos os olhos se voltaram 
para “Performance” . Para resolver este problema, muitos conceitos surgiram, 
entre eles o nosso ponto de estudo aparece como modelo para a Orientação a 
Objetos, conceito este que foi iniciado em 1996. Modelos RADs já não servem 
mais solitariamente: nasce a plataforma e a linguagem Java. 
Ano 2000, o “Controle”, que se torna a palavra de ordem. Toda computação 
deve passar por fases definidas, nasce a Unified Model Language (UML) e 
rapidamente atinge nossas portas. Fases com definição, desenho, 
desenvolvimento, testes e implementação são esclarecidas e conhecidas 
(ANSELMO, 2005). 
Resumindo as fases seria a sequencia: 
 Codificação – 1980 / Pascal,C,Basic,Cobol 
 Dados – 1985 / SQL e Case com Acesso ao Banco de Dados 
 Produtividade – 1990 / RAD 
 Performance – 1995 / Computação Distribuída 
 Controle – 2000 / UML – Processo Unificado 
 4 
 
A nova palavra chave para o futuro é “Multi”, ambientes que possibilitem 
execução de diversos aplicativos, pois, diferentemente da computação 
distribuída, esses ambientes abrangem tecnologia Web e portal em um 
processo complemente descentralizado. Imagine o programador sem ir ao 
trabalho realizando todas as suas funções em casa. Em relação aos serviços 
Web, provavelmente, os Applications Servers irão dominar (ANSELMO, 2005). 
 
 5 
 
LÓGICA 
 
Segundo (BERG & FIGUEIRÓ, 2006, p. 14), a lógica, em geral, trata da 
correção do pensamento. Como filosofia, procura saber por que pensamos 
assim e não de outro jeito. Como arte ou técnica, nos ensina a usar 
corretamente as leis do pensamento. 
Pode-se dizer também que a lógica é a arte de pensar corretamente. Visto que 
a forma mais complexa do pensamento é o raciocínio, a lógica estuda ou tem 
em vista a “correção do raciocínio”. Pode-se ainda dizer que a lógica tem em 
vista a “ordem da razão”. Por isso, a lógica ensina a colocar ordem no 
pensamento. 
O autor ainda menciona o seguinte exemplo para lógica: 
 Todo nascido no Rio Grande do Sul é gaúcho. 
 Canoas é uma cidade do Rio Grande do Sul. 
 Portanto, todos que nascem em Canoas são gaúchos. 
Dessas premissas, assumimos então que é importante o uso da lógica no 
cotidiano tanto para escrita quanto para fala, uma vez que, para falar ou 
escrever corretamente é necessário colocar ordem no pensamento, isto é, 
utilizar a lógica. 
Infelizmente o computador é uma máquina completamente burra, então é 
necessário programá-lo para que faça o que mandamos, neste sentido, poderá 
ajudá-lo a resolver seus problemas. A tarefa de programar utilizando lógica 
consiste em passos determinados e ordenados, que ganham o termo “Passos 
Lógicos”, ou simplesmente, “Lógica” (ANSELMO, 2005). 
 
 
 6 
 
ALGORITMOS 
 
Algumas tarefas do nosso cotidiano são executadas através de passos 
sequencias. Partimos de um estado inicial, através de um período de tempo 
finito, e produzimos um resultado esperado e bem definido (BERG & 
FIGUEIRÓ, 2006). 
Dessas premissas, entende-se que devemos definir muito bem nossas 
variáveis de entrada para que possamos realizar o procedimento e chegar ao 
resultado desejado. Façamos uma comparação com uma receita culinária, 
naturalmente, não podemos iniciá-la sem antes termos em mãos os 
ingredientes, ponto crucial para dar inicio a nossa receita. 
Com uma receita em mãos, podemos encontrar todos os passos que 
descrevem como realizá-la, sendo assim, qualquer pessoa pode fazer a 
receita, sem necessidade de ser um cozinheiro. 
Esse passo a passo pode ser chamado de algoritmo, visto que, segundo 
(BERG & FIGUEIRÓ, 2006), pode-se redefinir: algoritmo é a descrição de um 
conjunto de ações que, obedecidas, resultam numa sucessão finita de passos, 
atingindo o objetivo. 
Em geral, um algoritmo destina-se a resolver um problema: fixa um padrão de 
comportamento a ser seguido, uma norma de execução a ser trilhada, com 
vistasa alcançar, como resultado final, a solução de um problema. 
 
De acordo com o mesmo autor, algumas qualidades de um bom algoritmo são 
as seguintes: 
a) Clareza: que as suas ações sejam expressas de forma clara e sem 
ambiguidade; 
b) Eficácia: deve chegar a um resultado final; 
c) Eficiência: deve obter um resultado com a melhor relação 
custo/benefício; 
 
 
 7 
 
REPRESENTAÇÃO 
 
Fluxograma convencional 
 
Podemos também usar algoritmos naturais para representação de uma tarefa, 
visto que, são algoritmos usados no cotidiano, descritos em uma linguagem 
natural, como por exemplo, a troca de uma lâmpada ou troca de um pneu. 
Em programação, a forma de representação por fluxograma possibilita um 
entendimento mais rápido e fácil do algoritmo, uma vez que, sua representação 
é gráfica com formas geométricas diferentes para todas as ações (instruções, 
comandos). 
Diferentemente do algoritmo natural, que dita passo a passo o que devemos 
fazer o fluxograma, desenha as ideias de forma a não possibilitar duplo 
entendimento, como podemos encontrar nos algoritmos naturais. 
Segundo (BERG & FIGUEIRÓ, 2006), os fluxogramas convencionais 
preocupam-se com detalhes de nível físico da implementação do algoritmo. Por 
exemplo, figuras geométricas diferentes são adotadas para representar 
operações de saída de dados realizadas em dispositivos distintos, como uma 
fita magnética ou um motor de vídeo. Como essa abordagem será feita 
somente com o nível lógico (o que fazer e como fazer) das instruções, será 
adotada a notação simplificada a seguir: 
 
 
= Início e final do fluxograma 
 
= Processo 
 
= Operações de atribuição e chamada ou 
retorno de subalgoritmo – Subfluxo. 
 
= Decisão 
 
= Operação de entrada de dados 
 8 
 
 
= Interação - operação de saída de dados 
 
= Usado para o comando de repetição 
contada 
 
= Comentário, usado para documentar o 
fluxograma. 
 
Vejamos na Figura 1 um exemplo de fluxograma para calcular a média de duas 
notas, assumindo N1 e N2 como variável que receberá os valores digitados 
pelo usuário. 
 
Figura 1: Exemplo de fluxograma – CalcularMedia(N1,N2) 
Fonte: Própria (2012) - Ferramenta: Bizagi 
 
De modo geral, um fluxograma se resume a um único símbolo inicial, pelo qual 
a execução do algoritmo começa, e um ou mais símbolos finais, que são 
pontos em que a execução do algoritmo se encerra (BERG & FIGUEIRÓ, 2006, 
p. 24). 
 
 9 
 
O computador ao ler os códigos de uma linguagem de programação, assumirá 
um ponto de partida e executará os comandos de cima para baixo, o 
processador não vai parar ou desviar, a não ser que a programação desvie 
certos blocos de comandos através de condições que o processador não vai 
considerar verdadeira, por exemplo: Vamos supor que você deseja executar as 
seguintes instruções: 
 
1. Declarar variável “N1” 
2. Declarar variável “N2” 
3. Armazenar em N1 o valor digitado pelo usuário 
4. Armazenar em N2 o segundo valor digitado pelo usuário 
5. Declarar variável “Media” 
6. Declarar variável “Soma” 
7. Somar N1,N2 e armazenar em “Soma” 
8. Dividir “Soma” por 2 e armazenar em “Média” 
9. “Media” é maior ou igual a 6 ? 
10. Se for, emitir mensagem “Aprovado” 
11. Senão, emitir mensagem “Reprovado” 
12. Terminar 
 
Observe que no item 8 da sequencia acima é calculado a Média, portanto, 
deseja-se emitir uma mensagem na tela caso a média seja superior a 6, veja 
que o item 9 apenas testa se o valor é maior ou igual a 6, caso seja, o 
processador, saltará a linha 10 e continuará na linha 11, quando este 
procedimento ocorre, chamamos de decisão. 
Uma decisão pode mudar o curso de leitura dos códigos do processador, 
fazendo com que o fluxo tome outros caminhos de acordo com as condições 
impostas. Neste sentido, se podemos mudar o curso da leitura do processador 
colocando o processador para testar condições e expressões, assumimos que 
podemos fazê-lo repetir uma quantidade de linha por uma quantidade de vezes 
que acharmos necessários, veja abaixo o exemplo: 
 
1. Declarar variável “TotalBolas” 
2. Declarar variável “QuantidadeChutes” 
 10 
 
3. Atribuir um “TotalBolas” como 15 
4. Atribuir ponto de partida de “QuantidadeChutes” igual a Zero (0) 
5. “QuantidadeChutes” é igual ao “TotalBolas” ? 
6. Se for, interagir “Acabou as Bolas” 
7. Senão, “Chute” mais uma bala e “QuantidadeChutes” incrementa 1 
8. Fim 
 
Observe que um comando chamado “Chute” será executado até que a 
“QuantidadeChutes” seja igual a “TotalBolas” totalizando 15 vezes que, o item 
7 será executado. 
 
Dessas premissas, vamos assumir a seguinte situação que, deseja-se calcular 
a média de duas notas, todavia, não será de apenas um aluno, mas de uma 
tabela. Para realizar tal tarefa, precisaremos “Varrer” a tabela registro por 
registro até seu fim e calcular a média para cada um. 
Para iniciarmos, assuma a tabela de Notas na Tabela 1 abaixo: 
 
Nome do aluno Nota 1 Nota 2 Média 
Nickson 10 8 
Tayana 10 7 
Kenia 9 10 
Arthur 10 5 
Léo 9 10 
Cleiton 10 9 
Tabela 1: Tabela de Notas 
 
Veja que o campo da Tabela 1 chamado “Média” está vazio, isso porque, após 
o calculo de média deseja-se que o campo da tabela seja preenchido. 
 
Vamos nos lembrar da receita culinária agora e nos questionar: “Quais os 
ingredientes que preciso para Calcular a média e salvar no campo chamado 
Média?” 
 
Vamos a lista de “Ingredientes”: 
 11 
 
1. Preciso de uma cópia da Tabela 1 que fica com o professor para eu 
poder iniciar. 
2. Preciso saber como calcular a média, isso porque, pode ser diferente de 
um professor para outro, então ele me passará como fazer o calculo das 
médias dos alunos dele. 
 
Nossa lista de ingredientes está pronta, então vamos por a mão na massa. 
1 FLUXOGRAMA PARA CALCULAR MÉDIA 
1.1 CALCULAR TODAS AS MÉDIAS DA TABELA DE NOTAS 
1.1.1 Elementos do processo 
1.1.1.1 Inicio do processo: 
1.1.1.2 Declarar TabelaNota 
1.1.1.3 TabelaNota = Tabela 1 
1.1.1.4 Declarar N1 
1.1.1.5 Declarar N2 
1.1.1.6 Declarar Media 
1.1.1.7 Existe registro TabelaNota ? 
1.1.1.8 N1 = ObterCampoTabela("Nota 1") 
1.1.1.9 N2 = ObterCampoTabela("Nota 2") 
1.1.1.10 Media = CalcularMedia(N1,N2) 
1.1.1.11 AtualizarCampoTabela("Média",Media) 
1.1.1.12 ProximoRegistro("TabelaNota") 
1.1.1.13 Fim 
 
 12 
 
 
Figura 2: Exemplo fluxograma - Calcular notas de uma tabela 
Fonte: Própria (2012) - Ferramenta: Bizagi 
 
 
A Figura 2 mostra um exemplo de fluxograma para calcular as notas de uma 
tabela de notas. Observe que o primeiro processo é a declaração da variável 
que armazenará uma cópia da tabela original, uma vez que, no segundo 
processo a variável “TabelaNota” recebe o conteúdo de uma consulta que 
retorna todas as notas da tabela de notas original, os próximos passos são 
declarar N1, N2 e Media, para que nós tenhamos onde colocar os valores 
quando obtido, naturalmente da tabela de notas que está na variável 
“TabelaNota”. Neste sentido, seguindo o fluxograma, o próximo passo é 
verificar se existe registro na tabela, uma vez que, se não houver registro, 
nosso fluxograma chega ao fim, portanto, caso tenhamos registro a variável N1 
recebe o conteúdo obtido na coluna “Nota 1” que de acordo com a Tabela 1 
seria o valor 10 e, logo após a N2 recebe o valor da coluna “Nota 2” com a nota 
sendo 8 para o aluno Nickson. As notas foram obtidas para ser enviadas como 
parâmetro N1 e N2, para o subfluxo chamado “CalcularMédia”, uma vez que, 
criamos acima sendo representado na Figura 1 – Exemplo de fluxograma – 
CalcularMedia(N1,N2). Observe que para o subfluxoseja executado é 
necessário passar dois valores, respectivamente a nota 1 e nota 2, assim, será 
realizado todos os passos conforme fluxograma de calcular média. 
 13 
 
Seguindo a ideia do subfluxo, basta ter como comparação a função de X, onde 
o X será a variável de entrada para a função. Temos F(x) onde F=x+2, então, 
F(2) é igual a 4, uma vez que, F=x+2 e x é igual a 2 então temos, F=2+2 = 4. O 
subfluxo CalcularMedia(N1,N2), solicita duas variáveis “x” como entrada, seria 
o N1 e N2, de modo geral, é como se fosse X1 e X2, assim, 
CalcularMedia(10,5) seria o mesmo que calcular (10+5)/2, visto que, na Figura 
1, nos mostra o calcula a ser executado no subfluxo. 
Após todo o calculo a variável “Media” recebe o resultado do subfluxo, isso 
porque, o próximo processo realizará a atualização da coluna “Média” da tabela 
com o valor calculado. Para que seja possível realizar os mesmo passos com 
os outros registros, será necessário passar para o próximo registro, para que 
todo o processo se repita até não haver mais registros. 
 
Nome do aluno Nota 1 Nota 2 Média 
Nickson 10 8 9 
Tayana 10 7 8,5 
Kenia 9 10 9,5 
Arthur 10 5 7,5 
Léo 9 10 9,5 
Cleiton 10 9 9,5 
Tabela 2: Tabela Notas com Médias calculadas 
Fonte: Própria (2012) 
 
Após a execução do fluxograma para cada registro da Tabela 1: Tabela de 
notas, o fluxo conforme Figura 2: Exemplo fluxograma - Calcular notas de uma 
tabela, foi executado, resultando na Tabela 2 – Tabela Notas com Médias 
calculadas e preenchidas na coluna Média. 
 
 
 
 
 14 
 
USO DA INFORMACÃO 
 
Segundo (BERG & FIGUEIRÓ, 2006, p. 33), todo o trabalho realizado por um 
computador é baseado na manipulação das informações contidas em sua 
memória. Essas informações podem ser classificadas em dois tipos: 
 
 As instruções, que são os comandos de funcionamento da máquina e 
determinam a maneira como devem ser tratados os dados; 
 Os dados propriamente ditos, em correspondem à porção das 
informações a serem processadas pelas instruções. 
 
INFORMAÇÃO = INSTRUÇÕES + DADOS 
 
Ao realizarmos uma declaração de variável, no mundo real é como se 
destacássemos uma folha de papel em branco para escrever algo 
temporariamente, mas algumas vezes, o papel pode ser muito pequeno para o 
queremos escrever, portanto, precisamos antes de escrever, escolher o papel 
adequado, de modo geral, é como se fossemos declarar o tipo de papel que 
queremos, para assim seu tamanho e formato se adequar ao que desejamos 
que este receba. 
Nas linguagens esses tipos de papeis, são chamados de tipos de dados, isso 
porque é a classificação dos dados de acordo com a informação contida nele. 
 
REGRAS DE CONTROLE 
 
As regras de controle podem ser Lineares, Decisórias e de Repetição. 
Segundo (ANSELMO, 2005, p. 11), as regras de controle são definidas 
conforme pontos abaixo: 
1. Instruções Lineares: São instruções diretas, normalmente te 
representadas por verbos, para que o computador execute-as, sem 
interrupção ou dúvidas, desde que, e obviamente, estejam corretas: 
 CRIAR variável numérica de nome índice 
 15 
 
 SOLICITAR valor numérico para o índice 
 ATRIBUIR a índice o valor solicitado 
 MOSTRAR índice 
 
2. Instruções Decisórias: Parte-se do principio de que: se determinada 
coisa acontecer, faça determinada instrução; em caso contrário, outra. 
 SE índice for igual a 0 
o ATRIBUIR a índice o valor 2 
 SENÃO 
o ATRIBUIR a índice o valor 3 
 
3. Instruções de Repetição: Repetição de um determinado conjunto de 
instruções enquanto algo seja verdadeiro. 
 ENQUANTO índice for menor que 10 
o ATRIBUIR a índice a soma do seu valor com 1 
 
Exercício 
 
1. Pegue uma bíblia e considere como verdade: Livro,Capítulo e Versículo. 
Usando apenas os seguintes comandos(Abra, Primeiro,Próximo,Leia e 
Feche), realise um algoritmo capaz de localizar a passagem: LUCAS 
14:33. 
2. Criar um fluxograma para efetuar a soma de dois números; 
3. Escreva um fluxograma para trocar uma lâmpada; 
4. Escreva um fluxograma para cuidar de uma planta; 
5. Escreva um fluxograma para informar se um número é par ou impar. 
6. Escreva um fluxograma que mostre como (a seu ver) funcionaria uma 
venda de livros pela Internet. 
 
TIPOS DE DADOS 
As informações tratadas em um algoritmo podem ser classificadas em dois 
tipos: 
 16 
 
 Constantes: Não sofrem alterações com o decorrer do fluxo, como por 
exemplo, PI = 3,1416. 
 Variáveis: Há possibilidade de serem alteradas em algum instante no 
decorrer do fluxo. Exemplo: Uma nota, valor, data, saldo e etc. 
Diante das situações de programação, as linguagens já têm como base os 
tipos primitivos, segundo (BERG & FIGUEIRÓ, 2006, p. 33), são: 
 Numérico – toda informação numérica que pertença ao conjunto dos 
números relativos (negativos, nulos, positivos), por exemplo, a quantidade 
de alunos de uma sala. Bem como toda a informação numérica que 
pertença ao conjunto dos números reais (negativos, positivos, nulos), por 
exemplo, o preço de um produto. 
 Caracter – toda a informação composta por um ou mais caracteres 
alfanuméricos (0..9,A..Z,a..z) e/ou caracteres especiais 
(#,/,$,%,*,?,~,>,!,@...). 
Obs.: o espaço é considerado caracter especial. 
 Lógico – toda a informação que pode ser assumir apenas duas situações 
(biestável, ou seja, dois estados). Exemplo: verdadeiro ou falso, aberto ou 
fechado. 
 
Existem alem dos tipos primitivos, a possibilidade de declarar variáveis de 
classe, isso é muito comum nas linguagens atuais, uma vez que, possibilita 
toda uma estrutura da classe através da variável, por exemplo: Em Java o tipo 
String é uma classe que substitui o uso de do tipo primitivo caracter. Se uma 
variável é declarada do tipo primitivo caracter, o seu conteúdo contempla o 
escopo informado em caracteres alfanuméricos, especiais e só, já a classe 
String possibilita a manipulação da informação lá contida, isso através dos 
métodos próprios da classe String, veja o exemplo deste uso: 
 
Transformar o conteúdo da variável em minúscula: 
1. String email = "DTYBEL@yahoo.com.br"; 
2. email.toLowerCase(); 
 
 17 
 
A variável “email” após a execução da segunda linha será convertida 
totalmente para minúscula, deste modo, sua saída será: dtybel@yahoo.com.br 
Continuando a mesma linha de raciocínio, para identificar um tipo de dado 
classe basta observar que a primeira letra é maiúscula, isso porque, as classe 
têm as inicias maiúsculas, veja algumas classes que não são tipos primitivos 
em Java: String,Integer,Float etc. Estas classes são chamadas de “Wrapper 
Class” 
Segundo (ANSELMO, 2005, p. 33), o principal método de utilização dos 
numéricos é o parseTipo.Então, convertendo uma String para os diversos tipos, 
por exemplo, teríamos: 
 
 byte a = Byte.parseByte(“1”); 
 short b = Short.parseShort(“1”); 
 int c = Integer.ParseInt(“1”); 
 long d = Long.ParseLong(“1”); 
 float e = Float.parseFloat(“1”); 
 double f = Double.ParseDouble(“1”); 
 
O autor mostra acima como converter o texto “1” em diversos tipos de valores 
através do método parseTipo das Wrapper Class. 
Para converter tipos primitivos, basta informar entre parênteses usando o 
método conhecido como “Casting”, seu novo tipo de retorno. 
Para integer: 
 long g = 10L; 
 int i = (int) g; 
Para Double: 
 double d = 10.99; 
 byte b = (byte)d; 
 
 
 
 18 
 
DECLARAÇÃO DE VARIAVEL 
 
Para que certa informação fique armazenada temporariamente e que possibilite 
acesso rápido, por sua vez, tendo a possibilidade de alteração e manipulação, 
usamos as variáveis. 
Segundo (BERG & FIGUEIRÓ, 2006, pp. 34-35),a declaração de uma variável 
consiste em: 
 nome que a diferencia das demais; 
 tipo de dado associado, que indica o tipo de informação que poderá ser 
armazenada na variável; 
 conteúdo, que é o dado guardado na variável; 
 endereço, que a localiza na memória; 
 
O autor faz observações relevantes sobre as variáveis: 
1) O nome de uma variável é único em um algoritmo. 
2) O conteúdo de uma variável poderá ser um dado todo tipo usado na sua 
criação. 
3) O conteúdo de uma variável é substituído por outro conteúdo que lhe 
venha a ser atribuído. 
4) O uso do nome de uma variável em uma expressão significa o uso do 
seu conteúdo (naquele momento) dentro da expressão. 
5) O uso de um conteúdo de variável em uma expressão não modifica seu 
valor. 
 
Para a declaração da variável, de modo geral, basta definir seu tipo e nome, 
onde se tem certa liberdade na nomenclatura, todavia, existem alguns limites 
básicos a serem observados para que sua variável não seja confundida com 
comandos internos. 
Cada linguagem de programação tem suas próprias regras para formação do 
nome de uma variável, de modo geral, a regra básica é: Nome de uma variável 
pode ser composto por letras sem espaço, dígitos e até mesmo o underline (_), 
sendo que o primeiro caractere deve ser uma letra. 
 19 
 
 
EXPRESSÕES 
 
Segundo (BERG & FIGUEIRÓ, 2006, p. 36), expressão, em termos 
computacionais, está intimamente ligado ao conceito de expressão (ou fórmula) 
matemática, em que um conjunto de variáveis e constantes numéricas 
relaciona-se por meio de operadores aritméticos, compondo uma fórmula que, 
uma vez aliada, resulta num valor. 
O autor (ANSELMO, 2005, p. 13), afirma que uma expressão constitui-se em 
um conjunto de variáveis e/ou valores, separados por caracteres especiais, que 
indicam as operações que devem ser executadas. Assim, a expressão: 
Valor_a + Valor_b + Valor_C 
Normalmente o valor resultado de uma expressão deve ser armazenado em 
uma variável para seu posterior uso. 
Dessas premissas percebe-se que a expressão é normalmente um calculo 
matemático ou uma comparação lógica, portanto, quando for calculo, seu 
retorno será o resultado do mesmo e quando for lógico, seu retorno será 
verdadeiro ou falso. 
 
Expressões aritméticas 
 
São aquelas cujo resultado da expressão é do tipo numérico, seja inteiro ou 
real. Somente o uso de operadores aritméticos e variáveis do tipo numéricas é 
permitido (BERG & FIGUEIRÓ, 2006). 
 
Abaixo na Tabela 3 os operadores aritméticos por ordem de prioridade. 
Operador Operação Prioridade 
( ) Parênteses mais internos 0 
* Multiplicação 1 
/ Divisão 1 
inteiro Quociente divisão inteira 1 
 20 
 
resto Resto divisão inteira 1 
+ Adição 2 
- Subtração 2 
Tabela 3: Operadores aritméticos 
Fonte: Adaptado (BERG & FIGUEIRÓ, 2006, p. 37) 
 
O operador “inteiro” retorna somente a parte inteira de um número e a resto, 
retorna o resto de um calculo. 
 
Expressões lógicas 
 
As expressões lógicas são aquelas cujo resultado da avaliação é um valor 
lógico, isso quer dizer (verdadeiro ou falso), de modo geral, a expressão 
precisa de uma verdade para continuar no fluxo, caso uma delas seja 
verdadeira e outra falsa, a expressão verificará todas as comparações 
considerando os operadores lógicos OU, E e NÃO, para definir se toda a 
expressão é verdadeira ou falsa. 
 
Operador Tipo Operação Prioridade 
NÃO Unário Negação 1 
E Binário Conjunção 2 
OU Binário Disjunção 3 
Tabela 4: Operadores lógicos 
Fonte: Adaptado (BERG & FIGUEIRÓ, 2006, p. 38) 
 
Para melhor estudo de como descobrir se uma expressão é verdadeira ou 
falsa, usa-se a tabela-verdade, isso porque, relaciona as opções e pode-se 
chegar a conclusão através de uma tabela. 
Há, ainda, outro tipo de operador que pode aparecer em operações lógicas: os 
operadores relacionais, mostrados a seguir: 
Operador Comparação 
= Igual 
<> Diferente 
< Menor 
 21 
 
> Maior 
<= Menor ou igual 
>= Maior ou igual 
Tabela 5: Operadores relacionais 
Fonte: Adaptado (BERG & FIGUEIRÓ, 2006, p. 39) 
 
Usamos operadores relacionais, quando necessitamos realizar comparações. 
Visto que comparações só podem ser realizadas com objetos do mesmo tipo 
de dado. 
ATRIBUIÇÃO DE DADOS 
De nada adianta usar variáveis sem atribuir valores a estas, neste sentido, a 
atribuição de dados é o comando que fornece um valor a certa variável. Este 
comando pode ser diferente ente as linguagens e não existe regra fixada, deste 
modo, para melhor compreensão, abaixo segue exemplo em duas linguagens 
distintas, que são: Pascal (Delphi) e Java. 
 
A sintaxe do comando de atribuição no Delphi é: 
 
Variável := expressão; 
Exemplo: 
X := 8+13/5; 
 
Em Java: 
Variável = expressão; 
Exemplo: 
X = 8+13/5; 
 
A diferença entre os comandos de atribuição de uma linguagem para outra é 
muito raro e, se for da mesma família, assim como C >> C++ >> Java, não há 
mudanças. 
 
 22 
 
CONSTRUÇÃO DE UM ALGORITMO 
 
Por mais que o algoritmo seja a organização lógica de um pensamento, que 
diferença faz para um computador? Essa questão é respondida com algoritmos 
traduzidos para a linguagem de máquinas, isso faz com que o computador 
interprete e execute os comandos de forma estruturada. 
Em ciência da computação, houve um processo de desenvolvimento 
simultâneo e interativo de máquinas (hardware) e dos elementos que 
gerenciam a execução automática (software) de uma dada tarefa, que estamos 
chamando de algoritmo (BERG & FIGUEIRÓ, 2006, p. 43). 
 
ALGORITMO SEQUENCIAL 
 
É definido por (BERG & FIGUEIRÓ, 2006, p. 43), como um conjunto de ações 
primitivas que serão executadas numa sequencia linear de cima para baixo e 
da esquerda para direita, isto é, na mesma ordem em que foram escritas. 
Evite usar em comandos ou nome de variáveis com acentuação ou espaços, 
procure montar suas expressões de forma a não dificultar sua compilação 
(tradução) para a linguagem da máquina. 
Vejamos abaixo representação de um fluxograma com algoritmo sequencial 
Figura 3. 
 23 
 
 
Figura 3: Exemplo algoritmo sequencial 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
 
 
 
Sua representação seria basicamente a seguinte: 
 
//Algoritmo nome do algoritmo 
Variaveis declaração de variáveis 
Inicio 
 Comando A 
Comando B 
(...) 
 Comando N 
Fim 
 
Exemplo: Escrever um algoritmo que leia as 2 notas de um aluno e calcule a 
sua média. 
 
//Algoritmo media 
 24 
 
Variáveis 
 numerico n1,n2, media 
inicio 
 ler n1 
 ler n2 
 media = (n1+n2)/2 
 escrever na tela “A méida é: “, media 
fim 
 
 
ALGORITMO COM SELEÇÃO 
 
 
Segundo (BERG & FIGUEIRÓ, 2006, p. 45), uma estrutura de seleção permite 
a escolha de um grupo de ações e estruturas a ser executado quando 
determinadas condições representadas por expressões lógicas, são ou não 
satisfeitas. 
 
Seleção simples 
 
O algoritmo com seleção simples tem o poder de mudar o fluxo dos processos, 
podendo saltar ações quando a condição não for satisfeita. 
 
Se condição então 
 Comandos (ação primitiva) 
Fim do se 
 
A condição terá como resultado um valor lógico verdadeiro ou falso, se a 
condição for verdadeira será executado o bloco um bloco de comando; caso 
 25 
 
contrário (condição falsa) encerra o comando (fim), pode-se ao final da 
condição falsa adicionar outra condição e então realizar mais verificações. 
 
Figura 4: Algoritmo seleção simples 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
//Algoritmo media 
Variaveis 
 Numérico n1,n2, media 
InicioLer n1 
 Ler n2 
 Media = (n1+n2)/2 
 Escrever “A média é: “, media 
 Se media >= 6 entao 
 Escrever “Aprovado!” 
 Fim se 
fim 
 
 26 
 
Seleção composta 
 
Descreve tanto as ações que serão executadas quando a condição for 
satisfeita como as ações que serão executadas caso a condição não for 
satisfeita. 
 
Figura 5: Seleção composta 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
//Algoritmo media 
Variaveis 
 Numérico n1,n2, media, pontos 
Inicio 
 Ler n1 
 Ler n2 
 Media = (n1+n2)/2 
 Se Media >= 6 entao 
 Escrever “A média é: “, media 
 Escrever “Aprovado!” 
 Senão 
 Escrever “A média é: “, media 
Escrever “Não aprovado” 
 27 
 
Pontos = 8 – Media 
Escrever “Faltaram ”, pontos, “ pontos para obter a média” 
 Fim se 
fim 
 
 
Seleção encadeada 
 
 
Segundo (BERG & FIGUEIRÓ, 2006, p. 49), quando, devido à necessidade de 
processamento, se agrupam várias seleções, forma-se uma seleção 
encadeada. Normalmente, essa seleção ocorre quando uma determinada ação 
ou bloco deve ser executado, satisfazendo um grande conjunto de 
possibilidades ou combinações de situações. 
 
Se condição 1 entao 
 Se condição 2 entao 
 Comando 1 
 Comando 2 
 (...) 
 Comando N 
 Senao 
 Se condição 3 entao 
 Comando 1 
 Comando 2 
 (...) 
 Comando N 
 Senao 
 Se condição 4 entao 
 Se condição 5 entao 
 CV (Comando verdade) 
 Senão 
 CF (Comando falso) 
 28 
 
 Fim se 
 Fim se 
 Fim se 
 Fim se 
Fim se 
 
Seleção de múltipla escolha 
 
Descreve ações que serão executadas de acordo com os resultados previstos 
para a variável de condição (BERG & FIGUEIRÓ, 2006, p. 51). 
 
Figura 6: Seleção de múltipla escolha 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
Faca caso 
Caso x = V1 : 
 Comando 1 
Caso x = V2 : 
 Comando 2 
Caso x = V3 : 
 29 
 
 Comando 3 
Caso x = V4 
 Comando 4 
Outro_caso : 
 Comando 5 
Fim_caso 
 
Para cada valor de V1, há um tratamento de possíveis valores e para cada 
situação seu bloco de comando distinto. 
 
REPETIÇÃO CONTADA 
 
As estruturas de repetição vistas normalmente são apropriadas para situações 
onde é difícil se determinar a quantidade de vezes que o bloco será chamado. 
Sabe-se que enquanto a expressão for satisfeita, sua repetição será realizada. 
Já para a estrutura de repetição contada, chamada de para em algoritmo, 
usamos quando sabemos a quantidade de vezes que um bloco será 
executado, usa-se para um bloco onde se é determinado um número finito de 
vezes. 
 30 
 
 
Figura 7: Exemplo repetição contada 
Fonte: Própria (2012) – Ferramenta: BizAgi 
 
Onde (BERG & FIGUEIRÓ, 2006, p. 76): 
 v é a variável de controle; 
 vi é o valor inicial da variável v; 
 vf é o valor final da variável v, ou seja, o valor até o qual ela pode 
chegar; 
 n é o incremento da variável de controle a cada repetição. 
 
//Algoritmo media para 
Variaveis 
 Numérico ma, acum, mat, v 
Inicio 
 acum = 0 
 para v de 1 até 50 passo 1 
 ler ma 
 acum = acum + ma 
 próximo 
 mat = acum /50 
 escrever “Média geral da turma = “, mat 
fim
 31 
 
EXERCÍCIOS 
01 – Você é o Analista de Sistema de uma empresa XXX. O gerente solicitou 
que na tela de cadastro do cliente apareça a informação relativa à idade. Ele 
deixou claro que a idade deve ser real, isso quer dizer que, mesmo para 
clientes que ainda não aniversariam, os meses deve ser considerado a fim de 
informar a idade exata na tela. 
 
Sua tarefa é desenhar um fluxograma para calcular a idade do cliente, tendo 
em vista que, terá em mãos apenas a data de nascimento. 
Resposta: 
Funções Disponíveis 
DiasEntreDatas(DataIni,DataFim) 
ObterParteInteira(Numero) 
Mensagem(Texto) 
ObterDataHoje() 
 
 
 
 
 
 
 
 
 
 
 
 
 
DiasEntreDatas – Retorna a quantidade de dias entre duas datas informadas. 
ObterParteInteira – Retorna apenas a parte inteira de um número, por exemplo: 
5,5. O retorno seria 5. 
Mensagem – Emite uma mensagem na tela. 
 32 
 
02 – Considere a Tabela 2 abaixo: 
 
Cliente Data Nascimento Idade 
Douglas Tybel 12/12/1982 
Ruth Passos 01/02/1983 
Venilton Tybel 20/08/1959 
Tabela 6: Tabela de Clientes 
 
Sua tarefa é usar sua função criada na questão anterior, chamada: 
CalcularIdade(DataNascimento). Passar cada registro da tabela, obter a 
informação contida no campo Data Nascimento, passar para a sua função e 
seu resultado deve ser salvo no campo Idade. 
Resposta: 
Funções Disponíveis 
CalcularIdade(DataNascimento) 
ExisteRegistro(Tabela) 
ObterCampoTabela(Tabela,Campo) 
SalvarCampoTabela(Tabela,Campo, 
NovoConteudo) 
Proximo(tabela) 
AbrirConsulta(Comando de seleção) 
AtualizarCampoTabela(campo, 
novoConteudo) 
 
 
 
 
 
 
 
 
 
 
 33 
 
03 – Descreva o algoritmo do fluxograma da questão número 1: 
Sua tarefa é descrever passo a passo o fluxograma, tenha como exemplo a 
questão número 5. 
 
Resposta: 
 
 
 
 
 
 
 
 
 
 
 
 
 
RESPOSTAS 
1. 
 
 34 
 
 
2. 
 
 
 
3. 
10 Calcular Idade 
10.1 Descrição do Fluxograma “Calcular idade” 
10.1.1 Processar cada Elemento conforme passos abaixo: 
10.1.1.1 Inicio 
10.1.1.2 Declarar variável "datNasc" 
10.1.1.3 datNasc = Data Nascimento obtida 
10.1.1.4 Declarar variável "datHoje" 
10.1.1.5 datHoje = ObterDataHoje() 
10.1.1.6 Declarar variável "diasVivivos" 
10.1.1.7 diasVivivos = DiasEntreDatas(datNasc,datHoje) 
10.1.1.8 Declarar variável "idade" 
10.1.1.9 idade = diasVividos/365,6 
10.1.1.10 idade = ObterParteInteira(idade) 
10.1.1.11 Mensagem("Sua idade é: "+idade+" anos") 
10.1.1.12 Fim 
 
 
 
 
 35 
 
REFERÊNCIAS 
 
ANSELMO, F. (2005). Aplicando Lógica Orientada a Objeto em Java (2ª ed 
ed.). Florianópolis: VisualBooks. 
BERG, A., & FIGUEIRÓ, J. P. (2006). Lógica de programação (3ª Edição ed.). 
Canoas: ULBRA. 
OLIVEIRA, M. R. (2005). Administração de Empresa com Access. São Paulo: 
Digerati Books.