Guia de Estudos da Unidade 4 - Lógica de Programação Algorítmica

Prévia do material em texto

Lógica de Programação 
Algorítmica
UNIDADE 4
1
Palavras do Professor
Olá, aluno(a)! Seja bem-vindo(a)!
Chegamos a quarta e última unidade da nossa disciplina Lógica de Programação, cujo conteúdo já 
apresentamos no vídeo de apresentação da disciplina. 
Na unidade anterior, relembramos os vetores e estudamos as matrizes.
Antes de prosseguir com esse texto, leia o capítulo 4 do livro-texto da disciplina. Depois disso, volte a este 
ponto para continuar o nosso estudo.
Agora que você já leu o quarto capítulo do nosso livro-texto, vamos iniciar os nossos estudos.
2
ordeNaNdo dados
Vamos relembrar o uso de vetores com um algoritmo que armazena os nomes de um grupo de pessoas 
(aproveite para inserir esse algoritmo no visualg e testar).
ALGORITMO “CARREGANDO NOMES”. 
VAR
I : inteiro
nomes :vetor[1..10] de 
literal Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nome da posição ” , i) 
 leia(nomes[i])
Fimpara 
FIMALGORITMO
Suponha que, após a entrada de dados, o vetor tenha ficado assim: 
nomes
Esses nomes foram guardados no vetor na ordem que foram digitados, ou seja, à medida que foram 
digitados eles foram carregados nas posições de 1 a 10 do vetor “nomes”. E se quiséssemos emitir uma 
listagem em ordem alfabética?
Naturalmente, precisaríamos ordenar esse vetor. 
Se ordenássemos o vetor, ficaria assim:
nomes
Vamos ver outro exemplo.
No algoritmo abaixo, vamos carregar as notas de 10 alunos.
ALGORITMO “CARREGANDO 
NOTAS.” VAR
I : inteiro
notas :vetor[1..10] de 
real Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nota da posição ” , i) 
 leia(notas[i])
Fimpara 
FIMALGORITMO
Ricardo Roberta Renata Maria Fátima Henrique Cecília Marta Edgar Yvette
1 2 3 4 5 6 7 8 9 10
Cecília Edgar Fátima Henrique Maria Marta Renata Ricardo Roberta Yvette
1 2 3 4 5 6 7 8 9 10
3
Após a entrada de dados, o vetor ficou assim: 
notas
Gostaríamos de emitir uma listagem decrescente por ordem de nota. Se ordenássemos o vetor, ficaria 
assim:
notas
Esse tipo de organização definida por alguma ordem é chamado de “ordenação”.
Existem várias formas de ordenar um vetor e vários algoritmos para isso. Esse é um assunto que vem 
sendo pesquisado há muitos anos e é um importante assunto de informática como um todo.
Vamos ordenar um desses vetores? Vamos utilizar o de nomes. Exibiremos abaixo cada um desses códigos. 
Primeiro vamos carregar esse vetor. Para isso, podemos utilizar o algoritmo anterior, que reproduzimos 
abaixo.
ALGORITMO “CARREGANDO NOMES”. 
VAR
 I : inteiro
 nomes :vetor[1..10] de literal
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nome da posição ” , i) 
 leia(nomes[i])
Fimpara 
FIMALGORITMO
Com esse algoritmo, estamos carregando os elementos do vetor. Precisamos, além disso, listar esses 
elementos. Para isso, inseriremos no código mais uma repetição cuja finalidade é fazer essa listagem. O 
código vai ficar assim:
ALGORITMO “CARREGANDO E LISTANDO NOMES”. 
VAR
I : inteiro
nomes :vetor[1..10] de literal 
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nome da posição ” , i) 
 Leia(nomes[i])
Fimpara
4 5 6,5 7,5 8 9 9,5 9,5 10 10
1 2 3 4 5 6 7 8 9 10
8 5 10 9 4 7,5 9,5 6,5 10 9,5
1 2 3 4 5 6 7 8 9 10
4
escreval(“listagem dos nomes inseridos no vetor”) 
Para i:=1 ate 10 faca
 Escreval(“nome da posição ” , i , “: “ , nomes[i]) 
