Java Curiosidades Métodos

0
JAVA – Curiosidades e
Métodos Interessantes
Aprenda as curiosidades da linguagem java para Desktop
27/03/2014
Grupo - Programação JAVA/PHP/C#
JHUNIOR ALVES
Curiosidades, métodos, aplicações e muito mais.

Apresentação
Esta pequena apostila tem como objetivo aumentar seus conhecimentos sobre a
linguagem java (métodos, aplicações, etc.). Este também tem a intenção de ajudar
programadores já experientes ou até os que estão iniciando nessa área (veja este material
como um complemento extra).
Todo o conteúdo contido nesta apostila é derivado de experiências e de informações
de outras apostilas e livros de ensino didático. Procure não se basear apenas por este material,
procure se aprofundar no assunto, pois o verdadeiro aprendizado só se dá por seus próprios
esforços.

Sumário
1.0 JDK E O Netbeans + MySQL............................................................................................... 1
1.1 INSTALAÇÃO........................................................................................................................ 1
1.2 QUANDO O NETBEANS COMEÇA A FICAR LENTO............................................................... 1
1.3 INICIANDO – Fundamentos Básicos .................................................................................... 3
1.3.0 Classes em Java ............................................................................................................ 3
1.3.1 Objetos em Java ........................................................................................................... 3
1.3.2 Métodos em Java ......................................................................................................... 3
1.3.3 Atributos de um Objeto ............................................................................................... 3
1.3.4 Encapsulamento........................................................................................................... 3
1.3.5 Operadores Relacionais................................................................................................ 3
1.3.6 Operadores Lógicos (Básicos)....................................................................................... 3
1.3.7 Operadores Aritméticos............................................................................................... 4
1.3.8 Tabela Verdade ............................................................................................................ 4
2.0 String e Math – MÉTODOS................................................................................................ 5
2.1 MÉTODOS BÁSICOS............................................................................................................. 5
2.2 DECIMAL FORMAT – FORMATANDO SAIDA DE DADOS...................................................... 6
3.0 JAR'S - O que são eles?............................................................................................................ 7
3.1 GERANDO JAR'S................................................................................................................... 7
3.2 USO DE JAR'S EM SEUS PROJETOS .................................................................................... 11
4.0 INTERFACE GRÁFICA – NetBeans .......................................................................................... 11
4.1 JFRAME.............................................................................................................................. 11
4.2 NETBEANS - ARRASTEM OS COMPONENTES .................................................................... 12
4.3 Aplicações Gráficas com Swing ......................................................................................... 13
4.4 JCombobox/JList................................................................................................................ 19
4.5 Aplicações Gráficas com Swing Componentes Especializados.......................................... 21
4.5 JFILECHOOSE ..................................................................................................................... 24
4.6 JEditorPane........................................................................................................................ 27
5.0 Banco de Dados - MySQL ...................................................................................................... 28
5.1 Conhecendo o Banco de Dados MySQL ............................................................................ 28
5.2 Minha primeira aplicação com Banco de Dados (PUSIVUS) ............................................. 29
5.3 Minha aplicação com interface gráfica (PUSIVUS - Continuação) .................................... 54
6.0 iReport – Desenvolvendo de Relatórios................................................................................ 71

6.1 Relatório Com Inserção De Dados Via Software ............................................................... 71
6.2 Relatório Gerado Com Dados Do BD MySQL .................................................................... 79
6.3 Relatórios Gerados com Envio de Parâmetros.................................................................. 89
7.0 Fazendo o Instalador da Aplicação........................................................................................ 97
7.1 De .Jar para .Exe................................................................................................................ 98
7.2 Construindo o seu instalador com Inno Setup e Istool................................................... 101

1
1.0 JDK E O Netbeans + MySQL
1.1 INSTALAÇÃO
Todos sabem que para que construamos uma aplicação em java devemos ter,
basicamente: JDK, Uma IDE (Netbeans no caso) e um Banco de Dados (MySQL no caso). Logo
vamos os passos de instalação. Primeiro de tudo baixe os itens necessários e depois os
instalem nessa ordem:
 Netbeans: https://netbeans.org/index_pt_BR.html
 JDK: http://www.oracle.com
 MySQL: http://www.mysql.com
Quando forem instalar o MySql lembrem-se de colocar a senha do usuário root ‘’ (vazio).
1.2 QUANDO O NETBEANS COMEÇA A FICAR LENTO
Com o tempo o Netbeans fica muito lento na hora de inicializar. NetBeans gera uns
arquivos chamados uigesture*.html no seu temp do usuário corrente. Por quê? No momento
da instalação, o NetBeans pergunta se você deseja ajudar com dados anônimos para melhorar
o NetBeans. Quando você responde sim, ele começa a gerar estes arquivos na pasta temp do
usuário corrente. Quando o NetBeans é encerrado normalmente, estes arquivos são excluidos
com sucesso. Porém, devido a falhas ou interrupções bruscas do NetBeans(ctrl + alt + del) o
arquivo permanece lá e dai vão acumulando, acumulando… Na minha pasta existiam mais de
40000 arquivos uigesture*.html deixando meu Windows lento e o NetBeans também. Este
“problema” não é somente do SO Windows e pode acontecer com qualquer outro.
Isso é bem simples de resolver. Entre na pasta temp do usuário corrente.
No windows:
C:>cd %LOCALAPPDATA%Temp
dê o comando para excluir os arquivos uigesture:
> del uigesture*.html
Agora, tem que aguardar um bom tempo mesmo. Depende da quantidade de uigestures que
existe nesta pasta temp. :)
Ok, arquivos excluídos. O NetBeans agora entra rapidamente como na primeira instalação. :)

Resolvido, mas não quero que isso ocorra nunca mais!
No Netbeans, entre no menu ferramentas/opções:
na janela que se abrir, na opção geral, desative as estatísticas de uso.
Faça um teste. Você vai ver que com a opção de estatísticas de uso ativada ele gera o arquivo,
desativada não gera.

1.3 INICIANDO – Fundamentos Básicos
Para se aperfeiçoar melhor, procure pesquisar sobre os seguintes tópicos:
1.3.0 Classes em Java
É uma estrutura que abstrai um conjunto de objetos com características
similares. Uma classe define o comportamento de seus objetos através de métodos e
os estados possíveis destes objetos através de atributos. Em outros termos, uma classe
descreve os serviços providos por seus objetos e quais informações eles podem
armazenar.
Classes não são diretamente suportadas em todas as linguagens, e são
necessárias para que uma linguagem seja orientada a objetos. Classes são os
elementos primordiais de um diagrama de classes.
1.3.1 Objetos em Java
Objetos são instâncias de uma classe. Quando um objeto é criado ele precisa
ser inicializado, ou seja, para uma única classe de nome EstudanteDeGraduacao
podemos ter vários objetos durante a execução de um programa.
1.3.2 Métodos em Java
Métodos são ação(ões) realizada(s) pelo(s) objeto(s) afim de realizar alguma
tarefa. Objetos que são derivados de outras classes assumem os métodos e atributos
desta como herança.
1.3.3 Atributos de um Objeto
São valores e/ou características de certo objeto instanciado de uma certa
classe. Esses valores podem ser alteráveis (através dos métodos padrões get/set) ou
constantes (valores finais - final).
1.3.4 Encapsulamento
Servem para proteger ou isolar o código fonte ao máximo, assim facilita ao
máximo o acesso os atributos/métodos (public – todos podem acessar, private – apenas o
objeto pode acessar através dos métodos get/set, protected – Todo o pacote pode
acessar, etc).
1.3.5 Operadores Relacionais
Operador Definição
> Maior
< Menor
>= Maior ou Igual
<= Menor ou Igual
== Igual
!= Diferente
1.3.6 Operadores Lógicos (Básicos)
Operador Definição
&& E – lógico
|| OU – lógico
! Não - lógico

1.3.7 Operadores Aritméticos
+  SOMA
-  SUBTRAÇÃO
*  MULTIPLICAÇÃO
/  DIVISÃO
=  ATRIBUIÇÃO
1.3.8 Tabela Verdade
Situação 1 Operador Situação 2 Resultado
VERDADE && VERDADE VERDADE
VERDADE && FALSO FALSO
FALSO && FALSO FALSO
VERDADE || VERDADE VERDADE
VERDADE || FALSO VERDADE
FALSO || FALSO FALSO
Situação 1 Operador Resultado
VERDADE ! FALSO
FALSO ! VERDADE

2.0 String e Math – MÉTODOS
2.1 MÉTODOS BÁSICOS
Vamos iniciar com os métodos da classe Math, onde esta possui diversos métodos
para efetuar operações matemáticas:
<Nome_Classe>.<Nome_do_Metodo>
Match.ceil(<valor>): Serve para arredondar um valor numérico (float/double)
para seu próximo inteiro;
Match.floor(<valor>): Serve para arredondar um valor numérico (float/double)
para seu inteiro anterior;
Match.max(<valor1>, <valor2>): Serve para obter o maior valor entre os dois
números (int/long/float/double) fornecidos;
Match.min(<valor1>, <valor2>): Serve para obter o menor valor entre os dois
números (int/long/float/double) fornecidos;
Match.sqrt(<double_value>): Serve para fornecer a raiz quadrada de um valor
fornecido (do tipo double – parâmetro e retorno);
Match.pow(<base>,<potência>): Serve para calcular a potenciação de um
valor, com base em seus parâmetros. Ex: 5²  Math.pow(5,2);
(int) (Match.ramdom()*<número>): Serve para sortear um valor numérico de
0 ao <número> - 1. Ex: (int) (Match.ramdom()*100)  Sorteia de 0 a 99;
Vamos agora conhecer os métodos da Classe String, onde a mesma possui diversos
métodos de manipulação de String:
<Nome_da_String>.<Nome_do_Metodo>
<Nome_da_String>.length(): Serve para retornar o tamanho da String,
efetuando a contagem dos caracteres da mesma (os espaços em branco são
contados também).
<Nome_da_String>.charAt(<int_pocição>): Serve para retorna o char na
posição “x” da String. Ex: “JAVA”.charAt(0)  ‘J’;
<Nome_da_String>.toUpperCase(): Muda a string toda para maiúcula;
<Nome_da_String>.toLowerCase(): Muda a string toda para minúscula;

