Este será desativado em breve, por favor visitem o novo site.

O site contém todo o conteúdo deste site e algo mais.

Obrigado pela compreensão,
Saab.

Componentes Swing para trabalhar com datas

Nesse outro post eu mostrei como adicionar ao Netbeans alguns ótimos componentes para quem precisa tratar datas de uma maneira elegante em uma interface bem bonita.
Vale a pena dar uma conferida!

Strings de formatação de datas

Algo que todo mundo deve saber é que em alguns componentes (como os demonstrados no post citado acima) e alguns objetos (que veremos mais adiante) conseguem formatar a data de acordo com uma string, ou seja, mostrar a data em diversos formatos, tais quais definidos por uma string.

Antes de mostrar alguns exemplos vou deixar especificado quais os caracteres que podem compor a string de formatação e o que eles representam.
Segundo a documentação oficial:

Fique a vontade para brincar de combinar esses caracteres para formar a data.
Exemplo:

O objeto SimpleDateFormat: convertendo datas facilmente

A classe SimpleDateFormat do pacote java.lang.text é uma mão na roda tão grande!! Com um objeto dessa classe a gente pode facilmente converter um objeto java.util.Date para uma String no formato que a gente quiser (através da string de formatação).
Exemplo:

SimpleDateFormat sd = new SimpleDateFormat(“yyyy-MM-dd”);
Date data = new Date(); //data atual

System.out.println(sd.format(data));

Do mesmo jeito que dá pra converter um objeto Date pra uma String, o inverso também é válido: o SimpleDateFormat também converte uma String para um Date:

SimpleDateFormat sd = new SimpleDateFormat(“dd/MM/yyyy”);
String meuNiver = “13/04/1989”;

Date data = sd.parse(meuNiver);

Muito muito muito simples, útil e prático!

Comparando datas

Não sei se todo mundo sabe… mas uma data representada pelo objeto Date nada mais é do que um long, um número bem grande que guarda o número de milisegundos que já se passaram desde 1º de Janeiro de 1970, 00:00:00 GMT até o momento atual.

O objeto Date possui alguns métodos para comparar datas, são eles:

Date natal = new Date(110,11,25);        //25/12/2010
Date meuNiver = new Date(110,3,13);  //13/04/1989

if (natal.after(meuNiver) || meuNiver.before(natal)){
            System.out.println("Vou ficar mais velho antes do natal…");
}else if (natal.equals(meuNiver)){
            System.out.println("Vou ganhar 2 presentes no mesmo dia! ");
}

O código é totalmente auto-explicativo, exceto pelo construtor meio estranho do objeto Date. Seus parâmetros são: o ano – 1900 , o mês – 1, e o dia.

Os métodos “after(Date)”, “before(Date)” e “equals(Object)” nada mais fazem do que comparar aqueles números que eu comentei ali em cima. Quem não acreditar em mim é só ir no código fonte do método (no Netbeans: Ctrl + clique no método) e verificar que é exatamente isso que acontece:

public boolean after(Date when) {
    return getMillisOf(this) > getMillisOf(when);
}

Um probleminha que me ocorreu esses dias (e deu um trabalhinho) foi: como comparar datas sem envolver as horas, minutos, segundos e milisegundos?

Algumas vezes o horário pode atrapalhar a comparação das datas, uma vez que ela se baseia no número por trás da data. Só para ilustrar o problema segue um exemplinho:

Date inicioNatal = new Date(1293242400000L); //25/12/2010 00:00:00
Date fimNatal = new Date(1293328799999L);   //25/12/2010 23:59:59

if (inicioNatal.equals(fimNatal)){
    System.out.println("É natal!!");
}

No construtor dos Date foram passados os números que representam o primeiro e último segundo do natal. O “L” no final é apenas para indicar que aquele número é do tipo long.

Voltando ao problema, no código acima nunca será exibida a mensagem “É Natal!!” pois os números que representam as datas não são iguais.

A alternativa para solucionar esse problema que eu achei (confesso que parece uma gambiarra) foi a seguinte:

SimpleDateFormat sd = new SimpleDateFormat("dd/MM/yyyy");
Date inicioNatal = new Date(1293242400000L); //25/12/2010 00:00:00
Date fimNatal = new Date(1293328799999L);   //25/12/2010 23:59:59