Fimpara
FIMALGORITMO
Modifique o algoritmo que você inseriu no visualg para ficar igual ao que acabamos de mostrar, e execute 
usando a tecla F9.
Agora, vamos inserir um código que faz uma ordenação e depois explicaremos passo a passo. Vamos lá. 
Insira o algoritmo abaixo no Visualg.
ALGORITMO “CARREGANDO, ORDENANDO E LISTANDO NOMES”. 
VAR
I : inteiro
nomes :vetor[1..10] de literal 
aux : literal
trocou : literal 
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nome da posição ” , i) 
 Leia(nomes[i])
Fimpara
Escreval(“ordenando o vetor de nomes”) 
trocou := “v”
enquanto trocou = “v” faca 
 trocou := “f”
 para i := 1 ate 9 faca
 se nomes[i] > nomes[i +1] entao 
 aux := nomes[i]
 nomes[i] := nomes[i+1] 
 nomes[i+1] := aux 
 trocou := “v”
 fimse 
fimpara 
fimenquanto
escreval(“listagem dos nomes inseridos no vetor após ordenação”) 
Para i:=1 ate 10 faca
 Escreval(“nome da posição ” , i , “: “ , nomes[i])
Fimpara 
FIMALGORITMO
5
Você inseriu e executou esse algoritmo? Percebeu que ele ordena nomes? Legal, não é? Agora vamos 
fazer essa mesma ordenação com as notas.
ALGORITMO “CARREGANDO, ORDENANDO E LISTANDO NOTAS”. 
VAR
I : inteiro
notas :vetor[1..10] de real 
aux : real
trocou : literal 
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nota da posição ” , i) 
 Leia(notas[i])
Fimpara
escreval(“ordenando o vetor de notas”) 
trocou := “v”
enquanto trocou = “v” faca 
 trocou := “f”
 para i := 1 ate 9 faca
 se notas[i] > notas[i +1] entao 
 aux := notas[i]
 notas[i] := notas[i+1] 
 notas[i+1] := aux 
 trocou := “v”
 fimse 
fimpara 
fimenquanto
escreval(“listagem das notas inseridas no vetor após ordenação”) 
Para i:=1 ate 10 faca
 Escreval(“nota da posição ” , i, “: “ , notas[i])
Fimpara 
FIMALGORITMO
Aqui vimos algumas diferenças. Enquanto “nomes” é literal, “notas” é real.
A variável AUX, que é auxiliar em ambos os algoritmos, é literal no algoritmo de “nomes” e real no 
algoritmo de “notas”. Isso faz sentido, já que a variável auxiliar funciona com a finalidade de ajudar a 
ordenação. Agora vamos explicar cada ponto desse algoritmo. Vamos lá.
Primeiro as variáveis. Vamos reproduzi-las abaixo:
6
VAR
I : inteiro – essa variável é usada para percorrer o vetor. 
notas : vetor[1..10] de real – é o vetor de notas.
aux : real – é uma variável para ajudar na troca de valores entre células vizinhas no vetor.
trocou : literal – é uma variável que sinaliza quando houve troca no vetor. Essa variável é importante para 
sinalizar que o vetor precisa ser percorrido novamente.
Em seguida, a leitura dos dados:
Para i:=1 ate 10 faca
 Escreval(“informe nota da posição ”, i) 
 Leia(notas[i])
Fimpara
Nesse trecho, o algoritmo não tem nada de novo, ou seja, é a velha leitura de dados via teclado que já 
conhecemos.
Mas logo abaixo desse trecho, vemos o código para ordenação. Esse código abaixo é uma variante 
simplificada da ordenação por “bolha”, cujo código você encontra na página 104 do nosso livro-texto.
O código apenas de ordenação segue abaixo:
escreval(“ordenando o vetor de notas”) 
trocou := “v”
enquanto trocou = “v” faca 
 trocou := “f”
 para i := 1 ate 9 faca
 se notas[i] > notas[i +1] entao 
 aux := notas[i]
 notas[i] := notas[i+1] 
 notas[i+1] := aux 
 trocou := “v”
 fimse 