<Nome_da_String>.trim(): Serve para retirar os espaços em branco do inicio e
do final da string;
<Nome_da_String>.substring([posição_inicial], [posição_final]): Serve para
retornar “um pedaço” da string.Observe:
Frase L I N G U A G E M J A V A
Índice 0 1 2 3 4 5 6 7 8 9 10 11 12 13
String frase = “LINGUAGEM JAVA”;
frase.substring(10)  “JAVA”;
Frase.substring(3,9)  “GUAGEM”;
<Nome_da_String>.replace([substituídos], [sustituição]): Serve para substituir
uma cadeia de caracteres (ou até mesmo um caractere me formato String) em
uma string. Ex:
String frase = “O macaco gosta de maçã”;
String resultado = frase.replace(“maçã”, “Banana”);
resultado  “O macaco gosta de Banana”;
String frase = “O macaco gosta de maçã”;
String resultado = frase.replace(“a”, “e”);
resultado  “O mececo goste de Benene”;
<Nome_da_String>.valueOf(<valor>): Serve para converter qualquer tipo de
dados em um cadeia de caracteres, ou seja transforma qualquer dado
float/long/int/double em String;
<Nome_da_String>.indexOf([caractere ou substring a ser procurada],
[posição inicial]): Serve para procurar a primeira ocorrência de uma
caractere/substring em uma String. Logo é retornado a posição (index) da
primeira ocorrência na mesma;
2.2 DECIMAL FORMAT – FORMATANDO SAIDA DE DADOS
A classe DecimalFormat é usada, geralmente, para formatar saídas de valores
numéricos em formato Strng. EX:

import java.text.DecimalFormat;
public class Estudos {
public static void main(String[] args) {
DecimalFormat df = new DecimalFormat("##.##");
double a = 1.2222;
System.out.println("Valor: "+df.format(a));
// saída = 1.00
}
}
Observe que o argumento da classe DecimalFormat, ao criar o objeto “df”, serve para
modelar a máscara da formatação final do valor da variável “a”.
3.0 JAR'S - O que são eles?
(Java ARchive) é um arquivo compactado usado para distribuir um conjunto de
classes Java, um aplicativo java, ou outros itens como imagens, XMLs, entre outros. É usado
para armazenar classes compiladas e metadados associados que podem constituir um
programa.
3.1 GERANDO JAR'S
Para iniciar, abra o Netbeans para criar um programa simples. Ele apenas Lê seu nome
e o exibe. Usaremos a Classe JOptionPane do pacote javax.swing. Siga os passos abaixo:

Logo em seguida insira o seguinte trecho de código:
package estudos.java;
import javax.swing.JOptionPane;
public class EstudosJava {
String nome = "";
String msg = "Seja bem vindo ";
nome = JOptionPane.showInputDialog("Qual é o seu nome?");
if(nome == null)
System.exit(0);
msg += nome + " !!!";
JOptionPane.showMessageDialog(null, msg);
}
}
Logo depois você deve clicar em u botão na barra de ferramentas “limpar e construir” .
Agora observe a saída do terminal do Netbeans, lá será resumido todo o processo de
construção e ainda lhe mostrará a localização de seu arquivo .jar (geralmente os arquivos
gerados, .jar’s, ficam no diretório do projeto em uma pasta chamada dist).
Ao clicar no seu arquivo “Estudos_Java.jar” o programa executará normalmente .

3.2 USO DE JAR'S EM SEUS PROJETOS
Esses arquivos podem ser usados de outra forma. Dentro desses arquivos existem
códigos fontes já feitos, pronto para serem usados. Neste caso o arquivo.jar tem a intenção de
implementar/auxiliar seu trabalho com classes prontas. O JDK não possui todas as classes para
atender nossas necessidades (Ex.: O JDK não tem uma classe para gerar arquivos.pdf logo você
precisa baixar um arquivo. jar para obter uma classe que o satisfaça).
Porem já existe no Netbeans alguns jars importantes como o MySQL-Connector que é
um arquivo .jar responsável por fornecer as classes necessárias para conectar uma aplicação
java em um Banco de Dados MySQL.
4.0 INTERFACE GRÁFICA – NetBeans
4.1 JFRAME
O Netbeans oferece uma ambiente de programação de “arrastar componentes” que
consiste em, como o próprio nome sugere, arrastar um componente/objeto para um ponto
específico do deu JFrame, JPanel ou JDialog. Vamos iniciar agora conhecendo alguns métodos
da classe JFrame:
Se o seu JFrame for um objeto instanciado, os métodos devem ser usados da seguinte forma:
<Objeto JFrame>.<Nome do Método e seus parâmetros>
Caso seu jFrame seja uma classe que estar herdando um JFrame, os métodos devem ser
usados da seguinte forma:
this.<Nome do Método e seus parâmetros>
setExtendedState(MAXIMIZED_BOTH): Com este método é possível configurar o
JFrame para redimensionar ao máximo no momento da execução do projeto;
setUndecorated(true): Serve para expandir o JFrame sem as bordas;
this.setIconImage(Toolkit.getDefaultToolkit().getImage(this.getC
lass().getResource("<caminho da imagem>"))): Serve para mudar o ícone
do canto do JFrame. Quando mudado o ícone de canto do JFrame principal os demais
JFrames e JDialogs herdam o mesmo ícone;
setTitle("Titulo da Janela"): Serve para configurar o titulo do seu JFrame;
setResizable(true/false): Com este método é possível permitir ao usuário se o
JFrame ou JDialog é redimensionável (true) ou não (false);

4.2 NETBEANS - ARRASTEM OS COMPONENTES
O Netbeans possui um ambiente onde o programador pode simplesmente desenvolver
seus programas sem se preocupar com a interface gráfica, pois ele permite que você monte e
controle visualmente a posição/layout do seu projeto (não é recomendada esta funcionalidade
para as pessoas que estão iniciando, pois as mesmas precisão aprender a construção e a lógica
de um JFrame).
Vamos aproveitar o projeto anterior e criar um JFrame. Siga os passos abaixo:
a) Clique no pacote estudos.java com o botão esquerdo;
b) Depois clique com o botão direito e escola a opção Novo>Form JFrane... ;
c) Dê o nome de Formulario o seu JFrame;
d) Clique em Finalizar;
Paleta: Com esta aba de opções permite ao programador escolher os componentes que irão
fazer parte de sua aplicação, sejam estes componentes do pacote swing ou do pacote AWT
(existem as abas de opções). Assim é só escolher e arrastar para seu JFrame o(s)
componente(s) necessário(s);
Propriedades: Esta aba que está situada vizinha a aba paleta, serve para ver as propriedades
de um componente que está com o foco. Assim é possível ter um controle maior das
propriedades de cada objeto arrastado;
Observe o JFrame abaixo e tente construir um idêntico:

4.3 Aplicações Gráficas com Swing
Nova família de componentes com funcionalidade ampliada e grande capacidade de
configuração
O seu propósito é permitir a criação de interfaces versáteis e sofisticadas Surgiu em 1997com a
JFC ( Java Foundation Classes), com o Java 2, que engloba:
1. o Componentes Swing
2. o Compatibilidade com múltiplas ´Look and Feel` - peles
3. o Biblioteca de acessibilidade monitores e teclados especiais
4. o Biblioteca Java 2D
5. o Compatibilidade com `Drag and Drop`
.:Principais Componentes:.
Os seus componentes são semelhantes ao da AWT (Abstract Window Toolkit), pois o modelo
de eventos é o mesmo.
 Diferenças: Componentes Swing são mais flexíveis e mais numerosos;
 Não utilizam código nativo, seus nomes iniciam com um J;
 A base para uma aplicação é o JFrame ou JWindow ( janela) ou a classe JApplet
miniapplicativos);
 JFrame não é um mero container, mas um painel especial que agrega três outros
componentes em camadas;
 Destes o que nos interessa é o ContentPane (painel de conteúdo), onde vamos inserir
os demais componentes:

Container conteudo= getContePane();
a) JLabel: rótulo de texto.
Métodos específicos:
String getText()retorna o texto do label
void setText(String lbl) ajusta o texto do label para lbl
b) JButton: é um botão simples que pode ser criado com ou sem rótulo.
Métodos específicos:
String getText()retorna o label(etiqueta) do botão
void setText(String etiq) ajusta label do botão para o conteúdo de etiq
c) JTexField e JTextArea
TextField: caixa de entrada de texto, possibilita a entrada e a edição de
uma linha de texto.
TextArea: caixa de entrada de texto com múltiplas linhas. Exibe barra de
rolagem horizontal e vertical.
principais métodos:
String getText()retorna o texto contido no TextField
void setText(String txt) ajusta o texto da TextField para txt
d) JList e JCombobox
JList: caixa de lista que permite a exibição de uma lista de itens que não
podem ser editados diretamente pelo usuário.
JCombobox: implementa uma lista de itens em que um único item
selecionado é exibido.
principais métodos:
int getSelectedIndex(); retorna índice do item selecionado
String getSelectedItem();retorna o nome do item selecionado
void select(String str); ajusta o item selecionado para str
MÉTODOS COMUNS A TODOS OS COMPONENTES
void resize(int width, int height)  Tamanho do componente
void move(int x, int y)  Mover componente
void setForeground(Color x)  Cor do componente
void setBackground(Color y)  Cor de Fundo do componente
void disable()  Desabilitando componente
void enable()  Habilitando componente

.: Gerenciadores de Layout:.
Gerenciamento de layout (Layout Management) é o processo de determinar o
tamanho e a posição dos componentes na janela gráfica do programa, ou seja determinar
onde os componentes irá ficar guiando a maneira como os elementos de interface serão
dispostos dentro do container (Frame, Panel, Window).
Existem basicamente os seguintes tipos de layout:
a) FlowLayout;
b) BorderLayout;
c) CardLayout;
d) GridLayout;
e) GridBagLayout;
A escolha do gerenciador de layout depende muito das necessidades
do programa.
a) FlowLayout
Simplesmente posiciona os componentes da esquerda para a direita, criando novas
linhas se necessário;
b) BorderLayout
É o Padrão: Divide a janela em cinco áreas nas quais os componentes podem ser
exibidos: norte, sul, leste, oeste e centro;
c) CardLayout
Permite apresentar dois ou mais componentes (geralmente painéis) compartilhando o
mesmo espaço de apresentação. Funciona como uma pilha de cartas onde apenas uma
fica visível;
- Cria-se um Painel fixo de Controle e um genérico (CardLayout) para conter outros
painéis ;
d) GridLayout
Deixa todos os componentes com igual tamanho, exibindo-os como uma tabela (linhas
e colunas).
e) GridBagLayout
É o mais flexível dos gerenciadores de layout, permite colocar componentes em grades
de colunas, sendo possível um componente ocupar mais de uma coluna ao mesmo
tempo. As linhas também não precisam necessariamente ter os mesmos tamanhos, ou
seja, você pode configurar diferentes larguras e alturas de acordo com a necessidade.
No entanto, é o mais difícil de ser implementado;

Agora vamos montar um exemplo de interface gráfica. Suponha que queiramos criar
uma calculadora que realize as quatro operações básicas (adição, subtração, multiplicação e
divisão). Faça um JFrame semelhante a este abaixo:
Componente Propriedade Valor Propriedade Valor
JButton1 Text Somar Mnemonic S
JButton2 Text Subtrair Mnemonic D
JButton3 Text Multiplição Mnemonic M
JButton4 Text Divisão Mnemonic V
JButton5 Text Limpar Campos TooltipText Limpar as caixas de Texto
JLabel3 Text Resultado - -
JLabel4 Text - Borda javax.swing.BorderFactory.createEtchedBorder()

Dê um duplo clique no botão “Somar” e digite o nome do método que será
responsável por fazer a soma dos valores inseridos pelo usuário. Nesse caso escreva somar().
Logo em seguida o Netbeans apontará erro, mas você pode clicar no ícone da “lâmpada” que
lhe fornecerá uma possível solução para o seu código. A solução será criar um método com o
nome somar() pois este ainda não existe.
No método somar você deve inserir o seguinte código:
private void somar() {
String numero1 = "";
String numero2 = "";
float n1 = 0;
float n2 = 0;
float resultado = 0;
numero1 = jTextField1.getText();
numero2 = jTextField2.getText();
n1 = Float.parseFloat(numero1);
n2 = Float.parseFloat(numero2);
resultado = n1 + n2;
jLabel4.setText(resultado+"");
}

Repita o processo nos demais botões, mudando apenas a operação matemática
selecionada na imagem acima (+ soma. – subtração, * multiplicação e / divisão).
No botão limpar crie um método (de nome Limpar() – ou escolha outro nome) e
coloque o seguinte:
jTextField1.setText("");
jTextField2.setText("");
jLabel4.setText("");
Pronto! agora teste sua calculadora!

4.4 JCombobox/JList
a) Criar uma aplicação para informar qual a forma de pagamento selecionada
pelo usuário: Cheque, Cartão ou Dinheiro:
Clique no Menu File New Java GUI Forms clique em JFrame Form
clique em Next
Na Janela que se abre digite FormaPaga clique no botão Finish
Modifique o Layout para AbsoluteLayout
Clique no Form e modifique a propriedade Title do Form para Forma de
Pagamento
Clique no sétimo ícone JCombobox" e clique no Form, na Janela Propriedades
clique em Model clique no Botão ... .
Na janela que se abre em Item digite: cheque e clique no botão Add , digite:
cartão e clique no botão Add , digite dinheiro e clique no botão Add , clique
no botão OK
Insira um JLabel: clique no primeiro ícone (JLabel) e clique no Form.
Insira um JButton: clique no segundo ícone (JButton) e clique no Form

A parte visual foi criada, falta o código. Para saber qual a opção selecionada
utilize o Método:
Object getSelectedItem().
Dê um duplo clique no botão Escolher :
String S= (String) jComboBox1.getSelectedItem();//converte em String
jLabel1.setText("A opção escolhida foi: " + S); //exibe opção no Jlabel
Compile (F9) e Execute (F6).
Se desejar também é possível saber o índice: getSelectedIndex()
A utilização do JList é idêntica a vista a cima, basta substituir o método
getSelectedItem(), por getSelectedValue().
Utilizando JRadioButton com o NetBeans
b) Criar uma aplicação para mostrar o tipo de motor (1.0/1.6/2.0) escolhido pelo
usuário
Crie uma nova Template JFrame Form Motor , clique no Menu File New ...
No Form que se abre Clique no sexto ícone ButtonGroup e clique no Form
para criar um grupo de radio e permitir a seleção de apenas uma opção
Clique no quinto ícone JRadioButton" e clique no Form, na janela
Propriedades selecione Text e digite Motor 1.0 . Selecione a propriedade
buttonGroup e clique em buttonGroup1 , repita todo o processo por duas
vezes para criar a opção Motor 1.6 e Motor 2.0
Insira um JLabel, Text: Opção Escolhida , no Form e um JButton, Escolher .
Para saber qual a opção esta marcada devemos utilizar o Método boolean
isSelected(), que devolve true ou false.
Dê um duplo clique no botão para inserir o código:
if (jRadioButton1.isSelected()) //verifica se a opção esta marcada -true
jLabel1.setText("Motor escolhido: 1.0"); //exibe opção no JLabel
jLabel1.setText("Motor escolhido: 1.6");
jLabel1.setText("Motor escolhido: 2.0");

Para saber qual é o Texto exibido pelo JRadioButton basta utilizar o Método:
String getText().
Ex: String s=jRadioButton1.getText();
4.5 Aplicações Gráficas com Swing Componentes Especializados
Assunto: Aplicações Gráficas com Swing Componentes Especializados
Objetivo: Criar aplicações utilizando componentes especializados Swing.
JOptionPane
Janelas de dialogo para informar ou solicitar confirmação de operações ou
efetuar a entrada direta de valores:
 Mensagens
 Entrada de Texto
 Janelas de Confirmação

Exemplos:
//Mensagem
JOptionPane.showMessageDialog( this, mensagem );
// Confirmação
int x = JOptionPane.showConfirmDialog( this, Mensagem1 );
// Entrada de Texto
String s= JOptionPane.showInputDialog( Mensagem 2 );
int x = JOptionPane.showConfirmDialog(this, "Confirmar? , "Aplicação",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
Nas IDE como NetBeans é possível inserir um objeto visual, mas não é possível
controlar as ações dos respectivos botões.
Se quiser utiliza-los no Netbeans, insira-os dentro de um método
actionPerformed de um JButton.
Exemplo: - Criar um Programa contendo um botão que ao ser pressionado
exiba informações sobre o programa:
 - Crie uma nova Template JFrame Form Mensagem , Menu File New ...
 - Mude o Layout para AbsoluteLayuot
 - Insira um JButton Mensagem , dê um duplo clique para inserir o código:

JOptionPane.showMessageDialog(this,"Programa criado n utilizando o
Netbeans");
// o n foi utilizado para mostrar como inserir uma quebra de linha.
- Este componente pertence ao pacote Swing que deve ser importado através do
import .
- Procure no código o comando que cria a classe, que está no início do programa:
public class Mensagem extends javax.swing.JFrame {
- Antes deste comando insira o código:
import javax.swing.*; //importa os componentes do pacote swing.

- Execute (SHIFT + F6).
Todos os exemplos anteriores poderiam ter utilizado o
JOptionPane.showMessageDialog.
ToolTipText: texto explicativo exibido quando o mouse passa sobre o
componente:
No Netbeans basta inserir o texto desejado na propriedade ToolTipText dos
Componetes (JLabel, JTextField, JButton ...).
ToolTipText  Este é o texto explicativo dos componentes!

4.5 JFILECHOOSE
o Janelas de dialogo para seleção de arquivos:
o Abrir (Open)
o Salvar (Save)
Exemplo: Código a ser inserido na ação de um botão Abrir Arquivo :
JFileChooser arq= new JFileChooser();
int Result=arq.showOpenDialog(this);
if(Result==JFileChooser.APPROVE_OPTION){
File arquivo= arq.getSelectedFile(); //Classe para
Arquivos
System.out.println(arquivo); //Imprime nome do Arquivo
}
}
}
Classe File: suporte para tratamento de arquivos:
FileReader/FileWrite FileInputStream / FileOutputStream
- são usados para ler ou gravar arquivos no sistema:
FileReader in = new FileReader("Entrada.txt");
FileWriter out = new FileWriter ("Saida.txt");
Comando para ler e escrever arquivos (Byte e não String/char): read() e
write(String s)
while ((int c=arqin.read()) !=-1){ // lê Entrada.txt
out.write(c); // grava em Saida.txt
System.out.write(c); // direciona para o vídeo
}
out.write(p); // gravar a String no final do arquivo
in.close(); // fecha os arquivos
out.close();
}
}

Exemplo: criar um programa que permita selecionar um arquivo de texto, “.txt”
e mostrar o conteúdo em um JTextArea:
Crie uma nova Template, Java Gui Form JFrame Form
Insira um JTextArea e um JButton, Abrir Arquivo , e dê um duplo clique no
botão, digite:
try{ // Blco de Tratamento de erros/exceções nos arquivos
File arquivo; //Objeto para arquivos
JFileChooser arq= new JFileChooser(); // objetos de seleção de arquivo
int Result=arq.showOpenDialog(this); // mostra a janela de seleção de
arquivo
if(Result==JFileChooser.APPROVE_OPTION){ //verifica se foi seleciona um arquivo
arquivo = arq.getSelectedFile(); //verifica o arquivo selecionado
int c; //variável para receber os Bytes do arquivo
String Texto=""; //variável para receber os dados do arquivo
FileReader inArq = new FileReader(arquivo.getPath()); //abre o
arquivo para leitura
while((c = inArq.read())!=-1){ //lê Byte por Byte até o final do
arquivo (-1)
Texto=Texto+(char)c; // transforma o Byte lido em um char
} //final do while
jTextArea1.setText(Texto); // exibe no JTextArea o conteúdo lido do
arquivo
inArq.close();
} // final do if
} catch (IOException ioe) { // verifica qual foi o erro/exceção
JOptionPane.showMessageDialog(this,"erro ao abrir o arquivo"); //
mensagem de erro
}
Insira, antes da declaração da classe public class , no começo do programa:
import java.io.*;
import javax.swing.*;
É possível acrescentar um outro botão para salvar novos texto que o usuário
pode inserir no JTextArea:
Acrescente um novo JButton Salvar , dê um duplo clique e digite:
try{
File arquivo;
JFileChooser arq= new JFileChooser();
int Result=arq.showSaveDialog(this);

if(Result==JFileChooser.APPROVE_OPTION){
arquivo = arq.getSelectedFile(); //Classe para Arquivos
FileWriter inArq = new FileWriter(arquivo.getPath());
inArq.write(jTextArea1.getText()); // lê o arquivo
inArq.close();
}
}catch(IOException ioe) {
JOptionPane.showMessageDialog(this,"erro ao abriri o arquivo");
} // Add your handling code here:
}
Estes comandos podem ser inseridos em um Menu.
A primeira aplicação criada como exemplo, representa a criação de editor de
texto já composto de um Menu, mas que não possui os respectivos códigos
para efetuar as operações de abrir um documento e salvá-lo. Experimente
implementar os respectivos códigos nessa para efetivamente criar um editor de
texto.

4.6 JEditorPane
Painel de Conteúdo é uma área de texto especializada na exibição e edição de vários
tipos de conteúdo: texto simples(text/plain), HTML(text/html) e RTF Rich Text Format(text/rtf).
Exemplo: Criar um Programa que permita exibir um arquivo com extensão
.html ou .htm :
Crie uma nova Template Java GUI Form JFrame Form
Insira um objeto JScrollPane no Form e insira dentro deste um objeto
JEditorPane, da Aba Swing (Other)
Insira um objeto JButton, Selecionar Página :
JFileChooser arq = new JFileChooser();
int result = arq.showOpenDialog(this);
if(result==JFileChooser.APPROVE_OPTION){
try{
File arquivo= arq.getSelectedFile();
URL pagina= new URL("file:"+arquivo.getPath());
jEditorPane1.setPage(pagina);
} catch(MalformedURLException mue) {
JOptionPane.showMessageDialog(this,"Erro na página");
}catch( IOException ioe){
JOptionPane.showMessageDialog(this,"Erro no arquivo");
} }
Insira a importação dos pacotes, antes da declaração da classe public class :
import javax.swing.*;
import java.net.*;
import java.io.*;
Execute (Shift+F6).

5.0 Banco de Dados - MySQL
5.1 Conhecendo o Banco de Dados MySQL
O MySQL é um Sistema de Gerenciamento de Banco de Dados (SGBD), que utiliza a
linguagem SQL (Linguagem de Consulta Estruturada, do inglês Structured Query Language)
como interface. É atualmente um dos bancos de dados mais populares1
, com mais de 10
milhões de instalações pelo mundo.
Entre os usuários do banco de dados MySQL estão: NASA, Friendster, Banco
Bradesco, Dataprev, HP, Nokia, Sony, Lufthansa, U.S. Army, U.S. Federal Reserve
Bank, Associated Press, Alcatel, Slashdot, Cisco Systems, Google e outros.
 Portabilidade (suporta praticamente qualquer plataforma atual);
 Compatibilidade (existem drivers ODBC, JDBC e .NET e módulos de interface para
diversas linguagens de programação, como Delphi, Java, C/C++, C#, Visual
Basic, Python, Perl, PHP, ASPe Ruby);
 Excelente desempenho e estabilidade;
 Pouco exigente quanto a recursos de novos hardware;
 Facilidade no manuseio;
 É um Software Livre com base na GPL (entretanto, se o programa que acessar o Mysql
não for GPL, uma licença comercial deverá ser adquirida) ;
 Contempla a utilização de vários Storage Engines como MyISAM, InnoDB, Falcon, BDB,
Archive, Federated, CSV, Solid…
 Suporta controle transacional;
 Suporta Triggers;
 Suporta Cursors (Non-Scrollable e Non-Updatable);
 Suporta Stored Procedures e Functions;
 Replicação facilmente configurável;
 Interfaces gráficas (MySQL Toolkit) de fácil utilização cedidos pela MySQL Inc.

5.2 Minha primeira aplicação com Banco de Dados (PUSIVUS)
Por questões didáticas, o banco de dados criado para este tutorial se limita a uma
tabela, com
apenas 3 campos. O objetivo desse banco é manter dados dos carros que passam por
determinado estacionamento. Bom, vamos à nossa primeira tarefa, que é a criação do banco.
Primeiro passo: acesse o MySQL Command Line Client (iniciar->porgramas->MySQL->MySQL
Server 5.x-> MySQL Command Line Client).
Segundo passo: entre com a senha (aquela que você colocou quando fez a instalação). Se
você não alterou as configurações, a senha padrão é em branco para o usuário root. Se tudo
estiver ok, você verá a janela com aparência da figura abaixo.
Terceiro passo: criar o banco (vamos chamar de estacionamento) propriamente dito, para isso
digite o comando abaixo e tecle enter.
create database estacionamento;
Se o banco foi criado com sucesso a sua janela deverá se parecer com a figura abaixo.

Quarto passo: dizer para o MySQL que você deseja usar esse banco que acaba de criar. Para
isso digite o comando abaixo e tecle enter.
use estacionamento;
Se o banco foi mudado com sucesso a sua janela deverá se parecer com a figura abaixo.
Quinto passo: criação da tabela. Para isso digite os comandos a seguir, linha a linha e tecle
enter a cada linha. Só coloque o ponto-e-vírgula na última linha, pois este (ponto-e-vírgula) diz
para o MySQL que o comando terminou.
create table carro(
placa char(7) not null primary key,
cor varchar(20),
descricao varchar(100)
);
Obs.: usei char para placa porque tenho certeza de que todo o espaço alocado (7) será
usado. Já para cor e descricao, usei varchar porque não sei exatamente quanto desse
espaço será usado.
Pense assim, quando coloco o tipo char, eu digo para o SGDB que eu quero aquele espaço
para minha variável e ele (SGBD) tem que deixar exatamente esse tamanho para o meu uso,
mesmo que eu não use todo ele.
No caso de varchar, eu digo que preciso de no máximo aquele tamanho, assim o MySQL vai
alocando os espaços à medida que eu precisar.
Em suma, o char é mais rápido, mas ocupa espaço desnecessário, já o varchar é mais
lento, porém não ocupa espaço desnecessário.
O uso de um ou de outro depende do problema de cada desenvolvedor.
Se tudo deu certo, a sua janela deverá se parecer com a figura abaixo. Não se preocupe com a
mensagem “0 rows affected”, isso se dá porque a tabela está vazia.

Pronto! Seu banco de dados está criado e você tem uma tabela nele e é com essa tabela que
vamos trabalhar. Vamos para outra etapa.
Para esta etapa é necessário que você já tenha o netbeans instalado na sua máquina.
Primeiro passo: Acesse o netbeans (iniciar->netbeans->netbeans 6.x.x). Você verá uma janela
semelhante à apresentada na figura abaixo.
Segundo passo: criar um novo projeto. Para isso, click no ícone mostrado na figura abaixo.

Ao aparecer uma nova janela, selecione Java em categorias e aplicativo Java em
projetos,conforme figura abaixo, e click em próximo.
Ao aparecer uma nova janela, coloque o nome estacionamento em nome do projeto; click
em procurar e aponte para o diretório que se deseja criar o projeto. Neste tutorial foi criada a
pasta psv,diretamente no diretório raiz, para facilitar o acesso. Marque os dois últimos
checkbox, conforme mostra a figura abaixo, e click em finalizar.

O novo projeto já vem com algumas pastas: pacotes de código fonte (onde guardaremos as
nossas classes), pacote de testes, bibliotecas (onde colocaremos nossas bibliotecas externas)
e bibliotecas de testes. Só vamos nos preocupar com a primeira e terceira pasta. Normalmente
o netbens já cria um pacote com o nome da pasta onde foi criado o projeto, se isso não
acontecer, crie um pacote seguindo orientações da seção 4. Já nas pastas de bibliotecas,
temos algumas previamente adicionadas pelo netbeans. Não entrarei em detalhe a respeito de
cada pasta ou biblioteca, porque está fora do escopo deste tutorial.
Criação do pacote
É sempre recomendável que criemos um pacote para colocarmos nossas classes. Para isso,
click com o botão direito do mouse sobre a pasta “Pacotes de código fonte”, escolha novo-
>pacote. Uma nova janela aparecerá preencha os dados conforme figura abaixo. Coloque o
nome psv para o nome do pacote.

Adição do Conector
Para esta etapa você precisará ter o conector em alguma pasta na sua máquina, se
ainda não
tem, faça download no seguinte endereço: http://dev.mysql.com/downloads/connector/j/,
descompacte-o (normalmente vem zipado) em uma pasta de fácil acesso, de preferência,
como
por exemplo: C:psvmysql-connector-java-5.0.4-bin.jar
Primeiro passo: click com o botão direito do mouse sobre a pasta “Bibliotecas” e selecione a
opção “Adcionar JAR/pasta”. Quando aparecer uma nova janela, navegue por ela até localizar
o conector, conforme mostra a figura abaixo:
Segundo passo: selecione o conector e click em “caminho relativo”, conforme figura abaixo,
isso diz para o netbeans que ele não deve ficar preso à pasta que se encontra o conector
atualmente. Feito isso, click em open.
Pronto! Você agora tem um pacote para trabalhar e já tem o conector para o banco de dados,
conforme mostra a figura abaixo.

Bom, já temos o banco, o conector, o projeto e o pacote. Vamos agora criar as nossas classes
JAVA para manutenção do nosso banco. Para fazermos isso, precisaremos de 4 classes:
CarroBean (onde colocaremos todos os atributos e os métodos de acesso a esses atributos),
CarroDAO (onde colocaremos todos os métodos de acesso aos dados), Conexao (responsável
por abrir e fechar as conexões) e Teste (para testarmos as nossas classes).
Primeiro passo: criação da classe Conexao. Para isso, click com o botão direito sobre o pacote
criado anteriormente, quando uma nova janela aparecer (figura abaixo), coloque o nome
Conexao e click em finalizar.

Uma classe será criada, devemos acrescentar os seguintes códigos nela.
package psv;//Este não é necessário, pois já é colocado utomaticamente
Em uma linha abaixo de package, devemos importar o seguinte pacote para usarmos a classe
Connection.
import java.sql*;
A linha a seguir aparece automaticamente, pois é o nome da classe
public class Conexao {
Dentro da classe, vamos criar um método (abrirConexao) estático (não é necessário
instanciar
a classe para utilizá-lo) para abrir uma conexão com o banco de dados. Esse método deverá
retornar um objeto do tipo Connection e não recebe parâmetro.
public static Connection abrirConexao() {
Dentro do método (abrirConexao), vamos criar uma variável de método do tipo
Connection e
atribuir o valor null para ela, pois variável de método tem que inicializada.
Connection con = null;
Ainda dentro do método (abrirConexao), vamos abrir um bloco try colocar o código
para
conexão com o banco. Esse tratamento de exceção é necessário porque podem ocorrer as
seguintes exceções: SQLException e ClassNotFoundException.
try {
Agora precisamos registrar o driver, ou seja, precisamos dizer para o Java que esse é o
driver
que iremos usar para as conexões.
Class.forName("com.mysql.jdbc.Driver").newInstance();
Depois do driver registrado, podemos fazer a conexão usando o método estático (não
é necessário instanciar a classe para usa-lo) getConnection da classe DriverManager. Esse
método recebe uma String como argumento, que é o endereço do banco, bem assim o usuário
e senha. Por questão de legibilidade do código, criaremos uma variável chamada url para
colocar essa String.
String url = "";
url += "jdbc:mysql://127.0.0.1/estacionamento?";
url += "user=root&password=";
Antes de passar a url (poderia se qualquer nome) como parâmetro do método
getConnection, vamos analisar cada componente dela (url). O que é feito a seguir.

jdbc:mysql://127.0.0.1 – endereço do servidor de banco de dados, neste caso é o
localhost, ou seja, nossa própria máquina.
estacionamento – nome do nosso banco de dados.
? – indica que iremos passar um conjunto de parâmetro.
user=root – usuário do banco de dados, neste caso, usuário administrador.
password= - senha do usuário, neste caso está em branco porque não colocamos senha
para o usuário root.
Obs.: Não pode haver espaço algum entre esses componentes do parâmetro.
Bom, já que temos a nossa String de conexão montada, vamos fazer a nossa conexão e
passar o valor para a nossa variável criada no início do método.
con = DriverManager.getConnection(url);
Se a conexão for realizada com sucesso, podemos avisar usuário que essa foi estabelecida.
System.out.println("Conexão aberta.");
Como nós abrimos um bloco try, devemos ter pelo menos um catch ou finally para
finaliza-lo, no nosso caso teremos 3 catchs, um para SQLException (exceções que podem
ocorrer durante a conexão com o banco), outra para ClassNotFoundException (exceção
que pode ocorrer durante o processo de registro do driver) e outra para Exception (exceções
quaisquer que possam ocorrer).
} catch (SQLException e) {
System.out.println(e.getMessage());
} catch (ClassNotFoundException e) {
} catch (Exception e) {
}
Agora que já temos a nossa conexão, devemos retorna-la para quem a solicitou.
return con;
Podemos fechar o método, então.
}
Ainda dentro da classe, vamos criar um método (fecharConexao) estático (não é necessário
instanciar a classe para utilizá-lo) para fechar uma conexão com o banco de dados. Esse
método não tem retorno, mas recebe um objeto do tipo Connection, que é a conexão que ele
deve fechar.
public static void fecharConexao(Connection con) {
Ainda dentro do método (fecharConexao), vamos abrir um bloco try colocar o código para
fechar a conexão com o banco. Esse tratamento de exceção é necessário porque pode ocorrer
a seguinte exceção: SQLException.
try {

Agora vamos fechar a conexão
con.close();
Depois da conexão fechada vamos dar um aviso ao usuário de que essa (conexão) foi fechada.
System.out.println("Conexão fechada.");
finaliza-lo, no nosso caso teremos 2 catchs, um para SQLException (exceções que podem
ocorrer durante a conexão com o banco) e outra para Exception (exceções quaisquer que
possam ocorrer).
}
}
Agora fechamos a classe.
}
Segundo passo: criação da classe CarroBean. Para isso, click com o botão direito sobre o
pacote criado anteriormente, quando uma nova janela aparecer (figura abaixo), coloque o
nome CarroBean e click em finalizar.

Uma classe será criada, devemos acrescentar os seguintes códigos nela.
package psv;//Este não é necessário pois é colocado automaticamente
public class CarroBean {
Aqui colocamos os atributos, todos encapsulados com private para que não sejam
acessados diretamente.
private String placa;
private String cor;
private String descricao;
Aqui colocamos os métodos de acesso aos atributos private da classe. Todos os atributos
tem um par de métodos, um get (responsável por devolver o valor atual do atributo) e um set
(responsável por setar valor para o atributo). Esses métodos são a interface para acesso aos
valores desses atributos.
public String getCor() {
return cor;
}
public void setCor(String cor) {
this.cor = cor;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getPlaca() {
return placa;
}
public void setPlaca(String placa) {
this.placa = placa;
}
Precisamos fechar a classe.
}
Dica: No netbeans podemos criar os gets e sets de forma rápida usando o procedimento a
seguir.
1 – pressione ALT+INSERT e aparecerá a figura abaixo.
Selecione esta opção.

2 – Selecione “Getter e setter” e pressione enter. Quando aparecer a janela “Gerar getters e
setters”, selecione os atributos conforme figura abaixo e click em gerar. Pronto! Todos os seus
métodos de acesso aos atributos estão feitos.
Terceiro passo: Criação da classe CarroDAO. Para isso, click com o botão direito sobre o
pacote criado anteriormente, quando uma nova janela aparecer (figura abaixo), coloque o
nome CarroDAO e click em finalizar.

Uma classe será criada, devemos acrescentar os seguintes códigos nela. Essa classe será
responsável pelo contato com o banco de dados nosso, ou seja, ela será responsável por
incluir, alterar, pesquisar e excluir dados da tabela (CRUD).
Primeiro vamos criar a base da classe, com um atributo do tipo Connection, que será o
responsável por guardar a conexão usada durante o processo. Os componentes da classe
serão descritos a seguir.
package psv;//Este não é necessário, pois é colocado automaticamente.
Precisamos importar dois pacotes, o sql e o util. O primeiro contém classes para manipulação
banco de dados e o segundo contém classes para trabalharmos com collections.
import java.sql.*;
import java.util.*;
public class CarroDAO {
Criando o atributo da classe Connection.
private Connection con;
Vamos criar agora o construtor da classe que receberá como argumento uma conexão e a
passará ao nosso atributo com.

public CarroDAO(Connection con){
setCon(con);
}
Podemos, então criar os métodos get e set para o nosso atributo con.
public Connection getCon() {
return con;
}
public void setCon(Connection con) {
this.con = con;
}
Precisamos fechar a classe.
}
Bom, agora que temos a nossa classe base, podemos criar os métodos CRUD.
Começaremos com o método de inserção (inserir).
Este método receberá um objeto CarroBen como parâmetro e fará a persistência deste
no banco de dados, isto é, fará a gravação efetiva desses dados na nossa tabela carro. Cabe
observar que não está no escopo deste tutorial tratar de transações em banco de dados, não
nos preocuparemos com isso aqui, no futuro em outro tutorial tratarei disso.
Vamos criar a assinatura do método, que tem como retorno uma String para avisar ao
usuário se tudo ocorreu bem ou se deu algum erro.
public String inserir(CarroBean carro) {
Precisamos agora de uma variável do tipo String para passarmos o comando sql para o banco.
Observe que, com exceção das interrogações (que serão substituídas pelos valores dos
campos), são comandos padrões de SQL que, para o Java é apenas uma String.
String sql = "insert into carro(placa,cor,descricao)values(?,?,?)";
Ainda dentro do método (inserir), vamos abrir um bloco try colocar o código para enviar dados
para o banco. Esse tratamento de exceção é necessário porque pode ocorrer a seguinte
exceção: SQLException.
try {
Agora precisamos preparar o nosso comando para enviar ao banco. Para isso usaremos a
interface PreparedStatement.
PreparedStatement ps = getCon().prepareStatement(sql);
Após preparar o comando, podemos substituir as interrogações pelos valores dos campos
correspondentes. A seqüência aqui é muito importante, pois a primeira interrogação
corresponde ao campo número 1, a segunda, ao campo número 2 e assim por diante.
ps.setString(1, carro.getPlaca());
ps.setString(2, carro.getCor());
ps.setString(3, carro.getDescricao());
Feito isso vamos efetivar a inserção no banco, para isso podemos usar o método execute
(retorna um boolean ) ou executeUpdate (retorna um inteiro com o número de linhas

afetadas pela operação), vamos usar o segundo.
Vamos executar o comando e fazer o teste ao mesmo tempo para verificar se alguma linha foi
afetada para podermos retornar uma mensagem de sucesso ou insucesso.
if (ps.executeUpdate() > 0) {
return "Inserido com sucesso.";
} else {
return "Erro ao inserir";
}
finalizá-lo, no nosso caso teremos 1 catch para SQLException (exceções que podem
ocorrer durante a conexão com o banco).
return e.getMessage();
}
}
O próximo método é o de alteração (alterar).
Este método receberá um objeto CarroBen como parâmetro e fará a alteração dos dados na
nossa tabela carro. Este método não tem diferenças significativas em relação ao método
inserir, as únicas exceções são a String SQL e a seqüência dos parâmetros. Lembre-se, o
campo chave (placa) não pode ser alterado.
public String alterar(CarroBean carro){
String sql = "update carro set cor = ?,descricao = ?";
sql += " where placa = ?";
try {
return "Alterado com sucesso.";
} else {
return "Erro ao alterar";
}
}
}
O próximo método é o de exclusão (excluir).
Este método receberá um objeto CarroBen como parâmetro e fará a exclusão dos dados na
nossa tabela carro. Este método não tem diferenças significativas em relação ao método
alterar, as únicas exceções são a String SQL e que ele só tem um parâmetro.

public String excluir(CarroBean carro){
String sql = "delete from carro where placa = ?";
try {
return "Excluído com sucesso.";
} else {
return "Erro ao excluir";
}
}
}
E agora vamos ao ultimo método, lstarTodos. Ele tem várias diferenças dos demais, por isso
será explicado em detalhe.
Precisamos criar um método que retorne uma coleção de objetos, pois ele irá ao banco e trará
todos os dados que se encontram na tabela carro. Para isso usaremos uma implementação da
interface List, a ArrayList. A escolha por tal implementação é meramente didática, sem
levar em consideração as vantagens ou desvantagens dela. Dessa forma, a assinatura do
método fica assim:
public List<CarroBean> listarTodos() {
Como vamos listar todas as linhas da tabela, a nossa String SQL fica bem simples.
String sql = "select * from carro ";
Vamos criar uma lista de carros para armazenar os objetos carros que retornarão da nossa
consulta.
List<CarroBean> listaCarro = new ArrayList<CarroBean>();
As duas linhas a seguir já foram explicas anteriormente.
try {
Agora precisamos de um objeto da classe ResultSet para armazenar o resultado vindo do
banco. Observe que, diferentemente dos outros três métodos, neste usamos o
executeQuery para efetivar a nossa operação.
ResultSet rs = ps.executeQuery();
Um objeto ResultSet tem acesso ao método next que permite percorrer todos os dados nele
contido. Porém, se a consulta não retornar dados e tentarmos usá-lo, pode ocorrer uma
exceção, por isso é necessário fazer essa verificação antes.
if (rs != null) {
Se a consulta retornou dados, podemos percorrê-los e fazer a atribuição a um objeto e guardar
este na nossa lista. Dentro no laço (while) um objeto CarroBean é criado e os seus atributos
são preenchidos com os dados dos campos correspondentes da tabela. Observe que os
números dentro dos parênteses correspondem à ordem dos campos da tabela,
alternativamente podemos usar os nomes dos campos.

while (rs.next()) {
CarroBean cb = new CarroBean();
cb.setPlaca(rs.getString(1));
cb.setCor(rs.getString(2));
cb.setDescricao(rs.getString(3));
listaCarro.add(cb);
}
return listaCarro;
} else {
return null;
}
return null;
}
}
As linhas a seguir já foram explicadas anteriormente.
return null;
}
}
Com isso temos todas as classes necessárias, só nos resta fazer um teste para ver se estão
funcionando realmente. Não criaremos interface ainda (ficará para a parte 2 deste tutorial),
por
isso vamos criar uma classe de teste (Teste.java).
Crie uma classe chamada Teste com o método main.
package psv;
import java.sql.*;
import java.util.*;
public class Teste {
}
}
Agora testaremos as funcionalidades uma a uma:
1 – testando a conexão: dentro do método main coloque a linha de comando abaixo e execute
a classe (Shift+f6). Se você ver a mensagem “Conexão aberta” pode seguir em frente, se não,
revise a classe Conexao e verifique os passos anteriores: banco, driver,...
Connection con = Conexao.abrirConexao();
2 – criando os objetos necessários para a manutenção da tabela:
CarroDAO cd = new CarroDAO(con);

3 - Testando o método inserir: faça a seguinte operação.
cb.setPlaca("JKK1900");
cb.setCor("Azul");
cb.setDescricao("Carro 1");
System.out.println(cd.inserir(cb));
Verifique no seu banco de dados se o registro foi inserido, conforme figura a seguir.
4 - Testando o método alterar: escolha um dos carros e faça algumas alterações, observe que
a placa não deve ser alterada e ela deve existir no banco.
cb.setPlaca("JKL2897");
cb.setCor("Amarelo");
System.out.println(cd.alterar(cb));

Faça a consulta novamente. Aqui o carro verde foi alterado para carro amarelo.
5 - Testando o método excluir: vamos excluir o carro com placa JKL2897.
cb.setPlaca("JKL2897");
System.out.println(cd.excluir(cb));
Faça a consulta novamente.

6 - Testando o método listarTodos: como o método retorna uma List, precisamos criar uma
para receber o resultado. O código é mostrado a seguir, observe que estamos usando For-
Each para percorrer a lista. Se você não está familiarizado com o assunto, pesquise material a
respeito do FrameWork Collection.
List<CarroBean> lista = cd.listarTodos();
if(lista != null){
for(CarroBean carro : lista){
System.out.println("Placa: "+carro.getPlaca());
System.out.println("Cor: "+carro.getCor());
System.out.println("Descrição:
"+carro.getDescricao());
}
}
Resultado:
Placa: JKE2013
Cor: Preto
Descrição: Carro 2
Placa: JKK1900
Cor: Azul
Descrição: Carro 1
Com isso você já está pronto para criar a interface para o usuário fazer manutenção da
tabela carro.
Abaixo passaremos as classes para que você não se dê ao trabalho de copiar das
explicações acima. Lembrando que este conteúdo foi tirado do site
http://www.pusivus.com.br.

Classe Conexao.java
package psv;
import java.sql.*;
public class Conexao {
public static Connection abrirConexao() {
Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInst
ance();
String url = "";
url +=
"jdbc:mysql://127.0.0.1/estacionamento?";
url += "user=root&password=";
con = DriverManager.getConnection(url);
System.out.println("Conexão aberta.");
} catch (ClassNotFoundException e) {
}
return con;
}
public static void fecharConexao(Connection con) {
try {
con.close();
System.out.println("Conexão fechada.");
}
}
}

Classe CarroBean.java
package psv;
public class CarroBean {
private String placa;
private String cor;
private String descricao;
public String getCor() {
return cor;
}
public void setCor(String cor) {
this.cor = cor;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String getPlaca() {
return placa;
}
public void setPlaca(String placa) {
this.placa = placa;
}
}

Classe CarroDAO.java
package psv;
import java.sql.*;
import java.util.*;
public class CarroDAO {
private Connection con;
public CarroDAO(Connection con) {
setCon(con);
}
public String inserir(CarroBean carro) {
String sql = " insert into
carro(placa,cor,descricao)values(?,?,?)";
try {
return "Inserido com sucesso.";
} else {
return "Erro ao inserir";
}
}
}
public String alterar(CarroBean carro) {
String sql = "update carro set cor = ?,descricao = ?";
sql += " where placa = ?";
try {
return "Alterado com sucesso.";
} else {
return "Erro ao alterar";
}
}
}

public String excluir(CarroBean carro) {
String sql = "delete from carro where placa = ?";
try {
return "Excluído com sucesso.";
} else {
return "Erro ao excluir";
}
}
}
public List<CarroBean> listarTodos() {
String sql = "select * from carro ";
try {
ResultSet rs = ps.executeQuery();
if (rs != null) {
while (rs.next()) {
cb.setPlaca(rs.getString(1));
cb.setCor(rs.getString(2));
cb.setDescricao(rs.getString(3));
listaCarro.add(cb);
}
return listaCarro;
} else {
return null;
}
return null;
}
}
public Connection getCon() {
return con;
}
public void setCon(Connection con) {
this.con = con;
}
}

Classe Teste.java
package psv;
import java.sql.*;
import java.util.*;
//Testando método inserir
/* cb.setPlaca("JKL2897");
cb.setCor("Verde");
System.out.println(cd.inserir(cb));*/
//Testando método alterar
/*cb.setPlaca("JKL2897");
cb.setCor("Amarelo");
System.out.println(cd.alterar(cb));*/
//Testando excluir
/* cb.setPlaca("JKL2897");
System.out.println(cd.excluir(cb));*/
List<CarroBean> lista = cd.listarTodos();
if(lista != null){
for(CarroBean carro : lista){
System.out.println("Placa: "+carro.getPlaca());
System.out.println("Cor: "+carro.getCor());
System.out.println("Descrição:
"+carro.getDescricao());
}
}
Conexao.fecharConexao(con);
}
}

5.3 Minha aplicação com interface gráfica (PUSIVUS - Continuação)
Para acompanhar este tutorial é recomendável que você tenha seguido todas as
etapas da primeira parte deste que se encontra em: http://www.pusivus.com.br na seção de
tutoriais.
Supondo que você tenha acompanhado a primeira parte deste tutorial, você já deve
ter um banco de dados (MySQL) chamado estacionamento com uma tabela chamada carro e
as seguintes classes: CarroBean, CarroDAO e Conexao. Com isso, só precisamos agora criar a
interface e empacotar a nossa aplicação. Para realizar este trabalho, este tutorial está dividido
em duas etapas, a primeira é a criação da interface para comunicação com o usuário e
segunda, a criação do arquivo .jar. Cada etapa foi dividida em passos, siga-os.
1 – Crie um formulário dentro do pacote criado na parte I deste tutorial. Para isso, click com o
botão direito sobre o pacote e escolha novo->formulário JFrame, em seguida preencha o nome
do formulário conforme figura abaixo e click em finalizar.

Feito isso, você verá o ambiente sofreu mudanças, novas componentes aparecem
agora, conforme pode ser observado na figura abaixo. Como se pode ver, temos um formulário
pronto para ser modelado de acordo com o nosso desejo e necessidade.
Nesse formulário você pode colocar qualquer um dos componentes (botão, rótulo,
painel,..) da paleta que se encontra à direita acima. Para fazer isso, basta clicar, arrastar e
soltar o componente dentro do formulário. Você também tem as propriedades dos
componentes, que podem ser alterados, em foco (selecionado), à direita abaixo da paleta de
componentes. Além disso, você pode alternar entre o modo desenho e o módo código-fonte,
bastando, para isso, selecionar uma das opções. Click em “código-fonte”, você verá que já
existe algum código gerado automaticamente.

2 – Já que temos o nosso formulário, vamos colocar os componentes necessários para
manutenção do nosso banco de dados, ou seja, colocaremos os componentes de entrada de
dados, botões, e uma tabela para exibir dados de pesquisa.
Então, vamos começar a desenhar o nossa tela.
a) Procure o componente Panel na paleta de componente, click nele e o arraste para o
formulário, redimensione-o de maneira que como uma faixa superior no formulário.
Mude a propriedade “background” para a cor branca. Para isso, localize a propriedade
e click no botão ao lado. O seu formulário
deve se parecer com a figura abaixo.
b) Coloque um componente Rótulo (Label) dentro do componente Panel que você acaba
de colocar no formulário e mude as propriedades text (escreva Cadastramento de
veículos) e font (a fonte e o tamanho desejado e click em OK). Você pode acessar as
propriedades dos componentes clicando com o botão direito sobre eles e
selecionando propriedades, uma janela como a figura abaixo aparecerá. Para mudar a
cor da fonte, acesse a propriedade “foreground”.

Até aqui, a sua tela deverá estar como a da figura abaixo.
c) Coloque outro Panel, logo abaixo do anterior e mude a propriedade “background” para
uma cor diferente da que foi colocada no primeiro, como mostra a figura abaixo.

d) Coloque quatro rótulos no segundo Panel e mude a propridade text deles para ficar
como mostra a figura abaixo.
Para o quarto rótulo, precisamos mudar seu nome interno, ou seja, o nome ao qual iremos
nos referir a ele. É neste rótulo que colocaremos as mensagens devolvidas pela classe
CarroDAO, por isso precisamos dar um nome que nos seja familiar (em vez JLabel5). Para isso,
click com o botão direito do mouse sobre o rótulo “Mensagem” e click na opção “Alterar nome
da variável”; coloque o nome lblMensagem, conforme figura abaixo, e click em OK. Procure
colocar os nomes dos componentes com 3 letras iniciais que lembrem do que se trata.

e) Coloque 3 componentes “Caixa de texto” e mude as propriedades text de todos para
vazio, ou seja, limpe o texto que estiver lá (conforme figura abaixo). Altere o nome da
variável (da mesma forma como foi feito com o rótulo “Mensagem”) de cada um da
seguinte forma: o primeiro deverá se chamar txtPlaca, o segundo, txtCor e o terceiro,
txtDescricao.
Alterne para o código-fonte (click em “código-fonte”) e você verá que os seus
componentes já estão com os nomes que você colocou, como pode visto na figura
abaixo. Não é possível alterar qualquer valor na parte cinza do código.

f) Coloque um novo Panel abaixo do segundo, mude seu “background” para a mesma cor
do segundo e coloque 6 botões, muda a propriedade text deles, conforme mostra a
figura abaixo. Mude também o nome interno (botão direito sobre ele, escolher “Mudar
nome da variável”, colocar o nome e clicar em OK) deles para btnIncluir, btnAlterar,
btnExcluir, btnPesquisar, btnLimpar e btnFechar, conforme a ordem que aparece na figura.

g) Vamos colocar agora uma tabela para exibir os dados quando clicarmos em
“Pesquisar”. Para isso, coloque um componente Panel, mude a cor do seu background
para a mesma do último colocado no formulário, coloque um componente Tabela
nesse Panel, conforme mostra figura abaixo.

Como se pode observar, a tabela já vem pré-definida com 4 linhas e 4 colunas, mas isso
para nós não serve porque precisamos de 3 colunas e o número de linha não sabemos, pois
dependerá da quantidade de linhas que a consulta retornará. Por isso, vamos configurar a
tabela para ficar do jeito que queremos, ou seja, com 3 colunas, nenhuma linha
(acrescentaremos as linhas dinamicamente). Para isso siga o procedimento abaixo.
h) Click com o botão direito do mouse sobre a tabela e selecione “Conteúdo da tabela”,
com isso, a caixa de diálogo da figura abaixo irá aparecer.

i) click com o botão direito do mouse sobre a tabela e selecione “Conteúdo da tabela”,
com isso, a caixa de diálogo da figura abaixo irá aparecer.

j) Deixe marcada a opção “Especificado pelo usuário” e selecione a aba “Colunas”.
Selecione a última linha e click em excluir, mude os títulos das três linhas restantes,
mude o tipo e desmarque os checkbox (conforme figura abaixo) porque não queremos
que ela seja editável e nem redimensionda pelo usuário, pois nosso objetivo é usá-la
apenas para exibir dados.

k) Selecione a aba “Linhas”, selecione todas as linhas, conforme figura abaixo, e click em
excluir, com isso, temos uma tabela com três colunas e zero linha.
Agora só precisamos mudar o nome da tabela, botão direito -> Alterar nome da variável,
coloque tblConsulta. A sua tela deverá estar parecida com a figura abaixo. Para que ela não
seja redimensionável, e estrague seu desenho, desmarque a propriedade “resizeble”.

Eventos dos Componentes
a) Botão Incluir: Dê um duplo clique no botão “Incluir” e comece a digitar os comandos
que serão executados no momento em que o usuário clicar neste botão. Esta será a
ação/código a ser inserido:
cb.setPlaca(txtPlaca.getText());
cb.setCor(txtCor.getText());
cb.setDescricao(txtDescricao.getText());
lblMensagem.setText(cd.inserir(cb));
b) Botão Alterar: Dê um duplo clique neste botão e escreva a seguinte codificação:
cb.setCor(txtCor.getText());
cb.setDescricao(txtDescricao.getText());
lblMensagem.setText(cd.alterar(cb));
c) Botão Excluir: Dê um duplo clique neste botão e escreva a seguinte codificação:
Object[] opcoes = { "Sim", "Não" };
int i = JOptionPane.showOptionDialog(null,
"Deseja excluir esse veículo:
"+txtPlaca.getText()+"?", "Exclusão",
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE, null,
opcoes, opcoes[0]);
if (i == JOptionPane.YES_OPTION) {
lblMensagem.setText(cd.excluir(cb));
}

d) Botão Pesquisar: Dê um duplo clique neste botão e escreva a seguinte codificação:
listaCarro = cd.listarTodos();
DefaultTableModel tbm =
(DefaultTableModel)tblConsulta.getModel();
for(int i = tbm.getRowCount()-1; i >= 0; i--){
tbm.removeRow(i);
}
int i = 0;
for(CarroBean cb : listaCarro){
tbm.addRow(new String[1]);
tblConsulta.setValueAt(cb.getPlaca(), i, 0);
tblConsulta.setValueAt(cb.getCor(), i, 1);
tblConsulta.setValueAt(cb.getDescricao(), i, 2);
i++;
}
e) Botão Limpar: Dê um duplo clique neste botão e escreva a seguinte codificação:
txtPlaca.setText("");
txtCor.setText("");
txtDescricao.setText("");
lblMensagem.setText("");
DefaultTableModel tbm =
(DefaultTableModel)tblConsulta.getModel();
for(int i = tbm.getRowCount()-1; i >= 0; i--){
tbm.removeRow(i);
}
f) Botão Fechar: Dê um duplo clique neste botão e escreva a seguinte codificação:
System.exit(0);

Feita a pesquisa queremos que o usuário possa escolher o registro que deseja alterar ou
excluir. Para isso precisamos capturar a linha que ele selecionou. Para isso, vamos criar um
método para o click do mouse na tabela, o procedimento é o mesmo feito para os botões. O
código em vermelho deverá ser acrescentado.
Na primeira linha estamos capturando a linha que o usuário clicou. Na segunda,
terceira e quarta linha estamos pegando o valor de cada célula da tabela, que corresponde a
cada atributo da classe carro. O cast é necessário porque o objeto JTable retorna um objeto e
nós precisamos de uma String para passar para os campos de texto.
Na quarta, quinta e sexta linha estamos atribuindo o valor para os campos de texto do
formulário.
O resultado é mostrado na figura a seguir. Como pode ser observado, os dados da
linha selecionada pelo usuário são transferidos para os campos do formulário.
g) Evento da tabela (MouseClicked): Na tabela, do seu modelo no Netbeans,
clique nela com o botão esquerdo e logo depois com o botão direito e escolha a opção
do evento MouseClicked (Eventos>Mouse>mouseClicked). Depois insira o seguinte
código:
Integer linha = tblConsulta.getSelectedRow();
String placa = (String)tblConsulta.getValueAt(linha, 0);
String cor = (String)tblConsulta.getValueAt(linha, 1);
String descricao = (String)tblConsulta.getValueAt(linha, 2);
txtPlaca.setText(placa);
txtCor.setText(cor);
txtDescricao.setText(descricao);

6.0 iReport – Desenvolvendo de Relatórios
O iReport é uma ferramenta para desenvolver relatório com conexão ao Banco de
Dados. Isso permite ao programador montar relatórios profissionais onde o mesmo pode
escolher sua fonte de informações para montar o documento (ou seja, o relatório pode ser
montado através de dados do usuário diretamente ou pode ser recolhido do próprio banco de
dados).
Baixe os seguintes requisitos (você pode baixar as versões mais recentes):
 commons-beanutils-1.8.2.jar
 commons-collections-3.2.1.jar
 commons-digester-2.1.jar
 commons-logging-1.1.jar
 groovy-all-1.7.5.jar
 iText-2.1.7.jar
 jasperreports-5.0.0.jar
 poi-3.7-20101029.jar
 iReport-5.0.0-windows-installer.exe
6.1 Relatório Com Inserção De Dados Via Software
Vamos montar um exemplo em que o usuário fornece diretamente os dados para
montar o relatório (Obs.: Baixe e instale o iReport. No exemplo a versão dessa ferramenta é o
5.0.0).
a) Vamos aproveitar o projeto do estacionamento acima e criar mais duas classes. Crie a
primeira com o nome Cliente. Logo em seguida coloque os seguintes atributos:
nome, telefone e email (gere seus respectivos gets e sets ondes estres
devem ter as nomenclaturas padrões - get+nome_variavel ou set+nome_variavel para
evitar problemas com o iReport):

b) Agora vamos abrir o nosso iReport 5.0.0 e desenhar o nosso relatório. Vamos até a
barra de menu do iReport e escolha a opção arquivo>new (se seu iReport estiver na
versão portuguesa basta traduzir as palavras de acesso). Logo a seguinte aparecerá a
seguinte janela:
De inicio selecione o estilo de página “Blank A4” e logo após clique em “Launch Report
Wizard”.

Nesta janela você deve alterar o nome do relatório para “relatorio” e clicar no botão
“Browser” para navegar até o diretório do seu projeto e salvar este arquivo na pasta do
seu programa (no meu caso seria este o caminho
C:UsersJHUNIORDocumentsNetBeansProjectsEstacionamento).

Nesta tela, por enquanto, não vamos mexer em suas configurações. Clique em próximo em
todas as telas até chegar a esta tela (clique em “Finalizar”).

LEGENDA DE CADA UMA DAS ABAS EM DESTAQUE
Paleta: Seria um componente semelhante à paleta do Netbeans onde ficam os componentes
gráficos, prontos para serem arrastados para que se monte a interface gráfica. Nela contem
componentes que podem fornecer desde horas até datas;
Propriedades: Equivale opção de propriedades do Netbeans onde o programador pode
controlar as propriedades de cada objeto arrastado da paleta;
Barra de Formatação de Texto: Com esta ferramenta, podemos controlar o estilo dos texto de
vários componentes (ststicText [JLabel] que serve para inserir texto por exemplo);
Área de criação do Relatório: Este equivale ao JFrame do Netbeans, onde você insere os
componentes gráficos para montar um formulário gráfico;
Console de erro: Permite reportar qualquer irregularidade interna ou externa que ocorra
durante a compilação/execução do relatório;
Report Inspector : Permite controlar os dados de entrada do relatório. Ou seja, é responsável
por inspecionar os dados (parâmetros enviados pelo Java ou Querys usadas para selecionar os
dados a serem exibidos do Banco de Dados) que serão exibidos pelo Documento;
Botão que permite visualizar o documento.

Agora vamos ao Report Inspector >Fields e criar três variáveis/Filds com os mesmos
nomes usados na classe Cliente que criamos lá no Netbeans (Clique em Fields com o botão
esquerdo e depois clique em Adicionar Field).
Depois de criados os Fields, selecione-os e os arraste para o apara o Detail 1 do
relatório. O Column Header seria como o cabeçalho de nosso documento e o Detail 1 seria a
aparte onde ficará toda a informação (obs.: a largura do Detail 1 representa a distância de um)
registro para o outro. Formate-o como na figura abaixo:
Este local é onde será
moldada tabela de
informações dos
clientes. Os feilds são
controlados por
variáveis/parâmetros
($F{nome_variavel}).
Colunas da futura tabela

Retorne ao Netbeans e crie, no mesmo pacote que a classe Clientes.java uma
classe chamada Teste.java (no meu caso eu já avia criado) Crie um método principal (digite
psvm e aperte TAB). Adicionem na biblioteca de seu projeto os jar’s baixados anteriormente,
clicando na parte Bibliotecas>Adicionar Jar/pasta e navegue até o diretório onde se encontra
os arquivos necessários.
Insira o seguinte código na classe Teste.java:
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
public static void main(String[] args) throws JRException, SQLException {
// lista com os nossos clientes
Cliente c1 = new Cliente();
c1.setNome("MARIA");
c1.setEmail("maria@email.com");
c1.setTelefone("3683-9087");
c2.setNome("JOÃO");
c2.setEmail("joao@email.com");
Dica: Pesquise sobre
estes arquivos. Eles
servem para criar uma
interface para
calendários em Java.

c3.setNome("PEDRO");
c3.setEmail("pedro@email.com");
List lista = new ArrayList();
System.out.println("Gerando relatório...");
lista.add(c1);
lista.add(c2);
lista.add(c3);
// compilacao do JRXML
JasperReport report =
JasperCompileManager.compileReport("relatorio.jrxml");
// preenchimento do relatorio, note que o metodo recebe 3 parametros: // 1 -
//o relatorio
//
// 2 - um Map, com parametros que sao passados ao relatorio
// no momento do preenchimento. No nosso caso eh null, pois nao
// estamos usando nenhum parametro
//
// 3 - o data source. Note que nao devemos passar a lista diretamente,
// e sim "transformar" em um data source utilizando a classe
// JRBeanCollectionDataSource
JasperPrint print = JasperFillManager.fillReport(report, null, new
JRBeanCollectionDataSource(lista));
// exportacao do relatorio para outro formato, no caso PDF sanvando no
//diretório descrito abaixo (Vocês podem escolher os destino do arquivo)
JasperExportManager.exportReportToPdfFile(print,
"C:UsersJHUNIORDesktopRelatorioClientes.pdf");
System.out.println("Relatório gerado.");
}
}
O arquivo final foi gerado será semelhante a este:
Este
espaçamento
é resultado da
configuração
do Detail.
Este é o Column Header
configurado no iReport.

6.2 Relatório Gerado Com Dados Do BD MySQL
Vamos aproveitar o projeto do Estacionamento, e criar um botão que gere a lista de
todos os carros cadastrados.
Crie um botão gráfico com o nome “btnListagem” na interface do seu programa.
Abra o iReport e crie um relatório em Menu>Arquivo>New e siga as etapas abaixo das
imagens:

Escolha esta opção de estilo
do relatório.
Clique aqui
Edite o nome do relatório para
“listagem”.
Escolha o diretório do
projeto Estacionamento e
salve o arquivo lá.

Aqui você vai criar a conexão com o banco de dados do
projeto, que está no SGBD do MySQL. Clique em New e
siga as demais etapas.
Selecione esta opção
Aqui fica armazenadas todas as conexões criadas
anteriormente.

Preencha os campos de forma a ficarem da seguinte maneira:

Nome da Conexão
Driver de conexão
JDBC.
URL de conexão
entre o relatório e
o seu Banco de
Dados.
Usuário e Senhas padrão do
MySQL.
Teste sua conexão. Caso seja bem sucedida ou não aparecerá uma mensagem.
Selecione sua conexão.
Construa a sua
Query de
seleção dos
dados que
faram parte do
relatório.
Desenhe graficamente sua Query.

Na próxima interface cliquem no botão “finalizar”.
Passe todos os campos
para o lado direito. Pois
precisamos de todos no
relatório.
Ordem de seleção dos registros (opcional).

Logo em seguida, faça o mesmo procedimento de arrastar os “Fields” para o
seu relatório. Se preferir coloque algo a mais no seu relatório (enfeites). Logo você terá algo
mais ou menos assim:

Vamos implementar o botão de listagem. Existem duas maneiras de se fazer a listagem
de um relatório.
1. JasperViewer
Dê um duplo clique no botão “Listagem” e crie um método chamado
geraraRelatorio() e insira o seguinte código:
private synchronized final void geraraRelatorio() {
// “synchronized final” ou apenas “final” ajuda na
//velocidade do método
try
{
JasperPrint jp =
JasperFillManager.fillReport("listagem.jasper", new
HashMap(), con);
JasperViewer jrv = new JasperViewer(jp);
JasperViewer.viewReport(jp, false);
}
catch(Exception erro) {
JOptionPane.showMessageDialog(null,"Erro ao
exibir o relatório:
n"+erro.getMessage()+"n"+erro.getCause()+"n"+erro.toStr
ing(),"Erro no iReport",JOptionPane.ERROR_MESSAGE);
}
}
Este será o resultado:

2. JDialog personalizado
Edite o código já existente no método geraraRelatorio() para:
try
{
JasperPrint jp =
JasperFillManager.fillReport("listagem.jasper", new HashMap(), con);
JasperViewer jrv = new JasperViewer(jp);
JDialog jdPainelListagem;
jdPainelListagem = new JDialog(new
javax.swing.JFrame(),"Visualização da Listagem Geral", true);
//Configurando o tamanho da janela
jdPainelListagem.setSize(1000,600);
jdPainelListagem.setLocationRelativeTo(null);
// URL (localização) do nosso ícone
URL url = this.getClass().getResource("Meu_icone.png");
Image iconeTitulo =
Toolkit.getDefaultToolkit().getImage(url);
//Mudando o ícone da nossa janela
jdPainelListagem.setIconImage(iconeTitulo);
jdPainelListagem.getContentPane().add(jrv.getContentPane());
Icone e titulo desta janela não pode ser
mudado com este primeiro método.
É permitido maximizar,
minimizar e fechar.

jdPainelListagem.setVisible(true);
}
JOptionPane.showMessageDialog(null,"Erro ao exibir o
relatório:
n"+erro.getMessage()+"n"+erro.getCause()+"n"+erro.toString(),"Erro
no iReport",JOptionPane.ERROR_MESSAGE);
}
}
Este será o resultado:
Obs.: O JDialog é mais apropriado para ser usado nesta situação porque ele não interfere no
evento de fechamento do JFrame principal (pois se um JDialog for fechado, com um clique no
botão de fechar da janela ou de qualquer outra forma, O JFrame principal continua
aberto/executando normalmente). Isso vale para outras ocasiões.
Ícone e titulo foram alterados. E observe que as opções da janela foram
limitadas. O usuário poderá apenas fechala. Isso dá para fazer com o JFrame, o
código é o mesmo.

6.3 Relatórios Gerados com Envio de Parâmetros
Aproveitando o projeto do estacionamento, vamos programar uma função que gere
um “Cartão de Comprovação”. Suponha que este estacionamento gere cartões com dados de
cada carro estacionado para serem dados aos respectivos donos dos veículos.
Crie um arquivo no iReport, seguindo os mesmos passos acima (os mesmo passos para
criar o arquivo “listagem.jasper” usado para a listagem dos automóveis).
Utilize a mesma conexão criada anteriormente.
A Query serve para executar a
seleção dos dados para o
relatório.

Passe todos os campos para o lado esquerdo pois vamos precisar de todos.
Ao concluir todas as etapas, vá no “iReport Inspector” e crie um parâmetro com o
nome “placa” (clique em Parameters>Adicionar Parameter. Cria o parâmetro e depois
renomeio):

Clique com o botão direito em e escolha a opção “Edit Query”. Aparecerá
uma interface com a “Query” feita inicialmente com o intuito de selecionar todas as
informações de nosso banco de dados. Vamos conhecer as principais funções e observações
desta interface:

Edite a Query para que ela selecione, da tabela carro (Banco de Dados
estacionamento), apenas o registo que possui o valor “placa” igual ao do parâmetro
enviado pela nossa aplicação.
SELECT * FROM CARRO WHERE CARRO.PLACA = $P{placa}
Obs.: O argumento $P{placa} refere-se ao parâmetro chamado “placa” e não ao
Field “placa” representado por $F{placa}.
Área de edição da Query de seleção de
dados. Esta será editado mais a frente.
Mostra os
campos de
nossa tabela.
Edita
graficamente
nossa Query. Cria um novo
parâmetro.
Visualiza o resultado da execução de
nossa Query.

Agora você deve eliminar alguns elementos desnecessários no nosso relatório, que
seria as áreas de Title, Page Header, Column Header, Column Footer e Page Footer.
Estas linhas horizontais podem ser movimentadas arrastando-as para cima ou para
baixo com o mouse (usamos isso para configurar o espaçamento entre os registos
em uma tabela anterior mente). Mova-as essas linhas acima do Detail 1 para cima
do registro (até pararecer uma linha vermelha) e as de baixo clique com o botão
direito e escolha a opção Delete Band. Assim sobrará apenas o Detail 1.

Usando os seguintes componentes da paleta monte o seu modelo de carão:
Aba Report Elements
 Rectangle
 Line
 Static Text
 Fields
Aba Tools
 Current date

Visualize o documento:
Vamos implementar um botão para esta função em nosso projeto:
Nossa aplicação é quem fornecerá o
parâmetro (placa do carro). Porem você
deve inserir manualmente para
visualizar.

Crie um botão e dê um duplo clique nele. Depois crie um método chamado
gerarCartao() e insira a codificação a seguir:
private synchronized final void gerarCartao() {
try {
HashMap parametros = new HashMap();
parametros.put("placa",txtPlaca.getText());//Enviando
parâmetro
JasperPrint jp =
JasperFillManager.fillReport("cartao.jasper", parametros, con);
JasperViewer jrv = new JasperViewer(jp, true);
//Você pode implementar em um JDialog se preferir
JasperViewer.viewReport(jp, false);
}
JOptionPane.showMessageDialog(null,"Erro ao exibir o
cartão de autógrafo. ","Erro no iReport",JOptionPane.ERROR_MESSAGE);
System.out.println("");
}
}
Execute seu projeto e clique no botão pesquisar (não se esqueça de selecionar um item da
tabela para que o campo txtPlaca seja preenchido) e depois no botão Cartao e veja o resultado.

7.0 Fazendo o Instalador da Aplicação
Ferramentas
 launch4j-3.1.0-win32: Para converter seu arquivo .jar para .exe;
 inno setup-5.5.3: Para fazer o instalador propriamente dito;
 istool-5.3.0: Auxiliar do inno setup;
Antes de qualquer coisa vá ao seu projeto e configure para que o FrmCarro.java seja
sua classe principal (Estacionamento>Propriedades>Executar). E depois gere o seu
arquivo jar.
Vá ate a pasta dist de seu projeto (no meu caso o caminhho para chegar até lá seria
C:UsersJHUNIORDocumentsNetBeansProjectsEstacionamentodist).
Aqui ficam os jars de seu projeto.

Copie os arquivos do Jasper para esta pasta e um ícone para a executável:
7.1 De .Jar para .Exe
Vamos converter nosso arquivo .jar para .exe (assim fica mais fácil para a execução de
seu projeto encontrar a JRE no computador do usuário). Usaremos o launch4j para a
conversão. Mas antes, para facilitar nossa vida, copie a pasta dist de seu projeto para a área de
trabalho. Renomeio para Estacionamento. Depois agra o launch4j.
A saída do
seu
executável
deve ser a
própria pasta
do aplicativo.
Vá até a pasta
do seu arquivo
jar (na área de
trabalho) e
selecione o
mesmo.
Selecione o
ícone de sua
executável.
Inicializa a conversão.

Vá ate a aba JRE e escolha aversão mínima que sua aplicação exija para que o
aplicativo funcione de maneira correta:

Inicie a conversão de seu arquivo.
Salve o arquivo .xml no mesmo diretório do .jar e do futuro .exe (pasta
Estacionamento na área de trabalho). Esta deve ser a saída final do aplicativo.

7.2 Construindo o seu instalador com Inno Setup e Istool
Abra o Inno setup e siga as instruções abaixo:

Nome do seu aplicativo (no caso
Estacionamento).
Versão de seu
aplicativo.
Empresa que
fabrica o
produto.
Web Site da
empresa.

Aqui você pode escolher onde
será instalado o seu programa.
Program Files Folder: Padrão
de instalação (pasta de
programas);
(Custom): Você configura onde
o aplicativo deve se instalar.
Caso você
escolha a opção
Custom aqui
você digita o
caminho do
diretório de
instalação.
Caso seu aplicativo não
precise de uma pasta para se
instalar, marque esta opção.
Caso você queira que o usuário não
tenha o direito de escolher o
local/diretório da instalação,
desmarque esta opção.
Nome da pasta onde o programa se instalará.

Navegue até o executável que acabamos de criar e
selecione-o. Isso o referência como a “executável
principal”.
Selecione o diretório que contém a nossa
aplicação, que está situado na área de
trabalho com o nome Estacionamento.
Adicione secundários ao projeto.

Na janela abaixo você pode navegar aos arquivos de texto para selecionar os termos
de licença e/ou as recomendações de instalação.
Nome do atalho que ficará no menu iniciar do
Windows.
Criar atalho no
menu iniciar do
Windows.
Criar atalho de
desinstalação no
menu iniciar do
Windows.
Controle de criação de atalhos
(permitir que o usuário
escolha entre criar ou não um
atalho).

Escolha o(s) idioma(s) de sua aplicação.
Saida do instalador
Nome do Instalador.
Icone do Instalador.
Se quiser coloque senha no
instalador.

Abra o IsTool, copie e cole o código gerado:
Ao clicar aqui aparecerá uma janela com duas
opções. Clique em NÃO.

O observe a tela do istool (pesquise para se aprofundar mais). Clique no ícone .
Observe, e reproduza a ação aqui abaixo:

Nesta aba você pode controlar as imagens dos ícones. Sem falar em outras funções
adicionais que i Inno Setup não oferece. Pesquise mais sobre o IsTool. Use esta ferramenta
para implementar ainda mais seus instaladores.
Agora clique em para voltar ao script e clique em para compila/gerar o
instalador.
Veja na Área de trabalho o seu instalador pronto para uso!

Java Curiosidades Métodos

Recommandé

Recommandé

Contenu connexe

Similaire à Java Curiosidades Métodos

Similaire à Java Curiosidades Métodos (20)

Java Curiosidades Métodos