Java

1,414
-1

Published on

0 Comments
3 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,414
On Slideshare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
92
Comments
0
Likes
3
Embeds 0
No embeds

No notes for slide

Java

  1. 1. 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.
  2. 2. 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.
  3. 3. 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
  4. 4. 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
  5. 5. 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. :)
  6. 6. 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.
  7. 7. 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
  8. 8. 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
  9. 9. 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;
  10. 10. <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:
  11. 11. 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:
  12. 12. No final ficará assim:
  13. 13. Logo em seguida insira o seguinte trecho de código: package estudos.java; import javax.swing.JOptionPane; public class EstudosJava { public static void main(String[] args) { 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 .
  14. 14. 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);
  15. 15. 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:
  16. 16. 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:
  17. 17. 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
  18. 18. .: 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;
  19. 19. 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()
  20. 20. 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+""); }
  21. 21. 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!
  22. 22. 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
  23. 23. 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 if (jRadioButton2.isSelected()) //verifica se a opção esta marcada -true jLabel1.setText("Motor escolhido: 1.6"); if (jRadioButton3.isSelected()) //verifica se a opção esta marcada -true jLabel1.setText("Motor escolhido: 2.0");
  24. 24. 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
  25. 25. 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.
  26. 26. - 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!
  27. 27. 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(); } }
  28. 28. 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);
  29. 29. 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.
  30. 30. 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).
  31. 31. 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.
  32. 32. 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.
  33. 33. 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.
  34. 34. 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.
  35. 35. 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.
  36. 36. 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.
  37. 37. 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.
  38. 38. 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.
  39. 39. 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.
  40. 40. 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) { System.out.println(e.getMessage()); } catch (Exception e) { System.out.println(e.getMessage()); } 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 {
  41. 41. 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."); Como nós abrimos um bloco try, devemos ter pelo menos um catch ou finally para 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). } catch (SQLException e) { System.out.println(e.getMessage()); } catch (Exception e) { System.out.println(e.getMessage()); } Podemos fechar o método, então. } 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.
  42. 42. 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.
  43. 43. 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.
  44. 44. 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.
  45. 45. 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
  46. 46. 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"; } Como nós abrimos um bloco try, devemos ter pelo menos um catch ou finally para finalizá-lo, no nosso caso teremos 1 catch para SQLException (exceções que podem ocorrer durante a conexão com o banco). } catch (SQLException e) { return e.getMessage(); } Podemos fechar o método, então. } 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 { PreparedStatement ps = getCon().prepareStatement(sql); ps.setString(1, carro.getCor()); ps.setString(2, carro.getDescricao()); ps.setString(3, carro.getPlaca()); if (ps.executeUpdate() > 0) { return "Alterado com sucesso."; } else { return "Erro ao alterar"; } } catch (SQLException e) { return e.getMessage(); } } 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.
  47. 47. public String excluir(CarroBean carro){ String sql = "delete from carro where placa = ?"; try { PreparedStatement ps = getCon().prepareStatement(sql); ps.setString(1, carro.getPlaca()); if (ps.executeUpdate() > 0) { return "Excluído com sucesso."; } else { return "Erro ao excluir"; } } catch (SQLException e) { return e.getMessage(); } } 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 { PreparedStatement ps = getCon().prepareStatement(sql); 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.
  48. 48. 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; } } catch (SQLException e) { return null; } } As linhas a seguir já foram explicadas anteriormente. } catch (SQLException e) { 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 { public static void main(String[] args) { } } 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: CarroBean cb = new CarroBean(); CarroDAO cd = new CarroDAO(con);
  49. 49. 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"); cb.setDescricao("Carro 3"); System.out.println(cd.alterar(cb));
  50. 50. 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.
  51. 51. 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.
  52. 52. 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 (SQLException e) { System.out.println(e.getMessage()); } catch (ClassNotFoundException e) { System.out.println(e.getMessage()); } catch (Exception e) { System.out.println(e.getMessage()); } return con; } public static void fecharConexao(Connection con) { try { con.close(); System.out.println("Conexão fechada."); } catch (SQLException e) { System.out.println(e.getMessage()); } catch (Exception e) { System.out.println(e.getMessage()); } } }
  53. 53. 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; } }
  54. 54. 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 { PreparedStatement ps = getCon().prepareStatement(sql); ps.setString(1, carro.getPlaca()); ps.setString(2, carro.getCor()); ps.setString(3, carro.getDescricao()); if (ps.executeUpdate() > 0) { return "Inserido com sucesso."; } else { return "Erro ao inserir"; } } catch (SQLException e) { return e.getMessage(); } } public String alterar(CarroBean carro) { String sql = "update carro set cor = ?,descricao = ?"; sql += " where placa = ?"; try { PreparedStatement ps = getCon().prepareStatement(sql); ps.setString(1, carro.getCor()); ps.setString(2, carro.getDescricao()); ps.setString(3, carro.getPlaca()); if (ps.executeUpdate() > 0) { return "Alterado com sucesso."; } else { return "Erro ao alterar"; } } catch (SQLException e) { return e.getMessage(); } }
  55. 55. public String excluir(CarroBean carro) { String sql = "delete from carro where placa = ?"; try { PreparedStatement ps = getCon().prepareStatement(sql); ps.setString(1, carro.getPlaca()); if (ps.executeUpdate() > 0) { return "Excluído com sucesso."; } else { return "Erro ao excluir"; } } catch (SQLException e) { return e.getMessage(); } } public List<CarroBean> listarTodos() { String sql = "select * from carro "; List<CarroBean> listaCarro = new ArrayList<CarroBean>(); try { PreparedStatement ps = getCon().prepareStatement(sql); ResultSet rs = ps.executeQuery(); if (rs != null) { 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; } } catch (SQLException e) { return null; } } public Connection getCon() { return con; } public void setCon(Connection con) { this.con = con; } }
  56. 56. Classe Teste.java package psv; import java.sql.*; import java.util.*; public class Teste { public static void main(String[] args) { Connection con = Conexao.abrirConexao(); CarroBean cb = new CarroBean(); CarroDAO cd = new CarroDAO(con); //Testando método inserir /* cb.setPlaca("JKL2897"); cb.setCor("Verde"); cb.setDescricao("Carro 3"); System.out.println(cd.inserir(cb));*/ //Testando método alterar /*cb.setPlaca("JKL2897"); cb.setCor("Amarelo"); cb.setDescricao("Carro 3"); 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); } }
  57. 57. 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.
  58. 58. 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.
  59. 59. 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”.
  60. 60. 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.
  61. 61. 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.
  62. 62. 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.
  63. 63. 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.
  64. 64. 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.
  65. 65. 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.
  66. 66. 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.
  67. 67. 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.
  68. 68. 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”.
  69. 69. 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: Connection con = Conexao.abrirConexao(); CarroBean cb = new CarroBean(); CarroDAO cd = new CarroDAO(con); cb.setPlaca(txtPlaca.getText()); cb.setCor(txtCor.getText()); cb.setDescricao(txtDescricao.getText()); lblMensagem.setText(cd.inserir(cb)); Conexao.fecharConexao(con); b) Botão Alterar: Dê um duplo clique neste botão e escreva a seguinte codificação: Connection con = Conexao.abrirConexao(); CarroBean cb = new CarroBean(); CarroDAO cd = new CarroDAO(con); cb.setPlaca(txtPlaca.getText()); cb.setCor(txtCor.getText()); cb.setDescricao(txtDescricao.getText()); lblMensagem.setText(cd.alterar(cb)); Conexao.fecharConexao(con); c) Botão Excluir: Dê um duplo clique neste botão e escreva a seguinte codificação: Connection con = Conexao.abrirConexao(); CarroBean cb = new CarroBean(); CarroDAO cd = new CarroDAO(con); cb.setPlaca(txtPlaca.getText()); 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)); } Conexao.fecharConexao(con);
  70. 70. d) Botão Pesquisar: Dê um duplo clique neste botão e escreva a seguinte codificação: Connection con = Conexao.abrirConexao(); CarroDAO cd = new CarroDAO(con); List<CarroBean> listaCarro = new ArrayList<CarroBean>(); 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++; } Conexao.fecharConexao(con); 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);
  71. 71. 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);
  72. 72. 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):
  73. 73. 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”.
  74. 74. 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).
  75. 75. 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”).
  76. 76. 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.
  77. 77. 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
  78. 78. 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 class Teste { public static void main(String[] args) throws JRException, SQLException { // lista com os nossos clientes Cliente c1 = new Cliente(); Cliente c2 = new Cliente(); Cliente c3 = new Cliente(); c1.setNome("MARIA"); c1.setEmail("maria@email.com"); c1.setTelefone("3683-9087"); c2.setNome("JOÃO"); c2.setEmail("joao@email.com"); c2.setTelefone("3093-9550"); Dica: Pesquise sobre estes arquivos. Eles servem para criar uma interface para calendários em Java.
  79. 79. c3.setNome("PEDRO"); c3.setEmail("pedro@email.com"); c3.setTelefone("3653-8974"); 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.
  80. 80. 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:
  81. 81. 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á.
  82. 82. 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.
  83. 83. Preencha os campos de forma a ficarem da seguinte maneira:
  84. 84. 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.
  85. 85. 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).
  86. 86. 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:
  87. 87. 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 { Connection con = Conexao.abrirConexao(); JasperPrint jp = JasperFillManager.fillReport("listagem.jasper", new HashMap(), con); JasperViewer jrv = new JasperViewer(jp); JasperViewer.viewReport(jp, false); Conexao.fecharConexao(con); } 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:
  88. 88. 2. JDialog personalizado Edite o código já existente no método geraraRelatorio() para: private synchronized final void geraraRelatorio() { private synchronized final void geraraRelatorio() { try { Connection con = Conexao.abrirConexao(); 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.
  89. 89. jdPainelListagem.setVisible(true); Conexao.fecharConexao(con); } catch(Exception erro) { 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.
  90. 90. 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.
  91. 91. 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):
  92. 92. 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:
  93. 93. 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.
  94. 94. 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.
  95. 95. 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
  96. 96. 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.
  97. 97. 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 { Connection con = Conexao.abrirConexao(); 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); Conexao.fecharConexao(con); } catch(Exception erro) { 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.
  98. 98. 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.
  99. 99. 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.
  100. 100. Vá ate a aba JRE e escolha aversão mínima que sua aplicação exija para que o aplicativo funcione de maneira correta:
  101. 101. 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.
  102. 102. 7.2 Construindo o seu instalador com Inno Setup e Istool Abra o Inno setup e siga as instruções abaixo:
  103. 103. Nome do seu aplicativo (no caso Estacionamento). Versão de seu aplicativo. Empresa que fabrica o produto. Web Site da empresa.
  104. 104. 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á.
  105. 105. 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.
  106. 106. 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).
  107. 107. Escolha o(s) idioma(s) de sua aplicação. Saida do instalador Nome do Instalador. Icone do Instalador. Se quiser coloque senha no instalador.
  108. 108. Abra o IsTool, copie e cole o código gerado: Ao clicar aqui aparecerá uma janela com duas opções. Clique em NÃO.
  109. 109. O observe a tela do istool (pesquise para se aprofundar mais). Clique no ícone . Observe, e reproduza a ação aqui abaixo:
  110. 110. 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!

×