Descrição
O objetivo dessa
atividade é desenvolver um JavaBean gráfico, ou seja, um componente baseado
na tecnologia Java SE. Esse componente será um painel gráfico que permitirá a
visualização do calendário de um mês. O componente de calendário mostrará os
dias organizados em 7 colunas (uma para cada dia da semana) e 7 linhas (uma
linha para os dias da semana e as demais para cada semana do mês). Quando o
usuário clicar em um dia, deve ser gerado um evento informando a data
selecionada.
O componente que
será desenvolvido pode ser utilizado em qualquer aplicação que necessite
selecionar datas - por exemplo, na
aplicação desenvolvida na Atividade 1,
para registrar a data de início e fim de uma atividade.
A API do Java fornece
as classes Calendar e Date para manipulação de datas. Para facilitar essa
tarefa, pode ser utilizada a API Joda
Time.
JavaBeans
O
termo JavaBeans se refere ao modelo de componentes da linguagem Java, no
qual os componentes apresentam como suas principais características a
reusabilidade de software e a possibilidade de serem manipulados por
ferramentas de edição visual (Englander R., 2001). Os componentes
JavaBeans são classes Java que seguem uma convenção de nomeação de atributos
e métodos, que permite definir propriedades e eventos.
Alguns
exemplos de JavaBeans que foram utilizados na atividade 1 são: botões,
campos de texto, caixas de seleção, entre outros. A especificação do modelo
de componentes JavaBeans pode ser consultada aqui.
Utilizando JavaBeans no NetBeans
Novos
componentes gráficos podem ser inseridos na Paleta do NetBeans clicando na mesma
com o botão da direita do mouse e selecionando ‘Gerenciador de Paleta’. Na
janela abaixo, clique o botão 'Adicionar do JAR' e selecione o arquivo JAR
com o componente. Em seguida, escolha o componente a instalar e a categoria
da Paleta na qual ele será exibido. Componentes também podem ser inseridos a
partir de bibliotecas e projetos.
Para
testar esta funcionalidade, instale os componentes CalendarPane
(abaixo, à esquerda) e DatePicker (à dir.) contidos neste arquivo JAR. Coloque os componentes
na categoria Beans da Paleta.
 
Existem
várias empresas que produzem componentes que, assim como os componentes
mostrados acima, podem ser reutilizados em aplicações Java. Aqui há uma lista de algumas destas
empresas, com uma descrição dos componentes fornecidos por elas (alguns
destes componentes exigem pagamento de licença para utilização).
Implementação do Componente Gráfico
Para
iniciar a construção do componente, primeiro crie um novo projeto no NetBeans
do tipo ‘Aplicativo Java’. Em seguida, clique no menu ‘Arquivo à Novo Arquivo’ e
crie um 'Objeto JavaBean' do tipo ‘Personalizador’.
O
painel criado pode ser editado graficamente, adicionando a ele componentes
gráficos.
Definição de Propriedades e Métodos do Componente
Você
deve definir as propriedades e os métodos do componente que serão necessárias
para implementar a funcionalidade do calendário. Defina propriedades que
permitam que o usuário customize o visual e o comportamento do componente,
para que ele possa ser usado em diversas aplicações. Exemplos de propriedades
que podem ser criadas são: data atual, cor e fonte do texto, cor de fundo, etc.
Propriedades
podem ser geradas clicando com o botão da direita do mouse em qualquer ponto
do código-fonte da classe do componente, selecionando ‘Inserir Código’ e em
seguida clicando em ‘Adicionar propriedade’:
 