inicioNatal = sd.parse(sd.format(inicioNatal));
fimNatal = sd.parse(sd.format(fimNatal));

if (inicioNatal.equals(fimNatal)){
    System.out.println("É natal!!");
}

As linhas em negrito são responsáveis por “zerar” as horas, minutos, segundos e milisegundos da data.
Como? Muito simples: como o objeto SimpleDateFormat foi criado com uma string de formatação que não contém horas, minutos ou outros, ele simplesmente ignora essas partes da data na hora de converter uma string para Date. Nós primeiro passamos de Date para string (somente dia/mes/ano) e passamos a string para Date em seguida (sem horas, minutos e etc).

Existem muito mais coisas quando se trata de manipulação de datas, mas como esse post não tem a finalidade de deixar ensinar TUDO de avançado sobre datas, ficamos por aqui.

[] e até a próxima,
Saab.

No último post eu mostrei uma técnica bem interessante da programação dinâmica: a reflexão, através da qual agente consegue perguntar pra um objeto qualquer quais são suas variáveis de instância (inclusive os seus valores) e seus métodos.

Beleza, daí um monte de gente me perguntou: “Pra que diabos eu preciso saber disso?” ou então “Quando eu vou usar?” entre outras… Para exemplificar o uso da reflexão vamos criar uma pequena aplicação. Nada muito complicado… uma agenda de contatos. OK, só mais um detalhe: não vou explicar nada sobre a conexão com o banco de dados, ou tratamento de erros ou outras coisas que vou utilizar no tutorial, o foco vai ser a reflexão. Qualquer dúvida é só deixar um comentário que a gente resolve.

Então vamos ao que interessa! Primeiro vamos criar uma tabela no banco de dados para representar um contato:

CREATE TABLE `contatos` (

`con_id` INT NOT NULL ,
`con_nome` VARCHAR( 60 ) NOT NULL ,
`con_endereco` VARCHAR( 100 ) NOT NULL ,
`con_email` VARCHAR( 50 ) NOT NULL ,
`con_telefone` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `con_id` )

) ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Pronto, com o banco pronto vamos para a aplicação. Crie uma nova aplicação no NetBeans (aplicação para área de trabalho, porque ela já importa o .jar do swing), apague tudo que ele crie a seguinte estrutura:

Vamos aplicar um pequeno padrão aqui, algo que lembra o MVC, que é utilizar uma estrutura de 3 camadas:

1. Apresentação: mostra os dados para o usuário;
2. Negócios: cuida das regras de negócio da aplicação (nada muito complexo nessa nossa agenda);
3. Persistência: cuida do armazenamento físico dos dados.

Não vou explicar muito a engenharia da coisa portanto vamos em frente. Vamos começar de baixo pra cima, ou seja, vamos ver primeiro a classe da camada de persistência:

