Você está na página 1de 104

PROGRAMAO

ORIENTADA A
OBJETOS

MINISTRIO DA EDUCAO
PR-REITORIA DE ENSINO
DEPARTAMENTO DE EDUCAAO DISTNCIA
ESCOLA TCNICA ABERTA DO PIAU - ETAPI
CAMPUS TERESINA CENTRAL

PROGRAMAO
ORIENTADA A
OBJETOS

PRESIDENTE DA REPBLICA
Luiz Incio Lula da Silva
MINISTRO DA EDUCAO
Fernando Haddad
GOVERNADOR DO ESTADO
Wellington Dias
REITOR DO INSTITUTO FEDERAL DE EDUCAO, CINCIA E TECNOLOGIA
Francisco da Chagas Santana
SECRETRIO DE EDUCAO A DISTNCIA DO MEC
Carlos Eduardo Bielschowsky
COORDENADORIA GERAL DA UNIVERSIDADE ABERTA DO BRASIL
Celso Costa
SECRETRIO DE EDUCAO DO ESTADO DO PIAU
Antonio Jos Medeiros
COORDENADOR GERAL DO CENTRO DE EDUCAO ABERTA A DISTNCIA
DO INSTITUTO FEDERAL DE EDUCAO, CINCIA E TECNOLOGIA
Elanne Cristina Oliveira dos Santos
SUPERITENDNTE DE EDUCAO SUPERIOR NO ESTADO
Eliane Mendona
ORGANIZAO DO MATERIAL DIDTICO
Rogrio da Silva Batista

INTRODUO PROGRAMAO
ORIENTADA A OBJETOS
Rogrio da Silva Batista
Rafael Arajo de Moraes

APRESENTAO
Este texto destinado aos estudantes aprendizes que
participam do programa Escola Tcnica Aberta do Brasil (e-Tec
Brasil), vinculado Escola Tcnica Aberta do Piau (ETAPI) do
Instituto Federal de Educao, Cincia e Tecnologia do Piau
(IFPI), com apoio da Prefeitura Municipal dos respectivos plos:
Alegrete do Piau, Batalha, Monsenhor Gil e Valena do Piau.
O texto composto de seis (5) Aulas assim distribudas:
Na Aula 1 vamos estudar os arrays em Java. Veremos
como arrays de tipos nativos e de instncias de classes podem
ser criados e usados. Veremos tambm arrays multidimensionais,
irregulares e encapsulamento de arrays em classes para maior
flexibilidade e praticidade.
Na Aula 2 vamos estudar o tratamento de excees em
Java. Veremos quando e como capturar e tratar os principais tipos
de excees de acordo com sua hierarquia de classes. Veremos
tambm como lanar e construir sua prpria exceo.
Na Aula 3 vamos estudar as colees em Java.
Estudaremos com mais detalhes as 3 interfaces mais utilizadas
do framework Collections: List, Set e Map. Veremos as diferenas
de cada uma dessas interfaces, assim como mtodos de
ordenao e pesquisa envolvendo essas interfaces.
Na Aula 4 Vamos estudar as bibliotecas Java que nos
permitem criar aplicaes grficas, o que torna nossos programas
de mais fcil interao com o usurio final.
Na Aula 5 Vamos aprender como conectar e manipular um
Banco de Dados com uma aplicao JAVA usando JDBC e
comandos Java e Sql.

Boas Vindas!

Caro (a) Cursista,


Bem vindo (a) disciplina Programao Orientada
Objetos.
Esta a nossa Apostila, material elaborado com o
objetivo de contribuir para o desenvolvimento de seus estudos e
para a ampliao de seus conhecimentos acerca da citada
disciplina.

Quem sou?
Rogrio da Silva Batista
Sou Bacharel em Cincia da Computao pela Universidade
Federal do Piau e Especialista em Anlise de Sistemas pela
Universidade Estadual do Piau. Sou professor do IFPI desde 2003
e leciono disciplinas dos cursos de Informtica ligadas rea de
Programao, como: Algoritmos, Programao em Ambiente
Grfico e Programao Orientada Objetos dentre outras.
Atualmente estou frente da coordenao do curso de Tecnologia
em Anlise e Desenvolvimento de Sistemas e agora estou dando
minha contribuio ao projeto ETAPI junto ao curso Tcnico em
Informtica,

como

professor

Conteudista

da

disciplina

de

Programao Orientada Objetos. Espero que este material tenha


uma grande contribuio no aprendizado desta disciplina de forma
Professor
que o aluno adquira conhecimentos mais aprofundados no
paradigma Orientado Objetos e aplicando estas tcnicas na
construo de softwares mais complexos e ao mesmo tempo fceis
de manuteno atravs do reuso de cdigo .

Rafael Arajo de Moraes


Sou Tecnlogo em Informtica 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

Informtica ligadas

rea

de

Programao, como: Algoritmos, Programao em Ambiente


Grfico, Programao para WEB dentre outras. Atualmente estou
ministrando aulas no Campus do IFPI em Angical e agora estou
dando minha contribuio ao projeto ETAPI junto ao curso Tcnico
em Informtica, como professor Conteudista da disciplina de
Programao Orientada Objetos.

ndice Geral

1.1 Introduo ...................................................................................... 11


1.2 Arrays Unidimensionais ................................................................. 11
1.3 Arrays Multidimensionais............................................................... 19
1.4 Processando argumentos da linha de comando ................................ 23
1.5 A classe String (Array de Caracteres) ............................................ 25
1.6 Exerccios Resolvidos .................................................................... 29
RESUMO DA AULA 1 ....................................................................... 32
ATIVIDADES DA AULA 1 ................................................................ 33
2.1 Introduo ...................................................................................... 36
2.2 Capturando Excees ..................................................................... 37
2.2.1 Deixando uma exceo passar atravs do mtodo ........................ 40
2.3 Hierarquia das Classes de exceo Java .......................................... 40
2.4 Lanando Excees ........................................................................ 43
2.5 Criando sua prpria exceo ........................................................... 44
2.6 A clusula: finally .......................................................................... 45
RESUMO DA AULA 2 ....................................................................... 46
ATIVIDADES DA AULA 2 ................................................................ 47
Colees .............................................................................................. 48
3.1 Introduo ...................................................................................... 49
3.2 Listas: java.util.List ........................................................................ 51
3.3 Conjunto: java.util.Set .................................................................... 58
3.4 Mapas - java.util.map ..................................................................... 63
RESUMO DA AULA 3 ....................................................................... 68
ATIVIDADES DA AULA 3 ................................................................ 69
Interface Grfica em JAVA .................................................................. 70
4. Interface Grfica em JAVA .............................................................. 71
4.1 Criando Aplicaes Grficas em JAVA: ......................................... 71
4.2 Capturando um evento do usurio:.................................................. 73
Capturando o ActionEvent de um Boto:.............................................. 73
4.3 Ouvintes, origens e Eventos:........................................................... 75
4.4 Mais um pouco de parte grfica: ..................................................... 75
4.5 Criando seu prprio elemento grfico de desenho: .......................... 75
4.6 Exibindo uma figura JPEG em um painel: ...................................... 77
4.7 Agora vamos aprender como funciona o Gerenciador de Layout: ... 77
4.8 Testando os componentes do Swing ............................................... 82
RESUMO DA AULA 4 ....................................................................... 86
EXERCCIOS DA AULA 4 ................................................................. 87
5. Java com Banco de Dados ................................................................ 92
RESUMO DA AULA 5 ....................................................................... 96
EXERCCIOS DA AULA 5 ................................................................. 97

Arrays

1
10

Aula

Ao final desta aula, voc dever ser capaz


de:
declarar e instanciar arrays;
popular e percorrer arrays.
Ser capaz de usar arrays na resoluo
de problemas.
Aprender a usar arrays

Objetivos

multidimensionais e arrays irregulares.


Conhecer e utilizar os principais
mtodos para manipulao de Strings

11

1.1 Introduo
Arrays so estruturas de dados em Java que permitem o armazenamento de vrias
variveis de um mesmo tipo ou instncias de uma mesma classe usando uma nica referncia 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,
atravs de um conjunto de instncias da classe Aluno. Uma classe Turma poderia conter um
nmero pr-definido e limitado de referncias instncias de Alunos, mas a declarao e
manipulao de muitas referncias 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 matemtica, onde valores possam ser
acessados especificando-se uma linha e uma coluna, que sero os dois ndices usados.
Nesta aula veremos como arrays de tipos nativos e de instncias de classes podem ser
criados e usados. Veremos tambm arrays multidimensionais, irregulares e encapsulamento de
arrays em classes para maior flexibilidade e praticidade.

1.2 Arrays Unidimensionais


1.2.1 Declarao de Arrays
A declarao de arrays em Java feita usando a notao dos colchetes: uma varivel
declarada como sendo de um tipo especfico seguido de um par de colchetes ser uma
referncia um array de elementos daquele tipo. O exemplo abaixo mostra a declarao de
alguns arrays de tipos nativos.
int [] nmeros;
double [] notasDosAlunos;
char[] letrasDoAlfabeto;

No trecho de cdigo mostrado acima, numeros ser uma referncia a um array de valores do
tipo int; notasDosAlunos ser uma referncia a um array de valores do tipo double e
letrasDoAlfabeto ser uma referncia a um array de valores do tipo char.

1.2.2 Criao e Inicializao de Arrays


No basta somente declarar as referncias a arrays, estas devem ser criadas (ter memria
alocada para seus elementos). No exemplo mostrado acima, as referncias foram simplesmente
declaradas, mas no se sabe quantas posies cada array dever ter. Um array deve ser criado
com a palavra-chave new, seguida do tipo de dado a ser alocado e do nmero de elementos a
alocar, entre colchetes.

12

Um array declarado deve ser inicializado com um tipo compatvel com o declarado.
Desta forma, a declarao int[] array = new char[100]; no ser vlida, e causar um
erro de compilao. Na inicializao do array devemos especificar o seu tamanho entre
colchetes. Este tamanho no precisa ser uma constante definida em tempo de compilao: pode
ser um valor obtido de qualquer outra fonte, e pode ser determinado em tempo de execuo,
como mostrado no exemplo abaixo:
int quantidade = 32768;
byte[] vetorNumerico = new byte[quantidade];

Quando um array de tipos nativos criado, seus elementos so inicializados


automaticamente com valores padro 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 no h a necessidade de usar o operador new nem de definir o


tamanho do array. Em outras palavras, no exemplo acima acontecem trs coisas em apenas uma
linha:
I Declarao de uma referncia a um array de inteiros chamado nmeros;
II Criao de um array com quatro posies;
III Inicializao das posies com os valores 2,3,5,7;
O
trecho
de
cdigo
abaixo
declarao/criao/inicializao de arrays.

demonstra

outras

maneiras

de

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, no pode ter seu tamanho modificado, embora


possamos usar a referncia para apontar para outro array. Desta forma as declaraes
boolean[] respostas = new boolean[12]; respostas = new boolean[144]; estaro
corretas, mas os valores do primeiro array (de 12 posies) sero perdidos quando a referncia
apontar para o array de 144 posies.

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 declarao float[]
srie = 10,1,0.1,0.01,0.001; causar um erro de compilao pois o compilador assumir
que os valores decimais so 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 so do tipo float.
A declarao de arrays com listas de valores como foi feito para a referncia
letrasDoAlfabeto no torna o array nem seus elementos constantes: posteriormente, o cdigo
poderia conter o comando letrasDoAlfabeto[0] = ?;, que seria compilado e executado
corretamente. Graficamente teramos:
letrasDoAlfabeto

...

Uma outra maneira de inicializao de arrays bastante utilizada em classes a declarao


separada da inicializao, como mostrado no trecho de cdigo na listagem acima para a
referncia notas. A declarao pode ser feita em um bloco da classe e a inicializao em outra:
esta tcnica bastante usada quando encapsulamos arrays em classes, declarando o array como
sendo um campo da classe (podendo ser acessado por todos os mtodos da classe) e
inicializando-o no construtor (que o primeiro mtodo a ser chamado, evitando que outros
mtodos acessem o array no inicializado). Podemos ver na inicializao do array notas que o
tamanho do array no dado por uma constante, podendo ser o resultado de uma operao
qualquer.
Uma ltima maneira de inicializarmos um array criando uma cpia de uma referncia a um
array j inicializado, como mostrado na ltima linha do trecho de cdigo mostrado acima.
Neste caso, o acesso aos elementos do array poder ser feito por qualquer uma das duas
referncias (medias e notas). Se modificarmos um elemento de uma das referncias e
recuperarmos o mesmo elemento via a outra referncia, o valor recuperado ser o modificado.
Vale a pena notar que somente podemos fazer cpias de referncias quando a referncia
original j tiver sido inicializada com a palavra-chave new.

