introducao_1

Prévia do material em texto

Linguagens de Programação 
Prof. Marco Túlio Valente 
Prof. César Francisco de Moura Couto 
Prof. Pedro Felipe 
 
Introdução 
§  Definição de Linguagem de Programação (LP): 
§  Notação para descrição de algoritmos e estruturas de 
dados 
§  Requisitos de uma LP: 
§  Gramática (sintaxe) e significado (semântica) bem 
definidos 
§  Implementável (executável) com eficiência ‘‘aceitável’’ 
§  Universal: é possível expressar todo problema 
computável 
Paradigmas de Programação 
§  Definição: 
§  Modelo, padrão ou estilo de programação suportado por 
determinado grupo de linguagens 
§  Paradigmas: 
§  Paradigma Imperativo 
§  Paradigma Funcional 
§  Paradigma Lógico 
Paradigma Imperativo 
§  Definição: 
§  Programas centrados no conceito de um estado 
(“variáveis”) e ações (“comandos”) que manipulam este 
estado 
§  Primeiro paradigma a surgir e ainda é o dominante 
§  Baseado no Modelo de von Neumann 
§  Vantagens: 
§  Eficiência (arquiteturas atuais são von Neumann) ‏ 
§  Modelagem “natural” de aplicações do mundo real 
§  Paradigma mais do que estabelecido 
§  Desvantagens: 
§  Implementações demasiadamente operacionais (definem 
“como fazer” e não “o que fazer”)‏ 
 
Paradigma Funcional 
§  Definição: 
§  Programas são funções entre E/S 
§  Estilo declarativo: sem conceito de estado e comando 
atribuição 
§  Exemplo (em Haskell): 
 quadrado :: Int -> Int 
 quadrado n = n*n 
 duasVezes :: (Int -> Int) -> (Int -> Int)‏ 
 duasVezes f = f . f -- função quartaPot? 
 quartaPot = duasVezes(quadrado)‏ 
 quartaPot(2) retorna 16 
§  Uso extensivo de recursividade, funções de alta ordem, 
polimorfismo e avaliação lazy. 
Paradigma Lógico 
§  Definição: 
§  Programas são relações entre E/S 
§  Estilo declarativo 
§  Exemplo (Prolog): 
estrela (sol)‏ 
orbita (terra, sol)‏ 
orbita (marte, sol)‏ 
planeta (P) :- orbita (P, sol)‏ 
§  Execução de um programa Prolog: 
-: planeta (terra) ? 
 yes 
§  Aplicações: Inteligência Artificial 
Paradigma Orientado por Objetos 
§  Definição: 
§  Programas estruturados em módulos (classes) que 
agrupam um estado (atributos) e operações (métodos) 
sobre este estado 
§  Classes podem ser estendidas, via herança, e usadas 
como tipos (cujos elementos são objetos)‏ 
§  Ênfase em reutilização de código 
§  Uso mais comum junto com o paradigma imperativo 
§  Embora, existam por exemplo versões de Lisp OO, como 
CLOS 
 
Programação Orientada por Objetos 
Prof. César Francisco de Moura Couto 
 
 
9 
Programação Orientada por Objetos 
§  Paradigma de programação dominante 
§  Linguagens pioneiras: Simula 67 
§  Outras linguagens: C++, Java, C#, Eiffel 
§  Principais conceitos: 
§  Classes e objetos, herança e polimorfismo de inclusão 
§  Classes são tipos usados para instanciar objetos 
§  Objetos (de uma classe) encapsulam tanto: 
§  Estado (dados) ‏ 
§  Operações que manipulam estes dados 
§  Objetos são úteis para modelar entidades 
§  do mundo real: pessoa, funcionário, professor, aluno, 
conta bancária, pedido de compra etc 
§  abstratas: pilha, lista, arquivo, expressão, frame etc 
10 
Classes 
§  Classes permitem declarar: 
§  Dados (definem o estado de um objeto)‏ 
§  Operações (acessar e alterar estado do objeto) ‏ 
§  Exemplo: 
 
class Figura { 
 .... 
 private int x, y; 
private int color; 
..... 
public int getColor() { ..... } 
public void setColor(int color) { ..... } 
........ 
} 
 