public class ConexaoMySQL {

private Connection connect;
private String erro = “”;

public static ConexaoMySQL getConexao() throws Exception {
ConexaoMySQL c = new ConexaoMySQL();
Connection connect = null;
try {
Class.forName(“com.mysql.jdbc.Driver”);
String url = “jdbc:mysql://localhost/agenda”;
connect = DriverManager.getConnection(url, “root”, “123″);
c.setConnection(connect);
} catch (ClassNotFoundException cnfex) {
throw new Exception(“Falha ao ler o driver JDBC” + cnfex.toString());
} catch (SQLException sqlex) {
throw new Exception(“Impossível conectar com a base de dados” + sqlex.toString());
} catch (Exception ex) {
throw new Exception(“Outro erro” + ex.toString());
}
return c;
}

public void close() {
try {
this.connect.close();
} catch (Exception ex) {
System.out.println(ex.toString());
}
}

private void setErro(String erro) {
this.erro = erro;
}

private void setConnection(Connection connection) {
this.connect = connection;
}

public Connection getConnection() {
return this.connect;
}

public String getMensagemErro() {
return erro;
}

public boolean getEstadoConexao() {
if (connect == null) {
return false;
} else {
return true;
}
}

public boolean manipular(String sql) // inserir, alterar,excluir
{
try {
Statement statement = connect.createStatement();
int result = statement.executeUpdate(sql);
statement.close();
if (result >= 1) {
return true;
}
} catch (SQLException sqlex) {
erro = “Erro: ” + sqlex.toString();
return false;
}
return false;
}

public int getMaxPK(String tabela, String chave) {
String sql = “select max(” + chave + “) as max from ” + tabela;
int max = 0;
ResultSet rs = null;
try {
Statement statement = connect.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
System.out.println(sql);
rs = statement.executeQuery(sql);

if (rs.next()) {
max = rs.getInt(“max”);
}
statement.close();
} catch (SQLException sqlex) {
erro = “Erro: ” + sqlex.toString();
return -1;
}

return max;
}

//aqui que a mágica da reflexão acontece
public void Insere(String tabela, Object objeto) throws Exception {
SimpleDateFormat sd = new SimpleDateFormat(“yyyy-MM-dd”);
String sql = “INSERT INTO ” + tabela.toUpperCase() + “(“;

//percorre os atributos vendo o nome dos campos
Class<?> classe = objeto.getClass();
for (Field f : classe.getDeclaredFields()) {
f.setAccessible(true);
sql += f.getName() + “,”;
}

sql = sql.substring(0, sql.length() – 1); //retira a ultima virgula..
sql += “) VALUES(“;

//percorre os atributos vendo o valor dos campos
for (Field f : classe.getDeclaredFields()) {
f.setAccessible(true);
if (f.getType().getSimpleName().equals(“String”)) {
sql += “‘” + f.get(objeto) + “‘,”;
} else {
sql += f.get(objeto) + “,”;
}
}

sql = sql.substring(0, sql.length() – 1); //retira a ultima virgula..
sql += “)”;

//executa a query
System.out.println(sql);
if (!manipular(sql)) {
throw new Exception(getMensagemErro());
}
}
}

O único método que merece explicações é o método Insere(String tabela, Object objeto) que utiliza da reflexão computacional para criar dinâmicamente o SQL referente à inserção do objeto “objeto” na tabela “tabela”.

O código é bem simples de entender:

1. Inicializa a variável responsável por guardar o SQL;
2. Passa por todos os atributos do objeto adiciondo os nomes deles ao SQL;
3. Passa pelos atributos novamente, só que desta vez adicionando os valores dos atributos (caso seja uma variável da classe String, adiciona aspas simples antes e depois do valor).
4. Executa a query. Se algo deu errado, joga uma nova exceção com a mensagem de erro.

Muito simples não?!?!?
Vamos ver como funciona na prática então, vamos subir uma camada e ver como funciona a classe Contatos.java:

public class Contatos {

private int con_id;
private String con_nome;
private String con_endereco;
private String con_telefone;
private String con_email;

public Contatos(String con_nome, String con_endereco, String con_telefone, String con_email) throws Exception {
ConexaoMySQL c = ConexaoMySQL.getConexao();
this.con_id = c.getMaxPK(“contatos”, “con_id”) + 1;
c.close();
this.con_nome = con_nome;
this.con_endereco = con_endereco;
this.con_telefone = con_telefone;
this.con_email = con_email;
}

public void Insere() throws Exception{

if (this.con_nome.equals(“”) || this.con_telefone.equals(“”)){
throw new Exception(“Preencha pelo menos o nome e o telefone.”);
}

ConexaoMySQL c = ConexaoMySQL.getConexao();
c.Insere(“contatos”, this);
c.close();
}

//getters e setters
}

Uma classe extremamente simples que representa fielmente a tabela que criamos no banco de dados.

O construtor não exige o ID do contato, ao invés disso ele pega um novo para o contato (busca no banco o maior ID existente e soma 1).

O método Insere() não faz nada além de validar se pelo menos o nome e o telefone estão preenchidos e chamar o método Insere(..) da camada inferior passando uma String com o nome da tabela e passando ele mesmo (o objeto Contato) através da palavra reservada this. Caso ocorra algum erro na query, será retornada uma exceção do método Insere(…) da classe ConexaoMySQL.java para o método Insere() da classe Contato.java e este por sua vez irá retornar essa mesma exceção para quem o chamou.

