poo

Programação Orientada por Objetos

Prof. Rogério Celestino dos Santos

http://sites.google.com/site/rogeriocsaulas/

Fonte: Material do Prof. Marco Túlio de Oliveira Valente

Programação Orientada por Objetos

 _{Paradigma de programação dominante}

 _{Linguagens pioneiras: Simula 67 e Smalltalk}

 _{Outras linguagens: C++, Java, C#, Eiffel, Ada95}  _{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

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) { ... } ...

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

 _Objetivos:

 _{Definir um contrato entre clientes e implementadores}  _{Independência entre clientes e implementadores}

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();

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}

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}

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}

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 B2 B3

f ()

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;

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}

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()); }

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()); }

Exercícios

1. O que é um classe? 2. O que é um objeto ?

3. De um exemplo de uma classe e de um objeto. 4. Qual objetivo do encapsulamento ?

5. Qual objetivo da herança ?

6. O que é herança simples e herança multipla ? 7. Qual utilidade de uma classe abstrata ?

8. É possível instanciar objetos de um classe abstrata ? 9. Exemplifique o uso de uma classe abstrata?

Java

Prof. Rogério Celestino dos Santos

Fonte: Material do Prof. Marco Túlio de Oliveira Valente

Introdução

 _{Desenvolvida por James Gosling e equipe (Sun, 1995)}  _{Linguagem compilada e posteriormente interpretada}  _{bytecode: linguagem intermediária}

 _{Assembly de uma máquina hipotética}

 _{Máquina Virtual Java: interpretador de bytecodes}  _{Não é novidade: Pascal-P (Wirth, década de 70)}  _{Mesma estratégia em C#: CLR e CIL (ou MSIL)}  _{Vantagem: portabilidade} COMPILADOR MÁQUINA VIRTUAL JAVA - JVM (INTERPRETADOR) prog1.class (bytecodes) prog1.java (fonte)

Primeiro Programa

// arquivo HelloWorld.java public class HelloWorld {

public static void main(String[ ] args){ System.out.println (“Hello, world”); }

}

 _{Todo arquivo deve ter uma classe pública com o mesmo}

nome do arquivo

 _{Execução começa pelo método main desta classe}  _{Observações:}

 _{Programa em Java é um conjunto de classes}

Classes

 _Exemplo:

class Data {

private int dia, mes, ano; ....

Data(int dia, int mes, int ano) { // metodo construtor this.dia= dia; this.mes= mes; this.ano= ano;

} ... }

 _{Método construtor: usado para inicializar objeto}  _{Construtor tem o mesmo nome da classe}

 _{this: variável automaticamente declarada em um método}  _{Referencia o objeto alvo da chamada}

Classes

 _{Encapsulamento de membros:}

 _{public: em qualquer lugar onde a classe for acessível}  _{private: apenas dentro dos métodos da classe}

 _{protected: dentro dos métodos da classe, de suas}

subclasses e de classes do mesmo pacote (package)

Objetos

 _{Operador new: usado para instanciar um objeto}  _Exemplo:

Data d1= new Data(1,2,2008); // instanciação

Data d2= new Data(25,12,2007);

d1.imprime(); // chamada de método

 _{Programas em Java possuem duas áreas de memória:}  _{Heap: onde são alocados objetos criados via new}

 _{Stack: onde são alocadas variáveis locais de métodos}

ativados

 _{Dois tipos de valores podem ser armazenados no stack:}  _{Primitivos: byte,short,int,long,float,double,boolean,char}  _{Referências (ou “ponteiros”) para objetos}

Coleta de Lixo

 _{Objetivo: Evitar que programador tenha que se preocupar}

com a liberação de memória alocada no heap

 _{Programador aloca, mas não precisa liberar memória}  _{Tarefa normalmente sujeita a diversos erros}

 _{Funcionamento:}

 _{Existe na JVM um processo, chamado coletor de lixo,}

que fica continuamente procurando por objetos que não estão sendo mais referenciados

 _{Quando encontra um objeto inacessível, o coletor de}

lixo libera a área de memória alocada para o mesmo

 _{Não se tem controle sobre o momento em que o}

coletor de lixo roda