11 
Encapsulamento 
§  Classes devem prover ocultamento de informação (ou 
encapsulamento) de seus membros 
§  Deve ser permitido ao implementador informar: 
§  O que é visível aos clientes da classe (interface) ‏ 
§  O que é de uso privativo da classe (implementação) ‏ 
§  Membros podem ser: 
§  privados: usados apenas no corpo da classe 
§  públicos: usados em qualquer ponto do programa onde 
o nome da classe é visível 
§  protegidos: usados apenas no corpo da classe e das 
classes derivadas 
Encapsulamento 
§  Objetivos: 
§  Definir um contrato entre clientes e implementadores 
§  Independência entre clientes e implementadores 
§  Recurso essencial em grandes sistemas 
13 
Classes e TADs 
§  Classes são instrumentos úteis para implementar Tipos 
Abstratos de Dados (TAD)‏ 
§  Descrição de um tipo por meio de um conjunto de 
operações públicas 
§  Implementação do tipo é mantida oculta de seus 
clientes 
§  Exemplo: TAD Pilha (de elementos do tipo T)‏ 
§  Operações: 
void empilha (T item); 
T desempilha(); 
T topo(); 
boolean vazia(); 
14 
Classes Genéricas 
§  Classes que fazem uso de parâmetros 
§  Exemplo: 
template <class T> class Pilha { 
 int topo; 
 T vetor [100]; 
 public: 
 void empilha (T x); 
 T desempilha (); 
}; 
§  Instanciação: 
Pilha<int> p1; 
Pilha<float> p2; 
§  Principal utilidade: reúso de código 
§  Viabiliza polimorfismo paramétrico 
15 
Herança 
§  Permite definir uma nova classe que herde todos os 
membros “classe pai” 
§  Nova classe: subclasse 
§  Classe pai: superclasse 
§  Subclasse herda todos os membros da classe pai 
§  Inclusive membros privados (não podem ser usados na 
subclasse, mas existem em seus objetos)‏ 
§  Subclasse pode: 
§  Redefinir (sobrescrever) membros herdados 
§  Definir novos membros 
 
 
16 
Herança 
§  Exemplo: 
class Circulo extends Figura { 
 .... 
private double raio; 
..... 
public int getDiametro() { ..... } 
........ 
} 
§  Classe Circulo é uma subclasse de Figura; por sua vez, 
Figura é a superclasse de Circulo 
§  Circulo herda membros de Figura (x,y, color, getColor, etc)‏ 
§  Circulo acrescenta seus próprios membros 
§  Principal utilidade: reúso de código 
§  Viabiliza polimorfismo de inclusão 
17 
Herança Simples e Múltipla 
§  Herança 
§  Simples: classe pode ter no máximo uma superclasse 
§  Múltipla: classe pode ter mais de uma superclasse 
§  Herança múltipla possui problemas de ordem conceitual e 
de implementação: 
§  Problemas conceituais: 
§  Colisão de Nomes: g () definido em B2 e em B3 
§  Herança Repetida: f () definido em A 
 
 
A
C
B1 B3B2
f ()
g () g ()
18 
Chamada Dinâmica de Métodos 
§  Tipo Estático x Tipo Dinâmico: 
§  Tipo Estático: tipo com que uma variável foi declarada 
§  Tipo Dinâmico: tipo da variável em tempo de execução 
§  Atribuição Polimórfica: 
§  x= y é válida se tipo de y for subclasse do tipo de x 
§  Altera tipo dinâmico de x 
§  Chamada dinâmica (dynamic dispatching)‏ 
§  Tipo dinâmico de uma variável determina qual 
implementação de método será executada 
§  Exemplo: 
Figura f; Circulo c= new Circulo(10); 
f= c; 
f.draw(); 
19 
Classes Abstratas 
§  Classes que podem possuir um ou mais métodos sem 
implementação (chamados de métodos abstratos) ‏ 
§  Exemplo: 
abstract class Figura { 
 .... 
 public abstract void draw(); // não possui implementação 
 .... 
} 
§  Métodos abstratos são implementados nas subclasses 
§  Não é permitido instanciar objetos de classes abstratas 
§  Utilidade: 
§  Funcionar como raiz de uma hierarquia de classes 
§  Viabilizando chamadas dinâmicas em métodos de 
objetos dessa hierarquia 
20 
Herança e Classes Abstratas 
class Ponto { 
 private int x, y; 
 public int getX() { ... } 
 public int getY() { ... } 
 public void setX(int x) { ... } 
 public void setY(int y) { ... } 
 public void draw(Graphics g) { ... } 
 public void refresh() { 
 draw(Canvas.getGraphics());} 
} 
class Linha { 
 private Ponto p1, p2; 
 public int getP1() { ... } 
 public int getP2() { ... } 
 public void setP1(Ponto p) { ... } 
 public void setP2(Ponto p) { ... } 
 public void draw(Graphics g) { ... } 
 public void refresh() { 
 draw(Canvas.getGraphics()); 
 } 
} 
21 
Herança e Classes Abstratas 
class Ponto extends Figura { 
 private int x, y; 
 public int getX() { ... } 
 public int getY() { ... } 
 public void setX(int x) { ... } 
 public void setY(int y) { ... } 
 public void draw(Graphics g) { ... } 
 
 
 
} 
class Linha extends Figura { 
 private Ponto p1, p2; 
 public int getP1() { ... } 
 public int getP2() { ... } 
 public void setP1(Ponto p) { ... } 
 public void setP2(Ponto p) { ... } 
 public void draw(Graphics g) { ... } 
 
 
 
} 
abstract class Figura { 
 public abstract void draw(Graphics g); 
 public void refresh() { 
 draw(Canvas.getGraphics()); 
 } 
}