Baixe Programação Java Orientação ao Objecto e outras Manuais, Projetos, Pesquisas em PDF para Programação para Java, somente na Docsity!
AUTOR: CESAR AUGUSTO TACLA
CRIAÇÃO: 5/3/2009 11:
ÚLT. ALTERAÇÃO: 22/9/2009 09:
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
PR
REVISÃO
PROGRAMAÇÃO
ORIENTADA A OBJETOS
UTILIZANDO JAVA
Prof. Cesar Augusto Tacla
Departamento Acadêmico de Informática ht t p : / / w w w. d ai nf. c ef et pr. br / ~ t ac l a
O uso e reprodução desta apostila requerem autorização expressa do autor.
1 OBJETO
Um objeto representa uma entidade concreta (ex. produto em estoque) ou abstrata (transação
bancária, histórico, taxa de juros) do mundo real. Também pode ser algo necessário ao funcionamento
do sistema sem uma ligação forte com uma entidade do mundo real.
Um objeto num sistema possui três propriedades:
◊ Estado: definido pelo conjunto de propriedades do objeto (os atributos) e de suas relações com os
outros objetos, muda com o tempo. Ex. objeto turma pode estar aberta ou fechada – passa ao estado
fechada quando 10 alunos fizerem a inscrição.
◊ Comportamento: como um objeto responde às solicitações dos outros e tudo mais o que um objeto
é capaz de fazer. É implementado por um conjunto de operações. Ex. objeto turma pode ter
operações acrescentar aluno ou suprimir aluno.
◊ Identidade: significa que cada objeto é único no sistema. Por exemplo, o objeto turma Tecno-OO
manhã é diferente do objeto Tecno-OO tarde.
Figura 1. Notação de objeto em UML
2 CLASSE
Uma classe é uma descrição de um conjunto de objetos com propriedades, comportamento,
relacionamentos e semântica comuns. Uma classe pode ser vista como um esqueleto/modelo para criar
objetos.
Exemplo: classe turma
Atributos: sala, horário
Operações: obter local, adicionar estudante, obter horário
Dicas
◊ Classes devem encerrar uma só abstração do mundo real. Por exemplo, uma classe estudante
contendo também o histórico do estudante não é boa. Melhor é dividi-las em duas: estudante e
histórico estudante.
◊ Utilize substantivos para nomear as classes
◊ Podem-se suprimir os atributos e os métodos deixando somente os compartimentos.
◊ Em UML, classes abstratas são grafadas em itálico
Figura 2. Notação UML para classe.
atributos
métodos
<<estereótipo>> Turma
Tecno-OO manhã :Turma
Tecno-OO tarde : Turma
objeto : classe
2.1 Atributos
Sintaxe para declaração de um atributo em UML:
[][]:[][=]
◊ :
+ = público
- = privada, somente métodos da classe podem acessá-lo
# = protegido, métodos da classe e das classes derivadas podem acessá-lo
~ = pacote, métodos das classes presentes no mesmo pacote podem acessá-lo
◊ : nome do atributo
◊ : por exemplo, valores[5] ou matriz[4, 6]
◊ : Pode-se utilizar os tipos da linguagem de implementação. Por exemplo, char, float ou int.
◊ : valor inicial para o atributo que respeite o tipo de dado.
Exemplos
- nome[30]: char
- sexo: char=’f’
+ código: int=
2.2 Métodos
Sintaxe para declaração de um atributo em UML:
[]():[]
◊ :
+ público
- privada, somente métodos da classe podem acessá-lo
# protegido, métodos da classe e das classes derivadas podem acessá-lo
~ pacote, métodos de classes presentes no mesmo pacote podem acessá-lo
◊ : nome do método
◊ : (<nome_argumento>:, ..., <nome_argumento>). Por exemplo,
(nome:String, idade: int)
◊ : Tipo do dado retornado. Pode-se utilizar os tipos da linguagem de implementação. Por
exemplo, char, float ou int.
Exemplos
- calcularIdadeEmMeses(Data data_nasc): int
+moverPara(x:int, y:int):void
2.3 Encapsulamento
Encapsular num só objeto atributos (dados) e operações permite esconder os detalhes internos de
funcionamento do objeto. Podemos definir, por exemplo, que os atributos não são visíveis (privados) e
que certos métodos os modificam. Também, podemos definir que somente alguns dos métodos dos
objetos de uma classe são visíveis (métodos públicos), os demais seriam para o funcionamento interno
do objeto.
Se fizermos referência ao atributo não-estático str no método main ou no imprimir obtermos o seguinte
erro de compilação: non-static variable str cannot be referenced from static context. Podemos fazer
referência a métodos e atributos não estáticos de outros objetos.
Não devemos abusar de métodos estáticos porque um programa que utiliza somente métodos de
classe não é orientado a objetos (não há objetos). A Figura 5 mostra um exemplo adicional de método
estático e a Tabela 1 resume o vocabulário do assunto.
1 public class Circle { 2 static final double PI = 3.14159; 3 public static double calculaArea(double raio) { 4 return PI * ( raio * raio ); 5 } 6 } 7 8 // um método qualquer 9 ... 10 double circleArea = Circle .calculaArea(5); // utilizamos o nome da classe
Figura 5: exemplo de método estático.
TABELA 1:VOCABULÁRIO DE MÉTODOS E ATRIBUTOS ESTÁTICOS
De classe De instância
Método É um método static, não necessita de objeto
para ser chamado.
É um método não static, necessita de
objeto para ser chamado.
Atributo É um atributo static, existe um só para
todos os objetos da classe.
É um atributo static, há uma cópia
para cada objeto instanciado.
2.6 Escopo de Variáveis
As variáveis existem somente dentro do bloco em que foram definidas, sendo que um bloco é
delimitado por chaves. Na figura 6, temos os seguintes escopos:
◊ num: atributo de instância existe em todos os métodos da classe (chaves pretas);
◊ res: atributo de instância existe em todos os métodos da classe (chaves pretas);
◊ n: argumento do método calcular; existe da linha 5 a 17 (chaves vermelhas);
◊ res: variável auxiliar declarada na linha 8; existe da linha 8 a 17 (chaves azuis);
◊ i: variável auxiliar do for; existe nas linhas 9 e 10
1 public class Fatorial { 2 private int num = 0; // último número calculado 3 private int res = 1; // último resultado obtido 4 5 public int calcular(int n) { 6 if (n == num) return res; 7 else { 8 int res = 1; 9 for (int i=n; i>0; i--) 10 res = i * res; 11 12 // guarda resultado 13 this .res = res; 14 num = n; 15 return res; 16 } 17 } 18 }
Figura 6: escopo de variáveis (JexemploEscopoVariaveis).
Sombreamento. Quando um argumento ou uma variável de um método possui nome idêntico a um
atributo (variável res na figura 6) então é preciso utilizar a palavra reservada this para fazer referência
ao atributo. Isto é chamado de sombreamento ou ocultação do atributo pela variável de método.
3 HERANÇA
É um mecanismo típico de OO para definir classes que compartilham definições de métodos e de
atributos. Isto é feito quando classes apresentam parte do comportamento e da descrição de estado
similares e parte específica.
Por exemplo, num editor gráfico trabalhamos com duas formas geométricas: polígonos regulares e
círculos. Polígonos e círculos têm parte do comportamento similar, podemos movê-los, redesenhá-los,
calcular área e perímetro, e parte específica, polígonos podem ser rotacionados enquanto que círculos
não necessitam deste comportamento. Polígonos podem ser descritos da mesma forma: número de
lados, tamanho do lado, raio da circunferência inscrita (apótema) e centro do polígono. Embora os
círculos tenham centro e raio, não possuem número de lados nem tamanho do lado.
No exemplo em questão, temos uma classe base denominada forma geométrica. Uma classe derivada
herda métodos e atributos da classe base. Portanto, as classes polígono e círculo herdam os métodos e
atributos definidos na classe base. Uma classe derivada pode ser a classe base de outra, constituindo
assim uma relação de hierarquia entre as classes. Por exemplo, a classe polígono pode ser base de uma
classe retângulo, triângulo e outras. Esta técnica diminui os esforços de codificação assim como a
quantidade de código, pois operações comuns às classes são definidas uma só vez.
1 class Ponto { 2 public double x; 3 public double y; 4 5 Ponto(double x, double y) { 6 this.x = x; 7 this.y = y; 8 } 9 public double calcularDist(Ponto p) { 10 return (Math.sqrt(Math.pow(p.x - x, 2.0) + Math.pow(p.y - y, 2.0))); 11 } 12 } 13 14 class Circulo extends FormaGeometrica { 15 Circulo(Ponto c, double r) { 16 centro = c; 17 raio = r; 18 } 19 public double CalcularArea() { 20 return (Math.PI * Math.pow(raio, 2)); 21 } 22 public double CalcularPerimetro(){ 23 return (2 * Math.PI * raio); 24 } 25 public void Redesenhar() { 26 // não implementada 27 System.out.println("figura redesenhada"); 28 } 29 } 30 class Poligono extends FormaGeometrica { 31 public int numLados; 32 public double tamLado; 33 public double angRotacao=0; 34 Poligono(int n, double tam, Ponto c, double r) { 35 numLados = n; 36 tamLado = tam; 37 centro = c; 38 raio = r; 39 } 40 public double CalcularPerimetro() { 41 return (numLados * tamLado); 42 } 43 public double CalcularArea() { 44 return (raio * CalcularPerimetro() / 2); 45 } 46 public double Rotacionar(double incremento) { 47 angRotacao = Math.IEEEremainder(angRotacao+incremento, 360.0); 48 return angRotacao; 49 50 }
(AoQuadrado). Na classe AoQuadrado o compilador aponta que o método elevarQuadrado(float) já foi
definido na classe.
1 public class Somador { 2 public int somar(int a, int b) { 3 return a+b; 4 } 5 public int somar(float a, float b) { 6 return a+b; 7 } 8 }
1 public class AoQuadrado { 2 public float elevarQuadrado(float a) { 3 return aa; 4 } 5 public double elevarQuadrado(float a) { 6 return (double)aa; 7 } 8 }
Figura 9: Exemplos de sobrecarga de métodos (correto e incorreto) – JExemploPolimorfismoSobrecarga.
3.1.2 Sobreposição/Reescrita (override)
A sobreposição ocorre quando um método de uma classe base é reescrito na classe derivada. O
método reescrito tem a mesma assinatura que o método da classe base. Assinatura significa mesmo
nome, mesma lista de argumentos e mesmo valor retornado.
1 class ClienteEspecial extends Cliente { 2 ClienteEspecial(double desc) { 3 desconto = desc; 4 } 5 // Sobreposição do método calcularDesconto da classe base Cliente 6 public double calcularDesconto(double valor) { 7 return valor * desconto; 8 } 9 } 10 11 public class Cliente { 12 protected double desconto=0.1; // 10% 13 public double calcularDesconto(double valor) { 14 if (valor > 500) 15 return valor * desconto; 16 else 17 return 0.0; 18 } 19 20 public static void main(String args[]) { 21 Cliente cli[] = {new Cliente(), // cli[0] 22 new ClienteEspecial(0.15)}; // cli[1] 23 24 for (int i=0; i < 2; i++) 25 System.out.println(cli[i].calcularDesconto(100)); 26 } 27 }
Figura 10: Exemplo de sobreposição de método (JExemploPolimorfismoSobreposicao).
Restrições à sobreposição. Alguns métodos não podem ser sobrepostos em função dos modificadores
que recebem:
◊ final: um método final nunca muda, todas as classes derivadas utilizam a mesma implementação.
As chamadas aos métodos finais são resolvidas em tempo de compilação (vinculação estática).
◊ Static: é implicitamente um método final.
◊ private: são implicitamente finais, porque não podem ser sobrescritos nas classes derivadas
(embora seja possível escrever um método com mesma assinatura numa classe derivada).
3.1.3 Princípio da substituição
Um objeto de uma classe derivada é tratado como se fosse objeto da classe base.
Observe que no método main (figura 10) são criadas duas instâncias de cliente, um normal outro
especial. As duas instâncias são colocadas num vetor da classe Cliente, i.e., o cliente especial é tratado
como se fosse um objeto da classe Cliente todas as vezes em que for referenciado por meio da variável
cli[1].
Late Binding (vinculação ou associação dinâmica). A pergunta que se faz é: qual o método
calcularDesconto será chamado para a instância armazenada em cli[1]? O método da classe Cliente ou
da classe ClienteEspecial? A resposta é: o método da classe ClienteEspecial. Em tempo de execução, o
tipo real do objeto armazenado na variável (cli[1]) determina o método a ser chamado. Isto é chamado
de late binding, ou seja, associação dinâmica.
4 CLASSES ABSTRATAS
Classe abstrata. Não admite instâncias, não pode ser instanciada. Normalmente são classes bases que
contêm atributos e comportamentos comuns às classes derivadas.
Método abstrato. Um método abstrato é apenas uma declaração significando que ele deverá ser
implementado numa classe derivada concreta (figura 11). Se isto não for feito, a classe derivada deve
ser declarada como abstrata.
Não podem ser declarados como métodos abstratos:
◊ Métodos construtores: os construtores não são herdados, logo um método construtor abstrato
nunca seria implementado.
◊ Métodos static: métodos static não podem ser sobrepostos pelas classes derivadas, logo um
método static abstrato nunca seria implementado.
1 abstract class Veiculo { 2 public int cavalos; 3 public abstract double calcularIPVA(); 4 public abstract static void incrementarVeiculos(); // erro: combinação ilegal 5 public abstract Veiculo(); // erro: modificador abstract não permitido 6 } 7 class Carro extends Veiculo { 8 public double calcularIPVA() { 9 return (cavalos * 100); 10 } 11 }
Figura 11: Exemplo de método abstrato.
4.1 CLASSES DE INTERFACE
Uma classe de interface define um contrato que deve ser seguido pelas classes que a implementam.
Uma classe interface é uma classe abstrata onde todos os métodos são implicitamente abstratos e
públicos e todos os atributos são implicitamente públicos, estáticos e finais.
Dica: ao tentar colocar visibilidade private ou protected nos atributos e métodos numa classe interface o compilador acusará erro – visibilidade não pemitida.
A palavra-chave final pode ser associada a um método ou atributo. Se for associada a um método,
indica que ele não pode ser redefinido. Se for associada a um atributo, indica que seu valor não pode
ser modificado depois de ser inicializado. A inicialização de um atributo final pode ser feita na sua
declaração ou num método construtor. A Figura 12 ilustra um exemplo de utilização de uma classe
interface.
Para incluir um pacote num código faz-se:
import formas.*; //inclui todas as classes definidas no pacote formas
import formas.ponto; // inclui uma classe específica
5.2 Visibilidade
Pode ser aplicada às classes, atributos e métodos. Se nada for definido pelo programador (default), as
visibilidades destes elementos são restritas aos membros que fazem parte do mesmo pacote (os
pacotes podem ser vistos como diretórios).
A visibilidade pública modifica a visibilidade default, permitindo que todos os membros do mesmo
pacote ou de outros pacotes enxerguem o que for público.
◊ Arquivo .java: pode conter somente uma classe pública que deve ter o mesmo nome que o
arquivo. As demais classes (friends) de um arquivo .java possuem a visibilidade padrão (pacote).
◊ Public: todos os objetos do mesmo ou de outros pacotes podem enxergar classes, atributos ou
métodos públicos.
◊ Protected: atributos protected têm visibilidade restrita à própria classe e às classes derivadas.
Objetos de classes do mesmo pacote também enxergam atributos protegidos.
◊ Private: atributos e métodos private são visíveis pelas instâncias de uma mesma classe. Instâncias de uma
classe derivada não conseguem acessar os atributos e métodos definidos como private na classe base. Exemplo:
1 // Testar visibilidade privada de métodos e atributos 2 3 class Ponto { // esta classe só é visível neste pacote 4 private double x; 5 private double y; 6 7 Ponto(double x, double y) { 8 this.x = x; 9 this.y = y; 10 } 11 private double obterX() { 12 return x; 13 } 14 public double calcularDist(Ponto p) { 15 // O objeto que executa este método pode acessar os atributos privados x e y 16 // do objeto passado como argumento, pois são instâncias da mesma classe. 17 return (Math.sqrt(Math.pow(p.x - x, 2.0) + Math.pow(p.y - y, 2.0))); 18 } 19 } 20 public class FormasGraficas { 21 public static void criarPontos() { 22 Ponto ptoA = new Ponto(2, -6); 23 Ponto ptoB = new Ponto(5, -2); 24 System.out.println("distancia=" + ptoA.calcularDist(ptoB)); 25 // Se a linha abaixo for incluída, o erro de compilação seguinte ocorre: 26 // x has private access in Ponto 27 // System.out.println("Coordenada x:"+ptoA.x); 28 } 29 public static void main(String[] args) { 30 criarPontos(); 31 } 32 }
Figura 13: Exemplo de atributo privado.
Visibilidade e Herança
Os membros de uma classe base quando herdados por uma classe derivada, levam consigo a
visibilidade. Assim, se um atributo ou método é público na classe base também o será na derivada. O
compilador acusa erro de sintaxe se tentarmos sobrescrever um método com um modificador de acesso mais
restrito que o original.
Visibilidade e Construtoras
Construtoras podem receber modificadores de visibilidade. Se uma construtora for definida como
private então a classe deve ter um método estático público que permita criar instâncias. Exemplo:
1 // Testar visibilidade privada de métodos construtores 2 3 public class Semaforo { 4 private int estado; 5 private String[]={“vermelho”, “verde”, “amarelo”}; 6 7 private Semaforo() { 8 estado = 0; 9 } 10 public static Semaforo instanciar() { 11 return (new Semaforo()); 12 } 13 }
6 CLASSES ANINHADAS
Em Java, é possível codificar classes dentro de outras classes. Estas classes podem ser static ou não
static. Classes não estáticas aninhadas são denominadas classes internas como ilustra a figura 14.
1 class Externa { 2 ... 3 class Interna { 4 ... 5 } 6 class static AninhadaEstatica { 7 ... 8 } 9 }
Figura 14: classes aninhadas
Restrições:
◊ Classes externas somente podem ter visibilidade de pacote (default) ou pública
◊ Classes internas são membros de classe e como tal podem ser públicas, protegidas, privadas ou
de pacote.
◊ Classes aninhadas estáticas, assim como os métodos estáticos, não podem referenciar diretamente
variáveis ou métodos de instância da classe externa. Uma classe estática aninhada funciona
exatamente como outra qualquer não aninhada. Só é colocada dentro de outra por razões de
encapsulamento.
TABELA 2: COMPARAÇÃO ENTRE CLASSE ANINHADA E ANINHADA STATIC.
Interna (não static) Aninhada Static
Necessário instanciar objeto
da classe externa?
SIM NÃO
Classe interna tem acesso a
atributos e métodos de
instância da classe externa?
SIM NÃO
Um objeto da classe interna
tem implicitamente uma
referência ao objeto da sua
classe externa?
SIM NÃO (não há objeto)
6.2 Classes aninhadas Estáticas
Classes aninhadas estáticas podem ser bastante úteis para testes. O exemplo seguinte ilustra esta
aplicação para testes de limites de uma classe que simula o funcionamento de um radar de velocidade.
O radar aplica multas para velocidades superiores a 10% da velocidade máxima para a qual foi
configurado. Após compilar o código da figura 17, são geradas os arquivos JRadar.classe e
JRadar$TesteJRadar.
1 // JAVARepositorio\JRevisaoOO\JExemClasseAninhadaEstaticaRadar 2 // Este programa demonstra como utilizar uma classe aninhada 3 // estatica para testar uma classe. Depois da fase de testes 4 // a classe aninhada pode ser desprezada. 5 // Para executar fazer: java -cp. JRadar$TesteJRadar 6 7 public class JRadar { 8 private int velocidadeMaxima; 9 10 public JRadar(int v) { 11 velocidadeMaxima = v; 12 } 13 public Boolean multar(int v) { 14 // multar return true qdo a velocidade detectada pelo 15 // radar excede em 10% a velocidade maxima; 16 if (v > (velocidadeMaxima * 1.1)) 17 return true; 18 else 19 return false; 20 } 21 22 public static class TesteJRadar{ 23 public static void main(String args[]) { 24 JRadar r[] = {new JRadar(40), new JRadar(60), new JRadar(110)}; 25 int v[] = {44, 67, 110}; 26 Boolean res[]={false, true, false}; 27 28 for (int i=0; i < r.length; i++) { 29 if (r[i].multar(v[i]) == res[i]) 30 System.out.println("OK"); 31 else 32 System.out.println("ERRO: radar " + i); 33 } 34 } 35 } 36 }
Figura 17: Exemplo de classe aninhada estática.
6.3 Classes aninhadas locais e anônimas
Há outros dois tipos de classes aninhadas:
◊ Local: criada no corpo de um método
◊ Anônima: criada no corpo de um método sem nome de classe, bastante utilizada em tratamento
de eventos de interface gráfica. A forma de instanciação é ligeiramente diferente. Observar na
figura 18, linha 3, a instanciação de uma classe anônima que implementa a classe interface
ActionListener. Uma classe anônima deve estender ou (exclusivo) implementar uma e somente
uma classe.
1 Button b = new Button("Ok"); 2 b.addActionListener( 3 new ActionListener() { 4 public void actionPerformed(ActionEvent e) { 5 tratarOK(); 6 } 7 } 8 );
Figura 18: Exemplo de classe interna anônima.
7 DICAS DE PROGRAMAÇÃO
Planejar. Antes de começar a programar fazer um pseudo-código ou fluxograma.
Vantagens:
◊ Ajuda a detectar defeitos antes da codificação (economiza tempo)
◊ Aumenta a confiabilidade do software
Desvantagens
◊ Cria mais documentação que deverá ser mantida
◊ Podem exigir ferramentas adicionais, por exemplo, para desenhar fluxogramas
◊ Erros podem ser introduzidos no momento da tradução do pseudo-código/fluxograma para o
programa
Tratar exceções. Verificar se os parâmetros de entrada condizem ao esperado.
Usar nomes expressivos nas variáveis e métodos.
Exemplo:
◊ manipular (int num) //não diz nada
◊ obterNumeroAlunosDaTurma (int num) //é melhor
Dê nome aos números
Ex: for (int i=0; i < 54; i++) melhor fazer for (int i=0; i < TAM_TURMA; i++)
Evitar variáveis globais: preferir métodos com parâmetros sempre que possível.
Inicializar as variáveis
Declarar as variáveis perto de sua primeira utilização
Notação
◊ Classes: iniciam com letras maiúsculas: Aluno, VeiculoMotor
◊ Métodos: iniciam com letras minúsculas: obterNumeroAlunos()
◊ Atributos: numChassis
◊ Variáveis de métodos: em minúsculas ou idem aos atributos
Dicas de programação
Evitar utilizar parâmetros dos métodos como variáveis do método
Limitar o número de parâmetros dos métodos (até 6, máximo 7)
Evitar aninhamentos (loops) com mais de 3 níveis
Verificar contadores de laço (principalmente os limites)
Assegurar que os loops terminam
7.1 Características desejáveis para um projeto de software
◊ Correção: o software satisfaz aos requisitos da aplicação?
◊ Levar em conta que os requisitos variam ao longo do projeto impondo a necessidade de um
projeto flexível.
◊ Robustez: o projeto ou a implementação são robustos quando capazes de tratarem situações
incomuns ou de erro.
◊ Flexibilidade: tirar mais ou menos do que já foi implementado (por exemplo, uma calculadora
que só faz uma operação por vez, é possível fazer várias operações). Adicionar novas
funcionalidades e alterar funcionalidades
◊ Eficiência: tempo de execução e utilização de recursos (processador, memória, armazenamento).
8.3 Tratar Exceções
Antes de qualquer coisa é preciso saber qual o tipo de exceção gerada para poder tratá-la. Por
exemplo, o método construtor FileWriter lança uma exceção IOException. Para saber, basta consultar a
documentação do método em http://java.sun.com/j2se/1.5.0/docs/api/index.html. A figura seguinte
reproduz a documentação Java:
Constructor Detail
FileWriter
public FileWriter(String fileName) throws IOException
Constructs a FileWriter object given a file name.
Parameters:
fileName - String The system-dependent filename.
Throws:
IOException - if the named file exists but is a directory rather than a regular file, does not exist but
cannot be created, or cannot be opened for any other reason
Figura 20 : Exceção lançada pelo construtor de FileWriter.
Para tratar uma exceção é preciso cercá-la utilizando o try e pegá-la utilizando o comando catch. Cada
bloco catch é denominado exception handler. Podemos associar mais de um catch a um try. O código
mostrado na Figura 19 não passa na compilação. Para corrigi-lo é preciso substituir o método
gravarArqTexto pelo código mostrado na Figura 20.
public static void gravarArqTexto(String nomeArquivo) { PrintWriter saida = null; try { saida = new PrintWriter(new FileWriter(nomeArquivo)); saida.println("Eu sou o arquivo " + nomeArquivo); } catch (IOException e) { System.out.println("Erro na criação do objeto FileWriter: "+ nomeArquivo+e.getMessage()); } finally { if (saida != null) { System.out.println(nomeArquivo + " sera´ fechado"); saida.close(); } else System.out.println(nomeArquivo + " nao foi aberto"); } }
Figura 21 : Blocos try, catch e finally.
Observe que o bloco finally sempre é executado independentemente do bloco try ser executado até o
final ou abortar no meio.
8.4 Lançar Exceções
Códigos que lançam exceções podem criar objetos descendentes da classe Throwable através do
comando throws. No código abaixo, o método pop lança a exceção pilha vazia.
23 public Object pop() throws EmptyStackException { 1 Object obj; 2 3 if (size == 0) { 4 throw new EmptyStackException(); 5 } 6 7 obj = objectAt(SIZE - 1); 8 setObjectAt(SIZE - 1, null); 9 size--; 10 return obj; 11 }
Figura 22. Exemplo de lançamento de exceção.
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.util.EmptyStackException
Figura 23. Classe de um objeto de erro deve ser descendente da Throwable.
Um método pode lançar suas próprias exceções, como no exemplo da figura 22, ou lançar exceções
que foram lançadas por outros métodos que não foram tratadas no método em questão. Até o método
main pode lançar exceções geradas por outros métodos para o JRE.
