PROGRAMAÇÃO ORIENTADA A OBJETOS

Transcrição

1 PROGRAMAÇÃO ORIENTADA A OBJETOS

2

3 MINISTÉRIO DA EDUCAÇÃO PRÓ-REITORIA DE ENSINO DEPARTAMENTO DE EDUCAÇAO À DISTÂNCIA ESCOLA TÉCNICA ABERTA DO PIAUÍ - ETAPI CAMPUS TERESINA CENTRAL PROGRAMAÇÃO ORIENTADA A OBJETOS

4

5 PRESIDENTE DA REPÚBLICA Luiz Inácio Lula da Silva MINISTRO DA EDUCAÇÃO Fernando Haddad GOVERNADOR DO ESTADO Wellington Dias REITOR DO INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA Francisco da Chagas Santana SECRETÁRIO DE EDUCAÇÃO A DISTÂNCIA DO MEC Carlos Eduardo Bielschowsky COORDENADORIA GERAL DA UNIVERSIDADE ABERTA DO BRASIL Celso Costa SECRETÁRIO DE EDUCAÇÃO DO ESTADO DO PIAUÍ Antonio José Medeiros COORDENADOR GERAL DO CENTRO DE EDUCAÇÃO ABERTA A DISTÂNCIA DO INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA Elanne Cristina Oliveira dos Santos SUPERITENDÊNTE DE EDUCAÇÃO SUPERIOR NO ESTADO Eliane Mendonça ORGANIZAÇÃO DO MATERIAL DIDÁTICO Rogério da Silva Batista

6 6 INTRODUÇÃO À PROGRAMAÇÃO ORIENTADA A OBJETOS Rogério da Silva Batista Rafael Araújo de Moraes APRESENTAÇÃO Este texto é destinado aos estudantes aprendizes que participam do programa Escola Técnica Aberta do Brasil (e-tec Brasil), vinculado à Escola Técnica Aberta do Piauí (ETAPI) do Instituto Federal de Educação, Ciência e Tecnologia do Piauí (IFPI), com apoio da Prefeitura Municipal dos respectivos pólos: Alegrete do Piauí, Batalha, Monsenhor Gil e Valença do Piauí. O texto é composto de seis (5) Aulas assim distribuídas: Na Aula 1 vamos estudar os arrays em Java. Veremos como arrays de tipos nativos e de instâncias de classes podem ser criados e usados. Veremos também arrays multidimensionais, irregulares e encapsulamento de arrays em classes para maior flexibilidade e praticidade. Na Aula 2 vamos estudar o tratamento de exceções em Java. Veremos quando e como capturar e tratar os principais tipos de exceções de acordo com sua hierarquia de classes. Veremos também como lançar e construir sua própria exceção. Na Aula 3 vamos estudar as coleções em Java. Estudaremos com mais detalhes as 3 interfaces mais utilizadas do framework Collections: List, Set e Map. Veremos as diferenças de cada uma dessas interfaces, assim como métodos de ordenação e pesquisa envolvendo essas interfaces. Na Aula 4 Vamos estudar as bibliotecas Java que nos permitem criar aplicações gráficas, o que torna nossos programas de mais fácil interação com o usuário final. Na Aula 5 Vamos aprender como conectar e manipular um Banco de Dados com uma aplicação JAVA usando JDBC e comandos Java e Sql.

7 7 Boas Vindas! Caro (a) Cursista, Bem vindo (a) à disciplina Programação Orientada à Objetos. Esta é a nossa Apostila, material elaborado com o objetivo de contribuir para o desenvolvimento de seus estudos e para a ampliação de seus conhecimentos acerca da citada disciplina.

8 Quem sou? Rogério da Silva Batista Sou Bacharel em Ciência da Computação pela Universidade Federal do Piauí e Especialista em Análise de Sistemas pela Universidade Estadual do Piauí. Sou professor do IFPI desde 2003 e leciono disciplinas dos cursos de Informática ligadas à área de Programação, como: Algoritmos, Programação em Ambiente Gráfico e Programação Orientada à Objetos dentre outras. Atualmente estou à frente da coordenação do curso de Tecnologia em Análise e Desenvolvimento de Sistemas e agora estou dando minha contribuição ao projeto ETAPI junto ao curso Técnico em Informática, como professor Conteudista da disciplina de Programação Orientada à Objetos. Espero que este material tenha uma grande contribuição no aprendizado desta disciplina de forma Professor que o aluno adquira conhecimentos mais aprofundados no paradigma Orientado à Objetos e aplicando estas técnicas na construção de softwares mais complexos e ao mesmo tempo fáceis de manutenção através do reuso de código. 8 Rafael Araújo de Moraes Sou Tecnólogo em Informática pelo IFPI e Especialista em Novas Tecnologias Educacionais pelas Faculdades Integradas de Jacarepaguá. Sou professor do IFPI desde 2007 e leciono disciplinas dos cursos de Informática ligadas à área de Programação, como: Algoritmos, Programação em Ambiente Gráfico, Programação para WEB dentre outras. Atualmente estou ministrando aulas no Campus do IFPI em Angical e agora estou dando minha contribuição ao projeto ETAPI junto ao curso Técnico em Informática, como professor Conteudista da disciplina de Programação Orientada à Objetos.

9 9 Índice Geral 1.1 Introdução Arrays Unidimensionais Arrays Multidimensionais Processando argumentos da linha de comando A classe String (Array de Caracteres) Exercícios Resolvidos RESUMO DA AULA ATIVIDADES DA AULA Introdução Capturando Exceções Deixando uma exceção passar através do método Hierarquia das Classes de exceção Java Lançando Exceções Criando sua própria exceção A cláusula: finally RESUMO DA AULA ATIVIDADES DA AULA Coleções Introdução Listas: java.util.list Conjunto: java.util.set Mapas - java.util.map RESUMO DA AULA ATIVIDADES DA AULA Interface Gráfica em JAVA Interface Gráfica em JAVA Criando Aplicações Gráficas em JAVA: Capturando um evento do usuário: Capturando o ActionEvent de um Botão: Ouvintes, origens e Eventos: Mais um pouco de parte gráfica: Criando seu próprio elemento gráfico de desenho: Exibindo uma figura JPEG em um painel: Agora vamos aprender como funciona o Gerenciador de Layout: Testando os componentes do Swing RESUMO DA AULA EXERCÍCIOS DA AULA Java com Banco de Dados RESUMO DA AULA EXERCÍCIOS DA AULA

10 Arrays Aula 110 Objetivos Ao final desta aula, você deverá ser capaz de: declarar e instanciar arrays; popular e percorrer arrays. Ser capaz de usar arrays na resolução de problemas. Aprender a usar arrays multidimensionais e arrays irregulares. Conhecer e utilizar os principais métodos para manipulação de Strings

11 Introdução Arrays são estruturas de dados em Java que permitem o armazenamento de várias variáveis de um mesmo tipo ou instâncias de uma mesma classe usando uma única referência e um índice de acesso. Cada um dos valores individuais (ou elementos) do array poderá ser acessado individualmente, mas o array inteiro poderá ser processado como uma única entidade caso seja desejado, simplificando bastante algumas tarefas. Como exemplo, podemos considerar o problema de representar uma turma de alunos, através de um conjunto de instâncias da classe Aluno. Uma classe Turma poderia conter um número pré-definido e limitado de referências à instâncias de Alunos, mas a declaração e manipulação de muitas referências independentes seria complexa e poderia levar a erros. O exemplo mostrado acima representa um array unidimensional, isto é, cujos elementos podem ser acessados por um único índice. Ainda podemos ter arrays multidimensionais, de forma com que tenhamos que usar mais de um índice para acessar um elemento. Um exemplo simples de array multidimensional é uma matriz matemática, onde valores possam ser acessados especificando-se uma linha e uma coluna, que serão os dois índices usados. Nesta aula veremos como arrays de tipos nativos e de instâncias de classes podem ser criados e usados. Veremos também arrays multidimensionais, irregulares e encapsulamento de arrays em classes para maior flexibilidade e praticidade. 1.2 Arrays Unidimensionais Declaração de Arrays A declaração de arrays em Java é feita usando a notação dos colchetes: uma variável declarada como sendo de um tipo específico seguido de um par de colchetes será uma referência à um array de elementos daquele tipo. O exemplo abaixo mostra a declaração de alguns arrays de tipos nativos. int [] números; double [] notasdosalunos; char[] letrasdoalfabeto; No trecho de código mostrado acima, numeros será uma referência a um array de valores do tipo int; notasdosalunos será uma referência a um array de valores do tipo double e letrasdoalfabeto será uma referência a um array de valores do tipo char Criação e Inicialização de Arrays Não basta somente declarar as referências a arrays, estas devem ser criadas (ter memória alocada para seus elementos). No exemplo mostrado acima, as referências foram simplesmente declaradas, mas não se sabe quantas posições cada array deverá ter. Um array deve ser criado com a palavra-chave new, seguida do tipo de dado a ser alocado e do número de elementos a alocar, entre colchetes.