fimpara
Vamos explicá-lo agora.
Primeiro vamos ver a variável “trocou”. Ela é uma variável “flag”, ou seja, um sinalizador utilizado para 
informar se é necessário varrer o vetor novamente.
Ela é responsável, portanto, pela ativação do trecho de ordenação. Se ela estivesse “f”, a ordenação não 
aconteceria. Observe que logo depois do comando “trocou := “v” “ temos o comando “enquanto trocou 
= “v” faca”.
7
O comando “enquanto trocou = “v” faca” abre uma repetição indeterminada que só acabará, ou seja, será 
encerrada, quando trocou passar a ser igual a “f”. Portanto, essa é uma variável que controla a varredura 
e troca que fazemos nessa ordenação.
A seguir, temos esse trecho de programa:
para i := 1 ate 9 faca
 se notas[i] > notas[i +1] entao 
 aux := notas[i]
 notas[i] := notas[i+1] 
 notas[i+1] := aux 
 trocou := “v”
 fimse 
fimpara
Por qual motivo ele vai até 9 e não até 10? Explicaremos a seguir.
Nesse tipo de ordenação, vamos do primeiro até o penúltimo elemento comparando com o vizinho do 
lado. Ou seja, cada elemento notas[i] é comparado com notas[i+1], ou seja, notas[1] é comparado com 
notas[2], depois notas[2] é comparado com notas[3] e assim por diante, até que notas[9] seja comparado 
com notas[10].
Nessa varredura, faremos a troca da seguinte forma:se notas[i] for maior do que notas[i+1], eles vão 
trocar de lugar. Como isso será feito? Será através dos comandos abaixo:
se notas[i] > notas[i +1] entao 
 aux := notas[i]
 notas[i] := 
 notas[i+1] 
 notas[i+1] := aux 
 trocou := “v”
fimse
Ou seja, se notas[i] for maior do que notas[i+1] , guardaremos o valor de notas[i] na variável aux, copiaremos 
o valor de notas[i+1] em notas[i] e por fim, copiaremos o valor de aux na variável notas[i] vamos ver essa 
troca representada de forma visual.
Na figura abaixo, vemos uma parte do vetor (os elementos da primeira e segunda posição):
notas
Vemos que é necessário ordenar esse vetor, já que a notas[1] = 9,5 é maior do que notas[2]= 7,0.
Para fazer a troca, precisamos de um auxiliar, pois não podemos simplesmente fazer assim:
9,5 7,0
1 2
8
notas[1] := notas[2]
Se fizéssemos isso, o vetor ficaria assim: 
notas
Ou seja, perderíamos o conteúdo de notas[1], já que o de notas[2] seria copiado sobre ele.
Então, antes de fazer a cópia, temos que salvar o conteúdo de notas[1] numa variável auxiliar.
Para fazer isso, é simples, basta usar o auxiliar como vemos abaixo:
aux := notas[i] , uma vez que i é igual a 1 nesse momento.
Com isso, podemos copiar o conteúdo de notas[2] sobre o de notas[1], com o seguinte comando:
notas[i] := notas [i + 1]
E para finalizar, basta copiar o conteúdo de aux em notas[2] , assim:
notas[i+1] := aux
E por fim, precisamos sinalizar que houve uma troca e, por esse motivo, usamos o comando abaixo:
trocou := “v”
Dessa forma, o trecho que realiza a ordenação fica assim:
escreval(“ordenando o vetor de notas”) 
trocou := “v”
enquanto trocou = “v” faca 
 trocou := “f”
 para i := 1 ate 9 faca
 se notas[i] > notas[i +1] entao 
 aux := notas[i]
 notas[i] := notas[i+1] 
 notas[i+1] := aux 
 trocou := “v”
 fimse 
fimpara
Interessante, não é? Se você ainda não inseriu o código completo no Visualg para testar, faça isso agora 
mesmo. A melhor forma de entender o funcionamento de um algoritmo é ver esse algoritmo funcionando.
7,0 7,0
1 2
9
Se você realizou esse teste, então vamos em frente.
Suponha agora o seguinte caso: você agora vai usar 2 vetores, e não 1 apenas.
Vamos armazenar, em 2 vetores, os nomes e notas dos alunos. O algoritmo simples, sem ordenação, fica 
assim:
ALGORITMO “CARREGANDO E LISTANDO NOMES E NOTAS”. 
VAR
I : inteiro
nomes :vetor[1..10] de literal 
notas :vetor[1..10] de real 
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nome da posição ” , i) 
 leia(nomes[i])
 Escreval(“informe a nota de “, nomes[i]) 
 leia(notas[i])