Exemplo de Coleta de Lixo

class BigClasse { private int x;

private int bigvetor [ ]; // vetor de inteiros public BigClasse (int x1) { // construtora System.out.println ("Criando " + x1); x= x1;

bigvetor= new int [1024*1024]; }

protected void finalize () {

System.out.println("Eliminando " + x); }

Exemplo de Coleta de Lixo

public class Exemplo2 {

public static void main(String[] args) { BigClasse p;

for (int i= 0; i < 100; i++) p= new BigClasse (i); }

}

 _{Método finalize(): chamado automaticamente pelo coletor}

antes de liberar a área de memória de um objeto

 _{Utilidade: liberar outros recursos (que não memória)}  _{Exemplo: fechar arquivos, fechar conexões etc}

 _{Chamado no máximo uma vez por objeto, mesmo que sua}

execução “ressucite” o objeto

Atributos Estáticos

 _{Pertencem à classe e não a cada objeto individualmente}  _Exemplo:

class Conta { ... double saldo;

static double saldoMinimo= 500; ... }

 _{Externamente, são acessados via nome da classe}  _{Exemplo: System.out.prinln(Conta.saldoMinimo);}

 _{Atributos estáticos e finais: são constantes}

 _{Não podem ser alterados, após terem sido inicializados}  _Exemplo:

class Math { ...

public static final double PI = 3.1415; }

Métodos Estáticos

 _{Pertencem à classe e, portanto, não são invocados sobre}

um objeto alvo

 _Exemplo:

class Math { ...

public static double sin (double x) { ... } } ...

double x= Math.sin (90);

 _{Podem acessar apenas atributos e métodos estáticos}  _{Não podem acessar a referência this}

Passagem de Parâmetros e Sobrecarga

 _{Passagem de parâmetros:}  _{Sempre por valor}

 _{Mesmo que o parâmetro seja uma referência para um}

objeto (e essa referência seja usada no corpo do método para alterar o estado do objeto no heap)

 _{Métodos (e construtores) sobrecarregados:}

 _{Mesmo nome}

 _{Número e tipos de parâmetros diferentes}

 _{Para fins de sobrecarga, não se considera o tipo de}

retorno e as exceções levantadas pelo método

Herança

 _{Java possui Herança Simples}

class Figura { ....

}

class Quadrado extends Figura { ...

}

 _{Classe Object: raiz da hierarquia de classes de Java}

 _{Toda classe (diretamente ou indiretamente) é subclasse}

de Object

 _{Utilidade: variável do tipo Object pode se referir a qualquer}

objeto (de qualquer classe)

Redefinição de Métodos

 _{Quando uma subclasse reimplementa um método herdado}

da superclasse

 _{Reimplementação deve manter assinatura da superclasse}

(regra da invariância)

 _Exemplo:

public class Superclass {

public void printMethod() {

System.out.println("Printed in Superclass."); }

Redefinição de Métodos

public class Subclass extends Superclass { public void printMethod() { // redefinição

super.printMethod(); // acesso a método da

superclasse

System.out.println("Printed in Subclass"); }

public static void main(String[] args) { Subclass s = new Subclass();

s.printMethod(); }

Classes e Métodos final



_{Evitando herança:}

final class Senha { ... }

class MinhaSenha extends Senha { ... } // Erro !



_{Evitando redefinição de métodos:}

class Senha { ...

public final bool validarSenha () { ... } ....

}

class MinhaSenha extends Senha { ... bool validarSenha () { ... } // Erro ! ...

Chamada Dinâmica de Métodos

 _{Métodos são chamados utilizando o tipo dinâmico de uma}

referência.

 _Exemplo:

Figura p; if ( .... )

p= new Quadrado (4); // atribuição polimórfica

else p= new Circulo (3); // atribuição polimórfica

Classes Abstratas

 _Exemplo:

abstract class Figura {

public abstract double area ();

public abstract double perimetro (); }

 _{Implementação de area() e perimetro() ficará a cargo das}

Packages

 _{Recurso para modularização de programas Java}  _{Package: conjunto de arquivos}

 _{Cada arquivo pode possuir, no máximo, uma classe}

pública