Os nomes dos atributos devem ser iguais aos nomes das colunas da tabela, pois o método Insere(..) da classe ConexaoMySQL.java trata cada atributo como uma coluna da tabela para montar o SQL, como já vimos antes.

Agora vem a última (ou a primeira, depende do ponto de vista.. ) camada: a responsável pela apresentação. A classe Principal.java é um JFrame que vai fornecer a interface visual para o usuário. Deve ficar mais ou menos assim:

Os campos de texto são JTextFields com os respectivos nomes: jTF_Nome, jTF_Endereco, jTF_Telefone e jTF_Email.

Creio que eu nem precise comentar sobre o que o botão Limpar faz não é?

O código do botão Inserir segue abaixo:

public void Inserir() {
try {
Contatos c = new Contatos(jTF_Nome.getText(), jTF_Endereco.getText(), jTF_Telefone.getText(), jTF_Email.getText());
c.Insere();
JOptionPane.showMessageDialog(this, “Contato adicionado com sucesso”);
} catch (Exception e) {
JOptionPane.showMessageDialog(this, e.getMessage());
}
}

Cria-se um objeto Contato a partir dos dados do formulário e chama o método Insere(), caso ocorra algum erro, o programa desviará para o bloco catch(…) e será mostrado o erro, mas se der tudo certo, será mostrada a mensagem de sucesso.

DICA: Debuge o projeto para ver como o SQL é montado dinâmicamente. É bem interessante.

É isso! Repare como o código fica simples e fácil de ler.
Ao invés de ter uma classe só que cuida de mostrar os dados, validá-los, tratar a conexão com o banco e tratar o SQL (como eu mesmo já fiz e sei que muita gente faz), agora a gente tem uma estrutura muito bem projetada que facilita a manutenção e futuras mudanças, como por exemplo:

1. Se você quiser guardar o twitter do contato também, basta criar uma nova coluna no banco, um novo atributo na classe Contatos.java e um novo campo de texto na classe de apresentação. Não precisa se preocupar com SQL pois a reflexão cuida disso pra nós.
2. Se precisar mudar o banco para o SQL Server, basta trocar a classe ConexaoMySQL por uma ConexaoSQLServer. Não há necessidade de alteração na lógica nem na apresentação do projeto.

Minha intenção neste post era mostrar um exemplo somente sobre reflexão, mas eu acabei mostrando um pouco sobre o modelo de desenvolvimento em 3 camadas, algo realmente muito útil quando se trata do desenvolvimento de software.

Obrigado a você que teve paciência de ler até aqui.
Quem quiser o projeto do NetBeans, basta pegar aqui.
Qualquer dúvida é só deixar um comentário.

[] e até a próxima,
Saab.

PS: Só queria deixar uns créditos a outras pessoas:

Professor Silvio Carro (FIPP) que criou a base para a classe de conexão com o banco. A maior parte do código foi feito por ele.

Professor Emerson Silas Dória (FIPP) que mostrou esses conceitos de reflexão e camadas em aula, o que motivou a criação destes posts.

Quem se diz “programador” e nunca ouviu falar disso tem que rever seus conceitos. Existe toda uma filosofia por trás do conceito de Reflexão Computacional (ou apenas reflexão), mas eu não vou falar muito sobre isso (até porque eu não sei muita coisa sobre a teoria… ), vamos mais a prática.

Bom, vamos viajar um pouquinho: imagine que vc tem a missão de construir um método que receba um objeto que você não sabe qual é, e tenha que aprender a usá-lo em tempo de execução, ou seja, descobrir quais métodos esse objeto possui, quais variáveis de instância e etc (CALMA! Eu sei que parece besteira e que vc deve estar pensando: “Onde diabos eu vou usar um troço desses?!?” mas CALMA, vou dar uns exemplos mais adiante e em outros posts).

Como Java é uma linguagem quase completamente orientada a objetos, presume-se que TUDO é um objeto: um método é representado por um objeto da classe java.lang.reflect.Method, toda variável de instância também é representada um objeto da classe java.lang.reflect.Field e uma classe (qualquer uma delas, seja String, Integer, Float, ou aquela que vc escreveu) é representado por um objeto genérico: o objeto Class<?>.