Fimpara
escreval(“listagem dos nomes e notas dos alunos”)
Para i:=1 ate 10 faca
 Escreval(“nome : “ , nomes[i], “ tirou “, notas[i]) 
Fimpara
FIMALGORITMO
O algoritmo acima, apenas carrega os 2 vetores e lista. E para ordenar, como faríamos?
Vamos observar isso no algoritmo abaixo. Insira esse algoritmo no Visualg e teste, como sempre fazemos.
ALGORITMO “CARREGANDO, ORDENANDO E LISTANDO NOMES E NOTAS”.
VAR
I : inteiro
nomes :vetor[1..10] de literal 
notas :vetor[1..10] de real 
auxnomes : literal
auxnotas : real 
trocou : literal 
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe nome da posição ” , i) 
 leia(nomes[i])
 Escreval(“informe a nota de “, nomes[i]) 
 leia(notas[i])
Fimpara
10
escreval(“realizando a ordenação dos vetores”) 
escreval(“ordenando o vetor de notas”)
trocou := “v”
enquanto trocou = “v” faca 
 trocou := “f”
 para i := 1 ate 9 faca
 se notas[i] > notas[i +1] entao 
 auxnotas := notas[i]
 notas[i] := notas[i+1] 
 notas[i+1] := auxnotas 
 auxnomes := nomes[i] 
 nomes[i] := nomes[i+1] 
 nomes[i+1] := auxnomes 
 trocou := “v”
 fimse 
fimpara
escreval(“listagem dos nomes e notas dos alunos”)
Para i:=1 ate 10 faca
 Escreval(“nome : “ , nomes[i], “ tirou “, notas[i]) 
Fimpara
FIMALGORITMO
Observando esse algoritmo e comparando com o anterior, qual a diferença que você encontrou? A 
diferença é esse trecho:
auxnomes := nomes[i] 
nomes[i] := nomes[i+1] 
nomes[i+1] := auxnomes
Ou seja, a mesma operação de troca também é feita no vetor de nomes.
E não poderia ser diferente, afinal de contas, se você alterar a posição de um elemento do vetor notas, 
deve fazer a mesma alteração no elemento equivalente no vetor “nomes”.
Essa mesma estratégia pode ser usada para qualquer número de vetores, ou seja, todos os elementos 
equivalentes dos vetores devem ser movidos para que não aconteça nenhuma perda de dados.
Interessante, não é?
Também seria muito interessante se, além de armazenar dados e ordená-los, pudéssemos buscar uma 
dada informação dentro de um vetor. Vamos dar uma olhada nesse assunto no item a seguir.
11
Maria José João Antônio Pedro
1 2 3 4 5
BUsCaNdo dados
Para buscar dados, você pode trabalhar de várias formas. Suponha, por exemplo, que num vetor estão 
armazenados os nomes de 5 pessoas, conforme vemos na figura abaixo.
nomes
Suponha que estamos procurando o nome Antônio. Um algoritmo bem simples para isso seria de busca 
sequencial, ou seja, que varre o vetor passo a passo até achar o elemento. Vamos ver como ficaria esse 
algoritmo:
ALGORITMO “CARREGANDO BUSCANDO NOMES”. 
VAR
I : inteiro
nomes :vetor[1..5] de literal
nomebusca : literal 
Inicio
Para i:=1 ate 5 faca
 Escreval(“informe nome da posição ” , i) 
 leia(nomes[i])
Fimpara
Escreval(“informe o nome que deseja buscar”) 
leia(nomebusca)
Para i:=1 ate 5 faca
se nomes[i] = nomebusca entao
 Escreval(“ achei nome”, nomebusca , “na posição ” , i) 