 _{O nome do arquivo é o mesmo de sua classe pública}  _{Todo pacote possui um nome}

 _{Exemplo: pacote figuras, com classes públicas Figura,}

Circulo, Quadrado

 _{Arquivo c:\temp\figuras\Figura.java:}

package figuras;

public abstract class Figura { ... } // outras classes (não-públicas)

Packages

 _{Exemplo (continuação):}

 _{Arquivo c:\temp\figuras\Circulo.java}

package figuras;

public class Circulo { ... } // outras classes (não-públicas)

 _{Arquivo c:\temp\figuras\Quadrado.java}

package figuras;

public class Quadrado { ... } // outras classes (não-públicas)

 _{Nome do pacote deve ser igual ao nome do diretório que}

contém seus arquivos

 _{Variável de ambiente CLASSPATH: deve conter o nome}

do diretório onde se encontra o diretório do pacote

Packages

 _{Classes públicas de um pacote podem ser usados fora do}

pacote da seguinte forma:

 _{Via qualificação com o nome do pacote:}

figuras.Figura fig; figuras.Circulo c;

java.awt.Button btnOk;

 _{Via comando import no início doarquivo:}

import figuras.*; // importa todas classes do pacote figuras import java.awt.Button; // importa apenas classe Button

... Figura fig; Circulo c;

Interfaces

 _{Uma interface é um tipo (assim como uma classe)}

 _{Uma interface define apenas a assinatura de um conjunto}

de métodos (ou seja, são similares a classes abstratas)

 _{Uma classe pode declarar que implementa (implements)}

uma interface

 _{Neste caso, ela assume o compromisso de implementar}

todos os métodos desta interface

 _Exemplo:

interface Comparavel {

int compare(Comparavel obj); }

Interfaces

 _Exemplo:

class Aluno extends Pessoa implements Comparavel { int compare(Comparavel obj) {

Aluno obj2= (Aluno) obj;

“compara this.matr com obj2.matr; retorna –1, 0 ou 1” }

}

 _{Exemplo: suponha um método de ordenação}

 _{void ordena(Comparavel [] lista)}

 _{Qual a vantagem em relação a uma classe abstrata?}  _{Se Comparavel fosse uma classe abstrata, Aluno não}

poderia herdar de Pessoa

Classes Genéricas

 _Motivação:

List v = new ArrayList(); // List é uma lista de Object v.add("test");

String a = (String) v.get(0);

Integer b = (Integer) v.get(0); // erro em tempo de execução

 _{Usando classes genéricas:}

// List agora é uma lista de strings

List <String> v = new ArrayList <String> (); v.add("test");

String a = v.get(0);

Classes Genéricas

 _{Declarando uma classe genérica:}

class Pair <T, S> { private T first; private S second; public Pair(T f, S s) { first = f; second = s; }

public T getFirst() { return first; }

public S getSecond() { return second; } public String toString(){

return "("+first.toString()+", "+second.toString()+")"; }

Classes Genéricas

 _{Usando uma classe genérica:}

Pair<String, String> p1=new Pair<String, String>(“maria", "A"); Pair<String, Integer> p2=new Pair<String, Integer>(“maria", 100); System.out.println("P1:"+p1.toString());

C++

Prof. Marco Túlio de Oliveira Valente

Fonte: Material do Prof. Marco Túlio de Oliveira Valente

C++

 _{Criada por Bjarne Stroustrup}

 _{AT&T Bell Labs, a partir de 1979}

 _{Objetivo: introduzir conceitos de OO em C}  _{Inicialmente, chamava-se “C com Classes”}  _{Principais conceitos de OO}

 _{Classes, inclusive genéricas e abstratas}  _{Herança (simples e múltipla)}

 _Polimorfismo

Exemplo de Classe

class Cubo {

private: // membros privados

int altura, largura, prof; // atributos

public: // membros públicos

Cubo (int, int, int); // função construtora

int volume (); // métodos

};

Cubo::Cubo (int a, int l, int p) // Construtora

{ altura= a; largura:= l; prof:= p }

Exemplo de Classe

main () {

Cubo cb (7,8,9); // declara objeto e chama construtora cout << cb.volume();

}