1.2.3 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. No possvel acessar elementos fora
desta faixa, e o ndice deve ser sempre inteiro e positivo. Assim, as declaraes numeros[-1],
numeros[100] e numeros[5.4] so consideradas incorretas. O tamanho mnimo aceitvel para
um array zero: como os ndices so 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 variveis
independentes. Geralmente um array ser populado (isto , ter seus elementos inicializados)
com um lao cuja varivel de controle cobre os valores aceitveis para ndices do array,
modificando o elemento naquele ndice.

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
mdias na cidade de Teresina cujo tamanho definido pelo programador usurio da classe. A classe
permite a interao do usurio com o array somente atravs de mtodos que verificam os ndices sendo
usados, evitando que ndices invlidos sejam utilizados.
.
1 /**
2 * A classe TemperaturasTeresina, que encapsula um array de valores de ponto
3 * flutuante, com vrios mtodos que a tornam mais til e verstil do que um array
4 * comum.
5 */
6 class TemperaturasTeresina // declarao da classe
7 {
8 /**
9 * Declarao dos campos da classe
10 */
11 private float[] array; // o array encapsulado
12
13 /**
14 * O construtor para a classe TemperaturasTeresina, que recebe um argumento que
15 * ser o nmero de posies (ou valores do tipo float) que a instncia da classe
16 * ser capaz de armazenar.
17 * @param nmero o nmero de posies para valores do tipo float a serem alocadas
18 */
19 TemperaturasTeresina(int numero)
20 {
21
array = new float[numero]; // alocamos memria para o array encapsulado
22 }
23
24 /**
25 * O mtodo tamanho retorna o tamanho do array encapsulado. Uma vez que o campo que
26 * representa o array declarado como sendo privado, uma boa idia ter uma
27 * maneira de acessar o tamanho do array de fora desta classe.
28 * Retorna o nmero de posies para valores do tipo float no array encapsulado
29 */
30 public int tamanho()
31 {
32
return array.length;
33 }
34
35 /**
36 * O mtodo modifica recebe como argumentos uma posio e um valor, modificando no
37 * array encapsulado o valor na posio especificada. O valor somente ser
38 * modificado se a posio for vlida, isto , estiver entre zero e o tamanho
39 * mximo do array menos um. Caso uma posio no vlida seja passada, o mtodo no
40 * executar nenhum comando.
41 * @param posio: a posio do array que ser modificada
42 * @param valor: o valor que ser armazenado na posio especificada
43 */
44 public void modifica(int posio,float valor)
45 {
46
if ((posio >= 0) && (posio < array.length))
47
array[posio] = valor;
48 }
49 /**
50 * O mtodo valor retorna o valor armazenado em uma certa posio, que passada
51 * como argumento para o mtodo. O valor armazenado somente ser retornado se a
52 * posio for vlida, isto , estiver entre zero e o tamanho mximo do array menos
53 * um. Caso uma posio no vlida seja passada, o mtodo retornar a constante
54 * Float.NaN, que representa um valor de ponto flutuante que no um nmero. Em
55 * exemplos e exerccios posteriores veremos maneiras mais elegantes de tratar
56 * esses tipos de problema.
57 * @param: posio a posio do array cujo valor ser retornado

15
58 * Retorna: o valor que estava armazenado na posio 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;
66 }
67
68 /**
69 * O mtodo paraArray retorna o array encapsulado como um array de floats. Este
70 * mtodo pode ser til caso seja necessrio usar o array "desencapsulado", para,
71 * por exemplo, pass-lo como argumento para um mtodo que somente aceita arrays.
72 * @return o array encapsulado por esta classe
73 */
74 public float[] paraArray()
75 {
76
return array;
77 }
78
79 /**
80 * O mtodo menorValor retorna o menor valor presente no array encapsulado. Este
81 * mtodo 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 * @return 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
menorAtAgora = array[c];
93 return menorAteAgora;
94 }
95 /**
96 * O mtodo maiorValor retorna o maior valor presente no array encapsulado. Este
97 * mtodo 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;
110 }
111 /**
112 * O mtodo toString retorna os valores do array encapsulado formatados em uma
113 * String.
114 * Retorna uma String contendo uma representao 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;
122 }
123 } // fim da classe TemperaturasTeresina
Listagem 1.1: A classe TemperaturasTeresina, que encapsula um array de valores do tipo float

16
Os pontos de interesse da classe TemperaturasTeresina (listagem 1.1) so:
A classe encapsula um array de floats, fornecendo mtodos para recuperar e
modificar o array. O campo que representa o array declarado na classe, fora
dos mtodos, para que possa ser acessado de qualquer mtodo. O array
inicializado (memria alocada) no construtor da classe, desta forma quando
mtodos da classe forem executados saberemos que o array j foi inicializado,
uma vez que o construtor ser o primeiro mtodo a ser chamado.
Como o array foi declarado como sendo private da classe, o campo length do
array tambm o ser. Como til sabermos o tamanho do array, criamos o
mtodo tamanho para retornar este valor.
Dois mtodos permitem a modificao e recuperao de valores do array
encapsulado: modifica e valor. Ambos os mtodos tem um mecanismo
primitivo para evitar que ndices incorretos sejam usados para acessar os
elementos do array encapsulado.
A classe fornece um mtodo paraArray que retorna o array encapsulado - este
mtodo pode ser til caso seja necessrio montar um array a partir dos valores
encapsulados, evitando mltiplas chamadas ao mtodo valor, o que
computacionalmente custoso. O tipo de retorno deste mtodo float[], ou seja,
array de floats.
Dois mtodos adicionais (maiorValor e menorValor) demonstram as vantagens
do encapsulamento de um array ao invs do uso direto: podemos incluir mtodos
que calculam, inicializam ou fazem operaes de interesse no array, criando
mtodos que faam o processamento. Neste caso, poderemos saber qual foi a
maior e a menor temperatura na cidade de Teresina durante um certo perodo.
A classe TestaTemperaturasTeresina, mostrada na listagem 1.2, demonstra o uso de uma
instncia da classe TemperaturasTeresina.
1/**
2 * A classe TestaTemperaturasTeresina, que demonstra o uso de instncias da classe
3 * ArrayDeFloats.
4 */
5 class TestaTemperaturasTeresina
6 {
7 /**
8 * O mtodo main permite a execuo desta classe. Este mtodo contm declaraes de
9 * uma instncia da classe TemperaturasTeresina, e demonstra chamada de seus
10* mtodos.
11 * @param argumentos os argumentos que podem ser passados para o mtodo via linha
12 * de comando, mas que neste caso sero ignorados.
13 */
14 public static void main(String[] argumentos)
15 {
int min = 28;
int max = 37;
16 // Declara e inicializa a instncia da classe
17 TemperaturasTeresina tt = new TemperaturasTeresina(25);
18 // Vamos popular o array com valores obtidos atravs da gerao de valores
19 // aleatrios entre as temperaturas min e max atravs do mtodo random.
20 for(int i=-3;i<40;i++)
21
tt.modifica(i,(float) min+(Math.random()*(max-min)));
22
23 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 posies do array encapsulado
28 System.out.println("Na posio 0:"+tt.valor(0));

17
29 System.out.println("Na posio 24:"+tt.valor(24));
30 System.out.println("Na posio 25:"+tt.valor(25));
31 // Imprimimos os valores em determinadas posies do array encapsulado, mas usando
32 // a representao desencapsulada
33 float[] copia = tt.paraArray();
34 System.out.println("Na posio 0:"+cpia[0]); // indiretamente
35 System.out.println("Na posio 0:"+tt.paraArray()[0]); // diretamente
36 }
37 } // fim da classe TestaTemperaturasTeresina
Listagem 1.2: A classe TestaTemperaturasTeresina, que demonstra o uso de instncias da classe
TemperaturasTeresina.

Na classe TestaTemperaturasTeresina (listagem 1.2) podemos ver a declarao de


uma instncia da classe TemperaturasTeresina e chamadas a mtodos desta classe.
Mesmo com chamadas com argumentos nitidamente incorretos (tentativa de acesso a elementos
fora da faixa dos valores vlidos (linhas 20 e 21)), a execuo da classe no apresentar erros,
pois os mtodos de acesso foram preparados para ignorar tentativas de acesso invlido.
A classe TestaTemperaturasTeresina apresenta dois pontos interessantes que
esto relacionados ao mtodo paraArray. Uma chamada ao mtodo feita, e seu resultado
armazenado na referncia cpia, que no foi inicializada, somente tendo sido declarada. Esta
chamada ao mtodo faz com que o array encapsulado na instncia tt e o array cpia apontem
para a mesma posio de memria, desta forma, qualquer modificao feita usando a referncia
cpia alterar o array encapsulado. Se este no o comportamento desejado, podemos
reescrever o mtodo paraArray para que este retorne uma cpia ou clone do array
encapsulado.
O segundo ponto interessante a sintaxe da segunda chamada ao mtodo paraArray,
mostrado como tt.paraArray()[0], que permite que acessemos um elemento de um
resultado de chamada a mtodo. Embora a sintaxe seja incomum, est absolutamente correta: o
resultado da operao tt.paraArray() um array de floats, e podemos acessar seu primeiro
elemento com o sufixo [0].

1.2.4 Arrays de Instncias de Classes


Arrays de instncias 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 diferena principal que a inicializao do array deve ser seguida da inicializao dos
elementos do array, que deve ser feita da mesma maneira que fazemos com instncias de
classes comuns - geralmente, atravs da palavra-chave new e da chamada ao construtor da
classe.
Uma diferena fundamental entre os arrays de tipos nativos e de instncias de classes
que elementos de arrays nativos devem ser sempre do mesmo tipo, enquanto que elementos de
arrays de instncias podem conter instncias de qualquer classe que seja herdeira da classe
usada para declarao do array (aplicao de polimorfismo em arrays de instncias de classes).
Desta forma, se declaramos um array de instncias da classe Pessoa, por exemplo, poderamos
inicializar um dos elementos deste array como sendo uma instncia da classe Aluno, se a classe
Aluno for herdeira, direta ou indiretamente, da classe Pessoa.
Exemplo:

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+
instituio+anoDeEntrada;

1 /**
2 * A classe Equipe, que demonstra o uso de um array de instncias da classe
3 * Pessoa. O mtodo main desta classe declara e inicializa o array de instncias.
4 */
5 class Equipe
6 {
7 /**
8 * O mtodo main permite a execuo desta classe. Este mtodo declara e inicializa
9 * array de instncias da classe Pessoa, demonstrando caractersticas e
10 * problemas potenciais de arrays de instncias de classes.
11 * @param argumentos os argumentos que podem ser passados para o mtodo via linha
12 * de comando, mas que neste caso sero ignorados.
13 */
14 public static void main(String[] argumentos)
15 {
16 // Declaramos um array de Pessoas com cinco posies
17 Pessoa[] p1 = new Pessoa[5];
18 // Temos agora cinco posies para armazenar instncias da classe Pessoa no
19 // array, mas as instncias ainda no foram alocadas ! Devemos fazer isto
20 // manualmente para cada elemento do array.
21
22
23
24

p1[0]
p1[1]
p1[2]
p1[3]

=
=
=
=

new
new
new
new

Pessoa(23874,Maria);
Pessoa(43320, Joao);
Pessoa(764674,Pedro);
Aluno(101010,Anita,10929,IFPI,2002);

25 // Podemos imprimir diretamente os elementos do array pois so instncias da


26 // classe Pessoa, que contm o mtodo mgico 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
A figura abaixo mostra a representao na memria referente a listagem acima:

p1
Pessoa
23874
Maria

null

Pessoa
43320
Joo
Pessoa
764674
Pedro
Aluno
101010
Anita
10929
IFPI
2002

Figura: 1.1: Representao grfica de um array de objetos na memria

Os principais pontos da classe Equipe so:


O array de instncias da classe Pessoa declarado e inicializado de maneira similar
aos arrays de valores de tipos nativos. Aps a inicializao, o array tambm ser
preenchido com um valor constante. No caso de arrays de instncias de classes, todos os
elementos do array recebero o valor null.
Cada elemento do array usado como se fosse uma referncia individual uma
instncia da classe Pessoa, e deve ser inicializado individualmente atravs da palavrachave new e do construtor da classe Pessoa.
Podemos inicializar um dos elementos do array de instncias de Pessoa com uma
instncia da classe Aluno, uma vez que a classe Aluno herdeira da classe Pessoa.
Cada elemento do array segue a mesma regra das referncias instncias de classes: se
o comando p1[4] = p1[2] fosse executado, as duas referncias estariam apontando
para a mesma instncia, e qualquer modificao feita usando uma das duas referncias
estaria afetando a mesma instncia.

1.3 Arrays Multidimensionais


Os arrays mostrados nos diversos exemplos at agora so arrays de uma nica dimenso ou
unidimensionais: para acessar os elementos destes arrays basta usar um nico ndice. Podemos
facilmente criar arrays multidimensionais em Java, onde a posio de cada elemento dentro do
array ser indicada por dois ou mais ndices.

20
A declarao, construo e inicializao de arrays multidimensionais realizada conforme
exemplos a seguir. Observe que os trechos de cdigos so substituveis 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 peas 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 dimenses. Casas vazias no tabuleiro so representadas pelo
4 * caracter ., e casas com peas pelos caracteres o e x. Esta verso da
5 * classe no prev a representao de peas duplas (damas), que poderiam ser
6 * representadas por @ e *.
7 */
8 class JogoDeDamas // declarao da classe
9 {
10 /*
11 * O tabuleiro representado por um array de caracteres de duas dimenses, com o
12 * tamanho 8x8. Para evitar a manipulao direta do tabuleiro, o campo que o
13 * representa declarado como private.
14 */
15 private char tabuleiro[][];
16
17 /**
18 * O construtor da classe, que no recebe nenhum argumento. O construtor alocar
19 * o array de duas dimenses que representa o tabuleiro e inicializar as posies
20 * do tabuleiro de forma a representar o jogo em seu incio.
21 */
22 JogoDeDamas()
23 {
24 // A alocao simples, o tabuleiro tem sempre 8x8 posies
25 tabuleiro = new char[8][8];
26 // Inicializamos todas as posies do tabuleiro com o caracter ponto (.)
27 // que representa a ausncia de peas na posio.
28 for(int linha=0;linha<8;linha++)
29
for(int coluna=0;coluna<8;coluna++)
30
tabuleiro[linha][coluna] = .; // todas as posies inicializadas com pontos
31 // Inicialmente, todas as peas esto em posies pr-definidas: as do jogador
32 // que est de frente para o tabuleiro so marcadas com o caracter o ...
33 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) so marcadas
37 // com o caracter x.

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 mtodo toString no recebe argumentos, e retorna uma String contendo os
44 * valores dos campos da classe formatados. No caso desta classe, o array de duas
45 * dimenses ser formatado como se fosse um pequeno tabuleiro de damas.
46 * Retorna uma String contendo uma representao 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...
52 {
53
for(int coluna=0;coluna<8;coluna++) // para cada coluna do tabuleiro
54
resultado += tabuleiro[linha][coluna];
55 // concatena a pea naquela posio e inclui uma quebra de linha no final de cada
56 // linha do tabuleiro
57
resultado += "\n";
58 }
59 return resultado;
60 } // fim do mtodo toString
61
62 } // fim da classe JogoDeDamas
Listagem 1.4: A classe JogoDeDamas exemplificando o uso de arrays multidimensionais.

Figura 1.2 : Representao grfica de um tabuleiro de um jogo de damas

Os pontos interessantes da classe JogoDeDamas so seu construtor, que no somente aloca


memria para o array bidimensional que representa o tabuleiro do jogo de damas, mas tambm
inicializa os elementos do array para que o tabuleiro fique na sua configurao inicial, e o
mtodo toString, que retorna uma String contendo a representao grfica do tabuleiro.
Arrays multidimensionais podem ter bem mais que duas dimenses. Algumas aplicaes
matemticas e de simulaes requerem o uso de arrays com mais de trs dimenses. A criao
destes arrays segue o mesmo padro dos arrays uni e bidimensionais - a declarao do array
deve ser seguida de um nmero de pares de colchetes igual ao nmero de dimenses desejadas,
e o acesso aos elementos do array deve ser feito usando um ndice para cada dimenso.

22

1.3.1 Arrays Irregulares


Uma caracterstica interessante da maneira em que arrays multidimensionais so
implementados em Java que os arrays no precisam ter o mesmo nmero de valores para cada
dimenso, ou seja, possvel declararmos arrays que sejam irregulares. Por exemplo, um array
irregular bidimensional poderia ter cinco linhas, e cada linha pode ter um nmero diferente de
colunas - no obrigatrio que cada linha tenha o mesmo nmero de colunas.
Esta caracterstica 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 contm valores de determinado tipo. Um
exemplo ilustrativo de array irregular mostrado na figura abaixo:

Figura: 1.3 : Exemplo de um array irregular de duas dimenses

A coluna esquerda da figura 1.3 representa o ndice da primeira dimenso do array - cada
posio na primeira dimenso 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 dimenses precisa ser especificado - as outras
dimenses, podendo ser diferentes, devem ser alocadas em passos subsequentes do mtodo. A
listagem abaixo demonstra a criao e o preenchimento (atravs 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 necessrio para efeturarmos a entrada de dados
6 class ArrayIrregular // declarao da classe
7 {
8
9 public static void main(String[] argumentos)
10 {
11 // Consideramos o nmero 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 sero alocadas depois, cada uma
15 // com um tamanho diferente. Note que a segunda dimenso do array no 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
24 array1[4] = new int[8];
25 // Agora vamos popular o array fazendo um lao 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 aplicaes de Java (classes que contm o mtodo main) vimos que este mtodo
deve ser declarado como recebendo como argumento um array de Strings. Os valores contidos
neste array so criados pela mquina virtual Java quando esta tenta executar um programa,
usando os argumentos passados na linha de comando do sistema operacional em que esta
mquina virtual esteja sendo executado.
Como exemplo, considere uma classe Teste que contenha o mtodo main. Quando esta classe
for executada com o comando: java Teste, o array de Strings declarado dentro do mtodo
main ter comprimento zero, ou seja, ser vazio, pois nenhum argumento ou parmetro
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 mtodo main ter comprimento 5,
e seus elementos sero {1,b,3,d,5}. importante notar que mesmo que se alguns
elementos do array aparentam ser numricos, na verdade todos sero instncias da classe
String.
Caso seja necessrio processar valores numricos passados pela a linha de comando, estes
devero ser convertidos de Strings para numricos.
A linha de comando um mecanismo muito prtico e eficiente para que usurios passem
valores diretamente para o programa sem precisar que este interrompa a execuo 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 parmetros (p1, p2 e p3) durante a
execuo.

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 trs 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 operaes bsicas
(+, -, * ou /). O programa usar os argumentos para calcular o valor da expresso, 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 // declarao da classe
7 {
8 /**
9 * O mtodo main permite a execuo desta classe. Este mtodo usa os argumentos
10 * passados pela linha de comando, que sero disponibilizados para a aplicao
11 * atravs do array que o argumento para o mtodo main. Os argumentos sero
12 * processados para clculo da operao entre o primeiro e o terceiro argumentos,
13 * onde a operao ser definida pelo segundo argumento.
14 * Parametros: argumentos os argumentos que foram passados pela linha de comando
15 * para esta aplicao.
16 */
17 public static void main(String[] argumentos)
18 {
19 // Primeiro, verificamos se exatamente trs argumentos foram passados pela linha
20 // de comando, e samos do programa caso contrrio.
21 if (argumentos.length != 3)
22 {
23 System.out.println("Este programa precisa que trs argumentos sejam passados "+
24 "pela linha de comando.");
25 System.exit(1); // samos do programa com o cdigo de execuo nmero 1
26 }
27 // 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 operao
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;
41 }
42 // Imprimimos os argumentos passados com espaos 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 mtodo main
48
49 } // 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 mtodo main verificar se o nmero esperado de


argumentos foi passado pela linha de comando, e caso o nmero seja diferente de trs,

25
imprime uma mensagem de erro e sai do programa com o mtodo exit da classe System.
Este mtodo recebe como argumento um valor inteiro que, por conveno, deve ser
diferente de zero se o programa terminou inesperadamente ou com erro.
O array de argumentos de instncias 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 converso de String para int pode ser feita com o mtodo parseInt da classe
Integer.
Similarmente, o operador a ser processado do tipo char, e deve ser extrado da
String que o segundo elemento do array argumentos. A extrao de caracteres
individuais de Strings feita com o mtodo charAt da classe String.
Ao final da operao, os elementos do array argumentos e o resultado so impressos.
IMPORTANTE!

Alguns cuidados importantes devem ser tomados em relao linha de comando: o array de
Strings que passado como argumento para o mtodo main considera que seus elementos so
separados por espaos, desta forma, se a classe CalculadoraDeLinhaDeComando for
chamada com o argumento 7+5, somente uma nica String ser passada para a aplicao,
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
nmeros e seqncias de caracteres (strings). Alm de permitir a representao de cadeias de
caracteres de forma simples, a classe String contm muitos mtodos prticos 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 nmero de
caracteres que esta contm: no exemplo anterior, a string contm nove caracteres.
O ndice de cada um dos caracteres indica a posio deste na string: este ndice pode valer entre
zero e o valor do comprimento da string menos um. Por exemplo, a posio 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 vlidos causaro uma exceo
chamada java.lang.StringIndexOutOfBoundsException (excees so categorias
especiais de erros em Java, e sero vistas com detalhes mais adiante).

1.5.1 Construindo Strings


Nos exemplos vistos anteriormente vimos que instncias da classe String podem ser construdas
diretamente, por atribuio direta referncias, sem necessidade da chamada do construtor
atravs da palavra-chave new - isto uma exceo entre as outras classes que vimos. At agora
aprendemos a criar uma string em Java atravs da sintaxe:
String <identificador> = <valor entre aspas duplas>
Ex: String nome = Aula de Java;

26
Podemos tambm criar uma string usando a palavra-chave new e um construtor que recebe, como
argumento, uma outra instncia, 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 cdigo acima cria uma nova instncia da classe String contendo a cadeia de caracteres
Aula de Java

Instncias da classe String tambm podem ser construdas se passarmos para o construtor da
classe um array de caracteres que j tenha sido inicializado de alguma forma. Assim, o trecho
de cdigo:
char[] caracteres = {P,r,o,g,r,a,m,a};
String lista = new String(caracteres);

criar uma instncia da classe String contendo a cadeia de caracteres Programa. No


possvel criar uma instncia da classe String passando como argumento outros tipos de arrays
ou dados.

1.5.2 Mtodos importantes da classe String


length:
Este mtodo no recebe argumentos e retorna um valor inteiro igual ao nmero total de
caracteres contidos na string. importante notar que o mtodo length da classe String
diferente do campo length de arrays em Java - a sintaxe de chamada de mtodos exige que
usemos parnteses, mesmo que argumentos no sejam passados. Ex:
Int n =

lista.length(); // retorna o valor: 8

charAt:
Tem a funo de recuperar caracteres individuais de uma string. Este mtodo recebe como
argumento um valor inteiro correspondente posio do caractere que desejamos recuperar, e
retorna o caractere naquela posio. Usando os mtodos length e charAt podemos facilmente
escrever um lao que recupere todos os caracteres da string, um a um. Ex: Criar um programa
que dado uma string qualquer, retorne o numero de ocorrncias de uma letra nesta palavra.

String palavra = controle remoto;


letra = o;
int ocorrncias=0;
for (int i=0;i<palavra.length( );i++) {
if (palavra.charAt(i) == letra)
ocorrncias++;
System.out.println(O nmero de ocorrncias
:+ocorrncias);
...

da

letra

na

palavra

Mtodos para comparao de Strings


frequente a necessidade de comparao de valores de variveis ou campos com outras
variveis, campos ou constantes, para tomada de decises em programas e mtodos. Instncias

27
da classe String (sejam elas campos ou mesmo constantes) no podem ser comparadas com o
operador ==.
Para a comparao de strings podemos usar mtodos da prpria classe String. Uma vantagem
do uso de mtodos para comparao de strings que existem mais de uma maneira de
compararmos strings, a mais comum sendo a comparao de caracter por caracter de duas
strings, com diferenciao ou no de caracteres maisculos e minsculos. Se considerarmos
que caracteres maisculos e minsculos so iguais, as strings CASA e casa sero iguais,
mas se considerarmos que caracteres maisculos e minsculos so diferentes, as strings sero
diferentes.

equals
um dos mtodos bsicos na comparao de strings. Deve ser chamado a partir de uma
instncia da classe String e receber outra instncia da classe String como argumento, e
retornar o valor booleano true se todos os caracteres da instncia que chamou o mtodo forem
iguais (inclusive na ordem e considerando maisculos diferentes de minsculos) aos caracteres
da instncia passada como argumento. Ex:
String senha = CursoJava;
String senhadigitada = cursoJava;
if !(senha.equals(senhadigitada))
System.out.println(senha incorreta!);

No trecho de cdigo acima, temos duas strings que apesar de serem inicializadas com o mesmo
nome, no possuem todos os caracteres iguais. Neste caso, o mtodo equals, depois da
comparao dos contedos das duas strings, retornar um valor false.

equalsIgnoreCase
Este mtodo se comporta da mesma forma que o mtodo equals, exceto que considera
caracteres maisculos e minsculos como sendo iguais. Neste caso, se substituirmos o mtodo
equals por equalsIgnoreCase no trecho de cdigo anterior, o teste retornar um valor
true.
Mtodos para procura em Strings
Frequentemente tambm necessrio verificar se uma string contm outra, ou em que posio
uma string aparece dentro de outra. A classe String tem vrios mtodos para buscas de
substrings (consideradas trechos de strings).

indexOf
O mtodo de uso mais comum o mtodo indexOf, que recebe uma string como argumento e
retorna a posio onde esta string aparece dentro da string que executou o mtodo, ou -1 se a
string passada como argumento no estiver contida da que executou o mtodo. Assim, se a
string dna for igual a CTAGGTGTAGGC e a string trecho for igual a GG, a expresso
dna.indexOf(trecho) retornar 3 (a quarta posio, 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 ocorrncia ser considerada (o mtodo possui outras formas
que permitem verificar outras substrings alm da primeira). O mtodo 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
Mtodos para modificao de Strings
Instncias da classe String, depois de criadas, so imutveis - seu contedo no pode ser
modificado diretamente (atravs de acesso aos caracteres individuais da string) ou
indiretamente (atravs de mtodos). At mesmo operaes de concatenao como:
String nome = Jean-Paul;
nome = nome + Tremblay;

causam a criao de uma string temporria, contendo a concatenao das strings nome e
Tremblay, que depois sero associadas referncia nome.

toLowerCase
O mtodo toLowerCase no recebe argumentos e transforma todos os caracteres da string que o
executar em minsculos (inclusive respeitando acentos), retornando a string modificada. Desta
forma, se a string curso valer InFormTica, o resultado de curso.toLowerCase() ser
informtica.

toUpperCase
Similarmente, este mtodo transforma todos os caracteres da string que o executar em
caracteres maisculos, retornando esta string transformada, de forma que o resultado da
expresso curso.toUpperCase() ser INFORMTICA.

trim
Outro mtodo que retorna uma verso modificada da string que o executar o mtodo trim,
que elimina os espaos (e caracteres de controle) no incio e fim de uma string, retornando a
string sem estes caracteres. Por exemplo, se o campo texto valer Casa\n\n (notem os dois
espaos no incio da string e as duas quebras de linhas no final), a expresso
textoEntrado.trim() retornar Casa, tendo eliminado quatro caracteres nas pontas da
string original. O mtodo trim no elimina espaos internos na string: se executssemos este
mtodo na string tcnico em informtica o resultado seria uma nova string idntica original,
j que nenhum espao ou caracter de controle foi removido.

replace
Outro mtodo que retorna uma string modificada a partir da string que executa o mtodo o
replace, que recebe como argumentos dois caracteres, e troca todas as ocorrncias do
primeiro caractere pelo segundo caractere, retornando a string modificada. Desta forma se a
string gria valesse p-de-meia, o resultado da expresso gria.replace(-, ) seria
p de meia (todos os caracteres - foram trocados por espaos). No possvel, com o
mtodo replace, eliminar ou inserir caracteres adicionais, uma vez que os dois argumentos
para o mtodo devam conter um nico caractere.

substring
Este mtodo com duas formas permite a seleo e retorno de parte da string que o executar: o
mtodo 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
expresso: disciplina.substring(11) ser de Software.

29
O mtodo substring tambm tem uma forma na qual dois valores numricos so passados
como argumentos, e o mtodo 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 expresso
disciplina.substring(11,7) ser de Soft. Os argumentos para o mtodo devem estar
entre zero e o comprimento da string menos um, e o segundo argumento deve ser maior que o
primeiro, caso contrrio uma exceo ocorrer.

concat
O mtodo concat, que recebe como argumento uma string e retorna a concatenao da string
que executou o mtodo com a passada como argumento. Este mtodo tem a mesma
funcionalidade do operador +, de forma que se a string disciplina valer Engenharia, o
resultado da operao nome.concat( de Software) ser Engenharia de Software. A
vantagem do uso do mtodo concat sobre o operador + que podemos fazer chamadas em
cascata usando este mtodo e outros da classe String caso seja necessrio.

1.6 Exerccios Resolvidos


Exerccio 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];
for (int i=0;i<v.length;i++){
6
7
v[i] = 2*i;
8
}
9
}
10
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;
15
}
16
17
18
19

public static void main(String []args){


Exercicio1 e = new Exercicio1();
System.out.println(e);
}}

No cdigo acima, criamos um vetor de tamanho 5. O tamanho do array s definido no


construtor da classe (linha 5). A partir da esse tamanho no pode mais mudar. Ainda na
definio do construtor, percorremos o array atravs de um loop for e atribumos nmeros cujos
valores so o dobro de seus respectivos ndices (linhas 6 e 7). Na linha 10, definimos um
mtodo toString( ), que tem a funo de imprimir os valores dos elementos do vetor.
Finalmente na linha 16, temos a definio de um mtodo principal (main()), onde um objeto da
classe criado e a partir da o construtor chamado, fazendo com que o vetor seja criado e

30

Exerccio 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// Constri um tabuleiro vazio
6
7 public JogoVelha() {
8
tabuleiro = new char[3][3];
9
// preenche com espaos
10
for (int i=0; i <3; i++)
11
for (int j=0;j<3;j++)
12
tabuleiro[i][j] = ' ';
13
14}
15
16// atribui um valor('o' ou 'x') no tabuleiro
17
18 void setjogada(int i, int j, char jogador) {
19
/**
20
* Parmetros:
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("posio ocupada");
27
else
28
tabuleiro[i][j]=jogador;
29}
30
31/**
32 * Cria uma representao de string no tabuleiro como:
33 *
|x| |o|
34 *
| |x| |
35 *
| | |o|
36 *
Retorna a representao 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]+"|";
44
}
45
r = r+"\n";
46
}
47
return r;
48}
49
50 public static void main(String args[]) {
51
JogoVelha jv = new JogoVelha();
52
Scanner sc = new Scanner(System.in);

31
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67}
68}

int linha, coluna;


char jog = 'x';
while (true){
System.out.println("entre com a posio da linha para: "+jog);
linha = sc.nextInt();
System.out.println("entre com a posio da coluna para: "+jog);
coluna = sc.nextInt();
jv.setjogada(linha, coluna, jog);
if (jog == 'x')
jog = 'o';
else
jog = 'x';
System.out.println(jv);
}

No cdigo 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 espao. O mtodo setjogada responsvel por preencher com x ou o as casas livres do
tabuleiro do jogo. A cada jogada feita, ou seja, a cada vez que o mtodo setjogada chamado
em seguida o mtodo toString() para mostrar a configurao do tabuleiro depois da jogada
efetuada. Este exemplo simples e no verifica o ganhador da partida.
Exerccio resolvido 3:
Escreva uma classe em Java que contenha um mtodo retiravogais que receba uma string como
argumento e remova todas as vogais (maisculas e minsculas) 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 cdigo acima, criamos um mtodo retiravogais que recebe uma string como parmetro e
retorna uma string como resultado. Utilizamos um lao for para percorrer toda a string
caractere a caractere e para isso utilizamos o mtodo charAt que tem a funo de recuperar
caracteres individuais de uma string. Em seguida criamos uma varivel string s2, onde
concatenamos todos os caracteres diferentes de vogais e retornamos esta string como resultado.

32

RESUMO DA AULA 1
Nesta aula abordamos os conceitos e aplicaes prticas do uso de arrays. O array uma
sequencia de tamanho fixo de valores do mesmo tipo. O tamanho do array fixo e no pode ser
modificado durante sua a execuo do programa. Os arrays so acessados atravs de ndices
inteiros, como por exemplo na notao: referenciadearray[indice], onde indice representa um
ndice de valores inteiros. Use o campo length para obter o nmero 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 execuo. Arrays
de instncias de classes so criados utilizando-se a palavra chave new. Podemos facilmente
criar arrays multidimensionais em Java, onde a posio de cada elemento dentro do array ser
indicada por dois ou mais ndices. Os arrays no precisam ter o mesmo nmero de valores para
cada dimenso, ou seja, possvel declararmos arrays que sejam irregulares. Os arrays
irregulares tambm so definidos como arrays de arrays. A classe mais usada para
representao e processamento de cadeias de caracteres a classe String. Alm de permitir a
representao de cadeias de caracteres de forma simples, a classe String contm muitos
mtodos prticos e teis para o processamento de textos.

33

ATIVIDADES DA AULA 1

1. Qual ser o contedo dos arrays declarados na aplicao abaixo ao trmino da execuo do
mtodo main ?
class Exercicio1
{
public static void main(String[] argumentos)
{
double[] valores = {1,2,3,4,5,6};
double[] primeiraCpia = valores;
double[] segundaCpia = valores;
primeiraCpia[1] = 1;
segundaCpia[2] = valores[0]+primeiraCpia[1];
primeiraCpia[3] = valores[1]+segundaCpia[2];
valores[4] = primeiraCpia[2]+segundaCpia[3];
valores[5] = segundaCpia[3]+primeiraCpia[4];
}
}

2. Escreva um programa que declare um array bidimensional tabuada de 10x10 posies 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 16.
3. O mtodo abaixo pode ser um mtodo da classe TemperaturasTeresina (listagem 1.1) ?
Explique.
public void mudaTamanho(int novoTamanho)
{
array.length = novoTamanho;
}

4. Crie na classe TemperaturasTeresina (listagem 1.1) um mtodo mostraMdia que calcule e


retorne a temperatura mdia de todas as temperaturas do array.
5. Escreva um mtodo imprimeAlunos para a classe Equipe (listagem 1.3) que receba o array
de instncias da classe Pessoa como argumento e imprima somente os elementos que forem
instncias da classe Aluno. O mtodo no dever imprimir instncias que sejam iguais a null.
6. Escreva uma classe Menu em Java que encapsule um array de strings. Nesta classe, crie o
mtodo escolhe que mostra as strings com um nmero na frente, espere o usurio digitar um
nmero e retorne a string correspondente quele nmero. Dicas: faa com que o usurio seja
impossibilitado de digitar nmeros fora da faixa com um lao while, e faa com que os
nmeros a serem impressos antes das strings estejam na faixa 1 a N, onde N o tamanho do
array. Desta forma a escolha fica mais amigvel para o usurio.
7. Crie uma classe EntradaEmAgenda que contenha os dados necessrios para armazenar uma
entrada de agenda (hora, dia, ms, ano, assunto). Crie nesta classe, alm do construtor e do
mtodo toString, um mtodo NoDia que recebe valores de dia, ms e ano e retorna true se o
dia, ms e ano daquela instncia da classe forem iguais aos argumentos passados. Crie um

34
mtodo similar chamado NoMs que recebe valores de ms e ano somente e retorna true se o
ms e ano daquela instncia da classe forem iguais aos argumentos passados. Crie tambm uma
classe Agenda que encapsule uma agenda de compromissos, que ser representado por um array
de instncias da classe EntradaEmAgenda. Crie um mtodo listaDia que recebe valores de
dia, ms e ano e lista todas as instncias de EntradaEmAgenda que caem naquele dia, ms e
ano, e um mtodo listaMs que recebe valores de ms e ano e lista todas as instncias de
EntradaEmAgenda que caem naquele ms e ano.
8. Adicione um mtodo obterVencedor classe JogoVelha. Ele deve retornar x ou o
para indicar um vencedor ou se ainda no houver vencedor. Lembre-se de que uma
posio vencedora tem trs marcas que se correspondem em uma linha, coluna ou diagonal.
9. Escreva uma classe em Java que implemente um mtodo replica, que recebe como
argumentos uma string e um valor inteiro, e retorna uma string composta de vrias repeties
da string passada como argumento, onde o nmero de repeties deve ser o nmero passado
como argumento. Por exemplo, se os argumentos para este mtodo forem a string Ha! e o
valor 3, o mtodo dever retornar Ha!Ha!Ha!
10. Escreva na classe em Java que implemente um mtodo conta que receba como argumentos
uma string e uma substring, e retorne um inteiro correspondente ao nmero de ocorrncias da
substring na string passados como argumentos.
.

Tratamento de Excees

Aula

Objetivos

35

Ao final desta aula, voc dever ser capaz de:


Aprender a capturar excees
Saber quando

e onde capturar uma

exceo.
Aprender a lanar excees.
Entender

diferena

entre

verificadas e no-verificadas.

excees

36

2.1 Introduo
Uma exceo um evento que ocorre durante a execuo de um programa e que desfaz o fluxo
normal de instrues. Por exemplo, tentar acessar um elemento fora dos limites de um array,
tentar dividir um nmero por zero, so exemplos de excees. Um erro em Java uma
condio anormal irrecupervel. Por exemplo, uma condio de erro ocorre se existe algum
erro interno na JVM ou se a JVM fica sem memria. A diferena entre um erro e uma exceo
que uma exceo 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 exceo ocorre no interior de um mtodo Java, o mtodo cria um objeto do tipo
Exception e o retorna para o sistema. Este processo chamado de disparar uma exceo. O
objeto Exception contm informaes sobre a exceo, incluindo seu tipo e o estado do
programa quando a exceo ocorreu. Quando uma exceo disparada, o sistema busca em
seqncia na pilha todos os mtodos para tentar encontrar um capaz de tratar este tipo de
exceo. Na terminologia Java, este mtodo captura a exceo. Se o sistema no encontra
nenhum mtodo apto a capturar a exceo, o programa inteiro termina. Vamos comear os
nossos estudos conhecendo a forma como uma exceo apresentada e o seu significado,
observe as duas classes abaixo:

Figura 2.1: Exemplo de cdigo onde h uma exceo


Fonte: (www.t2ti.com)

As setas indicam o fluxo de execuo at o ponto onde ir acontecer a exceo (estrela) o que
ocasiona a quebra no fluxo normal da aplicao. Esta execuo pode ser entendida da seguinte
forma:
Ao invocar o mtodo main, sem o envio de parmetros, instanciado um novo objeto
RecebeArray e passado como parmetro do construtor o array vazio, o construtor por sua vez
invoca um mtodo desta mesma classe (imprimirPosicao0()) repassando o parmetro
recebido, este mtodo tenta imprimir o elemento da posio 0, primeira posio, e o resultado
obtido uma exceo, j que o array est vazio. Quando esta exceo acontece o programa
encerrado de forma inesperada, perceba que a ltima linha a ser executada (linha grifada em

37
amarelo) no percorrida devido ao trmino inesperado. Podemos observar a visualizao da
execuo desta aplicao na figura a seguir:

Figura 2.2: Resultado da execuo do programa descrito na figura 2.1

A exceo ocorrida foi do tipo java.Lang.ArrayIndexOutOfBoundsException que significa a


tentativa de acesso a uma posio fora dos limites do array, em seguida ele informa que posio
foi, neste caso o ndice 0 (zero).
Embaixo da definio da exceo ns temos a stacktrace (rastro da pilha) que contm a
seqncia da pilha de execuo. Pela stacktrace possvel perceber quais caminhos a
execuo percorreu at alcanar a exceo.
A primeira linha da stacktrace contm a definio da exceo, a segunda linha contm o
ultimo trecho de cdigo executado com o nmero da linha no cdigo fonte, neste caso foi a
invocao do mtodo imprimirPosicao0() da classe RecebeArray, que no cdigo fonte
(arquivo RecebeArray.java) refere-se a linha 10.

2.2 Capturando Excees


Quando chamamos um mtodo que pode retornar uma exceo (tanto verificvel quanto
no), temos trs alternativas:
1. Capturar a exceo e trat-la
2. Deixar a exceo passar pelo mtodo, ou seja, em algum outro lugar ela deve ser capturada.
3. Capturar a exceo e disparar uma exceo diferente. A nova exceo deve ser capturada em
algum lugar.
Toda exceo lanada representa um objeto que armazena informaes sobre a ocorrncia de
um erro ou alguma situao no-usual do programa. Caso a exceo no seja capturada por
nenhum mtodo do programa, o programa ir terminar com erro.

38
Para capturar uma exceo, devemos colocar o cdigo possvel de lanamento de exceo em
um bloco de comandos: try ... catch. Todas as linhas do programa que podem lanar uma
exceo devem ficar no bloco try. Para capturar a exceo 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 compilao. No pode haver cdigo adicional entre o bloco try
e o comeo do catch.
Cada bloco catch manipula um tipo de exceo indicado por seu parmetro. O tipo do
parmetro indica o tipo da exceo 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 mtodo
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 parmetro.");
}
}
}

E agora ao executarmos novamente este mesmo programa o usurio ir receber uma mensagem
mais significativa, observe a execuo abaixo:

Figura 2.3: Resultado da execuo da classe modulo10Main com tratamento de excees.

Agora ao executar o programa sem parmetros o usurio saber o que fazer. Porm o mais
interessante o seguinte, uma vez que a exceo foi tratada, o programa continua o fluxo de
execuo e termina normalmente.
Devemos observar o seguinte, esta no a nica exceo que pode acontecer neste mtodo,
vamos modificar o mtodo main( ) de forma que ele encaminhe como parmetro um valor nulo
(null).

39

public class modulo10Main {


public static void main(String[] args)
{
new RecebeArray(null);
System.out.println("Termino do programa!");
}
}

Repare que agora a nova instncia da classe RecebeArray est recebendo como parmetro uma
referncia nula, isto ocasionar uma exceo do tipo java.lang.NullPointerException.
Vejamos o resultado da execuo deste cdigo:

Figura 2.4: Resultado da execuo do cdigo acima depois da criao de uma instancia da classe
RecebeArray com uma referencia nula.

Percebemos que o programa encerrou de forma inesperada a mensagem Termino do


programa! no foi apresentada por uma exceo pois o nosso bloco try/catch no foi
capaz de captur-la. Isto aconteceu porque ele foi construdo de forma que apenas excees do
tipo java.lang.ArrayIndexOutOfBoundsException sejam tratadas.
Para corrigir este problema podemos encadear mais um bloco catch que capture todos os tipos
de excees, 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

Perceba agora que, no cdigo destacado, adicionamos mais um bloco de catch que captura
todos os tipos de excees veremos mais a frente como est estruturada a hierarquia de
classes de excees desta forma caso seja uma exceo do tipo
java.lang.ArrayIndexOutOfBoundsException ser tratado no primeiro bloco, todos os
demais tipos sero tratados no segundo bloco.
O cdigo destacado ir imprimir a mensagem (getMessage()) e na seqncia ir imprimir a
stacktrace, importante perceber novamente que aps o tratamento da exceo pelo segundo
bloco o programa encerrado normalmente. A seguir temos a execuo do novo programa:

Figura 2.5: Resultado da execuo do programa aps o tratamento da exceo.

2.2.1 Deixando uma exceo passar atravs do mtodo


Quando uma exceo ocorre mas no temos condio de trat-la naquele local, podemos
pass-la adiante para que num mtodo mais acima ela possa ser tratada adequadamente.
Para liberarmos um mtodo de tratar uma determinada exceo devemos usar o comando
throws na declarao do mesmo:
public int myMethod() throws exception1 {
//cdigo que pode gerar a exception1
}

Esta linha pode gerar uma exceo


de MalformedURLException.
Porm, o mtodo changeURL
resolveu no trat-la e pass-la
adiante.

Exemplo:
public URL changeURL(URL oldURL)throws MalformedURLException {
return new URL(http://www.xxx.com);
}

O mtodo que chamou changeURL pode optar por tratar a exceo ou tambm pass-la
adiante. Porm, se em nenhum momento algum mtodo trat-la, o programa terminar
em erro.

2.3 Hierarquia das Classes de exceo Java


A plataforma Java fornece uma numerosa quantidade de classes de exceo para uso nas mais
diferentes situaes de erro. A figura abaixo apresenta a hierarquia de classes que compe o
controle de erros da linguagem Java.

41

Figura 2.5: Hierarquia de classes de exceo da linguagem Java.


Fonte: (www.t2ti.com)

Nesta imagem esto representadas as trs modalidades de excees existentes na linguagem


Java: Unchecked Exception, Checked Exception e Error.

Error: Hierarquia em laranja na imagem, representam situaes incomuns, que no so


causadas pelo programa, indicam situaes que no acontecem usualmente durante a
execuo de um programa (Ex: Estouro da pilha de execuo StackOverflowError);

Checked Exception: Hierarquia em cinza, representam situaes que, geralmente, no


so erros de programao e sim indisponibilidade de recursos ou condio necessria
para a correta execuo inexistente (Ex: Em aplicaes distribudas existe dependncia
externa de rede de comunicao NoRouteToHostException).
As checked exceptions so tratadas obrigatoriamente, isto , o compilador s compila a
classe se houver um tratamento (bloco try/catch) para aquele tipo de exceo
Um exemplo que podemos mostrar agora, o de abrir um arquivo para leitura, onde
pode ocorrer o erro do arquivo no existir:
public static void metodo( ) {
new java.io.FileReader("arquivo.txt");
}

O cdigo acima no compila e o compilador avisa que necessrio tratar o


FileNotFoundException que pode ocorrer:

Figura 2.6: Mensagem de erro ao tentar compilar e executar o cdigo acima

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 mtodo, 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 prtico passar o erro pra frente para outros
tratarem dele. Pode ser que faa sentido, dependendo do caso, mas no at o main, por
exemplo. Acontece que quem tenta abrir um arquivo sabe como lidar com um problema na
leitura. Quem chamou um mtodo no comeo do programa pode no saber ou, pior ainda,
tentar abrir cinco arquivos diferentes e no saber qual deles teve um problema!
No h uma regra para decidir em que momento do seu programa voc vai tratar
determinada exceo. Isso vai depender de em que ponto voc tem condies de tomar uma
deciso em relao quele erro. Enquanto no for o momento, voc provavelmente vai
preferir delegar a responsabilidade para o mtodo que te invocou.

Unchecked Exception (RuntimeException): Hierarquia em azul, representam situaes


que, geralmente, identificam erros de programao (programa no robusto) ou mesmo
situaes incomuns/difceis de tratar (Ex: Acessar ndice invlido em um array
ArrayIndexOutOfBoundsException). Exemplo:

Que tal tentar dividir um nmero por zero? Ser que o computador consegue fazer aquilo que ns
definimos que no 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 execuo do cdigo acima, onde invocada a exceo de erro de operao aritmtica.

Outro exemplo:

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 execuo do cdigo acima, onde invocada a exceo de referencia nula.

Segue abaixo um quadro com relao de algumas das excees mais comuns:
EXCEO

QUANDO ACONTECE

ArrayIndexOutOfBounds Exception

Tentativa de acesso a posio


inexistente no array.
Tentativa de efetuar um cast em uma
referncia que no classe ou subclasse
do tipo desejado.
Argumento formatado de forma
diferente do esperado pelo mtodo.
O estado do ambiente no permite a
execuo da operao desejada.
Acesso a objeto que referenciado por
uma varivel cujo valor null.
Tentativa de converter uma String
invlida em nmero.
Normalmente acontece quando existe
uma chamada recursiva muito profunda.
Indica que a JVM no conseguiu localizar
uma classe necessria a execuo.

ClassCastException

IllegalArgumentException
IllegalStateException
NullPointerException
NumberFormatException
StackOverflowError
NoClassDefFoundError

2.4 Lanando Excees


Provavelmente em algum trecho do nosso programa, se uma determinada condio acontecer,
ns podemos lanar uma exceo para informar que a situao esperada no aconteceu. Lanar
uma Exception extremamente til principalmente se, por exemplo, algum esquecer de fazer
um if no retorno de um mtodo.
A palavra chave throw lana uma Exception (diferente de throws, que apenas avisa da
possibilidade daquele mtodo lan-la).

44
Vejamos um exemplo, suponha o mtodo abastecer( ) pertencente a uma classe que
representa um veculo. Este mtodo recebe como parmetro um Double que representa o valor
que est sendo abastecido, logo no pode haver situaes onde o valor seja negativo. Caso esta
situao acontea ns iremos lanar uma exceo 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 responsvel por lanar a exceo, logo
a seguir ns instanciamos um objeto do tipo IllegalArgumentException e passamos como
parmetro do mtodo construtor o texto que dever aparecer quando a stacktrace for impressa.
Veja o resultado da execuo deste mtodo 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 prpria exceo


s vezes, nenhum tipo de exceo-padro descreve com clareza o seu erro especfico. Nesse
caso, voc pode criar sua prpria classe de exceo.
Suponha que ao invs de utilizar a exceo: IllegalArgumentException no mtodo
abastecer(), caso o valor recebido seja negativo, ns desejemos jogar uma exceo prpria
chamada QuantidadeLitrosException. Neste caso basta que utilizemos os nossos
conhecimentos em herana e faamos uma extenso da classe RuntimeException conforme
abaixo:
public class QuantidadeLitrosException extends RuntimeException
{
QuantidadeLitrosException(String mensagem)
{
super(mensagem);
}
}

E agora, em vez de lanar um IllegalArgumentException, vamos lanar nossa prpria


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
tanque += litros;
}
}

A execuo deste mtodo 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 veculo e tente chamar o mtodo 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 pssima prtica de programao em java que a de escrever o catch e o throws
com Exception.
Existem cdigos que sempre usam Exception pois isso cuida de todos os possveis erros. O
maior problema disso generalizar o erro. Se algum joga algo do tipo Exception para quem o
chamou, quem recebe no sabe qual o tipo especfico de erro ocorreu e no vai saber como
tratar o mesmo.

2.6 A clusula: finally


Os blocos try e catch podem conter uma terceira clusula chamada finally que indica o que
deve ser feito aps o trmino do bloco try ou de um catch qualquer. interessante colocar
algo que imprescindvel de ser executado, caso o que voc queria fazer tenha dado certo, ou
no. O caso mais comum o de liberar um recurso no finally, como um arquivo ou conexo
com banco de dados, para que possamos ter a certeza de que aquele arquivo (ou conexo) v
ser fechado, mesmo que algo tenha falhado no decorrer do cdigo.
No exemplo a seguir, o bloco finally ser executado - no importa se tudo der certo ou no:
try {
// bloco try
} catch (IOException ex) {
// bloco catch 1
} catch (SQLException sqlex) {
// bloco catch2
} finally {
// bloco finally
}

46

RESUMO DA AULA 2
Nesta aula fizemos uma abordagem de tratamento de excees em Java. Uma exceo um
evento que ocorre durante a execuo de um programa e que desfaz o fluxo normal de
instrues. Quando chamamos um mtodo que pode retornar uma exceo (tanto verificvel
quanto no), podemos capturar a exceo e trat-la ou deixar a exceo passar pelo mtodo, ou
seja, em algum outro lugar ela deve ser capturada ou ainda, capturar a exceo e disparar uma
exceo diferente. A nova exceo deve ser capturada em algum lugar. Para capturar uma
exceo, devemos colocar o cdigo possvel de lanamento de exceo em um bloco de
comandos: try ... catch. Podemos passar uma exceo adiante para que num mtodo mais
acima ela possa ser tratada adequadamente e para isso devemos usar o comando throws na
declarao do mesmo. Existem dois principais tipos de Excees: As verificadas (checked) e as
no-verificadas (unchecked). As no-verificadas estendem da classe RuntimeException e
representam situaes que, geralmente, identificam erros de programao. As verificadas
(checked) estendem a classe Exception e representam situaes que, geralmente, no so erros
de programao e sim indisponibilidade de recursos ou condio necessria para a correta
execuo inexistente. Podemos lanar uma exceo para informar que a situao esperada no
aconteceu e para isso usamos o comando throw. Voc pode criar sua prpria classe de exceo
para especificar com clareza seu erro especfico. A clusula chamada finally utilizada
quando queremos que algo seja executado independente da situao anterior de teste ter dado
certo ou errado.

47

ATIVIDADES DA AULA 2
1. Qual a diferena entre lanar e capturar uma exceo?
2. O que acontece se uma exceo no tem uma clusula catch correspondente?
3. Qual o objetivo da clusula 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 exceo do tipo IllegalArgumentException com o
seguinte texto: Valor invlido, o valor esperado maior que 0 (zero).
5. Reescreva o programa anterior, s que em vez de lanar uma exceo do tipo
IllegalArgumentException, seja criada sua prpria exceo: ValorInvlidoException.
6. Crie uma classe denominada ContaCorrente. Adicione os mtodos: sacar, depositar e
obterSsaldo, adicione o atributo saldo_total. Modifique esta classe para lanar uma
exceo do tipo: IllegalArgumentException quanto a conta construda 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 faa com que essas trs
excees ocorram e que capture todas elas.

3
48

Colees

Aula

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 colees;

usar mapas para insero e busca de

Objetivos

objetos.

49

3.1 Introduo
A utilizao de arrays vista na aula 1 pode ser considerada uma boa soluo para alguns tipos
de problemas, mas torna-se complicada em muitos outros pontos a saber:

No podemos redimensionar um array em Java;


impossvel buscar diretamente por um determinado elemento cujo ndice no se sabe;
No conseguimos saber quantas posies do array j foram populadas sem criar, para
isso, mtodos auxiliares.

Figura 3.1: Representao grfica de um array na memria


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-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 espao vazio? Guardaremos em alguma estrutura de dados externa, as posies
vazias? E se no houver espao vazio? Teramos de criar um array maior e copiar os dados do
antigo para ele? H mais questes: como poderemos saber quantas posies esto sendo usadas
no array? Precisaremos sempre percorrer o array inteiro para conseguir essa informao? Alm
dessas dificuldades que os arrays apresentavam, faltava um conjunto robusto de classes para
suprir a necessidade de estruturas de dados bsicas, como listas ligadas e tabelas de
espalhamento.
Com esses e outros objetivos em mente, a Sun criou o framework Collections com a
inteno de formar uma arquitetura unificada para representao e manipulao de colees.
Mas o que o framework Collections? o conjunto de implementaes (classes e
interfaces) oferecidas no pacote java.util que fornecem as principais funcionalidades
esperadas quando trabalha-se com conjuntos de elementos (colees).

Figura 3.2: Representao da arquitetura unificada do framework Collections


Fonte: Curso Java Starter: Mdulo 09: Colees(www.t2ti.com)

50
Na figura acima temos as interfaces (razes e ns das rvores) que formam o conjunto de
interfaces disponveis. Nas folhas (retngulos com bordas mais espessas) encontramos as
classes concretas ou implementaes destas interfaces.
Esta arquitetura de interfaces forma o ncleo do Java Framework Collections e todas as
classes concretas iro derivar de uma ou mais interfaces. interessante notar que apesar da
arquitetura nica as colees derivadas da interface Map no implementam a interface
Collection no entanto elas tambm fazem parte do pacote de implementaes Java para
colees.
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 no do mesmo tipo dos
demais mas tambm manipula colees de elementos As implementaes de cada ramo esto
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 prtica, quando devemos utilizar uma ou outra implementao? Qual a diferena entra cada
uma destas interfaces? A seguir sero explicados, simplificadamente, as principais vantagens
obtidas com o uso de cada grupo de interfaces e respectivas implementaes.

List: Representa uma coleo ordenada (ordem de insero) e que permite duplicatas;
Set: Representa uma coleo que no pode conter duplicatas, implementa uma
abstrao dos conjuntos matemticos;
Map: um objeto que armazena um elemento e o remove atravs da sua chave, os
Maps no aceitam chaves duplicadas.
Queue: Parecida com a interface List porm 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 colees j implementadas no pacote java.util, obtemos as
seguintes vantagens:

Reduo na codificao: Muitas funcionalidades esperadas durante a manipulao de


um conjunto de elementos j esto prontas;
Melhor desempenho do programa: As implementaes 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
implementaes utilizadas sem prejuzo ao resto do programa;

51

3.2 Listas: java.util.List


Uma lista uma coleo que permite elementos duplicados e mantm uma ordenao
especfica entre os elementos. Qualquer implementao da interface List mantm seus
elementos indexados, ou seja, existe uma preocupao com o posicionamento de cada elemento
e esta posio determinada pelo ndice. Devemos utilizar um List quando a ordem de
insero ou a posio na coleo nos interessa. Em comparao ao array tradicional, as listas
resolvem problemas como: busca, remoo, 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 implementaes disponveis, cada uma com uma
forma diferente de representar uma lista. A figura a seguir mostra um diagrama UML com a
representao da interface List e algumas classes que a implementam:

Figura 3.3: Representao da interface List


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos)

A tabela abaixo mostra alguns mtodos importantes quando manipulamos lists:


Mtodo

Descrio
Adiciona um elemento ao List, na ltima posio.
Retorna o elemento da posio do ndice.
Retorna um objeto do tipo Iterator.
Retorna um int (inteiro) com a quantidade de elementos
da coleo.
contains(Objeto) Retorna true se o elemento j existe dentro do List
clear()
Elimina todos os elementos do Set.
add( Objeto )
get( ndice )
iterator()
size()

52

3.2.1 ArrayList
A implementao mais utilizada da interface List a ArrayList, que trabalha com um array
interno para gerar uma lista. Portanto, ela mais rpida na pesquisa do que sua concorrente, a
LinkedList, que mais rpida na insero e remoo de itens nas pontas.
IMPORTANTE: ArrayList no um Array!

comum confundirem uma ArrayList com um array, porm ela no um array. O que ocorre
que, internamente, ela usa um array dinmico como estrutura para armazenar os dados,
fazendo com que o espao disponvel seja aumentado conforme a demanda. Porm este
atributo est propriamente encapsulado e voc no tem como acess-lo. Repare, tambm, que
voc no pode usar colchetes ([ ]) com uma ArrayList, nem acessar atributo length.

Para criar um ArrayList, basta chamar o construtor:


ArrayList lista = new ArrayList();

sempre possvel 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 mtodos 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 posio da mesma.
Note que, em momento algum, dizemos qual o tamanho da lista. Podemos acrescentar
quantos elementos quisermos, que a lista cresce conforme for necessrio.
Toda lista (na verdade, toda Collection) trabalha do modo mais genrico possvel. Isto , no
h uma ArrayList especfica para Strings, outra para Nmeros, outra para Datas etc. Todos
os mtodos trabalham com Object.
Assim, possvel 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 mtodo size():

53

System.out.println(contas.size());

H, ainda, um mtodo get(int) que recebe como argumento o ndice do elemento que se quer
recuperar.
Atravs dele, podemos fazer um for para iterar na lista de contas:
for(int i = 0; i < contas.size(); i++) {
contas.get(i); // cdigo no muito til....
}

Supondo que a classe ContaCorrente tenha um mtodo getSaldo() responsvel por imprimir o
saldo de uma conta. Ento como fazer para imprimir o saldo dessas contas? Podemos acessar o
mtodo getSaldo() diretamente aps fazer contas.get(i)? No. Lembre-se que toda lista
trabalha sempre com Object. Assim, a referncia devolvida pelo get(i) do tipo Object,
sendo necessrio 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 no alterada

H ainda outros mtodos 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 no na lista.

3.2.2 Vector
Vector basicamente um ArrayList, no entanto seus mtodos so sincronizados o que
significa que o acesso por vrios 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 no houver acesso simultneo aos dados.

3.2.3 LinkedList
Muito similar as duas colees vistas anteriormente (Vector e ArrayList), a diferena que
todos os elementos so ligados entre si. O desempenho do LinkedList muito superior aos do
ArrayList e Vector quando necessitamos inserir elementos no incio da coleo, no entanto se
precisarmos obter algum elemento pelo o ndice o desempenho muito inferior.

3.2.3 Listas no Java 5.0 com Generics


At agora as nossas colees 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
arrayList.add(new String("Texto"));
//Adicionando um Integer
arrayList.add(new Integer(3));

Isto possvel pois nossas colees aceitam qualquer elemento que seja do tipo Object, e todas
as classes criadas em Java automaticamente herdam, e portanto so, da classe Object. No
entanto, com o uso de Generics podemos definir de que tipo especfico ser a nossa coleo.
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
notao, declarao <Integer> junto a declarao da Classe/Interface, evitando que sejam
inseridos indevidamente outros tipos que no sejam Integer na coleo.
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 mtodo get devolve um Object,
precisamos fazer o cast. Mas com uma lista com vrios objetos de tipos diferentes, isso pode
no ser to simples...
Geralmente, no nos interessa uma lista com vrios 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 no qualquer Object):
List<ContaCorrente> contas = new ArrayList<ContaCorrente>();
contas.add(c1);
contas.add(c3);
contas.add(c2);

Repare no uso de um parmetro 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
segurana em tempo de compilao:
contas.add("uma string"); // isso no compila mais!!

O uso de Generics tambm elimina a necessidade de casting, j que, seguramente, todos os


objetos inseridos na lista sero do tipo ContaCorrente:
for(int i = 0; i < contas.size(); i++) {
ContaCorrente cc = contas.get(i); // sem casting!
System.out.println(cc.getSaldo());
}

3.2.4 Ordenao em Listas: Collections.sort

55
Vimos anteriormente que as listas so percorridas de maneira pr-determinada de acordo com a
incluso dos itens. Mas, muitas vezes, queremos percorrer a nossa lista de maneira ordenada.
A classe Collections traz um mtodo esttico 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
insero e, depois de chamar o sort, ela impressa em ordem alfabtica.
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 critrio de ordenao adotado no cdigo acima?


Sempre que falamos em ordenao, precisamos pensar em um critrio de ordenao, uma
forma de determinar qual elemento vem antes de qual. necessrio instruir o Java sobre como
comparar nossas ContaCorrente a fim de determinar uma ordem na lista. Vamos fazer com
que os elementos da nossa coleo implementem a interface java.lang.Comparable, que
define o mtodo int compareTo(Object). Ex:
int x = esteObjeto.compareTo(outroObjeto)

O mtodo compareTo(Object) retorna um tipo int com as seguintes caractersticas:

Negativo : Se este objeto for menor que o objeto dado. (esteObjeto < outroObjeto)
Zero: Se este objeto for igual ao objeto dado. (esteObjeto == outroObjeto)

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 cdigo acima, nossa classe tornou-se comparvel": dados dois objetos da classe,
conseguimos dizer se um objeto maior, menor ou igual ao outro, segundo algum critrio por
ns definido. No nosso caso, a comparao ser feita baseando-se no saldo da conta. Repare
que o critrio de ordenao totalmente aberto, definido pelo programador. Se quisermos
ordenar por outro atributo (ou at por uma combinao de atributos), basta modificar a
implementao do mtodo compareTo na classe.
Agora sim, quando chamarmos o mtodo sort de Collections, ele saber como fazer a
ordenao da lista. Ele usar o critrio que definimos no mtodo compareTo.
Mas, e o exemplo anterior, com uma lista de Strings? Por que a ordenao 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 mtodo compareTo
para Strings, fazendo comparao em ordem alfabtica. (Consulte a documentao da classe
String e veja o mtodo compareTo).
O mtodo Collections.shuffle:
Este mtodo oposto ao mtodo de ordenao citado acima e ao invs de ordenar ele desordena
(mistura) os elementos dentro de um List. A primeira vista pode parecer intil, mas existem
situaes onde voc ir querer desordenar sua estrutura de dados para obter um elemento
aleatoriamente. Por exemplo, abaixo temos uma possvel implementao para a modalidade de
sorteio cujos nomes dos elementos a serem sorteados, normalmente pessoas, so escritos em
pequenos pedaos de papis e o primeiro a ser escolhido o vencedor.
//Criao 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
System.out.println(arrayList.get(0));

Resultado obtido em uma execuo:


Joao

Perceba que o elemento na posio 0 (zero), pela ordem de insero seria Maria e, no
entanto, obtivemos o elemento Joao, o que confirma, a mudana de posio destes elementos
dentro do List.

3.2.4 Pesquisa em Listas: Collections.binarySearch


Quando falamos em estruturas de dados devemos pensar em algoritmos de ordenao e
pesquisa, pois, de que adianta uma estrutura de dados cujos elementos no conseguimos
localizar? Ao manipularmos estruturas de dados sempre devemos ter em mente que iremos
orden-las ou pesquis-las.
A pesquisa efetuada pelo mtodo binarySearch da Classe Collections retorna um nmero
inteiro positivo ou zero se o elemento for encontrado e negativo se o elemento no existe na
coleo. Quando o elemento existe na coleo o nmero representa o seu ndice (posio), por
outro lado, quando o elemento no existe, o nmero, em mdulo, representa a posio que ele
deveria estar (ponto de insero), neste caso, esta posio somente vlida se a coleo estiver
ordenada antes da pesquisa. A seguir temos um exemplo:
//Criao

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 execuo:
Resultado da pesquisa: 1

O resultado obtido, conforme esperado, indica que o nome Pedro encontra-se na segunda
posio da coleo, lembrando que todas as colees iniciam-se pelo ndice 0 (zero), logo, o
valor 1 indica a segunda posio.
Outras funcionalidades teis:

Reverse Inverte a ordem dos elementos;


Fill Preenche a coleo com o elemento especificado;
Swap troca os elementos de posio;
addAll Adiciona os elementos a coleo;
frequency Conta a quantidade de ocorrncias do elemento especificado;
disjoint Verifica quando duas colees no possuem nenhum elemento em comum.

58

3.3 Conjunto: java.util.Set


Um conjunto (Set) funciona de forma anloga aos conjuntos da matemtica, ele uma coleo
que no permite elementos duplicados. Um exemplo deste conceito est na figura abaixo:

Figura 3.4: Representao grfica de um Conjunto (Set)


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos)

Um conjunto representado pela interface Set e tem como suas principais implementaes as
classes HashSet e TreeSet, Como mostra a figura abaixo:

Figura 3.5: Representao grfica da Interface Set no Java


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos)

Outra caracterstica fundamental dele o fato de que a ordem em que os elementos so


armazenados pode no ser a ordem na qual eles foram inseridos no conjunto. Tal ordem varia
de implementao para implementao.
Alguns dos mtodos mais utilizados quando manipulamos Sets, estes mtodos so comuns a
qualquer implementao desta interface:

Mtodo
boolean add(Objeto)

Descrio
Adiciona um elemento ao nosso Set, retorna true se

59

boolean remove(Objeto)
int size()
Boolean contains (Objeto)
Iterator iterator()
clear()

o elemento foi inserido


Remove o elemento da nossa coleo, retorna true
se o elemento foi removido
Retorna um int (inteiro) com a quantidade de
elementos da coleo
Retorna true se o elemento j existe dentro do Set
Retorna um objeto que possibilita percorrer os
elementos daquela coleo.
Elimina todos os elementos do Set

3.3.1 HashSet
Uma das implementaes concretas da interface Set. O HashSet caracteriza-se por no aceitar
duplicatas, caracterstica derivada do Set, ser uma coleo desordenada e desorganizada, isto ,
no h nenhuma garantia quanto a ordem que os elementos sero percorridos.
O cdigo a seguir cria um conjunto e adiciona trs 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 sequncia na tela
System.out.println(conjunto);

Resultado da execuo:
[item 3, item 2, item 1]

O resultado so os elementos do conjunto, a ordem na qual eles aparecem pode, ou no, ser a
ordem na qual eles foram inseridos e incorreto supor que ser sempre a mesma ordem. Assim
como as listas, conjuntos tambm podem ser parametrizados utilizando Generics, eliminando
a necessidade de castings.

3.3.2 LinkedHashSet
uma verso organizada do HashSet. Lembrando que organizada significa que existe
algum tipo de seqncia no-aleatria durante a iterao dos elementos: neste caso a ordem de
insero respeitada. Por ser um Set, o LinkedHashSet no aceita duplicatas e, da mesma
forma que o HashSet, dependente da correta implementao do mtodo equals(). Devemos
utilizar o LinkedHashSet ao invs do HashSet quando a ordem de iterao dos elementos
importante.

3.3.3 TreeSet

60
um Set ordenado e como tal no aceita duplicatas, ou seja, existe alguma regra que garante a
ordenao. No Treeset os elementos inseridos sero percorridos de acordo com sua ordem
natural e de forma ascendente.

3.3.4 Iterao de elementos de colees


Vamos a seguir, apresentar duas formas de iterao de elementos de colees: utilizando um
Iterator e utilizando o for-each ou enhanced-for.

Iterator: Toda coleo fornece acesso a um iterator, um objeto que implementa a interface
Iterator, que conhece internamente a coleo e d acesso a todos os seus elementos, como
mostra a figura abaixo:

Figura 3.6: Representao grfica de um iterator


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos)

A implementao ocorre da seguinte forma:


Primeiro criamos um Iterator que entra na coleo. A cada chamada do mtodo next, o Iterator
retorna o prximo objeto do conjunto. Um iterator pode ser obtido com o mtodo iterator() de
Collection, por exemplo:
Iterator i = lista.iterator();

Figura 3.7: Representao grfica da Interface iterator no Java


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos)

61
A interface Iterator possui dois mtodos principais:

hasNext() (com retorno booleano), indica se ainda existe um elemento a ser percorrido;
next(), retorna o prximo 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 mtodo hasNext mencionar que no existem mais itens.
IMPORTANTE: Usar o iterator no Java 5

O Iterator pode sim ainda ser til no Java 5. Alm de iterar na coleo como faz o enhancedfor, o iterator consegue remover elementos da coleo durante a iterao, o que bastante til.
Alm disso, no Java 5, o Iterator foi parametrizado e usa generics, facilitando castings e
evitando erros.

for-each: um for adaptado a colees e que percorre todos os elementos qualquer de


coleo 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 coleo de Carros (carrosHashSet) faa isto. Outro exemplo:
1
2
3
4
5
6
7
8

Set conjunto = new


conjunto.add("item
conjunto.add("item
conjunto.add("item

HashSet();
1");
2");
3");

// retorna o iterator
for (Object elemento : conjunto) {
String palavra = (String) elemento;

62
9 System.out.println(palavra);
10 }

Em que ordem os elementos sero acessados? Numa lista, os elementos aparecero 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 implementao da interface Set.
Por que o Set , ento, to importante e usado?
Para perceber se um item j existe em uma lista, muito mais rpido usar um Set do que um
List, e os TreeSets j vm ordenados de acordo com as caractersticas que desejarmos.
Exerccio resolvido:

Implemente um mtodo que manipule as trs 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
import
import
import
import

java.util.HashSet;
java.util.Iterator;
java.util.LinkedHashSet;
java.util.Set;
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
" TreeSet: "+itTreeSet.next());
}
}}

Resultado da execuo:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:
HashSet:

0 LinkedHashSet: 0 TreeSet: 0
100 LinkedHashSet: 100 TreeSet: 3
3 LinkedHashSet: 3 TreeSet: 5
5 LinkedHashSet: 5 TreeSet: 7
7 LinkedHashSet: 7 TreeSet: 10
10 LinkedHashSet: 10 TreeSet: 12
12 LinkedHashSet: 12 TreeSet: 21
465 LinkedHashSet: 465 TreeSet: 23
45 LinkedHashSet: 45 TreeSet: 29
21 LinkedHashSet: 21 TreeSet: 45
54 LinkedHashSet: 54 TreeSet: 54
23 LinkedHashSet: 23 TreeSet: 100
147 LinkedHashSet: 147 TreeSet: 147
29 LinkedHashSet: 29 TreeSet: 465

Antes de avaliarmos a ordem dos resultados, observe que durante a fase de incluso dos
nmeros no HashSet alguns deles se repetem, especificamente o 3 e o 12 (linhas em
destaque), porm no resultado estes nmeros aparecem apenas uma vez cada um, isto acontece
pois, conforme dito anteriormente, qualquer coleo do tipo Set no permite duplicatas, na
verdade, na segunda tentativa de incluso dos nmeros 3 e 12, eles no foram includos.
Em relao a ordem o HashSet, desta vez, manteve a ordem de insero e obtivemos um
resultado igual ao visto no LinkedHashSet, no entanto no temos garantia nenhuma de que
este comportamento ir se repetir. J o TreeSet no respeitou a ordem de insero mas,
ordenou de acordo com a ordem natural de cada um dos valores.
Para nmeros a ordem natural fcil de compreender afinal de contas, 1 menor do que 2
que menor do que 3 que menor... no entanto, nem sempre trabalhamos com nmeros,
muitas vezes criamos nossos prprios 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 associao de um objeto chave a um objeto valor. equivalente
ao conceito de dicionrio, usado em vrias linguagens. Um map ou qualquer implementao
desta interface, identifica seus elementos atravs de uma chave, logo, esta coleo aceita
duplicatas de valores (elementos) desde que eles possuam chaves diferentes. A principal
caracterstica dos Maps so que suas chaves nunca podem se repetir, ou seja, em um map
nunca iro haver dois elementos com a mesma chave. Assim como os elementos armazenados
as chaves utilizadas nos Maps tambm devem ser objetos. Exemplo:
Mapeie o valor Maria chave nome, ou mapeie o valor 23761804 chave RG. A
figura abaixo mostra a representao grfica de um map:

64

Figura 3.8: Representao grfica de um Mapa


Fonte: FJ11: Java e Orientao a Objetos (http://www.caelum.com.br/curso/fj-11-java-orientacao-objetos)

Os principais mtodos utilizados quanto manipulamos Maps so:


Mtodo

Descrio
Adiciona a chave e o elemento
Retorna o elemento de acordo com a chave
Retorna um objeto do tipo Iterator
Retorna um int (inteiro) com a quantidade de
elementos da coleo
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
put( chave, objeto )
get( chave )
iterator()
size()

3.4.1 HashMap e Hashtable


HashMap um Map desorganizado, isto , a ordem de iterao dos elementos desconhecida,

e desordenado, ou seja, os elementos no sofrem nenhum tipo de ordenao derivada de alguma


regra. Hashtable, similarmente ao ArrayList e Vector, a verso sincronizada do
HashMap. A maior diferena que o HashMap aceita nulos tanto para chaves quanto para
valores enquanto o Hashtable no aceita nenhum nulo.
A seguir segue trecho de cdigo 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 colees, trabalha diretamente com Objects (tanto na chave quanto
no valor), o que torna necessrio o casting no momento que recuperar elementos.

65

3.4.2 LikedHashMap
Muito similar ao LinkedHashSet, porm esta a verso que implementa a interface Map,
logo ao armazenar os objetos necessria uma chave. E, ao contrrio do HashMap, o
LinkedHashMap organizado, o que significa dizer que durante a iterao dos elementos ele
respeita a ordem que estes foram inseridos na coleo. Se a ordem de insero for importante e
precisarmos identificar os elementos pelas suas chaves devemos utilizar esta implementao da
interface Map. Abaixo temos o mesmo cdigo exibido anteriormente porm a implementao
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;

3.4.3 TreeMap
Assim como o TreeSet um Set que ordena os elementos de acordo com alguma regra, o
TreeMap tambm ordena seus elementos atravs da chave por alguma regra. Quando esta
ordem no definida pela interface Comparable ou por um objeto Comparator o TreeMap
busca a ordem natural dos elementos. A seguir apresentado um trecho de cdigo 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 execuo deste cdigo:


Numero
Numero
Numero
Numero

1
5
22
100

Observe que a declarao Map<Integer, String> utiliza generics. Ao declarar um Map


desta forma estou garantindo que todas as chaves sero do tipo Integer e todos os valores sero
do tipo String.

66

3.4.4 Equals e HasCode


Quando ns estamos trabalhando com objetos os operadores de igualdade, == e != , podem ter
efeitos desastrosos se no forem corretamente aplicados. Quando estes operadores so
utilizados, na verdade, o que est sendo comparado a referncia do objeto, isto , esta
operao ir retornar verdadeiro (true) apenas se as duas referncias so do mesmo objeto. Um
exemplo desta situao o seguinte:
System.out.println(new String("Pedro") == new String("Pedro"));//Imprime
false

No exemplo anterior, caso o cdigo seja executado, obteremos como sada: false. Isto
acontece, pois conforme explicado anteriormente, estamos comparando as referncias e no o
contedo das Strings (que so idnticos). Ou seja cada uma das partes da operao refere-se a
um objeto diferente porm, do mesmo tipo String e com o mesmo valor Pedro. Para resolver
este problema basta substituir o cdigo 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 contedo 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 referncias fazem aluso ao mesmo objeto.
Ao utilizar o mtodo equals() ns estamos verificando se os dois objetos so significativamente
iguais (equivalentes). A maioria das coisas (objetos) que importam, no contexto da
computao, possuem algum identificador nico ou alguma forma de identificao nica. Ex:
Carro placa/renavam, Pessoa CPF, Empresa CNPJ, Fatura cdigo, Nota fiscal
nmero/srie, Municpio Cdigo do IBGE, Produto cdigo de barras e etc. Sendo assim ao
sobreescrevermos o mtodo equals() devemos observar estes identificadores e implementar o
mtodo a fim de realizar os testes de igualdade sobre este(s) atributo(s).
Exerccio resolvido
Crie uma classe que represente notas fiscais com cdigo, valor e data, e
sobreescreva o mtodo equals de forma que duas notas fiscais sejam
consideradas
iguais apenas se seus cdigos forem idnticos.

Uma vez compreendida a importncia do mtodo equals() iniciamos os estudos para descobrir a
funo do mtodo hashcode(). Cdigos de Hash ou Hashcodes so utilizados para aumentar a
performance quando manipulamos grandes quantidades de objetos.
Hashcodes so utilizados para identificar objetos de forma que o acesso a estes se torne mais
eficiente. Estes cdigos so gerados por uma funo de espalhamento, o resultado desta funo
obtido de acordo com o valor (dado) de entrada.
importante compreender que entradas diferentes podem produzir tanto hashcodes iguais
quanto diferentes, j entradas iguais produziro sempre o mesmo hashcode, desta forma o
mtodo hashCode() deve respeitar o mtodo equals(), ou seja, sempre que dois objetos forem
iguais, de acordo com o mtodo equals(), obrigatoriamente o resultado obtido pelo mtodo
hashCode() deve ser igual para estes objetos.

67
Caso o mtodo hashCode() no respeite a implementao do mtodo equals() poderemos ter
problemas de desempenho e consistncia nas nossas colees. O ideal que a funo de
espalhamento nunca produza o mesmo cdigo hash para entradas diferentes porm isto nem
sempre possvel, nestes casos devemos nos preocupar em criar funes que faam uma boa
disperso de cdigos.

3.4.5 Boas Prticas


As colees do Java oferecem grande flexibilidade ao usurio. A perda de performance em
relao utilizao de arrays irrelevante, mas deve-se tomar algumas precaues:

Grande parte das colees usam, internamente, um array para armazenar os seus dados.
Quando esse array no mais suficiente, criada um maior e o contedo da antiga
copiado. Este processo pode acontecer muitas vezes, no caso de voc ter uma coleo
que cresce muito. Voc deve, ento, criar uma coleo j com uma capacidade grande,
para evitar o excesso de redimensionamento.
Evite usar colees que guardam os elementos pela sua ordem de comparao quando
no h necessidade. Um TreeSet gasta computacionalmente O(log(n)) para inserir (ele
utiliza uma rvore rubro-negra como implementao), enquanto o HashSet gasta
apenas O(1).
No 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 implementaes da List no
so de acesso aleatrio como a LinkedList, fazendo esse cdigo ter uma pssima
performance computacional. (use Iterator)

68

RESUMO DA AULA 3

Nesta aula exploramos os princpios bsicos de colees (interface Collections). As


atividades comuns das colees incluem a insero e a remoo de objetos, a verificao de
objetos includos, a recuperao dos mesmos e a iterao. As quatro verses bsicas das
colees so: Listas (java.util.List), Conjuntos (Java.util.Set), Mapas (Java.util.Map) e Filas
(Java.util.Queue).
Uma lista uma coleo que permite elementos duplicados e mantm uma ordenao
especfica entre os elementos. Qualquer implementao da interface List mantm seus
elementos indexados, ou seja, existe uma preocupao com o posicionamento de cada elemento
e esta posio determinada pelo ndice. Devemos utilizar um List quando a ordem de
insero ou a posio na coleo nos interessa. A implementao mais utilizada da interface
List a ArrayList. O uso de Generics restringe as Colees de um modo geral a um
determinado tipo de objetos e elimina a necessidade de casting. O mtodo Collections.sort
utilizado para a ordenao em listas. O mtodo Collections.binarySearch utilizado para
realizar buscas em listas.
Um conjunto representado pela interface Set e tem como suas principais
implementaes as classes HashSet e TreeSet. A ordem em que os elementos so
armazenados pode no ser a ordem na qual eles foram inseridos no conjunto. Tal ordem varia
de implementao para implementao. A diferena bsica entre o HashSet e o TreeSet que
no HashSet no h nenhuma garantia quanto a ordem que os elementos sero percorridos e no
TreeSet existe alguma regra que garante a ordenao. Existem duas formas de iterao de
elementos de colees: utilizando um Iterator ou utilizando o for-each ou enhanced-for. Para
perceber se um item j existe em uma lista, muito mais rpido usar um Set do que um List.
Um map composto de uma associao de um objeto chave a um objeto valor. A
principal caracterstica dos Maps so que suas chaves nunca podem se repetir, ou seja, em um
map nunca iro haver dois elementos com a mesma chave. Tem como suas principais
implementaes as classes HashMap e TreeMap. A diferena entre elas similar
implementao das classes Hashset e TreeSet.

69

ATIVIDADES DA AULA 3
1. Implemente cdigo em Java que possua um ArrayList e insira 12 Strings nesta lista.
2. Crie um cdigo em Java que insira 30 mil nmeros numa ArrayList e pesquise-os.
Utilize o mtodo: System.currentTimeMillis() para cronometrar o tempo gasto.
(OBS: o mtodo System.currentTimeMillis() retorna um tipo long).
3. Faa 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 tm a coleo?
4. Faa 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 tm a coleo?
5. Adicione os nmeros 100, 20, 200, 30, 80, 40, 100, 200 a um List, percorra todos os
elementos utilizando um Iterator e calcule a mdia.
6. Adicione os nmeros 100, 20, 200, 30, 80, 40, 100, 200 a um Set, percorra todos os
elementos utilizando for-enhanced (for-each) e calcule a mdia.
7. Porque as mdias encontradas nos exerccios 5 e 6 ficaram diferentes?
8. Utilizando a classe Collections ordene a coleo criada no exerccio 1. Imprima
(System.out.println()) o resultado.

Interface Grfica em
JAVA

4
70

Aula

Ao final desta aula, voc dever ser


capaz de:
Entender

como

se

utilizam

os

componentes do pacore Swing;

Objetivos

Criar aplicaes simples e complexas


usando a interface grfica

Usar eventos de manipulao de


objetos grficos

71

4. Interface Grfica em JAVA


Introduo
Sempre ouvimos falar que aparncia tudo, no ? E em linguagens de programao
acontece o mesmo. Quando desenvolvemos aplicativos que outras pessoas iro usar,
precisaremos de uma interface grfica. Tambm, se desenvolvermos para ns mesmo, claro que
queremos uma interface grfica. Ela facilita muito a utilizao dos aplicativos.
Os aplicativos de linhas de comando so fracos, inflexveis e nem um pouco amigveis.
Neste captulo trabalharemos com GUIs(Graphic Users Interface) e aprenderemos mais
recursos-chave da Linguagem JAVA, entre eles a Manipulao de Eventos e as Classes
Internas.

4.1 Criando Aplicaes Grficas em JAVA:


Tudo ir comear com a criao 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
botes, caixas de seleo, campos de textos e assim por diante. O JFrame ter uma aparncia
diferente, dependendo da plataforma em que voc trabalha. Esse um objeto JFrame no
Windows 7:

Quando temos um JFrame, poderemos inserir elementos grficos nele adicionando-os ao


objeto. Existem vrios componentes do Swing que podemos adicionar; procure-os no pacote
javax.swing. Entre os mais comuns esto 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 fcil:

72

Linha 1: importaremos o pacote swing.


Linhas 6 e 7: criam respectivamente uma moldura e um boto, 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 no for
includa, o programa ficar eternamente na janela).
Linha 9: Adiciona o boto ao painel de contedo da moldura.
Linha 10: fornece um tamanho para a moldura, em pixels.
Linha 11: para concluir, torna-a visvel. Se esquecermos dessa etapa no veremos nada quando
executarmos esse cdigo.
Agora veremos o que acontece quando executamos o cdigo acima:

Podemos notar que o boto preencheu todo o espao da moldura. Mais a frente iremos
aprender a controlar onde (e com que tamanho) o boto ficar na moldura. Tambm vimos que
nada aconteceu quando cliquei nele, eis ento uma dvida: Como fazer o boto executar algo
especfico quando o usurio clicar nele?.
Vamos precisar de duas coisas:
1- Um mtodo a ser chamado quando o usurio clicar (o que voc quiser que ocorra
como resultado do clique no boto).
2- Uma maneira de saber quando acionar esse mtodo. Em outras palavras, uma
maneira de saber que o usurio clicou no boto.

73

4.2 Capturando um evento do usurio:


Se ns quisssemos que o texto do boto fosse alterado de me aperte para Eu fui
apertado quando o usurio pressionar o boto primeiro podemos criar um mtodo que altere o
texto do boto (com uma pequena pesquisa na API ns encontramos o mtodo):
public void changeIt(){
button.setText(Eu fui apertado);
}
Como saberemos quando esse mtodo deve ser executado? Quando saberemos quando o boto
foi clicado?
Em Java, esse processo de capturar e manipular eventos de usurios se chama
manipulao de evento. Existem muitos tipos diferentes de eventos em Java, embora a maioria
envolva aes de usurios em GUI. Se o usurio clicar em um boto, isso ser um evento. Um
evento que representa O usurio quer que a ao desse boto ocorra.
Em Java a origem de um evento um objeto que pode converter aes do usurio (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 vrias classes de eventos (fceis de
identificar todas tm Event no nome). Voc encontrar MouseEvent, KeyEvent,
WindowEvent, ActionEvent e muitas outras.
A origem de um evento (como o boto) cria um objeto de evento quando o usurio faz
algo de relevante (como clicar no boto). A maioria do cdigo 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 mtodos de implementao para cada mtodo da interface.
Algumas interfaces tm mais de um mtodo, porque o prprio evento tem diferentes
verses. Se voc implementar MouseListener, por exemplo, poder capturar eventos de
mousePressed, mouseReleased, mouseMoved, etc. Cada um desses eventos de mouse tem um
mtodo separado na interface, ainda que todos sejam um MouseEvent. Se voc implementar
MouseListener, o mtodo mousePressed() ser chamado quando o usurio pressionar o boto
do mouse. E quando o usurio o soltar o mtodo mouseReleased() ser chamado.
Capturando o ActionEvent de um Boto:
1 Implemente a Interface ActionListener
2 Registre-se no boto (informe a ele que voc quer escutar os eventos)
3 Defina o mtodo de manipulao de eventos ( implemente o mtodo actionPerformed() da
interface ActionListener)

74

Linha 02: Uma nova instruo de importao para o pacote no qual ActionListener e
ActionEvent esto.
Linha 04: Implementa a interface. Isso quer dizer que uma instancia da SimpleGui1B um
ActionListener. O boto fornecer eventos somente para quem implementar ActionListener.
Linha 14: Registre seu interesse junto ao boto. Isto dir ao boto 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 mtodo actionPerformed() da interface ActionListener. Esse
realmente o mtodo de manipulao de eventos; O boto chamar esse mtodp para permitir
que voc saiba que um evento ocorreu. Ele lhe enviar um objeto ActionEvent como
argumento, mas no precisaremos dele. Saber que o evento ocorreu o bastante para ns.
O resultado desse cdigo ficaria assim:

75

4.3 Ouvintes, origens e Eventos:


A tarefa do ouvinte capturar o evento, ou seja, ele vai implementar a interface,
registrar-se no boto e fornecer a manipulao de eventos.
J a tarefa da origem do evento aceitar registros (dos ouvintes), capturar eventos do
usurio e chamar o mtodo de manipulao de eventos do ouvinte (quando o usurio clicar
nele).

4.4 Mais um pouco de parte grfica:


Agora que aprendemos um pouco mais de como os eventos funcionam (veremos um
pouco mais posteriormente) voltaremos a insero de elementos na tela. Passaremos algum
tempo examinando algumas maneiras divertidas de usar um ambiente grfico, antes de
retornarmos a manipulao de eventos.
Existem trs maneiras de inserir elementos em sua GUI:
1 Insira elementos grficos em uma moldura: Adicione botes, menus, botes de rdio, etc. O
pacote javax.swing tem vrios tipos de elementos grficos.
2 Desenhe figuras 2D em um elemento grfico: Use um elemento grfico para desenhar
formas.
graphics.fillOval(70,70,100,100);
Voc pode desenhar muitas outras caixas e crculos, o API Java2D est cheia de mtodos
grficos divertidos e sofisticados.
3 Insira uma figura JPEG em um elemento grfico: Voc pode inserir suas prprias fotos em
um elemento grfico.
graphics.drawImage(minhaimagem, 10,10,this);

4.5 Criando seu prprio elemento grfico de desenho:


Quando queremos inserir figuras na tela, a melhor opo criar o nosso prprio
elemento grfico de desenho. Ns inseriremos esse elemento grfico na moldura, da mesma
forma que um boto ou qualquer outro elemento, mas quando ele for exibido ter nossas
figuras.
Todos os nossos elementos grficos sero inseridos no mtodo paintComponent(). Ele
um mtodo chamado pelo sistema que faz com que o elemento grfico receba desenhos. Se
quisermos desenhar um retangulo, o mtodo paintComponent() ser chamado e seu circulo
aparecer.

76

Linha 04:Cria uma subclasse de JPanel, um elemento grfico que adicionaremos a uma
moldura como qualquer outra coisa. Exceto por ser seu prprio elemento grfico personalizado.
Linha 09: Esse o importantssimo mtodo grfico. Voc nunca o chamar por sua prpria
conta. O sistema o chamar e dir: Aqui est uma superfcie de desenho nova em folha, de
tipo Graphics, na qual voc pode desenhar agora.
Linhas 10 e 11: Suponhamos que g fosse uma mquina 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 execuo desse cdigo seria esse:

77

4.6 Exibindo uma figura JPEG em um painel:

O resultado da execuo desse cdigo 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
grficos em uma GUI Java. Eles executaro vrias tarefas por voc, que nem sempre gostar
dos resultados. Voc pode querer dois botes do mesmo tamanho, o que eles no tero. Pode
querer que o campo de texto tenha 9 centmetros, mas ele ter 12, e esteja abaixo do rtulo e
no ao lado dele.
Componentes do Swing:
Componente o termo mais correto para o que chamamos at agora de elemento
grfico. As coisas que voc vai inserir numa GUI. As coisas que um usurio ver e com as

78
quais interagir. Campos de texto, botes, listas rolveis, botes de rdio, etc. so 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 interao com o usurio como botes
listas em componentes de plano de fundo como molduras e painis. Embora seja possvel
inserir um painel dentro de um boto, mas isso seria muito estranho.
Gerenciadores de Layout:
Um Gerenciador de Layout um objeto Java associado a um componente especfico,
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 boto, o gerenciador de layout do painel controlar o tamanho e a
insero do boto, enquanto o gerenciador de layout da moldura controlar o tamanho e a
insero do painel. Para adicionar um determinado componente em um painel, por exemplo,
devemos escrever algo como:
meuPainel.add(button);
Os gerenciadores de layout vm em vrias verses, e cada componente de plano de
fundo pode ter seu prprio gerenciador de layout. Os gerenciadores de layout tm suas prprias
polticas a seguir quando constroem um layout.
Como um gerenciador de Layout decide?
Diferentes gerenciadores tem polticas distintas para a organizao 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 tero pelo menos
alguma pequena influncia na questo. Geralmente, o processo de dispor um componente de
plano de fundo semelhante ao descrito a seguir:
Um cenrio de layout:
1 Crie um painel e adicione trs botes a ele.
2 O gerenciador de layout do painel perguntar a cada boto que tamanho ele prefere ter.
3 O gerenciador de layout do painel usar suas polticas de layout para decidir se deve
respeitar todas, parte ou nenhuma das preferncias dos botes.
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 polticas de layout para decidir se deve
respeitar todas, parte ou nenhuma das preferncias do painel.
Existem trs grandes gerenciadores de layout que so: limite, fluxo e caixa. Abaixo
vamos explicar cada um deles:
BorderLayout: divide um componente de plano de fundo em cinco regies. Voc s poder
adicionar um componente por regio a um plano de fundo controlado por um gerenciador
BorderLayout. Os componentes dispostos por esse gerenciador geralmente no conseguem ter
seu tamanho preferido. Border Layout o gerenciador de layout padro 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 so dispostos da esquerda para
a direita na ordem que so adicionados, com a mudana automtica de linha ativada.
Portanto, quando um componente no couber horizontalmente, ele passar para a linha
seguinte do Layout. FlowLayout o layout padro para um painel.

79
BoxLayout: como o FlowLayout pelo fato de cada componente ter seu prprio tamanho e
pelos componentes serem inseridos na ordem em que so adicionados. Mas, diferente do
FlowLayout, um gerenciador BoxLayout pode emplilhar os componentes verticalmente (ou
horizontalmente, mas em geral s nos preocupamos com a disposio vertical). como
FlowLayout, mas em vez de ter a mudana do componente para a outra linha
automaticamente, voc poder inserir um tipo de tecla return de componentes e for-los a
comear em uma nova linha.
BorderLayout leva em considerao cinco regies: leste, oeste, norte, sul e centro. Veja
como fcil us-lo:

Quando executarmos o cdigo acima o resultado ser este:

O BoxLayout manter os componentes empilhados, mesmo se houver espao para


inseri-los lado a lado. O cdigo ficaria assim:

80

Depois de executado esse cdigo o resultado ser esse:

E se no quisermos utilizar os gerenciadores de layout? Como faremos? Abaixo tem o


cdigo mostrando como podemos fazer:

81

Quando utilizamos um Layout Nulo temos que informar em qual localizao os


componentes devem ficar, o que torna nosso processo de desenvolvimento de aplicaes
grficas um pouco mais complexo, pois temos que nos preocupar com todos os componentes,
enquanto quando utilizamos os gerenciadores de layouts no nos preocupamos com isto.
O resultado do cdigo acima seria o seguinte:

82

4.8 Testando os componentes do Swing


Voc aprendeu os aspectos bsicos 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 seleo e a lista. No mostraremos a API inteiro de cada um, apenas alguns
destaques como introduo.
JTextField

Construtores:
JTextField Field = new JTextField(20);
20 significa 20 colunas e no 20 pixels. Isso define a largura preferida do campo de
texto.
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 usurio 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 usurio possa comear a digitar).
field.requestFocus();
JTextArea

83
Diferente do JTextField, JTextArea pode ter mais de uma linha de texto. preciso
algum esforo de configurao em sua criao, porque ele no vem com barras de rolagem ou
quebra de linha. Para fazer um JTextArea rolar, voc ter que inseri-lo em um ScrollPane. Um
ScrollPane um objeto que aprecia muito rolar e se encarregar das necessidades de rolagem
da rea de texto.
Contrutores:
JTextArea text = new JTextArea(10,20);
10 significa 10 linhas (configura a altura) e 20 significa 20 colunas (configura a largura)
Como us-lo:
1- Faa com que ele tenha somente uma barra de rolagem vertical.
JScrollPane scroller = new JScrollPane(text);
Cria um JScrollPane e lhe fornece a rea de texto para a qual ele rolar.
text.setLineWrap(true);
scroller.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR
_ALWAYS);
scroller.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROL
LBAR_NEVER);
Informa ao painel de rolagem para usar somente uma barra de rolagem vertical.
painel.add(scroller);
Importante! Voc fornecer a rea de texto ao painel de rolagem (atravs do construtor
do painel de rolagem) e, em seguida, adicionar o painel de rolagem ao painel geral. Voc no
pode adicionar a rea de texto de rolagem diretamente ao painel geral;
2- Substitua o texto existente:
text.settext(Texto substitudo);
3- Acrescente algo ao texto existente:
text.append(Acrescentando texto);
4- Selecione/realce o texto no campo:
text.selectAll();
5- Posicione o cursor no campo (para que o usurio possa comear a digitar):
text.requestFocus();
JCheckBox

84

Construtores:
JCheckBox check = new JCheckBox(Eu sou um Check Box);
Como us-lo:
1- Escute o evento de um item (quando ele for selecionado ou desmarcado).
check.addItemListener(this);
2- Manipule o evento (e descubra se ele foi ou no selecionado).
Public void itemStateChanged(ItemEvent ev) {
String onOrOff = off;
If (check.isSelected()) onOrOff = on;
System.out.println(Check Box est + onOrOff);
}
3- Selecione ou desmarque-o em cdigo.
check.setSelected(true);
check.setSelected(true);
JList

Construtores:
String [] listEntries = {"Alfa", "Beta","Gama","Delta"};
JList list = new JList(listEntries);
O construtor de JList usa uma matriz de qualquer tipo de objeto. Eles no tm que ser
Strngs, mas a representao de uma String aparecer na lista.
Como us-lo:
1- Faa como que ele tenha uma barra de rolagem vertical.
JScrollPane scroller = new JScrollPane(list);
scroller.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR
_ALWAYS);
scroller.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROL
LBAR_NEVER);
panel.add(scroller);

85
Isso o mesmo que ocorre com o JTextArea voc criar um JScrollPane ( e o
fornecer lista) para em seguida adicionar o painel de rolagem (e no a lista) ao
painel geral.
2- Configure a quantidade de linhas a serem exibidas antes da rolagem.
List.setVisibleRowCount(4);
3- Restrinja o usurio seleo de somente uma coisa de cada vez.
List.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
4- Registre-se para ouvir eventos de seleo na lista.
List.addListSelectionListener(this);
5- Manipule eventos (descubra o que foi selecionado na lista).
Public void valueChanged(ListSelectionEvent lse) {
If (! Lse.getValueIsAdjusting()) {
String selection = (String)
List.getSelectedValue();
System.out.println(selection);
}
}

86

RESUMO DA AULA 4
Nesta aula podemos aprender como usar a interface grfica JAVA usando a biblioteca
Swing. Aprendemos como inserir componentes (objetos grficos) usando seus construtores e
tambm aprendemos como organizar esses componentes utilizando os Gerenciadores de
Layout.
Aprendemos nesta aula tambm como manipular alguns eventos dos componentes e
assim podendo criar aplicaes mais dinmicas e de fcil manipulao.

87

EXERCCIOS DA AULA 4
1 Faa um programa que leia um valor e a cotao do dlar e o converta na moeda
especificada: dlar ou real.
2 Faa um programa para ler o nome e o sexo do usurio e apresentar a seguinte mensagem:
Boa noite Senhor [nome] ou Boa Noite Senhora [nome] dependendo do sexo.
3 Faa um programa que leia um valor inteiro e decomponha-o usando a menor quantidade
possvel de notas em reais e centavos.
4 Faa um programa simples de converso de temperaturas (Kelvin, Celcius, Fahrenheit)

JAVA COM BANCO DE


DADOS

5
88

Aula

Ao final desta aula, voc dever ser


capaz de:

Objetivos

Conectar qualquer Banco de Dados


com JAVA

Manipular

um

Banco

de

Dados

atravs de comandos JAVA e Sql,


dentro de uma aplicao JAVA.

89

5. Java com Banco de Dados


Uma funcionalidade essencial em qualquer sistema a habilidade para comunicar-se
com um repositrio de dados. Podemos definir repositrio de dados de vrias maneiras, por
exemplo, como um pool de objetos de negcio num ORB ou um banco de dados. Bancos de
dados constituem o tipo mais comum de repositrio. Java dispe de uma API para acessar
repositrios de dados: a Java DataBase Connectivity API ou JDBC API.
A JDBC implementa em Java a funcionalidade definida pelo padro SQL Call Level
Interface ou SQLCLI. Um outro exemplo de API que implementa o SQL Call Level Interface
o popularssimo ODBC das plataformas Wintel. A maioria dos fornecedores de bancos de
dados oferece uma implementao particular de SQLCLI. A vantagem de JDBC a
portabilidade da aplicao cliente, inerente da linguagem Java. A especificao corrente da
JDBC API a 2.1.
A JDBC compreende uma especificao para ambos: os desenvolvedores de drivers
JDBC e os desenvolvedores de aplicaes clientes que precisem acessar bancos de dados em
Java. Estaremos dando uma olhada no desenvolvimento de aplicaes em Java, ento, uma
boa idia comear com o suporte de dados.
Existem 4 tipos de diferentes de drivers JDBC (para uma lista de fornecedores por
especificao e tipo, vide http://www.javasoft.com/products/jdbc/drivers.html ):
- Uma vez que ODBC uma especificao padro do mundo Wintel, o tipo 1 um
driver de ponte entre Java e ODBC. O driver de ponte mais conhecido o fornecido pela Sun o
JDBC-ODBC bridge. Este tipo de driver no portvel, pois depende de chamadas a funes
de ODBC implementadas em linguagem C e compiladas para Wintel, ou outra plataforma
ODBC compatvel, as chamadas funes nativas.
- O driver tipo 2 implementado parcialmente em Java e parcialmente atravs de
funes nativas que implementam alguma API especfica do fornecedor de banco de dados.
Este tipo faz o que se chama de wrap-out, ou seja, prov uma interface Java para uma API
nativa no-Java.
- O tipo 3 um driver totalmente Java que se comunica com algum tipo de middleware
que ento se comunica com o banco de dados
- O tipo 4 um driver totalmente Java que vai diretamente ao banco de dados.
Veremos a seguir como acessar um banco de dados atravs de JDBC. Nosso cenrio
bsico uma pequena aplicao de controle dos meus CDs (clssica !) implementada em algum
xBase compatvel.
Para utilizarmos a JDBC num programa em Java, precisamos declarar o pacote que
contm a JDBC API:

90
Acessando bancos de dados em JDBC
import java.sql.*;

A primeira coisa a fazer estabelecer uma conexo com o banco de dados. Fazemos
isso em dois passos: primeiro carregamos o driver para o banco de dados na JVM da aplicao
(1). Uma vez carregado, o driver se registra para o DriverManager e est disponvel para a
aplicao. Utilizamos ento a classe DriverManager para abrir uma conexo com o banco de
dados (2). A interface Connection designa um objeto, no caso con, para receber a conexo
estabelecida:
# try //A captura de excees SQLException em Java obrigatria para usarmos JDBC.
# {
#
// Este um dos meios para registrar um driver
#
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").getInstance();
#
#
// Registrado o driver, vamos estabelecer uma conexo
#
Connection con = DriverManager.getConnection("jdbc:odbc:meusCdsDb","conta","senha");
# }
# catch(SQLException e)
# {
#
// se houve algum erro, uma exceo gerada para informar o erro
#
e.printStackTrace(); //vejamos que erro foi gerado e quem o gerou
# }

Estabelecida a conexo, podemos executar comandos SQL para o banco de dados.


Vejamos como realizar uma consulta sobre o ttulo, numero de faixas e o artista de cada CD no
banco de dados. Podemos usar 3 interfaces para executar comandos SQL no banco de dados. A
primeira delas a interface Statement, que permite a execuo dos comandos fundamentais de
SQL (SELECT, INSERT, UPDATE ou DELETE). A interface PreparedStatement nos permite
usufruir de SQL armazenado ou pr-compilado no banco, quando o banco de dados suportar
este recurso. A terceira interface CallableStatement, e permite executar procedimentos e
funes armazenados no banco quando o banco suportar este recurso. Vejamos como utilizar a
interface Statement.
#
#
#
#
#
#

// Aps estabelecermos a conexo com o banco de dados


// Utilizamos o mtodo createStatement de con para criar o Statement
Statement stm = con.createStatement();
// Vamos executar o seguinte comando SQL :
String SQL = "Select titulo, autor, total_faixas from MeusCDs";

A interface ResultSet permite colher os resultados da execuo de nossa query no banco


de dados. Esta interface apresenta uma srie de mtodos para prover o acesso aos dados:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

// Definido o Statement, executamos a query no banco de dados


ResultSet rs = stm.executeQuery(SQL);
// O mtodo next() informa se houve resultados e posiciona o cursor do banco
// na prxima linha disponvel para recuperao
// Como esperamos vrias linhas utilizamos um lao para recuperar os dados
while(rs.next())
{
// Os mtodos getXXX recuperam os dados de acordo com o tipo SQL do dado:
String tit = rs.getString("titulo");
String aut = rs.getString("autor");
int totalFaixas = rs.getInt("total_faixas");

91
13.
14.
// As variveis tit, aut e totalFaixas contm os valores retornados
15.
// pela query. Vamos imprim-los
16.
17.
System.out.println("Titulo: "+tit+" Autor: "+aut+" Tot. Faixas: "+totalFaixas);
18. }

E nosso acesso est terminado. O importante agora liberar os recursos alocados pelo
banco de dados para a execuo deste cdigo. Podemos fazer isso fechando o Statement, que
libera os recursos associados execuo desta consulta mas deixa a conexo aberta para a
execuo de uma prxima consulta, ou fechando diretamente a conexo, que encerra a
comunicao com o banco de dados. Para termos certeza de que vamos encerrar esta conexo
mesmo que uma exceo ocorra, reservamos o fechamento para a clusula finally() do
tratamento de excees.
1. finally
2. {
3.
try
4.
{
5.
con.close();
6.
}
7.
catch(SQLException onConClose)
8.
{
9.
System.out.println("Houve erro no fechamento da conexo");
10.
onConClose.printStackTrace();
11.
}
12. }

Uma classe para listar uma tabela


Vamos colocar tudo isso em conjunto para termos uma viso em perspectiva:
# package wlss.jdbcTutorial;
#
# import java.sql.*;
#
# class Exemplo1
# {
#
#
public static void main(String args[])
#
{
#
#
#
// A captura de excees SQLException em Java obrigatria para usarmos JDBC.
#
// Para termos acesso ao objeto con, ele deve ter um escopo mais amplo que o bloco try
#
#
Connection con = null;
#
#
try
#
{
#
// Este um dos meios para registrar um driver
#
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").getInstance();
#
#
// Registrado o driver, vamos estabelecer uma conexo
#
con = DriverManager.getConnection("jdbc:odbc:meusCdsDb","conta","senha");

92
#
#
// Aps estabelecermos a conexo com o banco de dados
#
// Utilizamos o mtodo createStatement de con para criar o Statement
#
Statement stm = con.createStatement();
#
#
// Vamos executar o seguinte comando SQL :
#
String SQL = "Select titulo, autor, total_faixas from MeusCDs";
#
#
// Definido o Statement, executamos a query no banco de dados
#
ResultSet rs = stm.executeQuery(SQL);
#
#
// O mtodo next() informa se houve resultados e posiciona o cursor do banco
#
// na prxima linha disponvel para recuperao
#
// Como esperamos vrias linhas utilizamos um lao para recuperar os dados
#
while(rs.next())
#
{
#
#
// Os mtodos getXXX recuperam os dados de acordo com o tipo SQL do dado:
#
String tit = rs.getString("titulo");
#
String aut = rs.getString("autor");
#
int totalFaixas = rs.getInt("total_faixas");
#
#
// As variveis tit, aut e totalFaixas contm os valores retornados
#
// pela query. Vamos imprim-los
#
#
System.out.println(48:"Titulo: "+tit+" Autor: "+aut+"49:
Tot. Faixas:
"+totalFaixas);
#
}
#
#
}
#
catch(SQLException e)
#
{
#
// se houve algum erro, uma exceo gerada para informar o erro
#
e.printStackTrace(); //vejamos que erro foi gerado e quem o gerou
#
}
#
finally
#
{
#
try
#
{
#
con.close();
#
}
#
catch(SQLException onConClose)
#
{
#
System.out.println("Houve erro no fechamento da conexo");
#
onConClose.printStackTrace();
#
}
#
} // fim do bloco try-catch-finally
#
} // fim da main
#
# } // fim de nosso exemplo !

93

RESUMO DA AULA 5

Nesta aula podemos aprender como criar uma conexo com um Banco de Dados qualquer
e como manipul-lo atravs de algumas bibliotecas e comandos da Linguagem JAVA.
Utilizando esses conceitos e aplicae podemos conseguir conectar uma aplicao JAVA com
qualquer banco de dados.

94

EXERCCIOS DA AULA 5

1) Usando os conceitos de interface grfica e de acesso a banco de dados, crie uma


aplicao que verifique e crie uma conexo com um banco de daos qualquer usando um
boto e uma JLabel para informar se a conexo foi ou no bem sucedida.

95

BIBLIOGRAFIA
SANTOS, Rafael. Introduo Programao Orientada Objetos Usando Java. Rio de
Janeiro: Elsevier, 2003.
HORSTMANN, Cay. Big Java. Porto Alegre: Bookman, 2004.
BARNES, David J; KLLING, Michael. Programao Orientada A Objetos Com Java:
uma introduo prtica usando o BLUEJ. Pearson Education, 2004 .
MENDES, Douglas Rocha. Programao Java com nfase em Orientao Objetos. So
Paulo: Novatec Editora, 2009.
FJ-11: Java e Orientao Objetos. www.caelum.com.br.
KATHY SIERRA ET AL. Use a Cabea: Java. Alta Books, 2007

96

ANEXOS

97
RESPOSTAS
AULA4
Resoluo Exercicio 1:
1 //importao das classes necessrias
2 //layouts para alinhamento dos componentes
3 import java.awt.FlowLayout;
4 import java.awt.GridLayout;
5 //Evento para de ouvir um evento do boto
6 import java.awt.event.ActionListener;
7 //Evento de executar uma ao do evento que foi ouvido(ativado)
8 import java.awt.event.ActionEvent;
9 //para insero de textos ou imagens
10 import javax.swing.JLabel;
11 //campo para insero de valores ou caracteres
12 import javax.swing.JTextField;
13 //botes de marcar
14 import javax.swing.JRadioButton;
15 //grupo de boto para tornar o JRadioButton de seleo exclusiva
16 import javax.swing.ButtonGroup;
17 //boto
18 import javax.swing.JButton;
19 //Tela
20 import javax.swing.JFrame;
21 //painel que permite anexar outros a mesma
22 import javax.swing.JPanel;
23
24 //Criao da classe EX1 extendendo a classe JFrame que foi importada
25 public class Ex1 extends JFrame
26 {
27 //criao de duas variveis do tipo double
28 double r,d,resultado;
29
30 //Criao de um boto de nome botao
31 private JButton botao = new JButton("Converter");
32 //criao de label's com valores pr-configurados de texto
33 private JLabel resposta = new JLabel("");
34 private JLabel textc1 = new JLabel("Valor inicial:");
35 private JLabel textc2 = new JLabel("Cotao do dlar:");
36 private JLabel text1 = new JLabel("Moeda");
37 private JLabel text2 = new JLabel("Converte p/");
38
39 //criao de campos com valores vazios e 3 de largura
40 private JTextField real = new JTextField("0",3);
41 private JTextField dolar = new JTextField("0",3);
42
43 //criao do FlowLayout que alinha componentes da esquerda para a direita.
44 private FlowLayout flowLayout = new FlowLayout();
45 /*criao de GridLayout com 5 linhas e 2 colunas com 10 de espao em largura
46 e 1 de altura*/
47 private GridLayout gridLayout1 = new GridLayout(5,2,10,1);
48 /*criao de GridLayout2 com 2 linhas e 1 coluna */
49 private GridLayout gridLayout2 = new GridLayout(2,1,10,1);
50
51 //criao de dois paineis
52 private JPanel gridJPanel1 = new JPanel();
53 private JPanel gridJPanel2 = new JPanel();
54
55 //criao de 4 JRadioButton com todos desmarcados (false)
56 private JRadioButton r1 = new JRadioButton("Real",false);
57 private JRadioButton d1 = new JRadioButton("Dlar",false);
58 private JRadioButton r2 = new JRadioButton("Real",false);
59 private JRadioButton d2 = new JRadioButton("Dlar",false);
60
61 //criao do grupo de seleo exclusiva
62 private ButtonGroup radioGroup1 = new ButtonGroup();
63 private ButtonGroup radioGroup2 = new ButtonGroup();
64
65 //Mtodo construtor da classe EX1 sem argumentos
66 public Ex1()
67 {
68
//ttulo da janela

98
69
super("Converso de moeda");
70
//alinhamento do frame com o uso do objeto flowLayout
71
super.setLayout(flowLayout);
72
/*adicionando dois botes JRadioButton d1 e d2,respectivamente ao radioGroup1
73
para sejam de seleo exclusiva entre os mesmos, ou seja, ao selecionar um
74
o outro se estiver marcado automaticamente desmarcado */
75
radioGroup1.add(r1);
76
radioGroup1.add(d1);
77
78
//da mesma forma sendo em radioGroup2
79
radioGroup2.add(r2);
80
radioGroup2.add(d2);
81
82
//pegando o painel2 recem criado de nome gridJPanel2 e configurando o seu layout
83
gridJPanel2.setLayout(gridLayout2);
84
//adicionando 2 componentes em gridJPanel2
85
gridJPanel2.add(botao);
86
gridJPanel2.add(resposta);
87
88
//pegando o painel1 recem criado de nome gridJPanel1 e configurando o seu layout
89
gridJPanel1.setLayout(gridLayout1);
90
//adicionando 10 componentes em gridJPanel1
91
gridJPanel1.add(textc1);
92
gridJPanel1.add(real);
93
gridJPanel1.add(textc2);
94
gridJPanel1.add(dolar);
95
gridJPanel1.add(text1);
96
gridJPanel1.add(text2);
97
gridJPanel1.add(r1);
98
gridJPanel1.add(r2);
99
gridJPanel1.add(d1);
100
gridJPanel1.add(d2);
101
102
//adicionando a janela principal
103
super.add(gridJPanel1);
104
super.add(gridJPanel2);
105
106
//Criando um objeto registroB da classe RegistroButao para o boto
107
RegistroButao registroB = new RegistroButao();
108
//adicionando ao mtodo ActionListener
109
botao.addActionListener(registroB);
110
111 }//Fim do contrutor sem argumentos
112 //criando a classe RegistroButao responsvel e implementada com o ouvinte
113 //ActionListener
114 private class RegistroButao implements ActionListener
115 {
116
public void actionPerformed(ActionEvent event)
117
{
118
/*pega o valor do campo1 e converte para double atribuindo logo em
119
seguida a varivel r(real) */
120
r=Double.parseDouble(real.getText());
121
/*pega o valor do campo2 e converte para double atribuindo logo em
122
seguida a varivel d(dlar) */
123
d=Double.parseDouble(dolar.getText());
124
//Se ambos Jradio de reais ou dolares forem marcados, faa
125
if(((r1.isSelected()==true)&&(r2.isSelected()==true))||((d1.isSelected()==true)&&
126
(d2.isSelected()==true)))
127
{
128
129
resultado=r;
130
}
131
//Se um Jradio marcado for real e o outro dolar, faa
132
if((r1.isSelected()==true)&&(d2.isSelected()==true))
133
{
134
135
resultado=r/d;
136
}
137
//Se um Jradio marcado for dolar e o outro real, faa
138
if((d1.isSelected()==true)&&(r2.isSelected()==true))
139
{
140
141
resultado=r*d;
142
}
143
resposta.setText(String.format("Valor US$: %.3f",resultado));
144
}//Fim do mtodo ActionPerformed
145 }//Fim da classe interna RegistroButao

99
146 }//Fim da classe principal Ex1
1 //JFrame classe responsvel por exibir a janela
2 import javax.swing.JFrame;
3
4 //Main - Nome da classe
5 public class Main
6{
7 //Comando principal para execuo do programa
8 public static void main(String[] args)
9 {
10
//Criao de um objeto ex da classe Ex1
11
Ex1 ex = new Ex1();
12
//incluso dos componentes de maximinizar, miniminizar e fechar
13
ex.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14
//tamanho da tela
15
ex.setSize(250,230);
16
//posio da tela ao abri-la
17
ex.setLocation(400,300);
18
//tornando a tela visvel
19
ex.setVisible(true);
20 }
21 }

Resoluo Exerccio 2:
1 //importao das classes necessrias
2 //layout para alinhamento dos componentes
3 import java.awt.FlowLayout;
4 //Evento para de ouvir um evento do boto
5 import java.awt.event.ActionListener;
6 //Evento de executar uma ao do evento que foi ouvido(ativado)
7 import java.awt.event.ActionEvent;
8 //insero de texto e/ou imagem
9 import javax.swing.JLabel;
10 //campo para insero de valores ou caracteres
11 import javax.swing.JTextField;
12 //botes de marcar
13 import javax.swing.JRadioButton;
14 //grupo de boto para tornar o JRadioButton de seleo exclusiva
15 import javax.swing.ButtonGroup;
16 //buto
17 import javax.swing.JButton;
18 //janela
19 import javax.swing.JFrame;
20 //painel
21 import javax.swing.JPanel;
22
23 //Criao da classe EX6 extendendo a classe JFrame que foi importada
24 public class Ex6 extends JFrame
25 {
26 //criao de uma varivel nome do tipo string
27 private String nome;
28 //criao do boto exibir mensagem
29 private JButton botao = new JButton("Exibir mensagem");
30 //criao das label's
31 private JLabel texto = new JLabel("Nome:");
32 private JLabel resposta = new JLabel();
33 //criao do campo com 10 espaos
34 private JTextField campo = new JTextField("",10);
35 //criao do FlowLayout que alinha componentes da esquerda para a direita.
36 private FlowLayout flowLayout = new FlowLayout();
37 //criao de 2 JRadioButton com todos desmarcados (false)
38 private JRadioButton s1 = new JRadioButton("Masculino",false);
39 private JRadioButton s2 = new JRadioButton("Feminino",false);
40 //criao do grupo de seleo exclusiva
41 private ButtonGroup radioGroup = new ButtonGroup();
42 //Mtodo construtor da classe EX6 sem argumentos
43 public Ex6()
44 {
45
//ttulo da janela
46
super("Apresentao");
47
//alinhamento do frame com o uso do objeto flowLayout
48
super.setLayout(flowLayout);
49
/*adicionando dois botes JRadioButton s1 e s2,respectivamente ao radioGroup
50
para sejam de seleo exclusiva entre os mesmos, ou seja, ao selecionar um
51
o outro se estiver marcado automaticamente desmarcado */
52
radioGroup.add(s1);
53
radioGroup.add(s2);
54
55
//adicionando a janela principal

100
56
super.add(texto);
57
super.add(campo);
58
super.add(s1);
59
super.add(s2);
60
super.add(botao);
61
super.add(resposta);
62
63
//Criando um objeto registroB da classe RegistroButao para o boto
64
RegistroButao registroB = new RegistroButao();
65
//adicionando ao mtodo ActionListener
66
botao.addActionListener(registroB);
67
68 }//Fim do contrutor sem argumentos
69 //criando a classe RegistroButao responsvel e implementada com o ouvinte
70 //ActionListener
71
72 private class RegistroButao implements ActionListener
73 {
74
public void actionPerformed(ActionEvent event)
75
{
76
//Se s1 for selecionado (true) exibe uma mensagem
77
if(s1.isSelected()==true)
78
{
79
//pega o valor do campo e armazena na varivel nome
80
nome=(campo.getText());
81
//configura a label resposta com um novo valor
82
resposta.setText("Sejas bem Vindo Senhor "+nome);
83
}
84
//caso contrrio, se s2 for selecionado (true) exibe uma mensagem
85
else if(s2.isSelected()==true)
86
{
87
nome=(campo.getText());
88
resposta.setText("Sejas bem Vindo Senhorita "+nome);
89
}
90
}//Fim do mtodo ActionPerformed
91 }//Fim da classe interna RegistroButao
92 }//Fim da classe Ex6
1 //JFrame classe responsvel por exibir a janela
2 import javax.swing.JFrame;
3
4 //Main - Nome da classe
5 public class Main
6{
7 //Comando principal para execuo do programa
8 public static void main(String[] args)
9 {
10
//Criao de um objeto ex da classe Ex6
11
Ex6 ex = new Ex6();
12
//incluso dos componentes de maximinizar, miniminizar e fechar
13
ex.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14
//tamanho da tela
15
ex.setSize(250,150);
16
//posio da tela ao abri-la
17
ex.setLocation(400,300);
18
//tornando a tela visvel
19
ex.setVisible(true);
20 }
21 }

Resoluo Exerccio 3:
1 //importao das classes necessrias
2 //layouts para alinhamento dos componentes
3 import java.awt.FlowLayout;
4 import java.awt.GridLayout;
5 //Evento para de ouvir um evento do boto
6 import java.awt.event.ActionListener;
7 //Evento de executar uma ao do evento que foi ouvido(ativado)
8 import java.awt.event.ActionEvent;
9 //insero de texto e/ou imagem
10 import javax.swing.JLabel;
11 //campo para insero de valores ou caracteres
12 import javax.swing.JTextField;
13 //janela
14 import javax.swing.JFrame;
15 //painel
16 import javax.swing.JPanel;
17
18 public class Ex8 extends JFrame
19 {
20 //criao de um array troco e dinheiro do tipo double e int j com seus valores configurados
21 double troco[] = {100,50,20,10,5,2,1,0.50,0.25,0.10,0.05,0.01};
22 int dinheiro[]= { 0, 0, 0, 0, 0,0,0,0, 0, 0, 0, 0, 0};
23 //criao de uma varivel valor do double
24 double valor;
25 //criao de uma varivel ind do inteiro

101
26 int ind;
27 //criao de string's j com seus valores configurados como nulos
28 String resultado="";
29 String zero="";
30
31 //criao das label's
32 private JLabel texto = new JLabel("Digite o valor para o troco");
33 private JLabel resposta = new JLabel();
34 //criao de um campo com 20 espaos
35 private JTextField campo = new JTextField("",20);
36
37 //criao do FlowLayout que alinha componentes da esquerda para a direita.
38 private FlowLayout flowLayout = new FlowLayout();
39 /*criao de GridLayout com 3 linhas e 1 coluna com 10 de espao em largura
40 e 1 de altura*/
41 private GridLayout gridLayout = new GridLayout(3,1,10,1);
42 //criao de um painel
43 private JPanel gridJPanel = new JPanel();
44 //Mtodo construtor da classe EX8 sem argumentos
45 public Ex8()
46 {
47
//ttulo da janela
48
super("Troco");
49
//alinhamento do frame com o uso do objeto flowLayout
50
super.setLayout(flowLayout);
51
52
//pegando o painel recem criado de nome gridJPanel e configurando o seu layout
53
gridJPanel.setLayout(gridLayout);
54
//adicionando componentes ao mesmo
55
gridJPanel.add(texto);
56
gridJPanel.add(campo);
57
gridJPanel.add(resposta);
58
59
//adicionando a janela principal
60
super.add(gridJPanel);
61
62
//Criando um objeto registroc da classe RegistroCampo para o campo
63
RegistroCampo registroC = new RegistroCampo();
64
//adicionando ao mtodo ActionListener
65
campo.addActionListener(registroC);
66
67 }//Fim do contrutor sem argumentos
68 //criando a classe RegistroCampo responsvel e implementada com o ouvinte
69 //ActionListener
70
71 private class RegistroCampo implements ActionListener
72 {
73
public void actionPerformed(ActionEvent event)
74
{
75
//se prescionado a tecla enter sobre o campo
76
if(event.getSource()==campo)
77
{
78
resultado="";
79
//pega e converte os caracteres em double do campo para a vairvel valor
80
valor=Double.parseDouble(campo.getText());
81
//inicia um lao de repetio
82
for(ind=0; ind<=11; ind++)
83
{
84
//se a diviso de valor e troco for maior do que 1 faa
85
if ((valor/troco[ind])>=1);
86
{
87
//pega o valor da diviso e armazena no array dinheiro
88
//convertendo explicitamente o valor para inteiro (int)
89
dinheiro[ind]=(int)(valor/troco[ind]);
90
valor=valor%troco[ind]+0.0000001;
91
}
92
//se no array dinheiro na posio int for maior ou igual a 1 faa
93
if (dinheiro[ind]>=1)
94
{
95
//se troco na posio ind for 0.5 ou 0.1 atribua zero a varivel zero
96
if ((troco[ind]==0.5) || (troco[ind]==0.1))
97
zero="0";
98
else
99
zero="";
100
//atribua o resultado a varivel resultado
101
resultado=resultado+(int)dinheiro[ind]+"-"+troco[ind]+zero+" ";
102
}
103
}
104
//Configure o valor da label resposta com a variavel resultado
105
resposta.setText(resultado);
106
}
107
}//Fim do mtodo ActionPerformed
108 }//Fim da classe interna RegistroCampo
109 }//Fim da classe Ex4
1 //JFrame classe responsvel por exibir a janela
2 import javax.swing.JFrame;
3

102
4 //Main - Nome da classe
5 public class Main
6{
7 //Comando principal para execuo do programa
8 public static void main(String[] args)
9 {
10
//Criao de um objeto ex da classe Ex8
11
Ex8 ex = new Ex8();
12
//incluso dos componentes de maximinizar, miniminizar e fechar
13
ex.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14
//tamanho da tela
15
ex.setSize(280,120);
16
//posio da tela ao abri-la
17
ex.setLocation(400,300);
18
//tornando a tela visvel
19
ex.setVisible(true);
20 }
21 }

Resoluo exerccio 4 :
1 //importao das classes necessrias
2 //layouts para alinhamento dos componentes
3 import java.awt.BorderLayout;
4 import java.awt.FlowLayout;
5 import java.awt.GridLayout;
6 //Evento para de ouvir um evento do boto
7 import java.awt.event.ActionListener;
8 //Evento de executar uma ao do evento que foi ouvido(ativado)
9 import java.awt.event.ActionEvent;
10 //insero de texto e/ou imagem
11 import javax.swing.JLabel;
12 //campo para insero de valores ou caracteres
13 import javax.swing.JTextField;
14 //botes de marcar
15 import javax.swing.JRadioButton;
16 //grupo de boto para tornar o JRadioButton de seleo exclusiva
17 import javax.swing.ButtonGroup;
18 //buto
19 import javax.swing.JButton;
20 //janela
21 import javax.swing.JFrame;
22 //painel
23 import javax.swing.JPanel;
24
25 //Criao da classe EX7 extendendo a classe JFrame que foi importada
26 public class Ex7 extends JFrame
27 {
28 //criao de 3 variveis do tipo double
29 double c,k,f;
30 //criao de um boto de nome Converter
31 private JButton botao = new JButton("Converter");
32 //Criao das label's
33 private JLabel text1 = new JLabel("Temperatura:");
34 private JLabel text2 = new JLabel("Converte p/:");
35 private JLabel resposta = new JLabel("Resposta: ");
36 //criao de um campo com 15 espaos
37 private JTextField campo = new JTextField("0",15);
38 //criao do FlowLayout que alinha componentes da esquerda para a direita.
39 private FlowLayout flowLayout = new FlowLayout();
40 /*criao de GridLayout com 2 linhas e 1 coluna com 10 de espao em largura
41 e 1 de altura*/
42 private GridLayout gridLayout1 = new GridLayout(2,1,10,1);
43 /*criao de GridLayout2 com 4 linhas e 2 colunas */
44 private GridLayout gridLayout2 = new GridLayout(4,2,10,1);
45 //criao de 4 JRadioButton com todos desmarcados (false), exceto c1 e c2.
46 private JRadioButton c1 = new JRadioButton("Celsius",true);
47 private JRadioButton k1 = new JRadioButton("Kelvin",false);
48 private JRadioButton f1 = new JRadioButton("Fahrenheit",false);
49 private JRadioButton c2 = new JRadioButton("Celsius",true);
50 private JRadioButton k2 = new JRadioButton("Kelvin",false);
51 private JRadioButton f2 = new JRadioButton("Fahrenheit",false);
52
53 //criao dos paineis
54 private JPanel gridJPanel1 = new JPanel();
55 private JPanel gridJPanel2 = new JPanel();
56
57 //criao do grupo de seleo exclusiva
58 private ButtonGroup radioGroup1 = new ButtonGroup();
59 private ButtonGroup radioGroup2 = new ButtonGroup();
60
61 //Mtodo construtor da classe EX1 sem argumentos
62 public Ex7()
63 {

103
64
//ttulo da janela
65
super("Converso de Temperatura");
66
//alinhamento do frame com o uso do objeto flowLayout
67
super.setLayout(flowLayout);
68
/*adicionando dois botes JRadioButton d1 e d2,respectivamente ao radioGroup1
69
para sejam de seleo exclusiva entre os mesmos, ou seja, ao selecionar um
70
o outro se estiver marcado automaticamente desmarcado */
71
radioGroup1.add(c1);
72
radioGroup1.add(k1);
73
radioGroup1.add(f1);
74
75
//da mesma maneira com radioGroup2
76
radioGroup2.add(c2);
77
radioGroup2.add(k2);
78
radioGroup2.add(f2);
79
80
//pegando o Panel recem criado de nome gridJPanel1 e configurando o seu layout
81
gridJPanel1.setLayout(gridLayout1);
82
//adicionando os componentes a mesma
83
gridJPanel1.add(campo);
84
gridJPanel1.add(resposta);
85
86
//pegando o Panel recem criado de nome gridJPanel2 e configurando o seu layout
87
gridJPanel2.setLayout(gridLayout2);
88
//adicionando os componentes a mesma
89
gridJPanel2.add(text1);
90
gridJPanel2.add(text2);
91
gridJPanel2.add(c1);
92
gridJPanel2.add(c2);
93
gridJPanel2.add(k1);
94
gridJPanel2.add(k2);
95
gridJPanel2.add(f1);
96
gridJPanel2.add(f2);
97
98
//adicionando a janela principal
99
super.add(gridJPanel1);
100
super.add(gridJPanel2);
101
super.add(botao);
102
103
//Criando um objeto registroB da classe RegistroButao para o boto
104
RegistroButao registroB = new RegistroButao();
105
//adicionando ao mtodo ActionListener
106
botao.addActionListener(registroB);
107
108 }//Fim do contrutor sem argumentos
109 //criando a classe RegistroButao responsvel e implementada com o ouvinte
110 //ActionListener
111
112 private class RegistroButao implements ActionListener
113 {
114
public void actionPerformed(ActionEvent event)
115
{
116
//Se c1 for selecionado (true) realize os clculos
117
if(c1.isSelected()==true)
118
{
119
/*pega o valor do campo e converte para double atribuindo logo em
120
seguida a varivel c */
121
c=Double.parseDouble(campo.getText());
122
f=c*9/5+32;
123
k=c+273.15;
124
}
125
//Se k1 for selecionado (true) realize os clculos
126
if (k1.isSelected()==true)
127
{
128
k=Double.parseDouble(campo.getText());
129
c=k-273.15;
130
f=c*9/5+32;
131
}
132
//Se f1 for selecionado (true) realize os clculos
133
if(f1.isSelected()==true)
134
{
135
f=Double.parseDouble(campo.getText());
136
c=5/9*f-32;
137
k=c+273.15;
138
}
139
//Se c2 for selecionado (true) exiba a varivel c
140
if(c2.isSelected()==true)
141
resposta.setText(String.format("Resposta: %.2f",c));
142
//Se k2 for selecionado (true) exiba a varivel k
143
if(k2.isSelected()==true)
144
resposta.setText(String.format("Resposta: %.2f",k));
145
//Se f2 for selecionado (true) exiba a varivel f
146
if(f2.isSelected()==true)
147
resposta.setText(String.format("Resposta: %.2f",f));
148
}//Fim do mtodo ActionPerformed
149 }//Fim da classe interna RegistroButao
150 }//Fim da classe Ex7

104
1 //JFrame classe responsvel por exibir a janela
2 import javax.swing.JFrame;
3
4 //Main - Nome da classe
5 public class Main
6{
7 //Comando principal para execuo do programa
8 public static void main(String[] args)
9 {
10
//Criao de um objeto ex da classe Ex7
11
Ex7 ex = new Ex7();
12
//incluso dos componentes de maximinizar, miniminizar e fechar
13
ex.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14
//tamanho da tela
15
ex.setSize(210,220);
16
//posio da tela ao abri-la
17
ex.setLocation(400,300);
18
//tornando a tela visvel
19
ex.setVisible(true);
20 }
21 }