fimse
Fimpara 
FIMALGORITMO
Pelo que podemos ver, o programa é bem simples. Contudo, essa simplicidade faz também que ele seja 
bem ineficiente, ou seja, o vetor é percorrido até o fim, mesmo já tendo achado o elemento.
Existem diversos algoritmos de busca que são bem mais eficientes, e trataremos de alguns deles aqui.
Vamos pensar um pouco: Se, antes realizar a busca, ordenássemos o vetor em ordem crescente? Com 
isso, seria bem mais fácil realizar a busca de forma mais eficiente. Vamos fazer isso para um vetor com 
números:
12
ALGORITMO “CARREGANDO NUMEROS PARA BUSCA”. 
VAR
I : inteiro
numeros :vetor[1..10] de real 
Inicio
Para i:=1 ate 10 faca
Escreval(“informe numeros da posição ” , i) 
leia(numeros[i])
Fimpara 
FIMALGORITMO
Acrescentando o trecho com a ordenação, esse algoritmo fica assim:
ALGORITMO “CARREGANDO E ORDENANDO NUMEROS PARA BUSCA.” 
VAR
I : inteiro
numeros :vetor[1..10] de real 
auxnumeros : real
trocou: literal 
Inicio
Para i:=1 ate 10 faca
 Escreval(“informe números da posição ” , i) 
 leia(numeros[i])
Fimpara
escreval(“ordenando o vetor de números”) 
trocou := “v”
enquanto trocou = “v” faca 
 trocou := “f”
 para i := 1 ate 9 faca
 se numeros[i] > numeros[i +1] entao 
 auxnumeros := numeros[i] 
 numeros[i] := numeros[i+1] 
 numeros[i+1]:= auxnumeros
 trocou := “v” 
 fimse
fimpara
escreval(“listagem dos números ordenados”) 
Para i:=1 ate 10 faca
 Escreval(numeros[i]) 
Fimpara
FIMALGORITMO
13
Agora que já ordenamos os elementos, que tal se ao acharmos o elemento, o algoritmo interrompesse a 
repetição de imediato? O pedaço de código a utilizar seria dessa forma:
se numeros[i] = numerobusca então 
 escreval(“encontrei o número na posição “, i) 
 interrompa
fimse
O comando “interrompa”, mostrado acima, permite ao algoritmo sair da repetição antes do fim.
O algoritmo completo ficaria assim:
ALGORITMO “CARREGANDO E ORDENANDO NUMEROS PARA BUSCA”. 
VAR
I : inteiro
numeros :vetor[1..10] de real 
auxnumeros : real
trocou: literal 
Inicio
Para i:=1 ate 10 faca
Escreval(“informe números da posição ” , i) 
leia(numeros[i])
Fimpara
escreval(“ordenando o vetor de números”) 
trocou := “v”
enquanto trocou = “v” faca 
trocou := “f”
para i := 1 ate 9 faca
se numeros[i] > numeros[i +1] entao 
auxnumeros := numeros[i] 
numeros[i] := numeros[i+1]
 numeros[i+1]:= auxnumeros
