Escolar Documentos
Profissional Documentos
Cultura Documentos
PROGRAMAO
ORIENTADA A OBJETOS
COM
sem mistrios
PROGRAMAO
ORIENTADA A OBJETOS
COM
sem mistrios
So Paulo
2016
2016 UNINOVE
Eduardo Storpoli
Maria Cristina Barbosa Storpoli
Patricia Miranda Guimares
Andr Felipe Henriques Librantz
Marcos Alberto Bussab
Fabricantes
Java e NetBeans: desenvolvido pela Sun Microsystems, hoje de propriedade
da Oracle Corporation.
MySQL: desenvolvido pela MySQL AB, propriedade da Sun Microsystems,
hoje parte da Oracle Corporation.
Windows: desenvolvido pela Microsoft Corporation.
Microsoft Informtica Ltda.
Av Naes Unidas, 12901
Hardware
Processador: 2,6 GHz Intel Premium IV ou equivalente
Memria: 2 GB
Espao em disco: 1 GB de espao livre em disco
Dedicatria
Agradecimentos
no se desviar dele.
Provrbios 22:6
Sumrio
Prefcio................................................................................................................. 15
Sobre o autor........................................................................................................ 17
Apresentao........................................................................................................ 19
Introduo............................................................................................................ 21
3.1 Classes............................................................................................................. 74
3.1.1 Declarao da classe.................................................................................. 74
3.1.2 Declarao dos atributos........................................................................... 74
3.1.3 Construtor................................................................................................... 75
3.1.4 Mtodos....................................................................................................... 76
3.1.5 Exemplo de classe com atributos, construtor e mtodos...................... 79
3.1.6 Diagrama UML para representar uma classe......................................... 82
3.1.7 Boas prticas para nomeao de classes.................................................. 83
3.2 Pacotes............................................................................................................ 83
3.2.1 Boas prticas para nomeao de pacotes................................................ 85
3.2.2 Como utilizar pacotes das bibliotecas Java............................................. 85
3.3 Objetos............................................................................................................ 86
3.3.1 Instncia de objetos................................................................................... 86
3.4 Encapsulamento............................................................................................ 96
3.5 Criao de objetos com entradas do usurio............................................. 96
3.5.1 Entradas do usurio com a classe Scanner............................................. 96
3.5.2 Entradas do usurio com a classe JOptionPane..................................... 99
3.5.3 Comandos encadeados.............................................................................. 102
3.6 Classes sem atributos ................................................................................... 103
3.7 Array de objetos ............................................................................................ 106
Referncias.....................................................................................385
Prefcio
Espero que voc aprecie a leitura e que o contedo seja til para o seu
desenvolvimento profissional.
Prof. Me. Evandro Carlos Teruel
Sobre o autor
Apresentao
Introduo
Bons estudos!
1. Preparando o ambiente
para programar em Java
Para programar em Java necessrio instalar no computador a distribuio
Java Standard Edition (Java SE), que inclui as bibliotecas de classes, os
recursos para compilao e execuo do cdigo e a mquina virtual.
necessrio tambm instalar um ambiente integrado para desenvolvimento (IDE
Integrated Development Environment), que integra os recursos da linguagem
com um editor de cdigo-fonte. Apesar de voc poder digitar seu cdigofonte em um editor simples como o bloco de notas do Windows, comum
o uso de um ambiente de desenvolvimento robusto (como o NetBeans ou o
Eclipse) que integra os recursos da linguagem com os recursos do ambiente
de desenvolvimento em uma nica interface de programao.
Neste Captulo voc aprender a baixar e instalar os recursos necessrios para
criar um ambiente de desenvolvimento Java e a criar, compilar e executar sua
primeira aplicao Java.
NOTA
O Java SE deve estar instalado no computador caso voc queira utilizar as demais distribuies Java (EE, ME e FX).
NOTA
Na tela que aparece voc ter que marcar a opo Accept License Agreement,
para aceitar os termos da licena de uso gratuito. Na mesma tela, na parte
de baixo, voc escolhe a verso da JDK para seu sistema operacional. Para
Windows, voc pode baixar uma das verses apresentadas a seguir:
Para Windows 32 bits jdk-8u20-windows-i586.exe 61.08 MB
Para Windows 64 bits jdk-8u20-windows-x64.exe 173.08 MB
DICA para selecionar o servidor web Tomcat, muito bom para o desenvolvimento de sites com Java EE.
1.1.2 JavaFX
O JavaFX a distribuio Java que permite criar aplicaes multimdia com
interfaces grficas bonitas para desktop, browser e telefones celulares. Quando
voc instala a verso completa do NetBeans, como descrito no tpico anterior,
o Java FX j instalado automaticamente.
Toda classe que voc cria em um projeto iniciada pela instruo public
class seguida pelo nome da classe. Todo o cdigo-fonte da classe deve ficar
no interior das chaves.
public class Exemplo {
//Digite a programao da classe aqui
}
Caso haja alguma linha de cdigo que chame mtodos em outras classes,
pressione F7 para entrar nestes mtodos e depur-los.
Caso queira parar a depurao, basta clicar no menu Depurar e em Finalizar
sesso do depurador.
1.5 Resumo
Com Java possvel desenvolver qualquer tipo de aplicao, estruturada
ou orientada a objetos. Voc pode desenvolver sistemas para desktop, sites,
jogos para celulares, programas para microcontroladores embutidos em
eletrodomsticos, carros etc.
Java, criada pela Sun Microsystem, hoje de propriedade da Oracle Corporation,
cresceu tanto que teve que ser dividida em plataformas (distribuies)
especializadas em domnios especficos. Assim, Java Standard Edition (SE)
a plataforma fundamental, com a linguagem Java e os recursos necessrios
para utilizar qualquer outra distribuio. Java Enterprise Edition (EE) a
distribuio para desenvolvimento de aplicaes que executam em rede, em
servidores de aplicaes. Com Java EE voc pode desenvolver sites ou outras
1.6 Exerccios
1) Quais so as plataformas para desenvolvimento de aplicaes com Java?
2) Que plataforma (ou distribuio) Java necessrio utilizar para desenvolver
programas embarcados?
3) O que necessrio instalar no computador para utilizar o Java EE, Java
ME e JavaFX?
4) Um site feito em Java considerado uma aplicao Java _________.
5) Quando se compila um programa Java, como chamado o arquivo
compilado, que possui a extenso .class?
6) Onde o arquivo compilado em Java carregado e executado?
7) Quais so os principais IDEs de desenvolvimento para Java?
2. Programao Estruturada
em Java
Voc deve achar estranho um livro de Programao Orientada a Objeto iniciar
com um Captulo com o ttulo Programao Estruturada em Java. Pois ,
mas no h nada de estranho nisso. A maioria das linguagens de programao
orientadas a objeto, incluindo Java, utilizam um conjunto de estruturas
derivadas da programao estruturada, como criao de variveis de tipos
primitivos, comparaes, laos de repetio, arrays (vetores e matrizes) etc.
As aplicaes orientadas a objetos normalmente utilizam programao
estruturada quando criam variveis, fazem comparaes, executam laos
de repetio e manipulam arrays. Voc pode programar 100% de maneira
estruturada utilizando uma linguagem orientada a objeto como Java, porm,
estar subutilizando os recursos mais importantes da linguagem.
Este Captulo apresentar:
A diferena entre programao estruturada e programao orientada a
objetos.
As instrues fundamentais da linguagem Java para tipificao e criao
de variveis simples, arrays e constantes.
As principais operaes aritmticas, relacionais e lgicas.
Estruturas de seleo e laos de repetio.
No final voc encontrar um conjunto de exerccios para praticar e ajudar a
fixar conceitos.
O objetivo principal deste Captulo apresentar a voc as estruturas
fundamentais de programao usadas tanto na programao estruturada como
na programao orientada a objetos com Java.
if (media >= 6) {
mensagem = "aprovado";
} else {
mensagem = "reprovado";
}
System.out.print("O aluno " + nome + " foi " + mensagem + " com mdia " + media);
}
}
No tpico seguinte voc ver como esta mesma tarefa ser realizada de maneira
orientada a objetos.
Analisando o tamanho dos programas voc deve estar pensando que bem
mais fcil programar de maneira estruturada. Se pensarmos na simples tarefa
que executamos, voc tem razo. Agora pense no sistema de uma empresa
NOTA
Na programao orientada a objetos cada arquivo de programa chamado de classe. Assim, por exemplo, se voc for construir uma aplicao com 5 arquivos .java, ter 5 classes na aplicao.
Note que a varivel idade recebeu um valor numrico inteiro, logo, implicitamente do tipo int. J a varivel nome recebeu uma cadeia de caracteres, logo,
definida implicitamente como String.
Este no o caso da linguagem Java. Nesta linguagem, considerada fortemente
tipada, voc precisa obrigatoriamente indicar o tipo da varivel antes de atribuir
um valor a ela. Por exemplo:
int idade=40;
String nome="Evandro";
Inteiros
Reais
Tipo primitivo
Exemplo
char
byte
short
int
long
float
double
Espao em bytes
usado na memria
2
1
2
4
8
4
8
boolean
boolean casado=true;
byte a=240;
No, no est correta. Apesar de voc poder armazenar 256 valores inteiros
diferentes e exclusivos em uma varivel do tipo byte, estes valores podem ser
negativos ou positivos. Logo, voc pode armazenar valores de -128 at 127.
Se voc contar quantos valores inteiros exclusivos existem entre -128 e 127
(incluindo o zero), perceber que existem 256 valores que equivalem ao total
permitido em uma varivel do tipo byte. Sendo assim, no exemplo acima, a
varivel poderia armazenar apenas valores de -128 at 127.
Vamos ver alguns exemplos corretos:
byte a=127;
byte b=-80;
byte c=110;
Em resumo, use variveis do tipo byte apenas se for armazenar valores inteiros
na faixa de -128 at 127. Se precisar armazenar valores maiores, utilize o tipo
short.
short f=-20567;
short g=31789;
short h=32767;
short i=-32768;
Por no ser considerado o tipo padro para nmeros reais da linguagem Java,
j que o tipo padro double, valores atribudos a uma varivel do tipo float
devem terminar com a letra F.
2.3.2.1 Casting
Se a converso for de um tipo de dado de maior preciso para um tipo de dado
de menor preciso, o processo de converso chamado casting.
Trabalharemos neste tpico converses dos seguintes tipos de dados:
byte
short
int
long
float
double
Casting ocorre sempre que se deseja converter de um tipo mais abaixo, na lista
de tipos apresentada, para um tipo mais acima.
Por exemplo, para converter um valor do tipo int para byte, utiliza-se:
int a=10;
byte b=(byte) a;
Veja que a varivel int a recebeu o valor inteiro 10 e este valor foi convertido
para byte e armazenado na varivel byte b.
Para fazer casting, na converso, coloca-se o tipo de dado para o qual se quer
converter entre parnteses.
Vejamos outros exemplos:
double b=10.0;
short c=(short) b;
2.3.2.2 Promotion
Quando a converso ocorre de um tipo de menor preciso para um tipo de
maior preciso, ou seja, de um tipo mais acima na lista de tipos apresentada,
para um tipo mais abaixo, a converso ser direta, sem precisar de casting.
Neste caso chamamos a operao de promotion.
Vejamos alguns exemplos:
int a = 1786;
long c = a;
byte v = 2;
double x=v;
short t = 290;
long u = t;
int k=1675;
float l=k;
NOTA minados classes. Desta forma, no decorrer dos demais tpicos deste livro,
utilizaremos a palavra classe como sinnimo de arquivo de programa.
ou
String nome = new String("Evandro");
ou
String nome;
nome = new String("Evandro");
Observe que b uma varivel que faz referncia classe Byte.java, ou seja,
uma varivel do tipo Byte. Dizemos, neste caso, que b um objeto do tipo
Byte. Deixaremos os detalhes em relao ao termo objeto para o prximo
Captulo deste livro.
Da mesma forma, s um objeto do tipo Short, i um objeto do tipo Integer, l
um objeto do tipo Long, e assim por diante.
Alm das classes de referncia para tipos de dados numricos acima, caso
precise armazenar e manipular valores acima dos limites permitidos nos tipos
de dados numricos primitivos, pode utilizar a classe BigDecimal.java, como
mostra o exemplo a seguir:
BigDecimal g = new BigDecimal ("98876716752638949.78");
Veja que aluno uma varivel que faz referncia classe Aluno.java, ou seja,
uma varivel do tipo Aluno. Neste caso, dizemos que aluno um objeto da
classe Aluno.java. Esta classe contm recursos para manipular os dados do
aluno e executar operaes sobre estes dados.
Voc pode criar classes para manipular outras categorias de informaes e criar
objetos (variveis) de referncia a estas classes. Veremos isso nos prximos
Captulos deste livro.
Significado
Multiplicao
Diviso
Soma
Subtrao
Exemplos
double quantidade=20;
double valor = 109.6;
double total = quantidade*valor;
double salario=1987.7;
double percentual=10.0;
double aumento=salario*percentual/100;
int a=10;
int b=20;
int c=a + b;
double salario=2456.76;
double desconto=200.57;
double salLiquido= salario desconto;
double salario=1876.56;
double percentualAumento=1876.56;
double salReajustado=salario + salario * percentualAumento / 100;
Veja que naturalmente seria realizada a diviso de nota2 por 2 para depois o
valor resultante ser somado ao contedo da varivel nota1. Porm, o parntese
altera esta ordem natural, fazendo com que primeiro o contedo da varivel
nota1 seja somado ao contedo da varivel nota2 para depois o valor resultante
ser dividido por 2.
Modo extendido
Modo reduzido
a=a+1;
a=a+5;
a=a*4;
a=a/2;
a=a-1;
a=a-6;
a++;
a+=5;
a*=4;
a/=2;
a--;
a-=6;
Valor resultante na
varivel a
11
15
40
5
9
4
Operao
incremento
incremento
incremento
decremento
decremento
decremento
Voc pode utilizar tanto o modo extendido quanto o modo reduzido que ter
o mesmo resultado.
Veja que o contedo da varivel a utilizado na operao e o resultado
armazenado na prpria varivel a. Quando o valor resultante for maior do que
o valor inicial da varivel, ocorreu uma operao incremento. Quando o valor
resultante for menor, ocorreu um decremento de valor.
Operador
==
Significado
igual
>
>=
maior
maior ou igual
<
<=
!=
menor
menor ou igual
diferente
Exemplo
a==b
b==c
b>a
b>=c
a>=c
b<c
a<=b
a!=b
b!=c
Resultado
false
true
true
true
false
false
true
true
false
Note que o resultado de uma operao relacional ser sempre um valor boolean
(true ou false). Para indicar o que deve ocorrer se a avaliao da expresso for true
ou false utiliza-se o comando if que veremos no decorrer neste Captulo.
boolean a=true;
boolean b=false;
Operador
!
Significado
No
&&
||
OU
Exemplo
!a
!b
a&&b
a&&a
a||b
b||b
Resultado
false
true
false
true
true
false
NOTA tema Tabela Verdade. Trata-se de uma tabela que mostra os resultados das principais expresses lgicas.
NOTA
Para testar as estruturas apresentadas no restante deste Captulo, coloque os cdigos-fonte apresentados no interior do mtodo main de uma
classe principal criada em um projeto Java no NetBeans. Para compilar e executar a classe, pressione a tecla F6. Se precisar de mais orientaes sobre esse procedimento, reveja o Captulo 1.
Por exemplo:
int a=2;
int b=6;
if (a>=b){
System.out.println("a contm um valor maior ou igual a b");
} else {
System.out.println("a no contm um valor maior ou igual a b");
}
if (a==b) {
procedimento caso o resultado seja true
} else {
procedimento caso o resultado seja false
}
NOTA
Quando apenas um comando tiver de ser executado para cada resultado da comparao (true ou false), as chaves so desnecessrias. Caso
seja necessrio executar mais de um comando para cada resultado, as
chaves sero obrigatrias.
Veja que muitas expresses podem ser avaliadas utilizando esta estrutura.
Por exemplo:
Exemplo:
import javax.swing.JOptionPane;
public class Principal {
public static void main(String[] args) {
int a = Integer.parseInt(JOptionPane.showInputDialog("Digite um valor inteiro
para a varivel a"));
switch (a) {
case 0:
System.out.print("A varivel recebeu o valor 0");
break;
case 1:
System.out.print("A varivel recebeu o valor 1");
break;
case 2:
System.out.print("A varivel recebeu o valor 2");
break;
default:
System.out.print("A varivel recebeu qualquer outro valor no testado
acima");
}
}
}
Note que se a cidade informada pelo usurio for So Paulo, ser exibida
a mensagem Cidade da garoa. Se for Rio de Janeiro, ser exibida a
mensagem Cidade maravilhosa. Se for qualquer outra cidade, ser exibida
a mensagem Cidade no reconhecida.
Veja que a varivel cont inicializada com o valor 1 e testada a cada passagem
pelo lao verificando se contm um valor menor ou igual a 10. Em cada
passagem pelo lao, esta varivel vai sendo incrementada em 1. Quando a
varivel receber o valor 11, que torna o teste false, o lao finalizado.
Exemplo de lao com decremento:
for (int cont=10; cont>=1; cont--){
System.out.print(cont);
}
Isso faz com que o lao seja executado pelo menos uma vez, mesmo que a
condio retorne false no primeiro teste. A sintaxe do comando apresentada
a seguir:
declarao e inicializao da varivel contador
do {
operao a ser repetida
incremento ou decremento da varivel contador
} while(teste da varivel contador);
Veja um exemplo:
int cont=1;
do {
System.out.print(cont);
cont++;
} while (cont<=10);
Neste caso, a varivel cont foi inicializada com o valor 11, o que faz com que
no primeiro teste o resultado seja false. Mesmo assim, a mensagem ser exibida
uma vez.
nomes
0
Pedro
1
Ana
2
Por exemplo:
String clientes[] = new String[2];
int idades[] = new int[4];
double salarios[]=new double[3];
salarios[0]=1678.67;
salarios[1]=1390.00;
salarios[2]=2765.34;
Paulo
1
idades
19
0
40
1
29
2
41
3
salarios
1678.67
0
NOTA
1390.00
1
2765.34
2
nomes
0
1
Observe que trata-se de uma array de duas dimenses, onde tanto as linhas
quanto as colunas possuem ndices numricos iniciados em 0.
Para armazenar valores nesta array utiliza-se as instrues:
nomes[0][0]= "Paulo";
nomes[0][1]= "Maria";
nomes[1][0]= "Ana";
nomes[1][1]= "Angela";
Paulo
Ana
0
Maria
Angela
1
Caso seja necessrio visualizar o nome Angela, voc pode digitar o comando
a seguir:
System.out.print (nomes[1][1]);
OU
int i=0;
while (i<3){
System.out.println(nomes[i]);
i++;
}
TipoDaVarivel pode ser char, byte, short, int, long, float, double, boolean,
String, Date etc. Veja alguns exemplos:
int codigo;
codigo=10;
String cidade;
cidade= "So Paulo";
char sexo;
sexo= 'F';
Veja que a varivel idade recebeu o valor 39 e depois teve o valor modificado
para 80.
Outra maneira de trabalhar com variveis simples declarando a varivel e
j atribuindo valor na mesma linha, em uma nica instruo. Neste caso a
sintaxe ser:
UNINOVE uso exclusivo para aluno
TipoDaVarivel nomeDaVarivel=valor;
Veja o exemplo:
int codigo=1012;
String email= "aluno@uninove.edu.br";
2.7.1 Constantes
A diferena entre uma varivel e uma constante que o valor armazenado em
uma varivel pode mudar no decorrer da execuo de um programa e o valor
armazenado em uma constante, no.
Em Java, para declarar uma constante utiliza-se a sintaxe seguinte:
final TipoDaConstante NomeDaConstante = valor;
2.8 Resumo
Este Captulo apresentou um conjunto de conceitos e estruturas utilizados em
Java que incluem:
A diferena entre programao estruturada e orientada a objetos;
Os tipos de dados para declarar variveis (primitivos e por referncia);
As categorias de variveis (simples, arrays e objetos);
Operaes (aritmticas, relacionais e lgicas);
Declarao e atribuio de dados s variveis simples;
Declarao, atribuio de valores e manipulao de dados em arrays
unidimensionais e bidimensionais;
Declarao e atribuio de valores constantes;
Estruturas de seleo (if..elseif..else e switch...case..default);
Estruturas de repetio (for, while e do while).
A programao de computadores pode ser realizada de formas diferentes, de
acordo com um conjunto de princpios e recursos disponveis na linguagem de
programao. Estas formas so conhecidas como paradigmas de programao.
Os dois principais paradigmas so Programao Estruturada e Programao
Orientada a Objetos. Na programao estruturada os comandos so executados
sequencialmente, normalmente em um nico programa, que executa todas
as operaes necessrias. Na programao orientada a objetos as operaes
2.9 Exerccios
1) Dadas as variveis abaixo, resolva as expresses mistas A e B indicando o
resultado de cada uma:
int a=2;
int b=3;
int c=5;
int d = 1;
A) boolean e = (a+b*(c+d))<=(d*(b+c)/2)||(a+b-c)>(c+d);
B) boolean f = !((b*c/d)==(d*b+c)) && (c*d+a)!=(c+d);
int a = 2;
int b = 3;
int c = 5;
int d = 1;
if((b*c/d)==(d*b+c)&&(c*d+a)!=(c+d)||(a+b)<=(c-d)) {
System.out.print("A");
} else if ((a+b*d)>(b+c/2)||(a-c)>(c+d)) {
System.out.print("B");
} else if ((a*b/2)<(d*c+8)|| !((c+d*4)<=12)) {
System.out.print("C");
} else {
System.out.print("D");
}
Paulo
Ana
Janaina
0
Maria
Marcelo
Jos
1
Pedro
Andr
Renato
2
Marcos
Mauro
Clia
3
10) Dada a varivel b a seguir, converta seu valor para a varivel c do tipo byte
e para a varivel d do tipo short.
double b=12;
11) Dada a varivel g a seguir, converta seu valor para a varivel h do tipo
float e i do tipo long.
int g=6;
60
23
0
78
50
1
Algoritmo fatorial
var a, n, cont: inteiro
incio
n5;
a 1
cont1
enquanto (cont<=n) faa
a a* cont
cont cont +1
fim enquanto
imprima (a)
fim
3. Orientao a objetos
conceitos bsicos
A orientao a objetos foi criada observando-se conceitos aplicados no diaa-dia das pessoas. Normalmente categorizamos, classificamos, relacionamos
e realizamos operaes sobre um incontvel nmero de informaes. Nosso
crebro est programado para classificar tudo baseado em nosso conjunto de
conhecimentos e valores.
Na programao orientada a objetos tudo comea com a categorizao ou
classificao de informaes agrupando-as em classes. As informaes de uma
determinada classe ou categoria esto sujeitas a um conjunto de operaes
criadas especificamente para atuar sobre elas. Vamos a um exemplo prtico.
Em uma empresa podemos classificar as pessoas como clientes, funcionrios e,
em alguns casos, fornecedores. Cada uma destas classes de pessoas possui um
conjunto de informaes que as identifica e/ou caracteriza. Estas informaes
so seus atributos.
Vamos focar, por exemplo, na classe dos funcionrios. O funcionrio possui
matrcula, nome, cargo, salrio etc. Sobre estas informaes, podem ser
realizadas um conjunto de operaes. Por exemplo, sobre o salrio pode ser
realizada uma operao de reajuste, uma operao de desconto de imposto
etc. Estas operaes, na orientao a objetos, so chamadas de mtodos. Deste
exemplo podemos obter alguns conceitos essenciais da orientao a objetos,
que so:
Classe: Funcionrio
Atributos: matrcula, nome, cargo, salrio.
Mtodos: reajuste, desconto de imposto.
No s pessoas podem ser categorizadas ou classificadas em uma empresa. Por
exemplo, podemos identificar a classe dos produtos que a empresa vende. Estes
produtos possuem cdigo, nome, medida, cor, preo etc. Sobre estas informaes
do produto podem ser realizadas operaes. Por exemplo, sobre o preo, podem
ser realizadas operaes de reajuste, desconto etc. Assim, podemos tirar deste
exemplo um conjunto de conceitos da orientao a objetos que so:
Classe: Produto
Atributos: cdigo, nome, medida, cor, preo.
Mtodos: reajuste, desconto.
Muito bem, conceitualmente simples. Mas como transformar isso em
programa de computador?
isso que veremos no prximo tpico deste Captulo.
3.1 Classes
Tirando a parte conceitual e abstrata, uma classe nada mais do que um
arquivo de programa Java que precisa possuir uma estrutura que atenda aos
padres da linguagem. Elas possuem identificao, a declarao dos atributos
ou informaes que manipulam, um ou mais construtores e operaes que
podem ser realizadas sobre estes atributos. Cada uma destas caractersticas
das classes ser apresentada a seguir.
NOTA
3.1.3 Construtor
Construtor uma estrutura, semelhante a um mtodo ou funo, que permite
criar (ou instanciar) um objeto (varivel) da classe, j incluindo valores a serem
armazenados no objeto ou no.
Segundo Horstmann (2009, p. 369), construtores contm instrues para
inicializar os atributos de um objeto.
Se o construtor permitir o recebimento de parmetros, ento voc poder criar
um objeto (varivel) da classe e j armazenar as informaes nos atributos
desta classe em uma mesma operao. Veja um exemplo:
public Funcionario(int matricula, String nome, String cargo, double salario) {
this.matricula = matricula;
this.nome = nome;
this.cargo = cargo;
this.salario = salario;
}
Voc deve observar que o construtor, obrigatoriamente, deve ter o mesmo nome
da classe. Pode haver diversos construtores em uma classe, desde que eles
recebam parmetros diferentes. O uso de vrios construtores em uma classe
chamado de sobrecarga de construtor.
NOTA
Se voc no escrever um construtor na classe, implicitamente o compilador vai entender que existe um construtor vazio que no recebe parmetros. Neste caso, apesar de parecer que a classe no tem construtor,
h sim um construtor implcito.
3.1.4 Mtodos
Mtodos so semelhantes s funes utilizadas na programao estruturada,
porm, ao contrrio das funes, estaro sempre associados aos objetos da
classe e executaro operaes sobre os valores manipulados pela classe. So
trechos de cdigo em uma classe que podem ser chamados uma ou mais vezes
para realizar procedimentos especficos sobre os atributos da classe.
Os mtodos so recursos excelentes para viabilizar o reaproveitamento de
cdigo, uma vez que precisam ser digitados uma vez, mas podem ser chamados
quantas vezes forem necessrias.
Segundo Horstmann (2009. p. 63), um mtodo uma sequncia de instrues
que acessam os dados internos de um objeto.
Em uma classe Java normalmente existem trs categorias de mtodos: os
mtodos setter (que incluem valores nos atributos de um objeto); os mtodos
getter (que obtm valores armazenados nos atributos de um objeto); e mtodos
de uso geral, que executam operaes personalizadas e diversificadas sobre
os atributos da classe.
Onde:
ModificadorVisibilidade: determina se o mtodo ter acesso pblico,
privado, protegido ou padro. Veremos detalhes sobre esses modificadores
no prximo captulo.
TipoRetorno: determina que tipo de valor o mtodo ir retornar. Um mtodo
pode retornar qualquer tipo de valor, seja simples, array, objeto etc. Caso
o mtodo no retorne valor deve ser escrito void neste local.
Veja que este mtodo recebe um nome (do tipo String), exibe este nome na
tela e no retorna nenhum valor (void).
public double calcularMedia(double nota1, double nota2){
return (nota1+nota2)/2;
}
Veja que este mtodo recebe duas notas do tipo double e retorna o resultado
do clculo da mdia entre elas, tambm do tipo double.
public double calcularMedia(){
return (8.0+5.0)/2;
}
H duas operaes padro que podem ser realizadas sobre os atributos da classe
por meio de um objeto desta classe: armazenar valor e obter o valor armazenado.
Mtodos destinados a armazenar valores nos atributos so conhecidos como
mtodos setter e aqueles que obtm os valores armazenados, so conhecidos
como mtodos getter.
Veja que este mtodo, chamado setNome, recebe um nome como parmetro
e transfere este nome para o atributo nome da classe (this.nome). H duas
variveis nome diferentes: a varivel local, que recebe o nome como parmetro;
e o atributo nome, privado da classe, antecedido pela instruo this, que recebe
o nome que chegou como parmetro.
NOTA
NOTA
Agora que o projeto est criado, vamos criar a classe Funcionario.java. Para
criar esta classe, siga os procedimentos a seguir:
Clique com o boto direito do mouse no nome da pasta do projeto, localizado
na diviso Projetos do canto superior esquerdo da tela, clique na opo
Novo e, em seguida, na opo Classe Java.
No campo Nome da Classe, digite Funcionario e clique no boto
Finalizar.
No uma boa prtica acentuar nomes de classes e variveis, por esse
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
A linha 1 declara a classe com nome Funcionario. Veja que a chave aberta
nesta linha fechada apenas na linha 52.
Da linha 2 a 5 so declarados os atributos da classe, ou seja, as informaes que
se deseja manipular. Estes atributos no so nada mais que variveis privadas
da classe, ou seja, variveis que s podem ser acessadas do interior desta classe.
Calma!
No adianta compilar e executar esta classe que nada vai acontecer. Trata-se
de uma classe de apoio, que ser acessada de outras classes, sempre que se
desejar manipular dados de funcionrios. Para testarmos a classe Funcionario,
vamos criar nos tpicos seguintes uma classe principal (que possui o mtodo
main) no projeto por meio da qual manipularemos os dados de um funcionrio.
NOTA
A ideia do diagrama de classes desenhar a classe antes do seu desenvolvimento. Normalmente a equipe de anlise e/ou projeto desenha as classes
e entrega aos programadores para que eles a implementem na linguagem
de programao orientada a objeto definida para o projeto.
NOTA
Se voc no adotar as boas prticas de nomeao, no ocorrer erro, porm, sua aplicao no ser bem vista entre desenvolvedores profissionais. As boas prticas representam recomendaes adotadas como padro
atualmente e recomendadas pelos desenvolvedores da linguagem.
3.2 Pacotes
Pacotes so contineres (ou pastas) que se cria em um projeto para agrupar
classes que possuem alguma caracterstica comum ou afinidade.
Horstmann (2009, p. 339), afirma que um pacote um conjunto de classes
relacionadas.
Por exemplo, em um projeto, pode-se criar um pacote para agrupar as classes
que implementam o mdulo de controle de funcionrios, um pacote para
agrupar classes que implementam o mdulo de clientes, e assim por diante.
NOTA
Para representar os pacotes de uma aplicao pode ser utilizado o diagrama de pacotes da UML. Se voc quiser saber mais sobre o diagrama de
pacotes, visite o link a seguir: <http://www.uml-diagrams.org/package-diagrams-overview.html>.
Se o nome do pacote tiver mais que uma palavra, utilizar ponto final para
separar as palavras. Por exemplo: cadastro.clientes
Esta instruo permite utilizar na classe que voc est escrevendo qualquer
classe que esteja no pacote javax.swing.
3.3 Objetos
A classe Funcionario.java que voc criou no tpico anterior, uma classe
que permite manipular no projeto criado um novo tipo de dado, um tipo
Funcionario.
isso mesmo, agora voc pode criar variveis do tipo Funcionario sempre que
desejar armazenar informaes de funcionrios e manipular estas informaes.
String, por exemplo, um tipo de dado porque h uma classe chamada String.
java. Da mesma forma, Funcionario um tipo de dado porque existe a classe
Funcionario.java.
Veja na Figura 3.3 que a instruo new Funcionrio() chama o construtor vazio
da classe Funcionario.java.
0
Null
Null
0.0
setMatricula(int matricula): void
getMatricula(): int
setNome(String nome): void
getNome(): String
setCargo(String cargo): void
getCargo(): String
setSalario(double salario): void
getSalario(): double
ajustarSalario(double
percentual):void
Como o objeto foi instanciado vazio por meio do construtor que no recebe
parmetros, para armazenar (setar) valores no objeto deve-se chamar os
mtodos setter da seguinte forma:
67543
Angela Cristina
Analista
24567.98
setMatricula(int matricula): void
getMatricula(): int
setNome(String nome): void
getNome(): String
setCargo(String cargo): void
getCargo(): String
setSalario(double salario): void
getSalario(): double
ajustarSalario(double percentual): void
Figura 3.5: Objeto preenchido por meio dos mtodos setter.
Note que para obter o valor da matrcula armazenado no atributo matricula foi
utilizada a instruo func.getMatricula(). A instruo System.out.println exibe
na tela o valor obtido do atributo. Para obter os valores contidos nos demais
atributos, foram chamados os mtodos getter destes atributos. A Figura 3.6
ilustra o uso dos mtodos getter.
67543
Angela Cristina
Analista
24567.98
setMatricula(int matricula): void
getMatricula(): int
setNome(String nome): void
getNome(): String
setCargo(String cargo): void
getCargo(): String
setSalario(double salario): void
getSalario(): double
ajustarSalario(double percentual): void
Uma vez que um objeto instanciado, para acessar qualquer mtodo contido
na classe referente ao objeto, deve-se digitar o nome do objeto, o ponto final
e o mtodo que se deseja acessar. Pode-se concluir ento, at aqui, que:
O acesso aos mtodos de uma classe ocorre por meio de um objeto instanciado
desta classe.
func
matricula
nome
cargo
salario
1367
Paulo Henrique
Gerente
789.56
setMatricula(int matricula): void
getMatricula(): int
setNome(String nome): void
getNome(): String
setCargo(String cargo): void
getCargo(): String
setSalario(double salario): void
getSalario(): double
ajustarSalario(double
percentual):void
Na instncia do objeto, os valores passados como parmetro j foram armazenados no objeto func, sem a necessidade de chamar os mtodos setter.
Para obter os valores contidos nos atributos do objeto func, chamam-se os
mtodos getter, como mostra o exemplo a seguir.
public class Teste {
public static void main(String[] args) {
Funcionario func = new Funcionario(1367, "Paulo Henrique", "Gerente",
789.56);
System.out.println(func.getMatricula());
System.out.println(func.getNome());
System.out.println(func.getCargo());
System.out.println(func.getSalario());
}
}
NOTA
Veja que foram instanciados (criados) trs objetos: func1, func2, func3. Cada
objeto uma instncia da classe Funcionario.java. Em cada objeto, os atributos
matricula, nome, cargo e salario receberam valores diferentes. Se voc desejar
exibir uma informao contida no atributo de um objeto, deve primeiro obter
o valor do atributo, por meio do mtodo getter correspondente, para depois
exibir o valor obtido. Por exemplo:
System.ou.println(func2.getNome());
func.setNome("Angela Cristina");
func.setCargo("Analista");
func.setSalario(24567.98);
1367
Paulo Henrique
Gerente
789.56
Em seguida, estes valores foram alterados, por meio de chamadas aos mtodos
setter, para:
matricula
nome
cargo
salario
NOTA
67543
Angela Cristina
Analista
24567.98
Voc pode alterar os valores de um objeto quantas vezes desejar, bastando, para isso, chamar os mtodos setter a partir deste objeto e passar outros valores para seus atributos.
1367
Paulo Henrique
Gerente
868.516
setMatricula(int matricula): void
getMatricula(): int
setNome(String nome): void
getNome(): String
setCargo(String cargo): void
getCargo(): String
setSalario(double salario): void
getSalario(): double
ajustarSalario(double
percentual):void
Caso voc deseje visualizar o novo valor contido no atributo salario, basta
digitar a instruo System.out.print(func.getSalario()); aps a chamada ao
mtodo na classe Teste.java.
3.4 Encapsulamento
Quando voc instancia um objeto de uma classe voc encapsula os atributos
privados da classe no objeto, de forma que possam ser acessados somente por
mtodos pblicos. Dessa forma, podemos ver um objeto como uma cpsula.
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
Scanner ler;
Funcionario func;
ler= new Scanner(System.in);
func = new Funcionario();
System.out.println("Informe a matrcula:");
func.setMatricula(ler.nextInt());
ler.nextLine();
System.out.println("Informe o nome:");
func.setNome(ler.nextLine());
System.out.println("Informe o cargo:");
func.setCargo(ler.nextLine());
System.out.println("Informe o valor do salrio:");
func.setSalario(ler.nextDouble());
System.out.print("\n");
System.out.println("Matrcula:" + func.getMatricula());
System.out.println("Nome:" + func.getNome());
System.out.println("Cargo:" + func.getCargo());
System.out.println("Salrio:" + func.getSalario());
func.ajustarSalario(10);
System.out.println("Salrio reajustado:" + func.getSalario());
System.out.print("\n");
}
}
foram feitas chamadas aos mtodos getter. O sinal de mais (+) em cada linha
concatena um rtulo String ao contedo obtido do atributo do objeto.
A linha 22 chama o mtodo ajustarSalario e passa o valor 10, que se refere
ao percentual no qual se quer aumentar o salrio. Este mtodo recebe o valor
como parmetro e aumenta o salrio trocando o valor do atributo salario pelo
valor reajustado.
A linha 23 obtm o salrio reajustado por meio de uma chamada ao mtodo
getSalario da classe Funcionario.java e exibe na tela.
Observe na classe apresentada que para cada informao que se deseja pedir
ao usurio, so usadas duas linhas, uma para exibir o pedido da informao,
e outra para receber a informao e armazenar no atributo do objeto func da
classe Funcionario.java. Veja por exemplo a entrada da matrcula (linhas 8 e 9):
System.out.println("Informe a matrcula:");
func.setMatricula(ler.nextInt());
NOTA
O mtodo nextDouble da classe Scanner requer a digitao de um valor double utilizando vrgula para separar casas decimais, caso seja
necessrio.
11
12
13
14
import javax.swing.JOptionPane;
public class Teste {
public static void main(String[] args) {
Funcionario func;
func = new Funcionario();
func.setMatricula(Integer.parseInt(JOptionPane.showInputDialog("Digite a
matrcula: ")));
func.setNome(JOptionPane.showInputDialog("Digite o nome: "));
func.setCargo(JOptionPane.showInputDialog("Digite o cargo: "));
func.setSalario(Double.parseDouble(JOptionPane.showInputDialog("Digite o
salrio: ")));
JOptionPane.showMessageDialog(null,
"Matrcula:" + func.getMatricula() + "\n"
+ "Nome:" + func.getNome() + "\n"
+ "Cargo:" + func.getCargo() + "\n"
+ "Salrio:" + func.getSalario() + "\n");
func.ajustarSalario(Integer.parseInt(JOptionPane.showInputDialog("Digite o
percentual de reajuste para o salrio: ")));
JOptionPane.showMessageDialog(null, "Salrio reajustado: " + func.
getSalario());
}
}
Observe que a entrada de dados ocorrer por meio de janelas pop-up geradas
pelo mtodo showInputDialog da classe JOptionPane. Estas janelas aparecero
uma por uma, ao compilar e executar a classe utilizando a tecla F6. Veja na
Figura 3.11 como sero estas janelas:
Aps a exibio dos dados aparecer a janela pop-up mostrada na Figura 3.13,
para a digitao do percentual de aumento do salrio (linha 11).
NOTA
Todo valor digitado em campos de entrada, no Java e na maioria das linguagens, considerado um valor do tipo String, mesmo que a entrada seja
um nmero. Por esse motivo, se voc quer manipular o valor que entrou
como um valor numrico, deve fazer a converso para o tipo numrico do
seu interesse. As operaes de converso de tipo String para tipos numricos chamada parse. Assim, veja algumas formas de converso:
byte idade=Byte.parseInt(JOptionPane.showInputDialog(Digite a idade: );
short idade=Short.parseShort(JOptionPane.showInputDialog(Digite a idade:);
int idade=Integer.parseInt(JOptionPane.showInputDialog(Digite a idade: );
long idade=Long.parseLong(JOptionPane.showInputDialog(Digite a idade: );
float salario=Float.parseFloat(JOptionPane.showInputDialog(Digite o salrio:);
double salario=Double.parseDouble(JOptionPane.showInputDialog(Digite
o salrio:);
DICA
Note que h dois mtodos chamados media, um que recebe dois valores double,
calcula a mdia entre estes valores e retorna o resultado como double e um
que recebe trs valores double, calcula a mdia entre estes valores e retorna o
resultado como double.
H tambm dois mtodos chamados soma, um que recebe dois valores inteiros,
soma estes valores e retorna o resultado como int e um que recebe dois valores
inteiros e um valor double, soma estes valores e retorna o resultado como
double.
O mtodo chamado raizQuadrada recebe um valor int, calcula a raiz quadrada
deste valor e retorna o resultado como double. Para calcular a raiz quadrada foi
utilizado o mtodo sqrt da classe Math, instalada com o Java. A classe Math
permite realizar diversos tipos de operaes matemticas e trigonomtricas.
Perceba que h mais de um mtodo com o mesmo nome na classe, porm, estes
mtodos de mesmo nome recebem parmetros diferentes. Isto chamado na
orientao a objetos de sobrecarga de mtodos.
O diagrama de classes da UML para a classe acima mostrado na Figura 3.16.
Calculo
+ media(double valor1, double valor2): double
+ media(double valor1, double valor2, double valor3) : double
+ soma(int valor1, int valor2): int
+ soma(int valor1, int valor2, double valor3): double
+ raizQuadrada(int valor): double
Figura 3.16: Diagrama de classes mostrando a classe Calculo.
Observe que a diviso destinada aos atributos est vazia, j que a classe no
possui atributos.
Note que, neste caso, so usadas operaes aninhadas que chamam os mtodos,
passam os parmetros e j exibem os valores retornados, poupando a criao
de variveis.
Como voc deve ter percebido, pode criar uma classe apenas com mtodos de
apoio para operaes que ir utilizar na aplicao.
18
19
20
import javax.swing.JOptionPane;
public class Teste {
public static void main(String[] args) {
Funcionario funcionarios[];
funcionarios = new Funcionario[3];
Funcionario func;
for (int indice = 0; indice < funcionarios.length; indice++) {
func = new Funcionario();
func.setMatricula(Integer.parseInt(JOptionPane.showInputDialog("Digi
te a matrcula: ")));
func.setNome(JOptionPane.showInputDialog("Digite o nome: "));
func.setCargo(JOptionPane.showInputDialog("Digite o cargo: "));
func.setSalario(Double.parseDouble(JOptionPane.showInputDialog("Di
gite o salrio: ")));
funcionarios[indice] = func;
}
for (int indice = 0; indice < funcionarios.length; indice++) {
func = funcionarios[indice];
JOptionPane.showMessageDialog(null,
"Matrcula:" + func.getMatricula() + "\n"
+ "Nome:" + func.getNome() + "\n"
+ "Cargo:" + func.getCargo() + "\n"
+ "Salrio:" + func.getSalario() + "\n");
}
}
}
Basicamente, o que esta classe faz pedir dados de funcionrios, colocar estes
dados em objetos da classe Funcionario.java e incluir cada um destes objetos
nas posies de uma array. Para isso, utilizado um lao de repetio para
passar por cada posio da array (linhas de 7 14). Em seguida, o contedo
de cada objeto das posies da array tem seu contedo exibido. Para percorrer
a array, um lao de repetio tilizado (linhas 15 18).
Para entender melhor todo o processo, segue uma explicao mais detalhada.
A linha 4 declara a array funcionarios e a linha 5 instancia a array com trs
posies, sempre numeradas a partir de 0 (neste caso, de 0 2).
3.8 Resumo
Os conceitos fundamentais da orientao a objetos so classes, atributos,
mtodos, construtores e objetos.
atributo. Alm dos mtodos setter e getter, uma classe pode ter qualquer outro
mtodo que pode atuar sobre os valores dos atributos ou no.
A tcnica de ocultar de um objeto detalhes internos do funcionamento dos
mtodos de uma classe, de forma que o conhecimento interno do corpo dos
mtodos no seja necessrio para cham-los, conhecida como encapsulamento.
H classes que so criadas sem atributos, apenas com mtodos, para executar
operaes especficas na aplicao, que normalmente so chamadas diversas vezes.
Mtodos em uma mesma classe podem ter o mesmo nome, desde que recebam
parmetros diferentes. Neste caso, dizemos que h sobrecarga de mtodos.
A entrada de dados do usurio em uma aplicao Java SE pode ser feita
via prompt de comando, utilizando a classe Scanner; via interface grfica,
utilizando a classe JOptionPane; ou via formulrio, utilizando outras classes
do pacote javax.swing.
3.9 Exerccios
A seguir voc encontrar exerccios prticos, onde ter que criar projetos no
NetBeans e digitar o cdigo-fonte de classes, e tambm exerccios para fixar
os conceitos aprendidos neste Captulo. No deixe de fazer estes exerccios.
6) Quantos valores um mtodo pode retornar de cada vez? Justifique sua resposta.
4. Orientao a objetos
conceitos avanados
Ao chegar neste ponto do livro voc precisa ter os conhecimentos bsicos
da orientao a objetos apresentados no Captulo anterior. Precisa ser
capaz de criar classes, com atributos e mtodos, instanciar objetos destas
classes e manipular dados nestes objetos. Precisa tambm entender a funo
do construtor de uma classe, sobrecarga de construtores e sobrecarga de
mtodos.
Alm dos conceitos bsicos da orientao a objetos, precisa estar adaptado ao
uso do NetBeans, tendo condies de criar projetos com pacotes e classes e
compilar e executar estes projetos adequadamente.
Neste Captulo vamos alm dos conceitos bsicos. Voc vai aprender o conceito
de herana em suas vrias formas, que podem ocorrer em graus diferentes de
maneira simples, por meio do uso de interfaces e por meio do uso de classes
abstratas.
4.1 Herana
Herana um conceito proveniente da observao das relaes humanas, onde
os filhos herdam caractersticas dos pais; e da modelagem de dados, onde
tabelas especializadas herdam atributos de tabelas generalizadas.
Voc vai usar herana quando possuir um conjunto de atributos e/ou mtodos
que comum a um conjunto de classes e possuir alguns deles que so
especficos de cada classe. Nesse caso, voc centraliza os que so comuns em
uma superclasse e os especficos coloca nas respectivas subclasses, de tal forma
que estas subclasses herdem os atributos e/ou mtodos comuns da superclasse.
Segundo Horstmann (2009, p. 400),
a herana um mecanismo para estender as classes existentes adicionando novos mtodos e campos. A classe
mais geral chama-se superclasse e a classe mais especializada, que herda da superclasse chama-se subclasse.
NOTA
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
NOTA
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
this.limiteCheque = limiteCheque;
this.juroCheque = juroCheque;
public ContaCorrente() {
}
public double getLimiteCheque() {
return limiteCheque;
}
public void setLimiteCheque(double limiteCheque) {
this.limiteCheque = limiteCheque;
}
public double getJuroCheque() {
return juroCheque;
}
NOTA
Em uma subclasse, sempre que voc quiser acessar mtodos da superclasse, basta digitar a palavra super seguida do ponto final e do nome
do mtodo. Por exemplo: super.getNomeCliente(); Vale lembrar que o
mtodo deve permitir acesso, ou seja, deve ser pblico (public) ou protegido (protected).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Date;
public class ContaPoupanca extends Conta {
private Date dataAniversario;
public ContaPoupanca(Date dataAniversario, String noBanco, String noAgencia,
String noConta, String nomeCliente, double saldo) {
super(noBanco, noAgencia, noConta, nomeCliente, saldo);
this.dataAniversario = dataAniversario;
}
public ContaPoupanca() {
}
public Date getDataAniversario() {
return dataAniversario;
}
1
2
3
4
5
6
limiteCheque
juroCheque
noBanco
noAgencia
noConta
nomeCliente
saldo
ctCor2
10000.00
6.5
035
143-2
01435-9
Evandro
32789.50
setLimiteCheque(double limiteCheque): void
getLimiteCheque(): double
setJuroCheque(double juroCheque): void
getJuroCheque(): double
setNoBanco(String noBanco): void
getNoBanco(): String
setNoAgencia(String noAgencia): void
getNoAgencia(): String
setNoConta(String noConta): void
getNoConta(): String
setNomeCliente(String nomeCliente): void
getNomeCliente(): String
setSaldo(double saldo): void
getSaldo(): double
import java.util.Date;
public class Principal {
public static void main(String[] args) {
ContaCorrente ctCor2;
ContaPoupanca ctPoup;
Date data;
data = new Date("07/10/2014");
ctCor2 = new ContaCorrente(10000.00, 6.5, "035", "143-2", "01435-9",
"Evandro", 32789.50);
ctPoup = new ContaPoupanca(data, "022", "347-2", "003491-1", "Ana Luiza",
18976.40);
System.out.println("Banco:" + ctCor2.getNoBanco() + "\n"
11
12
13
Observe na linha 7 que foi instanciado um objeto da classe Date onde foi
armazenada a data de 07/10/2014 neste objeto. Est ser a data de aniversrio
da conta poupana.
Na linha 8 foi instanciado um objeto da subclasse ContaCorrente.java, que
j estudamos anteriormente, e na linha 9 foi instanciado um objeto da classe
ContaPoupanca.java.
Na linha 10 o contedo dos atributos do objeto ctCor2 obtido por meio de
chamadas aos mtodos getter correspondentes e exibidos na tela. J na linha
11, o contedo dos atributos do objeto ctPoup tambm obtido por meio de
chamadas aos mtodos getter e exibidos na tela.
Quando voc compilar e executar o projeto por meio do pressionamento da
tecla F6, ser apresentado na tela o seguinte resultado:
Banco:035
Agncia:143-2
Conta:01435-9
Cliente:Evandro
Saldo:32789.5
Limite:10000.0
Juros do Cheque especial:6.5
Banco:022
Agncia:347-2
Conta:003491-1
Cliente:Ana Luiza
Saldo:18976.4
Data de aniversrio da conta:Thu Jul 10 00:00:00 BRT 2014
Para alterar o contedo dos objetos podem ser feitas chamadas aos respectivos
mtodos setter. Veja, por exemplo, como poderiam ser includos novos valores
no objeto ctCor2 aps sua criao na classe Principal.java.
ctCor2.setNoBanco("546");
ctCor2.setNoConta("6758-9");
ctCor2.setNoAgencia("01564-2");
ctCor2.setNomeCliente("Marco Antnio");
ctCor2.setSaldo(23456.65);
ctCor2.setJuroCheque(5.9);
ctCor2.setLimiteCheque(1200.5);
Para inserir valores no objeto ctPoup voc pode chamar os mtodos setter
correspondentes de forma semelhante incluso que fizemos no objeto ctCor2.
}
public class ContaPoupanca Extends Conta {
}
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
this.peso = peso;
@Override
public double calcularPreco() {
return super.getValorBase() * this.peso;
}
17
18
19
20
21
22
@Override
public double calcularPreco(){
return (super.getValorBase() * this.quantidade) super.getValorBase() *
20/100;
}
}
Ao compilar e executar este projeto, o que pode ser feito pelo pressionamento
da tecla F6, ser exibido na tela os seguintes valores:
Preo de Arroz igual a 105.0
Preo de Camisa igual a 102.9
Note que foram instanciados dois objetos p1 e p2 (linhas 3 e 4), ambos do tipo
Produto.java, porm, com chamadas ao construtor de subclasses diferentes. O
objeto p1 foi instanciado por meio de uma chamada ao construtor da subclasse
Alimento.java e o objeto p2 por meio uma chamada ao construtor da subclasse
Vestuario.java. Em ambas as instncias, foram passados os mesmos valores
numricos utilizados para calcular o preo do produto.
Na linha 5 mostrado o nome do produto contido no atributo nome do objeto
p1 e o preo, calculado por meio de uma chamada ao mtodo calcularPreco.
4.2 Interfaces
Uma interface, na orientao a objetos, um tipo de classe que contm apenas
mtodos abstratos, ou seja, mtodos que possuem apenas a assinatura, sem
corpo. Podem tambm possuir constantes. A implementao (construo) dos
membros feita por uma classe concreta que implementa a interface.
Segundo Horstmann (2009, p. 361), um tipo interface em Java declara um
conjunto de mtodos e suas assinaturas e permite tornar o cdigo da aplicao
mais reutilizvel.
Para declarar uma classe como interface utiliza-se no lugar da instruo class
a instruo interface. Veja o exemplo a seguir:
public interface Operacoes{
}
Nas interfaces, os mtodos no podem ter corpo, ou seja, devem ter apenas
uma assinatura (declarao).
Veja o exemplo da interface chamada Operacoes.java que possui a assinatura
do mtodo calcularMedia.
public interface Operacoes{
public abstract double calcularMedia(double n1, double n2);
}
O mtodo no tem corpo entre chaves e termina com ponto e vrgula. Esta forma
de declarao chamada de assinatura do mtodo. A assinatura do mtodo mostra
de onde o mtodo pode ser acessado, o que o mtodo retorna, o nome do mtodo
e os parmetros que eventualmente o mtodo recebe, sem dizer o que o mtodo
faz. Ela mostra apenas o que necessrio saber para acessar o mtodo.
Ao contrrio das classes simples, uma interface nunca poder ser instanciada,
por isso, no pode conter um construtor, j que o construtor utilizado para
instncia de objetos. Voc instancia a classe que implementa a interface, no
a interface em si.
Para uma classe implementar a interface, ela deve ter, na linha da sua
declarao, a instruo implements. Veja o exemplo:
public class Professor implements Operacoes {
@Override
public double calcularMedia(double n1, double n2) {
return (n1+n2)/2;
}
}
NOTA
Note que, para indicar que a classe implementa a interface, utilizou-se uma
linha tracejada com seta apontando para a interface. Acima do nome da interface
foi utilizado o esteretipo <<interface>>. Um esteretipo, neste caso, uma
palavra que identifica uma categoria especial de classe.
As interfaces podem ser implementadas por diversas classes. Alis, esta uma
das grandes finalidades das interfaces, centralizar operaes obrigando diversas
classes que necessitam destas operaes a implement-las. Por exemplo, voc
pode centralizar a operao de login de um sistema em uma interface Login.
java e obrigar as classes Funcionario.java, Cliente.java e Fornecedor.java a
implementar a operao de login assinada na interface.
Uma classe pode implementar diversas interfaces. Por exemplo, se a classe
Professor.java deseja implementar as interfaces Operacoes.java e Aulas.java,
sua declarao deve ser:
public class Professor implements Operacoes, Aulas {
}
NOTA
Uma interface pode definir uma srie de mtodos, mas nunca conter
implementao deles. Ela s expe o que seus mtodos devem fazer, e
no como eles fazem. Como eles fazem ser definido em uma implementao dessa interface.
33
34
35
36
37
38
39
40
41
this.diasTrabalhados = diasTrabalhados;
@Override
public double calcularSalarioLiquido() {
return valorDia*diasTrabalhados;
}
}
import javax.swing.JOptionPane;
public class Principal {
public static void main(String[] args) {
String nom;
double sal, valDia, valLiquido;
int diasTrab;
nom = JOptionPane.showInputDialog("Digite o nome do funcionrio
mensalista");
sal = Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do
salrio"));
FuncionarioMensalista fm = new FuncionarioMensalista(nom, sal);
valLiquido = fm.calcularSalarioLiquido();
System.out.println("Funcionrio: " + fm.getNome() + "\nValor lquido a
receber: " + valLiquido);
nom = JOptionPane.showInputDialog("Digite o nome do funcionrio
Diarista");
valDia = Double.parseDouble(JOptionPane.showInputDialog("Digite o valor
do dia trabalhado"));
16
17
18
19
20
21
Maria
1000.00
setNome(String nome): void
getNome(): String
setSalario(double salario): void
getSalario(): double
calcularSalarioLiquido():double
do dia trabalhado e 10 para dias trabalhados no ms, este objeto ter o formato
mostrado na Figura 4.12.
fd
nome
valorDia
diasTrabalhados
Joo
100.00
10
setNome(String nome): void
getNome(): String
setValorDia(double valorDia): void
getValorDia(): double
setDiasTrabalhados(int diasTrabalhados): void
getDiasTrabalhados(): int
calcularSalarioLiquido():double
NOTA
Uma classe pode implementar diversas interfaces, desde que escreva o corpo
dos mtodos assinados de todas estas interfaces. Para demostrar como isso
possvel, vamos criar uma pequena aplicao com as classes mostradas no
diagrama a seguir:
@Override
public String metodoB(double valor) {
if (valor <= 10) {
return "Valor vlido";
} else {
return "Valor invlido";
}
}
1
2
3
4
5
6
7
8
9
NOTA superclasse. J nas relaes com interfaces, uma classe pode implementar mtodos de diversas interfaces, sendo obrigada a implement-los.
Veja neste exemplo que h dois mtodos abstratos (que contm apenas a
assinatura) e um mtodo concreto (implementado).
Classes abstratas, assim como as interfaces, servem apenas como modelo para
classes concretas. Como so modelos de classes, no podem ser instanciadas
diretamente com a instruo new, mas podem ser herdadas por classes concretas
(subclasses). Uma classe pode herdar uma classe abstrata da mesma forma
que uma subclasse herda de uma superclasse nas relaes de herana simples,
utilizando a instruo extends. Veja o exemplo a seguir:
@Override
public void desconectar() {
// a implementao do mtodo deve ocorrer aqui
}
NOTA
Uma classe abstrata semelhante a uma superclasse nas relaes de herana simples, com a grande diferena de poder ter assinaturas de mtodos, obrigando as subclasses a implement-los, o que no ocorre nas
relaes de herana simples.
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
19
@Override
public String obterCargo() {
switch (super.getCategoria()) {
case "A":
return "Gerente";
case "B":
return "Contador";
default:
return "Auxiliar";
}
}
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
}
public String getAreaAtuacao() {
return areaAtuacao;
}
public void setAreaAtuacao(String areaAtuacao) {
this.areaAtuacao = areaAtuacao;
}
@Override
public String obterCargo() {
switch (super.getCategoria()) {
case "A":
return "Pesquisador";
case "B":
return "Professor";
default:
return "Tutor";
}
}
Observe que esta classe herda a classe abstrata Funcionario.java (linha 1), o
que a obriga a criar um construtor (linhas de 5 a 8) e a implementar o mtodo
obterCargo (linhas de 18 28).
Note que o mtodo obterCargo, apesar de ter implementao semelhante nas
subclasses Administrativo.java e Academico.java, retornam valores diferentes,
por isso precisam ser implementados em cada uma das subclasses da classe
abstrata.
Note tambm que o construtor necessrio, pois ele precisa receber parmetros
e pass-los para os atributos da classe abstrata Funcionario.java, o que feito
pela instruo super (linha 6).
Para terminar a aplicao, escreva o cdigo-fonte da classe Principal.java, por
onde instanciaremos os objetos das subclasse Administrativo.java e Acedemico.
java. O cdigo-fonte da classe Principal.java apresentado a seguir:
1
2
3
4
5
6
7
8
9
10
NOTA
A chamada ao mtodo obterCargo (que possui implementao diferente nas subclasses), por meio de dois objetos (adm e aca) de subclasses
do mesmo tipo de classe abstrata, configura polimorfismo, j que estes
objetos do mesmo tipo de classe abstrata apresentaro comportamentos
diferentes, principalmente nesta chamada de mtodos.
Mesma
classe
x
x
x
x
Mesmo
pacote
Subclasses
Todas as
classes
x
x
x
x
x
6
7
8
9
10
11
12
13
14
15
16
public Cliente() {
}
public double obterRendaAjustada() {
return this.renda + obterValor();
}
NOTA
Apesar de voc poder declarar os atributos de uma classe como pblicos, como viu no exemplo apresentado, isso no comum nem indicado, pois outros objetos poderiam, em algumas circunstncias, ter acesso
ao contedo dos atributos, j que so pblicos. O ideal sempre declarar os atributos da classe como privados e criar mtodos getter e setter pblicos para eles.
import javax.swing.JOptionPane;
public class Calculo {
private final double IR=27.5;
public Calculo() {
}
private double obterPercentual(){
return Double.parseDouble (JOptionPane.showInputDialog ("Digite o valor do
percentual: "));
}
Veja que na linha 4 foi criada a constante privada IR do tipo double contendo
o valor 27.5. Como sabe, no ser possvel, na aplicao, mudar o valor
armazenado, pois trata-se de uma constante. A palavra final quem define que
se trata de uma constante.
Nas linhas de 9 11 foi criado o mtodo privado obterPercentual. Por ser
privado, este mtodo s poder ser chamado de dentro desta classe. A chamada
a este mtodo ocorre da linha 14, do interior do mtodo ajustarSalario. O
mtodo obterPercentual solicita um percentual, converte em double e retorna.
import javax.swing.JOptionPane;
public class Teste {
public static void main(String[] args) {
double salario = Double.parseDouble (JOptionPane.showInputDialog
("Digite o valor do percentual: "));
Calculo c = new Calculo();
System.out.print ("Salrio Lquido: " + c.ajustarSalario(salario));
}
}
NOTA
No Java, um recurso protegido (protected) pode ser acessado de classes do mesmo pacote em que est a classe que contm o recurso e de
subclasses em uma relao de herana. Porm, na maioria das demais
linguagens orientadas a objeto, um recurso protegido s poder ser acessado de subclasses em uma relao de herana.
Quando o objeto func torna-se nulo, ele vira candidato a ser desalocado da
memria pelo Garbage Collector.
Tipos primitivos (char, byte, short, int, long, float, double e boolean)
Garbage Collector.
4.6 Anotaes
Anotaes (ou annotations, em ingls) so instrues iniciadas pelo caractere
arroba (@) que podem fornecer informaes sobre o cdigo Java (seja sobre
um mtodo ou uma classe) e, apesar de muitas vezes se assemelharem a
comentrios, podem ser interpretadas pelos compiladores.
Algumas anotaes comuns utilizadas em Java so @Deprecated e @Override.
@Deprecated uma anotao colocada na linha anterior declarao de um
mtodo para indicar que seu uso desencorajado por ser perigoso ou por ter
uma alternativa melhor j desenvolvida.
@Override uma anotao colocada na linha anterior declarao de um
mtodo para indicar que ele est sendo sobrescrito, ou seja, que existe este
mtodo em uma superclasse e ele est sendo escrito de outra forma na subclasse.
Esta anotao normalmente utilizada em aplicaes que utilizam classes
relacionadas por herana onde se deseja obter polimorfismo.
Existem inmeras outras anotaes relacionadas a tecnologias Java especficas,
principalmente sobre Java EE (Enterprise Edition).
4.7 Resumo
As relaes de herana na programao orientada a objetos podem ocorrer de
vrias maneiras e utilizando vrios recursos, como herana simples, interfaces
e classes abstratas.
Voc deve utilizar herana na sua forma pura e simples quando tem um
conjunto de atributos e/ou mtodos comuns que deseja que vrias subclasses
compartilhem. Para no repetir essa parte comum nas subclasses da relao de
herana, centralize-os na superclasse e herde-os nas subclasses. As subclasses
podero ter, alm dos recursos herdados, seus prprios recursos (atributos,
mtodos etc.). Uma subclasse pode herdar de apenas uma superclasse. No
h herana mltipla em Java antes da verso 8, porm, a verso 8 j permite
herana mltipla. As subclasses tambm podem ser superclasses de outras
subclasses, em cadeias de herana.
Voc deve utilizar interfaces quando deseja obrigar que um conjunto de classes
implementem os mesmos mtodos, porm, de maneiras diferentes. Estas classes
tambm podero implementar seus prprios mtodos especficos.
4.8 Exerccios
Voc encontrar a seguir exerccios prticos, onde precisar criar projetos e
escrever o cdigo-fonte de vrias classes e exerccios para fixar os conceitos
tericos do Captulo. No deixe de resolv-los e esclarecer dvidas com seu
professor, caso voc seja um estudante de ensino tcnico ou superior.
<<interface>>
Validador
validarDocumento() : Boolean
Pessoa
nome : String
escreverNome()
validarDocumento() : Boolean
Fisica
Juridica
cnpj : String
cpf : String
escreverNome()
validarDocumento() : Boolean
escreverNome()
validarDocumento() : Boolean
Filme
FilmeNormal
FilmeInfantil
FilmeLanamento
16) Uma classe pode implementar mais de uma interface? Justifique sua resposta.
17) Quando uma classe implementa uma interface, o que ela ser obrigada a fazer?
18) O que um mtodo abstrato e em que tipos de classes eles podem aparecer?
19) Explique as diferenas entre os modificadores de visibilidade public,
private, protected?
5. Mtodos estticos e
tratamento de excees
Para acessar os mtodos pblicos de uma classe necessrio instanciar um
objeto desta classe, correto?
Est correto desde que o mtodo no seja esttico. Mtodos estticos podem
ser acessados diretamente a partir do nome da classe, sem precisar de instncia
de objetos desta classe.
Programar usando mtodos estticos, de certa forma, faz perder a caracterstica
principal da orientao a objetos, que acessar recursos das classes por
meio de objetos destas classes. O uso de mtodos estticos e tipos de dados
primitivos fazem com que Java no seja considerada por muitos profissionais
uma linguagem totalmente orientada a objetos. Em uma linguagem totalmente
orientada a objetos, os recursos (mtodos, atributos, variveis, constantes) s
podem ser acessados a partir da instncia de um objeto da classe que contm
o recurso.
Esse assunto renderia um captulo a parte, por isso, vamos deixar estas
discusses de lado e vamos entender como podemos aproveitar os mtodos
estticos nas nossas aplicaes.
O caso principal de uso de mtodos estticos em uma aplicao para
criar bibliotecas de classes de apoio cujos mtodos podero ser acessados
diretamente, sem instncia de objetos. Assim, de qualquer classe da aplicao
voc poder chamar os mtodos estticos das classes includas na biblioteca
do projeto. Veremos isso em um exemplo que ser apresentado no decorrer
deste captulo.
Alm de apresentar os mtodos estticos, sero apresentadas ainda as principais
formas de realizar tratamento de excees em Java. Excees so entradas no
esperadas nos mtodos, arrays e outras estruturas da aplicao. Por exemplo,
quando a aplicao est esperando e digitao do valor do salrio e o usurio
digita seu nome, ocorrer uma exceo, pois a aplicao est esperando um
valor double, mas entrou um valor String. Outro exemplo comum quando
voc tem, por exemplo, uma array com 3 posies numeradas de 0 2. Se voc
tentar, por engano, incluir um valor em uma posio que no existe, ocorrer
uma exceo. Existem inmeros outros casos em que excees podem causar
srias interrupes na execuo do programa e comprometer todo o sistema.
Para que isso no ocorra, as excees precisam ser tratadas de forma que se
ocorrerem o programa possa contorn-las com o menor impacto possvel.
No decorrer deste captulo sero apresentados exemplos de tratamento das
principais excees.
Esta operao calcula 103, logo, a varivel b receber o valor 1000.00. Note
que o mtodo pow da classe Math.java chamado diretamente por meio do
nome da classe. Veja como este mtodo escrito na classe Math.java:
public static double pow (double a, double b){
return StrictMath.pow(a,b);
}
Sempre que digitar o nome de uma classe que possui mtodos e/ou constantes
acessveis, estes mtodos/constantes aparecero em uma lista para que voc
possa escolh-los, ao invs de digit-los. Este um recurso do NetBeans para
facilitar a vida do desenvolvedor.
Outros exemplos que utilizamos anteriormente foram os mtodos estticos
da classe JOptionPane.java, que vem instalada no pacote javax.swing, que
estudaremos no Captulo 6. Veja um exemplo de uso do mtodo esttico
showInputDialog desta classe:
import javax.swing.JOptionPane;
public class Principal {
public static void main(String[] args) {
String c = JOptionPane.showInputDialog( "Digite o nome da cidade");
}
}
String sal="12678.56";
double d = Double.parseDouble(sal);
Veja que foi chamado o mtodo esttico valueOf da classe String.java. Observe
como este mtodo est escrito na classe String.java:
public static String valueOf(int i) {
return Integer.toString(i);
}
classe chamada Principal.java no pacote padro. Veja na Figura 5.2 como deve
estar seu projeto aps realizar estes procedimentos.
package calc.mat;
public class Calculo {
public static double soma(double a, double b) {
return a + b;
}
public static double soma(double a, double b, double c) {
return a + b + c;
}
public static int soma(int a, int b) {
return a + b;
}
public static String obterInfo() {
return "Esta uma classe teste";
}
Note que h vrios mtodos, todos estticos, que executam tarefas especficas.
Note que vrios destes mtodos possuem o mesmo nome, mas recebem
parmetros diferentes. O nome disto sobrecarga de mtodos, lembra? J
discutimos isso em captulos anteriores.
NOTA
Na mesma classe podem haver mtodos estticos e no estticos. A diferena ser apenas a forma de acesso. Para acessar os mtodos estticos,
basta digitar o nome da classe, o ponto final e o nome do mtodo. Para
acessar os mtodos no estticos, ser necessrio instanciar um objeto da
classe e fazer o acesso por meio deste objeto.
import calc.mat.Calculo;
public class Principal {
package calc.mat;
public class Soma {
public static double soma(double a, double b) {
return a + b;
}
public static double soma(double a, double b, double c) {
return a + b + c;
}
package calc.mat;
public class Multiplica {
public static double mult(int a, int b) {
return a * b;
}
public static double mult(double a, double b) {
return a * b;
}
Agora que voc j digitou o cdigo-fonte das duas classes, vamos gerar a
biblioteca. Para isso, ter que compilar a aplicao e gerar um arquivo de
distribuio que ter o mesmo nome do projeto, mas com a extenso .jar. Clique
no menu Executar e na opo Limpar e Construir Projeto (Matematica).
Ser gerado o arquivo Matematica.jar na subpasta dist, contida na pasta do
projeto. O caminho provavelmente ser \Matematica\dist\Matematica.jar.
Nossa biblioteca o arquivo Matematica.jar.
Para usar a biblioteca criada, vamos iniciar um novo projeto Java chamado
NovoProjeto. Nesse projeto, crie uma classe principal chamada Principal.java.
Clique na pasta Biblioteca do projeto com o boto direito do mouse e
selecione a opo Adicionar Jar/Pasta, como mostra a Figura 5.4.
Figura 5.4: Adicionando uma biblioteca JAR na pasta Bibliotecas do projeto Java
criado com o NetBeans.
Figura 5.5: Exibio das bibliotecas de classes do projeto criado com o uso do NetBeans.
import calc.mat.Multiplica;
import calc.mat.Soma;
public class Principal {
Note nas linhas 7 e 8 que so chamados os mtodos das classes que esto na
biblioteca do projeto, diretamente pelo nome da classe, afinal, os mtodos so
estticos.
Veja na mensagem que j aparece o nome da classe que deve ser utilizada no
catch para tratar a exceo, a classe ArithmeticException, e tambm a descrio
do erro /by zero.
Para evitarmos que a exceo cause o erro mostrado na Figura 5.6, altere o
cdigo-fonte da classe Principal.java para:
public class Principal {
public static void main(String[] args) {
int a = 2;
int b = 0;
try {
int c = a / b;
} catch (ArithmeticException x) {
System.out.println("No possvel dividir por zero");
}
}
}
Outros dados do erro podem ser obtidos por meio deste objeto.
Vamos a outro exemplo prtico.
Veja que a classe que deve ser utilizada no catch para o tratamento da exceo
a classe ArrayIndexOutOfBoundsException.
Para resolver este problema, voc pode alterar a classe da seguinte forma:
0
1
2
3
4
5
6
7
8
9
10
11
Veja que a linha 3 pode gerar uma exceo de falta da classe Driver.class e
desviar para a linha 6, onde os dados do erro ficaro no objeto ex da classe
ClassNotFoundException, e ser retornado para quem chamou o mtodo o
valor 2.
A linha 4 pode gerar uma exceo por encontrar dados incorretos do banco
de dados. Os dados do erro ficaro no objeto x da classe SQLException e ser
retornado o valor 3 para que chamou o mtodo.
Note que o mtodo acima retorna um valor inteiro para quem cham-lo. Se as
linhas 3 e 4 forem executadas sem erro, ser retornado o valor 1. Se a linha
2 gerar a exceo de ClassNotFoundException, ser retornado o valor 2. Se
a linha 4 gerar uma exceo do tipo SQLException, ser retornado o valor 3.
Com os valores retornados quem chamou o mtodo saber o que ocorreu na
sua execuo. Os mtodos de acesso a bancos de dados sero melhor estudados
no Captulo 7 deste livro.
NOTA
Caso voc no tenha certeza de qual exceo ser gerada, pode usar uma forma
de tratamento de exceo genrica, por meio da classe Exception. Veja a seguir
o mtodo apresentado anteriormente tratado desta forma:
1
2
3
4
5
6
7
8
9
("jdbc:mysql://
Note que qualquer tipo de exceo que ocorrer nas linhas do interior das chaves
do try ir desviar para o catch, que receber em um objeto da classe Exception
informaes da exceo e retornar o valor 2. Nesse caso, duas excees
diferentes podem ocorrer, uma na linha 3 e outra na linha 4. O desvio para um
nico catch no permite diferenciar o tratamento das duas, mas apresentar um
tratamento genrico. Este o motivo pelo qual esta forma de tratamento de
excees no recomendada.
declara que pode lanar o erro, e se este ocorrer, o mtodo que o chamou deve
tratar a exceo.
Se voc colocar throws na declarao do mtodo, voc est dizendo algo como:
Olha, tem certas operaes que eu executo mas que no tenho a mnima ideia de
como resolver, resolva voc.
Por exemplo:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Dao {
public int conectar(String driver, String url, String usuario, String senha)
throws ClassNotFoundException, SQLException{
Class.forName(driver);
Connection conn = DriverManager.getConnection (url, usuario, senha);
return 1;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import java.sql.SQLException;
public class Principal {
public static void main(String[] args) {
Dao d = new Dao();
try {
int r = d.conectar();
} catch (ClassNotFoundException ex) {
System.out.print("A classe do driver de acesso ao banco de dados no est
dispponvel");
} catch (SQLException ex) {
System.out.print("H um erro nos dados de conexo com o banco de dados");
}
}
}
NOTA lidade pelo tratamento das excees que possam ocorrer no mtodo a
quem cham-lo.
As formas mais comuns de lidar com excees foram apresentadas neste captulo,
mas h muito mais sobre excees. Voc pode conferir no link: <http://blog.
caelum.com.br/lidando-com-exceptions/> um bom artigo intitulado Lidando
com Exceptions. Se deseja informaes mais tcnicas, acesse o link:
<http://www.caelum.com.br/apostila-java-orientacao-objetos/excecoes-e-con
trole-de-erros/#11-11-exercicios-excecoes>.
5.3 Resumo
5.4 Exerccios
1) Analise o cdigo abaixo e preencha corretamente a lacuna:
public static void metodo() {
try {
new java.io.FileInputStream("arquivo.txt");
} catch (____________________ e) {
System.out.println("Nao foi possvel abrir o arquivo para leitura");
}
}
A) Trate a exceo que ser gerada se for digitado na primeira caixa de dilogo
o valor abaixo:
B) Trate a exceo que ser gerada se for digitado na segunda caixa de dilogo
o valor abaixo:
7) Crie uma classe em um projeto Java com um mtodo esttico para calcular
a mdia entre trs notas, descartando a menor delas, calculando a mdia das
duas maiores e retornando o resultado. Construa o arquivo .JAR do projeto.
Crie um novo projeto e adicione o arquivo .JAR biblioteca. Crie uma classe
principal nesse projeto, leia trs notas e utilize o mtodo esttico da classe que
est na biblioteca do projeto para calcular a mdia.
6. Criao de
interface grfica
NOTA
No posicionamento esttico voc tem controle total sobre o layout que est
sendo criado, mas precisa fazer normalmente um conjunto de clculos para
que os elementos no sejam posicionados uns sobre os outros.
Quando se utiliza os gerenciadores de layout (que so classes e mtodos
especficos para lidar com o layout dos contineres) o alinhamento,
posicionamento e dimensionamento dos componentes feito automaticamente.
A vantagem que voc no precisa fazer clculos para posicionar componentes.
A desvantagem que voc tem que se contentar com os layouts pr-definidos,
tendo pouca liberdade de modificao e personalizao.
Os gerenciadores de layout so classes contidas no pacote java.awt. Estas
classes so: FlowLayout, GridLayout, BorderLayout e GridBagLayout. Voc
pode ainda, se desejar, misturar o uso dos gerenciadores de layout, caso
necessrio.
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class TelaCliente extends JFrame{
private JLabel lblNome, lblRenda;
private JTextField txtNome, txtRenda;
private JButton btnSalvar, btnSair;
public TelaCliente() {
// definindo propriedades do formulrio
setLayout(null);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(600, 200);
setLocation(200, 300);
setTitle("Controle de Clientes");
//Definindo propriedades dos campos do formulrio
lblNome = new JLabel("Nome:");
lblNome.setSize(50,30);
lblNome.setLocation(30,10);
add(lblNome);
txtNome = new JTextField();
txtNome.setSize(480,30);
txtNome.setLocation(80,10);
add(txtNome);
lblRenda = new JLabel("Renda:");
lblRenda.setSize(50,30);
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
lblRenda.setLocation(30,45);
add(lblRenda);
txtRenda = new JTextField();
txtRenda.setSize(100,30);
txtRenda.setLocation(80,45);
add(txtRenda);
btnSalvar = new JButton("Salvar");
btnSalvar.setSize(80,30);
btnSalvar.setLocation(30,90);
add(btnSalvar);
setSize(600, 200);
setLocation(200, 300);
As linhas a seguir criam o campo vazio para a digitao do nome, por meio de
um objeto txtNome da classe JTextField (linhas 25 28). Veja na Figura 6.5
como este campo aparecer na janela.
txtNome = new JTextField();
txtNome.setSize(480,30);
txtNome.setLocation(80,10);
add(txtNome);
As linhas a seguir criam o rtulo Renda: por meio de um objeto lblRenda da classe
JLabel (linhas 30 33). Veja na Figura 6.6 como este rtulo aparecer na janela.
As linhas a seguir criam o campo vazio para a digitao da renda por meio de
um objeto txtRenda da classe JTextField (linhas 35 38). Veja na Figura 6.7
como este campo aparecer na janela.
txtRenda = new JTextField();
txtRenda.setSize(100,30);
txtRenda.setLocation(80,45);
add(txtRenda);
Quando voc chama um mtodo a partir de um objeto, este mtodo pode ser
da classe que instanciou o objeto ou de qualquer uma de suas subclasses,
quando esta classe herda outras classes. Veja por exemplo a seguinte chamada
ao mtodo setSize:
btnSair = new JButton("Sair");
btnSair.setSize(80,30);
NOTA que faz parte de uma cadeia de herana, o mtodo pode ser de qualquer
uma das classes da cadeia de herana.
Para gerar a tela programada na classe TelaCliente.java, necessrio instanciar um objeto desta classe, o que feito na classe Principal.java, cujo
cdigo-fonte apresentado a seguir:
1
2
3
4
5
6
Voc deve ter observado que utilizamos duas classes para criar a aplicao:
TelaCliente.java e Principal.java.
Poderamos ter conseguido o mesmo resultado apenas com a classe Principal.
java. Para isso, o cdigo-fonte desta classe deveria ficar da seguinte forma:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import javax.swing.JButton;
import javax.swing.JFrame;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class Principal extends JFrame {
private JLabel lblNome, lblRenda;
private JTextField txtNome, txtRenda;
private JButton btnSalvar, btnSair;
public Principal() {
// definindo propriedades do formulrio
setLayout(null);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(600, 200);
setLocation(200, 300);
setTitle("Controle de Clientes");
//Definindo propriedades dos campos do formulrio
lblNome = new JLabel("Nome:");
lblNome.setSize(50, 30);
lblNome.setLocation(30, 10);
add(lblNome);
txtNome = new JTextField();
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
txtNome.setSize(480, 30);
txtNome.setLocation(80, 10);
add(txtNome);
lblRenda = new JLabel("Renda:");
lblRenda.setSize(50, 30);
lblRenda.setLocation(30, 45);
add(lblRenda);
txtRenda = new JTextField();
txtRenda.setSize(100, 30);
txtRenda.setLocation(80, 45);
add(txtRenda);
btnSalvar = new JButton("Salvar");
btnSalvar.setSize(80, 30);
btnSalvar.setLocation(30, 90);
add(btnSalvar);
NOTA
6.2.1 FlowLayout
Este gerenciador de layout o mais simples de todos e possui as seguintes
caractersticas:
import java.awt.FlowLayout;
import javax.swing.*;
public class Principal extends JFrame {
private JLabel lblNome, lblRenda;
private JTextField txtNome, txtRenda;
private JButton btnSalvar, btnSair;
public Principal() {
// Propriedades da janela
setTitle("Exemplo de Flow layout");
setLayout(new FlowLayout());
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(600, 200);
setLocation(200, 300);
// definio dos componentes da janela
lblNome = new JLabel("Nome:");
add(lblNome);
txtNome = new JTextField(45);
add(txtNome);
lblRenda = new JLabel("Renda:");
add(lblRenda);
txtRenda = new JTextField(15);
add(txtRenda);
btnSalvar = new JButton("Salvar");
add(btnSalvar);
btnSair = new JButton("Sair");
28
29
30
31
32
33
34
35
add(btnSair);
A linha 11 define que o layout da janela ser FlowLayout utilizando o posicionamento padro ao centro. Caso voc queira que o alinhamento seja esquerda,
precisa digitar a seguinte instruo:
setLayout(new FlowLayout(FlowLayout.LEFT));
6.2.2 BorderLayout
O gerenciador de layout BorderLayout divide o continer em cinco reas: norte,
sul, leste, oeste e centro. Alm de no manter o tamanho original dos componentes
durante o redimensionamento (j que eles so aumentados de acordo com a tela),
o continer pode receber somente um componente por rea. A Figura 6.14 mostra
como o gerenciador de layout BorderLayout divide a janela.
NOTA
import java.awt.BorderLayout;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class Tela extends JFrame {
private JButton btnCentro, btnLeste, btnOeste, btnNorte, btnSul;
public Tela() {
setTitle("Exemplo com Border Layout");
setLayout(new BorderLayout());
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(700, 200);
setLocation(300, 200);
btnCentro = new JButton("Centro");
add(btnCentro, BorderLayout.CENTER);
btnLeste = new JButton("Leste");
add(btnLeste, BorderLayout.EAST);
btnSul = new JButton("Sul");
add(btnSul, BorderLayout.SOUTH);
btnNorte = new JButton("Norte");
add(btnNorte, BorderLayout.NORTH);
btnOeste = new JButton("Oeste");
add(btnOeste, BorderLayout.WEST);
}
Veja que foi colocado um boto em cada regio do layout j que s permitido
um elemento por rea e eles ocuparam todo o espao daquela rea. Se voc
aumentar ou diminuir a janela, o tamanho dos botes aumenta ou diminui
proporcionalmente.
NOTA
Este tipo de layout utilizado para que cada regio da janela receba
novos contineres (normalmente JPanel) e estes contineres menores
agrupem elementos como botes, rtulos, campos texto etc. Veremos
como fazer isso mais adiante neste captulo.
6.2.3 GridLayout
O gerenciador de layout GridLayout divide o continer em linhas e colunas
como uma tabela com clulas (grid). Se voc aumentar ou diminuir a janela,
o tamanho dos componentes acompanharo proporcionalmente as novas
dimenses da janela, ou seja, se voc aumentar a janela, o tamanho dos
componentes aumenta, se diminuir, o tamanho dos componentes diminui. Em
cada clula do grid, ou seja, em cada posio do layout, voc pode colocar
apenas um elemento.
import java.awt.GridLayout;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class Tela extends JFrame {
private JLabel lblNome, lblRenda;
private JTextField txtNome, txtRenda;
private JButton btnSalvar, btnSair;
private JButton sim, nao, cancelar;
private JLabel mensagem;
public Tela() {
setTitle("Exemplo com GridLayout");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new GridLayout(3, 2));
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
setSize(600, 200);
setLocation(300, 200);
lblNome = new JLabel("Nome:");
add(lblNome);
txtNome = new JTextField();
add(txtNome);
lblRenda = new JLabel("Renda:");
add(lblRenda);
txtRenda = new JTextField();
add(txtRenda);
btnSalvar = new JButton("Salvar");
add(btnSalvar);
btnSair = new JButton("Sair");
add(btnSair);
NOTA
Note que a linha 34 instancia um objeto da prpria classe Tela.java por meio
do comando new, que chama o construtor da classe (linhas de 13 31). Nessa
operao, todo o contedo do construtor executado, gerando a tela. A linha
35 exibe a janela.
6.2.4 GridBagLayout
O gerenciador de layout GridBagLayout o mais flexvel de todos, porm,
o mais complexo, pois cada elemento deve conter uma posio inicial, uma
posio final, um tamanho, uma escala, um alinhamento e um preenchimento.
Ele divide o continer em linhas e colunas como uma tabela com clulas (grid).
Dependendo do alinhamento dentro de uma clula, pode ou no manter o
tamanho original dos componentes. Em cada clula, pode ser colocado apenas
um componente e cada clula pode ser expandida para ocupar o espao de
uma ou mais clulas adjacentes usando regras especficas de alinhamento e
posicionamento.
Quando se utiliza o gerenciador de layout GridBagLayout, um objeto da classe
GridBagConstraints normalmente utilizado para determinar o posicionamento
do elemento na grid.
import java.awt.*;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class Tela extends JFrame {
private JButton btn1, btn2, btn3, btn4;
public Tela() {
setTitle("Exemplo com GridBagLayout");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(500, 200);
setLayout(new GridBagLayout());
GridBagConstraints gridCons = new GridBagConstraints();
btn1 = new JButton("Um");
btn2 = new JButton("Dois");
btn3 = new JButton("Trs");
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
gridCons.gridx = 0;
gridCons.gridy = 3;
add(btn4, gridCons);
Nome:
Renda:
Salvar
Sair
Note que:
O rtulo Nome: est na posio gridx=0 e gridy=0, ocupando duas
colunas (gridwidth=2).
O campo para o preenchimento do nome est na posio gridx=2 e gridy=0,
ocupando quatro colunas (gridwidth=4).
O rtulo Renda: est na posio (gridx=0 e gridy=1), ocupando duas
colunas (gridwidth=2).
O campo para o preenchimento da renda est na posio gridx=2 e gridy=1,
ocupando duas colunas (gridwidth=2).
O boto Salvar est na posio (gridx=1 e gridy=2), ocupando duas
colunas (gridwidth=2).
O boto Sair est na posio (gridx=3 e gridy=2), ocupando duas colunas
(gridwidth=2).
Para gerar a tela apresentada, crie um novo projeto chamado ProjetoGridBagNovo
e uma classe principal chamada Tela.java, conforme mostra a Figura 6.23.
import java.awt.*;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class Tela extends JFrame {
private JLabel lblNome, lblRenda;
private JTextField txtNome, txtRenda;
private JButton btnSalvar, btnSair;
public Tela() {
setTitle("Exemplo com GridBagLayout");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(700, 200);
setLayout(new GridBagLayout());
GridBagConstraints gridCons = new GridBagConstraints();
lblNome = new JLabel("Nome:");
txtNome = new JTextField(45);
lblRenda = new JLabel("Renda:");
txtRenda = new JTextField(15);
btnSalvar = new JButton("Salvar");
btnSair = new JButton("Sair");
gridCons.gridx = 0;
gridCons.gridy = 0;
gridCons.gridwidth = 2;
add(lblNome, gridCons);
gridCons.gridx = 2;
gridCons.gridy = 0;
gridCons.gridwidth = 4;
add(txtNome, gridCons);
gridCons.gridx = 0;
gridCons.gridy = 1;
gridCons.gridwidth = 2;
gridCons.insets = new Insets(15, 0, 8, 0);
add(lblRenda, gridCons);
gridCons.gridx = 2;
gridCons.gridy = 1;
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
gridCons.gridwidth = 2;
gridCons.anchor = GridBagConstraints.WEST;
add(txtRenda, gridCons);
gridCons.gridx = 1;
gridCons.gridy = 2;
gridCons.gridwidth = 2;
gridCons.insets = new Insets(5, 5, 5, 5);
gridCons.anchor = GridBagConstraints.CENTER;
add(btnSalvar, gridCons);
gridCons.gridx = 3;
gridCons.gridy = 2;
gridCons.gridwidth = 2;
gridCons.anchor = GridBagConstraints.CENTER;
add(btnSair, gridCons);
Neste exemplo ser comentado apenas o que novo em relao aos exemplos
anteriores. Veja que o rtulo lblNome, criado na linha 18, ser posicionado na
coluna 0 e linha 0 e ter duas colunas de largura.
J o campo txtNome, criado na linha 19, ser posicionado na coluna 2 e linha
0 e ter 4 colunas de largura.
O rtulo lblRenda, criado na linha 20, ser posicionado na coluna 0 e linha 1
e ter duas colunas de largura. Note que este rtulo ter 15 pixels de margem
superior e 8 pixel de margem inferior. Isso foi definido pela propriedade insets
(linha 38) com objetivo de desgrudar o contedo desta linha das demais.
O campo txtRenda, criado na linha 21, ser posicionado na coluna 2 e linha 1 e
ter 2 colunas de largura. Como o tamanho deste campo no chega a preencher
as duas colunas, ele foi alinhado esquerda pela propriedade anchor da linha 44.
O boto btnSalvar, criado na linha 22, ser posicionado na coluna 1 e linha 2
e ter 2 colunas de largura. Este boto ter uma margem de 5 pixel em todos
os seus lados (linha 50) e ser centralizado (linha 51).
O boto btnSair, criado na linha 23, ser posicionado na coluna 3 e linha 2 e
ter 2 colunas de largura. Este boto ser centralizado (linha 57).
Figura 6.25: Exemplo de Layout que utiliza Grid BagLayout com mesclagem de clulas.
DICA
import java.awt.*;
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
import java.util.Date;
public class Tela extends JFrame {
private JPanel pnlBotoes;
private JPanel pnlBarraStatus;
private JScrollPane pnlScrTexto;
private JButton btnNovo, btnLimpar, btnSalvar, btnSair;
private JLabel lblMensagem, lblHora;
private JTextArea txtAreaTexto;
public Tela() {
// Propriedades da janela (JFrame)
setTitle("Layout composto");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocation(200, 130);
setSize(640, 480);
setLayout(new BorderLayout());
// Criao dos elementos
btnNovo = new JButton("Novo");
btnSalvar = new JButton("Salvar");
btnLimpar = new JButton("Limpar");
btnSair = new JButton("Sair");
lblMensagem = new JLabel("Mensagem: ");
lblHora = new JLabel("Data e Hora: " + new Date().toString());
txtAreaTexto = new JTextArea("Digite seu texto aqui: ", 20, 40);
pnlScrTexto = new JScrollPane(txtAreaTexto,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
// Criao do painel para colocar os botes e adio dos botes a
este painel
pnlBotoes = new JPanel(new FlowLayout());
pnlBotoes.add(btnNovo);
pnlBotoes.add(btnSalvar);
pnlBotoes.add(btnLimpar);
pnlBotoes.add(btnSair);
// Criao do painel para a barra de status e adio dos botes a
este painel
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
Em uma janela (JFrame), que considerada um continer, podem ser adicionados diversos elementos, inclusive outros contineres, como JScrollPane e
JPanel. Contineres criados pela classe JPanel podem conter a maioria dos
outros elementos de tela, como caixas de texto, rtulos, caixas de combinao
etc. Contineres criados pela classe JScrollPane podem conter caixas de texto
dimensionadas com colunas e linhas definidas e j permitem apresentar barra
de rolagem.
Para entender o cdigo apresentado, segue a explicao das principais linhas.
Note que esta aplicao composta por quatro painis:
A janela JFrame.
O painel para colocar os botes (pnlBotoes).
O painel com a caixa de texto (pnlScrTexto).
O painel para compor uma barra de status (pnlBarraStatus).
A janela (JFrame) foi configurada para utilizar o layout BorderLayout (linha 21).
O painel para inserir os botes (pnlBotoes) foi configurado para usar o
gerenciador de layout FlowLayout (linha 34).
O painel para inserir a barra de status (pnlBarraStatus) foi configurado para
usar o gerenciador de layout FlowLayout (linha 41).
Para a rea de texto (pnlScrTexto) no foi definido gerenciador de layout
(linhas 30 e 31).
txtAreaTexto.setForeground(Color.blue);
Ou ainda:
txtAreaTexto.setForeground(new Color(255,0,126));
Ou ainda:
Color cor = new Color(0,255,0);
txtAreaTexto.setForeground(cor);
Ou ainda:
txtAreaTexto.setForeground(Color.green);
Ou ainda:
pnlBarraStatus.setBorder( new LineBorder(Color.RED, 2) );
Note que a aplicao no elemento da borda definida ocorre por meio do mtodo
setBorder da classe do elemento em que se quer aplicar a borda. Para que estas
instrues funcionem ter que importar as classes Border e LineBorder, por
meio das instrues:
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
Por:
Toolkit tk = Toolkit.getDefaultToolkit();
Dimension d = tk.getScreenSize();
int largura = d.width/2;
Note que o tamanho da tela obtido por meio de uma chamada ao mtodo
getScreenSize da classe Toolkit e armazenado em um objeto d da classe
Dimension. Por meio desse objeto possvel obter a largura (width) e a altura
(height) da tela. A diviso por 2 utilizada para achar o ponto central da tela
(eixos x e y). A janela ter a largura e a altura da medida deste ponto central,
o que definido na passagem do parmetro para o mtodo setSize. O ponto de
posio inicial da janela ser a medida do ponto central dividida por dois, o
que definido no parmetro passado ao mtodo setLocation.
Neste tpico, vamos utilizar outros componentes que nos permitir criar
interfaces mais ricas, com menus (classe JMenuBar), caixas de dilogo (classe
JOptionPane), combos (classe JComboBox), listas (classe JList) e tabelas
(classe JTable).
import javax.swing.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class TelaMenu extends JFrame {
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
NOTA
Voc tambm pode pedir a informao colocando ttulo na janela e personalizando o cone que aparece esquerda. Veja como na linha abaixo:
String nome = JOptionPane.showInputDialog(null, "Qual seu nome?: ", "Cadastro", JOptionPane.
DEFAULT_OPTION);
Como visto nos captulos anteriores, para receber o valor digitado em uma
varivel de tipo numrico primitivo voc deve converter o valor digitado de
String para o tipo numrico desejado.
Veja os exemplos a seguir:
byte idade = Byte.parseByte(JOptionPane.showInputDialog("Qual a sua idade"));
int cod = Integer.parseInt(JOptionPane.showInputDialog("Digite o cdigo do produto"));
long codBarra = Long.parseLong(JOptionPane.showInputDialog("Digite o cdigo de barras"));
double sal = Double.parseDouble(JOptionPane.showInputDialog("Digite o salrio"));
import javax.swing.*;
import java.awt.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class Tela extends JFrame {
private JButton btnSalvar, btnAbrir;
private JCheckBox chkTeatro, chkCinema, chkTv;
private JRadioButton rdoMasculino, rdoFeminino;
private JToggleButton tglAlarme;
private JPanel pnlBotoes1, pnlBotoes2, pnlBotoes3, pnlBotoes4;
public Tela() {
// Propriedades dajanela JFrame
setTitle("Exemplo com botes");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new GridLayout(4, 1));
setSize(300, 200);
setLocation(300, 200);
// Criao (instncia) dos botes
btnSalvar = new JButton("Salvar");
btnAbrir = new JButton("Abrir");
chkTeatro = new JCheckBox("Teatro");
chkCinema = new JCheckBox("Cinema");
chkTv = new JCheckBox("TV");
rdoMasculino = new JRadioButton("Masculino");
rdoFeminino = new JRadioButton("Feminino");
tglAlarme = new JToggleButton("Alarme");
// Criao do painel 1 e adio de botes
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
Observe que os botes de cada linha esto em um painel diferente. Note que podem
ser selecionados vrios botes check da segunda linha, porm na terceira linha
permitido selecionar apenas um sexo por meio dos botes radio. Na terceira linha
o boto Alarme pode ser ativado com um clique e desativado com outro. Veja
na Figura 6.38 como ficar a janela aps as algumas selees de botes.
Para testar o uso dessas classes, crie um novo projeto chamado ProjetoCampos,
com uma classe chamada Tela.java, como mostra a Figura 6.39.
import javax.swing.*;
import java.awt.*;
import java.text.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
import javax.swing.text.MaskFormatter;
public class Tela extends JFrame {
private JLabel lblNome, lblNascimento, lblTelefone, lblCpf, lblCep, lblEndereco;
private JTextField txtNome;
private JFormattedTextField txtNascimento, txtCep, txtTelefone, txtCpf;
private JTextArea txtEndereco;
MaskFormatter mskCep, mskTelefone, mskCpf, mskNascimento;
public Tela() {
setLayout(new GridLayout(6, 1));
FlowLayout esquerda = new FlowLayout(FlowLayout.LEFT);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(600, 450);
setLocation(300, 200);
// Criao dos rtulos dos campos
lblNome = new JLabel("Nome");
lblNascimento = new JLabel("Nascimento");
lblTelefone = new JLabel("Telefone");
lblCpf = new JLabel("CPF");
lblCep = new JLabel("CEP");
lblEndereco = new JLabel("Endereo");
// Criao dos campos e definio das mscaras quando pertinente
txtNome = new JTextField(40);
try {
mskNascimento = new MaskFormatter("##/##/####");
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
mskNascimento.setPlaceholderCharacter('_');
mskTelefone = new MaskFormatter("(##)####-####");
mskTelefone.setPlaceholderCharacter('_');
mskCpf = new MaskFormatter("#########-##");
mskCpf.setPlaceholderCharacter('_');
mskCep = new MaskFormatter("#####-###");
mskCep.setPlaceholderCharacter('_');
} catch (ParseException ex) {
JOptionPane.showMessageDialog (null,"Erro na definio das
mscaras dos campos");
}
txtNascimento = new JFormattedTextField(mskNascimento);
txtTelefone = new JFormattedTextField(mskTelefone);
txtCpf = new JFormattedTextField(mskCpf);
txtCep = new JFormattedTextField(mskCep);
txtEndereco = new JTextArea("", 3, 40);
JScrollPane scrollEndereco = new JScrollPane(txtEndereco,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
// Criao do painel para insero do rtulo e do campo nome
JPanel pnlNome = new JPanel(esquerda);
pnlNome.add(lblNome);
pnlNome.add(txtNome);
// Criao do painel para insero do rtulo e do campo nascimento
JPanel pnlNascimento = new JPanel(esquerda);
pnlNascimento.add(lblNascimento);
pnlNascimento.add(txtNascimento);
// Criao do painel para insero do rtulo e do campo telefone
JPanel pnlTelefone = new JPanel(esquerda);
pnlTelefone.add(lblTelefone);
pnlTelefone.add(txtTelefone);
// Criao do painel para insero do rtulo e do campo CPF
JPanel pnlCpf = new JPanel(esquerda);
pnlCpf.add(lblCpf);
pnlCpf.add(txtCpf);
// Criao do painel para insero do rtulo e do campo CEP
JPanel pnlCep = new JPanel(esquerda);
pnlCep.add(lblCep);
pnlCep.add(txtCep);
// Criao do painel para insero do rtulo e do campo endereo
JPanel pnlEndereco = new JPanel(esquerda);
pnlEndereco.add(lblEndereco);
pnlEndereco.add(scrollEndereco);
// Adio dos paineis janela
add(pnlNome);
74
75
76
77
78
79
80
81
82
83
84
85
86
add(pnlNascimento);
add(pnlTelefone);
add(pnlCpf);
add(pnlCep);
add(pnlEndereco);
}
DICA
Use sempre que possvel painis para agrupar campos ou para agrupar
rtulo e campo. Painis podem ser configurados e formatados facilmente,
podendo receber cores, bordas etc.
Veja na Figura 6.41 como fica a tela aps o preenchimento dos campos.
txtCep.setBackground(Color.red);
Define a cor de fundo para o campo.
txtCep.setFont(new Font("Arial", Font.BOLD, 14));
Define uma configurao de fonte para o campo.
txtCep.setText("04135-090");
Inclui o valor entre aspas no campo.
Para trabalhar com listas utilizando a API swing normalmente voc utiliza duas
classes principais: JList e DefaultListModel.
A classe JList cria a lista. Se quisermos utilizar um modelo de lista j existente
(o que indicado) utilizamos a classe DefaultListModel.
Para entender como trabalhar com listas, crie um projeto chamado ProjetoLista
com uma classe principal chamada TelaLista.java, conforme mostra a Figura
6.42.
import javax.swing.*;
import java.awt.*;
public class TelaLista extends JFrame {
private JList lstCidades;
private DefaultListModel lstCidadesModel;
public TelaLista() {
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Para criar uma lista foram utilizados objetos de duas classes: DefaultListModel
e JList. Quando foi instanciado um objeto da classe JList que efetivamente criou
a lista, foi preciso passar como parmetro o objeto da classe DefaultListModel,
indicando que a lista utiliza um modelo padro (linha 19).
Note nas linhas de 22 24 que so criadas trs variveis do tipo String como
nomes de cidades que sero colocadas na lista nas linhas de 26 28 por meio dos
mtodos addElement da classe DefaultListModel. As opes da lista recebem um
nmero de ndice iniciado por 0, na ordem que so inseridas na lista.
Na linha 30 a lista adicionada janela (JFrame) utilizando o gerenciador de
layout BorderLayout. Veja que a lista posicionada na rea CENTER, ou
seja, na rea central do layout.
Para que a lista tenha um rtulo como ttulo, um objeto da classe JLabel foi
instanciado na linha 32 e adicionado janela, ao norte.
Veja que foi clicado na primeira opo da lista e ela ficou selecionada. Voc
pode rolar o cursor sobre os elementos da lista utilizando as teclas de direo
do teclado ou clicar na opo que deseja selecionar.
lstCidadesModel.removeElementAt(2);
Remove o elemento de ndice 2.
lstCidadesModel.set(2, "Votuporanga");
Substitui o item de ndice 2 da lista por "Votuporanga".
lstCidadesModel.setSize(2);
Define o nmero de elementos visveis na lista.
Neste caso voc poderia utilizar no objeto lstCidades da classe JList para
acessar diversos mtodos importantes, dentre eles:
int indiceSelecionado = lstCidades.getSelectedIndex();
Obtm o nmero de ndice da opo selecionada na lista.
lstCidades.setForeground(Color.BLUE);
Define uma cor de letra para as opes da lista.
lstCidades.setFont(new Font("Arial", Font.BOLD, 14));
Define uma configurao de fonte para as opes da lista.
import javax.swing.*;
import java.awt.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class TelaCombo extends JFrame {
private JComboBox cmbCidades;
private DefaultComboBoxModel cmbCidadesModel;
public TelaCombo() {
setTitle("Exemplo ComoBox");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(300, 200);
setLocation(300, 200);
cmbCidadesModel = new DefaultComboBoxModel();
cmbCidades = new JComboBox(cmbCidadesModel);
String cidade1 = "So Paulo";
String cidade2 = "Rio de Janeiro";
String cidade3 = "Campinas";
cmbCidadesModel.addElement(cidade1);
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
cmbCidadesModel.addElement(cidade2);
cmbCidadesModel.addElement(cidade3);
cmbCidades.setEditable(true);
JPanel auxNomes = new JPanel();
auxNomes.add(cmbCidades);
add(auxNomes, BorderLayout.WEST);
cmbCidadesModel.removeAllElements();
Remove todos os elementos da lista.
cmbCidadesModel.removeElement("Campinas");
Remove o elemento "Campinas" da lista.
cmbCidadesModel.removeElementAt(1);
Remove o elemento de ndice 1 da lista.
cmbCidadesModel.setSelectedItem("Itu");
Muda o item selecionado da lista para "Itu".
Voc pode perceber que na classe apresentada adicionamos os itens caixa de
combinao (JComboBox) por meio de seu modelo (DefaultComboBoxModel)
utilizando o mtodo addElement (linhas de 24 26). Voc poderia adicionar
os elementos diretamente caixa de combinao, dispensando o modelo, da
seguinte forma:
String[] cidades = new String[]{"So Paulo", "Rio de Janeiro", "Campinas"};
JComboBox cmbCidades = new JComboBox(cidades);
Ou ainda:
JComboBox cmbCidades = new JComboBox();
cmbCidades.addItem("So Paulo");
cmbCidades.addItem("Rio de Janeiro");
cmbCidades.addItem("Campinas");
Veja alguns mtodos que podem ser aplicados por meio do objeto cmbCidades
da classe JComboBox, sem utilizar o DefaultComboBoxModel:
cmbCidades.removeItem("Rio de Janeiro");
Remove o item "Rio de Janeiro" da caixa de combinao.
cmbCidades.removeItemAt(1);
Remove o segundo item da caixa de combinao, de cima para baixo, ou seja,
o item "Rio de Janeiro", que tem ndice 1.
cmbCidades.removeAllItems();
Remove todos os itens da caixa de combinao.
cmbCidades.setSelectedItem("Campinas");
A opo selecionada e visvel na caixa de combinao ser "Campinas".
cmbCidades.setSelectedIndex(2);
cmbCidades.setMaximumRowCount(2);
Define o nmero de opes que estar visvel quando abrir a caixa de combinao.
Para testar o uso destas classes, crie um novo projeto chamado ProjetoTabela
com uma classe principal chamada TelaTabela.java, conforme mostra a Figura
import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
public class TelaTabela extends JFrame {
private JTable tblClientes;
private DefaultTableModel tblClientesModel;
public TelaTabela() {
setTitle("Exemplo de tabela");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(400, 200);
setLocation(300, 200);
String[] cols = {"Cdigo", "Nome", "E-mail"};
tblClientesModel = new DefaultTableModel(cols, 4);
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
Note que na linha 17 foi criada uma array unidimensional e nela foram
armazenados os valores que sero rtulos das colunas da tabela. Esta array
foi adicionada tabela na linha 18, juntamente com o nmero de linhas que a
tabela dever ter, neste caso, 4 linhas.
Na linha 19 foi instanciado um objeto da classe JTable aplicando o modelo de
tabela instanciado na linha 18.
Nas linhas de 21 24 foram criadas arrays unidimensionais com os valores
que sero adicionados em cada linha da tabela. Nas linhas de 26 29, estas
arrays foram adicionadas tabela, respectivamente, nas linhas de 0 3, pois
apesar da tabela ter 4 linhas, a numerao vai de 0 3.
Na linha 30 foi definido o nmero de linhas da tabela, neste caso, 4 linhas.
Na linha 32, a tabela foi adicionada barra de rolagem, indicando, pelos
parmetros, que estas barras (verticais e horizontais) estaro sempre visveis,
independente do contedo da tabela exceder a rea disponvel ou no. Na linha
Eventos de Janela.
Eventos de Foco.
Eventos de Mouse.
Nos tpicos seguintes sero apresentados exemplos de cada uma dessas
categorias.
A classe Aplicativo.java vai gerar uma janela com diversos campos e dois
botes: Adicionar tabela e Limpar campos. Ao preencher os campos e
clicar no boto Adicionar tabela, o contedo dos campos so adicionados
uma tabela na parte inferior da janela. Ao clicar no boto Limpar campos,
todos os campos so limpos.
Veja a seguir o cdigo-fonte da classe Aplicativo.java:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.ParseException;
import static javax.swing.JFrame.EXIT_ON_CLOSE;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
import javax.swing.text.MaskFormatter;
public class Aplicativo extends JFrame implements ActionListener {
private JPanel pnlCampos, pnlTabela, pnlBotoes, pnlNome,
pnlTelefone, pnlCidade;
private TitledBorder tituloPnlCampos, tituloPnlTabela, tituloPnlBotoes;
private JLabel lblNome, lblTelefone, lblCidade;
private JTextField txtNome;
private JFormattedTextField txtTelefone;
private MaskFormatter mskTelefone;
private JTable tblClientes;
private DefaultTableModel tblClientesModel;
JButton btnAdicionar, btnLimpar;
private JComboBox cmbCidades;
private DefaultComboBoxModel cmbCidadesModel;
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public Aplicativo() {
definirJanela();
pnlCampos = new JPanel(new GridLayout(3, 1));
tituloPnlCampos = BorderFactory.createTitledBorder("Cadastro de
Clientes");
pnlCampos.setBorder(tituloPnlCampos);
pnlBotoes = new JPanel(new FlowLayout());
tituloPnlBotoes = BorderFactory.createTitledBorder("Botes");
pnlBotoes.setBorder(tituloPnlBotoes);
pnlTabela = new JPanel(new GridLayout(1, 1));
tituloPnlTabela = BorderFactory.createTitledBorder("Tabela de
exibio de dados");
pnlTabela.setBorder(tituloPnlTabela);
lblNome = new JLabel("Nome");
lblTelefone = new JLabel("Telefone");
lblCidade = new JLabel("Cidade");
txtNome = new JTextField(50);
try {
mskTelefone = new MaskFormatter("(##)####-####");
mskTelefone.setPlaceholderCharacter('_');
} catch (ParseException ex) {
JOptionPane.showMessageDialog(null, "Mscara incorreta");
}
txtTelefone = new JFormattedTextField(mskTelefone);
cmbCidadesModel = new DefaultComboBoxModel();
cmbCidades = new JComboBox(cmbCidadesModel);
String cidade1 = "So Paulo";
String cidade2 = "Rio de Janeiro";
String cidade3 = "Campinas";
cmbCidadesModel.addElement(cidade1);
cmbCidadesModel.addElement(cidade2);
cmbCidadesModel.addElement(cidade3);
pnlNome = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlNome.add(lblNome);
pnlNome.add(txtNome);
pnlCampos.add(pnlNome);
pnlTelefone = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlTelefone.add(lblTelefone);
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
pnlTelefone.add(txtTelefone);
pnlCampos.add(pnlTelefone);
pnlCidade = new JPanel(new FlowLayout(FlowLayout.LEFT));
pnlCidade.add(lblCidade);
pnlCidade.add(cmbCidades);
pnlCampos.add(pnlCidade);
btnAdicionar = new JButton("Adicionar tabela");
btnAdicionar.addActionListener(this);
btnLimpar = new JButton("Limpar campos");
btnLimpar.addActionListener(this);
pnlBotoes.add(btnAdicionar);
pnlBotoes.add(btnLimpar);
String[] cols = {"Nome", "Telefone", "Cidade"};
tblClientesModel = new DefaultTableModel(cols, 3);
tblClientes = new JTable(tblClientesModel);
tblClientesModel.setNumRows(0);
JScrollPane scrRolagem = new JScrollPane(tblClientes,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
pnlTabela.add(scrRolagem);
add(pnlCampos, BorderLayout.NORTH);
add(pnlBotoes, BorderLayout.CENTER);
add(pnlTabela, BorderLayout.SOUTH);
113
114
115
116
117
118
119
120
121
122
123
if (e.getSource() == btnAdicionar) {
String[] linha = {txtNome.getText(), txtTelefone.getText(),
cmbCidadesModel.getSelectedItem().toString()};
tblClientesModel.addRow(linha);
} else if (e.getSource() == btnLimpar) {
txtNome.setText(null);
txtTelefone.setText(null);
cmbCidadesModel.setSelectedItem("So Paulo");
txtNome.requestFocus();
}
Figura 6.50: Janela com campos preenchidos e tratamento de evento de clique em botes.
1
2
3
4
5
6
7
8
9
10
11
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JOptionPane;
public class EventoOpen extends WindowAdapter {
@Override
public void windowOpened(WindowEvent we) {
JOptionPane.showMessageDialog(null, "A janela foi aberta");
}
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JOptionPane;
public class EventoClose extends WindowAdapter {
@Override
public void windowClosing(WindowEvent we) {
int resp = JOptionPane.showConfirmDialog(null, "Deseja sair ?");
if (resp == JOptionPane.YES_OPTION) {
System.exit(0);
}
}
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class Tela extends JFrame {
private JLabel lblNome;
private JTextField txtNome;
public Tela() {
setTitle("Eventos de Janela");
setSize(300, 200);
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
setLayout(new FlowLayout());
lblNome = new JLabel("Nome");
txtNome = new JTextField(20);
add(lblNome);
add(txtNome);
addWindowListener(new EventoClose());
addWindowListener(new EventoOpen());
}
Esta uma classe comum, que gera uma janela com um boto para a incluso
do nome. Criamos dezenas de classes como esta nos tpicos anteriores, por
isso, vamos explicao apenas do necessrio.
Veja na linha 14 que a finalizao automtica da aplicao ao se clicar no X
do canto superior direito da janela foi cancelada. Isso foi necessrio porque
queremos que ao clicar no X seja gerado um evento e chamado o mtodo
windowClosing da classe EventoClose.java.
O mtodo addWindowListener da linha 20 monitora a janela at que ela feche.
Quando isso ocorrer, um objeto da classe EventoClose.java instanciado
e passado como parmetro para este mtodo. Isso faz com que o mtodo
windowClosing da classe EventoClose.java seja executado.
O mesmo acontece na linha 21, mas com a classe EventoOpen.java, que executa
o mtodo windowOpened.
Perceba que so as linhas 20 e 21 que puxam o gatilho, quando o evento
ocorre e direcionam para os mtodos corretos para trat-los. Dessa forma, se
deseja apenas tratar o evento de fechamento da janela, mantenha a linha 20 e
retire a linha 21. Se deseja apenas tratar o evento de abertura da janela, mantenha
apenas a linha 21.
Apesar de termos criado uma classe para tratar cada evento, poderamos tratar
os eventos dentro da mesma classe que gera a tela. Nesse caso, a aplicao
teria apenas uma classe, mas o cdigo ficaria um pouco mais complexo. Veja
abaixo como ficar o cdigo-fonte, neste caso:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.awt.FlowLayout;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
public class Tela extends JFrame {
private JLabel lblNome;
private JTextField txtNome;
public Tela() {
setTitle("Eventos de Janela");
setSize(300, 200);
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
setLayout(new FlowLayout());
lblNome = new JLabel("Nome");
txtNome = new JTextField(20);
add(lblNome);
add(txtNome);
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent we) {
int resp = JOptionPane.showConfirmDialog(null, "Deseja sair ?");
if (resp == JOptionPane.YES_OPTION) {
System.exit(0);
}
}
});
addWindowListener(new WindowAdapter() {
@Override
public void windowOpened(WindowEvent we) {
JOptionPane.showMessageDialog(null, "A janela foi aberta");
}
});
38
39
40
41
42
43
44
Nesse projeto, ser gerada uma janela com dois campos: nome e renda. Quando
o campo renda ganhar o foco do cursor, ser chamado o mtodo focusGained da
classe EventoGanhaFoco.java. Quando o campo perder o foco, ser chamado
o mtodo focusLost da classe EventoPerdeFoco.java.
1
2
3
4
5
6
7
8
9
10
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
public class EventoGanhaFoco extends FocusAdapter {
@Override
public void focusGained(FocusEvent e) {
System.out.println("O campo Renda ganhou o foco");
}
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
public class EventoPerdeFoco extends FocusAdapter {
@Override
public void focusLost(FocusEvent e) {
System.out.println("O campo Renda perdeu o foco");
}
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class Tela extends JFrame {
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Caso queira, ao invs de criar classes auxiliares para tratar os eventos de ganho
e perda de foco, pode fazer diretamente na classe que gera a janela, ou seja,
na classe Tela.java, da seguinte forma:
1
2
3
4
5
6
import java.awt.FlowLayout;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
add(lblNome);
add(txtNome);
add(btnSalvar);
btnSalvar.addMouseListener(new MouseAdapter() {
@Override
public void mouseEntered(MouseEvent we) {
btnSalvar.setBackground(Color.yellow);
}
@Override
public void mouseExited(MouseEvent evt) {
btnSalvar.setBackground(Color.red);
}
});
Voc pode perceber que o tratamento de eventos em Java no uma tarefa fcil.
A maioria dos eventos tratados nos exemplos deste Captulo foram aplicados
apenas a alguns tipos de elementos da janela, mas a forma de tratamento de
eventos sobre outros elementos ocorre de forma semelhante.
Mais frente neste Captulo voc ver que h maneiras mais simples de se
trabalhar com a criao de interfaces de usurio utilizando as APIs swing e
awt no NetBeans.
Nesse tpico vamos criar uma aplicao simples que utiliza duas janelas e
mostrar como se faz para passar de uma para outra, quando necessrio. Vamos
tambm criar uma aplicao que utiliza abas na mesma janela e mostrar como
se alterna entre elas.
Criar uma aplicao que utiliza vrias janelas no uma tarefa difcil. Difcil
mesmo ajustar os elementos nas janelas de maneira adequada. O exemplo
que ser apresentado a seguir composto por uma nica classe que cria trs
janelas JFrame e alterna entre elas por meio de clique em botes. No teremos
a preocupao em colocar outros elementos nas janelas, pois o objetivo
explicar as operaes de alternncia entre janelas. Vamos ento ao exemplo.
Crie um novo projeto Java no NetBeans chamado AplicativoMultijanelas com
uma classe principal chamada Menu.java, conforme mostra a Figura 6.59.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Menu extends JFrame implements ActionListener {
JFrame frmJanela1, frmJanela2;
JButton btnJanela1, btnJanela2, btnVolta1, btnVolta2;
public Menu() {
//Programao da janela principal
setTitle("Janela Principal");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new FlowLayout());
btnJanela1 = new JButton("Chama Janela 1");
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
btnJanela1.addActionListener(this);
btnJanela2 = new JButton("Chama Janela 2");
btnJanela2.addActionListener(this);
add(btnJanela1);
add(btnJanela2);
setBounds(100, 100, 300, 200);
//Programao da janela 1
frmJanela1 = new JFrame("Janela 1");
frmJanela1.setDefaultCloseOperation(EXIT_ON_CLOSE);
frmJanela1.setBounds(100, 100, 300, 200);
frmJanela1.getContentPane().setBackground(Color.yellow);
btnVolta1 = new JButton("Voltar");
frmJanela1.add(btnVolta1, "South");
btnVolta1.addActionListener(this);
//Programao da janela 2
frmJanela2 = new JFrame("Janela 2");
frmJanela2.setDefaultCloseOperation(EXIT_ON_CLOSE);
frmJanela2.setBounds(100, 100, 300, 200);
frmJanela2.getContentPane().setBackground(Color.green);
btnVolta2 = new JButton("Voltar");
frmJanela2.add(btnVolta2, "South");
btnVolta2.addActionListener(this);
}
@Override
public void actionPerformed(ActionEvent e) {
Object btn = e.getSource();
if (btn == btnJanela1) {
setVisible(false);
frmJanela1.setVisible(true);
}
if (btn == btnJanela2) {
setVisible(false);
frmJanela2.setVisible(true);
}
if (btn == btnVolta1) {
setVisible(true);
frmJanela1.setVisible(false);
}
if (btn == btnVolta2) {
setVisible(true);
frmJanela2.setVisible(false);
62
63
64
65
66
67
68
69
NOTA
Se for clicado no boto Voltar, a janela atual ficar oculta e a janela principal
ser mostrada na tela novamente.
Voc deve ter observado que trabalhar com janelas em uma nica classe no
uma tarefa difcil, porm, dependendo da quantidade de elementos que
forem colocados na janela, o cdigo-fonte pode ficar muito grande e difcil de
gerenciar e manter. Nesse caso, uma alternativa criar uma classe que herda a
classe JFrame para cada janela. Quando um boto de uma janela for clicado,
voc instancia um objeto da classe referente a outra janela e a torna visvel.
NOTA
Quando voc criar aplicao com vrias janelas, alterne entre elas tornando visvel a que voc deseja, e invisvel a que no quer ver. Isto
feito por meio do mtodo setVisible do objeto referente janela.
Para testar o trabalho com abas, crie um novo projeto Java no NetBeans
chamado ProjetoAbas, e nele crie a classe principal TelaAbas.java, como
mostra a Figura 6.62.
Para trabalhar com abas voc deve criar um painel que suporta abas, utilizando
a classe JTabbedPane. Alm desse painel, voc deve criar vrios painis
comuns, utilizando a classe JPanel. Nesses painis comuns voc deve colocar os
elementos que cada aba ter. No final, cada painel JPanel ser ento adicionado
como uma aba do painel JTabbedPane.
Na classe TelaAbas.java, digite o seguinte cdigo-fonte:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.awt.*;
import javax.swing.*;
public class TelaAbas extends JFrame {
private JTabbedPane pnlComGuias;
private JPanel pnl1, pnl2;
private JLabel lblUsuario, lblSenha, lblNome, lblEndereco, lblCidade;
private JTextField txtUsuario, txtNome, txtEndereco, txtCidade;
private JPasswordField txtSenha;
public TelaAbas() {
setTitle("Aplicao de painel com guia");
setSize(300, 200);
setLocation(300,300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setBackground(Color.gray);
//Cria o painel pnl2 que ser includo na primeira aba
pnl1 = new JPanel();
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
pnl1.setLayout(null);
lblUsuario = new JLabel("Username:");
lblUsuario.setBounds(10, 15, 150, 20);
pnl1.add(lblUsuario);
txtUsuario = new JTextField();
txtUsuario.setBounds(10, 35, 150, 20);
pnl1.add(txtUsuario);
lblSenha = new JLabel("Senha:");
lblSenha.setBounds(10, 60, 150, 20);
pnl1.add(lblSenha);
txtSenha = new JPasswordField();
txtSenha.setBounds(10, 80, 150, 20);
pnl1.add(txtSenha);
//Cria o painel pnl2 que ser includo na segunda aba
pnl2 = new JPanel();
pnl2.setLayout(new GridLayout(3, 2));
lblNome = new JLabel("Nome:");
pnl2.add(lblNome);
txtNome = new JTextField();
pnl2.add(txtNome);
lblEndereco = new JLabel("Endereo:");
pnl2.add(lblEndereco);
txtEndereco = new JTextField();
pnl2.add(txtEndereco);
lblCidade = new JLabel("Cidade:");
pnl2.add(lblCidade);
txtCidade = new JTextField();
pnl2.add(txtCidade);
Nas linhas de 21 34 criado o painel pnl1 (linha 21), com layout nulo (linha
22), o que significa que os elementos tero a posio e o tamanho definidos
manualmente por meio do mtodo setBounds. Veja que diversos elementos
so criados e adicionados a este painel.
A linha 23 cria o rtulo Username, que tem sua posio e tamanho definidos
na linha 24 e adicionado ao painel pnl1 na linha 25. O mesmo procedimento
ocorre com o campo texto para entrada do nome do usurio, das linhas 26
28; com o rtulo Senha, das linhas 29 31; e com o campo texto para a
entrada da senha, das linhas 32 34. Veja que o campo para a entrada de senha
criado utilizando a classe JPasswordField (linha 32).
Das linhas 36 50 criado o painel pnl2 (linha 37) com layout GridLayout com
3 linhas e 2 colunas (linha 38). Nas linhas seguintes, de 39 50, so criados
rtulos e campos texto e adicionados a este painel.
Na linha 53 criado o painel que suporta guias, o JTabbedPane. Na linha 54
o painel pnl1 adicionado na primeira guia deste painel com o ttulo de guia
Login. Na linha 55 o painel pnl2 adicionado a este painel com o ttulo de
guia Cadastro. Na linha 56 o painel com as guias (pnlComGuias) adicionado
janela na posio central do layout BorderLayout.
A linha 60 cria um objeto desta classe (TelaAbas.java), o que executa o
construtor da classe, criando a janela e os objetos da janela na memria. A
linha 61 torna tudo isso visvel ao usurio.
Ao compilar e executar o projeto por meio do pressionamento da tecla F6, a
janela da esquerda na Figura 6.63 apresentada na tela.
Perceba na Figura 6.63 que a janela da esquerda mostra a aba Login aberta,
quando a aplicao executada. J a janela da direita mostra a aba Cadastro
aberta, quando o usurio clicar nesta aba. Voc pode alternar entre as abas
facilmente, bastando para isso clicar sobre o ttulo dela.
As abas possuem um ndice numrico comeado por 0 que vai aumentando
na medida em que vo sendo adicionadas janela. Assim, a primeira aba ter
ndice 0, a segunda ter ndice 1, e assim por diante.
A seguir so apresentados os principais mtodos utilizados para executar
operaes com as abas.
pnlComGuias.setSelectedIndex(1);
UNINOVE uso exclusivo para aluno
Agora vamos criar a classe principal, que ser um formulrio JFrame. Execute,
para isso, os seguintes procedimentos:
Veja que na paleta (painel) da direita existe o elemento Label (JLabel), Boto
(JButton), Painel (JPanel) etc. H uma barra de rolagem nessa paleta que
permite visualizar os demais elementos. A Figura 6.67 mostra os elementos
disponveis nesta paleta.
Figura 6.67: Paleta de elementos que podem ser arrastados para o formulrios.
Para mudar as propriedades de qualquer elemento, basta clicar sobre ele que
as propriedades passveis de modificao sero mostradas.
No canto inferior esquerdo da tela h um painel chamado Navegador, onde
so exibidos o nome do formulrio JFrame e os nomes dos elementos includos
no formulrio. Clicando com o boto direito do mouse sobre JFrame, voc
poder definir algumas propriedades do formulrio, como o gerenciador de
layout que ele deve utilizar. A Figura 6.69 mostra este procedimento.
Mude tambm o texto dos elementos, de forma que o formulrio fique com a
aparncia mostrada na Figura 6.75.
Para compilar e executar o projeto e ver como est o visual da tela, basta
pressionar a tecla F6 a qualquer momento.
Chegou a hora de programar os botes. Para isso, clique com o boto direito
do mouse sobre o boto Salvar, selecione a opo Eventos, em seguida
a opo Action e, por ltimo, a opo actionPerformed, como mostra a
Figura 6.77.
Aparecer uma rea para edio de cdigo-fonte, onde o cursor estar na linha
90 da Figura 6.78, e onde deve ser programado o que deve ocorrer quando o
usurio clicar no boto Salvar. A Figura 6.78 mostra detalhes desta rea de
programao.
Na Figura 6.78, alguns detalhes merecem ateno. Veja que por trs daquele
formulrio para onde voc arrasta os elementos, h uma classe gerada
automaticamente, de acordo com os elementos que voc vai adicionando
e com as propriedades que voc vai mudando. Na linha 10 voc pode ver
que a classe foi declarada. Na linha 97 voc pode ver a implementao
do mtodo main, j que esta a classe principal. Na linha 89 voc pode
ver o mtodo btnSalvarActionPerformed, utilizado para programar o
evento de clique no boto Salvar. Na linha 93 voc pode ver o mtodo
btnExcluirActionPerformed, utilizado para programar o evento de clique no
boto Excluir.
Veja que a numerao de linhas do nmero 16 passa para 88. Isso ocorre porque
tem um conjunto de linhas ocultas entre a linha 16 e a linha 88. Para ver essas
linhas, clique no sinal de mais (+) que aparece na linha 16. Voc ver que as
linhas ocultas sero mostradas. Ver que nessas linhas est a programao
referente a gerao dos elementos arrastados para a tela. Voc no pode alterar
o cdigo-fonte dessa rea, pois ela gerada na medida em que voc interage
montando o formulrio. Poder apenas inserir cdigo de programao nos
mtodos de tratamento de evento.
Figura 6.80: menu Janela para exibir paineis fechados por engano.
Veja que voc pode clicar e exibir os painis Projetos, Arquivos e Servios,
que aparecem na parte superior esquerda da rea de trabalho; o painel Paleta,
que aparece na parte superior direita da janela com os elementos que podem
ser arrastados para o formulrio; o painel Propriedades, que aparece na
parte inferior direita da janela e permite mudar as propriedades dos elementos
colocados no formulrio etc.
6.6 Resumo
A interface do usurio uma das partes mais importantes da aplicao, pois
representa todas as telas s quais o usurio tem acesso.
Para criar interfaces grficas de usurio (GUIs) em aplicaes para desktop
com Java utilizam-se as APIs swing e awt. A API swing a evoluo da awt
e composta por diversos pacotes de classes, sendo que os mais utilizados
so javax.swing e javax.swing.event. Nesses pacotes existem um conjunto de
classes que permitem criar, configurar e apresentar qualquer componente de
tela como janelas, painis, rtulos, caixas de texto, menus, tabelas etc, e tratar
eventos que podem ocorrer nesses componentes.
Na criao de uma janela comum o uso da classe JFrame. Para agrupar
componentes na janela comum o uso da classe JLabel. Estas classes
permitem criar contineres para agrupar elementos, normalmente, com
caractersticas comuns.
janelas a criao de abas (ou guias) na mesma janela. Para criar janelas voc
utiliza a classe JFrame, e para criar abas na janela voc pode utilizar as classes
JTabbedPane e JPanel.
Os elementos colocados na janela podem ser formatados, tendo suas propriedades
de formatao alteradas. Assim, voc poder definir cores de fonte e de fundo,
tipo e tamanho de fonte etc. Cada elemento permite mudar um conjunto de
formataes especficas, que podem no ser comuns a todos os elementos.
6.7 Exerccios
Os exerccios sero divididos em duas partes: os exerccios prticos, que
envolvem criao de telas e programao de eventos, e os exerccios conceituais,
que desenvolvem o entendimento dos conceitos apresentados neste captulo.
4) Crie uma aplicao Java que gere a janela com o menu principal abaixo.
Ao ser clicado na opo Cadastro de Clientes, a janela principal deve ser
fechada e deve ser aberta a janela de cadastro de clientes. Ao ser clicado no
boto Cadastro de Produtos, a janela principal deve ser fechada e deve ser
aberta a janela para o cadastro de produtos. Ao clicar no boto Voltar das
telas secundrias, estas janelas devem ser fechadas e a janela principal deve
ser mostrada. Utilize ou no gerenciadores de layout. No utilize recursos de
arrastar/soltar.
5) Crie uma janela que contenha duas abas: Cadastro de Clientes e Cadastro
de Produtos. Cada aba deve conter um conjunto de campos e um boto, como
mostra a Figura a seguir. Utilize ou no gerenciadores de layout. No utilize
recursos de arrastar/soltar.
7) Crie a janela a seguir, considerando que o menu Dados contm a opo Ver
grfico e o menu Operaes contm a opo Sair. Programe a opo Sair, de
forma que ao ser clicada finalize a aplicao. No utilize recursos de arrastar/soltar.
10) Que mtodos so utilizados para mudar a cor do plano de fundo e da fonte
de um elemento?
11) Quais classes da API swing so utilizadas para criar os principais tipos de
botes que podem existir em um continer?
12) A que os botes JRadioButton precisam ser associados para que seja
permitido a seleo de apenas um em um conjunto deste tipo de boto?
13) Que mtodo deve ser utilizado para verificar se um boto foi selecionado?
14) Explique o procedimento necessrio para definir uma mscara de entrada
em um campo formatado.
15) Quais as principais classes utilizadas para criar listas e caixas de combinao
(combos)?
16) Qual mtodo deve ser utilizado para se obter a opo selecionada em uma
caixa de combinao (combo) ou em uma lista?
17) Como se associa um modelo de tabela DefaultTableModel a uma tabela
JTable?
18) Como se adiciona dados em uma linha de um modelo de tabela
DefaultTableModel?
19) Como se obtm um valor selecionado em uma clula de uma tabela JTable?
20) Quais so os principais tipos de eventos que podem ser tratados em
aplicaes desktop que utilizam as APIs swing e awt?
21) Quais classes so normalmente utilizadas para lidar com eventos de ao
de clique do mouse sobre o elemento?
27) Qual classe deve ser utilizada para criar um painel que suporta abas (ou
guias)? O que precisa ser adicionado a este painel para construir as abas?
28) Qual alternativa os desenvolvedores do NetBeans encontraram para agilizar
a criao de interface grfica de usurio?
Use ODBC quando precisar de maior desempenho, j que este padro est
mais integrado ao sistema operacional. Quando precisar de independncia
de plataforma, ou seja, quiser que sua aplicao execute em mquinas com
qualquer sistema operacional, use JDBC.
Neste Captulo utilizaremos o padro JBDC, cujo driver j vem integrado
IDE NetBeans. Com este driver, poderemos conectar a aplicao a qualquer
SGBD, modificando apenas algumas strings de conexo.
Existem outras formas para se acessar banco de dados utilizando frameworks
e bibliotecas de persistncia, mas estes recursos apenas abstraem e escondem
do programador a complexidade do uso da API JDBC, mas no deixam de
utiliz-la.
Clique no boto Executar, caso queira que aps baixar j seja iniciada
a instalao, ou no boto Salvar, para salvar na pasta configurada para
receber os downloads em seu computador. Caso queira escolher a pasta,
clique na setinha preta direita do boto Salvar.
Aps o download ser concludo, abra a pasta onde gravou o arquivo mysqlinstaller-community-5.6.21.0 e clique sobre ele.
Durante a instalao, basta clicar no boto Next, e em algumas telas,
Execute, at chegar tela mostrada na Figura 7.4, onde ser solicitado a
senha para o superusurio root, que j instalado no MySQL.
Aps digitar e repetir a senha que voc deseja atribuir ao servidor MySQL,
clique no boto Next e prossiga a instalao at terminar.
Na tela mostrada na Figura 7.6, j podemos criar nosso banco de dados, as tabelas
que necessitamos e executar outros comandos SQL, caso seja necessrio.
Para criar um novo banco de dados, clique na ferramenta create a new
schema in the connected server, na parte superior da tela. Trata-se de
uma ferramenta com desenho de um barril com um sinal de mais no canto
inferior esquerdo ( ).
Note que nosso banco de dados bd001 j est na lista de bancos de dados
existentes.
Aparecer uma janela onde voc deve digitar o nome do banco de dados,
como mostra a Figura 7.16.
Nos tpicos a seguir voc aprender como utilizar essas classes e interfaces
para realizar operaes no banco de dados.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import javax.swing.JOptionPane;
public class Banco {
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Uma exceo SQLException poder ser gerada na linha 19, quando a instruo
insert definida na linha 13 for executada pelo mtodo executeUpdate. Caso
esta instruo esteja incorreta, gerar a exceo.
A linha 11 informa a classe do driver que ser utilizada para fazer a conexo
entre a aplicao e o MySQL.
A linha 12 faz a conexo com o banco de dados. Veja que o mtodo esttico
getConnection da classe DriverManager utilizado para passar os parmetros
de conexo com o banco de dados. So passados trs parmetros, apresentados
a seguir:
jdbc:mysql://localhost:3306/bd002 indica o IP da mquina em que o
MySQL server est instalado (localhost indica a mquina local, mas este
valor pode ser substitudo pelo IP da mquina), a porta onde o MySQL
recebe requisies (3306) e o nome do banco de dados (bd002).
root indica o nome do usurio que acessar o banco de dados. Deve ser
um usurio registrado no MySQL. O valor root de um usurio padro j
instado e configurado automaticamente na instalao do MySQL.
teruel indica a senha do MySQL. Neste caso, teruel a minha senha.
No deixe de colocar a senha que voc definiu na instalao do MySQL
em seu computador.
O mtodo getConnection, aps passar os parmetros de conexo com o banco
de dados, retorna um objeto da interface Connection, contendo a conexo
estabelecida. Este objeto recebido e chamado de conn (linha 12).
A linha 13 passa para o mtodo prepareStatement da interface Connection
uma instruo insert incompleta, pois precisa receber parmetros nos locais
onde esto os pontos de interrogao. Estes parmetros so fornecidos nas
linhas de 14 18. Veja na linha 14 que o valor 10 passado como parmetro
e substituir o primeiro ponto de interrogao. O nome Marco Antonio
passado como parmetro e substituir o segundo ponto de interrogao, e
assim por diante.
A linha 19 executa a instruo insert definida na linha 13, aps ela receber
todos os parmetros e se tornar completa. Veja que o mtodo executeUpdate da
interface Statement responsvel por executar o comando insert da linguagem
SQL. A linha 20 mostra uma mensagem indicando que a incluso foi realizada
e a linha 21 encerra (fecha) a conexo com o banco de dados.
Se ocorrerem as excees ClassNotFoundException ou SQLException ser
mostrada a mensagem contida na linha 23.
NOTA
import java.sql.*;
import javax.swing.JOptionPane;
public class Banco {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Statement st = conn.createStatement();
int id = 12;
String nome = "Marco Antonio";
String telefone = "(11)5678-9087";
String sexo = "Masculino";
double renda = 14567.56;
String sql = "insert into cliente (id, nome, telefone, sexo, renda)
values (" + id + ", '" + nome + "', '" + telefone + "', '" + sexo + "', " +
renda + ")";
st.executeUpdate(sql);
JOptionPane.showMessageDialog(null, "Os dados do cliente foram
salvos");
conn.close();
} catch (ClassNotFoundException | SQLException ex) {
JOptionPane.showMessageDialog(null, "Erro ao conectar com o
Banco de Dados");
}
NOTA
Class.forName(com.mysql.jdbc.Driver);
Connection conn = DriverManager.getConnection (jdbc:mysql://localhost:3306/
bd002, root, teruel);
import java.sql.*;
public class Banco {
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.sql.*;
public class Banco {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
Statement st = conn.createStatement();
int id = 12;
String sql = "select * from cliente where id = " + id;
ResultSet rs = st.executeQuery(sql);
if (rs.next()) {
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.sql.*;
public class Banco {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.sql.*;
public class Banco {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
Statement st = conn.createStatement();
String sql = "select * from cliente";
ResultSet rs = st.executeQuery(sql);
while (rs.next()) {
System.out.println("ID: " + rs.getString("id"));
System.out.println("Nome: " + rs.getString("nome"));
System.out.println("Telefone: " + rs.getString("telefone"));
System.out.println("Sexo: " + rs.getString("sexo"));
System.out.println("Renda: " + rs.getString("renda"));
System.out.println("--------------------------------------");
}
20
21
22
23
24
25
conn.close();
} catch (ClassNotFoundException | SQLException ex) {
System.out.println("Erro ao tentar se conectar ao banco de dados");
}
import java.sql.*;
public class Banco {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
PreparedStatement st = conn.prepareStatement("delete from
cliente where id = ? ");
st.setInt(1, 10);
int r = st.executeUpdate();
if (r == 1) {
System.out.println("Cliente excludo com sucesso");
} else {
System.out.println("Cliente no encontrado");
}
conn.close();
} catch (ClassNotFoundException | SQLException ex) {
19
20
21
22
import java.sql.*;
public class Banco {
import java.sql.*;
public class Banco {
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.sql.*;
public class Banco {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
int id = 3;
String nome = "Joo de Deus";
String telefone = "(11)7865-9087";
String sexo = "Masculino";
double renda = 14567.56;
Statement st = conn.createStatement();
String sql = "update cliente set nome= '" + nome + "', telefone= '" +
telefone + "', sexo= '" + sexo + "', renda=" + renda + " where id= " +
id + "";
int r = st.executeUpdate(sql);
if (r == 1) {
18
19
20
21
22
23
24
25
26
27
Neste tpico criaremos uma aplicao CRUD utilizando os recursos das APIs
swing e awt para criar as janelas para entrada e apresentao de dados, e da
API JDBC para executar operaes no banco de dados e na tabela que criamos
no incio deste Captulo.
Crie ento um projeto chamado ProjetoBD e uma classe principal chamada
Menu.java, conforme mostra a Figura 7.30.
Veja que voc tem um painel na parte superior onde poder realizar as operaes
de consulta, excluso e alterao.
Ao digitar no campo ID o valor 1 e clicar no boto Buscar, caso exista este
registro no banco de dados, os dados sero carregados na tabela na parte inferior
da janela, como mostra a Figura 7.39.
Veja na janela mostrada na Figura 7.44 que foi feita uma modificao nos
campos nome e telefone.
import java.awt.*;
import java.awt.event.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import java.text.DecimalFormat;
import java.text.ParseException;
import javax.swing.*;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.MaskFormatter;
import javax.swing.text.NumberFormatter;
public class Menu extends JFrame implements ActionListener {
JFrame frmCadastrarAlterar, frmManutencao;
JButton btnCadastro, btnOp, btnVoltaCadAlt, btnVoltaManutencao,
btnSair;
JButton btnSalvar, btnSalvarAlteracao, btnAlterar, btnBuscar, btnExcluir,
btnExibirTudo;
JLabel lblId, lblNome, lblTelefone, lblSexo, lblRenda;
JTextField txtNome;
JFormattedTextField txtTelefone, txtId, txtIdConsulta, txtRenda;
MaskFormatter mskTelefone, mskId;
ButtonGroup gruSexo;
JRadioButton rdoMasculino, rdoFeminino;
JPanel pnlCampos, pnlTabela;
TitledBorder tituloPnlCampos, tituloPnlTabela;
DefaultTableModel tblConsultaModel;
JTable tblConsulta;
JScrollPane scrRolagem;
Connection conn;
PreparedStatement st;
ResultSet rs;
public Menu() {
//Programao da janela principal (Menu)
setTitle("Menu Principal");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(null);
setBounds(500, 300, 300, 210);
btnCadastro = new JButton("Cadastro");
btnCadastro.setBounds(50, 20, 150, 30);
btnCadastro.addActionListener(this);
btnOp = new JButton("Outras Operaes");
btnOp.setToolTipText("Consultas, excluso e alterao de
dados");
btnOp.setBounds(50, 70, 150, 30);
btnOp.addActionListener(this);
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
frmManutencao.setLayout(null);
frmManutencao.setBounds(400, 200, 600, 500);
frmManutencao.getContentPane().setBackground(Color.LIGHT_
GRAY);
pnlCampos = new JPanel(null);
tituloPnlCampos = BorderFactory.createTitledBorder("rea de
operaes");
pnlCampos.setBorder(tituloPnlCampos);
pnlCampos.setBounds(10, 10, 565, 100);
lblId = new JLabel("ID:");
lblId.setBounds(10, 35, 50, 30);
pnlCampos.add(lblId);
txtIdConsulta = new JFormattedTextField();
txtId.setFormatterFactory(new DefaultFormatterFactory(new
NumberFormatter(new DecimalFormat("#"))));
txtIdConsulta.setBounds(40, 35, 100, 30);
pnlCampos.add(txtIdConsulta);
btnBuscar = new JButton("Buscar");
btnBuscar.setBounds(170, 35, 80, 30);
btnBuscar.addActionListener(this);
pnlCampos.add(btnBuscar);
btnExcluir = new JButton("Excluir");
btnExcluir.setBounds(255, 35, 80, 30);
btnExcluir.addActionListener(this);
pnlCampos.add(btnExcluir);
btnExibirTudo = new JButton("Exibir Tudo");
btnExibirTudo.setBounds(340, 35, 100, 30);
btnExibirTudo.addActionListener(this);
pnlCampos.add(btnExibirTudo);
btnAlterar = new JButton("Alterar");
btnAlterar.setBounds(445, 35, 80, 30);
btnAlterar.addActionListener(this);
pnlCampos.add(btnAlterar);
frmManutencao.add(pnlCampos);
pnlTabela = new JPanel(null);
pnlTabela.setLayout(new GridLayout(1, 1));
tituloPnlTabela = BorderFactory.createTitledBorder("rea de exibio");
pnlTabela.setBorder(tituloPnlTabela);
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
201
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
}
if (btn == btnSair) {
System.exit(0);
}
if (btn == btnSalvar) {
int id;
double renda;
String nome, telefone, sexo;
id = Integer.parseInt(txtId.getText());
nome = txtNome.getText();
telefone = txtTelefone.getText();
if (rdoMasculino.isSelected()) {
sexo = rdoMasculino.getText();
} else if (rdoFeminino.isSelected()) {
sexo = rdoFeminino.getText();
} else {
sexo = "";
}
renda = Double.parseDouble(txtRenda.getText().replace(",", "."));
if (conectar() == null) {
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar
Se conectar ao banco de dados");
} else {
try {
st = conn.prepareStatement("insert into cliente (id, nome,
telefone, sexo, renda) values (?, ?, ?, ?, ?)");
st.setInt(1, id);
st.setString(2, nome);
st.setString(3, telefone);
st.setString(4, sexo);
st.setDouble(5, renda);
st.executeUpdate();
JOptionPane.showMessageDialog(btnSalvar, "Os dados do
cliente foram salvos");
limparCampos();
} catch (SQLException ex) {
if (ex.getErrorCode() == 1062) {
JOptionPane.showMessageDialog(btnSalvar, "J existe um
cliente com este ID");
txtId.requestFocus();
} else {
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar
salvar os dados");
}
}
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
desconectar();
if (btn == btnBuscar) {
try {
if (conectar() == null) {
JOptionPane.showMessageDialog(btnBuscar, "Erro ao tentar
conectar ao banco de dados");
} else {
if (txtIdConsulta.getText().isEmpty()) {
JOptionPane.showMessageDialog(btnBuscar, "Por favor,
digite um valor no campo ID");
txtIdConsulta.requestFocus();
} else {
int id = Integer.parseInt(txtIdConsulta.getText());
st=conn.prepareStatement("select * from cliente where id=? ");
st.setInt(1, id);
tblConsultaModel.setRowCount(0);
rs = st.executeQuery();
if (rs.next()) {
String[] linha = {rs.getString("id"), rs.getString("nome"),
rs.getString("telefone"), rs.getString("sexo"),
rs.getString("renda").replace(".", ",")};
tblConsultaModel.addRow(linha);
} else {
JOptionPane.showMessageDialog(btnBuscar, "Este cliente
no foi encontrado");
}
desconectar();
}
}
} catch (SQLException ex) {
JOptionPane.showMessageDialog(btnBuscar, "Erro na consulta");
}
}
if (btn == btnExibirTudo) {
try {
if (conectar() == null) {
JOptionPane.showMessageDialog(btnExibirTudo, "Erro ao
tentar conectar ao banco de dados");
} else {
st = conn.prepareStatement("select * from cliente");
rs = st.executeQuery();
tblConsultaModel.setRowCount(0);
314
315
while (rs.next()) {
String[] linha = {rs.getString("id"), rs.getString("nome"),
rs.getString("telefone"), rs.getString("sexo"),
rs.getString("renda").replace(".", ",")};
tblConsultaModel.addRow(linha);
}
desconectar();
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
}
} catch (SQLException ex) {
JOptionPane.showMessageDialog(btnExibirTudo, "Erro na
consulta");
}
if (btn == btnExcluir) {
try {
if (conectar() == null) {
JOptionPane.showMessageDialog(btnSalvar, "Erro ao tentar se
conectar ao banco de dados");
} else {
if (txtIdConsulta.getText().isEmpty()) {
JOptionPane.showMessageDialog(btnExcluir, "Por favor,
digite um valor no campo ID");
txtIdConsulta.requestFocus();
} else {
int op = JOptionPane.showConfirmDialog(btnExcluir, "Tem
certeza que deseja excluir este cliente?",
JOptionPane.OPTIONS_PROPERTY,
JOptionPane.YES_NO_OPTION);
if (op == 0) {
int id = Integer.parseInt(txtIdConsulta.getText());
st=conn.prepareStatement("delete from cliente where
id=?");
st.setInt(1, id);
int r = st.executeUpdate();
if (r == 1) {
JOptionPane.showMessageDialog(btnExcluir, "Cliente
excludo com sucesso");
tblConsultaModel.setRowCount(0);
txtIdConsulta.setText("");
txtIdConsulta.requestFocus();
} else {
JOptionPane.showMessageDialog(btnExcluir, "Este
cliente no est cadastrado");
}
desconectar();
}
}
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
}
} catch (SQLException ex) {
JOptionPane.showMessageDialog(btnExcluir, "Erro na excluso");
}
if (btn == btnAlterar) {
try {
if (conectar() == null) {
JOptionPane.showMessageDialog(btnAlterar, "Erro ao tentar se
conectar ao banco de dados");
} else {
if (txtIdConsulta.getText().isEmpty()) {
JOptionPane.showMessageDialog(btnAlterar, "Por favor,
digite um valor no campo ID");
txtIdConsulta.requestFocus();
} else {
int id = Integer.parseInt(txtIdConsulta.getText());
st=conn.prepareStatement("select * from cliente where id=?");
st.setInt(1, id);
rs = st.executeQuery();
if (rs.next()) {
txtId.setText(rs.getString("id"));
txtId.setEditable(false);
txtNome.setText(rs.getString("nome"));
txtTelefone.setText(rs.getString("telefone"));
if (rs.getString("sexo").equalsIgnoreCase("masculino")) {
rdoMasculino.setSelected(true);
}
if (rs.getString("sexo").equalsIgnoreCase("feminino")) {
rdoFeminino.setSelected(true);
}
txtRenda.setText(rs.getString("renda").replace(".", ","));
btnSalvar.setVisible(false);
btnSalvarAlteracao.setVisible(true);
frmManutencao.setVisible(false);
frmCadastrarAlterar.setVisible(true);
} else {
JOptionPane.showMessageDialog(btnAlterar, "Este cliente
no foi encontrado");
}
}
}
} catch (SQLException ex) {
JOptionPane.showMessageDialog(btnAlterar, "Erro na consulta");
}
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
if (btn == btnSalvarAlteracao) {
int id;
double renda;
String nome, telefone, sexo;
id = Integer.parseInt(txtId.getText());
nome = txtNome.getText();
telefone = txtTelefone.getText();
if (rdoMasculino.isSelected()) {
sexo = rdoMasculino.getText();
} else if (rdoFeminino.isSelected()) {
sexo = rdoFeminino.getText();
} else {
sexo = "";
}
renda = Double.parseDouble(txtRenda.getText().replace(",", "."));
try {
st = conn.prepareStatement("update cliente set nome=?,
telefone=?, sexo=?, renda=? where id=?");
st.setString(1, nome);
st.setString(2, telefone);
st.setString(3, sexo);
st.setDouble(4, renda);
st.setInt(5, id);
st.executeUpdate();
JOptionPane.showMessageDialog(btnSalvarAlteracao, "Os dados
do cliente foram alterados");
limparCampos();
} catch (SQLException ex) {
JOptionPane.showMessageDialog(btnSalvarAlteracao, "Erro ao
tentar salvar os dados");
}
desconectar();
limparCampos();
frmCadastrarAlterar.setVisible(false);
tblConsultaModel.setRowCount(0);
txtIdConsulta.setText("");
txtIdConsulta.requestFocus();
frmManutencao.setVisible(true);
}
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/bd002", "root", "teruel");
return conn;
} catch (ClassNotFoundException | SQLException ex) {
return null;
}
Note a linha 49, que por meio do mtodo setToolTipText aplica uma mensagem
ao boto ao boto btnOp, que ser mostrada quando o ponteiro do mouse for
posicionado sobre ele.
Observe tambm as linhas 47, 51 e 54, que adicionam um Listener (ouvinte)
aos botes, de tal forma que quando eles receberem o clique do mouse, ser
feito um desvio para o mtodo actionPerformed, que tratar os eventos de
clique sobre os botes. As linhas de 55 57 adicionam os botes Cadastro,
Outras Operaes e Sair janela principal.
As linhas de 59 136 criam a janela com os campos. Esta janela ser utilizada
para fazer o cadastro e a alterao nos dados de um cliente. A janela gerada
mostrada na Figura 7.47.
estiver vazio, a linha 334 abre uma caixa de dilogo pedindo a confirmao da
excluso. Se o usurio clicar na opo Sim desta caixa de dilogo (linha 335),
o ID digitado no campo ID capturado (linha 336), uma instruo SQL delete
preparada (linha 337) e o id passado como parmetro para esta instruo
(linha 338). A linha 339 executa a instruo delete e guarda o retorno desta
execuo em uma varivel. Se o retorno for 1, ou seja, se a excluso ocorreu
com sucesso (linha 340), ser mostrada uma mensagem avisando que o registro
foi excludo (linha 341). Em seguida, a tabela que est na parte inferior da
janela limpa, assim como o campo ID (linha 343), e o cursor posicionado
neste campo (linha 344). Se a excluso no ocorreu (linha 345), ser mostrada
a mensagem da linha 346. Em seguida, a conexo com o banco de dados
encerrada (linha 348). Se houve alguma exceo na execuo da instruo
delete (linha 352), ser mostrada a mensagem da linha 353.
As linhas de 357 396 so referentes ao boto Alterar do formulrio de
consulta e excluso. Quando este boto pressionado, os dados do cliente
cujo ID est no campo ID desta janela so carregados no formulrio para
cadastro e alterao, para serem alterados. Basicamente este trecho executa
uma consulta na tabela do banco de dados, como o boto Buscar, j explicado
anteriormente. A diferena que os dados retornados nesta consulta so
carregados na janela para cadastro e alterao (linhas de 371 381). Quando
os dados consultados so carregados no formulrio, todos os campos podero
ser editados, exceto o campo ID, pois ele chave primria da tabela do banco
de dados e no poder ser modificado nesta operao. Isso mostrado na
linha 372. Note tambm na linha 381 que a renda obtida da tabela do banco
de dados vem com ponto para separar as casas decimais. Quando esta renda
carregada no campo renda do formulrio (linha 381), o ponto trocado por
vrgula, exibindo o valor com a vrgula separando as casas decimais. Aps os
dados consultados serem carregados nos campos do formulrio, o boto Salvar
Alterao exibido (linha 383), o formulrio ativo de consulta e excluso
escondido (linha 385) e o formulrio com os dados a serem alterados mostrado
(linha 386). Veja que na programao deste boto (Alterar) a conexo com
o banco de dados no foi fechada, pois isto ser feito apenas depois que os
dados forem alterados e salvos novamente no banco de dados, por meio do
boto Salvar Alterao.
As linhas de 398 434 so referentes ao boto Salvar Alterao, do formulrio
que exibe os dados para alterao. Aps os dados terem sido modificados neste
formulrio, esse boto permite atualizar o registro na tabela do banco de dados,
executando a instruo update da linguagem SQL.
Note que na programao deste boto no foi feita conexo com o banco de
dados, pois a conexo j foi aberta quando os dados foram carregados no
formulrio por meio do pressionamento do boto Alterar. Observe que os
package persistence;
import java.sql.*;
public class ClienteDao {
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package persistence;
public class Cliente {
private int id;
private String nome;
private String telefone;
private String sexo;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
Note que esta classe possui dois construtores, um vazio (linhas 10 e 11) e um
que recebe os parmetros que sero guardados em atributos do objeto (linhas
de 13 19). Observe que para cada atributo definido um mtodo setter e um
mtodo getter equivalente.
package view;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.text.DecimalFormat;
import java.text.ParseException;
import javax.swing.*;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.MaskFormatter;
import javax.swing.text.NumberFormatter;
import persistence.Cliente;
import persistence.ClienteDao;
public class TelaCliente extends JFrame implements ActionListener {
JButton btnSalvar;
JLabel lblId, lblNome, lblTelefone, lblSexo, lblRenda;
JTextField txtNome;
JFormattedTextField txtTelefone, txtId, txtRenda;
MaskFormatter mskTelefone, mskId;
ButtonGroup gruSexo;
JRadioButton rdoMasculino, rdoFeminino;
public TelaCliente() {
setTitle("Cadastro");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(null);
setBounds(400, 200, 600, 280);
lblId = new JLabel("ID:");
lblId.setBounds(10, 10, 50, 30);
add(lblId);
txtId = new JFormattedTextField();
txtId.setFormatterFactory(new DefaultFormatterFactory(new
NumberFormatter(new DecimalFormat("#"))));
txtId.setBounds(10, 40, 150, 30);
txtId.requestFocus();
add(txtId);
lblNome = new JLabel("Nome:");
lblNome.setBounds(170, 10, 50, 30);
add(lblNome);
txtNome = new JTextField(40);
txtNome.setBounds(170, 40, 400, 30);
add(txtNome);
lblTelefone = new JLabel("Telefone:");
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
DICA
Quando voc precisa exibir apenas uma dentre muitas mensagens que so
geradas em uma estrutura de seleo (if..else if..else), crie uma varivel para
receber a mensagem e exiba o contedo desta varivel somente aps sair
da estrutura de seleo. Isto diminui a execuo de comandos de exibio
e pode melhorar a performance da aplicao.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package persistence;
import java.sql.*;
import java.util.ArrayList;
public class ClienteDao {
private String url = "jdbc:mysql://localhost:3306/bd002";
private String usuario = "root";
private String senha = "";
private Connection con;
private PreparedStatement st;
private ResultSet rs;
//Mtodo para conectar ao banco de dados
public int conectar() {
try {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection(url, usuario, senha);
return 1;
} catch (ClassNotFoundException ex) {
return 2;
} catch (SQLException ex) {
return 3;
}
}
//Mtodo para salvar os dados de um cliente
public int salvar(Cliente cli) {
try {
st = con.prepareStatement("insert into cliente (id, nome, telefone,
sexo, renda) values (?, ?, ?, ?, ?)");
st.setInt(1, cli.getId());
st.setString(2, cli.getNome());
st.setString(3, cli.getTelefone());
st.setString(4, cli.getSexo());
st.setDouble(5, cli.getRenda());
int retorno = st.executeUpdate();
return retorno;
} catch (SQLException ex) {
int c = ex.getErrorCode();
if (c == 1062) {
return 2;
} else {
return 3;
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
104
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
}
//Mtodo para excluir um registro cujo id foi informado
public int excluir(int id) {
try {
st = con.prepareStatement("delete from cliente where id = ? ");
st.setInt(1, id);
int r = st.executeUpdate();
return r;
} catch (SQLException ex) {
return 0;
}
}
// Mtodo para alterar o registro cujo id foi informado
public int salvarAlteracao(Cliente cli) {
try {
st = con.prepareStatement("update cliente set nome=?, telefone=?,
sexo=?, renda=? where id=?");
st.setString(1, cli.getNome());
st.setString(2, cli.getTelefone());
st.setString(3, cli.getSexo());
st.setDouble(4, cli.getRenda());
st.setInt(5, cli.getId());
int r = st.executeUpdate();
return r;
} catch (SQLException ex) {
return 0;
}
}
@Override
public int excluir(int id) {
//implementao do mtodo aqui
}
@Override
public int alterar(Object obj) {
//implementao do mtodo aqui
}
@Override
public int conectar() {
//implementao do mtodo aqui
}
@Override
public void desconectar() {
//implementao do mtodo aqui
}
7.7 Resumo
Para acessar bancos de dados em aplicaes Java existem dois padres que
determinam as regras para acesso de maneira eficiente: Open Database
Connectivity (ODBC) e Java Database Connectivity (JDBC). Para utilizar
("jdbc:mysql://localhost:3306/bd002",
7.8 Exerccios
Os exerccios presentes neste tpico so divididos em duas categorias: prticos e
conceituais. Os exerccios prticos precisam ser realizados em um computador com
ambiente de programao Java instalado e configurado. Os exerccios conceituais
cobram conceitos referentes aos temas abordados neste captulo.
2) Implemente uma aplicao Java utilizando as APIs swing e awt para criar a
interface do usurio. Esta aplicao dever executar as operaes CRUD em
um banco de dados chamado BdProd com uma tabela produto contendo os
seguintes campos:
id int, not null, primary key
nomeProduto varchar (50)
marca varchar (30)
categoria varchar (30)
preco double precision
8. Recomendaes para
complementar a formao
em Java
Aps ler e praticar os contedos vistos at aqui neste livro, voc estar
pronto para aprofundar seus conhecimentos em Java estudando assuntos
mais complexos como Collections, Mapeamento Objeto-Relacional com
JPA e Hibernate, desenvolvimento de sites ou aplicaes distribudas com
Java EE (JSP, servlet, EJB, JSF etc.), desenvolvimento Java para celulares
e tablets que usam o sistema Android, design patterns (padres de projeto)
e frameworks. Poder ainda, se desejar, fazer provas para certificaes Java
reconhecidas internacionalmente. Este captulo apresenta uma introduo
sobre estes assuntos.
8.1 Collections
Agora que voc j conheceu e utilizou as diversas formas de manipulao
de dados com variveis simples, constantes, objetos, tipos primitivos e de
referncia, um bom caminho estudar um tipo de estrutura mais complexa
chamada de coleo (collection).
As colees (collections) em Java so estruturas de dados semelhantes as
arrays, porm, que manipulam dados como objetos, so dimensionadas
dinamicamente (ou seja, no tem tamanho pr-definido) e possuem um conjunto
de mtodos teis para manipular dados como listas, filas etc.
Da interface Collection descendem as interfaces Set(conjunto), Queue (filas)
e List (listas) que formam a base das colees genricas da linguagem Java,
como pode ser visto na Figura 8.1.
A interface Set define uma coleo que no contm valores duplicados;
Queue define uma coleo que representa uma fila no modelo FIFO (FirstIn, First-Out); e List define uma coleo ordenada que pode conter elementos
duplicados.
<<interface>>
Collection
<<interface>>
Set
<<interface>>
List
<<interface>>
Queue
<<interface>>
SortedSet
HashSet
LinkedHashSet
TreeSet
ArrayList
Vector
LinkedList
PriorityQueue
8.3 Java EE
Hoje em dia, a maioria das aplicaes funcionam na web, o que torna
atrativo aprender Java EE. Com os recursos disponveis no Java EE voc
pode desenvolver sites e aplicaes corporativas distribudas, como aquelas
que disponibilizam um conjunto de recursos acessados de aplicaes web,
desktop e mobile, oferecendo uma interface adequada para cada uma. Dentre
os recursos mais importantes do Java EE que vale a pena estudar esto JSP,
servlet, JSTL, EJB e JSF. Para criar aplicaes Java EE voc vai precisar de
um servidor de aplicao como TomEE, Glasfish, JBoss, Weblogic, Tomcat
(apenas continer web) etc.
Padres estruturais:
Adapter.
Bridge.
Composite.
Decorator.
Faade.
Flyweight.
Proxy.
Padres
comportamentais:
Chain of Responsibility.
Command.
Interpreter.
Iterator.
Mediator.
Memento.
Observer.
State.
Strategy.
Template Method.
Visitor.
8.5 Frameworks
Depois de entender o conceito de padro de projeto, ou design pattern, voc
deve estudar um pouco sobre os frameworks. Enquanto os design patterns
representam modelos de procedimentos que comprovadamente funcionam,
os frameworks trazem normalmente algo pronto, ou seja, pelo menos uma
parte dos cdigos necessrios para executar os procedimentos definidos em
algum padro de projeto. Alguns frameworks, principalmente voltados para o
desenvolvimento de aplicaes web, so listados a seguir:
Spring http://www.springsource.org/
EJB http://www.oracle.com/technetwork/java/javaee/ejb/index.html
Hibernate http://www.hibernate.org/
EJB http://www.oracle.com/technetwork/java/javaee/ejb/index.html
Struts http://struts.apache.org/
JSF http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html
8.8 Resumo
As colees (collections) so estruturas de dados semelhantes s arrays,
que manipulam dados como objetos, so dimensionadas dinamicamente e
possuem um conjunto de mtodos teis para manipular dados como listas, filas
e conjunto. Da interface Collection descendem as interfaces Set (conjuntos),
Queue (filas) e List (listas), que formam a base das colees em Java.
Referncias
CAELUM. Excees e controle de erros. Disponvel em: <http://www.caelum.com.
br/apostila-java-orientacao-objetos/excecoes-e-controle-de-erros>. Acesso em: 15
ago. 2014.
CODEJAVA. JComboBox basic tutorial and examples. Disponvel em: < http://www.
codejava.net/java-se/swing/jcombobox-basic-tutorial-and-examples>. Acesso em: 08
ago. 2014.
DEITEL, H.; DEITEL, P. Java: como programar. 8. ed. So Paulo: Pearson PrenticeHall, 2010.
HORSTMANN, Key. Conceitos de computao com Java. 5. ed. Porto Alegre:
Bookman, 2009.
Java Collection Framework. Disponvel em: <http://www.w3resource.
com/java-tutorial/java-collections.php>. Acesso em: 28 set. 2015.
TERUEL, Evandro Carlos. Arquitetura de sistemas para web com Java utilizando
design patterns e frameworks. Rio de Janeiro: Cincia Moderna, 2012.
O Gestor de Posicionamento GridBagLayout. Disponvel
em: <http://www.dei.isep.ipp.pt/~mouta/LPG2-Programas/progJavaGestPos/
GridBagLayout.htm>. Acesso em: 05 ago. 2014.
ORACLE Java Documentation. Trail: creating a GUI With JFC/Swing.
Disponvel em: <http://docs.oracle.com/javase/tutorial/uiswing/index.html>. Acesso
em: 05 ago. 2014.
Este livro apresenta de maneira prtica e simplificada a programao orientada a objetos utilizando Java.
Voc aprender a diferena entre a programao estruturada e orientada a objetos, as estruturas e comandos
fundamentais do Java, o s conceitos essenciais da
programao orientada a objetos (como encapsulamento, herana, polimorfismo, interfaces etc.), a criao de
interfaces g rficas para desktop, tratamento de excees e acesso a banco de dados utilizando a API Java
Database Connectivity (JDBC).
Cada captulo estruturado com uma i ntroduo,
apresentao dos contedos t ericos com exemplos,
resumo e lista de exerccios.
Um livro para se aprender, definitivamente, a
programao com Java.