Curso de Java Módulo I Exceções, Entrada e Saída Programação Swing Fábio Mengue fabio@unicamp.br Centro de Computação - Unicamp

Transcrição

1 Curso de Java Módulo I Exceções, Entrada e Saída Programação Swing Fábio Mengue fabio@unicamp.br Centro de Computação - Unicamp Exceções O termo exception é uma abreviatura da frase exceptional event. Sua definição formal é um evento que ocorre durante a execução de um programa que quebra o fluxo normal dessa execução. Vários eventos podem causar exceções. Desde problemas sérios com hardware (como um crash de disco) até um erro simples de programação, como acessar um elemento de um vetor com um índice inválido. Quando um erro desses tipos ocorrem em um método Java, o método cria um objeto do tipo Exception e o envia para o sistema. Esse objeto contém informação sobre o erro, incluindo seu tipo e o estado em que o programa se encontrava quando o erro aconteceu. O sistema fica responsável por encontrar alguma maneira de lidar corretamente com o erro. Na linguagem usada pelos programadores Java, dizemos que o sistema gerou uma exceção (em inglês, throwed an exception). Depois que o método gerou uma exceção, o sistema tenta encontrar algum código que possa ser utilizado para lidar com a exceção. Os candidatos mais prováveis são os que chamaram o método onde o erro aconteceu. Se eles não tiverem condições de lidar com o erro, o sistema continua a seguir a pilha de chamadas, até encontrar o código apropriado. Por sua vez, o código é considerado apropriado para lidar com uma exceção quando o tipo da exceção gerada é o mesmo tipo para o qual ele foi programado. Ao ser encontrado o código correto, o sistema o executa (em inglês, catch the exception). Caso o sistema não consiga identificar um código correto para gerenciar a exceção, o sistema (normalmente representado pelo programa Java) se encerra. Claro que é desnecessário dizer que isso não é exatamente o que gostaríamos que acontecesse na maioria das vezes. Pelo fato de utilizar exceções para gerenciar erros, os programas em java possuem vantagens sobre as linguagens tradicionais. A primeira grande vangatem é poder separar o gerenciamento de erros do código comum. Outra vantagem é a propagação de erros, que permite que se crie uma classe especializada apenas no gerenciamento destes eventos. E por fim, é possível agrupar erros por tipo, tratando-os de uma vez. Veremos exemplos para cada uma das vantagens a seguir. 1