trocou := “v”fimse
fimpara
Para i:=1 ate 5 faca
se nomes[i] = nomebusca entao
Escreval(“ achei nome”, nomebusca , “na posição ” , i) 
interrompa
fimse 
Fimpara
FIMALGORITMO
Interessante, não é?
14
No nosso livro-texto, nas páginas 110 a 116, você pode ver outros métodos de busca utilizados em vetores 
ordenados: a busca binária. Esse também é um importante tema ligado à informática. 
A seguir, veremos um importante assunto na nossa profissão: o processo de programação. Vamos lá.
ProCesso de ProGraMaÇÃo
Antes de tudo, vamos relembrar alguns conceitos que aprendemos nas aulas anteriores. Vamos relembrar 
o conceito de programa:
Um programa de computador é composto por um conjunto de comandos, que faz com que aquele compu-
tador realize alguma atividade.
Também vimos na primeira aula os passos que utilizamos para construir um programa de computador:
1. Entender o problema a ser resolvido.
2. Definir os dados que entrarão no sistema.
3. Definir o processamento, ou seja, que tipo de transformação será aplicada aos dados.
4. Definir quais são os dados de saída, que serão transmitidos ou exibidos em tela.
5. Construir o algoritmo.
6. Testar o algoritmo.
Esses passos são independentes da linguagem que é utilizada. No caso do Visualg, utilizamos uma 
linguagem conhecida como “português estruturado” ou “portugol”. Essa linguagem mostra, genericamente, 
quais são as principais estruturas utilizadas na programação.
Vimos, por exemplo, a estrutura de decisão “SE”. No caso do portugol, ela é composta da seguinte 
maneira:
se condição entao
Comandos para quando condição é verdadeira.
senao
Comandos para quando condição não é verdadeira.
fimse
Se observarmos outras linguagens, como por exemplo, o PASCAL, veremos que as instruções são parecidas 
– na prática, temos pequenas modificações, praticamente traduzindo do português para o inglês.
Vamos ver a estrutura de decisão “IF”, equivalente ao “SE”, no pascal:
15
IF condição THEN
Comandos para quando condição é verdadeira.
ELSE
Comandos para quando condição não é verdadeira.
Se utilizarmos mais de um comando, o IF do PASCAL fica assim:
IF condição THEN 
BEGIN
Comandos para quando condição é verdadeira. 
Comandos para quando condição é verdadeira.
END
ELSE 
BEGIN
Comandos para quando condição não é verdadeira.
END.
Na prática, podemos ver que os comandos são bem parecidos. Que tal vermos esse mesmo comando em 
JAVA?
if condição {
 comandos para quando condição é verdadeira;
}
else {
 comandos para quando condição não é verdadeira;
}
E agora, vamos ver no PHP:
if condição {
 comandos para quando condição é verdadeira;
}
else
{
 comandos para quando condição não é verdadeira;
}
o PHP possui uma estrutura mais sofisticada:
16
if condição {
 comandos para quando condição é verdadeira;
}
elseif outracondição {
 comandos para quando outracondição é verdadeira;
}
else
{
 comandos para quando outracondição não é verdadeira;
}
Da mesma forma, podemos comparar os comandos “PARA” e “FOR”. 
Vejamos alguns exemplos abaixo.
O comando PARA abre uma repetição determinada, por exemplo:
Para i:=1 ate 10 faca 
 escreval(i)
