Livro Texto 1 - Paradigmas de Linguagens

Prévia do material em texto

Paradigmas
de Linguagens
Professor conteudista: Rodrigo de Oliveira Plotze
Sumário
Paradigmas de Linguagens
Unidade I
1 INTRODUÇÃO AOS PARADIGMAS DE LINGUAGENS ............................................................................1
2 TIPOS DE DADOS ................................................................................................................................................4
2.1 Tipos de dados primitivos ....................................................................................................................4
2.2 Tipos string de caracteres ....................................................................................................................7
2.3 Tipos ordinais definidos pelo usuário ..............................................................................................8
2.4 Tipos array ..................................................................................................................................................9
2.5 Tipos registro ...........................................................................................................................................11
2.6 Tipos ponteiro .........................................................................................................................................11
3 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO ..................................................................................... 12
3.1 Expressões aritméticas ....................................................................................................................... 12
3.2 Conversões de tipo .............................................................................................................................. 14
3.3 Expressões relacionais e booleanas ............................................................................................... 15
3.4 Instruções de atribuição .................................................................................................................... 15
4 ESTRUTURAS DE CONTROLE ....................................................................................................................... 17
4.1 Estrutura condicional ......................................................................................................................... 17
4.2 Estruturas de repetição ...................................................................................................................... 20
5 SUBPROGRAMAS ............................................................................................................................................ 21
6 CONSIDERAÇÕES FINAIS .............................................................................................................................. 28
Unidade II
7 PROGRAMAÇÃO ESTRUTURADA ............................................................................................................... 34
8 PROGRAMAÇÃO ORIENTADA A EVENTOS ............................................................................................. 42
9 PROGRAMAÇÃO ORIENTADA A OBJETOS .............................................................................................. 46
10 CONSIDERAÇÕES FINAIS ............................................................................................................................ 60
1
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Unidade I5
10
15
20
25
30
35
1 INTRODUÇÃO AOS PARADIGMAS DE 
LINGUAGENS
Nesta primeira unidade você estudará os principais conceitos 
que fazem parte dos paradigmas de linguagens. Conhecerá sobre 
os tipos de dados, as expressões e instruções de atribuição, as 
estruturas de controle e os subprogramas.
Um paradigma de linguagem, ou um paradigma de 
programação, representa a metodologia, ou filosofia, adotada 
pelo programador para o desenvolvimento de um programa de 
computador.
Inicialmente, é importante entender sobre o processo de 
desenvolvimento de programas de computador. Esta máquina 
é capaz de executar ações que são especificadas por meio dos 
programas. Assim, para que um computador realize tarefas, é 
necessário que os programas sejam escritos em uma linguagem 
que ele entenda. Essa linguagem é conhecida como linguagem 
de programação.
Mas antes de escrever um programa de computador, 
é fundamental que se crie uma forma de representação, 
denominada algoritmo. Um algoritmo pode ser entendido como 
uma descrição, ou sequência de passos, que deverá ser seguida 
pelo computador para realização de uma determinada tarefa. 
Essa descrição é essencial para a construção dos programas, 
e uma das formas mais utilizada para a representação de 
algoritmos é conhecida como pseudocódigo, sendo também 
chamada de português estruturado (ou portugol).
2
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Para ilustrar os conceitos de algoritmos e programas, 
considere o seguinte problema: desenvolver um programa capaz 
de realizar a soma de três números inteiros informados pelo 
usuário e apresentar o resultado na tela. O trecho de código 
abaixo apresenta a solução em linguagem algorítmica:
1 algoritmo “soma três números”
2
3 declare
4 num1, num2, num3 : inteiro
5 Soma : inteiro
6 
7 inicio
8
9 escreva(“Entre com o primeiro número:”)
10 leia(num1)
11 escreva(“Entre com o segundo número:”)
12 leia(num2)
13 escreva(“Entre com o terceiro número:”)
14 leia(num3)
15 Soma <- num1+num2+num3
16 escreva(“Resultado = “, soma)
17 
18 fimalgoritmo
Agora, vamos visualizar como este algoritmo pode ser 
transformado em um programa. Para isso, devemos traduzir este 
trecho de código para a linguagem de programação desejada. O 
trecho de código abaixo apresenta a tradução do algoritmo para 
a linguagem de programação C:
1 #include <stdio.h>
2
3 int main()
4 {
3
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
5 int num1, num2, num3;
6 int soma;
7
8 printf(“Entre com o primeiro numero: “);
9 scanf(“%i”,&num1);
10 printf(“Entre com o segundo numero: “);
11 scanf(“%i”,&num2);
12 printf(“Entre com o terceiro numero: “);
13 scanf(“%i”,&num3);
14 soma = num1+num2+num3;
15 printf(“Resultado = %d”, soma);
16
17 return 0;
18 }
Utilizando uma ferramenta de pesquisa na internet, como 
por exemplo, os sites Google, Bing, Yahoo, entre outros, uma 
simples consulta sobre o termo linguagens de programação, 
ou sua variante em inglês programming languages retornará 
alguns milhões de resultados. Com isso, é possível notar como o 
desenvolvimento de programas para computador é um universo 
fascinante, e como podemos utilizar as mais variadas tecnologias 
e metodologias.
As diversas linguagens de programação existentes 
possuem características específicas, por meio das quais os 
programadores constroem os programas. Algumas dessas 
características são fundamentais e estão presentes em 
praticamente todas as linguagens de programação. Dentre 
elas temos:
• tipos de dados – determinam quais tipos de informações 
poderão ser manipuladas pelos programas;
• expressões – permitem a realização de cálculos nos 
programas;
4
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
• estruturas de controle – especificam as tomadas de 
decisão e repetição;
• subprogramas – permitem a modularização dos 
programas. 
Essas características serão exploradas em detalhes ao longo 
das próximas seções. 
2 TIPOSDE DADOS
Uma das principais funcionalidades de um programa de 
computador é a manipulação de informações. Para isso, é 
necessário que o programador utilize variáveis, cada qual com 
um tipo específico associado. Esses tipos estão relacionados com 
as informações que serão armazenadas e manipuladas.
2.1 Tipos de dados primitivos
Os tipos de dados primitivos representam os tipos mais 
simples de dados e estão presentes em praticamente todas 
as linguagens de programação. Neste conjunto de tipos 
temos:
• inteiro - é o tipo de dados mais comum presente nas 
linguagens de programação. Ele é utilizado para armazenar 
números inteiros, positivos, negativos ou iguais a zero. Em 
geral, é capaz de armazenar números com aproximadamente 
16 bits, o que representa o espaço necessário para armazenar 
essa informação na memória principal;
• ponto-flutuante - permite a manipulação de números 
reais. Um número real é formado por uma parte inteira e 
uma parte decimal. Por exemplo, o número 64,82 (sessenta 
e quatro inteiros e oitenta e dois décimos) é um valor do 
tipo de dados ponto-flutuante 1;
1 Uma característica importante do tipo de dados ponto-flutuante 
está relacionada à precisão. A precisão de um número representa a 
quantidade máxima de casas que este tipo pode armazenar. Na linguagem 
de programação C, por exemplo, o tipo de dados float tem uma precisão de 
seis casas decimais, enquanto o tipo de dados double tem uma precisão de 
dez casas decimais.
5
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
• decimal - este tipo de dados é semelhante ao tipo ponto-
flutuante, sendo capaz de armazenar números com 
precisão de duas casas decimais. O tipo de dados decimal 
é indicado para aplicações comerciais e financeiras que 
manipulam informações no formato moeda. Um exemplo 
de valor para este tipo é R$ 50,32 (cinquenta reais e trinta 
e dois centavos). A vantagem de utilizar este tipo de 
dados é a economia de memória para o armazenamento 
da parte decimal;
• booleano - é utilizado para armazenamento de valores 
lógicos, como por exemplo, verdadeiro ou falso. Também 
pode ser empregado para manipular informações do tipo 
sim ou não. A implementação deste tipo de dados é 
realizada utilizado bits;
• caractere - é utilizado para armazenar e manipular 
caracteres dos mais variados formatos. Um caractere 
pode ser, por exemplo, um número, uma letra do alfabeto 
e também pode ser representado por símbolos, tais como 
@, #, $, %, &, entre outros.
O código fonte abaixo apresenta a utilização dos tipos de 
dados primitivos na linguagem de programação Visual C#:
1 using System;
2
3 namespace ParadigmasLinguagens
4 {
5 class Program
6 {
7 static void Main(string[] args)
8 {
9 // tipo inteiro
10 int x = 10;
6
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
11 int y = -20;
12 int z = 0;
13
14 // tipo ponto-flutuante
15 float p = (float)20.0123456789;
16 double q = 20.0123456789;
17
18 //tipo decimal
19 decimal d = (decimal)55.21;
20
21 //tipo booleano
22 bool b = true;
23
24 //tipo caractere
25 char c1 = ‘a’;
26 char c2 = ‘6’;
27 char c3 = ‘@’;
28
29 //exibir variáveis na tela
30 Console.WriteLine(“Tipo Inteiro”);
31 Console.WriteLine(“X = {0}”, x);
32 Console.WriteLine(“Y = {0}”, y);
33 Console.WriteLine(“Z = {0}\n”, z);
34
35 Console.WriteLine(“Tipo Ponto-Flutuante”);
36 Console.WriteLine(“P = {0}”, p);
37 Console.WriteLine(“Q = {0}\n”, q);
38
39 Console.WriteLine(“Tipo Decimal”);
40 Console.WriteLine(“D = {0}\n”, d);
41
42 Console.WriteLine(“Tipo Booleano”);
43 Console.WriteLine(“B = {0}\n”, b);
44
7
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
45 Console.WriteLine(“Tipo Caractere”);
46 Console.WriteLine(“C1 = {0}”, c1);
47 Console.WriteLine(“C2 = {0}”, c2);
48 Console.WriteLine(“C3 = {0}”, c3);
49
50 Console.ReadLine();
51
52 }
53 }
54 }
2.2 Tipos string de caracteres
O tipo de dados string é utilizado para manipular informações 
representadas por uma cadeia de caracteres, especificada por 
uma sequência de caracteres, que podem ser definidos por letras, 
números ou símbolos.
É importante destacar a diferença entre o tipo de dados 
primitivo caractere e o tipo string. No primeiro, armazena-se 
apenas um único caractere por vez, enquanto que, o segundo, 
possibilita a manipulação de uma cadeia de caracteres.
As principais operações que podem ser realizadas com este 
tipo de dados são:
• comparação – em que é possível verificar se uma cadeia 
de caracteres é igual à outra;
• concatenação – que permite a união de duas cadeias de 
caracteres;
• cópia de subcadeias – em que é possível extrais subcadeias 
de caracteres a partir da cadeia original;
• tamanho – faz o retorno do número de caracteres 
presentes na cadeia.
8
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Diversas linguagens de programação implementam 
métodos com o objetivo de facilitar a tarefa de manipulação 
de strings. O trecho de código abaixo apresenta algumas dessas 
funcionalidades implantadas na linguagem de programação 
Java. Este código é funcional e pode ser utilizado em qualquer 
ambiente de desenvolvimento para plataforma Java.
1 public class TipoString {
2
3 public static void main(String[] args) {
4
5 String str = “João da Silva”;
6
7 //número de caracteres
8 System.out.println(“Tamanho = “ + str.length());
9
10 //caractere de uma determinada posição
11 System.out.println(“Posição 2 =” + str.charAt(2));
12
13 //comparação
14 System.out.println(str.equals(“José Antônio”));
15
16 //procura em Strings
17 System.out.println(str.indexOf(“Silva”));
18
19 //transforma em maiúsculo
20 System.out.println(str.toUpperCase());
21 }
22
23 }
2.3 Tipos ordinais definidos pelo usuário
Um tipo de dados ordinal representa uma faixa de valores 
possíveis que pode ser associada a um número inteiro positivo. 
9
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Este tipo de dados também é conhecido como enumerador e 
está presente em diversas linguagens de programação. O trecho 
de código abaixo ilustra a utilização de enumeradores na 
linguagem de programação Visual C#:
1 using System;
2
3 namespace Enumeradores
4 {
5 class Program
6 {
7
8 //Declaração do Tipo de Dados Ordinal
9 enum Dia { Domingo, Segunda, Terça, Quarta, Quinta, 
 Sexta, Sabado };
10
11 static void Main(string[] args)
12 {
13 Dia hoje = Dia.Segunda;
14
15 Console.WriteLine(“Hoje = {0}”, hoje);
16 Console.ReadLine();
17 }
18 }
19 }
2.4 Tipos array
Um arranjo é um conjunto homogêneo de elementos do 
mesmo tipo de dados, em que cada elemento individual é 
referenciado por sua posição, também conhecida como índice. 
Em geral, um índice é um número inteiro maior ou igual a zero, emenor ou igual ao tamanho do arranjo. Algumas linguagens de 
programação também permitem a utilização de outros tipos de 
dados como índice do vetor, por exemplo, a utilização de strings 
ou valores ponto-flutuantes.
10
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
O número de índices utilizados para referenciar as posições 
do arranjo faz com que sejam definidas algumas estruturas. Um 
arranjo contendo apenas um índice, ou apenas uma dimensão, é 
conhecido como vetor, enquanto que, um arranjo contendo dois 
índices, ou duas dimensões, é conhecido como matriz.
O trecho de código abaixo ilustra a utilização de arranjos 
na linguagem de programação Java. Neste código é possível 
identificar a inicialização do arranjo, bem como o acesso a um 
determinado elemento, e a exibição do conteúdo na tela.
1 public class TipoArray {
2
3 public static void main(String[] args) {
4
5 //declaração de um arranjo
6 int a1[] = new int[3];
7
8 //declaração e inicialização
9 //do arranjo
10 int a2[] = {10,20,30};
11
12 //atribuição dos elementos
13 a1[0] = 10;
14 a1[1] = 20;
15 a1[2] = 30;
16
17 //exibição dos elementos
18 for (int i = 0; i < a1.length; i++) {
19 System.out.println(“A1[“+i+”]= “+a1[i]);
20 System.out.println(“A2[“+i+”]= “+a2[i]);
21 }
22 }
23 }
11
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
2.5 Tipos registro
O tipo de dados registro é representado por um conjunto 
heterogêneo de elementos, em que cada elemento individual 
presente no registro é identificado pelo seu nome. Os elementos 
do registro são conhecidos como campos. O trecho de código 
abaixo ilustra a definição de uma estrutura do tipo registro na 
linguagem de programação C:
1 struct tipopessoa{
2 int idade;
3 char sexo;
4 float altura;
5 }pessoa1;
No trecho acima, uma estrutura do tipo registro foi 
declarada, e uma variável denominada pessoa1 foi definida. 
Assim, a estrutura pode ser referenciada por meio da variável. 
Além disso, a atribuição dos valores é realizada a partir do nome 
dos campos, conforme ilustrado no trecho a seguir:
1 pessoa1.idade = 22
2 pessoa1.sexo = ‘M’
3 pessoa1.altura = 1.68
2.6 Tipos ponteiro
O tipo de dados ponteiro é utilizado para armazenar o 
endereço de memória de outra variável. Este tipo de dados é 
muito empregado em linguagens de programação como C e 
C++, além de ser muito indicado quando o programador deseja 
acessar diretamente as informações na memória.
O trecho de código abaixo ilustra a utilização do tipo de 
dados ponteiro na linguagem de programação C. É importante 
identificar que o símbolo asterisco (*) é utilizado antes do nome 
12
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
da variável. Este uso é o que indica que a variável declarada é 
do tipo ponteiro.
1 int *pontIdade; // exemplo de ponteiro para int
2 char *pontNome; // exemplo de ponteiro para char
3 float *pontValor; // exemplo de ponteiro para float
O código fonte a seguir ilustra de maneira mais detalhada 
a utilização de ponteiros na linguagem de programação C. 
Neste exemplo são apresentadas a declaração e a atribuição de 
valores a uma variável do tipo de dados ponteiro. Além disso, 
são mostradas as informações da variável na tela.
1 #include <stdio.h>
2
3 int main()
4 {
5 int valor = 2582;
6 int *pontValor;
7
8 pontIdade = &valor;
9
10 printf(“Endereco da variavel valor: %u \n”, &idade);
11 printf(“Endereco apontado pelo ponteiro: %u \n”, 
 pontValor); 
12
13 return 0;
14 }
3 EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
3.1 Expressões aritméticas
No início da evolução das linguagens de programação, 
uma das principais aplicações dos programas de computadores 
era a avaliação automática de expressões aritméticas. Essa 
13
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
funcionalidade permitia a realização de complexos cálculos 
matemáticos em poucos minutos, os quais poderiam durar 
horas, até dias, se fossem realizados por seres humanos.
Uma expressão é formada por operadores, operandos e 
parêntesis. Um operador é representado por um símbolo e indica 
qual tipo de operação será realizada pela expressão. Algumas 
das principais operações são:
• (+) soma;
• (-) subtração;
• (*) multiplicação;
• (/) divisão;
• (%) módulo ou resto.
As regras de precedência são fundamentais para determinação 
do resultado da expressão aritmética. Essas regras definem a 
ordem em que os operadores devem ser avaliados.
Temos por exemplo, a expressão aritmética A+B*C. Suponha 
os valores A=3; B=4 e C=5 para os operandos, e considere a 
regra de precedência em que os operadores são avaliados da 
esquerda para direita. Assim, há inicialmente a soma de A+B, e 
em seguida a multiplicação do resultado por C e o resultado da 
avaliação da expressão com essa regra de precedência será 35.
Agora, considere os mesmos valores para os operandos, 
no entanto, adote como regra de precedência a avaliação dos 
operadores da direita para esquerda. Assim, primeiramente 
temos a multiplicação de B*C, em seguida a soma do resultado 
com o operando C. Neste caso, temos como resultado final da 
expressão o valor 23.
14
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Nas linguagens de programação, em geral, as regras 
de precedência seguem a mesma significância das regras 
matemáticas. Os operadores são avaliados em função da 
maior precedência na seguinte ordem (da maior para a menor 
precedência): exponenciação; multiplicação e divisão; soma e 
subtração.
A utilização de parêntesis permite a alteração das regras 
de precedência em uma expressão. Se, por exemplo, tivermos 
(A+B)*C, a soma será avaliada primeiro e, em seguida, a 
multiplicação.
3.2 Conversões de tipo
As conversões de tipo têm como objetivo a alteração do tipo 
de dados de um determinado valor para outro tipo. Assim, temos 
uma operação que transforma o tipo de dados de origem em um 
tipo de dados de destino.
Uma conversão de estreitamento é utilizada para 
transformar um valor para um tipo que não pode armazenar 
todo o valor do tipo de destino. Por exemplo, considere a 
conversão utilizando a linguagem de programação C do tipo 
de dados ponto-flutuante double, com precisão de dez casas 
decimais, para o tipo de dados float, com precisão de seis 
casas decimais. Como a faixa de armazenamento do tipo de 
dados double é muito maior que a faixa do tipo float, os 
valores adicionais são desprezados (ou truncados).
Uma conversão de alargamento permite a mudança de 
um valor para um novo tipo que é capaz de conter todo 
o valor original. Como exemplo, considere a conversão de 
um valor do tipo de dados inteiro para um valor do tipo de 
dados ponto-flutuante float. Assim, todo o valor contido no 
tipo inteiro é capaz de ser armazenado no tipo float.
15
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
3.3 Expressões relacionais e booleanas
As expressões relacionais utilizam operadores para comparar 
os valores entre dois operandos. Estes operadores são conhecidoscomo operadores relacionais. Os mais utilizados são: (>) maior; 
(<) menor; (>=) maior ou igual e (<=) menor ou igual.
O resultado de uma expressão relacional é sempre um valor 
lógico booleano. A ordem de precedência de um operador 
relacional é sempre menor do que dos operadores aritméticos. 
Assim, primeiramente as expressões matemáticas são resolvidas, 
e em seguida, a expressão relacional.
Como exemplo, considere a expressão A+1 >2*B, sendo que 
A=4 e B=6. Assim, a solução das expressões aritméticas resulta 
em 5 > 12, por fim, o resultado da expressão relacional será 
igual a falso.
As expressões booleanas são formadas a partir de um 
conjunto de operadores booleanos, que em geral incluem as 
operações:
• e (and);
• ou (or);
• negação (not)2.
3.4 Instruções de atribuição
Uma instrução de atribuição tem como objetivo a 
alteração do valor de uma variável. Assim, o programador 
pode modificar, em tempo de execução (com o programa em 
funcionamento), os valores associados a uma determinada 
variável.
Muitas linguagens de programação (Java, Visual C#, C, 
C++, Fortran, Basic, entre outras) utilizam como operador de 
2 Outras operações também são possíveis, por exemplo, ou-exclusivo 
(xor).
16
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
atribuição, o símbolo de igual (=). Outras utilizam dois símbolos, 
os dois pontos seguido do símbolo de igual (:=). Em Pascal, por 
exemplo, utiliza-se este formato de operador.
Algumas linguagens de programação permitem a utilização 
de uma instrução de atribuição para múltiplas tarefas. Assim, é 
possível atribuir um valor a diversas variáveis ao mesmo tempo. 
Por exemplo, o trecho de código abaixo, associa o valor 10, às 
variáveis denominadas A, B e C:
1 A = B = C = 10;
Outra maneira de utilizar uma instrução de atribuição é como 
resultado de uma operação condicional. Este tipo de operação 
é realizado com um tipo específico de operador, denominado 
ternário. O trecho de código abaixo ilustra este tipo de operação. 
Neste caso, a variável denominada valor receberá 10 ou 20, 
dependendo do resultado da avaliação da expressão relacional.
1 VALOR = ( X > Y ) ? 10 : 20; 
Uma instrução de atribuição também pode ser utilizada de 
forma a compor uma instrução mais complexa. Com isso, além da 
operação de atribuição, é possível a realização de outra operação, 
como de acumulação, por exemplo. O trecho de código abaixo 
ilustra a utilização de uma instrução de atribuição juntamente 
com um acumulador:
1 SOMA += 10;
A instrução de atribuição também pode ser realizada de 
maneira pontual. Este tipo de instrução é conhecido como 
operador prefixado ou pós-fixado, ou ainda como operador de 
incremento (++) ou operador de decremento (--). O trecho de 
código abaixo ilustra o operador de atribuição de incremento e 
decremento:
1 CONTADOR++;
2 CONTADOR--;
17
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
4 ESTRUTURAS DE CONTROLE
Uma estrutura de controle permite ao programador 
controlar o fluxo de execução de um programa. Ela é essencial 
para qualquer tipo de aplicação e pode ser utilizada para a 
seleção de caminhos de execução ou para a execução repetida 
de determinados trechos do programa.
Existem dois tipos de estrutura de controle: condicional e de 
repetição.
4.1 Estrutura condicional
Uma estrutura condicional utiliza uma expressão relacional 
para determinar que caminho deverá ser executado pelo 
programa. Este tipo de estrutura é formado por quatro tipos de 
instruções de seleção:
Instrução de seleção unidirecional
A instrução de seleção unidirecional está presente em todas 
as linguagens de programação. Essa instrução é chamada de if, e 
utiliza uma expressão booleana para definir se um determinado 
trecho da aplicação deverá ou não ser executado. O trecho do 
código será executado apenas quando o resultado da instrução 
for verdadeiro.
 Abaixo, está ilustrada a utilização de uma instrução de 