 _{Controle de visibilidade: membros de uma classe podem}

ser

 _{public: podem ser usados em qualquer ponto do}

programa

 _{private: podem ser usados apenas em métodos da}

própria classe (visibilidade default)

 _{protected: podem ser usados apenas em métodos da}

Funções Construtora e Destruidora

 _{Função construtora:}

 _{Mesmo nome da classe}

 _{Chamada automaticamente na declaração de objetos}

da classe

 _{Utilizada para inicializar atributos da classe}  _{Função destruidora:}

 _{Nome da classe, prefixado por ~}

 _{Chamada implicitamente quando termina o escopo de}

um objeto da classe

 _{Usada para liberar memória alocada no heap, fechar}

Herança

 _{Mecanismo para construir novas classes (chamadas de classes} derivadas ou subclasses) a partir de classes já existentes

(chamadas de classes base ou superclasses)

 _{Objetivo: reutilização de código (subclasse herda atributos e} métodos da superclasse)

class Hora {

int hora, min, seg; public:

Hora (int h, int m, int s) // construtora

{ hora= h; min= m; seg= s; } void imprime ()

{ cout << hora << “:” << min << “:” << seg; } };

Exemplo de Herança

class HoraCompleta: public Hora { protected:

char *fuso; // Fuso horário: “FNO”, “BRA”, “AMZ” ou “ACR” public:

HoraCompleta (int h, int m, int s, char *fs): Hora (h, m, s) { fuso= fs;

}

void imprime () {

Hora::imprime (); // chama imprime da superclasse cout << “ “ << fs;

} };

Herança Múltipla

 _Exemplo:

class aviao { ... } class barco { .... }

class hidroaviao: public aviao, public barco { .... }