Na
janela ‘Adicionar propriedade’, especifique o nome, valor inicial e o tipo da
propriedade, e os métodos de acesso que devem ser gerados.
Em
alguns casos pode ser necessário adicionar código aos métodos de acesso gerados
automaticamente, para que seja executado o comportamento adequado. Se
preferir, você pode criar a propriedade manualmente, adicionando ao
código-fonte a declaração do atributo e os métodos de acesso, respeitando as
convenções de nomeação.
Caso
julgue adequado, implemente outros métodos que possam ser necessários para
interação com o componente.
Tratamento de Eventos
Os
eventos gerados pelo bean devem ser tratados, para que ele apresente o
comportamento adequado. Ao selecionar uma data ou mudar o mês e o ano, atualize
o estado e as características visuais do componente. Isso deve ser feito
alterando o valor de propriedades e/ou efetuando chamadas a métodos que
ativem esse comportamento.
Quando
ocorrer uma alteração de data, essa alteração deve ser indicada difundindo um
evento. Para isso, devem ser definidas a interface que será implementada
pelos listeners do evento e a classe
que representa o evento.
import java.util.EventListener;
public interface DateEventListener
extends EventListener {
public void dateChanged(DateEvent
evt);
}
import java.util.EventObject;
import java.util.Date;
public class DateEvent extends EventObject {
private Date date;
public DateEvent(Object
source, Date date) {
super(source);
this.date = date;
}
public Date getDate() {
return this.date;
}
}
Os métodos para adicionar
e remover listeners de uma lista de
tratadores do evento e para disparar o evento são mostrados abaixo.
// Lista na qual são
armazenados os Listeners do evento DateEvent
protected javax.swing.event.EventListenerList dateListenerList =
new
javax.swing.event.EventListenerList();
// Método que registra os Listeners
para DateEvent
public void addDateEventListener(DateEventListener listener) {
dateListenerList.add(DateEventListener.class,
listener);
}
// Método que remove
Listeners de DateEvents
public void removeDateEventListener(DateEventListener listener) {
dateListenerList.remove(DateEventListener.class,
listener);
}
// Método que dispara
DateEvent; deve ser chamado quando a data for alterada
void fireDateEvent(Date date) {
Object[] list = dateListenerList.getListenerList();
// Cada listener ocupa 2
posições da lista: nome da classe e a instância
for (int i = 0; i < list.length;
i += 2) {
if (list[i] == DateEventListener.class)
{
((DateEventListener)list[i+1]).dateChanged(new
DateEvent(this,date));
}
}
}
Descritor do Componente
Depois de
criado o componente, crie também uma classe do tipo BeanInfo, que fornecerá
informações sobre o componente. A classe BeanInfo pode ser criada através do
menu ‘Arquivo à Novo Arquivo’, na
categoria ‘Objetos JavaBeans’, e deve ser dado a ela um nome igual ao nome do
componente, acrescido de ‘BeanInfo’. Crie um construtor para o BeanInfo e
defina os valores dos seguintes atributos, que serão úteis para que o
componente seja exibido adequadamente no NetBeans:
·
iconNameC16:
arquivo com um ícone de 16x16 pixels colorido que represente o
componente;
·
iconNameC32:
arquivo com um ícone de 32x32 pixels colorido que represente o
componente;
·
iconNameM16:
arquivo com um ícone de 16x16 pixels monocromático que represente o
componente;
·
iconNameM32:
arquivo com um ícone de 32x32 pixels monocromático que represente o
componente;
·
beanDescriptor:
objeto da classe BeanDescriptor que contém o nome e uma descrição do componente.
Edite também o arquivo ‘manifest.mf’,
localizado na pasta raiz do projeto, que pode ser acessado na janela
‘Arquivos’.
Especifique
o nome completo da classe e indique que se trata de um JavaBean.
Manifest-Version: 1.0
Name: /pacote/NomeDaClasse.class
Java-Bean: True
Por
fim, compile o projeto para que seja criado o arquivo de distribuição (JAR)
do componente.
Testando o Componente
Durante seu desenvolvimento, o componente pode ser
testado individualmente, criando um método main() para teste.
public static void main(String[] args) {
javax.swing.JFrame frame = new
javax.swing.JFrame(); // Cria frame
SimpleCalendarBean bean = new CalendarBean();
// Instancia o bean
// Alterar as propriedades que julgar
necessárias aqui!
frame.add(bean); // Adiciona bean ao frame
frame.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
frame.setVisible(true); // Exibe o frame
}
Após
concluídos os testes, adicione o bean
na paleta de componentes do NetBeans, abrindo o ‘Gerenciador de Paleta’ -
clique na paleta com o botão da direita do mouse e escolha a opção
‘Gerenciador de Paleta’. Em seguida, clique no botão ‘Adicionar JAR’,
selecione o arquivo JAR do bean
(contido na pasta ‘dist’ do projeto) e o adicione à categoria ‘Beans’.
Para
finalizar a atividade, teste o componente na aplicação gráfica desenvolvida na
Atividade 1. Insira o componente na aplicação, configure as propriedades do
componente e efetue as alterações no código que forem necessárias. Por fim,
execute a aplicação para testar o seu funcionamento.
Avaliação
A atividade deve ser desenvolvida em
duplas. A apresentação deve ser feita até o dia 28/04. Os dois
integrantes do grupo devem estar presentes no momento da apresentação. Será
verificado o funcionamento do programa e em seguida os alunos devem responder
oralmente a questões formuladas pelo professor sobre o código fonte do
programa. Podem ser atribuídas notas diferentes aos integrantes de um grupo,
dependendo das respostas às perguntas sobre o código do programa efetuadas
pelo professor. Caso um dos alunos não esteja presente ou demonstre não
conhecer o código do programa, este ficará com nota zero na atividade. Em
caso de cópia do código de outro grupo, ambos terão nota igual a zero.
Referências
Dúvidas
Material
para Consulta
·
Help e
página do NetBeans.
·
Documentação
da API do Java.
Atendimento
aos Alunos
- Horário: Terças-feiras das 16:20
às 18:00.
- Local: Prédio do INE - Sala 407.
E-Mail
f r a n k @ i n f . u f s c . b
r
l a u . l u n g @ i n f . u f s
c . b r
Mantida por Frank
Siqueira , com a colaboração de Bruno
Ghisi. Atualizada em 10/04/2010.
|