fimpara
Vamos ver esse mesmo comando no JAVA:
for(int i=1; i<=10; i++){ 
 System.out.println(i);
}
No comando feito em JAVA, percebemos que o PARA é substituído por FOR. A variável i é declarada no 
próprio FOR. O comando “Escreval(i)” é substituído por “System.out.println(i)”.
Como podemos ver o que é feito no Visualg, ou seja, a estrutura utilizada pode ser feita em outras 
linguagens utilizando a forma de escrever (que chamamos de sintaxe) daquela linguagem. 
Vários exemplos podem ser encontrados no nosso livro-texto a partir da página 118, indo até a página 
122. Lá, é possível ver exemplos em PASCAL, JAVA, C e outras linguagens. Pesquise também, na internet, 
como seriam essas estruturas em C# e C++, e verá que são bem parecidas.
É importante salientar que essas linguagens foram originadas em momentos diferentes, sob pontos de 
vista (paradigmas) diferentes.
Por esse motivo, podemos dizer que existem vários tipos de linguagens de programação que são ligados 
aos seus paradigmas. Tema esse que abordaremos a seguir.
17
TIPos de lINGUaGeM de ProGraMaÇÃo
Podemos dizer que existem vários tipos de linguagens de programação. Segue abaixo um exemplo de 
algumas das linguagens existentes (não colocaremos uma grande quantidade porque existem centenas 
delas).
Pascal, Object Pascal (derivada do Pascal), java, C, C#, C++, Cobol, Algol, Lisp, Prolog, Natural, Fortran, 
Miranda, PHP, Basic, Delphi, JavaScript, Mumps, Modula, PowerBuilder, Python, Visual Basic, VbScript e 
assim por diante.
São muitas, muitas linguagens de programação.
Aí surge a pergunta: Quais são as mais utilizadas atualmente? São todas semelhantes? Elas funcionam da 
mesma forma ou demandam tipos de programação diferente? Sem dúvida, elas não são iguais.
Mas existem bastantes semelhanças entre aquelas que estão no seu grupo (paradigma) de programação. 
Existem vários paradigmas de programação, mas 2 deles se sobressaem atualmente: o paradigma 
estruturado, ou seja, a programação estruturada, e a programação orientada a objetos.
Mas antes desses 2 paradigmas, havia um outro: a programação sequencial. Trataremos desses 3 
paradigmas a seguir.
•	 Programação sequencial
Conforme citado no nosso livro-texto, na página 123, as primeiras linguagens de programação eram 
sequenciais, em função das características dos sistemas existentes e destinavam-se a uma atividade 
específica.
O que significa isso? Significa dizer que nos primórdios da programação as linguagens eram muito 
dependentes do hardware existente, e isso significava que elas eram limitadas e limitavam a própria 
interação com o usuário. 
Naquele tempo não era comum termos, como hoje em dia, o usuário interagindo diretamente através de 
telas multimídia ou com mouse.
Aquele era o tempo do processamento de dados puro, ou seja, um volume de dados era lido pelo programa 
através de algum dispositivo de entrada, esses dados eram processados e o resultado era normalmente 
impresso em algum dispositivo específico para isso. 
Portanto, o mundo interativo que você vê hoje em dia, onde você usa tablet ou celular para acessar 
internet através de simples toques de dedo, simplesmente não existia. 
Isso não quer dizer, contudo, que as linguagens poderiam ser consideradas inferiores. Elas eram adaptadas 
à realidade existente, que foi mudando com o passar do tempo. Naquele tempo, se programava em 
linguagens muito mais próximas do hardware das máquinas, numa linguagem conhecida como ASSEMBLER.
18
Na página 124 do nosso livro, podemos ver o exemplo abaixo de um pequeno programa Assembler (não 
vamos reproduzir o código inteiro):
sub esp, 2D0h
mov dword ptr [ebp+FFFFFDDCh], eax 
mov dword ptr [ebp+FFFFFDD8h], ecx mov 
eax, dword ptr [ebp+8]
mov ecx, dword ptr [ebp+4] mov 
dword ptr [eax+0Ch], ecx lea eax, 
[ebp+FFFFFD2Ch]
mov dword ptr [eax+000000B8h], ecx 
mov dword ptr [eax+000000A4h], ebx 
mov dword ptr [eax+000000A8h], edx 
mov dword ptr [eax+000000A0h], esi mov 
dword ptr [eax+0000009Ch], edi lea ecx, 
[ebp+0Ch]
Bem diferente do que estamos acostumados, não é? Antigamente, programar era coisa para especialistas 
na área. Hoje em dia, com o vasto material que podemos acessar em sites como o Youtube, por exemplo, 
é relativamente fácil dar os primeiros passos na programação.
Isso acontece porque as linguagens passaram a ser bem mais amigáveis e legíveis bem diferentes desse 
código complexo, que vemos no exemplo em Assembler que acabamos de citar.
Isso decorre da própria evolução da programação. Os sistemas ficaram mais complexos, mas as linguagens 
ficaram mais amigáveis, embora em alguns casos haja uma alta complexidade nos sistemas desenvolvidos.
Nessa evolução natural da programação, a própria programação sequencial foi sucedida pela programação 
estruturada, que tratamos a seguir.
•	 Programação estruturada
A programação estruturadafoi criada com base numa ideia que, na prática, utilizamos todos os dias: o de 
dividir um problema em partes para depois resolver as partes menores e, ao final, acabamos abordando o 
problema todo a partir do entendimento das partes.
Vejamos como funciona:
Vamos começar com um exemplo que não é ligado à informática.
Suponha que você pretende comprar um carro. Portanto, a tarefa geral é essa. Mas, se você for pensar 
com calma, vai subdividir essa tarefa em partes, que ficariam assim:
•	 Escolher modelo do carro;
•	 Verificar preço;
•	 Verificar se há como comprar (saldo disponível ou financiamento);
19
•	 Procurar veículos daquele modelo;
•	 Selecionar veículo;
•	 Efetuar compra.
E assim por diante, ou seja, você dividiu a tarefa em outras subtarefas, que em programação estruturada 
chamamos de “módulos”. Portanto, nesse caso realizamos um processo chamado de “modularização”. 
No exemplo acima, poderíamos dizer que cada módulo desses seria uma “função” ou “procedimento”. 
Ou seja, é bastante simples. A complexidade dessa abordagem é diretamente ligada à complexidade do 
problema, ou seja, quanto maior o sistema, maior a quantidade de submódulos que ele terá.
A seguir, vamos ver uma abordagem bem diferente, mais moderna, surgida de uma forma de pensamento 
que tenta fazer com que o sistema seja construído com componentes que se assemelham à realidade. 
Esses componentes são chamados de objetos, e essa abordagem é chamada de “programação orientada 
a objetos”.
•	 Programação orientada a objetos
Vimos anteriormente que a programação estruturada é baseada na ideia de dividir o problema em partes 
e abordar cada uma delas, detalhando mais e mais até chegar a um ponto onde o que se precisa fazer é 
codificar o algoritmo em alguma linguagem padrão e construir o sistema.
A abordagem que veremos agora é bem diferente. A programação orientada a objetos decorre da 
modelagem orientada a objetos, que consiste em analisar um cenário particular, verificar quais são os 
seus objetos, como interagem e como um programa de computador pode representar esses objetos e sua 
interação.
Os objetos são modelados partindo do pressuposto de que possuem atributos e comportamentos. Vamos 
ver um exemplo prático de objeto.
Vamos analisar o objeto “Carro”.
Todo carro possui alguns atributos (características):
•	 Placa
•	 Chassi
•	 Modelo
•	 Valor
Esse veículo também tem comportamentos:
•	 Ligar
•	 Desligar
20
Na modelagem orientada a objetos, representaríamos esse carro assim: 
CARRO
placa 
chassi 
modelo 
valor
Ligar 
Desligar
Esses itens, por sua vez, serão representados diretamente numa linguagem de programação orientada a 
objetos, como o JAVA. 
Vejamos um exemplo em JAVA (baseado na classe carro, acima). Nessa linguagem, definimos as classes 
que darão origem a objetos durante a execução do programa.
class Carro {
 String placa; 
 String chassi; 
 String modelo; 
 double valor;
 //liga o carro 
 void ligar() {
 System.out.println(“Agora o carro já está ligado”);
 }
 void desligar() {
 System.out.println(“Agora o carro já está desligado”);
 }
}
Interessante, não é?
vIsITe a PáGINa
Neste link, você pode ler uma explicação bem detalhada do assunto.
Clique aqui para acessar.
Nesta disciplina não tratamos diretamente deste assunto, que você verá em profundidade mais à frente 
no seu curso de graduação.
https://www.caelum.com.br/apostila-java-orientacao-objetos/orientacao-a-objetos-basica/
21
vIsITe a PáGINa
No link abaixo, você pode ver diversos artigos tratando do tema.
Clique aqui para acessar.
Você encontra, na internet, muito material acerca desse assunto, que é fundamental para qualquer pessoa 
que atue na área de programação e desenvolvimento de sistemas. 
Vários sistemas são desenvolvidos com esse paradigma, e é importantíssimo você conhecê-lo.
Palavra fINal
Prezado(a) aluno(a)!
Terminamos aqui, a nossa disciplina de lógica de programação. Esperamos que tenha gostado e, que 
continue estudando e se aprofundando neste tema.
Abaixo, faremos um pequeno resumo deste capítulo.
Nesta unidade, vimos alguns métodos de ordenação e busca do processo de programação e seus principais 
paradigmas. 
Com isso, finalizamos a nossa disciplina de Lógica de Programação.
Aproveite para realizar os exercícios de fixação do livro. Insira suas dúvidas nos fóruns da disciplina. 
Para consolidar os seus conhecimentos, releia a unidade 4 do nosso livro-texto, realize os exercícios e 
depois responda os exercícios avaliativos que estão no Ambiente Virtual de Aprendizagem (AVA). 
Agradecemos a sua dedicação e atenção. 
Desejamos bons estudos a você.
http://www.engenhariadesoftware.net.br/artigos/