Descrição
Nesta
tarefa você irá criar uma aplicação gráfica em Java, utilizando componentes
de software, para cadastramento de participantes de uma promoção realizada
por um shopping center.
Componentes
Gráficos
O Java
oferece dois pacotes para criação de interfaces gráficas: AWT e Swing. O AWT
acompanha o Java desde as primeiras versões, e o Swing trata-se de um pacote mais
completo introduzido posteriormente. Estes pacotes oferecem contêineres
(janelas, painéis e frames) nos quais podem ser inseridos componentes
gráficos (botões, caixas de texto, etc.).
A figura
abaixo (do livro Java
Foundation Classes in a Nutshell, de David Flanagan, Ed. O´Reilly)
mostra as principais classes do pacote javax.swing.
Os
contêineres trabalham com o conceito de layout, que define como os
componentes são dispostos dentro do contêiner. Os principais layouts
definidos pelo Java são os seguintes:
·
Layot
de Fluxo (Flow): os componentes são dispostos em seqüência no contêiner, da
esquerda para a direita.
·
Layout
de Borda (Border): os componentes podem ser colocados em 5 regiões - norte,
sul, leste, oeste e centro.
·
Layout
de Grade (Grid): cria uma "grade" de X linhas por Y colunas, com
X*Y células nas quais os componentes são colocados.
·
Layout
de Caixa (Box): empilha os componentes na horizontal ou na vertical.
·
Null
Layout: sem um layout específico.
  
 
É possível
colocar dentro de um contêiner outros contêineres com layouts
diferentes. No exemplo abaixo foram criados três painéis (componente JPanel):
o primeiro segue o layout Box, o central usa o layout Border e
o último é um Grid 2x2.
Além dos layouts
padrão, outros tipos de layout podem ser utilizados. O layout Desenho
Livre (usado como layout default pelo NetBeans - o ambiente de
desenvolvimento que iremos utilizar) dispõe os componentes na posição exata
na qual eles são colocados no contêiner.
Usando Componentes
Gráficos no NetBeans
O NetBeans
é um poderoso ambiente para desenvolvimento de aplicativos, com suporte a
desenvolvimento de aplicações em várias linguagens e plataformas, incluindo
Java em suas três edições: Micro Edition, Standard Edition e Enterprise
Edition.
Através do
NetBeans é possível desenvolver aplicações gráficas em Java utilizando
componentes Swing e AWT, assim como aplicações que utilizem outros
componentes desenvolvidos por terceiros.
O NetBeans
trabalha com o conceito de projetos de software. Um novo projeto é criado no
NetBeans através do menu Arquivoà Novo Projeto. No assistente 'Novo Projeto' pode-se
selecionar um entre os diversos tipos de projetos disponíveis. Por exemplo, o
tipo de projeto 'Aplicação de área de trabalho Java' da Categoria 'Java'
corresponde a uma aplicação gráfica do Java Standard Edition. Em
seguida é possível definir o nome do projeto e o diretório no qual o projeto
será criado, além de outras opções.
O projeto
criado será exibido na janela ‘Projetos’.
O projeto
criado possui uma classe que representa uma interface gráfica, na qual podem ser
adicionados componentes contidos na paleta de componentes do NetBeans,
conforme mostra a figura abaixo. Ao editar uma interface gráfica, será
exibida a tela de edição ‘Projeto’ - o retângulo cinza à esquerda na figura
abaixo, que representa a área de trabalho da janela que está sendo editada -
na qual é possível inserir os componentes disponíveis na janela 'Paleta'.
Para isso basta selecionar o componente a ser inserido e depois clicar no
local onde se deseja inseri-lo.
Para
visualizar a interface gráfica na forma como esta será exibida na tela, basta
pressionar o botão  .
Também é
possível inserir no projeto diversos tipos de classes Java através do menu
Arquivo à Novo Arquivo.
Selecionando a categoria ‘Formulários GUI Swing’, pode-se criar quadros
(Formulário JFrame), painéis (Formulário JPanel) e janelas de diálogo
(Formulário JDialog), por exemplo. Esses elementos corresponderão a uma nova
classe Java da aplicação, e servirão como contêineres para outros componentes
gráficos.
A forma
como o componente se ajusta à tela depende do layout utilizado. O layout
default usado pelo NetBeans é o ‘Desenho Livre’, que mantém a posição
original na qual o componente foi inserido. O layout utilizado pode ser
alterado clicando o com o botão da direita do mouse sobre o contêiner na
janela 'Inspetor'.
Na janela
'Propriedades' é possível definir as propriedades dos componentes. Por exemplo,
após adicionar um item de menu (JMenuItem) a um dos menus da barra de menus
da interface gráfica, ao selecioná-lo, é possível editar o texto mostrado no
item de menu alterando a propriedade 'text' na janela de propriedades do
NetBeans.
Cada
componente possui um conjunto diferente de propriedades. As propriedades
podem ser acessadas também no código da aplicação, através dos métodos setPropriedade
e getPropriedade (por exemplo, setText(String s) e getText()
para a propriedade text do item de menu).
Note que,
à medida que você for editando a interface gráfica, o código correspondente a
essas alterações será gerado no arquivo Java. Clique no botão 'Código-Fonte' na
tela de edição pra visualizar o código da classe, e em seguida expanda
(clicando no sinal '+') a linha marcada como 'Generated Code' para exibir o
código gerado pelo NetBeans. O NetBeans protege este código, marcado em azul,
impedindo sua edição. Note que os componentes adicionados à interface gráfica
são criados automaticamente como atributos da classe que representa a
interface gráfica da aplicação.
Novos
componentes gráficos podem ser inseridos na Paleta do NetBeans através do
menu Ferramentas à Paleta à Componentes
Swing/AWT. 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. Após serem inseridos na
paleta, esses componentes podem ser utilizados em uma aplicação gráfica, da
mesma forma que os componentes padrão do Swing.
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).
Tarefa
1: A Interface Gráfica da Aplicação
Comece a
implementar a interface gráfica do aplicativo de cadastramento de
participantes na promoção do shopping utilizando o NetBeans. Não se preocupe
por enquanto em implementar a funcionalidade da aplicação.
Crie um
novo projeto do tipo ‘Aplicativo de área de trabalho Java’. Na seqüência,
edite os componentes da janela principal da aplicação. Caso necessário,
adicione novos frames e janelas de diálogo ao projeto. Teste a disposição dos
componentes dentro da janela, para que seu aplicativo se comporte de maneira
adequada quando for redimensionado ou maximizado. Durante este processo, pode
ser necessário modificar os layouts e a disposição dos componentes até
atingir um resultado satisfatório.
Insira na
interface da aplicação os componentes necessários para executar as seguintes
funcionalidades:
·
Cadastramento
de participantes: registrar os dados pessoais do participante, como nome,
CPF, RG, data de nascimento, endereço, telefone e e-mail.
·
Cadastramento
de notas fiscais: deve permitir o registro das notas fiscais de compras
efetuadas pelo participante nas lojas do shopping durante o período da
promoção, selecionando o nome do estabelecimento em uma lista e informando a
data e o valor da compra.
·
Emissão
de cupons para o sorteio: deve ser gerado um cupom para cada R$100 em notas
fiscais apresentadas pelo participante.
Use a
janela de propriedades dos componentes para modificar as propriedades que
julgar necessárias, como por exemplo o texto, o tipo de fonte, a cor, ou
ícone dos botões.
Tente
compilar e rodar a interface gráfica da aplicação (Shift+F6). A lógica de
funcionamento será implementada em um segundo momento.
Eventos
O Java
permite que eventos gerados pelo usuário sejam tratados pelos programas
utilizando tratadores de eventos. Eventos produzidos pelo mouse e pelo
teclado - das classes MouseEvent e KeyEvent respectivamente - podem ser
tratados criando objetos que implementem as interfaces MouseListener e KeyListener. A API do Java define
classes auxiliares para implementação dos tratadores de eventos, chamadas MouseAdapter e KeyAdapter, que são classes abstratas
(com implementações vazias para os métodos da interface correspondente)
usadas como superclasses para tratadores de eventos do mouse e do teclado
respectivamente.
Suponha
que queremos tratar os eventos gerados pelo mouse. Um consumidor do evento MouseEvent
gerado pelo componente meuComponente (um botão, por exemplo) deve se
registrar para receber os eventos com o método addMouseListener, e
criar um objeto do tipo MouseAdapter. Isto pode ser feito criando uma
classe anônima, na qual deve ser definido o código para tratar o evento
correspondente. No exemplo abaixo foi definido o código do método mouseClicked,
que é chamado toda vez que o componente é clicado com o mouse:
meuComponente.addMouseListener(new java.awt.event.MouseAdapter() { public void mouseClicked(java.awt.event.MouseEvent evt) { // trata o evento de click do mouse } } );
Outra
forma de fazê-lo seria criar uma classe que implemente a interface MouseListener,
definir seus métodos e chamar addMouseListener passando um objeto
desta classe como parâmetro.
Outros
tipos de eventos também possuem suas classes Listener, Adapter
e Event, que são utilizadas de maneira semelhante.
Tratamento de Eventos no
NetBeans
A partir
da janela de edição do NetBeans é possível criar tratadores de eventos
gerados por componentes. Isso pode ser feito de duas formas: usando o modo de
conexão ou definindo os tratadores de eventos.
Para
ativar o ‘Modo de conexão’, clique o botão  na janela de
edição da interface gráfica. Em seguida, você deve selecionar o componente de
origem e o componente de destino da ação. No exemplo abaixo, selecionamos na janela
de projeto da interface gráfica o item de menu ‘File -> New’ da aplicação,
e logo depois a área de texto da aplicação.
No
‘Assistente de conexão’, que será aberto automaticamente, selecione o evento
de origem – no caso, o evento ‘actionPerformed’, que inclui a ativação do
menu pelo mouse ou pelo teclado.
Logo
depois, selecione a operação a ser executada quando o evento ocorrer – nesse
caso, limpar a área de texto, selecionando a propriedade ‘text’ e alterando
seu valor para um texto vazio.
Ao
finalizar o assistente, o seguinte método tratador de eventos será gerado:
Outra
forma possível de tratar eventos é associar um tratador de evento a um
componente. Ao clicarmos um componente o botão da direita do mouse, é
possível criar um tratador para um evento gerado pelo componente.
Feito
isso, pode-se editar o código que será executado quando o evento selecionado
ocorrer. A edição de código é facilitada pelo recurso auto-completar do
NetBeans, ativado teclando Ctrl+Espaço. Assim é possível ter acesso aos
atributos e método da classe que está sendo editada. Lembre-se que os
componentes adicionados à interface gráfica são atributos da classe, e seus
métodos e atributos também podem ser visualizados utilizando o recurso
auto-completar.
Tarefa 2: A Lógica de
Funcionamento na Aplicação
Você deve
criar tratadores para os eventos da interface gráfica do aplicativo de
cadastramento de participantes na promoção do shopping center. Estes
tratadores de eventos devem chamar os métodos de uma classe de controle, que
implementarão a lógica de funcionamento da aplicação. Essa classe, por
sua vez, deve interagir com as entidades utilizadas pela aplicação –
participantes, notas fiscais e cupons para sorteio. As classes de entidade
serão também JavaBeans, com propriedades acessadas através de métodos de
acesso.
Com isso,
será possível separar o código da aplicação segundo o padrão de projeto MVC,
ou seja:
·
classes
para interfaceamento gráfico - a visão (desenvolvidas na Tarefa 1);
·
classes
para representar o modelo, com os dados internos da aplicação e os
métodos para manipulá-los;
·
uma
classe controladora, responsável pelo fluxo de execução da aplicação.
O uso do
padrão MVC torna mais fácil a manutenção do código e a sua reutilização.
Os dados
dos participantes, das notas fiscais e dos cupons emitidos devem ficar
armazenados em memória. Para efetuar uma segunda troca, o participante deverá
fornecer apenas o seu CPF para localização do seu cadastro. O valor não
utilizado pelo participante para troca de cupons deve ficar registrado no
sistema, para o caso de ele apresentar posteriormente mais notas fiscais que
completem o valor necessário para emissão de cupons. Por exemplo: se o
participante apresentar inicialmente R$250 em notas, ele obterá dois cupons,
e R$50 ficarão registrados no sistema; se posteriormente ele apresentar mais
R$150 em notas, serão gerados mais dois cupons.
Avaliação
A
atividade deve ser desenvolvida em duplas. A apresentação deve ser feita até
o dia 18/04. Os dois alunos 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 alunos 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.
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 305.
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. Atualizada em 01/04/2011.
|