seleção unidirecional na linguagem de programação Java. A 
execução do trecho de código não exibirá nenhuma mensagem 
na tela, uma vez que o resultado da expressão booleana é falso 
e o conteúdo da instrução não será executado.
1 int a = 10;
2 int b = 20;
3
18
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
4 if ( a == b ){
5 System.out.println(“Os valores são iguais”);
6 }
Alterar os valores das variáveis iniciais faz com que 
o conteúdo da instrução de seleção unidirecional seja 
executado.
1 int a = 10;
2 int b = 10;
3
4 if ( a == b ){
5 System.out.println(“Os valores são iguais”);
6 }
Instrução de seleção bidirecional
Uma instrução de seleção bidirecional permite especificar 
o que será executado pelo programa quando o resultado 
da expressão lógica for falso. Assim, é possível codificar o 
comportamento da instrução da seleção condicional para o 
resultado verdadeiro ou falso. O trecho de código a seguir ilustra 
este tipo de instrução:
1 int a = 10;
2 int b = 20;
3
4 if ( a == b ){
5 System.out.println(“Os valores são iguais”);
6 }else{
7 System.out.println(“Os valores são diferentes”);
8 }
19
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Aninhamento de seletores
A utilização de uma instrução de seleção dentro de outra, é 
conhecida como aninhamento de seletores. O trecho de código 
abaixo ilustra este tipo de instrução:
1 int a = 10;
2 int b = 20;
3 int c = 30;
4
5 if ( a > b){
6 if ( a > c){
7 System.out.println(“A é o maior”);
8 }else{
9 System.out.println(“C é o maior”);
10 }
11 }else{
12 if ( b > c){
13 System.out.println(“B é o maior”);
14 }else{
15 System.out.println(“C é o maior”);
16 }
17 }
Instrução de seleção múltipla
Uma instrução de seleção múltipla permite determinar 
qual trecho de código será executado a partir de um 
conjunto de condições. Este tipo de seleção produz uma 
escolha mutuamente exclusiva, ou seja, apenas uma das 
condições será selecionada. O trecho de código a seguir 
ilustra este tipo de instrução na linguagem de programação 
Java:
20
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
1 int opcao = 1;
2 
3 switch(opcao){
4 case 1:
5 System.out.println(“Soma”);
6 break;
7 case 2:
8 System.out.println(“Subtração”);
9 break;
10 case 3:
11 System.out.println(“Multiplicação”);
12 break;
13 case 4:
14 System.out.println(“Divisão”);
15 break;
16 }
4.2 Estruturas de repetição
Uma estrutura de repetição é utilizada para determinar que 
uma instrução ou um conjunto de instruções, seja executado 
zero, uma ou mais vezes. Essa estrutura pode ser controlada por 
um contador ou por uma condição lógica.
Laço controlado por contador
Uma estrutura de repetição, controlada por um contador 
utiliza uma variável especial para determinar quantas vezes 
o laço foi executado. A principal estrutura que utiliza essa 
metodologia é conhecida como for, e está presente em diversas 
linguagens de programação. O trecho de código abaixo ilustra 
essa estrutura:
1 for (int i = 1; i <= 10; i++) {
2 System.out.println(“I=” + i);
3 }
21
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -0
3/
02
/2
01
1
Também é possível criar um laço comandado por contador 
com outras estruturas de repetição, como por exemplo, com a 
instrução while. O código a seguir ilustra essa implementação:
1 int i = 1;
2 while ( i <= 10){
3 System.out.println(“I=” + i);
4 }
Laço controlado por condição lógica
Um laço controlado por condição lógica é indicado quando 
não se sabe exatamente quantas vezes um determinado trecho 
do código deverá ser executado. Neste caso, um teste lógico é 
realizado para determinar se o trecho do código deverá ou não 
ser executado novamente.
1 do{
2 //trecho do código que
3 //deverá ser repetido
4 }while( valor == true)
5 SUBPROGRAMAS
Os subprogramas são uma técnica de programação que tem 
como objetivo a organização do código fonte em blocos de 
instruções, que podem ser reutilizadas a qualquer momento ao 
longo do programa.
Um subprograma representa uma sequência de instruções 
com um objetivo específico, que pode ser utilizada ao ser 
adicionada (ou chamada) por um programa ou por outro 
subprograma.
A principal vantagem dos subprogramas está relacionada 
à organização do código fonte, bem como sua facilidade de 
22
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
manutenção, uma vez que cada subprograma realiza uma tarefa 
específica.
A figura abaixo ilustra o modelo de funcionamento de um 
subprograma e como é realizada a chamada ao longo do fluxo 
de execução do programa:
Programa Subprograma
início início
fim
fim
fluxo de execução
fluxo de execução
chamada do subprograma
Cada subprograma possui um único ponto de entrada, o qual 
representa seu início do fluxo de execução. Da mesma maneira, 
este subprograma contém um ponto de saída, que representa o 
final da execução das instruções do subprograma.
Quando a chamada do subprograma é acionada, o fluxo de 
execução do programa principal é suspenso, até que a execução 
do subprograma termine. Ao final da execução do subprograma, 
a execução do programa principal é retomada normalmente.
Os subprogramas são classificados em duas categorias 
denominadas funções ou procedimentos. Algumas linguagens 
de programação, (como a C, por exemplo), possuem apenas 
funções, mas permitem que uma função seja escrita na forma 
de um procedimento.
Um procedimento é a implementação mais simplificada de 
um subprograma, cujo objetivo principal é a execução de um 
23
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
conjunto de instruções. O procedimento não retorna nenhum 
tipo de resultado para o programa principal. O trecho de código 
abaixo ilustra um exemplo de procedimento na linguagem de 
programação Pascal:
1 procedure escrever();
2 begin
3 Writeln(‘Este é um exemplo de procedimento’);
4 end;
Uma função sempre retorna algum tipo de valor, por isso é 
muito semelhante às funções matemáticas. A execução de uma 
função deve obrigatoriamente retornar uma informação. Assim, 
cada vez que uma função for acionada, ao final da sua execução, 
algum tipo de retorno deve ser produzido para o ponto em que 
a função foi chamada. O trecho de código a seguir ilustra uma 
função na linguagem de programação Pascal:
1 function soma(valor1, valor2: integer): integer;
2 begin
3 //retorno da função
4 soma := valor1+valor2;
5 end;
Quando construímos subprogramas, é possível enviar 
informações a partir da unidade chamadora para o subprograma. 
Essas informações são enviadas por meio de parâmetros. 
Uma lista de parâmetros é um recurso utilizado para passar 
informações para os subprogramas. Essa lista deve conter o tipo 
de dados do parâmetro, bem como seu nome.
Existem três maneiras distintas de passagem de parâmetros, 
denominadas:
• modo de entrada - é utilizado para enviar uma informação 
da unidade chamadora para o subprograma;
24
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
• modo de saída - é utilizado para transmitir uma informação 
do subprograma para a unidade chamadora;
• modo entrada-saída - pode ser utilizado tanto para 
enviar uma informação da unidade chamadora para o 
subprograma, quanto para transmitir uma informação do 
subprograma para a unidade chamadora.
Os modelos semânticos de passagens de parâmetros estão 
ilustrados na figura:
Subprograma
entrada
Subprograma
Subprograma
saída
entrada-saída
Unidade chamadora
Unidade chamadora
Unidade chamadora
A implementação da passagem de parâmetros para um 
subprograma pode ser realizada de três maneiras:
• passagem por valor - é baseada no modo de entrada, em 
que o parâmetro é utilizado para inicializar uma variável 
local do subprograma. Essa variável é destruída ao final 
da execução do subprograma. Além disso, qualquer tipo 
de alteração realizada na variável local, não é propagada 
para a unidade chamadora;
• passagem por resultado - é baseada no modo de saída, em 
que uma variável local do subprograma é utilizada para 
transmitir uma informação para a unidade chamadora. 
Essa transmissão é realizada antes da execução do 
subprograma ser encerrada. Algumas linguagens de 
programação não permitem este tipo de passagem de 
parâmetros;
25
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
• passagem por referência - é baseada no modo de entrada-
saída. Sendo assim, a unidade chamadora transmite ao 
subprograma o endereço de memória da variável que será 
utilizada no parâmetro. Todas as alterações realizadas 
na variável do parâmetro são refletidas na unidade 
chamadora, uma vez que, as alterações são realizadas 
diretamente no endereço de memória da variável.
O trecho de código ilustra os métodos de passagem de 
parâmetros na linguagem de programação Visual C#. No 
exemplo a seguir são demonstrados os três tipos citados acima:
1 using System;
2
3 namespace PassagemParametros
4 {
5 class Program
6 {
7 //PROGRAMA PRINCIPAL
8 //Unidade chamadora
9 static void Main(string[] args)
10 {
11 //Passagem por Valor
12 int valor1 = 10;
13 Console.WriteLine(“Passagem por Valor”);
14 Console.WriteLine(“Antes = {0}”, valor1);
15 porValor(valor1);
16 Console.WriteLine(“Depois = {0}”, valor1);
17 Console.WriteLine(“”);
18
19 //Passagem por Resultado
20 int valor2;
21 Console.WriteLine(“Passagem por Resultado”);
22 //A variável não foi inicializada.
23 //Console.WriteLine(“Antes = {0}”, valor2);
24 porResultado(out valor2);
25 Console.WriteLine(“Depois = {0}”, valor2);
26
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
26 Console.WriteLine(“”);
27
28 //Passagem por Referência
29 int valor3 = 10;
30 Console.WriteLine(“Passagem por Referência”);
31 Console.WriteLine(“Antes = {0}”, valor3);
32 porReferencia(ref valor3);
33 Console.WriteLine(“Depois = {0}”, valor3);
34 Console.WriteLine(“”);
35
36
37 Console.ReadLine();
38 }
39
40 //SUBPROGRAMA: Passagem por Valor
41 static void porValor(int pValor)
42 {
43 
44 pValor = 500;
45 }
46
47 //SUBPROGRAMA: Passagem por Resultado
48 static void porResultado(outint pValor)
49 {
50 pValor = 500;
51 }
52
53
54 //SUBPROGRAMA: Passagem por Referência
55 static void porReferencia(ref int pValor)
56 {
57 pValor = 500;
58 }
59
60 }
61 }
27
PARADIGMAS DE LINGUAGENS
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
Resultado da execução do programa:
A implementação de subprogramas pode ser realizada 
utilizando um recurso interessante, denominado sobrecarga. 
Com ele é possível desenvolver diversos subprogramas com o 
mesmo nome, mas com o número de parâmetros diferentes. O 
trecho de código abaixo ilustra este conceito:
1 using System;
2
3 namespace SubProgramasSobrecarga
4 {
5 class Program
6 {
7 //PROGRAMA PRINCIPAL
8 static void Main(string[] args)
9 {
10 int v1 = 10, v2 = 20, v3 = 30, v4 = 40;
11
12 Console.WriteLine(“Soma= {0}”, soma(v1,v2));
13 Console.WriteLine(“Soma = {0}”, soma(v1, v2,v3));
14 Console.WriteLine(“Soma = {0}”, soma(v1, v2,v3,v4));
15 Console.ReadLine();
16 }
17
18 static int soma(int valor1, int valor2)
28
Unidade I
Re
vi
sã
o:
 C
ris
tin
a 
- 
Di
ag
ra
m
aç
ão
: F
ab
io
 -
 2
8/
01
/1
1 
-|
|-
 2
ª R
ev
isã
o:
 C
ris
tin
a 
- 
Co
rr
eç
ão
: F
ab
io
 -
 0
3/
02
/2
01
1
19 {
20 return (valor1+valor2);
21 }
22
23 static int soma(int valor1, int valor2, int valor3)
24 {
25 return (valor1+valor2+valor3);
26 }
27
28 static int soma(int valor1, int valor2, int valor3, int valor4)
29 {
30 return (valor1 + valor2 + valor3+valor4);
31 }
32
33 }
34 }
Resultado da execução do programa:
6 CONSIDERAÇÕES FINAIS
Nesta unidade você estudou sobre os principais conceitos 
dos paradigmas de linguagens e aprendeu sobre os tipos de 
dados, as expressões aritméticas e relacionais, as instruções 
de atribuições, as estruturas de controle e os subprogramas. 
Aproveite os exercícios para aprimorar seu conhecimento.