 _{A subclasse hidroaviao herda todos os atributos e métodos}

Colisão de Nomes

class A { class B {

public: void f () { .... } public: void f () { .... }

}; };

class C: public A, public B { public:

void g () {

f(); // Erro ! Ambíguo, qual f ?

A::f (); // OK, qualificação (operador ::) com o nome B::f (); // da classe remove ambigüidade

Herança Repetida

class A { public: int x; ...}; class B1: public A {.... }; class B2: public A {.... };

class C: public B1, public B2 { public:

void g () {

x= 2; // Erro

B1::x= 3; // OK, cópias diferentes de x B2::x= 4; // OK, cópias diferentes de x }

Classe Base Virtual

 _{Classe base virtual: usada para evitar que uma superclasse}

seja herdada mais de uma vez

class A { public: int x; ...};

class B1: public virtual A {.... }; // classe base virtual class B2: public virtual A {.... }; // classe base virtual class C: public B1, public B2 {

public:

void g () {

x= 2; // OK

B1::x= 3; B2::x= 4; // OK, mesma cópia de x }

Polimorfismo

 _{Um apontador para uma classe base pode apontar para um}

objeto de uma classe dela derivada

 _Exemplo:

HoraCompleta hc (15,25,18, “BRA”); Hora *ph;

ph= &hc; // atribuição polimórfica

 _{Somente apontadores possuem tipo estático e dinâmico.}  _{Tipo Estático: tipo com que o apontador foi declarado.}

Exemplo: Hora

 _{Tipo Dinâmico: tipo para o qual o apontador se refere em}

tempo de execução. Exemplo: HoraCompleta

 _{Atribuições polimórficas alteram o tipo dinâmico de um}

Funções Virtuais

 _{Chamadas utilizando o tipo dinâmico de um apontador}

class Hora { ....

virtual void imprime () { .... } }

class HoraCompleta: public Hora { .... virtual void imprime () { .... }

}

main () {

HoraCompleta hc (21, 42, 12, “BRA”);

Hora *ph= &hc; // atribuição polimórfica ph->imprime (); // imprime: 21:42:12 BRA }

Classes Abstratas

 _{Classes que possuem uma ou mais funções virtuais puras,}

isto é, funções que não possuem implementação

 _{Não se pode criar objetos de classes abstratas}  _Exemplo:

class Poligono { ....

virtual float perimetro() = 0; // função virtual pura }

...

Poligono t; // Erro !

 _{Utilização:}

 _{Projeto OO}

Ponteiro this

 _{Toda classe possui um ponteiro de nome this, que, dentro}

de um método da classe, aponta para o objeto que está sendo manipulado por este método (objeto receptor).

 _{Útil quando se precisa passar o objeto receptor como}

Exemplo de Uso do this

Pilha undo;

class Circulo: public Poligono { int raio; ...

void aumenta_tam (int dr); ....

}

void Circulo::aumenta_tam (int dr) {

undo.empilha (this); // salva circulo corrente na pilha de undo raio= raio+dr;

... // redesenha circulo com novo tamanho }

... Circulo c (10);

Membros Estáticos

 _{Atributo estático: atributo que pertence à classe, sendo}

compartilhado por todos os objetos da mesma.

 _{Exemplo: atributo para armazenar o número de objetos já}

criados de uma classe class Circulo {

int raio;

static int total_circulos; // atributo estático

public:

Circulo (int r); void imprime(); };

Membros Estáticos

int Circulo::total_circulos= 0; // inicializa atributo estático Circulo::Circulo (int r) { raio= r; total_circulos++; }

void Circulo::imprime ()

{ cout << "\nTotal circulos: " << total_circulos; } ...

Circulo c1 (10) Circulo c2 (27); c1.imprime(); c2.imprime();

Métodos Estáticos

 _{Métodos Estáticos: podem ser chamados sobre a classe e}

não sobre um objeto da mesma

 _{Somente podem acessar atributos estáticos da classe}  _{Não possuem o ponteiro this}

class Circulo { int raio;

static int total_circulos; // atributo estático public:

Circulo (int r);

static void imprime(); // método estático

Métodos Estáticos

int Circulo::total_circulos= 0; // inicializa atributo estático Circulo::Circulo (int r) { raio= r; total_circulos++; }

void Circulo::imprime () // somente acessa atributos estáticos { cout << "\nTotal circulos: " << total_circulos; }

...

Circulo c1 (10) Circulo c2 (27); ...

Classes Genéricas

 _{Classes Genéricas: permitem parametrizar a}

implementação de classes

 _{Exemplo: pilha de inteiros}

class pilha {

int topo; int vetor [100]; public:

pilha ();

void empilha (int x); int desempilha ();

Classes Genéricas

pilha::pilha () { topo= 0; }

void pilha::empilha (int x) { vetor [topo++]= x; } int pilha::desempilha () { return vetor [--topo]; }

 _{Mas e se pilha de float ? Ou de char ?}

 _{Solução “braçal”: “copiar e colar” + “trocar”}

 _{Classes Genéricas: parametrizar uma classe com um}

parâmetro de tipo

 _{“copiar e colar” + “trocar” a cargo do compilador}  _{Chamadas em C++ de templates.}

Templates: Definição

template <class T> class pilha_gen { int topo; T vetor [100]; public: pilha_gen (); void empilha (T x); T desempilha (); };

template <class T> pilha_gen<T>:: pilha_gen () { topo= 0; }

template <class T> void pilha_gen<T>:: empilha (T x) { vetor [topo++]= x; } template <class T> T pilha_gen<T>:: desempilha () { return vetor [--topo]; }

Templates: Instanciação

void main () { int i; float x;

pilha_gen<char> pchar; // pchar: pilha de char pilha_gen<float> pfloat; // pfloat: pilha de float for (i=0; i < 10; i++)

pfloat.empilha (3.14 * i); for (i=0; i < 10; i++) {

x= pfloat.desempilha (); cout << x << “\n”;

} ... }

Templates: Comentários Finais

 _{Em C++, pode-se também parametrizar uma classe com}

parâmetros que não sejam tipos

template <class T, int tam> class pilha_gen { int topo; T vetor [tam]; ...

}

 _{C++ implementa apenas generalidade irrestrita}

 _{Não é possível restringir os tipos a serem instanciados}  _{C++ implementa templates com uma semântica de}

macro-expansão

Tratamento de Exceções

Prof. Marco Túlio de Oliveira Valente

Fonte: Material do Prof. Marco Túlio de Oliveira Valente

Seqüenciadores

 _{Definição: construção que altera o fluxo de execução}

normal de um programa

 _{Principais tipos de seqüenciadores:}  _{Saltos, Escapes e Exceções}

 _{Saltos (jumps):}

 _{Sintaxe: goto L, onde L é um label}

 _{Permite que um bloco de comandos possua várias}

entradas e várias saídas

 _{Desvantagem: legibilidade}  _Escapes:

 _{Exemplos (em C) : break, return, halt}

 _{Permite que um bloco de comandos tenha múltiplas}

Exceções: Introdução

 _{Programas devem tratar erros ou situações não previstas:}  _{Exemplos: divisão por zero, Indexação de um vetor}

além de seus limites, overflow em uma operação aritmética, memória insuficiente, disco cheio etc

 _{Ausência de tratamento: graves conseqüências}

 _{Exemplo: explosão do foguete Ariane 5 em 1996}

devido a um overflow em uma operação de ponto flutuante em um programa desenvolvido em ADA

 _{Problema: formas convencionais “poluem” o programa}

com código para tratamento de erros

 _{Chegando a 2/3 do código em alguns programas}  _{Solução: exceções}

Exceções: Introdução

 _{Exceção: erro ou um estado imprevisto, que não ocorre com} freqüência

 _{Idéia: remover o tratamento de erros do fluxo normal de} execução, de forma a não “poluir” o código.

 _{Tratador (ou Manipulador) de Exceção: bloco de código para} onde a execução é desviada quando ocorre uma exceção  _{Primeira linguagem: PL/I (1964)}

 _{Atualmente: ADA, C++, Java etc}

 _{Exceções em linguagens de programação:}  _{Como ativar uma exceção ?}

 _{Como especificar um tratador de exceções ?}

 _{Como exceções são propagadas?}

Tratamento de Exceções em C++

 _{Como ativar uma exceção em C++ ?}

 _{Através do comando throw <expressão>}  _Exemplo:

class DivisaoPorZero { } ;

double divisao (double x, double y) { if (y = = 0)

throw DivisaoPorZero (); // ativa (ou levanta) exceção return x / y;

}

 _{throw: abandona execução do bloco corrente e passa a}

Tratamento de Exceções em C++

 _{Como especificar um tratador de exceções em C++ ?}  _{Através dos comandos:}

try { ... } // comandos que podem ativar exceções catch (parâmetro formal) { ... } // tratador

catch (parâmetro formal) { ... }

 _{Exceções ocorridas no interior de um try são transferidas}

para o catch correspondente

 _Exemplo:

try { ...

divisao (5.0, 0.0); // ativa uma exceção ...

}

catch (DivisaoPorZero) { // “captura” exceção ...; cout << “divisão por zero”; ...

Exemplo 2

Sem Tratamento de Exceções:

ok= AbraArquivo (nome); if (ok) {

tam= TamanhoArquivo (nome); if (tam != 0) { p= AloqueMemoria (tam); if (p != NULL) { ... } else { ... } } else { ... } } else { ... }

Com Tratamento de Exceções :

try {

abraArquivo (nome);

tam= TamanhoArquivo (nome); p= AloqueMemoria (tam); ... } catch (ExcecaoAberturaArquivo) { ... } catch (ExcecaoTamanhoArquivo) { ... } catch (ExcecaoAlocacaoMemoria) { ... }

Como exceções são propagadas ?

 _{Exceções são propagadas automaticamente, terminando}

cada um dos blocos e funções do programa, até se

encontrar um tratador com parâmetro formal do mesmo tipo do objeto especificado na ativação da exceção.

 _{Em outras palavras, procura-se na pilha de ativação de}

blocos e funções, o primeiro catch que trate a exceção ativada

 _{Como um tratador é escolhido ?}

catch (A) { ... } // captura exceções da classe A e das subclasses de A catch (B) { .... } // captura exceções da classe B e das subclasses de B catch (...) { ... } // captura exceções de qualquer classe (catch-all)

Exemplo 3

void f (int a) { cout << "f-inicio "; try { divisao (5.0, a); } catch (Overflow) { cout << "f-over"; } cout << "f-fim "; } void g () { int a; cout << "g-inicio "; try { cin >> a; f (a); } catch (DivisaoPorZero) { cout << "g-div0 "; } cout << "g-fim "; }

void main () { // Resultado:

g (); // a= 1: g-inicio f-inicio f-fim g-fim

Retorno ao Fluxo Normal Execução

 _{Como retornar ao fluxo normal de execução após tratar}

uma exceção ?

 _{Basta que encontre-se um bloco catch que trate o tipo da}

exceção levantada

 _{Este bloco é então executado;}  _{A exceção é desativada;}

 _{E a execução prossegue na linha seguinte ao bloco}  _{Como reativar uma exceção dentro de um bloco catch ?}

 _{Através do comando throw}  _Exemplo:

catch (A) { ...

throw; // reativa exceção do tipo A ...

Sobrecarga de Operadores em C++

 _{Objetivo: permitir que operadores (+, -, * etc) sejam usados}

para operar com outros tipos que não os tipos primitivos

 _Exemplo:

class Complexo {

double re, im; public:

Complexo (double r, double i); Complexo ();

Complexo operator+ (Complexo b); };

Complexo::Complexo (double r, double i) { re= r; im= i;} Complexo::Complexo () { re= im= 0;}

Sobrecarga de Operadores em C++

Complexo Complexo::operator+ (Complexo b) { Complexo res (0,0); res.re= re + b.re; res.im= im + b.im; return res; } void main() { Complexo a (2.4, 3.2); Complexo b (0.6, 1.8); Complexo c; c= a + b; // a + b ⇔ a.operator+ (b) }

Exemplo 4: Classe Vetor

 _{Implementar uma classe vetor que ative uma exceção no}

caso de se tentar acessar um índice fora dos limites permitidos

class IndiceForaDeFaixa { public:

int indice;

IndiceForaDeFaixa (int i) { indice= i; } };

Exemplo 4: Classe Vetor

class Vetor {

int tam; // numero de elementos do vetor int *elem; // elementos do vetor

public:

Vetor (int n) { // construtora elem= new int [n]; tam= n; }

int& operator[ ] (int i) { // Sobrecarga de operador: v[i] ⇔ v.operator[ ](i)

if ((i < 0) || (i >= tam))

throw IndiceForaDeFaixa (i); return elem[i];

} };

Exemplo 4: Classe Vetor

void main () { Vetor v(10);

for (int i= 0; i < 10; i++) v[i]= 10*i;

try {

cout << v[11]; }

catch (IndiceForaDeFaixa i) {

cout << "indice " << i.indice << " fora de faixa"; }

Tratamento de Exceções em Java

 _{Como ativar uma exceção: throw <expressão>}

 _{Expressão deve ser um objeto de uma classe derivada}

da classe pré-definida Exception

 _{Similar a C++, porém incluir um new para criar objeto}  _{Métodos devem relacionar na clásula throws todas as}

exceções que podem encerrar a execução do mesmo

 _Exemplo:

class DivisaoPorZero extends Exception { } ; ...

double divisao (double x, double y) throws DivisaoPorZero{ if (y = = 0)

throw new DivisaoPorZero (); // ativa (ou levanta) exceção return x / y;

Tratamento de Exceções em Java

 _{Como especificar um tratador de exceções ?}

try { ... } // comandos que podem ativar

exceções

catch (ExceptionType ident ) { ... } // tratador de exceções catch (ExceptionType ident) { ... }

finally { .... } // opcional

 _{Código do finally é executado ocorrendo ou não uma exceção no} try

 _Exemplo:

try { ... }

catch (A e) { .... } finally { ... }

 _{Neste exemplo, o bloco finally será executado quando:}  _{try terminar corretamente, sem ativação de nenhuma}

exceção

Tratamento de Exceções em Java

 _{Bloco finally é usado para liberar algum recurso que foi}

alocado

 _{Exemplo: processar um arquivo, sendo que em caso de}

erro deve-se fechar o arquivo e propagar a exceção.

 _{Sem finally:}

file.open();

try { ... } // processamento do arquivo catch (IOException e) { file.close(); throw e; } file.close();

 _{Com finally:}

file.open(); try { ... }