Chega de historinha, vamos escrever alguma coisa para demonstrar tudo isso. Vamos criar uma classe com algumas variáveis e alguns métodos bem inúteis, só para exemplificar.

public class Contato {
private String nome;
private int idade;
private String email;

public Contato() {
}

public Contato(String nome, int idade, String email) {
this.nome = nome;
this.idade = idade;
this.email = email;
}

public void emString() {
System.out.println(nome + ” – ” + idade + ” – ” + email);
}

public int idadeEmDias() {
return idade * 365;
}

public void enviarEmail(String assunto, String mensagem) {
System.out.println(“Email”);
System.out.println(“Para: ” + email);
System.out.println(“Assunto: ” + assunto);
System.out.println(“Mensagem: ” + mensagem);
System.out.print(“Enviando…”);
System.out.println(“concluído”);
}
}

Como da pra ver… uma classe bem simples e que não faz absolutamente nada.
Vamos ao código de reflexão que depois eu explico ele:

public class Reflexao{

public Reflexao(){
Contato c = new Contato(“Felipe”, 20, “fesaab@gmail.com”);
infoClasse(c.getClass());
}

public void infoClasse(Class<?> classe){
//percorrendo as variáveis de instancia
for (Field f : classe.getDeclaredFields()){
System.out.println(f.getName());
}

//percorrendo os métodos
for (Method m : classe.getDeclaredMethods()){
System.out.print(m.getReturnType().getName()+” “);

System.out.print(m.getName()+” “);

Class<?> c[] = m.getParameterTypes();
if (c.length == 0){
System.out.println(“()”);
}else{
System.out.print(“(“);
for (Class<?> cl : c){
System.out.print(cl.getName()+”,”);
}
System.out.println(“)”);
}
}
}
}

Muito bem, logo no construtor da classe Reflexao foi criado o objeto “c” da classe Contato e logo em seguida foi invocado o método “infoClasse(Class<?>)” passando como parâmetro um objeto da classe “Class<?>” que for retornado pelo método “getClass()” que QUALQUER objeto tem.

No método infoClasse(..), a primeira instução for percorre todas as variáveis de instância da classe passada no parâmetro.
A segunda instrução for percorre todos os métodos da classe. Eu dei uma “enfeitada” nesse segundo for, mais foi só para demonstrar alguns métodos da classe Method. A execução do código gera a seguinte saída:

nome
idade
email
void emString ()
int idadeEmDias ()
void enviarEmail (java.lang.String,java.lang.String,)

Repare que apenas foram exibidas informações da CLASSE, nada do objeto foi revelado. Para tal propósito, devemos explorar alguns outros métodos, vamos ao código:

public void infoObjeto(Object o) throws Exception{
Class<?> classe = o.getClass();

for (Field f :classe.getDeclaredFields()){
f.setAccessible(true);
System.out.println(f.getName()+”: “+f.get(o));
}
}

Para descobrir o conteúdo das variável de instância, deve-se:

1. Recuperar o objeto Field da respectiva variável
2. Se a variável não possuir visibilidade pública (como é o caso das nossas, são privadas), deve-se liberar o acesso para seu conteúdo através do método setAccessible(true).
3. Recuperar o conteúdo da variável através do método get(Object) da classe Field. Lembrando que o método pertence ao objeto da classe Field, esse objeto não sabe o valor da variável de instância que agente quer, mas ele sabe como recuperar esse valor porque esse objeto representa a variável. Portanto agente simplesmente fala assim: “ô objeto da classe Field, recupera o valor da variável que você representa. A variável que eu quero está nesse objeto aqui”. Por isso agente passa o objeto como parâmetro para o método.

A execução do método infoObjeto(…) gera a seguinte saída:

nome: Felipe
idade: 20
email: fesaab@gmail.com

Antes de finalizar essa pequena introdução, só mais uma coisa: eu mostrei como recuperar os objetos Field e Method que representam as variáveis de instância e os métodos de um objeto de uma classe qualquer, mostrei também como recuperar o conteúdo de qualquer variável de instância, só falta ver como agente executa um método.