12 12 Um array declarado deve ser inicializado com um tipo compatível com o declarado. Desta forma, a declaração int[] array = new char[100]; não será válida, e causará um erro de compilação. Na inicialização do array devemos especificar o seu tamanho entre colchetes. Este tamanho não precisa ser uma constante definida em tempo de compilação: pode ser um valor obtido de qualquer outra fonte, e pode ser determinado em tempo de execução, como mostrado no exemplo abaixo: int quantidade = 32768; byte[] vetornumerico = new byte[quantidade]; Quando um array de tipos nativos é criado, seus elementos são inicializados automaticamente com valores padrão da seguinte forma: char : \u0000 (Valor Unicode para 0000) byte, short, int e long : 0 boolean : false float e double: 0.0 Podemos inicializar os elementos de um array das seguintes formas: Atribuindo valores para cada elemento do array: nomedoarray[indice] = valor; Ex: letrasdoalfabeto[2] = c ; Usando inicializadores: tipo[] nomedoarray = {lista_de_valores; Ex: int [] numeros = {2,3,5,7; No exemplo acima não há a necessidade de usar o operador new nem de definir o tamanho do array. Em outras palavras, no exemplo acima acontecem três coisas em apenas uma linha: I Declaração de uma referência a um array de inteiros chamado números; II Criação de um array com quatro posições; III Inicialização das posições com os valores 2,3,5,7; O trecho de código abaixo demonstra outras maneiras de declaração/criação/inicialização de arrays. int[] numeros = new int[100]; char[] letrasdoalfabeto = { a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z ; double[] notas; notas = new double[24*2]; double[] medias = notas; Um array, depois de inicializado, não pode ter seu tamanho modificado, embora possamos usar a referência para apontar para outro array. Desta forma as declarações boolean[] respostas = new boolean[12]; respostas = new boolean[144]; estarão corretas, mas os valores do primeiro array (de 12 posições) serão perdidos quando a referência apontar para o array de 144 posições.

13 13 Arrays inicializados com listas de constantes de valores do tipo float devem ser declarados de forma que as listas de constantes sejam do tipo correto: a declaração float[] série = 10,1,0.1,0.01,0.001; causará um erro de compilação pois o compilador assumirá que os valores decimais são do tipo double. Estas constantes devem ser precedidas de um cast para o tipo float ou ter o sufixo f que indica que os valores são do tipo float. A declaração de arrays com listas de valores como foi feito para a referência letrasdoalfabeto não torna o array nem seus elementos constantes: posteriormente, o código poderia conter o comando letrasdoalfabeto[0] =? ;, que seria compilado e executado corretamente. Graficamente teríamos: letrasdoalfabeto? b c d e f g h... z Uma outra maneira de inicialização de arrays bastante utilizada em classes é a declaração separada da inicialização, como mostrado no trecho de código na listagem acima para a referência notas. A declaração pode ser feita em um bloco da classe e a inicialização em outra: esta técnica é bastante usada quando encapsulamos arrays em classes, declarando o array como sendo um campo da classe (podendo ser acessado por todos os métodos da classe) e inicializando-o no construtor (que é o primeiro método a ser chamado, evitando que outros métodos acessem o array não inicializado). Podemos ver na inicialização do array notas que o tamanho do array não é dado por uma constante, podendo ser o resultado de uma operação qualquer. Uma última maneira de inicializarmos um array é criando uma cópia de uma referência a um array já inicializado, como mostrado na última linha do trecho de código mostrado acima. Neste caso, o acesso aos elementos do array poderá ser feito por qualquer uma das duas referências (medias e notas). Se modificarmos um elemento de uma das referências e recuperarmos o mesmo elemento via a outra referência, o valor recuperado será o modificado. Vale a pena notar que somente podemos fazer cópias de referências quando a referência original já tiver sido inicializada com a palavra-chave new Índice de Arrays O índice para acesso a um elemento de um array deverá ser um valor entre zero e o tamanho do array menos um. Desta forma numeros[0] corresponderá ao primeiro elemento do array, e numeros[99] corresponderá ao último elemento. Não é possível acessar elementos fora desta faixa, e o índice deve ser sempre inteiro e positivo. Assim, as declarações numeros[-1], numeros[100] e numeros[5.4] são consideradas incorretas. O tamanho mínimo aceitável para um array é zero: como os índices são contados a partir do zero, um array declarado com tamanho zero terá um único elemento. Os elementos de um array inicializado podem ser utilizado como campos ou variáveis independentes. Geralmente um array será populado (isto é, terá seus elementos inicializados) com um laço cuja variável de controle cobre os valores aceitáveis para índices do array, modificando o elemento naquele índice.

14 14 Um exemplo de uso de arrays, é mostrado na classe TemperaturasTeresina (listagem 1.1). Esta classe encapsula um array de valores do tipo float que representam os valores das temperaturas médias na cidade de Teresina cujo tamanho é definido pelo programador usuário da classe. A classe permite a interação do usuário com o array somente através de métodos que verificam os índices sendo usados, evitando que índices inválidos sejam utilizados.. 1 /** 2 * A classe TemperaturasTeresina, que encapsula um array de valores de ponto 3 * flutuante, com vários métodos que a tornam mais útil e versátil do que um array 4 * comum. 5 */ 6 class TemperaturasTeresina // declaração da classe 7 { 8 /** 9 * Declaração dos campos da classe 10 */ 11 private float[] array; // o array encapsulado /** 14 * O construtor para a classe TemperaturasTeresina, que recebe um argumento que 15 * será o número de posições (ou valores do tipo float) que a instância da classe 16 * será capaz de armazenar. 17 número o número de posições para valores do tipo float a serem alocadas 18 */ 19 TemperaturasTeresina(int numero) 20 { 21 array = new float[numero]; // alocamos memória para o array encapsulado /** 25 * O método tamanho retorna o tamanho do array encapsulado. Uma vez que o campo que 26 * representa o array é declarado como sendo privado, é uma boa idéia ter uma 27 * maneira de acessar o tamanho do array de fora desta classe. 28 * Retorna o número de posições para valores do tipo float no array encapsulado 29 */ 30 public int tamanho() 31 { 32 return array.length; /** 36 * O método modifica recebe como argumentos uma posição e um valor, modificando no 37 * array encapsulado o valor na posição especificada. O valor somente será 38 * modificado se a posição for válida, isto é, estiver entre zero e o tamanho 39 * máximo do array menos um. Caso uma posição não válida seja passada, o método não 40 * executará nenhum comando. 41 posição: a posição do array que será modificada 42 valor: o valor que será armazenado na posição especificada 43 */ 44 public void modifica(int posição,float valor) 45 { 46 if ((posição >= 0) && (posição < array.length)) 47 array[posição] = valor; /** 50 * O método valor retorna o valor armazenado em uma certa posição, que é passada 51 * como argumento para o método. O valor armazenado somente será retornado se a 52 * posição for válida, isto é, estiver entre zero e o tamanho máximo do array menos 53 * um. Caso uma posição não válida seja passada, o método retornará a constante 54 * Float.NaN, que representa um valor de ponto flutuante que não é um número. Em 55 * exemplos e exercícios posteriores veremos maneiras mais elegantes de tratar 56 * esses tipos de problema. 57 posição a posição do array cujo valor será retornado

15 58 * Retorna: o valor que estava armazenado na posição especificada 59 */ 60 public float valor(int posicao) 61 { 62 if ((posicao >= 0) && (posicao < array.length)) 63 return array[posicao]; 64 else 65 return Float.NaN; /** 69 * O método paraarray retorna o array encapsulado como um array de floats. Este 70 * método pode ser útil caso seja necessário usar o array "desencapsulado", para, 71 * por exemplo, passá-lo como argumento para um método que somente aceita arrays. 72 o array encapsulado por esta classe 73 */ 74 public float[] paraarray() 75 { 76 return array; /** 80 * O método menorvalor retorna o menor valor presente no array encapsulado. Este 81 * método usa um algoritmo simples que considera que no seu primeiro passo o menor 82 * valor encontrado é o primeiro valor do array, e varre os valores restantes, 83 * modificando o menor valor armazenado se um elemento do array for menor que o 84 * armazenado. 85 o menor valor presente no array encapsulado 86 */ 87 public float menorvalor() 88 { 89 float menorateagora = array[0]; 90 for(int c=1;c<array.length;c++) 91 if (array[c] < menorateagora) 92 menoratéagora = array[c]; 93 return menorateagora; /** 96 * O método maiorvalor retorna o maior valor presente no array encapsulado. Este 97 * método usa um algoritmo simples que considera que no seu primeiro passo o maior 98 * valor encontrado é o primeiro valor do array, e varre os valores restantes, 99 * modificando o maior valor armazenado se um elemento do array for maior que o 100 * armazenado. 101 * Retorna o maior valor presente no array encapsulado 102 */ 103 public float maiorvalor() 104 { 105 float maiorateagora = array[0]; 106 for(int c=1;c<array.length;c++) 107 if (array[c] > maiorateagora) 108 maiorateagora = array[c]; 109 return maiorateagora; /** 112 * O método tostring retorna os valores do array encapsulado formatados em uma 113 * String. 114 * Retorna uma String contendo uma representação dos valores do array encapsulado. 115 */ 116 public String tostring() 117 { 118 String resultado = "O array tem "+array.length+" elementos: \n"; 129 for(int c=0;c<array.length;c++) 120 resultado += array[c]+" "; 121 return resultado; // fim da classe TemperaturasTeresina Listagem 1.1: A classe TemperaturasTeresina, que encapsula um array de valores do tipo float 15

16 16 Os pontos de interesse da classe TemperaturasTeresina (listagem 1.1) são: A classe encapsula um array de floats, fornecendo métodos para recuperar e modificar o array. O campo que representa o array é declarado na classe, fora dos métodos, para que possa ser acessado de qualquer método. O array é inicializado (memória alocada) no construtor da classe, desta forma quando métodos da classe forem executados saberemos que o array já foi inicializado, uma vez que o construtor será o primeiro método a ser chamado. Como o array foi declarado como sendo private da classe, o campo length do array também o será. Como é útil sabermos o tamanho do array, criamos o método tamanho para retornar este valor. Dois métodos permitem a modificação e recuperação de valores do array encapsulado: modifica e valor. Ambos os métodos tem um mecanismo primitivo para evitar que índices incorretos sejam usados para acessar os elementos do array encapsulado. A classe fornece um método paraarray que retorna o array encapsulado - este método pode ser útil caso seja necessário montar um array a partir dos valores encapsulados, evitando múltiplas chamadas ao método valor, o que é computacionalmente custoso. O tipo de retorno deste método é float[], ou seja, array de floats. Dois métodos adicionais (maiorvalor e menorvalor) demonstram as vantagens do encapsulamento de um array ao invés do uso direto: podemos incluir métodos que calculam, inicializam ou fazem operações de interesse no array, criando métodos que façam o processamento. Neste caso, poderemos saber qual foi a maior e a menor temperatura na cidade de Teresina durante um certo período. A classe TestaTemperaturasTeresina, mostrada na listagem 1.2, demonstra o uso de uma instância da classe TemperaturasTeresina. 1/** 2 * A classe TestaTemperaturasTeresina, que demonstra o uso de instâncias da classe 3 * ArrayDeFloats. 4 */ 5 class TestaTemperaturasTeresina 6 { 7 /** 8 * O método main permite a execução desta classe. Este método contém declarações de 9 * uma instância da classe TemperaturasTeresina, e demonstra chamada de seus 10* métodos. 11 argumentos os argumentos que podem ser passados para o método via linha 12 * de comando, mas que neste caso serão ignorados. 13 */ 14 public static void main(string[] argumentos) 15 { int min = 28; int max = 37; 16 // Declara e inicializa a instância da classe 17 TemperaturasTeresina tt = new TemperaturasTeresina(25); 18 // Vamos popular o array com valores obtidos através da geração de valores 19 // aleatórios entre as temperaturas min e max através do método random. 20 for(int i=-3;i<40;i++) 21 tt.modifica(i,(float) min+(math.random()*(max-min))); System.out.println(tt); // imprimimos uma String contendo array encapsulado. 24 // Imprimimos o maior e o menor valor da temperatura do array encapsulado 25 System.out.println("Maior valor:"+tt.maiorvalor()); 26 System.out.println("Menor valor:"+tt.menorvalor()); 27 // Imprimimos os valores em determinadas posições do array encapsulado 28 System.out.println("Na posição 0:"+tt.valor(0));

17 17 29 System.out.println("Na posição 24:"+tt.valor(24)); 30 System.out.println("Na posição 25:"+tt.valor(25)); 31 // Imprimimos os valores em determinadas posições do array encapsulado, mas usando 32 // a representação desencapsulada 33 float[] copia = tt.paraarray(); 34 System.out.println("Na posição 0:"+cópia[0]); // indiretamente 35 System.out.println("Na posição 0:"+tt.paraArray()[0]); // diretamente // fim da classe TestaTemperaturasTeresina Listagem 1.2: A classe TestaTemperaturasTeresina, que demonstra o uso de instâncias da classe TemperaturasTeresina. Na classe TestaTemperaturasTeresina (listagem 1.2) podemos ver a declaração de uma instância da classe TemperaturasTeresina e chamadas a métodos desta classe. Mesmo com chamadas com argumentos nitidamente incorretos (tentativa de acesso a elementos fora da faixa dos valores válidos (linhas 20 e 21)), a execução da classe não apresentará erros, pois os métodos de acesso foram preparados para ignorar tentativas de acesso inválido. A classe TestaTemperaturasTeresina apresenta dois pontos interessantes que estão relacionados ao método paraarray. Uma chamada ao método é feita, e seu resultado armazenado na referência cópia, que não foi inicializada, somente tendo sido declarada. Esta chamada ao método faz com que o array encapsulado na instância tt e o array cópia apontem para a mesma posição de memória, desta forma, qualquer modificação feita usando a referência cópia alterará o array encapsulado. Se este não é o comportamento desejado, podemos reescrever o método paraarray para que este retorne uma cópia ou clone do array encapsulado. O segundo ponto interessante é a sintaxe da segunda chamada ao método paraarray, mostrado como tt.paraarray()[0], que permite que acessemos um elemento de um resultado de chamada a método. Embora a sintaxe seja incomum, está absolutamente correta: o resultado da operação tt.paraarray() é um array de floats, e podemos acessar seu primeiro elemento com o sufixo [0] Arrays de Instâncias de Classes Arrays de instâncias de classes (tanto já existentes em Java quanto definidas pelo programador) podem ser declaradas de forma bem similar à arrays de valores de tipos nativos. A diferença principal é que a inicialização do array deve ser seguida da inicialização dos elementos do array, que deve ser feita da mesma maneira que fazemos com instâncias de classes comuns - geralmente, através da palavra-chave new e da chamada ao construtor da classe. Uma diferença fundamental entre os arrays de tipos nativos e de instâncias de classes é que elementos de arrays nativos devem ser sempre do mesmo tipo, enquanto que elementos de arrays de instâncias podem conter instâncias de qualquer classe que seja herdeira da classe usada para declaração do array (aplicação de polimorfismo em arrays de instâncias de classes). Desta forma, se declaramos um array de instâncias da classe Pessoa, por exemplo, poderíamos inicializar um dos elementos deste array como sendo uma instância da classe Aluno, se a classe Aluno for herdeira, direta ou indiretamente, da classe Pessoa. Exemplo:

18 18 Class Pessoa { long rg; String nome; // construtor da classe Pessoa(int rg, String nome) { this.rg=rg; This.nome=nome public String tostring() { return rg +, +nome; // fim da classe Pessoa Class Aluno Extends Pessoa { long matricula; String instituicao; int anodeentrada; //construtor da classe Aluno (long rg, String nome,long m, String ie, int ano){ Super(rg,nome); matricula = m; inttituicao = ie; anodeentrada = ano; public String tostring() { return super.tostring()+matricula+ instituição+anodeentrada; 1 /** 2 * A classe Equipe, que demonstra o uso de um array de instâncias da classe 3 * Pessoa. O método main desta classe declara e inicializa o array de instâncias. 4 */ 5 class Equipe 6 { 7 /** 8 * O método main permite a execução desta classe. Este método declara e inicializa 9 * array de instâncias da classe Pessoa, demonstrando características e 10 * problemas potenciais de arrays de instâncias de classes. 11 argumentos os argumentos que podem ser passados para o método via linha 12 * de comando, mas que neste caso serão ignorados. 13 */ 14 public static void main(string[] argumentos) 15 { 16 // Declaramos um array de Pessoas com cinco posições 17 Pessoa[] p1 = new Pessoa[5]; 18 // Temos agora cinco posições para armazenar instâncias da classe Pessoa no 19 // array, mas as instâncias ainda não foram alocadas! Devemos fazer isto 20 // manualmente para cada elemento do array. 21 p1[0] = new Pessoa(23874, Maria ); 22 p1[1] = new Pessoa(43320, Joao ); 23 p1[2] = new Pessoa(764674, Pedro ); 24 p1[3] = new Aluno(101010, Anita,10929, IFPI,2002); 25 // Podemos imprimir diretamente os elementos do array pois são instâncias da 26 // classe Pessoa, que contém o método mágico tostring. 27 System.out.println(p1[0]); 28 System.out.println(p1[3]); 29 System.out.println(p1[4]); // imprimirá null! // fim da classe Equipe Listagem 1.3: a classe Equipe que mostra um exemplo de arrays de instancias de classes.

19 19 A figura abaixo mostra a representação na memória referente a listagem acima: p1 Pessoa Maria null Pessoa João Pessoa Pedro Aluno Anita IFPI 2002 Figura: 1.1: Representação gráfica de um array de objetos na memória Os principais pontos da classe Equipe são: O array de instâncias da classe Pessoa é declarado e inicializado de maneira similar aos arrays de valores de tipos nativos. Após a inicialização, o array também será preenchido com um valor constante. No caso de arrays de instâncias de classes, todos os elementos do array receberão o valor null. Cada elemento do array é usado como se fosse uma referência individual à uma instância da classe Pessoa, e deve ser inicializado individualmente através da palavrachave new e do construtor da classe Pessoa. Podemos inicializar um dos elementos do array de instâncias de Pessoa com uma instância da classe Aluno, uma vez que a classe Aluno é herdeira da classe Pessoa. Cada elemento do array segue a mesma regra das referências à instâncias de classes: se o comando p1[4] = p1[2] fosse executado, as duas referências estariam apontando para a mesma instância, e qualquer modificação feita usando uma das duas referências estaria afetando a mesma instância. 1.3 Arrays Multidimensionais Os arrays mostrados nos diversos exemplos até agora são arrays de uma única dimensão ou unidimensionais: para acessar os elementos destes arrays basta usar um único índice. Podemos facilmente criar arrays multidimensionais em Java, onde a posição de cada elemento dentro do array será indicada por dois ou mais índices.

20 20 A declaração, construção e inicialização de arrays multidimensionais é realizada conforme exemplos a seguir. Observe que os trechos de códigos são substituíveis entre si, isto é, equivalentes: Um exemplo de uso de arrays multidimensionais é dado pela classe JogoDeDamas, mostrada na listagem 1.4 Esta classe encapsula um tabuleiro de jogo de damas usando caracteres, com casas vazias sendo representadas pelo caracter. e casas com peças de jogadores sendo representadas pelos caracteres o e x. 1/** 2 * A classe JogoDeDamas, que encapsula um tabuleiro de jogo de damas usando um 3 * array de duas dimensões. Casas vazias no tabuleiro são representadas pelo 4 * caracter., e casas com peças pelos caracteres o e x. Esta versão da 5 * classe não prevê a representação de peças duplas (damas), que poderiam ser 6 * representadas e *. 7 */ 8 class JogoDeDamas // declaração da classe 9 { 10 /* 11 * O tabuleiro é representado por um array de caracteres de duas dimensões, com o 12 * tamanho 8x8. Para evitar a manipulação direta do tabuleiro, o campo que o 13 * representa é declarado como private. 14 */ 15 private char tabuleiro[][]; /** 18 * O construtor da classe, que não recebe nenhum argumento. O construtor alocará 19 * o array de duas dimensões que representa o tabuleiro e inicializará as posições 20 * do tabuleiro de forma a representar o jogo em seu início. 21 */ 22 JogoDeDamas() 23 { 24 // A alocação é simples, o tabuleiro tem sempre 8x8 posições 25 tabuleiro = new char[8][8]; 26 // Inicializamos todas as posições do tabuleiro com o caracter ponto (. ) 27 // que representa a ausência de peças na posição. 28 for(int linha=0;linha<8;linha++) 29 for(int coluna=0;coluna<8;coluna++) 30 tabuleiro[linha][coluna] =. ; // todas as posições inicializadas com pontos 31 // Inicialmente, todas as peças estão em posições pré-definidas: as do jogador 32 // que está de frente para o tabuleiro são marcadas com o caracter o for(int linha=0;linha<=2;linha++) 34 for(int coluna=0;coluna<8;coluna+2) 35 tabuleiro[linha][coluna] = o ; 36 //... e as do outro jogador (que está do lado oposto do tabuleiro) são marcadas 37 // com o caracter x.

21 21 38 for(int linha=5;linha<=7;linha++) 39 for(int coluna=0;coluna<8;coluna+2) 40 tabuleiro[linha][coluna] = x ; 41 // fim do construtor 42 /** 43 * O método tostring não recebe argumentos, e retorna uma String contendo os 44 * valores dos campos da classe formatados. No caso desta classe, o array de duas 45 * dimensões será formatado como se fosse um pequeno tabuleiro de damas. 46 * Retorna uma String contendo uma representação do tabuleiro de damas 47 */ 48 public String tostring() 49 { 50 String resultado = ""; // esta String receberá o resultado 51 for(int linha=0;linha<8;linha++) // para todas as linhas do tabuleiro { 53 for(int coluna=0;coluna<8;coluna++) // para cada coluna do tabuleiro 54 resultado += tabuleiro[linha][coluna]; 55 // concatena a peça naquela posição e inclui uma quebra de linha no final de cada 56 // linha do tabuleiro 57 resultado += "\n"; return resultado; 60 // fim do método tostring // fim da classe JogoDeDamas Listagem 1.4: A classe JogoDeDamas exemplificando o uso de arrays multidimensionais. Figura 1.2 : Representação gráfica de um tabuleiro de um jogo de damas Os pontos interessantes da classe JogoDeDamas são seu construtor, que não somente aloca memória para o array bidimensional que representa o tabuleiro do jogo de damas, mas também inicializa os elementos do array para que o tabuleiro fique na sua configuração inicial, e o método tostring, que retorna uma String contendo a representação gráfica do tabuleiro. Arrays multidimensionais podem ter bem mais que duas dimensões. Algumas aplicações matemáticas e de simulações requerem o uso de arrays com mais de três dimensões. A criação destes arrays segue o mesmo padrão dos arrays uni e bidimensionais - a declaração do array deve ser seguida de um número de pares de colchetes igual ao número de dimensões desejadas, e o acesso aos elementos do array deve ser feito usando um índice para cada dimensão.

22 Arrays Irregulares Uma característica interessante da maneira em que arrays multidimensionais são implementados em Java é que os arrays não precisam ter o mesmo número de valores para cada dimensão, ou seja, é possível declararmos arrays que sejam irregulares. Por exemplo, um array irregular bidimensional poderia ter cinco linhas, e cada linha pode ter um número diferente de colunas - não é obrigatório que cada linha tenha o mesmo número de colunas. Esta característica deve-se ao fato que Java trata arrays multidimensionais como arrays de arrays: desta forma um array bidimensional pode ser considerado um array unidimensional onde cada elemento é outro array unidimensional que contém valores de determinado tipo. Um exemplo ilustrativo de array irregular é mostrado na figura abaixo: Figura: 1.3 : Exemplo de um array irregular de duas dimensões A coluna à esquerda da figura 1.3 representa o índice da primeira dimensão do array - cada posição na primeira dimensão aponta para um array de valores inteiros. Um array irregular pode ser declarado da mesma forma que um array multidimensional regular, exceto que somente o tamanho da primeira das dimensões precisa ser especificado - as outras dimensões, podendo ser diferentes, devem ser alocadas em passos subsequentes do método. A listagem abaixo demonstra a criação e o preenchimento (através de entrada de dados) do array representado na figura acima. 1 /** 2 * A classe ArrayIrregular, que demonstra como arrays multidimensionais podem ser 3 * irregulares. 4 */ 5 import java.util.scanner; // pacote necessário para efeturarmos a entrada de dados 6 class ArrayIrregular // declaração da classe 7 { 8 9 public static void main(string[] argumentos) 10 { 11 // Consideramos o número de linhas constante 12 int numerodelinhas = 5; 13 // Declaramos o array bidimensional para formar o array irregular, mas só 14 // alocamos as linhas do array - as colunas serão alocadas depois, cada uma 15 // com um tamanho diferente. Note que a segunda dimensão do array não foi 16 // especificada. 17 int[][] array1 = new int[numerodelinhas][]; 18 // Alocamos cada linha do array separadamente. 19 // Chamamos o operador new para cada linha do array. 20 array1[0] = new int[6]; 21 array1[1] = new int[3]; 22 array1[2] = new int[1]; 23 array1[3] = new int[4];

23 23 24 array1[4] = new int[8]; 25 // Agora vamos popular o array fazendo um laço para efetuarmos a leitura de seus 26 //elementos. Para isso usaremos a classe Scanner para entrada de dados 27 Scanner sc = new Scanner(System.in) 28 for (int i=0;i<=4;i++) { 29 for (int j=0;j<array1[i].length;j++) 30 array1[i][j] = sc.nextint(); 31 Listagem 1.5: A classe ArrayIrregular que demonstra o uso de arrays multidimensionais irregulares. 1.4 Processando argumentos da linha de comando Em todas as aplicações de Java (classes que contém o método main) vimos que este método deve ser declarado como recebendo como argumento um array de Strings. Os valores contidos neste array são criados pela máquina virtual Java quando esta tenta executar um programa, usando os argumentos passados na linha de comando do sistema operacional em que esta máquina virtual esteja sendo executado. Como exemplo, considere uma classe Teste que contenha o método main. Quando esta classe for executada com o comando: java Teste, o array de Strings declarado dentro do método main terá comprimento zero, ou seja, será vazio, pois nenhum argumento ou parâmetro adicional foi passado para a classe. Se a mesma classe for executada com o comando: java Teste 1 b 3 d 5, o array de Strings declarado dentro do método main terá comprimento 5, e seus elementos serão { 1, b, 3, d, 5. É importante notar que mesmo que se alguns elementos do array aparentam ser numéricos, na verdade todos serão instâncias da classe String. Caso seja necessário processar valores numéricos passados pela a linha de comando, estes deverão ser convertidos de Strings para numéricos. A linha de comando é um mecanismo muito prático e eficiente para que usuários passem valores diretamente para o programa sem precisar que este interrompa a execução para pedir valores pelo teclado, especialmente útil para trabalhos em lote ou para passar argumentos que modifiquem o funcionamento do programa. No exemplo abaixo, a classe Teste está recebendo 3 parâmetros (p1, p2 e p3) durante a execução.

24 24 A classe CalculadoraDeLinhaDeComando, mostrada na listagem 1.6, demonstra o uso da linha de comando para criar uma pequena e simples calculadora que recebe três argumentos via linha de comando: o primeiro e o terceiro argumentos devem corresponder a valores inteiros, e o segundo argumento deve ser um caractere correspondente a uma das quatro operações básicas ( +, -, * ou / ). O programa usará os argumentos para calcular o valor da expressão, e imprimirá este resultado. 1 /** 2 * A classe CalculadoraDeLinhaDeComando, que implementa uma calculadora simples 3 usando argumentos passados pela linha de comando. Esta calculadora somente aceita 4 valores inteiros como argumentos. 5 */ 6 class CalculadoraDeLinhaDeComando // declaração da classe 7 { 8 /** 9 * O método main permite a execução desta classe. Este método usa os argumentos 10 * passados pela linha de comando, que serão disponibilizados para a aplicação 11 * através do array que é o argumento para o método main. Os argumentos serão 12 * processados para cálculo da operação entre o primeiro e o terceiro argumentos, 13 * onde a operação será definida pelo segundo argumento. 14 * Parametros: argumentos os argumentos que foram passados pela linha de comando 15 * para esta aplicação. 16 */ 17 public static void main(string[] argumentos) 18 { 19 // Primeiro, verificamos se exatamente três argumentos foram passados pela linha 20 // de comando, e saímos do programa caso contrário. 21 if (argumentos.length!= 3) 22 { 23 System.out.println("Este programa precisa que três argumentos sejam passados "+ 24 "pela linha de comando."); 25 System.exit(1); // saímos do programa com o código de execução número // Extraimos um valor inteiro da String correspondente ao primeiro argumento 28 int primeirovalor = Integer.parseInt(argumentos[0]); 29 // Extraimos o primeiro caracter da String correspondente ao segundo argumento 30 char operador = argumentos[1].charat(0); 31 // Extraimos um valor inteiro da String correspondente ao terceiro argumento 32 int segundovalor = Integer.parseInt(argumentos[2]); 33 // Dependendo do caracter operador, efetuamos a operação 34 int resultado = 0; // deve ser inicializada 35 switch(operador) 36 { 37 case + : resultado = primeirovalor + segundovalor; break; 38 case - : resultado = primeirovalor - segundovalor; break; 39 case * : resultado = primeirovalor * segundovalor; break; 40 case / : resultado = primeirovalor / segundovalor; break; // Imprimimos os argumentos passados com espaços entre eles 43 for(int índice=0;índice<argumentos.length;índice++) 44 System.out.print(argumentos[índice]+" "); 45 // Imprimimos o resultado 46 System.out.println("= "+resultado); 47 // fim do método main // fim da classe CalculadoraDeLinhaDeComando Listagem 1.6: A classe CalculadoraDeLinhaDeComando que implementa uma calculadora simples usando argumentos passados pela linha de comando Analisando a listagem acima, temos alguns pontos interessantes: Um dos primeiros passos do método main é verificar se o número esperado de argumentos foi passado pela linha de comando, e caso o número seja diferente de três,

25 25 imprime uma mensagem de erro e sai do programa com o método exit da classe System. Este método recebe como argumento um valor inteiro que, por convenção, deve ser diferente de zero se o programa terminou inesperadamente ou com erro. O array de argumentos é de instâncias da classe String, mas o programa deve processar os valores do tipo int correspondentes ao primeiro e terceiro argumentos (de índices 0 e 2). A conversão de String para int pode ser feita com o método parseint da classe Integer. Similarmente, o operador a ser processado é do tipo char, e deve ser extraído da String que é o segundo elemento do array argumentos. A extração de caracteres individuais de Strings é feita com o método charat da classe String. Ao final da operação, os elementos do array argumentos e o resultado são impressos. IMPORTANTE! Alguns cuidados importantes devem ser tomados em relação à linha de comando: o array de Strings que é passado como argumento para o método main considera que seus elementos são separados por espaços, desta forma, se a classe CalculadoraDeLinhaDeComando for chamada com o argumento 7+5, somente uma única String será passada para a aplicação, que terminará com uma mensagem de erro. 1.5 A classe String (Array de Caracteres) Grande parte dos programas de computador tem a necessidade de representar e manipular números e seqüências de caracteres (strings). Além de permitir a representação de cadeias de caracteres de forma simples, a classe String contém muitos métodos práticos e úteis para o processamento de textos. Por exemplo, a string Alo, Java! é composta dos caracteres A, l, o,,,, J, a, v, a,!, sendo que A é considerado o primeiro caractere da string e! o último. O comprimento da string é dado pelo número de caracteres que esta contém: no exemplo anterior, a string contém nove caracteres. O índice de cada um dos caracteres indica a posição deste na string: este índice pode valer entre zero e o valor do comprimento da string menos um. Por exemplo, a posição do caracter J na string Java é zero, e do caracter v na mesma string é dois. Os índices em uma string podem estar entre 0 (zero) e o numero de caracteres menos um. Tentativas de acessar caracteres ou trechos de uma string usando índices fora da faixa de valores válidos causarão uma exceção chamada java.lang.stringindexoutofboundsexception (exceções são categorias especiais de erros em Java, e serão vistas com detalhes mais adiante) Construindo Strings Nos exemplos vistos anteriormente vimos que instâncias da classe String podem ser construídas diretamente, por atribuição direta à referências, sem necessidade da chamada do construtor através da palavra-chave new - isto é uma exceção entre as outras classes que vimos. Até agora aprendemos a criar uma string em Java através da sintaxe: String <identificador> = <valor entre aspas duplas> Ex: String nome = Aula de Java ;

26 26 Podemos também criar uma string usando a palavra-chave new e um construtor que recebe, como argumento, uma outra instância, já existente,da classe String. Sintaxe: String <identificador> = new String(<valor entre aspas duplas>) Ex: String nome = new String ( Aula de Java ); O trecho de código acima cria uma nova instância da classe String contendo a cadeia de caracteres Aula de Java Instâncias da classe String também podem ser construídas se passarmos para o construtor da classe um array de caracteres que já tenha sido inicializado de alguma forma. Assim, o trecho de código: char[] caracteres = { P, r, o, g, r, a, m, a ; String lista = new String(caracteres); criará uma instância da classe String contendo a cadeia de caracteres Programa. Não é possível criar uma instância da classe String passando como argumento outros tipos de arrays ou dados Métodos importantes da classe String length: Este método não recebe argumentos e retorna um valor inteiro igual ao número total de caracteres contidos na string. É importante notar que o método length da classe String é diferente do campo length de arrays em Java - a sintaxe de chamada de métodos exige que usemos parênteses, mesmo que argumentos não sejam passados. Ex: Int n = lista.length(); // retorna o valor: 8 charat: Tem a função de recuperar caracteres individuais de uma string. Este método recebe como argumento um valor inteiro correspondente à posição do caractere que desejamos recuperar, e retorna o caractere naquela posição. Usando os métodos length e charat podemos facilmente escrever um laço que recupere todos os caracteres da string, um a um. Ex: Criar um programa que dado uma string qualquer, retorne o numero de ocorrências de uma letra nesta palavra. String palavra = controle remoto ; letra = o ; int ocorrências=0; for (int i=0;i<palavra.length( );i++) { if (palavra.charat(i) == letra) ocorrências++; System.out.println( O número de ocorrências da letra na palavra é: +ocorrências);... Métodos para comparação de Strings É frequente a necessidade de comparação de valores de variáveis ou campos com outras variáveis, campos ou constantes, para tomada de decisões em programas e métodos. Instâncias

27 27 da classe String (sejam elas campos ou mesmo constantes) não podem ser comparadas com o operador ==. Para a comparação de strings podemos usar métodos da própria classe String. Uma vantagem do uso de métodos para comparação de strings é que existem mais de uma maneira de compararmos strings, a mais comum sendo a comparação de caracter por caracter de duas strings, com diferenciação ou não de caracteres maiúsculos e minúsculos. Se considerarmos que caracteres maiúsculos e minúsculos são iguais, as strings CASA e casa serão iguais, mas se considerarmos que caracteres maiúsculos e minúsculos são diferentes, as strings serão diferentes. equals É um dos métodos básicos na comparação de strings. Deve ser chamado a partir de uma instância da classe String e receber outra instância da classe String como argumento, e retornará o valor booleano true se todos os caracteres da instância que chamou o método forem iguais (inclusive na ordem e considerando maiúsculos diferentes de minúsculos) aos caracteres da instância passada como argumento. Ex: String senha = CursoJava ; String senhadigitada = cursojava ; if!(senha.equals(senhadigitada)) System.out.println( senha incorreta! ); No trecho de código acima, temos duas strings que apesar de serem inicializadas com o mesmo nome, não possuem todos os caracteres iguais. Neste caso, o método equals, depois da comparação dos conteúdos das duas strings, retornará um valor false. equalsignorecase Este método se comporta da mesma forma que o método equals, exceto que considera caracteres maiúsculos e minúsculos como sendo iguais. Neste caso, se substituirmos o método equals por equalsignorecase no trecho de código anterior, o teste retornará um valor true. Métodos para procura em Strings Frequentemente também é necessário verificar se uma string contém outra, ou em que posição uma string aparece dentro de outra. A classe String tem vários métodos para buscas de substrings (consideradas trechos de strings). indexof O método de uso mais comum é o método indexof, que recebe uma string como argumento e retorna a posição onde esta string aparece dentro da string que executou o método, ou -1 se a string passada como argumento não estiver contida da que executou o método. Assim, se a string dna for igual a CTAGGTGTAGGC e a string trecho for igual a GG, a expressão dna.indexof(trecho) retornará 3 (a quarta posição, considerada a partir do zero, é onde a substring aparece na string). Vale a pena notar que a string trecho aparece mais de uma vez na string dna, mas somente a primeira ocorrência será considerada (o método possui outras formas que permitem verificar outras substrings além da primeira). O método indexof é frequentemente usado para verificar se uma substring é parte de outra: se o valor retornado for maior ou igual a zero, a substring está contida na string.

28 28 Métodos para modificação de Strings Instâncias da classe String, depois de criadas, são imutáveis - seu conteúdo não pode ser modificado diretamente (através de acesso aos caracteres individuais da string) ou indiretamente (através de métodos). Até mesmo operações de concatenação como: String nome = Jean-Paul ; nome = nome + Tremblay ; causam a criação de uma string temporária, contendo a concatenação das strings nome e Tremblay, que depois serão associadas à referência nome. tolowercase O método tolowercase não recebe argumentos e transforma todos os caracteres da string que o executar em minúsculos (inclusive respeitando acentos), retornando a string modificada. Desta forma, se a string curso valer InFormáTica, o resultado de curso.tolowercase() será informática. touppercase Similarmente, este método transforma todos os caracteres da string que o executar em caracteres maiúsculos, retornando esta string transformada, de forma que o resultado da expressão curso.touppercase() será INFORMÁTICA. trim Outro método que retorna uma versão modificada da string que o executar é o método trim, que elimina os espaços (e caracteres de controle) no início e fim de uma string, retornando a string sem estes caracteres. Por exemplo, se o campo texto valer Casa\n\n (notem os dois espaços no início da string e as duas quebras de linhas no final), a expressão textoentrado.trim() retornará Casa, tendo eliminado quatro caracteres nas pontas da string original. O método trim não elimina espaços internos na string: se executássemos este método na string técnico em informática o resultado seria uma nova string idêntica à original, já que nenhum espaço ou caracter de controle foi removido. replace Outro método que retorna uma string modificada a partir da string que executa o método é o replace, que recebe como argumentos dois caracteres, e troca todas as ocorrências do primeiro caractere pelo segundo caractere, retornando a string modificada. Desta forma se a string gíria valesse pé-de-meia, o resultado da expressão gíria.replace( -, ) seria pé de meia (todos os caracteres - foram trocados por espaços). Não é possível, com o método replace, eliminar ou inserir caracteres adicionais, uma vez que os dois argumentos para o método devam conter um único caractere. substring Este método com duas formas permite a seleção e retorno de parte da string que o executar: o método substring, na forma que recebe somente um valor inteiro como argumento, retornará a substring composta por todos os caracteres cujos índices sejam maiores ou iguais ao valor passado. Assim, se a string disciplina valer Engenharia de Software, o resultado da expressão: disciplina.substring(11) será de Software.

29 29 O método substring também tem uma forma na qual dois valores numéricos são passados como argumentos, e o método retornará uma nova string composta de todos os caracteres cujos índices forem maiores ou iguais ao primeiro argumento e menores do que o segundo argumento. Desta forma, usando a string disciplina como exemplo, o resultado da expressão disciplina.substring(11,7) será de Soft. Os argumentos para o método devem estar entre zero e o comprimento da string menos um, e o segundo argumento deve ser maior que o primeiro, caso contrário uma exceção ocorrerá. concat O método concat, que recebe como argumento uma string e retorna a concatenação da string que executou o método com a passada como argumento. Este método tem a mesma funcionalidade do operador +, de forma que se a string disciplina valer Engenharia, o resultado da operação nome.concat( de Software ) será Engenharia de Software. A vantagem do uso do método concat sobre o operador + é que podemos fazer chamadas em cascata usando este método e outros da classe String caso seja necessário. 1.6 Exercícios Resolvidos Exercício resolvido 1: Escreva um programa em Java que crie um array de valores inteiros e que popule o array de forma que o valor do elemento do array seja o dobro de seu índice. 1 public class Exercicio1 { 2 int v[]; 3 4 Exercicio1(){ 5 v = new int[5]; 6 for (int i=0;i<v.length;i++){ 7 v[i] = 2*i; public String tostring(){ 11 String resultado = ""; // esta String receberá o resultado 12 for(int i=0;i<v.length;i++) 13 resultado += v[i]; 14 return resultado; public static void main(string []args){ 17 Exercicio1 e = new Exercicio1(); 18 System.out.println(e); 19 No código acima, criamos um vetor de tamanho 5. O tamanho do array só é definido no construtor da classe (linha 5). A partir daí esse tamanho não pode mais mudar. Ainda na definição do construtor, percorremos o array através de um loop for e atribuímos números cujos valores são o dobro de seus respectivos índices (linhas 6 e 7). Na linha 10, definimos um método tostring( ), que tem a função de imprimir os valores dos elementos do vetor. Finalmente na linha 16, temos a definição de um método principal (main()), onde um objeto da classe é criado e a partir daí o construtor é chamado, fazendo com que o vetor seja criado e

30 30 Exercício resolvido 2: Escreva um programa simples em Java para jogar o jogo da velha: 1 import java.util.scanner; 2 public class JogoVelha { 3 char [][] tabuleiro; 4 5// Constrói um tabuleiro vazio 6 7 public JogoVelha() { 8 tabuleiro = new char[3][3]; 9 // preenche com espaços 10 for (int i=0; i <3; i++) 11 for (int j=0;j<3;j++) 12 tabuleiro[i][j] = ' '; // atribui um valor('o' ou 'x') no tabuleiro void setjogada(int i, int j, char jogador) { 19 /** 20 * Parâmetros: 21 * i : indice da linha; 22 * j : indice da coluna; 23 * jogador: jogada ('o' ou 'x') 24 */ 25 if (tabuleiro[i][j]!= ' ') 26 System.out.println("posição ocupada"); 27 else 28 tabuleiro[i][j]=jogador; /** 32 * Cria uma representação de string no tabuleiro como: 33 * x o 34 * x 35 * o 36 * Retorna a representação da String 37 */ 38 public String tostring() { 39 String r = ""; 40 for (int i=0; i < 3; i++){ 41 r = r+" "; 42 for (int j= 0;j < 3;j++){ 43 r = r+tabuleiro[i][j]+" "; r = r+"\n"; return r; public static void main(string args[]) { 51 JogoVelha jv = new JogoVelha(); 52 Scanner sc = new Scanner(System.in);

31 31 53 int linha, coluna; 54 char jog = 'x'; 55 while (true){ 56 System.out.println("entre com a posição da linha para: "+jog); 57 linha = sc.nextint(); 58 System.out.println("entre com a posição da coluna para: "+jog); 59 coluna = sc.nextint(); 60 jv.setjogada(linha, coluna, jog); 61 if (jog == 'x') 62 jog = 'o'; 63 else 64 jog = 'x'; 65 System.out.println(jv); No código acima, criamos um array bidimensional do tipo char. O tamanho do array é definido apenas no construtor da classe (linha 8) e em seguida o array é inicializado com um caractere de espaço. O método setjogada é responsável por preencher com x ou o as casas livres do tabuleiro do jogo. A cada jogada feita, ou seja, a cada vez que o método setjogada é chamado em seguida o método tostring() para mostrar a configuração do tabuleiro depois da jogada efetuada. Este exemplo é simples e não verifica o ganhador da partida. Exercício resolvido 3: Escreva uma classe em Java que contenha um método retiravogais que receba uma string como argumento e remova todas as vogais (maiúsculas e minúsculas) desta string, retornando a string modificada como resultado. import java.util.scanner; public class Exercicio3 { String retiravogais(string s1) { String s2=""; for (int i=0; i<s1.length();i++){ if ((s1.charat(i)!= 'a') && (s1.charat(i)!='e') && (s1.charat(i)!='i') && (s1.charat(i)!='o') && (s1.charat(i)!='u')) s2=s2+s1.charat(i); return s2; public static void main (String args[]){ Exercicio3 ex = new Exercicio3(); Scanner sc = new Scanner(System.in); String palavra = sc.next(); System.out.println(ex.retiraVogais(palavra)); No código acima, criamos um método retiravogais que recebe uma string como parâmetro e retorna uma string como resultado. Utilizamos um laço for para percorrer toda a string caractere a caractere e para isso utilizamos o método charat que tem a função de recuperar caracteres individuais de uma string. Em seguida criamos uma variável string s2, onde concatenamos todos os caracteres diferentes de vogais e retornamos esta string como resultado.

32 32 RESUMO DA AULA 1 Nesta aula abordamos os conceitos e aplicações práticas do uso de arrays. O array é uma sequencia de tamanho fixo de valores do mesmo tipo. O tamanho do array é fixo e não pode ser modificado durante sua a execução do programa. Os arrays são acessados através de índices inteiros, como por exemplo na notação: referenciadearray[indice], onde indice representa um índice de valores inteiros. Use o campo length para obter o número de elementos de um array. O índice para acesso a um elemento de um array deverá ser um valor entre zero e o tamanho do array menos um. Qualquer valor acessado fora deste limite ocasionará erro de execução. Arrays de instâncias de classes são criados utilizando-se a palavra chave new. Podemos facilmente criar arrays multidimensionais em Java, onde a posição de cada elemento dentro do array será indicada por dois ou mais índices. Os arrays não precisam ter o mesmo número de valores para cada dimensão, ou seja, é possível declararmos arrays que sejam irregulares. Os arrays irregulares também são definidos como arrays de arrays. A classe mais usada para representação e processamento de cadeias de caracteres é a classe String. Além de permitir a representação de cadeias de caracteres de forma simples, a classe String contém muitos métodos práticos e úteis para o processamento de textos.

33 33 ATIVIDADES DA AULA 1 1. Qual será o conteúdo dos arrays declarados na aplicação abaixo ao término da execução do método main? class Exercicio1 { public static void main(string[] argumentos) { double[] valores = {1,2,3,4,5,6; double[] primeiracópia = valores; double[] segundacópia = valores; primeiracópia[1] = 1; segundacópia[2] = valores[0]+primeiracópia[1]; primeiracópia[3] = valores[1]+segundacópia[2]; valores[4] = primeiracópia[2]+segundacópia[3]; valores[5] = segundacópia[3]+primeiracópia[4]; 2. Escreva um programa que declare um array bidimensional tabuada de 10x10 posições e popule os elementos do array com os valores da tabuada da soma para aquele elemento, de forma que, por exemplo, o elemento tabuada[7][9] valha O método abaixo pode ser um método da classe TemperaturasTeresina (listagem 1.1)? Explique. public void mudatamanho(int novotamanho) { array.length = novotamanho; 4. Crie na classe TemperaturasTeresina (listagem 1.1) um método mostramédia que calcule e retorne a temperatura média de todas as temperaturas do array. 5. Escreva um método imprimealunos para a classe Equipe (listagem 1.3) que receba o array de instâncias da classe Pessoa como argumento e imprima somente os elementos que forem instâncias da classe Aluno. O método não deverá imprimir instâncias que sejam iguais a null. 6. Escreva uma classe Menu em Java que encapsule um array de strings. Nesta classe, crie o método escolhe que mostra as strings com um número na frente, espere o usuário digitar um número e retorne a string correspondente àquele número. Dicas: faça com que o usuário seja impossibilitado de digitar números fora da faixa com um laço while, e faça com que os números a serem impressos antes das strings estejam na faixa 1 a N, onde N é o tamanho do array. Desta forma a escolha fica mais amigável para o usuário. 7. Crie uma classe EntradaEmAgenda que contenha os dados necessários para armazenar uma entrada de agenda (hora, dia, mês, ano, assunto). Crie nesta classe, além do construtor e do método tostring, um método énodia que recebe valores de dia, mês e ano e retorna true se o dia, mês e ano daquela instância da classe forem iguais aos argumentos passados. Crie um

34 34 método similar chamado énomês que recebe valores de mês e ano somente e retorna true se o mês e ano daquela instância da classe forem iguais aos argumentos passados. Crie também uma classe Agenda que encapsule uma agenda de compromissos, que será representado por um array de instâncias da classe EntradaEmAgenda. Crie um método listadia que recebe valores de dia, mês e ano e lista todas as instâncias de EntradaEmAgenda que caem naquele dia, mês e ano, e um método listamês que recebe valores de mês e ano e lista todas as instâncias de EntradaEmAgenda que caem naquele mês e ano. 8. Adicione um método obtervencedor à classe JogoVelha. Ele deve retornar x ou o para indicar um vencedor ou se ainda não houver vencedor. Lembre-se de que uma posição vencedora tem três marcas que se correspondem em uma linha, coluna ou diagonal. 9. Escreva uma classe em Java que implemente um método replica, que recebe como argumentos uma string e um valor inteiro, e retorna uma string composta de várias repetições da string passada como argumento, onde o número de repetições deve ser o número passado como argumento. Por exemplo, se os argumentos para este método forem a string Ha! e o valor 3, o método deverá retornar Ha!Ha!Ha! 10. Escreva na classe em Java que implemente um método conta que receba como argumentos uma string e uma substring, e retorne um inteiro correspondente ao número de ocorrências da substring na string passados como argumentos..

35 Tratamento de Exceções Aula 35 2 Objetivos Ao final desta aula, você deverá ser capaz de: Aprender a capturar exceções Saber quando e onde capturar uma exceção. Aprender a lançar exceções. Entender a diferença entre exceções verificadas e não-verificadas.

36 Introdução Uma exceção é um evento que ocorre durante a execução de um programa e que desfaz o fluxo normal de instruções. Por exemplo, tentar acessar um elemento fora dos limites de um array, tentar dividir um número por zero, são exemplos de exceções. Um erro em Java é uma condição anormal irrecuperável. Por exemplo, uma condição de erro ocorre se existe algum erro interno na JVM ou se a JVM fica sem memória. A diferença entre um erro e uma exceção é que uma exceção pode ser capturada e o programa pode seguir em frente a partir dali, já quando um erro ocorre o programa necessariamente irá terminar. Quando uma exceção ocorre no interior de um método Java, o método cria um objeto do tipo Exception e o retorna para o sistema. Este processo é chamado de disparar uma exceção. O objeto Exception contém informações sobre a exceção, incluindo seu tipo e o estado do programa quando a exceção ocorreu. Quando uma exceção é disparada, o sistema busca em seqüência na pilha todos os métodos para tentar encontrar um capaz de tratar este tipo de exceção. Na terminologia Java, este método captura a exceção. Se o sistema não encontra nenhum método apto a capturar a exceção, o programa inteiro termina. Vamos começar os nossos estudos conhecendo a forma como uma exceção é apresentada e o seu significado, observe as duas classes abaixo: Figura 2.1: Exemplo de código onde há uma exceção Fonte: ( As setas indicam o fluxo de execução até o ponto onde irá acontecer a exceção (estrela) o que ocasiona a quebra no fluxo normal da aplicação. Esta execução pode ser entendida da seguinte forma: Ao invocar o método main, sem o envio de parâmetros, é instanciado um novo objeto RecebeArray e passado como parâmetro do construtor o array vazio, o construtor por sua vez invoca um método desta mesma classe (imprimirposicao0()) repassando o parâmetro recebido, este método tenta imprimir o elemento da posição 0, primeira posição, e o resultado obtido é uma exceção, já que o array está vazio. Quando esta exceção acontece o programa é encerrado de forma inesperada, perceba que a última linha a ser executada (linha grifada em

37 37 amarelo) não é percorrida devido ao término inesperado. Podemos observar a visualização da execução desta aplicação na figura a seguir: Figura 2.2: Resultado da execução do programa descrito na figura 2.1 A exceção ocorrida foi do tipo java.lang.arrayindexoutofboundsexception que significa a tentativa de acesso a uma posição fora dos limites do array, em seguida ele informa que posição foi, neste caso o índice 0 (zero). Embaixo da definição da exceção nós temos a stacktrace (rastro da pilha) que contém a seqüência da pilha de execução. Pela stacktrace é possível perceber quais caminhos a execução percorreu até alcançar a exceção. A primeira linha da stacktrace contém a definição da exceção, a segunda linha contém o ultimo trecho de código executado com o número da linha no código fonte, neste caso foi a invocação do método imprimirposicao0() da classe RecebeArray, que no código fonte (arquivo RecebeArray.java) refere-se a linha Capturando Exceções Quando chamamos um método que pode retornar uma exceção (tanto verificável quanto não), temos três alternativas: 1. Capturar a exceção e tratá-la 2. Deixar a exceção passar pelo método, ou seja, em algum outro lugar ela deve ser capturada. 3. Capturar a exceção e disparar uma exceção diferente. A nova exceção deve ser capturada em algum lugar. Toda exceção lançada representa um objeto que armazena informações sobre a ocorrência de um erro ou alguma situação não-usual do programa. Caso a exceção não seja capturada por nenhum método do programa, o programa irá terminar com erro.

38 38 Para capturar uma exceção, devemos colocar o código possível de lançamento de exceção em um bloco de comandos: try... catch. Todas as linhas do programa que podem lançar uma exceção devem ficar no bloco try. Para capturar a exceção devemos usar a palavra reservada catch. Um bloco try pode estar relacionado a mais de um bloco catch, mas um bloco try sozinho representa um erro de compilação. Não pode haver código adicional entre o bloco try e o começo do catch. Cada bloco catch manipula um tipo de exceção indicado por seu parâmetro. O tipo do parâmetro indica o tipo da exceção a ser tratada pelo bloco catch e deve ser uma classe que estenda da classe Throwable. Vamos modificar agora a nossa classe RecebeArray e adicionar este bloco ao método imprimirposicao0(): public class RecebeArray { public RecebeArray(String[] array) { imprimirposicao0(array); public void imprimirposicao0(string[] array) { try{ System.out.println(array[0]); catch(arrayindexoutofboundsexception e) { System.out.println("Erro: Array vazio, execute o programa novamente" + " passando ao menos um parâmetro."); E agora ao executarmos novamente este mesmo programa o usuário irá receber uma mensagem mais significativa, observe a execução abaixo: Figura 2.3: Resultado da execução da classe modulo10main com tratamento de exceções. Agora ao executar o programa sem parâmetros o usuário saberá o que fazer. Porém o mais interessante é o seguinte, uma vez que a exceção foi tratada, o programa continua o fluxo de execução e termina normalmente. Devemos observar o seguinte, esta não é a única exceção que pode acontecer neste método, vamos modificar o método main( ) de forma que ele encaminhe como parâmetro um valor nulo (null).

39 39 public class modulo10main { public static void main(string[] args) { new RecebeArray(null); System.out.println("Termino do programa!"); Repare que agora a nova instância da classe RecebeArray está recebendo como parâmetro uma referência nula, isto ocasionará uma exceção do tipo java.lang.nullpointerexception. Vejamos o resultado da execução deste código: Figura 2.4: Resultado da execução do código acima depois da criação de uma instancia da classe RecebeArray com uma referencia nula. Percebemos que o programa encerrou de forma inesperada a mensagem Termino do programa! não foi apresentada por uma exceção pois o nosso bloco try/catch não foi capaz de capturá-la. Isto aconteceu porque ele foi construído de forma que apenas exceções do tipo java.lang.arrayindexoutofboundsexception sejam tratadas. Para corrigir este problema podemos encadear mais um bloco catch que capture todos os tipos de exceções, vejamos: public class RecebeArray { public RecebeArray(String[] array) { imprimirposicao0(array); public void imprimirposicao0(string[] array) { try{ System.out.println(array[0]); catch(arrayindexoutofboundsexception e) { System.out.println("Erro: Array vazio, execute o programa novamente" + " passando ao menos um parametro."); catch(throwable t) { System.out.println("Mensagem do erro: "+t.getmessage()); t.printstacktrace();

40 40 Perceba agora que, no código destacado, adicionamos mais um bloco de catch que captura todos os tipos de exceções veremos mais a frente como está estruturada a hierarquia de classes de exceções desta forma caso seja uma exceção do tipo java.lang.arrayindexoutofboundsexception será tratado no primeiro bloco, todos os demais tipos serão tratados no segundo bloco. O código destacado irá imprimir a mensagem (getmessage()) e na seqüência irá imprimir a stacktrace, é importante perceber novamente que após o tratamento da exceção pelo segundo bloco o programa é encerrado normalmente. A seguir temos a execução do novo programa: Figura 2.5: Resultado da execução do programa após o tratamento da exceção Deixando uma exceção passar através do método Quando uma exceção ocorre mas não temos condição de tratá-la naquele local, podemos passá-la adiante para que num método mais acima ela possa ser tratada adequadamente. Para liberarmos um método de tratar uma determinada exceção devemos usar o comando throws na declaração do mesmo: public int mymethod() throws exception1 { //código que pode gerar a exception1 Exemplo: Esta linha pode gerar uma exceção de MalformedURLException. Porém, o método changeurl resolveu não tratá-la e passá-la adiante. public URL changeurl(url oldurl)throws MalformedURLException { return new URL( ); O método que chamou changeurl pode optar por tratar a exceção ou também passá-la adiante. Porém, se em nenhum momento algum método tratá-la, o programa terminará em erro. 2.3 Hierarquia das Classes de exceção Java A plataforma Java fornece uma numerosa quantidade de classes de exceção para uso nas mais diferentes situações de erro. A figura abaixo apresenta a hierarquia de classes que compõe o controle de erros da linguagem Java.

41 41 Figura 2.5: Hierarquia de classes de exceção da linguagem Java. Fonte: ( Nesta imagem estão representadas as três modalidades de exceções existentes na linguagem Java: Unchecked Exception, Checked Exception e Error. Error: Hierarquia em laranja na imagem, representam situações incomuns, que não são causadas pelo programa, indicam situações que não acontecem usualmente durante a execução de um programa (Ex: Estouro da pilha de execução StackOverflowError); Checked Exception: Hierarquia em cinza, representam situações que, geralmente, não são erros de programação e sim indisponibilidade de recursos ou condição necessária para a correta execução inexistente (Ex: Em aplicações distribuídas existe dependência externa de rede de comunicação NoRouteToHostException). As checked exceptions são tratadas obrigatoriamente, isto é, o compilador só compila a classe se houver um tratamento (bloco try/catch) para aquele tipo de exceção Um exemplo que podemos mostrar agora, é o de abrir um arquivo para leitura, onde pode ocorrer o erro do arquivo não existir: public static void metodo( ) { new java.io.filereader("arquivo.txt"); O código acima não compila e o compilador avisa que é necessário tratar o FileNotFoundException que pode ocorrer: Figura 2.6: Mensagem de erro ao tentar compilar e executar o código acima

42 42 Para compilar e fazer o programa funcionar, precisamos tratar o erro de um de dois jeitos. O primeiro, é tratá-lo com o try/catch: public static void metodo() { try { new java.io.filereader("arquivo.txt"); catch (java.io.filenotfoundexception e) { System.out.println("Nao foi possivel abrir o arquivo para leitura"); A segunda forma de tratar esse erro, é delegar ele para quem chamou o nosso método, isto é, passar para a frente: public static void metodo() throws java.io.filenotfoundexception { new java.io.filereader("arquivo.txt"); Vendo os dois exemplos acima, parece ser mais prático passar o erro pra frente para outros tratarem dele. Pode ser que faça sentido, dependendo do caso, mas não até o main, por exemplo. Acontece que quem tenta abrir um arquivo sabe como lidar com um problema na leitura. Quem chamou um método no começo do programa pode não saber ou, pior ainda, tentar abrir cinco arquivos diferentes e não saber qual deles teve um problema! Não há uma regra para decidir em que momento do seu programa você vai tratar determinada exceção. Isso vai depender de em que ponto você tem condições de tomar uma decisão em relação àquele erro. Enquanto não for o momento, você provavelmente vai preferir delegar a responsabilidade para o método que te invocou. Unchecked Exception (RuntimeException): Hierarquia em azul, representam situações que, geralmente, identificam erros de programação (programa não é robusto) ou mesmo situações incomuns/difíceis de tratar (Ex: Acessar índice inválido em um array ArrayIndexOutOfBoundsException). Exemplo: Que tal tentar dividir um número por zero? Será que o computador consegue fazer aquilo que nós definimos que não existe? public class TestandoADivisao { public static void main(string args[]) { int i = 5571; i = i / 0; System.out.println("O resultado " + i); Tente executar o programa acima. O que acontece? Figura 2.7: Resultado da execução do código acima, onde é invocada a exceção de erro de operação aritmética. Outro exemplo:

43 43 public class TestandoReferenciaNula { public static void main(string args[]) { Conta c = null; System.out.println("Saldo atual " + c.getsaldo()); Agora, tente executar este programa. O que acontece? Figura 2.8: Resultado da execução do código acima, onde é invocada a exceção de referencia nula. Segue abaixo um quadro com relação de algumas das exceções mais comuns: EXCEÇÃO QUANDO ACONTECE ArrayIndexOutOfBounds Exception Tentativa de acesso a posição inexistente no array. ClassCastException Tentativa de efetuar um cast em uma referência que não é classe ou subclasse do tipo desejado. IllegalArgumentException Argumento formatado de forma diferente do esperado pelo método. IllegalStateException O estado do ambiente não permite a execução da operação desejada. NullPointerException Acesso a objeto que é referenciado por uma variável cujo valor é null. NumberFormatException Tentativa de converter uma String inválida em número. StackOverflowError Normalmente acontece quando existe uma chamada recursiva muito profunda. NoClassDefFoundError Indica que a JVM não conseguiu localizar uma classe necessária a execução. 2.4 Lançando Exceções Provavelmente em algum trecho do nosso programa, se uma determinada condição acontecer, nós podemos lançar uma exceção para informar que a situação esperada não aconteceu. Lançar uma Exception é extremamente útil principalmente se, por exemplo, alguém esquecer de fazer um if no retorno de um método. A palavra chave throw lança uma Exception (diferente de throws, que apenas avisa da possibilidade daquele método lançá-la).

44 44 Vejamos um exemplo, suponha o método abastecer( ) pertencente a uma classe que representa um veículo. Este método recebe como parâmetro um Double que representa o valor que está sendo abastecido, logo não pode haver situações onde o valor seja negativo. Caso esta situação aconteça nós iremos lançar uma exceção do tipo: IllegalArgumentException.... public void abastecer(double litros) { if (litros < 0) { throw new IllegalArgumentException("Era esperado um valor maior que 0: "+litros); else { tanque += litros; A seta indica o uso da palavra reservada throw que é responsável por lançar a exceção, logo a seguir nós instanciamos um objeto do tipo IllegalArgumentException e passamos como parâmetro do método construtor o texto que deverá aparecer quando a stacktrace for impressa. Veja o resultado da execução deste método passando o valor -1 (um negativo): Exception in thread "main" java.lang.illegalargumentexception: Valor indevido era esperado um valor maior que 0: -1.0 at Veiculo.abastecer(Veiculo.java:10) at modulo10main.main(modulo10main.java:6) 2.5 Criando sua própria exceção Às vezes, nenhum tipo de exceção-padrão descreve com clareza o seu erro específico. Nesse caso, você pode criar sua própria classe de exceção. Suponha que ao invés de utilizar a exceção: IllegalArgumentException no método abastecer(), caso o valor recebido seja negativo, nós desejemos jogar uma exceção própria chamada QuantidadeLitrosException. Neste caso basta que utilizemos os nossos conhecimentos em herança e façamos uma extensão da classe RuntimeException conforme abaixo: public class QuantidadeLitrosException extends RuntimeException { QuantidadeLitrosException(String mensagem) { super(mensagem); E agora, em vez de lançar um IllegalArgumentException, vamos lançar nossa própria exception, com uma mensagem que dirá Valor indevido. Era esperado um valor maior que 0:": public void abastecer(double litros) { if(litros < 0) { throw new QuantidadeLitrosException("Valor indevido. Era esperado um valor maior que 0: "+litros); else {

45 45 tanque += litros; A execução deste método com um valor negativo resulta em: Exception in thread "main" QuantidadeLitrosException: Valor indevido. Era esperado um valor maior que 0: -1.0 at Veiculo.abastecer(Veiculo.java:10) at modulo10main.main(modulo10main.java:6) E, para testar, crie uma classe que crie um objeto veículo e tente chamar o método abastecer com um valor negativo: public static void main(string[] args) { Veiculo v = new Veiculo(); try { v.abastecer(-1); catch (QuantidadeLitrosException e) { System.out.println(e.getMessage()); IMPORTANTE! Uso do catch e throws com Exception Existe uma péssima prática de programação em java que é a de escrever o catch e o throws com Exception. Existem códigos que sempre usam Exception pois isso cuida de todos os possíveis erros. O maior problema disso é generalizar o erro. Se alguém joga algo do tipo Exception para quem o chamou, quem recebe não sabe qual o tipo específico de erro ocorreu e não vai saber como tratar o mesmo. 2.6 A cláusula: finally Os blocos try e catch podem conter uma terceira cláusula chamada finally que indica o que deve ser feito após o término do bloco try ou de um catch qualquer. É interessante colocar algo que é imprescindível de ser executado, caso o que você queria fazer tenha dado certo, ou não. O caso mais comum é o de liberar um recurso no finally, como um arquivo ou conexão com banco de dados, para que possamos ter a certeza de que aquele arquivo (ou conexão) vá ser fechado, mesmo que algo tenha falhado no decorrer do código. No exemplo a seguir, o bloco finally será executado - não importa se tudo der certo ou não: try { // bloco try catch (IOException ex) { // bloco catch 1 catch (SQLException sqlex) { // bloco catch2 finally { // bloco finally

46 46 RESUMO DA AULA 2 Nesta aula fizemos uma abordagem de tratamento de exceções em Java. Uma exceção é um evento que ocorre durante a execução de um programa e que desfaz o fluxo normal de instruções. Quando chamamos um método que pode retornar uma exceção (tanto verificável quanto não), podemos capturar a exceção e tratá-la ou deixar a exceção passar pelo método, ou seja, em algum outro lugar ela deve ser capturada ou ainda, capturar a exceção e disparar uma exceção diferente. A nova exceção deve ser capturada em algum lugar. Para capturar uma exceção, devemos colocar o código possível de lançamento de exceção em um bloco de comandos: try... catch. Podemos passar uma exceção adiante para que num método mais acima ela possa ser tratada adequadamente e para isso devemos usar o comando throws na declaração do mesmo. Existem dois principais tipos de Exceções: As verificadas (checked) e as não-verificadas (unchecked). As não-verificadas estendem da classe RuntimeException e representam situações que, geralmente, identificam erros de programação. As verificadas (checked) estendem a classe Exception e representam situações que, geralmente, não são erros de programação e sim indisponibilidade de recursos ou condição necessária para a correta execução inexistente. Podemos lançar uma exceção para informar que a situação esperada não aconteceu e para isso usamos o comando throw. Você pode criar sua própria classe de exceção para especificar com clareza seu erro específico. A cláusula chamada finally é utilizada quando queremos que algo seja executado independente da situação anterior de teste ter dado certo ou errado.

47 47 ATIVIDADES DA AULA 2 1. Qual é a diferença entre lançar e capturar uma exceção? 2. O que acontece se uma exceção não tem uma cláusula catch correspondente? 3. Qual é o objetivo da cláusula finally? Exemplifique. 4. Crie uma classe Quadrado com um atributo lado do tipo inteiro. Modifique o construtor desta classe de forma que caso seja recebido um valor igual a zero ou negativo para o atributo lado, seja jogada uma exceção do tipo IllegalArgumentException com o seguinte texto: Valor inválido, o valor esperado é maior que 0 (zero). 5. Reescreva o programa anterior, só que em vez de lançar uma exceção do tipo IllegalArgumentException, seja criada sua própria exceção: ValorInválidoException. 6. Crie uma classe denominada ContaCorrente. Adicione os métodos: sacar, depositar e obterssaldo, adicione o atributo saldo_total. Modifique esta classe para lançar uma exceção do tipo: IllegalArgumentException quanto a conta é construída com saldo negativo, quando uma quantidade negativa é depositada ou quando se saca um valor maior que o saldo total. Escreva uma classe de teste que faça com que essas três exceções ocorram e que capture todas elas.

48 Coleções Aula 48 3 Ao final desta aula, você deverá ser capaz de: utilizar arrays, lists, sets ou maps dependendo da necessidade do programa; iterar, ordenar e pesquisar listas e coleções; usar mapas para inserção e busca de objetos. Objetivos

49 Introdução A utilização de arrays vista na aula 1 pode ser considerada uma boa solução para alguns tipos de problemas, mas torna-se complicada em muitos outros pontos a saber: Não podemos redimensionar um array em Java; É impossível buscar diretamente por um determinado elemento cujo índice não se sabe; Não conseguimos saber quantas posições do array já foram populadas sem criar, para isso, métodos auxiliares. Figura 3.1: Representação gráfica de um array na memória Fonte: FJ11: Java e Orientação a Objetos ( Na figura acima, podemos ver um array que antes estava sendo completamente utilizado e que, depois, teve um de seus elementos removidos. Supondo que os dados armazenados representem contas, o que acontece quando precisarmos inserir uma nova conta no banco? Precisaremos procurar por um espaço vazio? Guardaremos em alguma estrutura de dados externa, as posições vazias? E se não houver espaço vazio? Teríamos de criar um array maior e copiar os dados do antigo para ele? Há mais questões: como poderemos saber quantas posições estão sendo usadas no array? Precisaremos sempre percorrer o array inteiro para conseguir essa informação? Além dessas dificuldades que os arrays apresentavam, faltava um conjunto robusto de classes para suprir a necessidade de estruturas de dados básicas, como listas ligadas e tabelas de espalhamento. Com esses e outros objetivos em mente, a Sun criou o framework Collections com a intenção de formar uma arquitetura unificada para representação e manipulação de coleções. Mas o que é o framework Collections? É o conjunto de implementações (classes e interfaces) oferecidas no pacote java.util que fornecem as principais funcionalidades esperadas quando trabalha-se com conjuntos de elementos (coleções). Figura 3.2: Representação da arquitetura unificada do framework Collections Fonte: Curso Java Starter: Módulo 09: Coleções(

50 50 Na figura acima temos as interfaces (raízes e nós das árvores) que formam o conjunto de interfaces disponíveis. Nas folhas (retângulos com bordas mais espessas) encontramos as classes concretas ou implementações destas interfaces. Esta arquitetura de interfaces forma o núcleo do Java Framework Collections e todas as classes concretas irão derivar de uma ou mais interfaces. É interessante notar que apesar da arquitetura única as coleções derivadas da interface Map não implementam a interface Collection no entanto elas também fazem parte do pacote de implementações Java para coleções. A figura apresentada pode ser interpretada da seguinte forma: Um Set, List ou Queue é um tipo de Collection, cada um com suas particularidades. Já um Map não é do mesmo tipo dos demais mas também manipula coleções de elementos As implementações de cada ramo estão dividas da seguinte forma: List: ArrayList, Vector e LinkedList; Set: HashSet, LinkedHashSet e TreeSet; Map: Hashtable, LinkedHashMap, HashMap e TreeMap. Queue: LinkedList e PriorityQueue; Na prática, quando devemos utilizar uma ou outra implementação? Qual a diferença entra cada uma destas interfaces? A seguir serão explicados, simplificadamente, as principais vantagens obtidas com o uso de cada grupo de interfaces e respectivas implementações. List: Representa uma coleção ordenada (ordem de inserção) e que permite duplicatas; Set: Representa uma coleção que não pode conter duplicatas, implementa uma abstração dos conjuntos matemáticos; Map: É um objeto que armazena um elemento e o remove através da sua chave, os Maps não aceitam chaves duplicadas. Queue: Parecida com a interface List porém adiciona algumas funcionalidades, é muito utilizada para representar listas de elementos cuja ordem é importante, normalmente elementos em ordem de processamento; Nesta aula iremos estudar as interfaces: List, Set e Map. Em resumo, ao utilizarmos as coleções já implementadas no pacote java.util, obtemos as seguintes vantagens: Redução na codificação: Muitas funcionalidades esperadas durante a manipulação de um conjunto de elementos já estão prontas; Melhor desempenho do programa: As implementações das funcionalidades e estruturas de armazenamento foram feitas com o objetivo de fornecerem um desempenho ótimo; Maior qualidade do programa: Respeitando as interfaces podemos substituir as implementações utilizadas sem prejuízo ao resto do programa;

51 Listas: java.util.list Uma lista é uma coleção que permite elementos duplicados e mantém uma ordenação específica entre os elementos. Qualquer implementação da interface List mantém seus elementos indexados, ou seja, existe uma preocupação com o posicionamento de cada elemento e esta posição é determinada pelo índice. Devemos utilizar um List quando a ordem de inserção ou a posição na coleção nos interessa. Em comparação ao array tradicional, as listas resolvem problemas como: busca, remoção, tamanho infinito, etc. A API de Collections traz a interface java.util.list, que especifica o que uma classe deve ser capaz de fazer para ser uma lista. Há diversas implementações disponíveis, cada uma com uma forma diferente de representar uma lista. A figura a seguir mostra um diagrama UML com a representação da interface List e algumas classes que a implementam: Figura 3.3: Representação da interface List Fonte: FJ11: Java e Orientação a Objetos ( A tabela abaixo mostra alguns métodos importantes quando manipulamos lists: Método Descrição add( Objeto ) Adiciona um elemento ao List, na última posição. get( índice ) Retorna o elemento da posição do índice. iterator() Retorna um objeto do tipo Iterator. size() Retorna um int (inteiro) com a quantidade de elementos da coleção. contains(objeto) Retorna true se o elemento já existe dentro do List clear() Elimina todos os elementos do Set.

52 ArrayList A implementação mais utilizada da interface List é a ArrayList, que trabalha com um array interno para gerar uma lista. Portanto, ela é mais rápida na pesquisa do que sua concorrente, a LinkedList, que é mais rápida na inserção e remoção de itens nas pontas. IMPORTANTE: ArrayList não é um Array! É comum confundirem uma ArrayList com um array, porém ela não é um array. O que ocorre é que, internamente, ela usa um array dinâmico como estrutura para armazenar os dados, fazendo com que o espaço disponível seja aumentado conforme a demanda. Porém este atributo está propriamente encapsulado e você não tem como acessá-lo. Repare, também, que você não pode usar colchetes ([ ]) com uma ArrayList, nem acessar atributo length. Para criar um ArrayList, basta chamar o construtor: ArrayList lista = new ArrayList(); É sempre possível abstrair a lista a partir da interface List: List lista = new ArrayList(); Para criar uma lista de nomes (String), podemos fazer: List lista = new ArrayList(); lista.add("maria"); lista.add("pedro"); lista.add("ana"); A interface List possui dois métodos add, um que recebe o objeto a ser inserido e o coloca no final da lista, e um segundo que permite adicionar o elemento em qualquer posição da mesma. Note que, em momento algum, dizemos qual é o tamanho da lista. Podemos acrescentar quantos elementos quisermos, que a lista cresce conforme for necessário. Toda lista (na verdade, toda Collection) trabalha do modo mais genérico possível. Isto é, não há uma ArrayList específica para Strings, outra para Números, outra para Datas etc. Todos os métodos trabalham com Object. Assim, é possível criar, por exemplo, uma lista de Contas Correntes: ContaCorrente c1 = new ContaCorrente(); c1.deposita(100); ContaCorrente c2 = new ContaCorrente(); c2.deposita(200); ContaCorrente c3 = new ContaCorrente(); c3.deposita(300); List contas = new ArrayList(); contas.add(c1); contas.add(c3); contas.add(c2); Para saber quantos elementos há na lista, podemos usar o método size():

53 53 System.out.println(contas.size()); Há, ainda, um método get(int) que recebe como argumento o índice do elemento que se quer recuperar. Através dele, podemos fazer um for para iterar na lista de contas: for(int i = 0; i < contas.size(); i++) { contas.get(i); // código não muito útil... Supondo que a classe ContaCorrente tenha um método getsaldo() responsável por imprimir o saldo de uma conta. Então como fazer para imprimir o saldo dessas contas? Podemos acessar o método getsaldo() diretamente após fazer contas.get(i)? Não. Lembre-se que toda lista trabalha sempre com Object. Assim, a referência devolvida pelo get(i) é do tipo Object, sendo necessário o cast para ContaCorrente se quisermos acessar o getsaldo( ): for(int i = 0; i < contas.size(); i++) { ContaCorrente cc = (ContaCorrente) contas.get(i); System.out.println(cc.getSaldo()); // note que a ordem dos elementos não é alterada Há ainda outros métodos como remove() que recebe um objeto que se deseja remover da lista; e contains(), que recebe um objeto como argumento e devolve true ou false, indicando se o elemento está ou não na lista Vector Vector é basicamente um ArrayList, no entanto seus métodos são sincronizados o que significa que o acesso por vários processos simultaneamente é coordenado. A classe Vector deve ser tratada com cuidado pois lida de uma maneira diferente com processos correndo em paralelo e será mais lenta que uma ArrayList quando não houver acesso simultâneo aos dados LinkedList Muito similar as duas coleções vistas anteriormente (Vector e ArrayList), a diferença é que todos os elementos são ligados entre si. O desempenho do LinkedList é muito superior aos do ArrayList e Vector quando necessitamos inserir elementos no início da coleção, no entanto se precisarmos obter algum elemento pelo o índice o desempenho é muito inferior Listas no Java 5.0 com Generics Até agora as nossas coleções aceitavam qualquer tipo de elemento, desde que fosse um Object. No exemplo abaixo temos um ArrayList onde adicionamos um String e um Integer: //Criando ArrayList List arraylist = new ArrayList(); //Adicionando um String

54 54 arraylist.add(new String("Texto")); //Adicionando um Integer arraylist.add(new Integer(3)); Isto é possível pois nossas coleções aceitam qualquer elemento que seja do tipo Object, e todas as classes criadas em Java automaticamente herdam, e portanto são, da classe Object. No entanto, com o uso de Generics podemos definir de que tipo específico será a nossa coleção. Abaixo temos um exemplo de ArrayList, parecido com o anterior, utilizando Generics: //Criando ArrayList de Integer List<Integer> arraylist = new ArrayList<Integer>(); //Adicionando Integer arraylist.add(new Integer(3)); arraylist.add(new Integer(5)); Perceba que a partir de agora este List aceita apenas objetos do tipo Integer utilizando esta notação, declaração <Integer> junto a declaração da Classe/Interface, evitando que sejam inseridos indevidamente outros tipos que não sejam Integer na coleção. Outro Exemplo: List lista = new ArrayList(); lista.add("uma string"); lista.add(new ContaCorrente());... Mas e depois, na hora de recuperar esses objetos? Como o método get devolve um Object, precisamos fazer o cast. Mas com uma lista com vários objetos de tipos diferentes, isso pode não ser tão simples... Geralmente, não nos interessa uma lista com vários tipos de objetos misturados; no dia-a-dia, usamos listas como aquela de contas correntes. No Java 5.0, podemos usar o recurso de Generics para restringir as listas a um determinado tipo de objetos (e não qualquer Object): List<ContaCorrente> contas = new ArrayList<ContaCorrente>(); contas.add(c1); contas.add(c3); contas.add(c2); Repare no uso de um parâmetro ao lado de List e ArrayList: ele indica que nossa lista foi criada para trabalhar exclusivamente com objetos do tipo ContaCorrente. Isso nos traz uma segurança em tempo de compilação: contas.add("uma string"); // isso não compila mais!! O uso de Generics também elimina a necessidade de casting, já que, seguramente, todos os objetos inseridos na lista serão do tipo ContaCorrente: for(int i = 0; i < contas.size(); i++) { ContaCorrente cc = contas.get(i); // sem casting! System.out.println(cc.getSaldo()); Ordenação em Listas: Collections.sort

55 55 Vimos anteriormente que as listas são percorridas de maneira pré-determinada de acordo com a inclusão dos itens. Mas, muitas vezes, queremos percorrer a nossa lista de maneira ordenada. A classe Collections traz um método estático sort que recebe um List como argumento e o ordena por ordem crescente. Por exemplo: List lista = new ArrayList(); lista.add("maria"); lista.add("joao"); lista.add("pedro"); System.out.println(lista); //repare que o tostring de ArrayList foi sobrescrito! Collections.sort(lista); System.out.println(lista); Resultado obtido: [Maria, Joao, Pedro] [Joao, Maria, Pedro] Ao testar o exemplo acima, você observará que, primeiro, a lista é impressa na ordem de inserção e, depois de chamar o sort, ela é impressa em ordem alfabética. Mas toda lista em Java pode ser de qualquer tipo de objeto, por exemplo, ContaCorrente. E se quisermos ordenar uma lista de ContaCorrente? Em que ordem a classe Collections ordenará? Pelo saldo? Pelo nome do correntista? Ex:... ContaCorrente c1 = new ContaCorrente(); c1.deposita(500); ContaCorrente c2 = new ContaCorrente(); c2.deposita(200); ContaCorrente c3 = new ContaCorrente(); c3.deposita(150); List<ContaCorrente> contas = new ArrayList<ContaCorrente>(); contas.add(c1); contas.add(c3); contas.add(c2); Collections.sort(contas); Qual foi o critério de ordenação adotado no código acima? Sempre que falamos em ordenação, precisamos pensar em um critério de ordenação, uma forma de determinar qual elemento vem antes de qual. É necessário instruir o Java sobre como comparar nossas ContaCorrente a fim de determinar uma ordem na lista. Vamos fazer com que os elementos da nossa coleção implementem a interface java.lang.comparable, que define o método int compareto(object). Ex: int x = esteobjeto.compareto(outroobjeto) O método compareto(object) retorna um tipo int com as seguintes características: Negativo : Se este objeto for menor que o objeto dado. (esteobjeto < outroobjeto) Zero: Se este objeto for igual ao objeto dado. (esteobjeto == outroobjeto)

56 56 Positivo: Se este objeto for maior que o objeto dado. (esteobjeto > outroobjeto) Para ordenar as ContaCorrentes por saldo, basta implementar o Comparable: public class ContaCorrente extends Conta implements Comparable<ContaCorrente> { //... todo o codigo anterior fica aqui public int compareto(contacorrente outra) { if(this.saldo < outra.saldo) { return -1; if(this.saldo > outra.saldo) { return 1; return 0; Com o código acima, nossa classe tornou-se comparável": dados dois objetos da classe, conseguimos dizer se um objeto é maior, menor ou igual ao outro, segundo algum critério por nós definido. No nosso caso, a comparação será feita baseando-se no saldo da conta. Repare que o critério de ordenação é totalmente aberto, definido pelo programador. Se quisermos ordenar por outro atributo (ou até por uma combinação de atributos), basta modificar a implementação do método compareto na classe. Agora sim, quando chamarmos o método sort de Collections, ele saberá como fazer a ordenação da lista. Ele usará o critério que definimos no método compareto. Mas, e o exemplo anterior, com uma lista de Strings? Por que a ordenação funcionou, naquele caso, sem precisarmos fazer nada? Simples: quem escreveu a classe String (lembre que ela é uma classe normal do Java) implementou a interface Comparable e o método compareto para Strings, fazendo comparação em ordem alfabética. (Consulte a documentação da classe String e veja o método compareto). O método Collections.shuffle: Este método é oposto ao método de ordenação citado acima e ao invés de ordenar ele desordena (mistura) os elementos dentro de um List. A primeira vista pode parecer inútil, mas existem situações onde você irá querer desordenar sua estrutura de dados para obter um elemento aleatoriamente. Por exemplo, abaixo temos uma possível implementação para a modalidade de sorteio cujos nomes dos elementos a serem sorteados, normalmente pessoas, são escritos em pequenos pedaços de papéis e o primeiro a ser escolhido é o vencedor. //Criação do ArrayList List arraylist = new ArrayList(); //Adicionando elementos arraylist.add("maria"); arraylist.add("pedro"); arraylist.add("ana"); arraylist.add("joao"); //Misturando elementos Collections.shuffle(arrayList); //Sorteando o primeiro nome e imprimindo o resultado

57 57 System.out.println(arrayList.get(0)); Resultado obtido em uma execução: Joao Perceba que o elemento na posição 0 (zero), pela ordem de inserção seria Maria e, no entanto, obtivemos o elemento Joao, o que confirma, a mudança de posição destes elementos dentro do List Pesquisa em Listas: Collections.binarySearch Quando falamos em estruturas de dados devemos pensar em algoritmos de ordenação e pesquisa, pois, de que adianta uma estrutura de dados cujos elementos não conseguimos localizar? Ao manipularmos estruturas de dados sempre devemos ter em mente que iremos ordená-las ou pesquisá-las. A pesquisa efetuada pelo método binarysearch da Classe Collections retorna um número inteiro positivo ou zero se o elemento for encontrado e negativo se o elemento não existe na coleção. Quando o elemento existe na coleção o número representa o seu índice (posição), por outro lado, quando o elemento não existe, o número, em módulo, representa a posição que ele deveria estar (ponto de inserção), neste caso, esta posição somente é válida se a coleção estiver ordenada antes da pesquisa. A seguir temos um exemplo: //Criação do ArrayList List arraylist = new ArrayList(); //Adicionando elementos arraylist.add("maria"); arraylist.add("pedro"); arraylist.add("ana"); arraylist.add("joao"); //Pesquisando int resultado = Collections.binarySearch(arrayList, "Pedro"); //Imprimindo resultado System.out.println("Resultado da pesquisa: "+resultado); Resultado da execução: Resultado da pesquisa: 1 O resultado obtido, conforme esperado, indica que o nome Pedro encontra-se na segunda posição da coleção, lembrando que todas as coleções iniciam-se pelo índice 0 (zero), logo, o valor 1 indica a segunda posição. Outras funcionalidades úteis: Reverse Inverte a ordem dos elementos; Fill Preenche a coleção com o elemento especificado; Swap troca os elementos de posição; addall Adiciona os elementos a coleção; frequency Conta a quantidade de ocorrências do elemento especificado; disjoint Verifica quando duas coleções não possuem nenhum elemento em comum.

58 Conjunto: java.util.set Um conjunto (Set) funciona de forma análoga aos conjuntos da matemática, ele é uma coleção que não permite elementos duplicados. Um exemplo deste conceito está na figura abaixo: Figura 3.4: Representação gráfica de um Conjunto (Set) Fonte: FJ11: Java e Orientação a Objetos ( Um conjunto é representado pela interface Set e tem como suas principais implementações as classes HashSet e TreeSet, Como mostra a figura abaixo: Figura 3.5: Representação gráfica da Interface Set no Java Fonte: FJ11: Java e Orientação a Objetos ( Outra característica fundamental dele é o fato de que a ordem em que os elementos são armazenados pode não ser a ordem na qual eles foram inseridos no conjunto. Tal ordem varia de implementação para implementação. Alguns dos métodos mais utilizados quando manipulamos Sets, estes métodos são comuns a qualquer implementação desta interface: Método boolean add(objeto) Descrição Adiciona um elemento ao nosso Set, retorna true se

59 59 o elemento foi inserido boolean remove(objeto) Remove o elemento da nossa coleção, retorna true se o elemento foi removido int size() Retorna um int (inteiro) com a quantidade de elementos da coleção Boolean contains (Objeto) Retorna true se o elemento já existe dentro do Set Iterator iterator() Retorna um objeto que possibilita percorrer os elementos daquela coleção. clear() Elimina todos os elementos do Set HashSet Uma das implementações concretas da interface Set. O HashSet caracteriza-se por não aceitar duplicatas, característica derivada do Set, ser uma coleção desordenada e desorganizada, isto é, não há nenhuma garantia quanto a ordem que os elementos serão percorridos. O código a seguir cria um conjunto e adiciona três itens, apesar de tentar adicionar quatro: Set conjunto = new HashSet(); conjunto.add("item 1"); conjunto.add("item 2"); conjunto.add("item 3"); conjunto.add("item 3"); // imprime a sequência na tela System.out.println(conjunto); Resultado da execução: [item 3, item 2, item 1] O resultado são os elementos do conjunto, a ordem na qual eles aparecem pode, ou não, ser a ordem na qual eles foram inseridos e é incorreto supor que será sempre a mesma ordem. Assim como as listas, conjuntos também podem ser parametrizados utilizando Generics, eliminando a necessidade de castings LinkedHashSet É uma versão organizada do HashSet. Lembrando que organizada significa que existe algum tipo de seqüência não-aleatória durante a iteração dos elementos: neste caso a ordem de inserção é respeitada. Por ser um Set, o LinkedHashSet não aceita duplicatas e, da mesma forma que o HashSet, é dependente da correta implementação do método equals(). Devemos utilizar o LinkedHashSet ao invés do HashSet quando a ordem de iteração dos elementos é importante TreeSet

60 60 É um Set ordenado e como tal não aceita duplicatas, ou seja, existe alguma regra que garante a ordenação. No Treeset os elementos inseridos serão percorridos de acordo com sua ordem natural e de forma ascendente Iteração de elementos de coleções Vamos a seguir, apresentar duas formas de iteração de elementos de coleções: utilizando um Iterator e utilizando o for-each ou enhanced-for. Iterator: Toda coleção fornece acesso a um iterator, um objeto que implementa a interface Iterator, que conhece internamente a coleção e dá acesso a todos os seus elementos, como mostra a figura abaixo: Figura 3.6: Representação gráfica de um iterator Fonte: FJ11: Java e Orientação a Objetos ( A implementação ocorre da seguinte forma: Primeiro criamos um Iterator que entra na coleção. A cada chamada do método next, o Iterator retorna o próximo objeto do conjunto. Um iterator pode ser obtido com o método iterator() de Collection, por exemplo: Iterator i = lista.iterator(); Figura 3.7: Representação gráfica da Interface iterator no Java Fonte: FJ11: Java e Orientação a Objetos (

61 61 A interface Iterator possui dois métodos principais: hasnext() (com retorno booleano), indica se ainda existe um elemento a ser percorrido; next(), retorna o próximo objeto. Ex:... //usando a sintaxe do java 1.4 // popula o conjunto Set conjunto = new HashSet(); conjunto.add("item 1"); conjunto.add("item 2"); conjunto.add("item 3"); // retorna o iterator Iterator i = conjunto.iterator(); while (i.hasnext()) { // recebe a palavra Object elemento = i.next(); String palavra = (String) elemento; // mostra a palavra System.out.println(palavra); O while acima só termina quando todos os elementos do conjunto forem percorridos, isto é, quando o método hasnext mencionar que não existem mais itens. IMPORTANTE: Usar o iterator no Java 5 O Iterator pode sim ainda ser útil no Java 5. Além de iterar na coleção como faz o enhancedfor, o iterator consegue remover elementos da coleção durante a iteração, o que é bastante útil. Além disso, no Java 5, o Iterator foi parametrizado e usa generics, facilitando castings e evitando erros. for-each: É um for adaptado a coleções e que percorre todos os elementos qualquer de coleção do Framework Collection. A seguir temos um exemplo: Set carroshashset = new HashSet(); for(carros carro : carroshashset) { carro.setplaca(...);... A estrutura deste for-each poderia ser lida da seguinte forma : Para cada elemento do tipo Carro existente na minha coleção de Carros (carroshashset) faça isto. Outro exemplo: 1 Set conjunto = new HashSet(); 2 conjunto.add("item 1"); 3 conjunto.add("item 2"); 4 conjunto.add("item 3"); 5 6 // retorna o iterator 7 for (Object elemento : conjunto) { 8 String palavra = (String) elemento;

62 62 9 System.out.println(palavra); 10 Em que ordem os elementos serão acessados? Numa lista, os elementos aparecerão de acordo com o índice em que foram inseridos, isto é, de acordo com o que foi pré-determinado. Em um conjunto, a ordem depende da implementação da interface Set. Por que o Set é, então, tão importante e usado? Para perceber se um item já existe em uma lista, é muito mais rápido usar um Set do que um List, e os TreeSets já vêm ordenados de acordo com as características que desejarmos. Exercício resolvido: Implemente um método que manipule as três modalidades de Set (HashSet, LinkedHashSet e TreeSet), e insira o mesmo conjunto de inteiros em cada uma delas. Percorra todos os elementos de cada uma delas e compare a ordem encontrada. import java.util.hashset; import java.util.iterator; import java.util.linkedhashset; import java.util.set; import java.util.treeset; public class IntegerLinkedHashSet { public static void main(string[] args) { Set hashset = new HashSet();//Criacao do HashSet hashset.add(100);//adicionando valores aleatoriamente hashset.add(0); hashset.add(23); hashset.add(465); hashset.add(45); hashset.add(21); hashset.add(10); hashset.add(3); hashset.add(12); hashset.add(5); hashset.add(147); hashset.add(29); hashset.add(7); hashset.add(3); hashset.add(12); hashset.add(54); //Criacao do LinkedHashSet a partir do hashset Set linkedhashset = new LinkedHashSet(hashSet); //Criacao do TreeSet a partir do hashset Set treeset = new TreeSet(hashSet Iterator ithashset = hashset.iterator()); //obtendo Iterator para HashSet //obtendo Iterator para LinkedHashSet //obtendo Iterator para TreeSet Iterator ithashset = linkedhashset.iterator(); Iterator itlinkedhashset = linkedhashset.iterator(); Iterator ittreeset = treeset.iterator(); //Enquanto existir proximo elemento nos Iterators while(ithashset.hasnext() && itlinkedhashset.hasnext() && ittreeset.hasnext()) { //Imprime (system.out.println) o proximo elemento de cada Iterator System.out.println("HashSet: "+ithashset.next()+ " LinkedHashSet: "+itlinkedhashset.next()+

63 63 " TreeSet: "+ittreeset.next()); Resultado da execução: HashSet: 0 LinkedHashSet: 0 TreeSet: 0 HashSet: 100 LinkedHashSet: 100 TreeSet: 3 HashSet: 3 LinkedHashSet: 3 TreeSet: 5 HashSet: 5 LinkedHashSet: 5 TreeSet: 7 HashSet: 7 LinkedHashSet: 7 TreeSet: 10 HashSet: 10 LinkedHashSet: 10 TreeSet: 12 HashSet: 12 LinkedHashSet: 12 TreeSet: 21 HashSet: 465 LinkedHashSet: 465 TreeSet: 23 HashSet: 45 LinkedHashSet: 45 TreeSet: 29 HashSet: 21 LinkedHashSet: 21 TreeSet: 45 HashSet: 54 LinkedHashSet: 54 TreeSet: 54 HashSet: 23 LinkedHashSet: 23 TreeSet: 100 HashSet: 147 LinkedHashSet: 147 TreeSet: 147 HashSet: 29 LinkedHashSet: 29 TreeSet: 465 Antes de avaliarmos a ordem dos resultados, observe que durante a fase de inclusão dos números no HashSet alguns deles se repetem, especificamente o 3 e o 12 (linhas em destaque), porém no resultado estes números aparecem apenas uma vez cada um, isto acontece pois, conforme dito anteriormente, qualquer coleção do tipo Set não permite duplicatas, na verdade, na segunda tentativa de inclusão dos números 3 e 12, eles não foram incluídos. Em relação a ordem o HashSet, desta vez, manteve a ordem de inserção e obtivemos um resultado igual ao visto no LinkedHashSet, no entanto não temos garantia nenhuma de que este comportamento irá se repetir. Já o TreeSet não respeitou a ordem de inserção mas, ordenou de acordo com a ordem natural de cada um dos valores. Para números a ordem natural é fácil de compreender afinal de contas, 1 é menor do que 2 que é menor do que 3 que é menor... no entanto, nem sempre trabalhamos com números, muitas vezes criamos nossos próprios tipos (Classes). Nestes casos devemos informar que a nossa Classe (tipo) pode ser comparada. Isto é feito utilizando-se a interface Comparable. 3.4 Mapas - java.util.map Um map é composto de uma associação de um objeto chave a um objeto valor. É equivalente ao conceito de dicionário, usado em várias linguagens. Um map ou qualquer implementação desta interface, identifica seus elementos através de uma chave, logo, esta coleção aceita duplicatas de valores (elementos) desde que eles possuam chaves diferentes. A principal característica dos Maps são que suas chaves nunca podem se repetir, ou seja, em um map nunca irão haver dois elementos com a mesma chave. Assim como os elementos armazenados as chaves utilizadas nos Maps também devem ser objetos. Exemplo: Mapeie o valor Maria à chave nome, ou mapeie o valor à chave RG. A figura abaixo mostra a representação gráfica de um map:

64 64 Figura 3.8: Representação gráfica de um Mapa Fonte: FJ11: Java e Orientação a Objetos ( Os principais métodos utilizados quanto manipulamos Maps são: Método Descrição put( chave, objeto ) Adiciona a chave e o elemento get( chave ) Retorna o elemento de acordo com a chave iterator() Retorna um objeto do tipo Iterator size() Retorna um int (inteiro) com a quantidade de elementos da coleção containskey( chave ) Retorna true se a chave já existe containsvalue( objeto ) Retorna true se o objeto já existir no Map clear() Elimina todos os elementos do Set HashMap e Hashtable HashMap é um Map desorganizado, isto é, a ordem de iteração dos elementos é desconhecida, e desordenado, ou seja, os elementos não sofrem nenhum tipo de ordenação derivada de alguma regra. Hashtable, similarmente ao ArrayList e Vector, é a versão sincronizada do HashMap. A maior diferença é que o HashMap aceita nulos tanto para chaves quanto para valores enquanto o Hashtable não aceita nenhum nulo. A seguir segue trecho de código que exemplifica o uso do HashMap:... ContaCorrente c1 = new ContaCorrente(); c1.deposita(10000); ContaCorrente c2 = new ContaCorrente(); c2.deposita(3000); // cria o mapa Map mapadecontas = new HashMap(); // adiciona duas chaves e seus valores mapadecontas.put("diretor", c1); mapadecontas.put("gerente", c2); // qual a conta do diretor? Object elemento = mapadecontas.get("diretor"); ContaCorrente contadodiretor = (ContaCorrente) elemento; Um mapa, assim como as coleções, trabalha diretamente com Objects (tanto na chave quanto no valor), o que torna necessário o casting no momento que recuperar elementos.

65 LikedHashMap Muito similar ao LinkedHashSet, porém esta é a versão que implementa a interface Map, logo ao armazenar os objetos é necessária uma chave. E, ao contrário do HashMap, o LinkedHashMap é organizado, o que significa dizer que durante a iteração dos elementos ele respeita a ordem que estes foram inseridos na coleção. Se a ordem de inserção for importante e precisarmos identificar os elementos pelas suas chaves devemos utilizar esta implementação da interface Map. Abaixo temos o mesmo código exibido anteriormente porém a implementação utilizada agora é a LinkedHashMap:... ContaCorrente c1 = new ContaCorrente(); c1.deposita(10000); ContaCorrente c2 = new ContaCorrente(); c2.deposita(3000); // cria o LinkedHashmap Map mapadecontas = new LinkedHashMap(); // adiciona duas chaves e seus valores mapadecontas.put("diretor", c1); mapadecontas.put("gerente", c2); // qual a conta do diretor? Object elemento = mapadecontas.get("diretor"); ContaCorrente contadodiretor = (ContaCorrente) elemento; TreeMap Assim como o TreeSet é um Set que ordena os elementos de acordo com alguma regra, o TreeMap também ordena seus elementos através da chave por alguma regra. Quando esta ordem não é definida pela interface Comparable ou por um objeto Comparator o TreeMap busca a ordem natural dos elementos. A seguir é apresentado um trecho de código mostrando o uso do TreeMap: //Criacao do TreeMap utilizando Generics Map<Integer, String> treemap = new TreeMap<Integer, String>(); //Inserindo os valores treemap.put(5, "Numero 5"); treemap.put(1, "Numero 1"); treemap.put(22, "Numero 22"); //For-Each, percorrendo todos os elementos do Map for(string str : treemap.values()) { //Imprimindo os valores encontrados System.out.println(str); Resultado da execução deste código: Numero 1 Numero 5 Numero 22 Numero 100 Observe que a declaração Map<Integer, String> utiliza generics. Ao declarar um Map desta forma estou garantindo que todas as chaves serão do tipo Integer e todos os valores serão do tipo String.

66 Equals e HasCode Quando nós estamos trabalhando com objetos os operadores de igualdade, == e!=, podem ter efeitos desastrosos se não forem corretamente aplicados. Quando estes operadores são utilizados, na verdade, o que está sendo comparado é a referência do objeto, isto é, esta operação irá retornar verdadeiro (true) apenas se as duas referências são do mesmo objeto. Um exemplo desta situação é o seguinte: System.out.println(new String("Pedro") == new String("Pedro"));//Imprime false No exemplo anterior, caso o código seja executado, obteremos como saída: false. Isto acontece, pois conforme explicado anteriormente, estamos comparando as referências e não o conteúdo das Strings (que são idênticos). Ou seja cada uma das partes da operação refere-se a um objeto diferente porém, do mesmo tipo String e com o mesmo valor Pedro. Para resolver este problema basta substituir o código acima por: System.out.println(new String("Pedro").equals(new String("Pedro")));//Imprime true Neste exemplo o resultado obtido será true, isto acontece pois agora o que está sendo comparado é o conteúdo de cada objeto String, ou seja o valor Pedro. O importante é que você compreenda que ao utilizar os operadores de igualdade, sobre objetos, (== ou!=) o que você está verificando é se as duas referências fazem alusão ao mesmo objeto. Ao utilizar o método equals() nós estamos verificando se os dois objetos são significativamente iguais (equivalentes). A maioria das coisas (objetos) que importam, no contexto da computação, possuem algum identificador único ou alguma forma de identificação única. Ex: Carro placa/renavam, Pessoa CPF, Empresa CNPJ, Fatura código, Nota fiscal número/série, Município Código do IBGE, Produto código de barras e etc. Sendo assim ao sobreescrevermos o método equals() devemos observar estes identificadores e implementar o método a fim de realizar os testes de igualdade sobre este(s) atributo(s). Exercício resolvido Crie uma classe que represente notas fiscais com código, valor e data, e sobreescreva o método equals de forma que duas notas fiscais sejam consideradas iguais apenas se seus códigos forem idênticos. Uma vez compreendida a importância do método equals() iniciamos os estudos para descobrir a função do método hashcode(). Códigos de Hash ou Hashcodes são utilizados para aumentar a performance quando manipulamos grandes quantidades de objetos. Hashcodes são utilizados para identificar objetos de forma que o acesso a estes se torne mais eficiente. Estes códigos são gerados por uma função de espalhamento, o resultado desta função é obtido de acordo com o valor (dado) de entrada. É importante compreender que entradas diferentes podem produzir tanto hashcodes iguais quanto diferentes, já entradas iguais produzirão sempre o mesmo hashcode, desta forma o método hashcode() deve respeitar o método equals(), ou seja, sempre que dois objetos forem iguais, de acordo com o método equals(), obrigatoriamente o resultado obtido pelo método hashcode() deve ser igual para estes objetos.

67 67 Caso o método hashcode() não respeite a implementação do método equals() poderemos ter problemas de desempenho e consistência nas nossas coleções. O ideal é que a função de espalhamento nunca produza o mesmo código hash para entradas diferentes porém isto nem sempre é possível, nestes casos devemos nos preocupar em criar funções que façam uma boa dispersão de códigos Boas Práticas As coleções do Java oferecem grande flexibilidade ao usuário. A perda de performance em relação à utilização de arrays é irrelevante, mas deve-se tomar algumas precauções: Grande parte das coleções usam, internamente, um array para armazenar os seus dados. Quando esse array não é mais suficiente, é criada um maior e o conteúdo da antiga é copiado. Este processo pode acontecer muitas vezes, no caso de você ter uma coleção que cresce muito. Você deve, então, criar uma coleção já com uma capacidade grande, para evitar o excesso de redimensionamento. Evite usar coleções que guardam os elementos pela sua ordem de comparação quando não há necessidade. Um TreeSet gasta computacionalmente O(log(n)) para inserir (ele utiliza uma árvore rubro-negra como implementação), enquanto o HashSet gasta apenas O(1). Não itere sobre uma List utilizando um for de 0 até list.size( ) e usando get(int) para receber os objetos. Enquanto isso parece atraente, algumas implementações da List não são de acesso aleatório como a LinkedList, fazendo esse código ter uma péssima performance computacional. (use Iterator)

68 68 RESUMO DA AULA 3 Nesta aula exploramos os princípios básicos de coleções (interface Collections). As atividades comuns das coleções incluem a inserção e a remoção de objetos, a verificação de objetos incluídos, a recuperação dos mesmos e a iteração. As quatro versões básicas das coleções são: Listas (java.util.list), Conjuntos (Java.util.Set), Mapas (Java.util.Map) e Filas (Java.util.Queue). Uma lista é uma coleção que permite elementos duplicados e mantém uma ordenação específica entre os elementos. Qualquer implementação da interface List mantém seus elementos indexados, ou seja, existe uma preocupação com o posicionamento de cada elemento e esta posição é determinada pelo índice. Devemos utilizar um List quando a ordem de inserção ou a posição na coleção nos interessa. A implementação mais utilizada da interface List é a ArrayList. O uso de Generics restringe as Coleções de um modo geral a um determinado tipo de objetos e elimina a necessidade de casting. O método Collections.sort é utilizado para a ordenação em listas. O método Collections.binarySearch é utilizado para realizar buscas em listas. Um conjunto é representado pela interface Set e tem como suas principais implementações as classes HashSet e TreeSet. A ordem em que os elementos são armazenados pode não ser a ordem na qual eles foram inseridos no conjunto. Tal ordem varia de implementação para implementação. A diferença básica entre o HashSet e o TreeSet é que no HashSet não há nenhuma garantia quanto a ordem que os elementos serão percorridos e no TreeSet existe alguma regra que garante a ordenação. Existem duas formas de iteração de elementos de coleções: utilizando um Iterator ou utilizando o for-each ou enhanced-for. Para perceber se um item já existe em uma lista, é muito mais rápido usar um Set do que um List. Um map é composto de uma associação de um objeto chave a um objeto valor. A principal característica dos Maps são que suas chaves nunca podem se repetir, ou seja, em um map nunca irão haver dois elementos com a mesma chave. Tem como suas principais implementações as classes HashMap e TreeMap. A diferença entre elas é similar à implementação das classes Hashset e TreeSet.

69 69 ATIVIDADES DA AULA 3 1. Implemente código em Java que possua um ArrayList e insira 12 Strings nesta lista. 2. Crie um código em Java que insira 30 mil números numa ArrayList e pesquise-os. Utilize o método: System.currentTimeMillis() para cronometrar o tempo gasto. (OBS: o método System.currentTimeMillis() retorna um tipo long). 3. Faça um HashSet e insira as Strings String 1, String 2 e String 3 cada uma duas vezes, percorra todos os elementos e imprima (System.out.println()). Observe o resultado. Quantos elementos têm a coleção? 4. Faça um HashMap e insira as Strings String 1, String 2 e String 3 cada uma duas vezes, utilize o numeral como chave, percorra todos os elementos e imprima (System.out.println()). Observe o resultado. Quantos elementos têm a coleção? 5. Adicione os números 100, 20, 200, 30, 80, 40, 100, 200 a um List, percorra todos os elementos utilizando um Iterator e calcule a média. 6. Adicione os números 100, 20, 200, 30, 80, 40, 100, 200 a um Set, percorra todos os elementos utilizando for-enhanced (for-each) e calcule a média. 7. Porque as médias encontradas nos exercícios 5 e 6 ficaram diferentes? 8. Utilizando a classe Collections ordene a coleção criada no exercício 1. Imprima (System.out.println()) o resultado.

70 Interface Gráfica em JAVA Aula 70 4 Objetivos Ao final desta aula, você deverá ser capaz de: Entender como se utilizam os componentes do pacore Swing; Criar aplicações simples e complexas usando a interface gráfica Usar eventos de manipulação de objetos gráficos

71 71 4. Interface Gráfica em JAVA Introdução Sempre ouvimos falar que aparência é tudo, não é? E em linguagens de programação acontece o mesmo. Quando desenvolvemos aplicativos que outras pessoas irão usar, precisaremos de uma interface gráfica. Também, se desenvolvermos para nós mesmo, claro que queremos uma interface gráfica. Ela facilita muito a utilização dos aplicativos. Os aplicativos de linhas de comando são fracos, inflexíveis e nem um pouco amigáveis. Neste capítulo trabalharemos com GUIs(Graphic Users Interface) e aprenderemos mais recursos-chave da Linguagem JAVA, entre eles a Manipulação de Eventos e as Classes Internas. 4.1 Criando Aplicações Gráficas em JAVA: Tudo irá começar com a criação de uma janela. Um JFrame é um o objeto que representa uma janela na tela e é onde iremos inserir todos os elementos da interface como os botões, caixas de seleção, campos de textos e assim por diante. O JFrame terá uma aparência diferente, dependendo da plataforma em que você trabalha. Esse é um objeto JFrame no Windows 7: Quando temos um JFrame, poderemos inserir elementos gráficos nele adicionando-os ao objeto. Existem vários componentes do Swing que podemos adicionar; procure-os no pacote javax.swing. Entre os mais comuns estão JButton, JRadioButton, JCheckBox, JLabel, JList, JScrollPane, JSlider, JTextArea, JTextField e JTable. A maioria é muito simples de usar, mas outros (como o JTable) podem ser um pouco mais complicados. Agora vamos criar a nossa primeira GUI. Veja como é fácil:

72 72 Linha 1: importaremos o pacote swing. Linhas 6 e 7: criam respectivamente uma moldura e um botão, passamos para o construtor o texto que desejamos. Linha 8: fará com que o programa seja encerrado assim que você fechar a janela ( se ela não for incluída, o programa ficará eternamente na janela). Linha 9: Adiciona o botão ao painel de conteúdo da moldura. Linha 10: fornece um tamanho para a moldura, em pixels. Linha 11: para concluir, torna-a visível. Se esquecermos dessa etapa não veremos nada quando executarmos esse código. Agora veremos o que acontece quando executamos o código acima: Podemos notar que o botão preencheu todo o espaço da moldura. Mais a frente iremos aprender a controlar onde (e com que tamanho) o botão ficará na moldura. Também vimos que nada aconteceu quando cliquei nele, eis então uma dúvida: Como fazer o botão executar algo específico quando o usuário clicar nele?. Vamos precisar de duas coisas: 1- Um método a ser chamado quando o usuário clicar (o que você quiser que ocorra como resultado do clique no botão). 2- Uma maneira de saber quando acionar esse método. Em outras palavras, uma maneira de saber que o usuário clicou no botão.

73 Capturando um evento do usuário: Se nós quiséssemos que o texto do botão fosse alterado de me aperte para Eu fui apertado quando o usuário pressionar o botão primeiro podemos criar um método que altere o texto do botão (com uma pequena pesquisa na API nós encontramos o método): public void changeit(){ button.settext( Eu fui apertado ); Como saberemos quando esse método deve ser executado? Quando saberemos quando o botão foi clicado? Em Java, esse processo de capturar e manipular eventos de usuários se chama manipulação de evento. Existem muitos tipos diferentes de eventos em Java, embora a maioria envolva ações de usuários em GUI. Se o usuário clicar em um botão, isso será um evento. Um evento que representa O usuário quer que a ação desse botão ocorra. Em Java a origem de um evento é um objeto que pode converter ações do usuário (um clique com o mouse, o pressionamento de uma tecla, o fechamento de uma janela) em eventos. Se você pesquisar o pacote java.awt.event da API, verá várias classes de eventos (fáceis de identificar todas têm Event no nome). Você encontrará MouseEvent, KeyEvent, WindowEvent, ActionEvent e muitas outras. A origem de um evento (como o botão) cria um objeto de evento quando o usuário faz algo de relevante (como clicar no botão). A maioria do código que você escrever receberá eventos em vez de criá-los. Em outras palavras, você passara a maior parte de tempo como ouvinte de eventos em ver de ser a origem deles. Cada tipo de evento tem uma interface de escuta correspondente. Se você quiser MouseEvents, implemente a interface MouseListener. Lembre-se das regras de interface: para implementar uma interface, você tem que declarar que a implementa, o que significa que terá que criar métodos de implementação para cada método da interface. Algumas interfaces têm mais de um método, porque o próprio evento tem diferentes versões. Se você implementar MouseListener, por exemplo, poderá capturar eventos de mousepressed, mousereleased, mousemoved, etc. Cada um desses eventos de mouse tem um método separado na interface, ainda que todos sejam um MouseEvent. Se você implementar MouseListener, o método mousepressed() será chamado quando o usuário pressionar o botão do mouse. E quando o usuário o soltar o método mousereleased() será chamado. Capturando o ActionEvent de um Botão: 1 Implemente a Interface ActionListener 2 Registre-se no botão (informe a ele que você quer escutar os eventos) 3 Defina o método de manipulação de eventos ( implemente o método actionperformed() da interface ActionListener)

74 Linha 02: Uma nova instrução de importação para o pacote no qual ActionListener e ActionEvent estão. Linha 04: Implementa a interface. Isso quer dizer que uma instancia da SimpleGui1B é um ActionListener. O botão fornecerá eventos somente para quem implementar ActionListener. Linha 14: Registre seu interesse junto ao botão. Isto dirá ao botão Me adicione à sua lista de ouvintes. O argumento que você deve passar deve ser um objeto de uma classe que implemente ActionListener. Linha 20,21: implementa o método actionperformed() da interface ActionListener. Esse é realmente o método de manipulação de eventos; O botão chamará esse métodp para permitir que você saiba que um evento ocorreu. Ele lhe enviará um objeto ActionEvent como argumento, mas não precisaremos dele. Saber que o evento ocorreu é o bastante para nós. O resultado desse código ficaria assim: 74

75 Ouvintes, origens e Eventos: A tarefa do ouvinte é capturar o evento, ou seja, ele vai implementar a interface, registrar-se no botão e fornecer a manipulação de eventos. Já a tarefa da origem do evento é aceitar registros (dos ouvintes), capturar eventos do usuário e chamar o método de manipulação de eventos do ouvinte (quando o usuário clicar nele). 4.4 Mais um pouco de parte gráfica: Agora que aprendemos um pouco mais de como os eventos funcionam (veremos um pouco mais posteriormente) voltaremos a inserção de elementos na tela. Passaremos algum tempo examinando algumas maneiras divertidas de usar um ambiente gráfico, antes de retornarmos a manipulação de eventos. Existem três maneiras de inserir elementos em sua GUI: 1 Insira elementos gráficos em uma moldura: Adicione botões, menus, botões de rádio, etc. O pacote javax.swing tem vários tipos de elementos gráficos. 2 Desenhe figuras 2D em um elemento gráfico: Use um elemento gráfico para desenhar formas. graphics.filloval(70,70,100,100); Você pode desenhar muitas outras caixas e círculos, o API Java2D está cheia de métodos gráficos divertidos e sofisticados. 3 Insira uma figura JPEG em um elemento gráfico: Você pode inserir suas próprias fotos em um elemento gráfico. graphics.drawimage(minhaimagem, 10,10,this); 4.5 Criando seu próprio elemento gráfico de desenho: Quando queremos inserir figuras na tela, a melhor opção é criar o nosso próprio elemento gráfico de desenho. Nós inseriremos esse elemento gráfico na moldura, da mesma forma que um botão ou qualquer outro elemento, mas quando ele for exibido terá nossas figuras. Todos os nossos elementos gráficos serão inseridos no método paintcomponent(). Ele é um método chamado pelo sistema que faz com que o elemento gráfico receba desenhos. Se quisermos desenhar um retangulo, o método paintcomponent() será chamado e seu circulo aparecerá.

76 76 Linha 04:Cria uma subclasse de JPanel, um elemento gráfico que adicionaremos a uma moldura como qualquer outra coisa. Exceto por ser seu próprio elemento gráfico personalizado. Linha 09: Esse é o importantíssimo método gráfico. Você nunca o chamará por sua própria conta. O sistema o chamará e dirá: Aqui está uma superfície de desenho nova em folha, de tipo Graphics, na qual você pode desenhar agora. Linhas 10 e 11: Suponhamos que g fosse uma máquina de desenho. Você esta dizendo para ela como que cor pintar e, em seguida, que forma desenhar (com as coordenadas de onde inserir e qual o tamanho). O resultado da execução desse código seria esse:

77 Exibindo uma figura JPEG em um painel: O resultado da execução desse código acima ficaria assim: 4.7 Agora vamos aprender como funciona o Gerenciador de Layout: Os Objetos do Gerenciador de Layout controlam o tamanho e o local dos elementos gráficos em uma GUI Java. Eles executarão várias tarefas por você, que nem sempre gostará dos resultados. Você pode querer dois botões do mesmo tamanho, o que eles não terão. Pode querer que o campo de texto tenha 9 centímetros, mas ele terá 12, e esteja abaixo do rótulo e não ao lado dele. Componentes do Swing: Componente é o termo mais correto para o que chamamos até agora de elemento gráfico. As coisas que você vai inserir numa GUI. As coisas que um usuário verá e com as

78 78 quais interagirá. Campos de texto, botões, listas roláveis, botões de rádio, etc. são todos componentes. Na verdade, todos estendem javax.swing.jcomponent. No Swing, praticamente todos os componentes podem conter outros componentes. Mas na maioria das vezes você adicionará componentes de interação com o usuário como botões listas em componentes de plano de fundo como molduras e painéis. Embora seja possível inserir um painel dentro de um botão, mas isso seria muito estranho. Gerenciadores de Layout: Um Gerenciador de Layout é um objeto Java associado a um componente específico, quase sempre um plano de fundo. O gerenciador de layout controla os componentes que se encontram dentro do componente ao qual ele está associado. Ou seja, se uma moldura tiver um painel, e o painel tiver um botão, o gerenciador de layout do painel controlará o tamanho e a inserção do botão, enquanto o gerenciador de layout da moldura controlará o tamanho e a inserção do painel. Para adicionar um determinado componente em um painel, por exemplo, devemos escrever algo como: meupainel.add(button); Os gerenciadores de layout vêm em várias versões, e cada componente de plano de fundo pode ter seu próprio gerenciador de layout. Os gerenciadores de layout têm suas próprias políticas a seguir quando constroem um layout. Como um gerenciador de Layout decide? Diferentes gerenciadores tem políticas distintas para a organização de componentes (como organizar em uma grade, fazer com que todos tenham o mesmo tamanho, empilhá-los verticalmente, etc.), mas os componentes que estiverem sendo dispostos terão pelo menos alguma pequena influência na questão. Geralmente, o processo de dispor um componente de plano de fundo é semelhante ao descrito a seguir: Um cenário de layout: 1 Crie um painel e adicione três botões a ele. 2 O gerenciador de layout do painel perguntará a cada botão que tamanho ele prefere ter. 3 O gerenciador de layout do painel usará suas políticas de layout para decidir se deve respeitar todas, parte ou nenhuma das preferências dos botões. 4 Adicione o painel a uma moldura. 5 O gerenciador de layout da moldura perguntará ao painel o tamanho que ele prefere ter. 6 - O gerenciador de layout da moldura usará suas políticas de layout para decidir se deve respeitar todas, parte ou nenhuma das preferências do painel. Existem três grandes gerenciadores de layout que são: limite, fluxo e caixa. Abaixo vamos explicar cada um deles: BorderLayout: divide um componente de plano de fundo em cinco regiões. Você só poderá adicionar um componente por região a um plano de fundo controlado por um gerenciador BorderLayout. Os componentes dispostos por esse gerenciador geralmente não conseguem ter seu tamanho preferido. Border Layout é o gerenciador de layout padrão para uma moldura. FlowLayout: age como um processador de palavras, porem com componentes em vez de palavras. Cada componente recebe o tamanho que deseja, e eles são dispostos da esquerda para a direita na ordem que são adicionados, com a mudança automática de linha ativada. Portanto, quando um componente não couber horizontalmente, ele passará para a linha seguinte do Layout. FlowLayout é o layout padrão para um painel.

79 79 BoxLayout: é como o FlowLayout pelo fato de cada componente ter seu próprio tamanho e pelos componentes serem inseridos na ordem em que são adicionados. Mas, diferente do FlowLayout, um gerenciador BoxLayout pode emplilhar os componentes verticalmente (ou horizontalmente, mas em geral só nos preocupamos com a disposição vertical). É como FlowLayout, mas em vez de ter a mudança do componente para a outra linha automaticamente, você poderá inserir um tipo de tecla return de componentes e forçá-los a começar em uma nova linha. BorderLayout leva em consideração cinco regiões: leste, oeste, norte, sul e centro. Veja como é fácil usá-lo: Quando executarmos o código acima o resultado será este: O BoxLayout manterá os componentes empilhados, mesmo se houver espaço para inseri-los lado a lado. O código ficaria assim:

80 80 Depois de executado esse código o resultado será esse: E se não quisermos utilizar os gerenciadores de layout? Como faremos? Abaixo tem o código mostrando como podemos fazer:

81 Quando utilizamos um Layout Nulo temos que informar em qual localização os componentes devem ficar, o que torna nosso processo de desenvolvimento de aplicações gráficas um pouco mais complexo, pois temos que nos preocupar com todos os componentes, enquanto quando utilizamos os gerenciadores de layouts não nos preocupamos com isto. O resultado do código acima seria o seguinte: 81

82 Testando os componentes do Swing Você aprendeu os aspectos básicos dos gerenciadores de Layout, portanto agora testaremos alguns dos componentes mais comuns: um campo de texto, a área de texto de rolagem, a caixa de seleção e a lista. Não mostraremos a API inteiro de cada um, apenas alguns destaques como introdução. JTextField texto. Construtores: JTextField Field = new JTextField(20); 20 significa 20 colunas e não 20 pixels. Isso define a largura preferida do campo de JTextField Field = new JTextField( Your name ); Como usá-lo: 1- Capture o texto que se encontra nele. System.out.println(Field.getText()); 2- Insira texto nele. field.settext( texto ); field.settext( ); // isso limpa o texto 3- Capture um ActionEvent quando o usuário pressionar return ou enter. field.addactionlistener(myactionlistener); 4- Selecione/Realce o texto do campo. field.selectall(); 5- Posicione o cursor no campo (para que o usuário possa começar a digitar). field.requestfocus(); JTextArea