Descrição
Nessa
tarefa você irá criar uma aplicação gráfica em Java – um programa de controle
de vendas para pequenos estabelecimentos comerciais – utilizando componentes
de software. O programa será utilizado pelos funcionários do estabelecimento
para cadastrar os produtos à venda e para registrar as compras efetuadas
pelos clientes.
Aplicações
Gráficas
Em seguida
será descrito como utilizar o ambiente de desenvolvimento NetBeans para
criação de aplicações gráficas. Outros ambientes de desenvolvimento podem ser
utilizados, caso seja de sua preferência e desde que eles permitam a criação de
aplicações gráficas utilizando componentes.
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.
Download do
NetBeans: Windows | Linux
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 'Aplicativo Java' da Categoria 'Java' corresponde a uma
aplicação 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 principal, com o mesmo nome do projeto, a partir da
qual outras classes poderão ser instanciadas.
Para criar
uma aplicação gráfica, devemos criar um novo arquivo (menu Arquivo à Novo arquivo) do
tipo “Formulário JFrame” da categoria “Formulários GUI Swing”.
A classe
criada 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  .
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 'Navegador'.
Na janela
'Propriedades' é possível definir as propriedades dos componentes. Por
exemplo, após adicionar um botão (JButton) à janela, ao selecioná-lo, é possível
editar o texto mostrado no botão alterando o valor da 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 botão).
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.
Também é
possível inserir no projeto outros tipos de contêineres, através do menu
Arquivo à Novo arquivo,
incluindo contêineres como painéis (Formulário JPanel) e janelas de diálogo
(Formulário JDialog), por exemplo. Cada um desses elementos corresponderá a
uma nova classe Java da aplicação, que servirá como contêiner para outros
componentes gráficos.
Tarefa
1: A Interface Gráfica da Aplicação
O trabalho
consiste em desenvolver um sistema para registro de produtos e de vendas
efetuadas em um pequeno estabelecimento comercial – por exemplo, uma loja de
informática, uma loja de autopeças, um quiosque de um shopping, etc.
O sistema
deve permitir a execução das seguintes funcionalidades:
· Registro de
produtos à venda: cadastramento dos dados do produto, para o caso de este
ainda não estar cadastrado no sistema.
· Controle de
estoque: permite alterar a quantidade em estoque de um produto cadastrado no
sistema.
· Registro de venda
de produtos: permite que um ou mais produtos em estoque sejam vendidos para
um cliente.
Comece a
desenvolver a interface gráfica do sistema de controle de vendas usando o NetBeans.
Não se preocupe por enquanto em implementar a funcionalidade da aplicação.
Crie um
projeto do tipo ‘Aplicativo Java’ e adicione um ‘Formulário JFrame’ ao
projeto, que será a janela principal da aplicação. Na seqüência, adicione
componentes ao JFrame que permitam a execução das funcionalidades descritas
acima. 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.
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.
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. Isso 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 um botão, e como componente de destino uma
área de texto.
No ‘Assistente
de conexão’, que será aberto automaticamente, selecione o evento de origem –
no caso, o evento ‘actionPerformed’, que é enviado quando o botão é
pressionado utilizando o mouse ou o 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 a
qualquer atributo ou método da classe que está sendo editada. Note 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 sistema de controle
de vendas. Estes tratadores de eventos devem chamar os métodos de classes de
controle (gerenciadores), que implementarão a lógica de funcionamento da
aplicação. As classes de controle devem interagir com as entidades gerenciadas
por elas – produto, venda, etc. 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
manipulados pelo sistema devem ser serializados, de modo a permitir a sua
recuperação em futuras execuções da aplicação.
Avaliação
A
atividade deve ser desenvolvida em duplas. A apresentação deve ser feita até
o dia 22/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 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
23/09/2012.
|