É extramente simples… uma vez que agente já sabe como recuperar os objetos Method que representam os métodos, basta chamar o método invoke(Object, Object[]).
O primeiro parâmetro é o objeto que agente quer que execute o método, e o segundo é um vetor que contém os parâmetros que o método exige. Vamos a um exemplo:

public void executaMetodos(Object o) throws Exception {
Class<?> classe = o.getClass();

for (Method m : classe.getDeclaredMethods()) {
if (m.getParameterTypes().length == 0) {
System.out.println(“Invocando o método: ” + m.getName());
if (m.getReturnType().getName().equals(“void”)) {
m.invoke(o, new Object[0]);
} else {
System.out.println(m.invoke(o, new Object[0]));
}
}
}
}

Só para simplificar eu restringi a invocar apenas os métodos que não tem parâmetro nenhum para passar, se tivesse, bastava descobrir através do método “getParameterTypes()” da classe Method e criar o array de Object com os parametros corretos.

No código eu também separei a chamada de métodos que não tem retorno dos que tem utilizando o método “getReturnType()”, quando tiver retorno eu simplesmente imprimo ele na tela. O resultado da execução do código é o seguinte:

Invocando o método: emString
Felipe – 20 – fesaab@gmail.com
Invocando o método: idadeEmDias
7300

Bom galera, essa foi uma pequena introdução sobre reflexão computacional. Espero que ajude um pouco quem estava procurando sobre o assunto.
Nos próximos posts eu vou utilizar esse conceito numa abordagem bem mais próxima da realidade (onde usar isso).

[] e até a próxima,
Saab.

São componentos visuais que facilitam imensamente o usuário selecionar uma data. Segue uma pequena imagem dos componentes:

O JCalendar é como o calendário do Windows, já o JDateChooser é como um combobox, que abre um mini-calendário quando o usuário clica no ícone do lado direito e o fecha quando o usuário clica na data desejada.

Site do projeto – http://www.toedter.com/en/jcalendar/

Para instalar esses componentes é necessário fazer o download no site do projeto e procurar dentro da pasta /lib o .jar desejado, mas como eu sou mto bonzinho, eu coloquei no meu 4shared o único arquivo necessário. Para baixar clique aqui.

Antes de configurar, vale lembrar que o Netbeans vai fazer apenas uma referência ao arquivo, ou seja, ele vai usar o que está dentro do arquivo, então se deixar ele na área de trabalho, ou no diretório dos seus downloads, não vai ter como mudar de lugar depois, então vale a pena guardar em um local seguro (tipo: …/Java/jdk/lib).

Com o Netbeans aberto (estou usando o 6.7.1), clique em “Ferramentas > Paleta > Componentes Swing/AWT”. Voce deverá chegar na seguinte tela:

Clique em “Nova Categoria” e de o nome desejado, algo como Calendário ou Data, sei lá… Se não quiser não precisa, só acho mais organizado deixar separado.

Com a nova categoria criada (ou não), clique em “Adicionar do JAR…” e navegue até o .jar que você acabou de baixar.

Selecione todos os componentes e clique em “Próximo”.

Na última tela basta selecionar a pasta que vai conter os novos componentes e clicar em “Finalizar”.

Prontinho, agora você já tem a sua disposição o JCalendar, o JDateChooser e mais alguns componentes. Para usar é só clicar e arrastar pra tela.

Duas coisas que valem ser lembradas:

1. A propriedade dateFormatString é responsável pela formatação da string exibida no componente. Ex:
   ”dd/MM/yyyy” –> 19/01/2010
   ”MM/dd/yyyy” –> 01/19/2010
2. Todos os componentes possuem o método getDate que retorna a data selecionada em um objeto java.util.Date

É isso ai galera.
Qualquer dúvida é só comentar…

Até a próxima,
Saab.

Nos relatórios mais simples (clientes, estoque, fornecedores…) foi só alegria! Mas chegou uma hora em que eu precisei fazer um relatório agrupado: Pedidos X Produtos. Começei a pesquisar como fazer um relatório com duas querys e/ou coisas relacionas até que eu descobri sobre o Subreport.

O componente Subreport do iReport permite incluir um relatório já existente (outro arquivo .jasper) dentro do relatório que eu estou editando.