2 Nas linguagens de programação tradicionais, a detecção de erros e seu tratamento normalmente causa uma certa confusão no código, pois tudo está misturado. Por exemplo, imagine que você tenha uma função que leia um arquivo do disco para a memória. Imagine que esse programa se parece com isso: lerarquivo{ abrir o arquivo; determinar seu tamanho; alocar memória; ler o arquivo para a memória; fechar o arquivo; Parece muito simples. Mas o que acontece se: O arquivo não puder ser aberto? For impossível determinar o tamanho do arquivo? Não for possível alocar a quantidade total de memória? A leitura falhar? O arquivo não puder ser fechado? Então, criamos código a mais para detectar e lidar com esses possíveis erros. Assim, nosso programa agora ficaria assim: lerarquivo { codigoerro=0; abrir arquivo; if (arquivoaberto) { determinar tamanho; if (tamanhodeterminado) { alocar memória; if (memoriaalocada) { ler o arquivo para a memória; if (leiturafalhou) { codigoerro=-1; else { codigoerro=-2; else { codigoerro=-3; fechar arquivo; if (arquivonaofechado) && codigoerro=0) { codigoerro=-4; 2

3 Desta maneira, seu programa com 7 linhas ficou praticamente 3 vezes maior. O pior é que o código a mais torna o programa um tanto ilegível, e a lógica se perde no meio dos if's e else's, dificultando a identificação de quais pedaços do código estão realmente fazendo parte da linha de raciocínio deste programa. Depois de algumas manutenções, o código deve ficar ainda pior de ler, e os programadores geralmente irão resolver o problema simplesmente ignorando a prevenção aos erros; eles irão aparecer quando o programa der pau. A soluçaõ encontrada pelo Java é mais elegante. O programador irá escrever o programa de maneira usual, mas o tratamento de erros estará separado. Se sua função for reescrita à maneira Java, ficaria assim: lerarquivo { try { abrir arquivo; determinar tamanho; alocar memória; ler o arquivo para memória; fechar arquivo; catch (falhaaberturaarquivo) { Código de tratamento catch (falhadeterminartamanho) { Código de tratamento catch (falhaalocacaomemoria) { Código de tratamento catch (falhaleitura) { Código de tratamento catch (falhafechamentoarquivo) { Código de tratamento Note que o trabalho de criar código para gerenciar o erro continua. O que temos é a separação dos detalhes do que fazer quando algo acontece. O Java automaticamente executa apenas o código que se relaciona com o erro, tornando desnecessária a construção de cadeias ifelse para gerenciar os erros. O programa também fica maior, mas mais legivel e ainda sim menor do que na abordagem tradicional. A segunda vantagem que existe na utilização de exceções é a habilidade de propagar erros. Suponha que nossa função lerarquivo é o quarto método em uma série de métodos 3

4 implementados em sua classe. O metodo1 chama o metodo2, que chama metodo3, que finalmente chama lerarquivo. metodo1 { call method2; metodo2 { call method3; metodo3 { call lerarquivo; Suponha que o código em metodo1 seja o único interessado nos erros que podem acontecer em lerarquivo. Se isso fosse ser implementado usando a notificação tradicional, metodo3 e metodo2 deveriam ter maneiras de propagar códigos de erro eventualmente retornados por lerarquivo para os métodos que os invocaram, até chegar a metodo1. metodo1 { errorcodetype error; error = call metodo2; if (error) doerrorprocessing; else proceed; errorcodetype metodo2 { errorcodetype error; error = call metodo3; if (error) return error; else proceed; errorcodetype metodo3 { errorcodetype error; error = call lerarquivo; if (error) return error; else proceed; 4

5 Como já visto, o sistema Java irá procurar automaticamente um código adequado para o gerenciamento de erros. Usamos então uma palavra que indica que qualquer exceção ocorrida (e não tratada) deve ter propagada para a classe que chamou a classe corrente. Veja o exemplo: metodo1 { try { call metodo2; catch (Exception) { doerrorprocessing; metodo2 throws Exception { call metodo3; metodo3 throws Exception { call lerarquivo; Entretanto, como pode ser visto no código, o envio das exceções exige um certo esforço dos métodos intermediários, que também necessitam repassar a exceção com throws até o método correto. Mesmo assim, essa técnica obviamente é mais vantajosa que a tradicional, no sentido que evita confusão no código. A última mas não menos importante vantagem é que as exceções são agrupadas. Por exemplo, imagine um grupo de exceções. Todas elas dizem respeito a erros que podem ocorrer quando se manipula um vetor. Exceção para estouro do vetor, para inclusão de tipo inválido, ou mesmo para quando o elemento procurado não faz parte do vetor. Cada uma dessas exceções pode ser tratada de maneira independente, ou você pode ter um método que trate todas as exceções deste grupo, tornando a coisa mais simples. Pelo fato das exceções serem classes Java como qualquer outra, a hierarquia presente em todas as classes Java também está presente aqui. Todas elas são instâncias ou descendentes da classe Throwable. Cada folha da árvore que se inicia em Throwable representa uma exceção específica, e cada tronco representa um grupo relacionado de exceções. Por exemplo, ArrayException é uma subclasse de Exception (por sua vez, uma subclasse de Throwable), e possui 3 subclasses: InvalidIndexException, ElementTypeException, NoSuchElementException. Cada uma delas representa um erro específico, que pode ocorrer na manipulação de um vetor. Uma maneira de lidar com as exceções é uma a uma: catch (InvalidIndexException e) {... Outra maneira seria tratando a exceção de acordo com o grupo ao qual ela pertence. Isso pode ser feito por vários motivos, o mais forte deles é manter a simpliciadade. No nosso exemplo, temos ArrayException, que representa qualquer erro que pode acontecer com a 5

6 manipulação de um vetor. Assim, um método pode lidar com uma exceção baseada em sua hierarquia. Por exemplo: catch (ArrayException e) {... Este método lida com todas as exceções que dizem respeito a vetores. É possível saber qual a exceção através de uma pergunta ao objeto e, recebido como parâmetro. Também é possível definir um método que lida com qualquer exceção que chegar até ele, como no exemplo: catch (Exception e) {... Seu primeiro encontro com exceções Java. Veja a mensagem de erro abaixo. Ela é gerada pois a classe que estamos compilando contém chamadas a métodos que lançam exceções quando um erro acontece. InputFile.java:8: Warning: Exception java.io.filenotfoundexception must be caught, or it must be declared in throws clause of this method. in = new FileReader(filename); ^ A linguagem Java exige que os métodos capturem ou especifiquem o lançamento de exceções que podem acontecer dentro daquele escopo. Se o compilador identifica que aquele pedaço de código não possui código adequado para o tratamento de exceções, a mensagem de erro acima é apresentada e o programa simplesmente não é compilado. Vamos ver o código do programa InputFile.java e verificar a causa do erro. import java.io.*; public class InputFile { private FileReader in; public InputFile(String filename) { in = new FileReader(filename); public String getword() { int c; StringBuffer buf = new StringBuffer(); 6

7 do { c = in.read(); if (Character.isWhitespace((char)c)) return buf.tostring(); else buf.append((char)c); while (c!= -1); return buf.tostring(); O compilador apresenta o erro na linha 8 (in = new FileReader(filename);). Essa instrução cria um objeto FileReader, usado para abrir um arquivo cujo nome é passado como parâmetro. O que acontece se o arquivo não existir no disco? Os profissionais que desenharam a classe FileReader não tinham a menor idéia do que o programador gostaria que acontecesse caso o arquivo não existisse. O programa deve terminar? Um nome de arquivo diferente deve ser testado? O arquivo deve ser criado? Não existe jeito de saber o que o programador que está utilizando o FileReader gostaria que acontecesse nessa situação. Assim, eles geram uma exceção (do tipo java.io.filenotfoundexception). Assim, o método que chamou a instrução decide a maneira apropriada de tratar do assunto. No nosso exemplo, pode se ver que o programa ignora o fato de que FileReader pode gerar uma exceção. Mas o compilador Java não deixa que o fato passe em branco, se recusando a compilar o programa e gerando uma mensagem de erro que alerta o programador a respeito. Além da mensagem vista acima, outra mensagem deve ser gerada: InputFile.java:15: Warning: Exception java.io.ioexception must be caught, or it must be declared in throws clause of this method. while ((c = in.read())!= -1) { ^ Agora, o problema está no objeto in, que da classe FileReader. O método read() também pode gerar uma exceção, desta vez caso algum problema aconteça na leitura. Por exemplo, se as permissões do arquivo não estejam configuradas de modo que esse programa possa ler seus dados. A exceção gerada pode esse método é java.io.ioexception. Nesse ponto, você tem duas opções. Ou pode criar o código para capturar as exceções dentro do programa InputFile ou propaga-las para outros métodos mais acima na pilha de execução. De qualquer maneira, o programa InputFile deve fazer alguma coisa. E para fazer isso existe uma maneira correta. 7

8 O Bloco try O primeiro passo para construir um programa capaz de gerenciar exceções é colocar os comandos que podem gerar exceções dentro de um mesmo contexto, usando a palavra reservada try: try { Comandos... Você pode colocar cada um dos comandos em um contexto próprio, ou pode colocar todos os comandos que podem gerar exceção em apenas um contexto e depois programar (separadamente) o código que irá lidar com cada uma das exceções. Por exemplo: PrintWriter out = null; try { out = new PrintWriter( new FileWriter("OutFile.txt")); for (int i = 0; i < size; i++) out.println("value at: " + i + " = " + victor.elementat(i)); O bloco try neste programa delimita o escopo sobre o qual o código de tratamento de erros irá atuar. Nesse pedaço de código existem duas instruções que podem gerar exceções; você consegue identifica-las? O Bloco catch Uma instrução try deve ser acompanha de pelo menos um bloco catch. A instrução catch define qual o código que irá ser executado, dependendo da exceção gerada. Você os associa aos blocos definidos pelo try colocando-os logo após o bloco: try {... catch (... ) {... catch (... ) { catch. Não se deve ter nenhuma outra instrução entre o final do contexto do try eoinício do 8

9 A forma geral do catch é: catch (SomeThrowableObject variavel) { Comandos... Note que ele é muito parecido com um método. Todo bloco catch identifica o tipo de exceção que ele trata (SomeThrowableObjet, que é o nome da classe-filho de Throwable) e recebe como parâmetro a exceção recebida. Essa exceção, como tudo em Java, é um objeto. Sendo subclasse de Throwable, esse objeto herda uma série de métdos. Um dos mais utilizados é o getmessage(), que serve para mostrar qual a mensagem de erro. Temos ainda métodos para mostrar a pilha de execução e você pode definir ainda suas próprias exceções (basta criar uma classe que extends Throwable). O bloco catch contém normalmente comandos comuns do Java. Muitas vezes o bloco serve simplesmente para imprimir uma mensagem indicando o erro e parando o programa. O bloco é executado apenas se a exceção for disparada; os outros blocos catch são ignorados. Se utilizarmos como exemplo o código apresentado na página anterior, podemos definir os blocos catch da maneira mostrada abaixo: try {... catch (ArrayIndexOutOfBoundsException e) { System.err.println("Caught ArrayIndexOutOfBoundsException: " + e.getmessage()); catch (IOException e) { System.err.println("Caught IOException: " + e.getmessage()); O primeiro bloco irá ser executado quando for disparada uma exceção deíndice do vetor, e o outro quando ocorrer um erro de escrita no arquivo. A granularidade permitida é muito grande, como podemos ver. Mas é possível definir apenas alguns (ou mesmo um) blocos para todas as exceções. Criar código diferenciado para erros de acesso a um vetor ou erro no disco pode ser pouco produtivo. O Java tem a capacidade de agrupar as exceções, baseado na organização hierárquica das mesmas. Quanto mais próximo da classe folha, mais específica é o tratamento da exceção. Podemos escolher em tratar as classes mais próximas do tronco ou mesmo da raiz. Veja a imagem: 9

10 Assim, podemos reescrever nosso exemplo de modo que apenas um bloco catch pode lidar com todas as exceções: try {... catch (Exception e) { System.err.println("Exception caught: " + e.getmessage()); A classe Exception é a mais alta na hierarquia Throwable. Assim, qualquer exceção que ocorrer será tratada por esse bloco. A idéia em si é que ele basta para tratar de erros gerais, mas é um tanto inútil para um tratamento adequado, perdendo um pouco da vantagem de tratamento que o Java fornece. Finalmente, temos o bloco finally. O Bloco finally Todo try deve ter pelo menos um catch. Existe mais um bloco de código que pode ser definido, mas ele não é obrigatório. Ele existe para que se possa realizar certas atividades que devem ser feitas independentemente do curso de execução ter gerado exceções ou não. Um exemplo é fechar um arquivo ou conexão com o banco de dados. Lembremos novamente de nosso exemplo da página 8. Três casos ocorrer. 1) O FileWriter falha e lança uma IOException. 2) O victor.elementat(i) falha e lança uma ArrayIndexOutOfBoundsException. 3) Tudo dá certo, e nenhuma exceção é gerada. Certas instruções devem ser executadas para qualquer um dos casos. O bloco finally serve justamente para isso. Suas instruções serão executadas sempre, com exceções ou sem elas. Sua definição permite que eliminemos código duplicado e facilita o encerramento de uma rotina. 10

11 Exercícios: 1. O código abaixo é válido? try {... finally {... 2.Quais as exceções que serão capturadas pelo bloco abaixo? catch (Exception e) {... Cite uma desvantagem de usar esse tipo de classe de exceção. 3.Quais as exceções que serão capturadas pelo bloco abaixo?... catch (Exception e) {... catch (ArithmeticException a) {... Há alguma coisa errada com esses blocos? O código compila? 11

12 Entrada e saida As vezes um programa necessita trazer informação de uma fonte externa ou enviar informação para um destino fora do programa. A informação pode estar em qualquer lugar: um arquivo em disco, na rede, em outro programa. A informação também pode ser de qualquer tipo: um objeto, um caracter, uma imagem, um som... Para lidar com essas informações, o Java utiliza o conceito de stream. Ele pode ser entendido como se fosse um tubo, onde as informações são enviadas em fluxo, que são lidas (ou escritas). Veja o desenho: Não importa de onde o dado esteja vindo (ou indo), e não importa seu tipo. Os algoritmos que lidam com streams tratam de maneira sequencial do dados: abrir o stream enquanto houver informação ler informação fechar o stream O pacote java.io possui classes que tratam e criam os streams. Basicamente, temos streams para leitura de caracteres e para leitura de bytes. Os primeiros possibilitam a leitura e escrita de palavras de 16 bits, e são originários da classe abstrata java.io.reader e java.io.writer. 12

13 Os streams para leitura de bytes lidam com palavras de 8 bits, e são subclasses de java.io.inputstream e java.io.outputstream. Os streams mais fáceis de entender são os relacionados a arquivos. Segue um exemplo de programa que copia um arquivo de um stream para outro. import java.io.*; public class Copy { public static void main(string[] args) throws IOException { File inputfile = new File("entrada.txt"); 13

14 File outputfile = new File("saida.txt"); FileReader in = new FileReader(inputFile); FileWriter out = new FileWriter(outputFile); int c; while ((c = in.read())!= -1) out.write(c); in.close(); out.close(); Como podemos ver, o programa é muito simples. Ele abre um FileReader no arquivo entrada.txt e abre um FileWriter no arquivo saida.txt. O programa lê caracteres enquanto houver no stream de entrada e os escreve no stream de saída. Quando terminar, ele fecha ambos os streams. O assunto é um tanto extenso, e esse curso se propõe a passar apenas a idéia básica sobre o assunto. Temos capacidade de gerar ou ler streams com arquivos zipados, serializar objetos (artifício utilizado para comunicação remota) e mesmo acessar arquivos de maneira não sequencial. Introducao ao Swing O pacote Swing é parte da JavaTM Foundation Classes (JFC) na plataforma Java. Existe na linguagem como pacote de extensão desde a versão 1.1, e serve basicamente para auxiliar as pessoas a construirem GUI's (Guided User Interface). O Swing fornece todos os componentes básicos, de botões a tabelas. Seu primeiro Swing A maneira mais fácil de ensinar a utilizar o Swing mostrando código. Vamos a um programa bem simples, que exibe Alo Mundo. 14 import javax.swing.*; public class HelloWorldSwing { public static void main(string[] args) { JFrame frame = new JFrame("HelloWorldSwing"); final JLabel label = new JLabel("Hello World"); frame.getcontentpane().add(label); frame.setdefaultcloseoperation(jframe.exit_on_close); frame.pack();

15 frame.setvisible(true); linha. Esta é a aplicação mais simples que se pode escrever. Vamos analisar o código linha a Inicialmente, como sempre, importamos os pacotes que iremos utilizar. No caso, javax.swing.*. A outra linha interessante é a onde se define nossa raiz, ou container. Ele é o elemento principal, e onde iremos dependurar tudo que queremos que apareca em nossa tela. No nosso caso, eh o JFrame. Ele permite que outros componentes sejam adicionados a ele, e tem a capacidade de gerenciar eventos. Existem outros 2 containers Swing: JDialog e JApplet (esse último, utilizado apenas para Applets). Cada objeto JFrame implementa uma única janela principal, que possui decorações. Elas são a borda, o título e botões para maximizar, minimizar e fechar a janela. Uma aplicação Swing usa normalmente pelo menos um JFrame. Nosso frame tem um componente. Um label, onde escrevemos Alo Mundo. As duas linhas de código abaixo constroem e adicionam o componente ao frame: final JLabel label = new JLabel("Hello World"); frame.getcontentpane().add(label); Para fechar a janela quando o botão de fechar é clicado, devemos incluir a linha abaixo no nosso programa: frame.setdefaultcloseoperation(jframe.exit_on_close); O comportamento padrão de um frame quando o botão de fechar é clicado é esconder a janela, coisa que não desejamos. A linha onde consta o método pack() determina o tamanho do frame de modo que todos os componentes estejam em um tamanho padrão. Esse método utiliza algumas propriedades do sistema para criar e colocar o frame em um tamanho considerado adequado. A última linha, que chama o método setvisible(), faz com que o frame apareça na tela. Veja o resultado: 15

16 Notas sobre o Swing: Para aparecer na tela, todos os componentes devem ser adicionados e estarem presentes em alguma parte de hierarquia, que se inicia na raiz (JFrame, JDialog ou JApplet). Todos os componentes raiz possuem um content pane, que contém a parte visível do que estamos montando, como mostrado na figura abaixo: Opcionalmente, você pode adicionar um menu a um componente raiz. O menu é posicionado diretamente na raiz, fora do content pane. Bibliografia The Java Tutorial Core Java Horstmann, Cay S., Cornell, Gary. Makron Books Proibida a alteração, reprodução e cópia de parte deste material para qualquer finalidade sem a permissão do Centro de Computação da Unicamp. A utilização deste material é permitida desde que conste a autoria do mesmo Centro de Computação da Unicamp. 16