Maravilha! Era só fazer um relatório para mostrar somente os produtos daquele pedido e depois chamá-lo dentro do relatório principal que continha os detalhes do pedido. Para isso eu ainda tive que apanhar mais um pouco e aprender como passar parâmetros de um relatório para outro, mas nesse ponto eu já tinha pesquisado bastante e isso não foi um grande empecilho.

Cheguei então ao resultado final: o relatório principal continha os dados do pedido e um subrelatório que mostrava todos os produtos que faziam parte do respectivo pedido, mas na hora de visualizar o relatório, adivinhe…. PAU!!! Não visualizava de jeito nenhum, e o único erro apresentado era:

Mas vamos ao que interessa: às vezes pode ser bem interessante abrir um menu popup ao clicar em um botão da sua aplicação, como por exemplo em uma tela de cadastro de contas a pagar. A conta a pagar pode estar vinculada a um fornecedor, a um equipamento, a um veículo ou seja lá o que for que você o cliente queira.

Uma boa prática que eu gosto de usar é sempre deixar o usuário poder fazer uma busquinha rápida pelo fornecedor (equipamento, veículo, …) ao invés de ter que digitar o código dele lá.

Sendo assim, ao invés de fazer um botão para a busca de fornecedores, outro botão pra busca disso e outro pra busca daquilo, eu faço apenas um botão que quando clicado abre um menu com todas as opções e frescuras que eu quiser.

Muito mais simples neh… então mãos a obra: crie um novo projeto na sua IDE, adicione um JFrame e coloque um JTextField e um JButton nele (um iconezinho sempre eh legal neh… iauhiauaihu), fica +/- assim:

 

Quando o usuário clicar no botão agente cria o JPopupMenu e os JMenuItems dinamicamente, portanto podemos escrever o código tanto no evento de ActionPerformed quanto em algum de mouse. Eu vou escrever no MouseClicked:

private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {
       
        //cria o primeiro item do menu e atribui uma ação pra ele
        JMenuItem item1 = new JMenuItem(“Opção 1″);
        item1.addActionListener(new ActionListener() {

        //mostra na tela
        popup.show(jB_Busca, 10, 10);
    }

O código é totalmente auto-explicativo nao eh… ainda mais com alguns comentarios… hehe
Talvez a única parte diferente seja mostrar o menu: o método show(…) da classe JPopupMenu é o responsável por jogar o menu por cima dos outros componentes, e pra isso, ele precisa saber em cima de quem ele vai aparecer… então é só passar para ele uma referencia do nosso botão. Os outros dois parâmetros são as coordenadas X,Y que o menu vai ser desenhado, sendo que a coordenada 0,0 é a mesma coordenada 0,0 do botão. Só pra dar um efeito mais bonitinho, eu desloquei 10 em X e 10 em Y:

Bem simples não?…
Dúvidas é só postar, twittar…

Para quem quiser o código fonte desse exemplo, é só pegar o Projeto do NetBeans.

[]s, e até a próxima.

Vamos imaginar que devemos representar uma matriz dentro de uma JTable, ou seja, devemos ter um cabeçalho para as linhas e outro para as colunas.
Nosso objetivo vai ser construir a seguinte matriz:

Vamos começar definindo as colunas dessa tabela:

String colunas[] = {“”,”A”,”B”,”C”};

Como a primeira coluna da tabela vai servir para representar o cabeçalho das linhas, então a primeira coluna fica sem nome.

Agora vamos definir a matriz de dados, lembrando que a primeira coluna será o cabeçalho ainda:

String dados[][] = {{“A”,”0″,”1″,”0″},{“B”,”1″,”0″,”1″},{“C”,”0″,”1″,”0″}};

Agora que temos todos os dados necessários, vamos completar a tabela:

jTable.setModel(new DefaultTableModel(dados,colunas));

Obs: estou supondo que a tabela já foi instanciada e que seu nome seja “jTable”.
Pronto, agora a tabela está criada, porém ela não parece uma matriz ainda:

Um pouco de teoria: o Java utiliza uma classe chamada TableCellRenderer para definir as propriedades de cada célula (cor de fundo, fonte, alinhamento, entre outras). Essa classe mostra a tabela como nós estamos acostumados a ver, porém se nós quisermos personalizar as células, nós devemos criar a nossa própria classe TableCellRenderer, para tal, devemos criar uma classe que herda de DefaultTableCellRenderer.

Como nossa finalidade é muito simples (apenas mudar a cor e o alinhamento), vamos criar o nosso objeto em tempo de execução mesmo:

DefaultTableCellRenderer letras =
new DefaultTableCellRenderer() {

public void setValue(Object value) {
setBackground(new Color(238, 238, 238));
setForeground(Color.BLACK);
setHorizontalAlignment(JLabel.CENTER);
//outras alterações entram aqui…
super.setValue(value);
}
};

Acabamos de criar o objeto letras, que é do tipo DefaultTableCellRender e reescrevemos o método setValue(Object value).

É dentro desse método que a mágica acontece: como estamos criando um objeto que define as propriedades de uma célula, basta alterá-las e consequentemente alterar a(s) célula(s).

Já com o nosso próprio objeto DefaultTableCellRender criado, basta atribuí-lo à célula desejada. No nosso caso, como queremos modificar todas as células de uma mesma coluna, vamos setar o nosso DefaultTableCellRender para todas as células de uma coluna:

TableColumn tc = jTable.getColumn(“”);
tc.setCellRenderer(letras);

TableColumn é a classe que controla todas as células da coluna, portanto se setarmos o nosso próprio DefaultTableCellRender como CellRenderer dela, todas as células daquela coluna vão ser personalizadas.
Para recuperar uma TableColumn usa-se o método getColumn(Object id) da JTable, onde id é o que está escrito no cabeçalho da coluna. Como definimos anteriormente que a primeira coluna seria “” , recuperamos ela do mesmo jeito.

Até aqui agente tem a seguinte tabela:

Já está bem mais parecida com uma matriz, mas só para dar uma melhorada no visual, vamos centralizar as colunas dos dados também. Para isso precisamos definir um outro DefaultTableCellRender que só centralize o texto nas células:

DefaultTableCellRenderer numeros =
new DefaultTableCellRenderer() {

public void setValue(Object value) {
setHorizontalAlignment(JLabel.CENTER);
super.setValue(value);
}
};

jTable.getColumn(“A”).setCellRenderer(numeros);
jTable.getColumn(“B”).setCellRenderer(numeros);
jTable.getColumn(“C”).setCellRenderer(numeros);

Pronto! Agora ficou igual uma matriz mesmo:


Obs: aqui eu fiz a tabela inteira estática só para facilitar o exemplo, mas nada impede que você personalize uma tabela com dados vindos de outra fonte (entrada, banco de dados…), a idéia é sempre a mesma.

É isso ai pessoal…
Qualquer duvida, dica ou seja lá o que for, posta um comentário ae… ^^

Até a próxima…

Eu sempre tive muita vontade de aprender a desenvolver aplicativos que utilizassem o bluetooth do celular através de J2ME, então eu começei a pesquisar. Porém, meus esforços foram inúteis… nunca achava um bom material, quando achava alguma coisa não tinha nenhum código fonte como exemplo… sempre uma m*#!@.
Até que um dia eu descobri o Project Marge, que tem como objetivo simplificar o uso do bluetooth em J2ME.
Ótima iniciativa, muito boa mesmo… alguém tinha que começar isso um dia não é mesmo? hehehe

A partir daí eu começei a fuçar alguns códigos que utilizam o framework “marge-core”(Framework resultante do projeto) e me impressionei com a facilidade de uso. Qualquer um que entenda um mínimo de J2ME e o básico de Java consegue facilmente acessar o bluetooth…

Enquanto eu aprendia eu ia desenvolvendo um joguinho pong, apenas alterando as classes de um exemplo disponível na época (um chat bluetooth), tal exemplo se encontra hoje no site do projeto, junto com muitos outros.

Quem se interessar e quiser dar uma olhadinha mais afundo: site do projeto.

O pong que eu fiz.. =]

PS: tem erros e redundâncias no código… vale frizar que meu objetivo era a comunicação bluetooth e não o design.

Se alguem quiser saber mais, é só deixar um comentário ou entrar em contato.
[] a todos e até a próxima.