Apostila Programação 3º Período.

Transcrição

Programação
3° Período
Alex Coelho
...
import javax.swing.*;
...
public class AppCadastro extends Frame{
...
TextField nome = new TextField(71);
TextField descricao = new TextField(68);
Button salvar = new Button("Salvar");
Button limpar = new Button("Limpar");
Button report = new Button("Relatório");
Button sair = new Button("Sair");
Label result = new Label();
//método construtor
public AppCadastro(){
rio");
...
painelCadastro.setLayout(new FlowLayout());
painelCadastro.add(new Label("Nome:"));
painelCadastro.add(nome);
painelCadastro.add(new Label("Descrição:"));
painelCadastro.add(descricao);
Caro estudante,
Na aula 1, iniciaremos conhecendo os componentes básicos para a
programação visual, utilizando a biblioteca AWT, além de relembrarmos
conceitos básicos já vistos na disciplina de Programação anterior. Na aula
2, continuaremos com a apresentação dos componentes da biblioteca
AWT e aprenderemos a desenvolver programas e explorar a interação.
Em nossa 3ª aula, serão apresentados os tratadores de eventos para a
interação dos usuários com o sistema que são aceitos pela biblioteca AWT
e serão explorados os conceitos vinculados ao gerenciamento de layouts e
disposição dos componentes em uma interface gráfica. Na 4ª aula, conheceremos os conceitos para construção de aplicações que serão interligadas
a banco de dados para o armazenamento e recuperação de dados.
Em nossa aula 5, o foco será o trabalho com a Applets, que possibilita
a criação de programas com interfaces para WEB. Na aula 6, iremos falar
sobre o desenvolvimento de programas em Java com relatórios, possibilitando a criação de aplicações comerciais, mais completas. Finalizando, na
aula 7 será apresentado um estudo de caso, de uma aplicação completa
para o cadastro e consultas de cursos, por meio da utilização de todos os
conceitos apresentados em nosso módulo. Então vamos ao que interessa,
tente aproveitar ao máximo tudo o que será exposto na disciplina.
Apresentação
Seja bem-vindo à disciplina Programação. O objetivo deste material
é apresentar os principais conceitos que a tecnologia Java disponibiliza
para a construção de aplicações visuais, aprofundar e conhecer novos
componentes da programação visual, além dos conceitos relacionados à
conexão e consulta a banco de dados, para que, ao final desta disciplina,
você consiga desenvolver programas em Java, aplicando todo o conhecimento adquirido. A tecnologia Java, nos últimos anos, tornou-se muito popular no mercado, estando presente nas mais diversas aplicações, como,
em eletrodomésticos, aparelhos celulares e web. Assim, a linguagem Java
tem características que a tornam diferenciada, sendo de grande importância na criação de software.
Fundação Universidade do Tocantins
Reitor
Humberto Luiz Falcão Coelho
Vice-Reitor
Lívio William Reis de Carvalho
Pró-Reitor de Graduação
Galileu Marcos Guarenghi
Pró-Reitor de Pós-Graduação e Extensão
Claudemir Andreaci
Pró-Reitora de Pesquisa
Antônia Custódia Pedreira
Pró-Reitora de Administração e Finanças
Maria Valdênia Rodrigues Noleto
Diretor de EaD e Tecnologias Educacionais
Marcelo Liberato
Coordenador Pedagógico
Geraldo da Silva Gomes
Coordenador do Curso
Igor Yepes
Organização de Conteúdos Acadêmicos
Alex Coelho
Material Didático – Equipe Unitins
Coordenação Editorial
Maria Lourdes F. G. Aires
Assessoria Editorial
Marinalva do Rêgo Barros Silva
Assessoria Produção Gráfica
Katia Gomes da Silva
Revisão Lingüístico-Textual
Kyldes Batista Vicente
Revisão Digital
Projeto Gráfico
Douglas Donizeti Soares
Irenides Teixeira
Programação Visual
Douglas Donizeti Soares
Material Didático – Equipe Univali
Coordenação Geral - Gerência de EaD
Margarete Lazzaris Kleis
Reitor
José Roberto Provesi
Vice-Reitor
Mário César dos Santos
Procurador Geral
Vilson Sandrini Filho
Coordenação Técnica e Logística
Jeane Cristina de Oliveira Cardoso
Coordenação de Curso
Luis Carlos Martins
Editoração Gráfica
Delinea Design Soluções Gráficas e Digitais LTDA
Secretário Executivo
Nilson Scheidt
Coordenação Editorial
Charlie Anderson Olsen
Larissa Kleis Pereira
Pró-Reitora de Ensino
Amândia Maria de Borba
Logística Editorial
Michael Bernardini
Pró-Reitor de Pesquisa, Pós-Graduação,
Extensão e Cultura
Valdir Cechinel Filho
Diagramação
Michael Bernardini
EADCON – Empresa de Educação
Continuada Ltda
Diretor Presidente
Luiz Carlos Borges da Silveira
Diretor Executivo
Luiz Carlos Borges da Silveira Filho
Diretor de Desenvolvimento de Produto
Márcio Yamawaki
Diretor Administrativo e Financeiro
Júlio César Algeri
Ilustração
Alexandre Beck
Ementa
Programação visual utilizando a tecnologia Java. Biblioteca AWT (Abstract
Window Toolkit). Componentes básicos: Frame, Label, Button, TextField, Panel,
TextArea, List, Choice, CheckBox, CheckBoxGroup, Menus. Gerenciadores de
Layout. Eventos AWT. Conexão com Banco de dados: JDBC, Tipos JDBC, Connection, Statement, PreparedStatament. Applets. JasperReports e iReport.
Objetivos
• Apresentar conceitos básicos da linguagem de programação Java para
programação visual.
• Apresentar os principais componentes utilizados para a construção de
• Proporcionar a compreensão aos alunos sobre a utilização de banco de dados em aplicações visuais utilizando componentes e conceitos de conexão.
• Demonstrar aos alunos o potencial do desenvolvimento de aplicações
visuais e sua possibilidade de interação com os usuários.
• Demonstrar aos alunos a confecção de relatórios utilizando a tecnologia Java.
Conteúdo programático
• Componentes visuais básicos
• Label
• Button
• TextField
• Pane
• TextArea
• Choice
• List
• Checkbox
• CheckboxGroup
• Menu
• Tratamento de eventos
• Gerenciamento de layouts
• Conexão com banco de dados
• Inserção e consultas a banco de dados
• Applets
• Relatórios com jasperReport
Plano de Ensino
interfaces gráficas.
BIBLIOGRafia básica
BOENTE, Alfredo. Aprendendo a programar em Java 2: orientado a objetos.
Rio de Janeiro: Brasport, 2003.
ANSELMO, Fernando. Aplicando lógica orientada a objetos em Java. 2. ed.
Florianópolis: Visual Books, 2005.
CARDOSO, Caíque. Orientação a objetos na prática: aprendendo orientação a objetos com Java. Rio de Janeiro: Ciência Moderna, 2006.
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice
Hall, 2005.
SANTOS, Rafael. Introdução à programação orientada a objetos usando
Java. Rio de Janeiro: Campus, 2003.
HEFFELFINGER, David. JasperReports for Java Developers. Agosto, 2006.
Bibliografia complementar
SUN, MicroSystem. Java Technology. Disponivel em http://java.sun.com.
Acessado em 12 out. 2007.
Aula 1 – Programação Visual em Java....................................................... 9
Aula 2 – Componentes visuais................................................................ 23
Aula 3 – Gerenciadores de layout e Tratadores de evento.......................... 37
Aula 4 – Trabalhando com Banco de Dados............................................. 49
Aula 5 – Applets Java............................................................................ 61
Aula 6 – Relatórios................................................................................ 71
Sumário
Aula 7 – Estudo de Caso........................................................................ 83
Aula 1
Programação Visual em Java
Objetivo
Esperamos que, ao final desta aula, você seja capaz de:
• c onhecer os principais componentes visuais utilizados na tecnologia
Java para a programação visual.
Pré-requisitos
Para iniciarmos os estudos sobre a programação visual Java, é importante
conhecermos os conceitos básicos da programação orientada a objetos, vistos
na disciplina Programação do segundo período. Esse conhecimento é importante para uma melhor compreensão desta aula, uma vez que são conceitos
básicos para prosseguimento na construção de programas visuais em Java.
Introdução
Nos últimos anos, com o avanço tecnológico e dos microcomputadores
em empresas e residências, as aplicações gráficas ganharam considerável espaço, aumentando, com isso, as possibilidades que, além de fornecerem uma
interface mais simples, rica e intuítiva com os usuários, passaram a agilizar os
processos antes desempenhados de maneira pouco interativa. Essas interfaces
que mudaram todo o conceito da programação são mais conhecidas como
GUI (Graphical User Interface) e obedecem a um padrão que consiste em dar
ao usuário o que ele está vendo e precisando, o famoso “what you see is what
you get” das pesquisas oriundas da interação homem-máquina.
Assim, a linguagem de programação Java oferece diversas capacidades,
únicas no desenvolvimento de aplicações gráficas que, conforme apresentado
no módulo anterior, devido à capacidade de liberdade de plataforma não
Univali/UNITINS • superior de tecnologia • 3º PERÍODO
9
Aula 1 • programação
são necessárias modificações ou mesmo recompilação da aplicação, sendo
que estas podem ser executadas em diferentes ambientes gráficos, sendo uma
vantagem comercial diante das demais linguagens.
1.1 Programação Visual
“
A linguagem
Java
disponibiliza
duas
bibliotecas
para a
construção
de interfaces
gráficas,
utilizando
componentes
GUI.”
Nesta aula, veremos mais a fundo os conceitos relacionados à programação com interfaces visuais, apresentados na aula 5 da disciplina de programação anterior. Assim, iniciaremos esta aula apresentando um conceito
geral da programação visual com Java. Podemos dizer que a utilização de
componentes padronizados, como botões, campos de texto e menus, fez das
interfaces gráficas um sucesso. Pela utilização de componentes visuais, é possível que usuários interajam por meio de operações realizadas pelo teclado
ou mouse, tornando possível com isso, entradas de dados, seleção de caixas,
botões além de, acionar outras operações que tornem as aplicações interessantes ao usuário conforme demonstrado nas aulas finais do módulo anterior.
Estes componentes também conhecidos como GUI componentes, são elementos
que compõem uma interface GUI. Segundo Deitel (2005), um componete GUI é:
um objeto pelo qual o usuário interage através do mouse, do teclado ou outra forma de entrada, como reconhecimento de voz.
A linguagem Java disponibiliza duas bibliotecas para a construção de
interfaces gráficas, utilizando componentes GUI. A primeira consiste na utilização da biblioteca Swing, vista anteriormente, com a implementação de
aplicações simples. A outra biblioteca e que será tema de nossos estudos nesta
aula, consiste na biblioteca AWT (Abstract Window Toolkit) que é disponibilizada por meio da importação do pacote java.awt. No caso, a biblioteca
AWT fornece diversas classes, comuns e abstratas que realizam com a utilização da JVM (Java Virtual Machine) a apresentação dos componentes visuais
pertencentes a essa biblioteca.
A classe abstrata Component consiste na base para construção de qualquer componente visual oferecido pela linguagem Java, por meio da utilização da AWT (DEITEL, 2005). Em discussão sobre os conceitos vinculados aos
componentes, pode se afirmar que a AWT faz com que seja criada uma generalização dos componentes utilizados na construção de aplicações visuais,
sendo independentes da plataforma que esteja sendo utilizada, fazendo com
que estas sejam sempre equivalentes, e desempenhando as mesmas funções
10
3º PERÍODO • superior de tecnologia • Univali/UNITINS
para as quais foram destinadas e se propõem a resolver garantindo a portabilidade do sistema. A Sun define a Java como (SUN, 2007):
simples, distribuída, interpretada, robusta, segura, de arquitetura neutra, portátil, multi-funções e dinâmica.
Certo, porém o que isto significa para a construção de minhas aplicações?
Isto significa que, independentemente do sistema operacional escolhido, uma
mesma aplicação pode ser executada sem que o resultado final seja alterado,
por exemplo, um botão sempre será compreendido como um botão pela JVM
rodando seja no Linux, Windows ou mesmo Solaris, mesmo que a aparência
do componente seja distinta, os princípios básicos de funcionamento e operação sempre serão os mesmos (DEITEL, 2005).
1.2 Construindo uma Aplicação Gráfica
O processo inicial de uma aplicação gráfica sempre é realizado com a
seleção e projeto de uma interface para o sistema, selecionando todos os componentes que irão compor a tal interface, distribuindo-os da forma desejada
no ambiente visual e, no caso, é mais importante definir qual a real função de
cada componente e sua utilização na aplicação. O mercado fornece diversas
IDEs para a construção de interfaces gráficas Java, utilizando o padrão Drag
and Drop, porém como nosso intuito nesta aula consiste em fixar todos os
conceitos ligados à programação visual, fica a seu critério a utilização ou não
dessas ferramentas, não nos apegaremos a nenhuma IDE.
Saiba mais
Existem diversas IDEs e plugins para ferramentas de desenvolvimento
para aplicações gráficas em Java. Dentre estas, as mais utilizadas
consistem no Eclipse, Netbeans, Sun One e JBuilder. Estas colaboram
com a aceleração do processo de desenvolvimento e, conseqüentemente,
com a redução de custos.
Com isso, podemos dividir a implementação de um sistema visual utilizando
a linguagem Java em três etapas, como visto anteriormente: a primeira consiste
na criação e instanciação dos componentes da biblioteca AWT no projeto (FLANAGAN, 2006). Sempre é válido mencionar que em Java todos os componentes
são classes. Sendo assim, um componente é instanciado da mesma forma como
uma variável, ou mesmo atributo, como melhor você estiver familiarizado.
11
Outra etapa a ser desempenhada na criação de uma aplicação visual
consiste na adição dos componentes à interface, para que eles estejam visíveis
no momento da execução do sistema. Existem componentes que incorporam
outros componentes, para que estes estejam visíveis sendo denominados como
containers. Estes são criados e associados à interface, sendo que podem ser
especificados o seu posicionamento com a utilização de gerenciadores de
layout que serão estudados nesta aula.
A terceira e última etapa de um desenvolvimento voltado para criação de
aplicações gráficas, consiste no que irá ser realizado quando um determinado
evento ocorrer sobre um dos componentes gráficos de uma aplicação, assim
que ocorrer uma interação do usuário com a aplicação, seja por meio do teclado ou mesmo pela utilização do mouse.
Após essa interação, é enviada uma mensagem da plataforma em que a
aplicação esta sendo executada, informando o tipo e a forma de interação
que ocorreram sobre o componente. Aí entram em ação os listeners, que
são métodos que ficam em estado de alerta escutando o que é enviado pelo
sistema operacional. Estes métodos especiais são implementados nas aplicações e são associados aos componentes, sendo responsáveis por escutar uma
interação e reagir a tais interações, conforme desejado (DEITEL, 2005).
Depois da apresentação desta visão inicial sobre as aplicações gráficas,
vamos pôr a mão na massa e criar nosso primeiro exemplo, utilizando as bibliotecas gráficas AWT. Então transcreva o código a seguir e execute-o.
// Classe PrimeiroExemplo.java
import java.awt.*;
public class PrimeiroExemplo extends Frame{
public static void main (String args[]) {
Frame f = new Frame ();
Button botao = new Button (“SAIR”);
//botao. addActionListener(Evento);
f.add(botao);
f.setSize(50, 100);
f.setLocation(50, 50);
f.show();
}
}
12
Como podemos perceber, são utilizados diversos conceitos apresentados
no módulo anterior, como o processo de instanciação e referência dos objetos
ou mesmo a idéia de herança. Porém, conforme mencionado anteriormente
neste módulo, iremos trabalhar com a biblioteca AWT, que difere do que já foi
apresentado na aula anterior.
Por exemplo: com a utilização da biblioteca Swing, para criarmos um
botão convencional, deveríamos instanciar um objeto da classe JButton.
Conforme apresentado no exemplo anterior, a AWT utiliza apenas a classe
Button, para que o mesmo processo seja realizado, sendo uma biblioteca
nativa do Java. Mas não se preocupe, todos os conceitos e componentes
conhecidos serão úteis para construções de aplicações, uma vez que a idéia
geral do processo é muito semelhante.
Com isso, torna-se possível criar aplicações gráficas que utilizem os componentes GUI da biblioteca AWT. Então, para que possamos criar efetivamente uma aplicação, é interessante que sejam conhecidos quais são os componentes básicos da AWT, bem como instanciar, obviamente adicioná-los estes a
interfaces, além de propor funcionalidades por meio dos eventos e interações
desempenhadas pelos usuários sobre os componentes (SUN, 2007).
1.3 Componentes Básicos
Como já mencionado nesta aula, a classe abstrata Component é a base
para construção de qualquer componente visual, sendo que este é fornecido
pela linguagem Java, por meio do pacote java.awt. Esse pacote oferece classes com toda infra-estrutura necessária para criação de objetos que possuam
uma representação gráfica que podem ser exibidos em uma interface que
pode reagir a interações de um usuário (DEITEL, 2005).
Assim como no conceito de interfaces apresentado no módulo anterior,
as classes abstratas não podem ser instanciadas diretamente, mas podem ser
utilizadas como um modelo para a criação de novos componentes, sendo
estas novas classes derivadas desta, permitindo um tratamento generalizado
dos componentes que são oriundos do conceito de polimorfismo. Todos os
componentes gráficos que serão aqui apresentados são baseados no pacote
java.awt, não se esqueça.
A classe Component também é base para construção da classe abstrata
Container, que consiste em uma área na qual outros componentes podem ser
13
adicionados e posicionados a interface. No caso, qualquer classe que herda da
classe Container pode agregar a seu escopo outros componentes. Alguns exemplos de containers de componentes são as classes Frame e Window, que
consistem em janelas, além da classe Panel que é um painel (DEITEL, 2005).
Pensando sobre o assunto
Assim como qualquer outra classe, são fornecidos diversos
métodos pela classe Component, fornecendo formas de acesso às
funcionalidades desta. Sugerimos uma verificação prévia deste, uma
vez que todos são herdados pelos demais componentes.
Então vamos ao que interessa, vamos apresentar os principais componentes da AWT, conhecendo suas principais aplicações e utilizando, para isso, a
construção de pequenos exemplos. Nosso primeiro componente a ser explorado consiste no Frame.
1.3.1 Componente Frame
O componente Frame consiste em uma classe responsável pela construção
de janelas para aplicações gráficas que disponibiliza uma barra de título e
bordas. Como esta é uma subclasse da classe Container, conforme mencionado, esta pode conter em seu escopo outros componentes, sendo que esta
consiste em sua finalidade principal. Outro detalhe que deve ser levado em
consideração é o alinhamento dos componentes dentro do Frame instanciado,
sendo por definição o alinhamento default BorderLayout para os componentes que são adicionados (FILHO, 2005). Ademais, o componente Frame,
também implementa a interface MenuContainer, possibilitando que possam
ser associados a estes componentes de menu associados à janela . Todos estes
componentes serão explorados mais profundamente no decorrer desta aula.
Geralmente, o componente Frame consiste na base para a criação de
aplicações gráficas, sendo que são feitas especificações da classe Frame,
criando, assim, além da janela a ser utilizada, um container para os componentes desta janela, através da utilização de seu método construtor (DEITEL,
2005). Vamos criar nosso exemplo utilizando tais conceitos; então, transcreva
o exemplo a seguir e execute-o.
14
// FrameExemplo.java
import java.awt.*;
public class FrameExemplo extends Frame{
// metodo construtor
public FrameExemplo(){
super(“Janela Exemplo”);
setSize(50, 100);
setLocation(100, 100);
}
// metodo executável
public static void main (String args[]) {
FrameExemplo janela = new FrameExemplo();
janela.setVisible(true);
}
}
Note que no nosso segundo exemplo, conforme mencionado anteriormente, são construídas geralmente classes que estendem da classe Frame, sendo
que esta se torna, além de uma janela, um repositório para componentes. Na
classe FrameExemplo explicitamos outro detalhe interessante e muito importante, que consiste na invocação do método setVisible(true) para a apresentação
da janela, dentro do método executável da classe, porém poderia ser utilizado
o método show(), mas este está sendo depreciado pela nova versão da JVM.
Porém, apesar de conseguirmos apresentar nossa janela, conforme desejado, com capacidade de conter diversos componentes, além de diversas
características, a janela ainda não responde a nenhum evento, por exemplo,
quando o botão “fechar”, é acionado nada ocorre. Isso se dá devido ao fato
de não existirem métodos que tratem os eventos, no caso que recebam a mensagem do sistema operacional e seja capaz de tratá-la.
Por exemplo, como não possuímos um método que escute tais mensagens
da plataforma, necessitamos então encerrar a execução da Java Virtual Machine, para conseguirmos finalizar nossa janela. Então vamos tornar nosso segundo exemplo mais interessante: é necessário que sejam construídos métodos
que processem os eventos que irão reagir à interação com a janela.
Iremos, para tanto, utilizar a interface WindowListener para se incumbir de
tal tarefa. A utilização da interface exige de maneira semelhante a um contrato que
os métodos definidos nestes sejam implementados, pelas classes que se propõem a
implementá-la, pode ser facilmente utilizada devido à possibilidade da utilização de
diversas interfaces, para a mesma classe, conforme foi apresentado no módulo anterior (DEITEL, 2005). O ponto negativo da utilização da interface WindowListener é que
esta exige a implementação de 7 (sete) métodos, sendo que utilizaremos apenas um.
15
Vamos verificar como ficará nossa classe FrameExemplo, após a definição
de que esta passará a implementar a interface WindowListener. É interessante
observar os métodos que devem ser ao menos declarados, devido à utilização
da interface, bem como a importação do pacote java.event, sendo que este
será detalhado na 3ª aula. Assim, faça as alterações na classe conforme é
apresentado no quadro abaixo e execute seu programa.
import java.awt.*;
import java.awt.event.*;
public class FrameExemplo extends Frame implements WindowListener{
public FrameExemplo (){
super(“Titulo: Janela Exemplo”);
setSize(50, 100);
addWindowListener(this);
}
// metodo executavel
static public void main(String args[]){
}
// metodos listeners
public void windowClosing(WindowEvent e){
System.exit(0);
}
public void windowClosed(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
}
Assim, conseguimos fazer com que a nossa janela passe a escutar as
mensagens vindas do sistema operacional, fazendo com que a interação do
usuário junto a nossa janela possa gerar uma reação desta. Todos os componentes da AWT possuem métodos especiais que tratam essas interações entre
os usuários e o componente.
Certo, pessoal? Então vamos agora a nosso segundo componente que
pode ser agregado à nossa janela, enriquecendo nossos programas.
16
1.3.2 Componente Label
Nesta subseção, iremos apresentar o componente Label, que, conforme
mencionado, pode ser agregado ao componente Frame, apresentado, assim,
rótulos de texto, ou simplesmente legendas. Este, por sua vez, pode ser utilizado em qualquer componente que seja do tipo container, exibindo apenas uma
linha, sendo que esta não permite alteração. Diversos métodos podem ser acessados para uma instância da classe Label, porém, com certeza, os mais utilizados são os métodos construtores, nos quais já podem ser definidos textos que
serão apresentados dentro das interfaces gráficas criadas com a classe Frame.
Outra característica que é muito utilizada na instanciação de objetos do tipo
Label consiste na utilização das constantes para a definição de seu alinhamento.
São disponibilizadas três constantes: Label.LEFT, Label.CENTER e Label.RIGHT.
Então vamos a outro exemplo para uma pequena demonstração deste componente, no qual alteramos nosso o exemplo anterior (MANZANO, 2006).
import java.awt.*;
public class FrameExemplo extends Frame implements WindowListener{
super(“Titulo: Segundo Exemplo”);
setSize(50, 100);
}
// metodo executavel
static public void main(String args[]){
Label texto = new Label(“Novo Texto!”);
janela.add(texto);
}
...
}
Note que no exemplo apenas criamos uma instância da classe Label, denominada texto e, com a utilização de seu construtor, definimos o texto a ser apresentado na janela. Note que foi utilizado o método add() do objeto janela, para que o
label fosse acrescentado à janela, para sua apresentação. Desta forma, qualquer
objeto que deva ser apresentado deve estar adicionado à janela por meio desse
método. Assim, vamos a mais um componente, sendo que este tem importância
significativa para o desenvolvimento de aplicações gráficas, no caso os botões.
17
1.3.3 Componente Button
Agora vamos a um componente importantíssimo para a criação de aplicações gráficas, a classe Button, responsável pela criação de componentes do
tipo botão. Os botões são interessantes para as aplicações gráficas por possibilitar a interação entre o sistema e os usuários e, assim, determinar seqüências de
comandos para reagirem a tais interações. Os botões agregam valor visual, uma
vez que apresentam efeitos e modificações no estado deste, que denotam uma
resposta do sistema às ações desempenhadas pelos usuários (DEITEL, 2005).
Porém, assim como apresentado na construção das janelas através da utilização da classe Frame, os botões necessitam de implementações, para que
as mensagens das interações entre o usuário e o sistema sejam interpretadas e
sejam atendidas, ou seja, dependem de tratadores ou escutadores de eventos,
realizado pelos famosos listeners.
Para que essa interação seja percebida pelo sistema, a classe Button deve
implementar a interface ActionListener, no qual exige que seja definido apenas
um método, o actionPerformed(), conforme é apresentado em nosso exemplo a
seguir, onde alteramos novamente nosso exemplo em que criamos a janela e
definimos uma legenda de texto. Assim, altere as linhas no método construtor,
bem como crie o novo método conforme é apresentado.
import java.awt.*;
public class FrameExemplo extends Frame implements WindowListener,
ActionListener{
super(“Titulo: Botão Exemplo”);
Label texto = new Label(“Para sair aperte o botão!”);
Button botao = new Button(“Sair”);
setSize(150, 100);
setLayout(new FlowLayout());
botao.addActionListener(this);
add(texto);
add(botao);
}
//metodo listener
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
...
}
18
Neste exemplo, podemos notar que, assim como na janela, na qual definimos qual é o seu listener, que será o responsável por receber e tratar as mensagens, agindo sobre estas, no botão ocorre o mesmo, porém o método que
realiza tal tarefa consiste no actionPerformed(), que recebe um evento de ação
que é produzido pelos botões. Outro detalhe a ser percebido é a transferência
do código para o construtor da classe, trazendo maior clareza do que a interface deve conter no momento de sua instanciação, facilitando a modularidade do
sistema. Além disso, foi acrescentado o método setLayout() no qual foi atribuído
o valor de uma nova instância da classe FlowLayout para centralizar os componentes na janela. Retornaremos a este assunto na nossa 3ª aula.
Uma vez que existem os listeners para escutar e receber as mensagens
do sistema de que ocorreu alguma interação sobre os componentes, é
possível identificar sobre qual componente a ação foi disparada; para
tanto, existe o método getSource() que nos fornece tal informação.
Podem ser criados diversos botões em uma aplicação e, uma boa prática
de programação que, quando o método actionPerformed() se tornar grande e
complexo é a realização de uma explosão do código em outros métodos que
tratem isto de maneira mais clara.
1.3.4 Componente TextField
Vamos ao nosso último componente desta aula. Assim como o Button, este
é exaustivamente utilizado em programas que fazem uso de interfaces visuais:
é o componente TextField.
Através da classe TextField, obtemos uma caixa de texto, que possibilita a
entrada de texto pelos usuários. Todo o conteúdo digitado dentro das caixas
de texto é tratado como Strings dentro da aplicação, sendo que devem ser
tratados após sua inserção conforme necessário. Assim como a Classe Button,
a TextField também utiliza a interface ActionPerformed e, conseqüentemente, o
método de mesmo nome para tratar entradas de dados. Porém, este só é acionado através da tecla “enter”. Para ações que devam ser executadas, ao digitar
algum texto, deve ser utilizado o método listener addTextListener(TextListener)
(DEITEL, 2005). Altere o método construtor de nossa classe FrameExemplo,
conforme o quadro abaixo e execute-o.
19
import java.awt.*;
public class FrameExemplo extends Frame implements WindowListener,
ActionListener{
super(“Titulo: Botão Exemplo”);
Label texto = new Label(“Para sair aperte o botão!”);
Button botao = new Button(“Sair”);
TextField caixaDeTexto = new TextField(“”, 30);
setSize(250, 120);
add(texto);
add(caixaDeTexto);
add(botao);
}
...
}
Tanto o componente Label quanto o TextField podem ter seu conteúdo alterado,
bem como recuperado pelos métodos setText() e getText(), respectivamente. Dessa
maneira, finalizamos nossa 1ª aula. Façam as atividades para uma melhor fixação
dos conceitos e componentes apresentados até aqui. Nos vemos na próxima aula.
Saiba mais
É mais que interessante, é de vital importância para que suas aplicações
sejam bem sucedidas e que se tenha domínio sobre os métodos disponibilizados pela classe TextField. Para tanto, sugerimos a leitura do javadoc deste
importante componente da programação visual Java.
Síntese da aula
Nesta aula, apresentamos os conceitos básicos relacionados à programação
visual com a utilização da tecnologia Java, bem como alguns componentes e
tratadores de eventos para uma maior interação entre usuários e sistema. Aprendemos como criar janelas utilizando a classe Frame, além de criar textos estáticos
que não podem ser alterados diretamente pelos usuários, no caso as legendas
através da classe Label. Ademais, foram apresentados os componentes Button e
TextField para a criação de botões e a caixa de texto respectivamente.
20
Atividades
1. A classe Frame possibilita que criemos janelas para aplicações visuais.
Estas podem ter eventos vinculados a sua estrutura. Assim, qual é a interface
responsável por fornecer os métodos de uma janela?
2. Devido ao conceito de portabilidade da linguagem Java e a JVM as aplicações visuais com a biblioteca AWT e Swing tem ganho espaço considerável
no mercado. Assim, qual a principal vantagem conseguida com a construção
de aplicações Java, levando em consideração o conceito de portabilidade?
Comentário das atividades
Na atividade 1, a principal vantagem apresentada pelas aplicações visuais
em Java consiste em sua independência de plataforma graças aos conceito de
portabilidade, fazendo com que, independente do sistema operacional, o mesmo
botão será apresentado da mesma maneira em todas as plataformas. Já na questão
2, a interface responsável por definir os métodos de uma janela é a WindowListener, que fornece os métodos: windowClosing(), windowClosed(), windowIconified(),
windowOpened(), windowDeiconified(), windowActivated(), windowDeactivated().
Referências
Hall, 2005.
FILHO, Renato Rodrigues. Desenvolva aplicativos com Java 2. São Paulo:
Érica, 2005.
MANZANO, José Augusto Navarro Garcia; COSTA JR., Roberto Affonso da.
Java 2: programação de computadores. São Paulo: Érica, 2006.
THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo: Érica, 2002.
Na próxima aula
Veremos outros componentes para a construção de aplicações visuais utilizando a biblioteca AWT, que enriquecerão a interação com o usuário.
21
Anotações
22
Aula 2
Componentes visuais
Objetivo
• c onhecer os componentes visuais básicos da biblioteca AWT relacionados a programação visual.
Pré-requisitos
É de fundamental importância que os conceitos apresentados na aula 1
tenham sido assimilados por você. Esse conhecimento é necessário, pois agora iremos nos aprofundar na utilização da tecnologia Java, para a crição de
programas com outros componentes visuais que interagem com os apresentados em nossa 1a aula.
Introdução
Com a utilização das interfaces gráficas, conseguimos incorporar valor
aos sistemas. Assim, quanto mais componentes forem disponibilizados, mais
possibilidades existirão para criarmos aplicações que contribuam com a interação entre usuários e programas. A biblioteca AWT, assim como a Swing,
disponibilizam diversos componentes.
A programação visual Java é uma metodologia com um enfoque muito
diferente aos usuais sustentados e encontrados no mercado, uma vez que estes
não disponibilizam controle total sobre os eventos. Estes recursos fornecidos
por essa metodologia dão suporte à construção de aplicações que aumentam
o poder dos sistemas, além de fornecer subsídio para a solução de problemas
pelo computador como uma atividade mais humanizada.
23
Assim como a própria linguagem de programação Java, a construção
de aplicações com a utilização de aplicações visuais em Java é relativamente nova na concepção e implementação de sistemas de software.
Os maiores objetivos desta nova metodologia consistem em aumentar
a produtividade do programador, além de acelerar todo o processo de
desenvolvimento com componentes prontos. Assim, iremos, nesta aula,
continuar o trabalhalho com os componentes básicos mais importantes.
2.1 Componentes visuais
Então vamos ao que interessa, pessoal! Agora, conheceremos outros
componentes visuais, que colaboram com a construção de interfaces e
aplicações mais ricas e que apresentam características para uma melhor
interação entre usuário e sistemas.
2.1.1 Componente Panel
Então, pessoal, empolgados com a programação visual? É claro que sim.
É através da utilização de componentes visuais que conseguimos observar
toda uma nova era dos computadores que buscam uma maior proximidade
com o usuário. Para tanto, iremos, agora, conhecer o componente Panel, que
consiste em um painel que, como os demais componentes apresentados até
aqui, é um tipo de classe (DEITEL, 2005).
Esta consiste em um tipo de container, ou seja, pode agregar a seu escopo
outros componentes, inclusive outros painéis, assim como a classe Frame, uma
vez que ambas são derivadas da classe Container. Com a utilização do componente Panel, é possível se obter uma maior versatilidade para a disposição
de outros componentes gráficos nas interfaces criadas na aplicação (DEITEL,
2005). Sua utilização, juntamente com os gerenciadores de layouts, amplia as
possibilidades de uso desta classe. Pessoal, é hora de colocarmos a mão na
massa. Vamos criar uma nova janela para observar a combinação de todos
os componentes vistos até o momento.
24
//NovaJanela.java
import java.awt.*;
public class NovaJanela{
public static void main(String[] args) {
Panel painelTopo = new Panel();
Panel painelDireita = new Panel();
Panel painelBaixo = new Panel(new FlowLayout(FlowLayout.LEFT));
Panel painelCentro = new Panel(new FlowLayout(FlowLayout.CENTER));
Panel painelEsquerda = new Panel();
Frame janela = new Frame(“Painel”);
janela.setSize(100, 100);
janela.setLocation(300, 300);
painelTopo.setBackground(Color.RED);
painelDireita.setBackground(Color.GREEN);
painelBaixo.setBackground(Color.BLUE);
painelCentro.setBackground(Color.CYAN);
painelEsquerda.setBackground(Color.ORANGE);
janela.add(painelTopo, BorderLayout.NORTH);
janela.add(painelDireita, BorderLayout.EAST);
janela.add(painelBaixo, BorderLayout.SOUTH);
janela.add(painelCentro, BorderLayout.CENTER);
janela.add(painelEsquerda, BorderLayout.WEST);
}
}
Executando o exemplo anterior, ficam claras as possibilidades de disposição dos painéis em uma janela, bem como dos componentes que podem estar
contidos dentro destes, notando a distinção dos painéis por meio das diferentes cores. Deve ser observado que os painéis são agregados ao container de
componentes, no caso a janela, por meio do método add(). Porém, um maior
detalhamento será realizado quanto à utilização do gerenciamento de layout,
na 3ª aula. Nossos exemplos de agora em diante sempre farão uso dos painéis, sendo utilizados como container para os nossos componentes. Assim,
vamos ao próximo componente da biblioteca AWT.
Assim como já mencionado para a classe Frame, uma vez não definido
o layout para os componentes instanciados do tipo Panel, estes
automaticamente assumirão um layout default, definido pela própria
maquina virtual.
25
2.1.2 Componente TextArea
Na aula anterior, foi apresentado o componente TextField que apresenta uma caixa de texto de linha única. Agora, iremos conhecer outro de
caixa de texto, porém este componente que muito contribui para as diversas
aplicações que podem ser desenvolvidas, permite a criação de uma área que
aceite a entrada e edição de textos de múltiplas linhas.
O componente TextArea assim como o TextField possuí os mesmos métodos, uma vez que são derivados da mesma classe pai a TextComponent, porém
esta ainda disponibiliza alguns métodos para o manuseio de suas particularidades, como linhas, colunas ou mesmo a barra de rolagem (FLANAGAN, 2006).
Assim, vejamos o exemplo abaixo com a utilização deste componente visual.
// NovaJanela.java
import java.awt.*;
public class NovaJanela extends Frame implements ActionListener {
private TextArea multTexto;
private Button botao;
private TextField texto;
public static void main(String args[]) {
NovaJanela f = new NovaJanela();
f.addWindowListener(new WindowAction());
f.setVisible(true);
}
public NovaJanela() {
super(“TextArea”);
setSize(300, 300);
texto = new TextField(20);
texto.addActionListener(this);
botao = new Button(“Inserir”);
multTexto = new TextArea();
Panel p = new Panel();
p.setBackground(SystemColor.control);
p.setLayout(new FlowLayout());
p.add(texto);
p.add(botao);
add(p, BorderLayout.NORTH);
add(multTexto, BorderLayout.CENTER);
}
if (e.getSource()==botao) {
multTexto.append(texto.getText());
}
texto.setText(“”);
}
}
26
Neste exemplo, criamos um janela com três componentes, um TextField, um Button
e um TextArea. Porém, agora, como apresentado anteriormente para o componente
Panel, começamos a dispor nossos elementos utilizando os gerenciadores de layout.
Um detalhe que deve ser observado neste exemplo consiste na alteração de nosso método actionPerfomed(), para realização de operações sobre o componente TextArea. A
classe TextArea disponibiliza operações sobre textos como copiar e colar, sendo que
tais operações podem ser ativadas e desativadas. Outro detalhe consiste na utilização
dos métodos append() e insert() para a inserção de texto no componente. Assim, finalizamos esta seção e vamos conhecer agora outro objeto para programação visual.
2.1.3 Componente List
Nesta seção, será apresentado o componente List que permite a exibição de
uma lista de itens. Este possui diversas características e comportamentos, sendo que os
itens desta lista não podem ser editados diretamente pelos usuários, além de ser sensível à seleção, ou seja, podem ser acrescentadas ações ao evento de seleção sobre os
itens da lista através da utilização das interfaces ItemListener e ActionListener, que são
acionados quando um objeto é selecionado e quando ocorre um duplo clique sobre
algum item respectivamente (DEITEL, 2005). Para criarmos nosso próximo exemplo de
utilização do componente List, substitua apenas as linhas referentes a instanciação do
objeto TextArea do exemplo da seção anterior pelo código apresentado a seguir.
// NovaJanela.java
import java.awt.*;
public class NovaJanela extends Frame implements ActionListener {
private List lista;
private Button botao;
private TextField texto;
...
public NovaJanela() {
...
lista = new List();
...
add(lista, BorderLayout.CENTER);
}
if (e.getSource()==botao) {
lista.add(texto.getText());
}
texto.setText(“”);
}
}
27
Como resultado, teremos uma janela muito semelhante à apresentada
no exemplo da seção anterior, mas, observando seu funcionamento, pode
ser verificado que, ao invés de um texto contínuo que pode ser digitado ou
mesmo alterado, temos uma lista de itens. Assim como realizado na classe
Frame e na Panel, para adicionarmos texto a um objeto List é utilizado o
método add(), conforme demonstrado no exemplo anterior. Assim como
nos demais componentes, sugerimos a leitura do javadoc para enriquecer
suas interfaces.
Saiba mais
Javadoc consiste na documentação disponibilizada juntamente com cada
classe, detalhando o funcionamento e as funcionalidades de atributos e
métodos. Desta forma, consiste em uma boa prática de programação, a
disponibilização dos javadoc para todas as classes desenvolvidas. A própria
máquina virtual disponibiliza um recurso para a geração automática do
javadoc. Para tanto, sugerimos a leitura de material relacionado a este assunto.
2.1.4 Componente Choice
Outro componente muito utilizado em aplicações gráficas com a utilização do pacote AWT, consiste na Choice, este por sua vez implementa uma
lista de itens onde somente um item pode ser exibido. Este consiste no famoso
combobox das demais linguagens de programação gráficas. A seleção dos
itens que compõem um objeto Choice é disponibilizada para que apenas um
destes seja selecionado, não havendo seleção múltipla.
Para qualquer ação que queira ser desempenhada sobre os eventos
deste componente, devem ser implementados os métodos referentes à interface ItemListener, assim como no objeto List apresentado na seção anterior.
Então, utilizando os conhecimentos adquiridos até aqui, construa uma janela por meio da utilização da classe Frame, e crie um painel para receber
seus componentes (DEITEL, 2005). Acrescente o código abaixo nos locais
indicados nos comentários e execute o programa para visualização do
componente Choice.
28
//Crie sua janela e seu painel conforme demonstrado nos exemplos anteriores
import java.awt.*;
public class Janela extends Frame
implements ItemListener {
private Choice combobox;
...
//Transcreva o código abaixo no metodo construtor
combobox = new Choice();
combobox.add(“Java”);
combobox.add(“Delphi”);
combobox.add(“C++ Builder”);
combobox.addItemListener(this);
...
//Crie o método que reage ao evento
public void itemStateChanged(ItemEvent e) {
if (e.getSource()==combobox) {
texto.setText(“Selecionado:”+combobox.getSelectedItem());
}
...
}
Assim como nos demais casos apresentados até o momento, é utilizado
o método add(), para que sejam acrescentados itens ao componente Choice.
O método que trata os eventos que ocorrem sobre um objeto Choice, consiste
no itemStateChanged(), conforme pode ser observado no exemplo anterior.
Sugerimos que sejam realizadas alterações, bem como a criação de novas
interfaces para a fixação dos conhecimentos vinculados a este componente.
2.1.5 Componentes Checkbox
Vamos ao próximo componente da biblioteca AWT: uma instância da classe Checkbox cria graficamente, nos programas visuais, caixas de opção. Este componente
é geralmente utilizado para representar que uma opção deve ser escolhida, sendo verdadeira, quando o componente está marcado, ou falsa quando estiver desmarcado.
Todos os objetos criados por meio da utilização da classe Checkbox, da
mesma forma como as classes List e Choice, fazem uso da interface ItemListener para tratar eventos. Um detalhe interessante deste componente consiste no
fato de mesclar, além de uma caixa de seleção, um componente Label para
descrição textual deste, conforme é apresentado a seguir.
29
//Classe JanelaCheck
import java.awt.*;
public class JanelaCheck extends Frame implements ItemListener {
private Checkbox checkEmail;
private Checkbox checkCorreio;
private Label texto;
public JanelaCheck() {
super(“Checkbox”);
setSize(800, 200);
texto = new Label(“Indique os meios de envio:”);
Panel p = new Panel();
checkCorreio = new Checkbox(“Correios”);
checkEmail = new Checkbox(“Email”);
checkCorreio.addItemListener(this);
checkEmail.addItemListener(this);
p.setLayout(new FlowLayout());
p.add(texto);
p.add(checkCorreio);
p.add(checkEmail);
add(p, BorderLayout.NORTH);
}
public void itemStateChanged(ItemEvent e) {
if (checkCorreio.getState()) {
texto.setText(“Selecionado:”+checkCorreio.getLabel());
}
if (checkEmail.getState()&& checkCorreio.getState()) {
texto.setText(“Selecionado:”+checkEmail.getLabel()+” e “
+checkCorreio.getLabel());
} if (checkEmail.getState()) {
texto.setText(“Selecionado:”+checkEmail.getLabel());
}
}
JanelaCheck janela = new JanelaCheck();
janela.addWindowListener(new WindowAction());
}
}
Diversos Checkboxs podem ser criados, sem que exista referência entre
estes componentes; para tanto, quando isto é necessário, utilizamos uma instância da classe CheckboxGroup para que seja realizado um agrupamento
de componentes Checkbox.
30
2.1.6 Componente CheckboxGroup
Conforme mencionado, o componente Checkboxgroup realiza o agrupamento de diversos objetos da classe Checkbox, tornando-se um único componente visual no qual seja capaz de selecionar apenas um item dentro deste componente. Porém, vale ressaltar que o componente Checkboxgroup não
apresenta nenhuma interface, apenas faz vinculação entre os itens criados com
o Checkbox, e com isto fazendo com que uma única opção seja escolhida.
No caso, este tipo de componente visual é mais conhecido como radiobuttons em outras linguagens de programação, sendo que associados estes,
disponibilizam que apenas um item seja selecionado, garantindo uma escolha
única (DEITEL, 2005). Igualmente aos outros componentes da biblioteca AWT
que trabalham com itens, além do fato deste ser composto por um ou mais
Checkbox para que os eventos sejam tratados neste, deve ser implementada
a interface para tais. Alterando o exemplo anterior, para que este só permita
apenas uma opção, apenas crie uma instância do componente Checkboxgroup e nos construtores de cada objeto Checkbox criado, associe ao grupo,
conforme é apresentado abaixo.
//Classe JanelaCheck
import java.awt.*;
public class JanelaCheck extends Frame implements ItemListener {
private Checkbox checkEmail;
private Checkbox checkCorreio;
private CheckboxGroup grupo;
private Label texto;
public JanelaCheck() {
...
grupo = new CheckboxGroup();
checkCorreio = new Checkbox(“Correios”,grupo,true);
checkEmail = new Checkbox(“Email”,grupo,false);
...
}
...
}
O último parâmetro passado nos construtores dos objetos Checkbox consiste na definição de qual será apresentado como verdadeiro. Certo, pessoal?
Conforme pode ser observado no exemplo anterior, isso torna esse componente uma forma de disponibilizar diversas opções, porém garante que apenas
uma seja a escolhida. Agora iremos finalizar nossa 2ª aula com a apresentação de um importantíssimo componente, senão o mais importante de todos,
devido à sua estrutura e recurso.
31
2.1.7 Componentes para criação de Menus
Vamos conhecer, agora, diversos componentes que são necessários para
a criação de menus nas aplicações gráficas, fazendo com que as aplicações
fiquem mais profissionais.
A AWT disponibiliza suporte para a criação das famosas barras de menu
ou, como também são conhecidos, menus suspensos. Para a criação de menus
suspensos utilizando esta biblioteca é necessária a utilização de três classes:
MenuBar, Menu e MenuItem (FILHO, 2005).
Este três componentes são hierarquicamente organizados, sendo que um
deve conter o outro. Inicialmente, o componente MenuBar cria uma barra de
menu, para que seja acrescentado o menu, e esta barra deve sempre ser associada ao objeto Frame, no caso a janela. O componente Menu conforme mencionado, deve ser atribuído à barra de menu. E, finalizando nossa organização,
as instâncias da classe MenuItem devem ser agregados ao menu. Desta forma,
conseguiremos construir menus, aumentando o poder de interação em nossos sistemas, além de uma melhor disposição das funcionalidades. Vamos a um exemplo no qual criamos um menu, então transcreva o código abaixo e o execute.
//JanelaMenu.java
import java.awt.*;
public class JanelaMenu extends Frame implements ActionListener, WindowListener{
//metodo construtor
public JanelaMenu(){
super(“Menus”);
MenuBar barra = new MenuBar();
Menu menuArquivo = new Menu(“Arquivo”);
Menu menuSobre = new Menu(“Sobre”);
MenuItem itemNovo = new MenuItem(“Novo”);
MenuItem itemSair;
itemSair = new MenuItem(“Sair”, new MenuShortcut(KeyEvent.VK_R));
MenuItem itemAjuda = new MenuItem(“Ajuda”);
//Adicionando eventos aos componentes
itemSair.addActionListener(this);
itemNovo.addActionListener(this);
//Agregando os itens ao menu e a barra
menuArquivo.add(itemNovo);
menuArquivo.add(itemSair);
menuSobre.add(itemAjuda);
barra.add(menuArquivo);
barra.add(menuSobre);
setMenuBar(barra);
setSize(400, 400);
}
32
//metodo executável
JanelaMenu janela = new JanelaMenu();
}
//métodos listeners
System.exit(0);
}
...
if (e.getSource() instanceof MenuItem) {
MenuItem item = (MenuItem) e.getSource();
if(item.getLabel().equals(“Sair”)){
System.exit(0);
}
if(item.getLabel().equals(“Novo”)){
Frame novaJanela = new Frame();
novaJanela.setVisible(true);
}
}
}
}
Certo, pessoal? Vamos, agora, entender o que foi realizado no exemplo
anterior. Inicialmente, da mesma maneira como nos outros exemplos, criamos
nossa classe, sendo que esta deriva da classe Frame, com isto explicitando
que estamos criando uma nova janela. Continuando, temos o método construtor que é o responsável por inicializar todos os componentes que farão parte
de nossa interface visual. Até aqui, nenhum segredo, pessoal. Tudo acontece
da mesma maneira como nos exemplos das outras seções, ou mesmo aula.
O único detalhe a ser mencionado, quanto ao conteúdo do método construtor, consiste na instanciação dos objetos que compõem um menu, ou seja,
componentes do tipo MenuBar, Menu e MenuItem. Note o agrupamento hierárquico que é realizado, no qual um menu contém vários itens, e uma barra
de menu contém diversos menus, sendo que esta barra é associada a nossa
janela, conforme é destacado no quadro abaixo.
...
//Agregando os itens ao menu e a barra
menuArquivo.add(itemNovo);
menuSobre.add(itemAjuda);
barra.add(menuArquivo);
barra.add(menuSobre);
setMenuBar(barra);
...
33
Após isto, temos nosso método executável main, no qual é instanciado um
objeto de nossa classe JanelaMenu. Este por derivar da classe Frame, conforme mencionado, é uma janela. Com isto, finalizando, são criados os métodos
exigidos pelas interfaces que nossa classe implementa a ActionListener e WindowListener.
Porém, note que no método actionPerformed() estamos tratando o evento
de maneira diferente ao que vínhamos trabalhando. Desta vez, mencionamos
que a fonte de nosso evento consiste em um componente do tipo MenuItem.
Com tal tratamento por meio do comando instaceof conseguimos lidar com todos os atributos e métodos que venham a ser necessários. A partir deste ponto
somente verificamos qual dos itens foi invocado para reagir a interação.
...
System.exit(0);
}
if(item.getLabel().equals(“Novo”)){
Frame novaJanela = new Frame();
novaJanela.setVisible(true);
}
}
}
...
Outra característica que enriquecerá as aplicações com menu consiste na
utilização de teclas de atalhos para acelerar o processo de acesso às funcionalidades do sistema definidas nos itens. Um exemplo desta possibilidade está
disponível em nosso exemplo completo, apresentado no início desta seção,
com a utilização do método construtor para a definição deste, conforme é
apresentado no quadro logo a seguir, por meio da classe MenuShortcut().
...
new MenuItem(“Sair”, new MenuShortcut(KeyEvent.VK_R));
...
Muito bem, pessoal, assim finalizamos nossa 2ª aula e também a apresentação dos componentes gráficos para a criação de programas com interfaces
visuais, utilizando a biblioteca AWT. Esperamos que vocês tenham tirado o
máximo de proveito, desta forma façam todos os exercícios.
34
Síntese da aula
Nesta aula, foram apresentados os principais componentes da programação visual Java como, TextArea, Choice, List e Menu, utilizando a biblioteca
AWT. Além disto, foram vistos conceitos e classes necessárias para um melhor
entendimento de tais componentes, uma vez que, para utilização desses componentes, foi necessário que detalhes como layout e tratadores de eventos
fossem incorporados a estes.
Atividades
1. Qual o gerenciador default do compenente Panel?
2. Os menus auxiliam na organização e acionamento das funcionalidades
do sistema. Para tanto, usuários mais avançados podem fazer uso de técnicas
que acelerem o processo de acesso às fucionalidades. Dentre estas técnicas,
podemos destacar as teclas de atalho. Assim como são definidas as teclas de
atalhos em um menu?
Na atividade 1, como mencionado em nossa aula, o gerencidor de layout
default consiste no BorderLayout, que define as regiões: Norte, Sul, Leste, Oeste e Centro em uma janela para que sejam adicionados outros compoentes.
Já na atividade 2, as teclas de atalho podem ser definidas a um menu com a
utilização do componente MenuShortcut(), que deve ser definido no momento
da instanciação dos itens do menu, além de definidas quais serão as teclas
utilizadas para acionar cada item.
Referências
Hall, 2005.
Érica, 2005.
FLANAGAN, David. Java: o guia essencial. 5. ed. Porto Alegre. Bookman, 2006.
35
Na próxima aula
Continuaremos a relembrar e explorar mais a fundo conceitos vinculados ao gerenciamento de layout, bem como o tratamento de eventos
para os componentes.
Anotações
36
Aula 3
Gerenciadores de layout e
Tratadores de evento
Objetivos
• relembrar e compreender conceitos relacionados aos gerenciadores de
layout para aplicações visuais e os tratadores de eventos.
Pré-requisitos
É de fundamental importância, para um melhor desenvolvimento e entendimento desta aula, que você já tenha fixado os conceitos expostos nas aulas 1 e 2. É
importante também conhecer os componentes da biblioteca AWT, para a definição
de uma interface mais amigável através da disposição dos componentes, bem
como as interfaces necessárias para a implementação dos tratadores de evento.
Introdução
No desenvolvimento de aplicações gráficas, interfaces mais amigáveis proporcionam uma melhor aceitação por parte dos usuários, uma vez que, além
dos aspectos estéticos, uma melhor organização dos componentes visuais de
maneira mais eficiente auxilia a reduzir dificuldades de entendimento, localização de componentes ou mesmo agilizam os trabalhos para os usuários mais
avançados, com a utilização de teclas de atalho definidas junto ao sistema.
Além disso, uma interface amigável não garantirá o sucesso do sistema se este
não desempenhar suas funções da maneira correta, reagindo a ações dos usuários.
Desta forma, nesta aula, iremos rever conceitos relacionados aos tratadores de eventos, porém desta vez de maneira isolada, sendo o ponto central de nosso estudo, onde
nos atentaremos a conhecer as interfaces que podem ser utilizadas para o tratamento
dos principais eventos. Então, pessoal, uma boa aula e tentem aproveitar ao máximo.
37
3.1 Gerenciamento de Layouts
Como visto nas aulas anteriores, quando criamos uma interface em
Java podemos utilizar componentes no qual devem ser incorporados a outros componentes, conforme visto, containers Frame e o Panel. Porém, estes
funcionam de maneira diferente nas demais linguagens de programação
quanto à definição de posições na janela, no qual podem ser especificadas
ecoordenadas para sua definição. A linguagem Java fornece os gerenciadores de layout, responsáveis por, de forma simples, dispor os componentes
na interface gráfica. Devido ao fato de tentar se obter o máximo do conceito de portabilidade, criou-se o conceito de gerenciadores de layout, para
que, qualquer que seja o sistema operacional que esteja executando, essa
aplicação seja interpretada da mesma forma, evitando surpresas quanto a
disposição dos elementos na janela (DEITEL, 2005).
Como visto na disciplina anterior, e até mesmo com exemplos práticos
nas aulas desta aula, os objetos podem ser dispostos dentro de janelas e
painéis, sendo que estes podem assumir posições relativas em uma janela,
tudo definido pelos gerenciadores de layout.
Os gerenciadores de layout são classes especiais que realizam a implementação de interfaces, determinando como os componentes presentes
em um container são ordenados e posicionados. Desta forma, podem ser
definidos gerenciadores para os painéis que irão compor uma determinada janela, bem como definidos os gerenciadores para os componentes que
serão agregados aos painéis. A biblioteca AWT disponibiliza alguns gerenciadores de layout, sendo eles: FlowLayout, GridLayout, BorderLayout,
CardLayout e GridBagLayout (DEITEL, 2005). A seguir iniciaremos uma
maior explanação dessas classes.
3.1.1 Gerenciador FlowLayout
Vamos iniciar esta seção, relembrando os exercícios feitos nas seções e
aulas anteriores, então sugerimos uma rápida observação sobre eles para
então percebemos a utilização do gerenciador FlowLayout.
Segundo Deitel (2005), o gerenciador FlowLayout consiste no mais
simples dos gerenciadores, padrão para os applets e painéis. Neste tipo
de gerenciador, todos os componentes são dispostos da esquerda para a
direita. Ele obedece a ordem como os objetos são adicionados ao contai-
38
ner, sendo que os componentes são apresentados em uma mesma linha
até que não exista mais espaço nela, isto obedecendo ao tamanho do
container, criando-se uma nova linha logo abaixo para a disposição dos
outros componentes. Certo, pessoal? Vamos a mais um exemplo para que
sejam apresentadas a disposição dos componentes por meio da utilização
do gerenciador FlowLayout.
// GerenciadorLayout.java
import java.awt.*;
public class GerenciadorLayout extends Frame {
// método construtor
public GerenciadorLayout() {
super(“Gerenciador Layout”);
setSize(200, 115);
for (int i=1; i<7; i++)
add(new TextField(“Texto “+i));
}
// método executavel
GerenciadorLayout gerente = new GerenciadorLayout();
EventosWindows evt = new EventosWindows();
gerente.addWindowListener(evt);
gerente.setVisible(true);
}
}
class EventosWindows implements WindowListener{
System.exit(0);
}
public void windowClosed(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
}
Como pôde ser observado no exemplo anterior, cria-se uma seqüência
de componentes, que, conforme mencionado, é realizada uma quebra de
linha a cada momento em que não existe mais espaço para novos objetos
na linha. Outro tipo de gerenciador muito utilizado na construção de
aplicações gráficas consiste no GridLayout, então vamos a ele.
39
Como mencionado na aula anterior, todos os tipos de containers da
linguagem de programação Java derivam da classe Container, sendo que
esta disponibiliza o método setLayout() para a definição do gerenciador
de um componente do tipo container. Utilize este método sempre que
necessário para a redefinição da disposição dos objetos em sua janela.
3.1.2 Gerenciador GridLayout
Conforme mencionado, outro gerenciador de layout trata-se da classe
GridLayout. Esse gerenciador permite que os componentes sejam arrumados em uma grade formada por células de igual tamanho até que toda a área
do container, no caso o Frame ou o Panel, seja ocupada (DEITEL, 2005).
Assim como em vetores, podem ser especificadas as quantidades de linhas e colunas, sendo que todos os componentes adicionados aos containers
ocupam todo o espaço da celula do qual fazem parte, sendo que alterações
quanto à sua dimensão são repassadas, automaticamente, para as células e
obviamente para os componentes que as ocupam.
Com isto, vamos a um exemplo para que seja observada a disposição dos
componentes visuais utilizando este tipo de gerenciador. Para tanto, altere apenas
a linha que é responsável pela definição do layout no método construtor do exemplo anterior, substituindo pelo código no quadro a seguir e execute o programa.
import java.awt.*;
public class GerenciadorLayout extends Frame{
public GerenciadorLayout(){
...
setLayout(new GridLayout(2,3));
...
}
public static void main(String args[]){ ... }
}
class EventosWindows implements WindowListener{ ... }
40
Se tudo ocorreu como o esperado, provavelmente você deve ter percebido
a mudança na disposição dos objetos na tela de seu programa. Isto tudo com
apenas a redefinição do gerenciador de layout. A linguagem Java ainda dispõe do gerenciador BorderLayout, CardLayout e GridBagLayout.
3.1.3 Gerenciador BorderLayout
Assim como em uma bússola, o gerenciador de layout BorderLayout executa a disposição de componentes em um container dividido em cinco regiões,
sendo elas: east, west, north, south e center, no caso direita, esquerda, norte,
sul e centro, respectivamente. Este, por sua vez, é o gerenciador padrão para
o container Frame da API (Application Program Interface) AWT, bem como
JFrame do pacote Swing, conforme foi visto na aula anterior (DEITEL, 2005).
Um detalhe interessante, e que foge do que foi visto até agora para os
demais gerenciadores já apresentados, consiste no fato de que a ordem como
os componentes são adicionados não afetará o resultado final da tela: eles
devem ser adicionados explicitamente a uma região fixa do gerenciador, sendo que uma vez adicionado um componente, ele ocupará toda a região. Tudo
isso foi demonstrado no exemplo utilizado para a apresentação do container
criado por meio da utilização da classe Panel, na aula 2 na seção 2.1.1.
Desta forma, revisem o exemplo mencionado.
Saiba mais
Conforme mencionado, cada região definida pelo gerenciador de
layout só pode ser ocupada por apenas um componente, sendo que
este é redimensionado ocupando-a toda. Assim, uma vez que dois ou
mais elementos forem inseridos na mesma região um sobrescreverá o
outro, sendo que o primeiro não estará disponível para visualização ou
mesmo acesso (DEITEL, 2005).
3.1.4 CardLayout
A partir desta seção, trabalharemos com gerenciadores de layout diferenciados frente aos demais apresentados. Embora bem mais flexíveis, estes são
muitas vezes ineficientes para resolver alguns problemas. No caso, a classe CardLayoout é responsável por gerenciar um layout mais incrementado, que trata os
componentes presentes no container como uma pilha de cartas (FILHO, 2005).
41
Este gerenciador disponibiliza formas de acesso aos diversos componentes que podem ser “empilhados” no container, sendo que este permite a exibição do primeiro componente ou mesmo o último, ficando livre a navegação
entre estes (FILHO, 2005).
Desta forma, é possível navegarmos em diversos componentes Panel ou
mesmo Frame, sendo que estes podem conter diversos outros tipos de componentes, conforme demonstrado nas aulas anteriores. Assim, conseguimos obter o
aspecto de aplicações com diversas janelas, sendo que estas podem ser acessadas a qualquer momento por componentes como os Menus. Isto, porém, é mais
trabalhoso, uma vez que exige que mais código seja necessário, mas os resultados compensam todo o trabalho. O exemplo a seguir demonstra a utilização
deste gerenciador visual. Alguns pontos do código foram suprimidos, pois não
sofrem alteração do último exemplo apresentado, então os reutilize.
import java.awt.*;
public class GerenciadorLayout extends Frame implements ActionListener
{
private Panel windows;
private Button anterior, proximo;
// método executável, reutilize o código do outro exemplo
...
}
public GerenciadorLayout() {
super(“Janelas”);
setSize(250, 100);
// Painel Lateral de Controle
Panel lateral = new Panel();
lateral.setBackground(SystemColor.control);
Panel p2 = new Panel();
p2.setBackground(SystemColor.control);
p2.setLayout(new GridLayout(2, 1));
p2.add(anterior = new Button(“Anterior”));
anterior.addActionListener(this);
p2.add(proximo = new Button(“Proximo”));
proximo.addActionListener(this);
lateral.add(p2);
add(“East”, lateral);
Panel painel1 = new Panel();
painel1.add(new Label(“Segundo Painel”));
painel1.add(anterior);
42
// Painel Múltiplo
windows = new Panel();
windows.setLayout(new CardLayout());
windows.add(new Label(“Primeiro Painel”), “Janela2”);
windows.add(painel1, “Janela2”);
add(“Center”, windows);
}
CardLayout janelas = (CardLayout) windows.getLayout();
if (e.getSource()==anterior) {
janelas.previous(windows);
}
if (e.getSource()==proximo) {
janelas.next(windows);
}
}
}
class EventosJanela implements WindowListener{
...
}
Note que, neste exemplo, consegue-se criar diversos painéis, construíndo
o efeito de que existem diversas janelas que são executadas ao clicar sobre
os botões. Isto tudo é possível devido às características da classe CardLayout,
sendo que tais funcionalidades o diferenciam dos demais. Nosso último gerenciador consiste no mais complexo, mas também o que mais dispõe de funcionalidades dentre os gerenciadores.
3.1.5 GridBagLayout
Finalizando os gerenciadores de layout, apresentaremos o mais flexível dentre todos os apresentados, o GridBagLayout. Assim como o CardLayout, devido a esta flexibilidade, este torna-se o mais complexo de
todos os gerenciadores (FILHO, 2005).
O GridBagLayout, por sua vez, permite, assim como o GridLayout, definir
a posição de componentes em uma tabela com linhas e colunas. Porém, diferentemente do gerenciador GridLayout, este é bem mais tratável, permitindo
que os componentes sejam adicionados em qualquer ordem, além de poder
variar o tamanho das células, sendo que um componente pode ocupar mais
de uma linha ou coluna (FILHO, 2005).
43
Este gerenciador é mais utilizado por programas que utilizam a API Swing,
porém este também pode ser utilizada pelos componentes AWT. A utilização
deste gerenciador consiste na definição de um objeto para a caracterização,
através da classe GridBagConstraints, na qual podem ser definidas a quantidade de células, a posição, tamanho e, por exemplo, se o componente deve
ocupar todo o espaço da celular. Vamos a um pequeno exemplo para fixação.
// ExemploGridBag.java
import java.awt.*;
public class ExemploGridBag extends JFrame {
public ExemploGridBag {
super(“Exemplo1”);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
Container c = this.getContentPane();
GridBagConstraints cons = new GridBagConstraints();
c.setLayout(new GridBagLayout());
c.add(new Button(“Esquerda”), cons);
c.add(new Button(“Direita”), cons);
this.setSize(600,600);
}
public static void main(String[] args ) {
ExemploGridBag exe = new ExemploGridBag();
exe.setVisible(true);
}
}
Conforme mencionado, criado um objeto da classe GridBagConstraints
que será o responsável pela redefinição das características da interface como
os componentes devem ser apresentados, estes devem ser associados à janela
através do método add(). Assim finalizamos nossa seção de gerenciamento de
layout e agora iremos trabalhar mais a fundo com os tratadores de eventos.
Saiba mais
Para uma melhor utilização da classe GridBagConstraints, sugerimos
leituras complementares para que sejam conhecidas todas as
características que podem ser manuseadas através de uma instância
desta classe, enriquecendo suas interfaces através do gerenciamento de
layout flexível com a classe GridBagLayout.
44
3.2 Tratadores de eventos
Assim como vimos em diversos exemplos até aqui, os eventos ocorrem quando existe uma interação dos usuários por meio de operações com o mouse (pressionar um botão ou arrastar) ou através do teclado (pressionando alguma tecla).
O modelo de eventos da AWT é o responsável por este serviço, identificando
os objetos em que ocorreram as interações, os sources e os que atuarão como receptores, escutando as mensagens do sistema operacional mais conhecidos como
listeners. Neste modelo de eventos, mais especificamente os objetos receptores
são os responsáveis por além de receber, processar os eventos reagindo a interação realizada pelos usuários, chamando determinadas tarefas (DEITEL, 2005).
Os eventos são objetos de uma classe, enquanto os listeners são interfaces
que implementam os métodos que tratam estes eventos. Usualmente, cada tipo de
componente pode disparar certos tipos de eventos que podem ser “escutados” por
mais de um listener, conforme é apresentado na Tabela 1 (FLANAGAN, 2006).
Evento
Interface ou
Adaptador
Métodos
ActionEvent
ActionListener
actionPerformed
AdjustmentEvent
AdjustmentListener
adjustmentValueChanged
ComponentEvent
ComponentListener
ComponentAdapter
componentMoved
componentHidden
componentResized
ContainerEvent
ContainerListener
ContainerAdapter
componentAdded
componentRemoved
FocusEvent
FocusListener
FocusAdapter
focusGained
focusLost
ItemEvent
ItemListener
itemStateChanged
KeyEvent
KeyListener
KeyAdapter
keyPressed
keyReleased
keyTyped
MouseEvent
MouseListener
MouseAdapter
MouseMotionListener
MouseMotionAdapter
mousePressed
mouseReleased
mouseEntered
mouseExited
mouseClicked
mouseDragged
mouseMoved
45
TextEvent
WindowEvent
TextListener
WindowListener
WindowAdapter
textValueChanged
windowClosing
windowOpened
windowIconified
windowDeiconified
windowClosed
windowActivated
windowDeactivated
Alguns destes eventos, interfaces e métodos foram implementados nos
exemplos desta disciplina. Assim, vamos finalizar nossa 3ª aula falando de
uma maneira mais simples de tratar os listeners.
Como ficou claro no decorrer desta disciplina, ao implementarmos uma
interface todos os métodos nela declarados deverão ser redefinidos na classe
que a implementa. Conforme pôde ser observado nos diversos exemplos que
fizemos até o momento, ou mesmo na Tabela 1, muitas vezes somente um dos
métodos nos interessa.
Por exemplo, isto acontece quando uma classe implementa a interface
WindowListener, sendo que assim é necessário que se declarem todos os sete
métodos que estão definidos na interface. Mas se quisermos tratar somente um
determinado evento, quando este ocorre ignorando o restante, sem precisar
ficar reescrevendo os métodos que são desnecessários, como podemos agir?
Para podermos fazer isso, apenas redefinimos somente o método que se
necessita, ignorando os demais, para tanto utilizamos as classes adaptadoras,
que também foram apresentadas na Tabela 1, juntamente com as interfaces.
As classes adaptadoras são classes que já implementam as interfaces listener para os eventos, redefinindo todos os seus métodos (DEITEL, 2005).
Porém, os métodos definidos na classe adaptadora não possuem corpo ou
funcionalidade, fazendo com isto que tenhamos que utilizar o processo de
herança, criando uma subclasse das classes adaptadoras e nela redefinirmos
ou implementarmos somente o método que nos interessa. Desta forma, vamos
a um exemplo que demonstra tudo o que mencionamos: para fechar uma das
janelas de nossos exemplos, era necessário declarar, nada mais, nada menos,
que sete métodos da interface WindowListener.
46
import java.awt.*;
public class GerenciadorLayout extends Frame{
public GerenciadorLayout(){
...
setLayout(new GridLayout(2,3));
...
}
public static void main(String args[]){ ... }
}
class EventosWindows extends WindowAdapter{
System.exit(0);
}
}
Note que apenas alteramos nossa classe EventosWindows e, considerando o código apresentado e qualquer outro exemplo, fica claro que as classes
adaptadoras reduzem, consideravelmente, o trabalho, sendo apenas necessário que sejam implementados os métodos listerner que realmente serão necessários. Isto não é possível quando temos uma classe que já herda de alguma
outra classe. Bom, pessoal, assim chega ao fim nossa 3ª aula, espero que
todos tenham conseguido sanar qualquer dúvida sobre os conceitos aqui tratados, de suma importância para aplicações visuais.
Síntese da aula
Nesta aula, foram apresentados os conceitos relacionados aos métodos construtores, responsáveis por inicializar o espaço de memória de uma instância de
uma classe, bem como realizar operações e inicializar atributos e variáveis com
valores, tornando possível o perfeito funcionamento da funcionalidades da instância da classe. Da mesma maneira que existem os métodos construtores, existem
os métodos destrutores, sendo responsáveis por colocar ordem na casa, liberando
espaços de memória e finalizando operações da instância. Porém, diferentemente
das outras linguagens de programação, em Java não é necessário se preocupar
com a liberação do espaço de memória: Java possui um coletor de lixo automático,
que se responsabiliza pela liberação de memória para o bom funcionamento do
programa. Finalizando, apresentamos os conceitos vinculados ao encapsulamento,
que tem por objetivo, além da segurança evitando acesso direto aos atributos, esconder detalhes de implementação do usuário, fornecendo somente a real função
da classe, sem que os detalhes de como isto ocorrer fiquem explícitos.
47
Atividades
1. Quais são os gerenciadores de layout definidos pela biblioteca AWT?
2. A implementação de interfaces listener são responsáveis por interpretar os
eventos oriundos da interação do usuário com o sistema. Estas, muitas vezes,
se tornam dispendiosas devido a obrigar que todos os métodos da interface
sejam declarados na classe que implementa a interface. Dessa forma, qual a
outra possibilidade fornecida pela linguagem Java para tratar os eventos?
Na atividade 1, os gerenciadores de layout definidos pela biblioteca AWT
consistem nas classes FlowLayout, BorderLayout, CardLayout, GridLayout, GridBagLayout, sendo que este podem ser definidos a qualquer componente que
seja um container. Já na atividade 2, a outra possibilidade fornecida pela linguagem Java para tratar os eventos de um sistema consiste nas classes adaptadoras, que implementam as interfaces, e desta forma fornecem a possibilidade
de que outras classes derivem destas classes adaptadoras e assim, deixa de
ser obrigatória a definição de todos os métodos das interfaces listener, sendo
somente redefinindo os métodos que realmente serão utilizados pelo sistema.
Referências
Hall, 2005.
Érica, 2005.
Na próxima aula
Serão expostos os conceitos sobre conexão de aplicações Java com banco de dados, possibilitando a construção de programas que realizem as operações básicas com o manuseio de dados, além de, com isto, enriquecê-los.
48
Aula 4
Trabalhando com Banco de Dados
Objetivo
• c ompreender os conceitos relacionados à conexão de aplicações gráficas com banco de dados.
Pré-requisitos
Para iniciarmos esta aula, é importante ter concluído a disciplina de banco de dados já apresentada e, além disso, ter assimilado todo conhecimento
referente às aulas anteriores. Sendo mais específico: serão necessários, conhecimento básico de SQL (Structured Query Language), além de dominar
os conceitos quantos aos componentes da linguagem de programação Java
para aplicações visuais.
Introdução
Uma funcionalidade primordial em qualquer sistema, é a habilidade
para comunicar-se com um repositório de dados. A Linguagem Java possui
uma Application Programming Interface (API) que possibilita o acesso a
repositórios de dados através de um modelo de conexão uniforme, permitindo uma padronização no acesso a distintos bancos de dados. Esta API
é a Java DataBase Connectivity (JDBC).
49
4.1 JDBC
A API JDBC consiste em uma biblioteca, implementada em Java, que disponibiliza classes e interfaces para o acesso ao banco de dados. Para cada banco de
dados, deve haver uma implementação (também chamada de driver) dessas interfaces, levando em consideração as suas particularidades (THOMPSON, 2002).
4.1.1 Tipos de drivers JDBC
Conforme mencionado, a API JDBC utiliza-se de diversos tipos de drivers
que possibilitam a conexão de aplicações com banco de dados. Os principais
drivers são apresentados a seguir.
4.1.1.1 JDBC-ODBC
Também conhecido como Ponto JDBC-ODBC, é restrito à plataforma Windows,
este tipo utiliza ODBC para conectar-se com o banco de dados, convertendo métodos JDBC em chamadas às funções do ODBC. Este tipo de conexão geralmente é
usado quando não há um driver “puro-java”, que será descrito na seção 4.1.1.4
logo a seguir, para um determinado banco de dados (THOMPSON, 2002).
4.1.1.2 Driver API-Nativo
Este é o responsável por traduzir as chamadas realizadas com o JDBC
para realizadas com a API cliente do banco de dados utilizado. Assim como
o driver JDBC-ODBC, pode ser que sejam necessários que outras soluções e
aplicativos estejam instalados nas máquinas clientes, para que a conexão
possa ser estabelecida (THOMPSON, 2002).
4.1.1.3 Driver de Protocolo de Rede
A utilização do driver de protocolo de rede funciona, convertendo a chamada por meio do JDBC para um protocolo de rede, que independe do banco de
dados que está sendo utilizado, fazendo com que os dados sejam traduzidos
para o protocolo do banco de dados. Desta forma, devido ao fato de se utilizar
de protocolos que não se prendem a um determinado banco de dados, este consiste no modelo de conexão mais flexível e abrangente (THOMPSON, 2002).
50
4.1.1.4 Driver nativo
Este drive, por sua vez, converte as chamadas JDBC diretamente no protocolo do banco de dados. Este, que é implementado na linguagem Java, normalmente independe de plataforma, é escrito pelos próprios desenvolvedores,
tornando o muito flexível. É o tipo mais recomendado para ser usado e mais
utilizado no mercado (THOMPSON, 2002).
Saiba mais
Conforme mencionado, os drivers são os responsáveis pela maneira como
a aplicação realizará a comunicação com o banco de dados. Com isto, é
interessante ficar atento aos drivers disponíveis para o banco de dados que
estamos utilizando, uma vez que este pode fornercer uma interface que otimize
essa comunicação, como por exemplo, com o banco de dados Oracle.
4.1.2 Pacote java.sql
O pacote java.sql é o responsável por fornecer a API para acesso e processamento de dados armazenados em uma fonte de dados, geralmente em
uma base de dados relacional, utilizando a linguagem de programação Java.
As principais classes e interfaces do pacote java.sql são (DEITEL, 2005):
• D
riverManager, responsável por criar uma conexão com o banco
de dados;
• C
onnection, classe responsável por manter uma conexão aberta
com o banco;
• Statement, gerencia e executa instruções SQL;
• P
reparedStatement, gerencia e executa instruções SQL, permitindo também a passagem de parâmetros em uma instrução;
• R
esultSet, responsável por receber os dados obtidos em uma
pesquisa ao banco.
Prosseguindo nos tópicos seguintes, serão descritas e exemplificadas cada
uma dessas principais classes e interfaces, que tornam possível o armazenamento e recuperação de informação em base de dados.
51
4.1.3 DriverManager
A Classe DriverManager é a responsável pelo gerenciamento de drivers
JDBC. Esta classe também proporciona o estabelecimento de conexões a bancos de dados (THOMPSON, 2002).
// Carregando um driver em tempo de execução
Class.forName(“org.gjt.mm.mysql.Driver”);
// Tentando estabelecer conexão com o Banco de Dados
Connection conn =
DriverManager.getConnection(“jdbc:mysql://localhost/
aula04?autoReconnect=true”, “conta”, “senha”);
No código apresentado, primeiramente um driver é carregado em tempo de execução para que seja possível a tentativa de estabelecer conexão
com o banco de dados, por meio do método getConnection() da classe
DriverManager. Este método retorna uma implementação para a interface
Connection, então vamos a ela?
4.1.4 Connection
A interface Connection representa a conexão com o banco de dados.
Todas as operações executadas entre a aplicação Java e o banco de dados
ocorrem dentro do contexto desta interface (SUN, 2007).
No código exibido no tópico anterior, um objeto da interface Connection
(conn) recebe a conexão estabelecida com o banco de dados através da
classe DriverManager. Tal objeto é capaz de proporcionar informações sobre
as tabelas do banco, capacidades de sua conexão, quais gramáticas de SQL
são suportadas pelo banco, entre outros. Estes são métodos desta interface
freqüentemente utilizados (SUN, 2007):
• c ommit(), executa todas as alterações feitas com o banco de dados
pela atual transação.
• rollback(), desfaz qualquer alteração feita com o banco de dados pela
atual transação.
• close(), libera o recurso que estava sendo utilizado pelo objeto.
52
Note, porém que os métodos fornecidos pela interface Connection não
trabalham diretamente com os dados, lidando somente com características de
como o banco irá se comportar.
4.1.5 Statement
O objeto desta interface fornece métodos para executar uma instrução SQL estática, sem passagem de parâmetros. Os principais métodos
da Interface Statement são (SUN, 2007):
• executeUpdate(), executa instruções SQL do tipo: INSERT, UPDATE e DELETE;
• execute(), executa instruções SQL de busca de dados do tipo SELECT;
// Instanciando o objeto statement (stmt)
Statement stmt = conn.createStatement();
// Executando uma instrução SQL.
stmt.executeUpdate(“INSERT INTO ALUNO VALUES (1, ‘Pedro da Silva’)”);
O código acima mostra a instância de um objeto do tipo Statement
(stmt) através do método createStatement(), do objeto conn da interface
Connection. Após a instância do objeto stmt, é executada uma instrução
SQL de inserção em uma tabela de um banco de dados, a partir do método
executeUpdate().
4.1.6 PreparedStatement
A interface PreparedStatement possui todos os recursos da interface Statement, acrescentando a utilização de parâmetros em uma instrução SQL. Os
principais métodos da interface PreparedStatement são (SUN, 2007):
•
•
•
•
execute(), consolida a instrução SQL informada;
setDate(), método utilizado para atribuir um valor do tipo Data;
setInt(), utilizado para atribuir valores do tipo inteiro;
setString(), método utilizado para atribuir valores do tipo Alfa Numéricos.
53
// Instanciando o objeto preparedStatement (pstmt)
PreparedStatement pstmt = conn.prepareStatement(“UPDATE ALUNO SET NOME = ?”);
// Setando o valor ao parâmetro
pstmt.setString(1, “MARIA RITA”);
O código acima apresenta a instância do objeto pstmt da classe PreparedStatement, através do método prepareStatement(), do objeto conn da classe
Connection. Após a instância, o objeto pstmt utiliza o método setString() para
passar o valor do parâmetro criado na instrução SQL anteriormente.
4.1.7 ResultSet
Esta interface permite o recebimento e gerenciamento do conjunto de dados resultante de uma consulta SQL, realizada ao banco de dados. Ela proporciona métodos capazes de acessar os dados provenientes da consulta SQL.
Alguns dos métodos desta interface frequentemente utilizados (SUN, 2007):
• n
ext(), move o cursor para a próxima linha de dados, já que o conjunto de
dados retornados pela consulta SQL é armazenado como em uma lista.
• g
etString(String columnName), recupera o valor da coluna informada
como parâmetro, da linha atual do conjunto de dados recebidos pelo
objeto ResultSet.
//Recebendo o conjunto de dados da consulta SQL
ResultSet rs = stmt.executeQuery(“SELECT id, nome FROM ALUNO”);
// Se
while
}
houver resultados, posiciona-se o cursor na próxima linha de dados
(rs.next()) {
// Recuperando os dados retornados pela consulta SQL
int id = rs.getInt(“id”);
String nome = rs.getString(“nome”);
Este código exibe uma instância da interface ResultSet (rs), recebendo
um conjunto de dados retornados pela consulta SQL, caso esta retorne algo.
Esta consulta contém a seleção de dois campos: id e nome. Com o método
next(), caso haja resultados, o cursor que indica qual linha de dados do conjunto está em evidência, é apontado para a próxima linha. Assim, é possível
recuperar os valores dos campos selecionados com métodos como o getInt(),
getString(), entre outros.
54
4.2 Exemplo de uma aplicação
O exemplo contido nesta seção apresenta uma aplicação com uma base
de dados MySQL. Essa aplicação contém tudo o que foi mostrado nos tópicos
anteriores. O código abaixo mostra o início de uma classe chamada Aula04.
java, mostrando as importações necessárias para a aplicação funcionar. Então, mãos à obra, transcreva o código a seguir.
import
import
import
import
import
import
import
import
java.awt.Frame;
java.awt.List;
java.sql.Connection;
java.sql.DriverManager;
java.sql.PreparedStatement;
java.sql.ResultSet;
java.sql.SQLException;
java.sql.Statement;
public
class Aula04 {
private Connection conn;
private PreparedStatement pstmt;
private Statement stmt;
private ResultSet rs;
Após as importações, foram declarados quatro atributos, os quais serão
necessários para a interação com o banco. Além desses atributos, esta aplicação contém sete métodos apresentados logo a seguir.
public void open() {
try {
Class.forName(“org.gjt.mm.mysql.Driver”);
conn = DriverManager.getConnection(
“jdbc:mysql://localhost/aula04?autoReconnect=true”,
“root”, “”);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
}
}
public void close() {
try {
if (stmt != null)
stmt.close();
conn.close();
}
}
55
Para esta aplicação, foi utilizado o Tipo de driver 4 (drive nativo). O método
open() atribui a string de conexão do banco em questão (MySQL). Logo a seguir é
instanciado um objeto conn da interface Connection, passando como parâmetro o
tipo de driver, o local do servidor, o usuário e senha. A intenção deste método é apenas abrir uma conexão com o banco. O próximo método, close(), faz exatamente o
contrário do método open(), ou seja, somente fecha a conexão com o banco.
public void inserir(){
try {
// Abrindo a conexão com o banco
open();
// Instanciando o objeto statement (stmt)
stmt = conn.createStatement();
// Executando uma instrução SQL.
stmt.executeUpdate(
“INSERT INTO ALUNO VALUES (1, ‘Pedro da Silva’)”);
// Fechando a conexão com o banco
close();
close();
}
}
O método inserir() utilizou a interface Statement para adicionar um aluno
ao banco. Observe que para rodar esta aplicação, teremos que possuir uma
tabela Aluno, contendo duas colunas, id e nome. Neste método foi aberta uma
conexão com o banco, através do método open(), logo após criou-se uma instância da interface Statement (stmt). Este objeto executou um método chamado
executeUpdate(), passando como parâmetro uma instrução SQL de inserção
de dados. Ao final foi fechada a conexão com o banco.
public void alterar(){
try {
// Abrindo a conexão com o banco
open();
// Instanciando o objeto preparedStatement (pstmt)
pstmt = conn.prepareStatement(“UPDATE ALUNO SET NOME = ? Where id = 1”);
// Setando o valor ao parâmetro
pstmt.setString(1, “MARIA RITA”);
pstmt.execute();
close();
close();
}
}
56
O método alterar() é bem parecido com o inserir(). Apenas foi utilizada outra classe para a execução da instrução SQL. Neste caso, utilizamos a interface
PreparedStatement, que funciona de forma semelhante à interface Statement,
mas possui a grande vantagem de se passar parâmetros a uma instrução SQL.
Na instância da interface PreparedStatement (pstmt), é informada a instrução
SQL. Nesta instrução, espera-se alterar o nome de um aluno que possui o id
igual a “1”, inserido no método anterior. Nesta mesma instrução, logo após o
nome, foi utilizado o caractere “?”, que significa a criação de um parâmetro.
Na próxima linha, o objeto pstmt utiliza o método setString() para atribuir o valor ao parâmetro em questão. Repare que são informados dois valores: qual o
parâmetro e o seu devido valor. Neste caso, como só existe um parâmetro, foi
informado o número “1”. Se houvesse mais parâmetros, seriam informados na
seqüência: “2”, “3” etc. Logo após informar o valor do parâmetro, é executado
o método execute() do objeto pstmt, consolidando a alteração no banco.
public ResultSet buscarAlunos(){
try {
open();
stmt = conn.createStatement();
rs = stmt.executeQuery(“SELECT id, nome FROM ALUNO”);
return rs;
close();
}
return null;
}
O método seguinte, buscarAlunos(), utiliza o Statement, para fazer uma
pesquisa ao banco, através do método executeQuery(). Este retorna um objeto
do tipo ResultSet ao objeto rs, contendo os dados selecionados da tabela Aluno. Este método será utilizado logo a seguir para imprimir os dados na tela.
public void imprimirAlunos() throws SQLException{
List listAlunos = new List();
Aula04 aula = new Aula04();
aula.rs = aula.buscarAlunos();
while (aula.rs.next())
listAlunos.add(“Id: “ + aula.rs.getInt(“id”) + “ - “ +
“Nome: “ + aula.rs.getString(“nome”));
Frame janela = new Frame(“Janela”);
janela.setLocation(300, 300);
janela.setSize(300, 300);
janela.add(listAlunos);
}
57
O método imprimirAlunos() utilizou componentes do pacote AWT para a
impressão dos alunos na tela. Foram feitas instâncias das classes List e Aula04.
O objeto aula faz uma pesquisa no banco, através de seu método buscarAlunos(), explicado anteriormente, e logo a seguir é feito um laço de repetição
para adicionar os valores ao objeto listAlunos. Logo após, é criado o objeto
janela do tipo Frame, atribuindo valores de posição e tamanho. Depois disso,
é adicionada a lista de alunos à janela, a qual é exibida na tela.
Assim como foi utilizado um objeto do tipo List para a exibição
dos valores obtidos junto ao banco de dados, diversos outros
componentes poderiam ter sido utilizados. Dentre esses podemos
citar o componete Jtable da biblioteca Swing. Com isto, sugerimos
testes e uma leitura mais detalhada sobre quais componentes podem
receber valores de uma consulta a um banco de dados.
public static void main(String[] args ){
Aula04 aula = new Aula04();
aula.inserir();
aula.alterar();
aula.rs = aula.buscarAlunos();
try {
aula.imprimirAlunos();
}
}
Finalmente, o código acima apresenta o método main(), de execução padrão de uma classe Java. Nele, apenas se instância o objeto da classe Aula04
e executa os métodos explicados anteriormente. Assim finalizamos nossa 4ª
aula, refaçam todos os exemplos para um melhor aproveitamento dela.
Síntese da aula
Nesta aula, foram apresentados os conceitos relacionados à conexão de
aplicações Java com banco de dados. Inicialmente foram apresentados os
tipos de conexão JDBC possíveis, além de detalhar cada um destes. Depois,
foram consideradas as classes que fazem parte de uma conexão nativa do
Java, apresentado sua utilização. Finalmente, foi criado um exemplo que fizesse uso de todos os conceitos vistos anteriormente.
58
Atividades
1. Levando em consideração os tópicos apresentados nesta aula, quais são os
métodos implementados pela Interface Connection, para controle da conexão
com um banco de dados e qual o objetivo destes?
2. Qual a diferença entre as interfaces Statement e PreparedStatement?
Na atividade 1, os métodos que são implementados pela interface Connection, constem em: commit(), que executa todas as alterações feitas pela
atual transação; rollback(), que desfaz qualquer alteração feita pela atual
transação; close(), que libera o recurso que estava sendo utilizado pelo objeto. Já na atividade 2, a primeira consiste em uma interface que disponibiliza
métodos para a execução de claúsulas SQL, sem a passagem de parâmetros,
no caso estáticos. Já a interface PreparedStatement, além de possuir todos os
métodos disponibilizados pela primeira interface, fornece suporte à passagem
de parâmetros para as claúsulas que esta executa.
Referências
Hall, 2005.
THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo: Érica, 2002.
SUN, MicroSystem. Java Technology. Disponivel em http://java.sun.com.
Acessado em 12 out. 2007.
Na próxima aula
Serão apresentados os conceitos relacionados a construção de aplicações utilizando a classe Applets Java, fornecendo suporte para que possamos
disponibilizar aplicações visuais Java para a WEB.
59
Anotações
60
Aula 5
Applets Java
Objetivo
• desenvolver programas Java para WEB utilizando Applets.
Pré-requisitos
Para começar os estudos sobre a tecnologia de programação Applet Java,
é importante conhecer os conceitos de programação Java, vistos nas aulas anteriores, bem como conceitos relacionados à orientação ao objeto. Esse conhecimento é importante para uma melhor compreensão dos conceitos desta aula.
Introdução
Um Applet consiste em um trecho de código Java que pode ser integrados a páginas WEB, sendo que este têm um ciclo de vida diferente dos programas executável. Se destinam a ser utilizado pelos navegadores, significando
que será transportado pela Internet tal como documentos HTML, imagens entre
outros conteúdos típicos da rede.
Assim, esta aula irá apresentá-lo e prepará-lo para compreender e aplicar
os conceitos da tecnologia Applets Java. Bons estudos!
61
5.1 Funcionamento das Applets
As classes Applets são muito úteis para escrever aplicativos para a Internet, pois podem ser incorporadas a documentos HTML e executadas usandose navegadores que sejam compatíveis com Java, no caso, que suportem os
plugins disponibilizados para a execução do código pela JVM.
Os programas construídos com Applets são construídos de forma idêntica
aos programas gráficos Java, o entendimento da forma do seu ciclo de vida auxilia bastante na compreensão de sua estrutura. O seu funcionamento se baseia
em um modo particular de programação, que consiste em (DEITEL, 2005):
1.Instanciação – (create);
2.Inicialização – (init);
3.Início – (start);
4.Execução e renderização – (paint e outros métodos);
5.Parada – (stop);
6.Finalização ou destruição – (destroy).
Figura 1 - Ciclo de vida das Applets
Todos as classes Applets devem, necessariamente, seguir este ciclo de
vida. Dessa forma, é interessante conhecermos qual a função de cada um
destes métodos que determinam a vida de um Applet.
62
5.1.1 Método Init
É executado uma única vez, assim que a página que executa o Applet está
sendo carregada pela primeira vez, sendo invocado pelo navegador, através das JVM encarregada pela execução das Applets, conforme mencionado.
Através desse método é possível adicionar componentes, receber parâmetros
de execução e realizar outras atividades de preparo, antes que o Applet seja
apresentado (DEITEL, 2005).
5.1.2 Método start
Seguindo o ciclo de vida apresentado anteriormente, é executado logo
após o método init() o start(), no caso, este é invocado pelo browser toda vez
que o Applet se torna visível. Este pode ser utilizado para iniciar outros métodos
e executar animações gráficas ou mesmo arquivos de som (DEITEL, 2005).
5.1.3 Método paint
O paint é um método executado toda vez que a área de exibição da Applet precisa ser novamente renderizada, ou seja, toda vez em que houver a
necessidade de uma nova apresentação do conteúdo do Applet, este deverá
ser invocado. Após o Applet ser carregado pela primeira vez, este método
deverá ser chamado explicitamente para que seu código seja executado e,
assim, apresentado o resultado ao usuário (DEITEL, 2005).
5.1.4 Método stop
Outro método que sempre deve ser considerado na implementação de um
Applet consiste no stop(). Ele é executado sempre que houver uma mudança
da página atual que contém o Applet, ou minimização da janela ou qualquer
outra operação em que a janela não for mais a principal, ou seja, quando o
Applet deixar de ser visível (DEITEL, 2005).
5.1.5 Método destroy
Finalizando os métodos de ciclo de vida de um Applet, chegamos ao método destroy. Muito parecido com o método stop, no entanto este é executado
63
após todos os recursos da página serem utilizados, assim liberando todos os
recursos alocados durante a sua execução. Não há a necessidade de explicitá-lo, ou seja, de invocá-lo, havendo uma comunicação com outras classes
Applets ou conexões de rede que serão finalizadas (DEITEL, 2005).
Bom, pessoal, depois de tantos conceitos, iremos, a seguir, entender como
esses métodos são utilizados em uma classe Java e depois utilizados pelos
navegadores. O trecho de código logo abaixo exemplifica, dando uma noção
de como uma classe Applet Java é implementada.
// MetodosApplet.java
import java.applet.Applet;
import java.awt.Graphics;
public class MetodosApplet extends Applet{
private int init = 0;
private int start = 0;
private int paint = 0;
private int stop = 0;
public void init(){
init++;
}
public void start(){
start++;
}
public void paint( Graphics g){
paint++;
g.drawString(“O método Init: “+init, 5, 15);
g.drawString(“O método Start: “+start, 5, 30);
g.drawString(“O método Paint: “+paint, 5, 45);
g.drawString(“O método Stop: “+stop, 5, 60);
}
public void stop(){
stop++;
}
}
Este exemplo é interessante, devido ao fato de demonstrar a quantidade
de vezes que os métodos essenciais do ciclo de vida de um applet são invocados no momento de sua execução, explicitando todas as características
mencionadas. Outro detalhe que deve ser mencionado consiste no fato de
que as classes que se propõem a implementar um Applet devem derivar, no
caso, herdar da classe Applet, conforme é apresentado no exemplo anterior
na assinatura da classe MetodosApplet.
64
Saiba mais
As classes Applets passaram a ser um diferencial da linguagem Java, abrindo
um grande leque de possibilidades para as aplicações Java. O conceito de
Applets foi o responsável pelo crescimento exponencial vivido pela tecnologia
Java, que, em conjunto com o navegador Netscape, revolucionou o conteúdo
e a forma de apresentação na WEB em meados dos anos 90.
5.2 Rodando Applets Java em uma Página WEB
É isso, pessoal, depois de alguns conceitos básicos na seção anterior, iremos nos aprofundar neste conceito, porém, agora, realizaremos a chamada
de um Applet por meio de um arquivo html, ou seja, uma página WEB que
serão apresentados por navegadores.
Para carregar um Applet Java em uma página HTML (HyperText Markup Language), devemos especificar sua utilização através da tag Applet. Abaixo segue
um trecho de código que exemplifica essa afirmação. Um detalhe que temos de nos
atentar consiste na necessidade da compilação do código Applet como as demais
classes Java apresentadas até aqui, uma vez que é utilizado o arquivo .class.
<HTML>
<HEAD>
<TITLE>Primeiro Programa Applet</TITLE>
</HEAD>
<BODY>
<applet code= MetodosApplet.class width=”220” height=”100”>
</applet>
</BODY>
</HTML>
Pronto, agora que já sabemos como apresentar nosso Applet em um navegador, iremos apresentar um programa simples que escreverá na página
HTML a mensagem “Olá Mundo !!!”. O código a seguir ilustra a classe responsável por isto.
import java.awt.Graphics;
public class PrimeiroApplet extends Applet{
public void paint(Graphics g){
g.drawString(“Oi Mundo!!!”, 50, 25);
}
}
65
Conforme já mencionado, após a criação de nossa classe Applet, é necessário que o código de nossa classe seja compilado, para que o Applet inserido
no navegador possa funcionar corretamente. Para compilar nossa classe é necessário digitar o comando javac, conforme é realizado com qualquer classe.
javac PrimeiroApplet.java
A partir disso, será gerado um arquivo PrimeiroApplet.class que é um bytecode da Applet. Para a apresentação de nossa nova classe em um navegador,
o byte-code deve ser adicionado a um código HTML como demonstrado no
exemplo de código inicial desta seção.
Alguns navegadores não suportam Java e obviamente não conseguem disponibilizar a visualização do Applet inserido no código HTML de uma página.
Porém, existe um programa denominado appletviewer, que é disponibilizado
pela JDK, fazendo com que apenas a área onde o Applet é executado, seja
apresentada. O trecho de código a seguir exemplifica a utilização desta ferramenta, que deve indicar qual arquivo html deve ser apresentado.
appletviewer index.html
Este aplicativo é, na maioria das vezes, utilizado para verificar a consistência dos Applets, antes que a página seja disponibilizada, uma vez que a maioria dos navegadores atuais já possui plugins para suporte a tecnologia Applet.
5.3 Restrições das Applets
Vimos que as Applets podem ser incorporadas às páginas WEB, mas,
como qualquer código, deve-se ficar atento para que nenhuma classe Applet desconhecida possa prejudicar o sistema onde está sendo executada, ou seja, apagando ou acessando informações indevidas armazenadas
dentro do sistema (DEITEL, 2005).
Para isso, há um sistema de monitoramento de segurança denominado
applet security manager, que causa uma interrupção no applet, caso este tente
violar as regras de segurança determinadas. Sendo assim, é comum dizer que
as Applets são como crianças que estão sempre sob a vigilância de um adulto.
Algumas restrições impostas aos applets que são (DEITEL, 2005):
66
1.Programas localmente instalados não podem ser executados;
2.Exceto no host de origem não há comunicação com outros hosts;
3.Não há permissão de leitura e escrita no sistema de arquivo local;
4.Só podem obter informações do sistema sobre a JVM a qual operam.
Na maioria das vezes, não é necessário se preocupar com estes
detalhes, visto que as classes Applets são utilizadas apenas para a
disponibilização e apresentação de conteúdo de outra classe, sendo
que essa então realiza os acessos necessários, evitando que a classe
Applet desempenhe diretamente estas funções.
5.4 Parametrizando Applets
Assim como programas podem receber argumentos vindos das linhas de comando, fazendo alterações que os ajustem com esses parâmetros, as Applets
podem ser parametrizadas, para que possam ter uma maior versatilidade de sua
utilização, possibilitando a criação de um código mais genérico (DEITEL, 2005).
Como vimos anteriormente, as applets não são executadas através de
uma linha de comando e sim através de um arquivo HTML, que é lido pelo
navegador ou pelo appletviewer. A passagem de parâmetros, neste caso,
pode ser realizada com o uso da tag especial <APPLET> em conjunto com a
tag denominada <PARAM>.
Essa tag possui alguns parâmetros dos quais dois são aplicáveis unindo-os
a tag <APPLET> que são o NAME e o VALUE. Assim sendo, um determinado
parâmetro especificado, cujo nome está definido no campo NAME e cujo valor está definido no campo VALUE, se encontra disponível para ser utilizado.
A quantidade de parâmetros não é predefinida em uma Applet, podendo
ser utilizados quantos forem necessários desde que uma ou mais tags <PARAM> sejam incluídas dentro das tags <APPLET> e </APPLET>. Estes são então
lidos pela Applet Java. O exemplo a seguir demonstra esse tipo de código.
67
...
<applet code=”param.class” height=115 width=115>
<param name=”cor” value=”FFF000”>
<param name=”valor” value=”10”>
</applet>
...
A idéia principal dos parâmetros consiste na troca de informação com as
classes applets. Para tanto, com a utilização do método getParameter(), é possível se passar valores para a tag HTML <PARAM>. Com isso, é possível recuperar valores de parâmetros especificados como argumentos. O código a seguir
exemplifica a afirmação sendo utilizado o método em uma classe Applet.
// processamento dos parâmetros
...
String aux = getParameter(“corFundo”);
if (aux!=null){
setBackground(new Color(Integer.parseInt(aux, 16)));
}
aux = getParameter(“valorInicial”);
if (aux!=null){
tfEntrada.setText(aux)
}
...
Se o método getParameter() retornar um valor null, significa que o nome especificado não contém valor definido ou o parâmetro especificado é nulo. No exemplo
acima, os valores recuperados têm como retorno objetos do tipo String, sendo que,
logo após, o valor é convertido para o tipo desejado, é exigido pelo método setBackground(), no caso, o parâmetro corFundo teve seu valor de String recuperado, é logo
após convertido para um valor inteiro com base hexadecimal, ao passo que o parâmetro valorInicial é utilizado diretamente para apresentação por um componente.
5.5 Applets que são Aplicações
Dependendo de como os programas Java forem carregados, eles podem
se portar como aplicativos ou como Applets. Portanto, quando adicionamos
o método executável (main) a uma aplicação Applet, este está realizando o
tratamento para criar uma aplicação (DEITEL, 2005).
As aplicações feitas através de applets são úteis em situações em que
devem ser utilizadas tanto localmente quanto em conexões de rede. Agora no
sentido inverso é de certa forma possível, embora algumas restrições impostas
a este funcionamento sejam feitas.
68
5.6 O Contexto das Applets
Uma das principais e mais importantes características de um Applet é a forma
como ele interage com o navegador no qual está sendo executado, obtendo informações sobre o ambiente em que são executados utilizando-se da interface AppletContext, cujos métodos são relacionados na tabela a seguir (DEITEL, 2005).
Método
Descrição
getApplets()
Lista as applets contidas na exibição do
documento.
getAudioClip(URL)
Um clip de áudio da URL solicitada é
retornado.
getApplet(String)
Retorna uma referência para a tag <APPLET>
no documento atual.
getImage(URL)
A URL retorna uma imagem.
showDocument(URL)
Requisita ao navegador que substitua a página
atual pela contida na URL dada.
showStatus(String)
A string será fornecida na linha de status ou
na janela.
showDocument(URL,
String)
Requisita ao navegador que substitua a página
atual pela contida na URL dada na janela
especificada como alvo.
Tabela 1 - Métodos da Interface AppletContext
Nos métodos citados acima, pode-se verificar que suas funcionalidades
apresentadas auxiliam no trabalho com Applets, conseguindo executar até
mesmo referências a outras classes Applet, além possibilitar o trabalho com
imagens, áudio e vídeos dentre outros.
Um dos métodos mais importantes em uma classe Applet é o showDocument(), no qual pode-se gerenciar um navegador, para criar novas janelas ou
mesmo exibir um novo documento em uma janela já existente. Assim finalizamos nossa 5ª aula, com este importante conceito da tecnologia Java.
Síntese da aula
Nesta aula, foram apresentados os conceitos de Applets, bem como o seu funcionamento para criação de programas, através de páginas WEB, a forma como é feita
a programação do código para que esses Applets possam funcionar nos documentos HTML e alguns métodos para auxiliar na criação de Applets mais sofisticadas.
69
Atividades
1. Um Applet consiste em uma classe com características e comportamentos
que a diferem das demais classes conhecidas. Dentre os comportamentos de um
Applet, existe o ciclo de vida. No que consiste o clico de vida de um Applet?
2. Uma classe Applet, conforme pôde ser observado em nossa aula, pode ser executado dentro de uma página HTML que pode conter parâmetros. Quais são os
métodos que possibilitam a interação entre a claase Applet e a página HTML?
Na atividade 1, uma classe Applet possui um ciclo de vida pré-determinado, que deve ser obedecido e definido pelos métodos init(), start(), paint(),
stop() e destroy(). No caso, um Applet tem um processo que é iniciado com os
métodos init() e start(), processado com paint() e stop() e logo após este tem um
fim com o método destroy(), sendo que este não necessita ser explicitamente
invocado. Já na atividade 2, os métodos que disponibilizam uma interface
entre a Applet e a página HTML consistem nos métodos getParameter() e setParameter(), sendo que o primeiro é o responsável por obter o conteúdo de
um parâmetro definido em uma tag HTML e o segundo por estabelecer valores
que podem ser utilizados pela página.
Referências
DEITEL, Harvey M. Java: como programar. 6. ed. São Paulo: Pearson Prentice
Hall, 2005.
Na próxima aula
Apresentaremos os conceitos relacionados à criação de relatórios em aplicações Java com a utilização do framework jasperReport, bem como a apresentação de ferramentas que auxiliem neste processo.
70
Aula 6
Relatórios
Objetivo
• criar relatórios de aplicações Java utilizando ferramentas livres.
Pré-requisitos
Para começarmos os estudos sobre a geração de relatórios, é importante
conhecer os conceitos de programação Java, vistos nas aulas anteriores, bem
como conceitos relacionados à XML (eXtensible Markup Language). Esse conhecimento é importante para uma melhor compreensão das aulas desta aula.
Introdução
Todo sistema é criado com a finalidade de organizar, guardar e recuperar
dados. Um de seus objetivos é a geração de relatórios, contendo parte desses
dados armazenados no sistema para um determinado fim específico, seja ele
de gerência, auditoria ou apenas de conferência.
Apesar de sua importância e sua presença em, basicamente, todos os
sistemas computacionais, muitas vezes este módulo do sistema não tem seu
devido reconhecimento.
Em resumo, podemos dizer que o processo de geração de relatórios consiste na criação de um layout e na seleção dos dados que irão compor o corpo
do relatório. Essa necessidade de criação de relatórios fez com que surgissem
diversas ferramentas especializadas neste assunto, como a ferramenta proprietária Crystal Reports e as ferramentas de código aberto JasperReports e
iReport que serão tratadas nesta aula.
71
Agora que já tivemos a idéia da finalidade dos relatórios, vamos ao que
interessa! Começaremos a nossa aula falando sobre o JasperReports.
6.1 JasperReports
Como dissemos anteriormente, JasperReports é uma das ferramentas (framework) de código aberto (open-source) que nos auxilia na criação de relatórios.
Como não podia deixar de ser, essa ferramenta é escrita em Java e alguns de
seus pontos fortes são a organização e apresentação de conteúdo, gerando de
forma dinâmica seus relatórios em vários formatos: XML, PDF, XLS, HTML e CSV
(HEFFELFINGER, 2006). E como todos nós já sabemos, podemos utilizá-la em
qualquer aplicativo feito em Java, indo de desktop, WEB ou mesmo distribuído.
Saiba mais
Um framework consiste em uma estrutura de software muito utilizada
na linguagem Java. Ele consiste em um arcabouço de soluções,
disponibilizando bibliotecas ou mesmo softwares que acelerem o processo
de desenvolvimento de aplicações. Estes se diferenciam das bibliotecas de
classes convencionais fornecidas, pois, diferentemente destas, os frameworks
fornecem uma solução para uma família de problemas em comum, com
pouco esforço, aumentando o poder de reutilização de código.
6.1.1 XML a chave do funcionamento
Aqui, pessoal, é onde começamos o processo de criação dos nossos relatórios. Logo, temos que compreender como o processo funciona, e a Figura 1
tem como objetivo nos mostrar como se dá este processo.
Figura 1 - JasperReports - Processo para gerar um relatório
72
Você deve estar se perguntando: “Qual o objetivo do arquivo XML?”. Calma, iremos falar sobre isso agora.
Na introdução da aula falamos que o processo de criação de relatórios consistia basicamente em definir um layout e filtrar (selecionar) os dados que irão fazer
parte de seu conteúdo. Pois bem! O arquivo XML é quem vai definir tanto o layout
quanto a localização e os nomes dos campos dos dados a serem preenchidos.
Este processo se dá por meio das tags, não as tags de Java, mas as tags
do XML, que, por sua vez, obedecem a um padrão de estrutura e vocabulário
com suas restrições, cujos valores são declarados em um arquivo chamado
jasperreports.dtd (HEFFELFINGER, 2006).
A XML é uma metalinguagem utilizada para intercâmbio de informações
e criação de estruturas de arquivos. Dessa forma, sugerimos a leitura
de obras relacionadas ao assunto e que colaborem com o seu
aprendizado. Segue uma boa referência: http://www.w3.org/XML/.
Com o uso do XML, o layout poderá ser definido com formas geométricas, imagens e textos padronizados estaticamente e/ou principalmente dinamicamente, através dos campos definidos para tal fim, tendo o seu conteúdo buscado em uma base de
dados. Todos esses elementos contêm uma localização específica dentro do relatório.
Após a fase de definição dos elementos que compõem o layout do arquivo XML,
ele precisa passar por uma compilação que gerará um arquivo de formato .jasper,
ou seja, o código Java ali contido será verificado e compilado neste processo.
As etapas de geração de relatório são representadas utilizando diferentes
objetos do JasperReports, que serão apresentadas na Tabela 5.1.
OBJETO
DESCRIÇÃO
JasperDesign
Objeto de definição do relatório é criado a partir do
template XML.
JasperReport
Objeto de compilação do JasperDesign, é criado após o
processo de compilação e verificação do layout do relatório.
JasperPrint
Objeto final, é criado a partir de um JasperReport e
contém o relatório preenchido.
Tabela 5.1 – Objetos do JasperReports para criação de relatórios
73
6.1.2 Dados, a alma do conteúdo
Nesta parte, pessoal, trataremos do preenchimento com os dados necessários para a criação do conteúdo do relatório. Na maioria esmagadora das
vezes, esses dados são recuperados de algum SGBD (Sistema Gerenciador de
Banco de Dados), mas, também, podem ser recuperados de arquivos XML.
Quando queremos recuperar os dados de um SGBD relacional, utilizamos
como padrão a linguagem SQL, conforme apresentado na 3ª aula, para realizar e retornar os dados da consulta, conforme foi visto na aula 4. Podemos
inserir o código de consulta SQL ao código do XML ou utilizar uma classe Java
já definida para esse fim, cujo resultado irá gerar um objeto ResultSet, que será
lido pelas classes do Jasper, fazendo com que o relatório seja preenchido.
Outro ponto forte do JasperReports é o suporte a muitos tipos de fonte de
dados (datasources). O responsável por isso é a interface JRDataSource. JRResultSetDataSource é uma implementação padrão para objetos ResultSet para a
interface JRDataSource (HEFFELFINGER, 2006). O ResultSet deve conter todas
as colunas que serão mapeadas para seus campos correspondentes no relatório, quando este for à fonte de dados.
6.1.3 Campos, Variáveis, Parâmetros e Expressões
Dando seqüência ao conteúdo, falaremos sobre o que são os campos,
variáveis, parâmetros e expressões, para a geração de relatórios.
Os campos (field) servem para entrada direta de dados no relatório, a coluna referenciada deve conter o mesmo nome do campo do relatório (HEFFELFINGER, 2006). Como exemplo, pegaremos os dados da coluna ‘Matricula’ com o
tipo ‘Integer’ de uma tabela ‘aluno’. Para mapearmos esse dado, devemos definir, no arquivo XML, um campo com o nome ‘matricula’, como segue abaixo:
...
<field name=“Matricula” class=“java.lang.Integer”/>
...
Para a simplificação do projeto do relatório, utilizamos as variáveis (variable) e através delas podemos definir apenas uma expressão que será repetida
freqüentemente e, quando se fizer necessário, no decorrer do design do relatório. As variáveis podem referenciar, internamente, tipos de cálculos como
74
count (realiza uma contagem de itens), sum (realiza a soma de itens), average
(realiza a média aritmética de itens) entre outros. Seguindo o exemplo anterior, poderíamos utilizar as variáveis para realizar o cálculo da média das
notas dos alunos como é demonstrado abaixo.
...
<variable name=“ValorMedia” class=“java.lang.Double” calculation= “Average”>
<variable expression> ${Nota} </variable expression>
</variable>
...
A ordem de declaração de variáveis no relatório tem muita importância,
pois, em uma expressão, uma variável pode referenciar outras variáveis, desde que elas tenham sido pré-definidas.
Quando usamos variáveis para a realização de cálculos, podemos definir quando elas devem ser reinicializadas. Para isso, existem vários níveis de
reinicialização, que são apresentadas na Tabela 5.2.
NÍVEIS
DESCRIÇÃO
None
Este nível indica que a variável nunca é inicializada com o
valor inicial da expressão, ela apenas guarda o valor obtido
pela expressão principal;
Report
Este nível indica que a variável somente será inicializada no inicio
do relatório e terá seu valor acumulado até o término do mesmo;
Page
Este nível indica que a variável será inicializada no início de
cada página do relatório;
Column
Este nível indica que a variável será inicializada no início de
cada coluna;
Group
Este nível indica que a variável será inicializada quando o
grupo especificado pelo atributo de resetGroup for modificado;
Default
O valor padrão do nível é Report;
Tabela 5.2 – Níveis de reinicialização de variáveis (FURUTANI, 2007)
A ferramenta também oferece variáveis pré-definidas para uso nas expressões regulares, sendo elas: PAGE_NUMBER, COLUMN_NUMBER, REPORT_
COUNT, PAGE_COUNT, COLUMN_COUNT, GroupName_COUNT.
Quando não podemos encontrar os dados na fonte de dados que estamos
usando para o preenchimento do relatório, usamos os parâmetros (parameter)
para nos auxiliar nesse objetivo, assim temos.
75
...
<parameter name=“Titulo” class= “java.lang.String”/>
...
Então passados, através da classe HashMap, via código Java, conforme
é demonstrado a seguir.
...
Map param = new HashMap( );
param.put( “Aluno”, “Vinny Coelho Frota” );
...
Outra forma muito importante de utilização de parâmetros é no uso do SQL
do relatório, para obtermos dados em bases de dados, tendo como exemplo.
...
SELECT * FROM aluno WHERE matricula=$P{Matricula}
...
Assim, como resultado desta consulta, os dados contidos no relatório serão apenas aluno cuja matrícula foi passada por parâmetro.
Para podermos especificar o conteúdo de campos de texto, que freqüentemente são usados, utilizamos as expressões (expression) e essas expressões
são feitas em código Java e, normalmente, contêm em sua sintaxe campos,
variáveis e parâmetros de relatório, veja este exemplo.
6.1.4 Layout
...
<textFieldExpression>
“Sr.(a) ” + $F{Aluno} + “ seu pagamento está em atraso no valor de: R$ “
+ $V{ValorTotalDevedor} + “ referente à data de vencimento: “
+ (new SimpleDateFormat(“dd/MM/yyyy”)).format($F{DataVencimento})
+ “. Favor passar na secretaria.”
</textFieldExpression>
...
O layout do JasperReports, por motivos de melhor organização e definição
de seu design, está dividido em algumas áreas pré-definidas que chamamos
de seções, são elas: title, pageHeader, columnHeader, groupHeader, detail,
groupFooter, columnFoter, pageFooter, summary (FURUTANI, 2007).
A definição da posição do conteúdo do relatório é essencial para a criação do
mesmo, pois é ela quem representa a estrutura visual do documento gerado. Porém,
a criação de relatórios diretamente em XML não é uma tarefa simples e fácil, daí a
necessidade de ferramentas que auxiliem na criação de layout dos relatórios.
76
6.2 iReport
O iReport, uma ferramenta que automatiza e torna mais intuitiva a criação
dos layouts dos relatórios. Constituído de ambiemte gráfico, reune todos os recursos da biblioteca Jasper para a criação de relatórios apresentados até aqui,
auxiliando na construção de layouts mais elaborados e de maneira rápida, pois
evita que o usuário perca tempo escrevendo linhas de código em XML.
O iReport está disponível para download gratuitamente na internet. Este é
disponibilizado de duas formas: a primeira consiste em um arquivo para descompactação, e a segunda um executável. Para tanto, baixe o arquivo que mais
lhe convier no endereço: http://www.jasperforge.org/sf/projects/ireport.
Existem diversas publicações que auxiliam o processo de instalação do
iReport disponíveis na WEB, mas não nos apegaremos aos detalhes de
instalação dessa ferramenta. Um detalhe que dever ser citado é que,
assim como para o funcionamento de nossos exemplos em Java, é
necessário que estejam definas as variáveis de ambiente, uma vez que
o iReport consiste em um programa Java.
Uma vez que todo o processo de instalação tenha acontecido da maneira desejada, teremos como resultado da execução do iReport a tela
apresentada na Figura 2.
Figura 2 - Tela inicial do iReport
77
Familiarize-se com todos os componentes desta ferramenta e, assim,
construa seu layout conforme a necessidade. Todo código XML é gerado
automaticamente pela ferramenta, ela ainda traz diversos atalhos para
testes, como compilação e visualização de como está ficando o relatório
a ser gerado.
Saiba mais
Existem outras ferramentas com o mesmo objetivo do iReport, mas estas não
fazem parte do escopo desta aula. Fica aqui a sugestão para que sejam
realizados estudos correlatos, a fim de se ter uma visão geral destas e, com
isto, definir qual mais satisfaz as necessidades de seu projeto. Segue uma
lista delas: iText, JFreeReports, OracleReports, JFreeStudio e FOP.
Com isso, a ferramenta acelera, significativamente, o processo de desenvolvimento do relatório.
6.2.1 Fonte de Dados Suportadas
O iReport suporta diversos tipos de conexões para a recuperação de
dados para a construção de relatórios: conexões ODBC, JDBC, XML DataSource, JavaBeans Set DataSource, Custom DataSource e Empty DataSource. Sugerimos leituras complementares para conhecer essas fontes de dados
(HEFFELFINGER, 2006).
6.3 Um estudo de caso
Agora, iremos colocar a mão na massa, pessoal: vamos criar um relatório
que nossa aplicação irá executar. Para tanto, execute ou crie uma tabela com
a estrutura: ‘nome’ e ‘descricao’, e preencha sua tabela com dados, se necessário, adapte ao banco de dados que melhor lhe convier, porém note que, no
exemplo, essas mudanças devem ser refletidas. Apenas certifique-se de que
não ocorreram erros na criação.
Certo. Agora, crie, com a utilização do iReport, seu relatório com o layout,
conforme é demonstrado na Figura 3. Para tanto, familiarize-se com a ferramenta, acrescente novos elementos como Fields e Texts, para obter mais conhecimento dos elementos que a compõe.
78
Figura 3 - Criação do layout do relatório
Conforme já mencionado, um arquivo do iReport, quando salvo, consiste
em uma arquivo XML, com a extensão .jrxml. Este deve ser nomeado como curso.jrxml. Porém, nosso programa Java utiliza o arquivo .jasper. Certo. Então,
para isso, no próprio iReport compile o programa .jrxml e verifique que na
pasta onde foi salvo o arquivo jrxml foi criado também um arquivo jasper.
Agora, iremos criar nosso programa Java que irá realizar a chamada a nosso
relatório. Porém, como o iReport consiste em um framework externo devemos ter
acrescentado as bilbiotecas ao repositório java. Isto já deve ter sido realizado no
processo de instalação do iReport. Então transcreva o código abaixo e execute-o.
//Report.java
import java.awt.*;
import java.sql.*;
import java.util.*;
import com.mysql.jdbc.*;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.view.*;
public class Report extends Frame implements ActionListener{
public Report(){
super(“Relatórios”);
Button botao = new Button(“Relatório”);
add(botao);
setSize(200, 60);
addWindowListener(new Eventos());
}
79
// Cria método de conexão com o banco de dados
// da mesma forma como apresentado na aula 4
private static Connection getConnection() throws
ClassNotFoundException, SQLException
{
...
return con;
}
// método que cria o relatório
public void geraRelatorio() throws JRException, Exception
{
Connection con = getConnection();
Statement stm = (Statement) con.createStatement();
String query = “select * from Curso”;
ResultSet rs = (ResultSet) stm.executeQuery(query);
// implementação da interface JRDataSource para DataSource ResultSet
JRResultSetDataSource jrRS = new JRResultSetDataSource(rs);
// HashMap de parametros utilizados no relatório. Sempre instanciados
Map parameters = new HashMap();
// Preenche o relatório com os dados. Gera o arquivo curso.jrprint
JasperFillManager.fillReportToFile( “curso.jasper”, parameters, jrRS );
// Preenche o relatorio e o salva diretamente em arquivo PDF.
JasperRunManager.runReportToPdfFile(“curso.jasper”, parameters, jrRS);
/* Visualiza o relatório em formato PDF */
JasperViewer.viewReport( “curso.pdf”, false);
}
// método de execução
Report programa = new Report();
programa.setVisible(true);
}
// listener que reage ao evento
try {
geraRelatorio();
} catch (JRException e1) {
e1.printStackTrace();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
// Eventos da Janela
class Eventos extends WindowAdapter{
...
}
Se tudo correu como esperado, através do botão “Relatório”, realizamos a execução de nosso relatório. Adapte o exemplo para novos exemplos, utilize o iReport
e crie seus novos relatórios para seus programas. Assim, finalizamos nossa aula 6,
e esperamos que você já saiba criar suas aplicações gráficas com relatórios.
80
Síntese da aula
Nesta aula, foram apresentados os conceitos fundamentais do JasperReports para a elaboração e criação de relatórios práticos de aplicações Java
e a interação do JasperReports com o iReport. Foram expostôs as principais
características de como criar relatórios usando XML e recuperar dados de
SGBDs. Além disso, outro aspecto fundamental do Reports foi a ênfase na
criação do layout dos relatórios e seus tipos. Finalizando com os conceitos
da ferramenta gráfica open-source iReport e suas fontes de dados suportadas,
para geração dos relatórios.
Atividades
1. Porque o arquivo XML é tão importante para a criação de relatórios?
2. Quais as principais características do iReport? Explique.
Na atividade 1, sabemos que o arquivo XML é o responsável por gerenciar os dados que serão exibidos no relatório a ser gerado. Com o uso do
XML, o layout poderá ser definido com formas geométricas, imagens e textos,
através dos campos mapeados a uma base de dados ou datasource. Todos
esses elementos terão uma localização específica dentro do relatório.
Na atividade 2, as características do iReport é ser uma ferramenta open-source
que automatiza a criação dos arquivos XML e torna mais intuitivo a criação dos
layouts dos relatórios. Constituido de ambiemte gráfico, reune todos os recursos da biblioteca Jasper, para a criação de relatórios mais elaborados e de forma rápida, pois
evita que o usuário perca tempo escrevendo inúmeras linhas de código em XML.
Referências
FURUTANI, Roberto J. Como criar relatórios Java para Web com JasperReports e iReport. <http://www.furutani.eti.br/tutoriais/Mini-Tutorial_
Relatorios_Java_JasperReports_e_iReport.pdf> Acessado em 12 out. 2007.
HEFFELFINGER, David. JasperReports for Java Developers. Agosto, 2006.
81
Na próxima aula
Continuaremos com a apresentação dos fundamentos do paradigma de
Programação Orientada a Objetos, mencionando os conceitos de métodos
construtores e encapsulamento.
Anotações
82
Aula 7
Estudo de Caso
Objetivo
• utilizar todos os conceitos aprendidos durante toda a disciplina.
Pré-requisitos
Para esta aula é necessário que os conceitos apresentados no decorrer
desta disciplina tenham sido assimilados, e que estejam muito claro o conceito e orientação a objetos que foi visto na disciplina de Programação
anterior: eles serão utilizados na construção do estudo de caso, visando
a demonstrar que são de fundamental importância, para construção de
aplicações por um programador Java.
Introdução
Iremos, agora, criar um estudo de caso, no qual utilizaremos todos os conceitos apresentados em nossas aulas, relacionados ao processo de construção
de aplicações visuais com a linguagem Java, utilizando um banco de dados,
criando, assim, uma pequena aplicação.
83
7.1 Definição do problema
Como estamos no final de nossa disciplina, iremos agora utilizar todos os
conceitos apresentados, bem como relembrar outros que nos foram colocados
na aula passada. Para tanto, vamos criar uma aplicação que interage com um
banco de dados. Então vamos ao que interessa.
Nosso estudo de caso consiste na criação de uma pequena aplicação
para cadastro de cursos de uma universidade. Assim, utilizaremos a estrutura
de banco de dados criada na aula 6, na construção de relatórios. Para isso,
devemos definir uma tela inicial com um menu, no qual deverá ser oferecida
a possibilidade de abrir a tela de cadastro ou mesmo sair. A tela de cadastro
deve possibilitar que diversos cursos sejam acrescentados, com nome e descrição. Além disso, iremos acionar um relatório através de nossa aplicação.
7.2 Implementação do estudo de caso
Iniciaremos nosso estudo de caso criando uma classe que deriva da classe
Frame, no caso, será criada uma janela na qual iremos definir através de seu método construtor o tamanho e a localização da tela. Além disso, também definiremos o método executável, então, transcreva o código a seguir, salve-o e execute.
//AppCadastro.java
import java.awt.Frame;
super(“Aplicação de cadastro”);
setSize(600, 600);
}
//método executável
AppCadastro exec = new AppCadastro();
exec.setVisible(true);
}
}
Note que, em nosso método executável instanciamos um objeto da classe
que estamos construindo. Dessa forma, conseguimos visualizar os resultados
de nossa aplicação. Prosseguindo com nosso exemplo, defina, no mesmo arquivo, uma nova classe que será responsável por definir as funcionalidades da
janela, que serão acionados com os eventos sobre esta, no caso o listener.
84
//AppCadastro.java
import java.awt.*;
...
}
class EvtJanela extends WindowAdapter{
System.exit(0);
}
}
Verifique que apenas foram adicionados um import e a nova classe, ao
final da apresentada no exemplo anterior. Note que, ao invés de implementarmos a interface WindowListener, fazendo com que obrigatoriamente tivéssemos de declarar sete métodos, derivamos da classe WindowAdapter, sendo
que é declarado apenas o método que utilizaremos. Porém, é necessário que
este evento seja associado à janela, para tanto, acrescente o próximo código
ao método construtor. Neste, instanciamos, um listener, no caso um escutador
que é o responsável por reagir à interação dos usuários com a janela.
...
...
EvtJanela evt = new EvtJanela();
addWindowListener(evt);
}
...
}
...
Vamos agora definir nosso menu, sendo que neste definiremos dois itens,
para que sejam executadas as funcionalidades de acionar a tela de cadastro
e sair. Assim, como nos exemplos anteriores, transcreva as linhas de código a
seguir no método construtor.
...
...
MenuBar barraMenu = new MenuBar();
MenuItem itemCadastro = new MenuItem(“Cadastro de Curso”);
MenuItem itemSair = new MenuItem(“Sair”);
menuArquivo.add(itemCadastro);
barraMenu.add(menuArquivo);
setMenuBar(barraMenu);
}
...
}
...
85
Agora, precisamos definir o listener de nosso menu. Para tanto, devemos
mencionar que nossa classe AppCadastro implementa a interface ActionListener e, com isso nos obriga a também implementar o método ActionPerformed.
Então vamos a eles.
...
public class AppCadastro extends Frame implements ActionListener{
...
itemCadastro.addActionListener(this);
}
...
System.exit(0);
}
if(item.getLabel().equals(“Novo de Curso”)){
}
}
}
...
}
Continuamos nosso estudo de caso definindo os containers de componentes de nossa aplicação. Então vamos criar três painéis que serão nossas telas,
sendo que utilizaremos o gerenciador de layout CardLayout, para assim, termos o efeito de novas janelas que serão trabalhadas.
...
Panel geral;
...
Panel painelApp = new Panel();
Panel painelCadastro = new Panel();
painelApp.setBackground(SystemColor.control);
painelCadastro.setBackground(SystemColor.control);
geral = new Panel();
geral.add(painelApp,”J1”);
geral.add(painelCadastro,”J2”);
geral.setLayout(new CardLayout());
add(“Center”,geral);
}
...
...
CardLayout pilha = (CardLayout) geral.getLayout();
pilha.next(geral);
}
…
}
}
...
86
Criamos três painéis sendo que um consiste no mestre, denominado geral,
por meio do qual conseguimos acessar os demais, criando como mencionado o aspecto de janelas. O componente painelCadastro consiste em nosso
container que possuirá todos os demais campos, no caso outros componentes
para nosso cadastro. Então, ao final o método construtor adicione as linhas de
código a seguir descritas.
O efeito de janelas criado pela utilização de painéis é muito útil para
a construção de aplicações visuais. Porém, podem ser instanciadas
diversas classes que derivam da classe Frame, e realizando assim a
chamada, através do método setVisible(). Deve-se, antes de invocar
novas janelas, informar que a janela que está realizando a chamada não
é mais a janela ativa, isso com a utilização do método setEnable().
...
import
...
public
javax.swing.*;
class AppCadastro extends Frame{
...
Button salvar = new Button(“Salvar”);
Button limpar = new Button(“Limpar”);
Button report = new Button(“Relatório”);
Button sair = new Button(“Sair”);
...
painelCadastro.add(new Label(“Nome:”));
painelCadastro.add(new Label(“Descrição:”));
String[] colunas = {“NOME”, “DESCRIÇÃO”};
Object[][] conteudo = {{“”, “”}};
JTable tabela = new JTable(10,2);
tabela.setPreferredScrollableViewportSize(new Dimension(560, 120));
painelCadastro.add(new JScrollPane(tabela));
Panel painelButton = new Panel();
painelButton.add(salvar);
painelButton.add(limpar);
painelButton.add(sair);
painelButton.add(result);
painelCadastro.add(“South”, painelButton);
}
...
}
...
87
Com isso, temos nosso layout de nossa aplicação concluído, porém, ainda
temos de adicionar as funcionalidades aos eventos que nossos botões reagirão. Dessa forma, inicialmente iremos criar nosso método que irá realizar a
conexão com o banco de dados, abrindo espaço para que possamos criar
outros métodos para inserção de novos elementos.
...
import java.sql.*;
import com.mysql.jdbc.Connection;
...
...
...
}
public Connection connection() {
Connection connection = null;
String con =
“jdbc:mysql://localhost:3306/aula07?user=root&password=root”;
try {
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
} catch (InstantiationException e) {
} catch (IllegalAccessException e) {
}
try {
connection = (Connection) DriverManager.getConnection(con);
}
return connection;
}
}
...
Note que, em nosso método de conexão, utilizamos o driver jdbc para
o banco de dados MySql, porém, adapte a string de conexão para que seu
banco de dados, de forma que este seja acessado, possibilitando a inserção
e consulta a seu seus dados.
Geralmente é necessário que realizemos o import dos drivers de conexão
para um determinado banco de dados. Os SGBDs fornecem estas APIs
junto com sua distribuição. Desta forma, consulte o manual de seu
banco de dados e verifique o driver para conexão Java. Por exemplo,
realizamos o import da classe “com.mysql.jdbc.Connection”.
88
Levando a tona todo o conceito de orientação a objetos, criaremos
nosso “modelo” de um curso, no caso a classe Curso, com seus atributos e
métodos. Note que são disponibilizados os métodos get e set garantindo
que os atributos não são acessados diretamente. Então, transcreva a classe
Curso para dentro do arquivo.
//AppCadastro.java
...
...
}
...
}
class Curso {
private Integer id = new Integer(0);
private String nome = new String();
private String descricao = new String();
private public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
Nosso próximo passo consiste na criação dos métodos que serão responsáveis por incluir e consultar dados em nosso banco de dados. Com
isso, nos restara apenas fazer com que estes métodos sejam acionados por
eventos em nossos botões. Assim, transcreva o código abaixo para sua
classe e execute-a.
89
//AppCadastro.java
...
import java.sql.*;
import com.mysql.jdbc.ResultSet;
import com.mysql.jdbc.Statement;
...
Curso c = new Curso();
...
public void incluir(){
try {
Statement statement = connection().createStatement();
String sql = “Insert into Curso VALUES
(null, \’”+c.getNome()+
“\’, \’”+c.getDescricao()+”\’)”;
statement.executeUpdate(sql);
result.setText(“CURSO INSERIDO COM SUCESSO!”);
result.setText(“OCORRERAM ERROS NA INSEÇÃO!”);
}
}
public ResultSet consultar(){
ResultSet resultadoBanco = null;
String consulta = “Select * from Curso”;
try {
PreparedStatement comandoBanco =
connection().prepareStatement(consulta);
resultadoBanco = comandoBanco.executeQuery();
connection().close();
} catch (Exception Erro) {
result.setText(“OCORRERAM ERROS NA CONSULTA!”);
}
return resultadoBanco;
}
public void limpar(){
nome.setText(“”);
descricao.setText(“”);
}
}
Nos resta, ainda, gerar nosso relatório, conforme exemplificado na aula 6.
Utilizaremos o arquivo jasper desenvolvido nesta aula, e assim temos somente que
criar um método que execute a invocação de nosso relatório. Vamos ao que interessa: copie o código a seguir, conforme exemplificado, na classe AppCadastro.
Conforme exemplificado na aula 6, é interessante que seja utilizada
uma ferramenta para criação dos relatórios, pois, além de acelerar
todo o processo de desenvolvimento, evita um processo trabalhoso
manual e, com isso, surpresas na construção dos relatórios.
90
...
import
import
import
import
public
java.io.*;
net.sf.jasperreports.engine.*;
net.sf.jasperreports.engine.export.*;
net.sf.jasperreports.view.*;
class AppCadastro extends Frame implements ActionListener{
Panel geral;
...
}
...
...
}
public void gerarReport() {
try {
Connection con = connection();
String query = “Select * from Curso”;
JRResultSetDataSource jrRS = new JRResultSetDataSource(rs);
JRExporter jrpdf = new JRPdfExporter();
JasperPrint print;
OutputStream fos = null;
print = JasperFillManager.fillReport(“.\\reports\\Curso.jasper”,
null, jrRS);
fos = new FileOutputStream(“.\\reports\\Curso.pdf”);
jrpdf.setParameter(JRExporterParameter.OUTPUT_STREAM, fos);
jrpdf.setParameter(JRExporterParameter.JASPER_PRINT, print);
jrpdf.exportReport();
fos.close();
JasperViewer.viewReport(print);
} catch (IOException e) {
} catch (JRException e) {
}
}
}
...
Para que nosso código funcione, certifique-se que o arquivo Curso.
jasper está no “report” dentro do diretório em que nossa classe AppCadastro está. Como mencionado, iremos fazer com que nossos botões, assim que acionados, executem nossos métodos, e apresentem os resultados
na tabela. Então, assim como nos exemplos, copie o código e verifique
o resultado.
91
...
Panel geral;
...
salvar.addActionListener(this);
limpar.addActionListener(this);
report.addActionListener(this);
sair.addActionListener(this);
}
...
...
if(e.getSource()==salvar){
c.setNome(nome.getText());
c.setDescricao(descricao.getText());
incluir();
limpar();
}
if(e.getSource()==limpar){
limpar();
}
if(e.getSource()==report){
gerarReport();
}
if(e.getSource()==sair){
System.exit(0);
}
}
}
...
Chegamos ao fim de nosso estudo de caso. No quadro a seguir, é apresentado todo o código de nossa classe, auxiliando numa visão mais macro do
exemplo apresentado.
AppCadastro.java
//AppCadastro.java
import java.awt.*;
import java.io.*;
import java.sql.*;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.export.*;
import net.sf.jasperreports.view.*;
import com.mysql.jdbc.ResultSet;
import com.mysql.jdbc.Statement;
92
Button salvar = new Button(“Salvar”);
Button limpar = new Button(“Limpar”);
Button report = new Button(“Relatório”);
Button sair = new Button(“Sair”);
Panel geral;
Curso c = new Curso();
super(“Aplicação de cadastro”);
setSize(600, 285);
EvtJanela evt = new EvtJanela();
addWindowListener(evt);
MenuBar barraMenu = new MenuBar();
MenuItem itemCadastro = new MenuItem(“Novo de Curso”);
MenuItem itemSair =
new MenuItem(“Sair”, new MenuShortcut(KeyEvent.VK_R));
menuArquivo.add(itemCadastro);
barraMenu.add(menuArquivo);
setMenuBar(barraMenu);
itemCadastro.addActionListener(this);
Panel painelApp = new Panel();
Panel painelCadastro = new Panel();
painelApp.setBackground(SystemColor.control);
painelCadastro.setBackground(SystemColor.control);
geral = new Panel();
geral.add(painelApp,”J1”);
geral.add(painelCadastro,”J2”);
geral.setLayout(new CardLayout());
add(“Center”,geral);
painelCadastro.add(new Label(“Nome:”));
painelCadastro.add(new Label(“Descrição:”));
String[] colunas = {“NOME”, “DESCRIÇÃO”};
Object[][] conteudo = {{“”, “”}};
JTable tabela = new JTable(conteudo, colunas);
tabela.setPreferredScrollableViewportSize(new Dimension(560,120));
painelCadastro.add(new JScrollPane(tabela));
Panel painelButton = new Panel();
painelButton.add(salvar);
painelButton.add(limpar);
painelButton.add(report);
painelButton.add(sair);
painelButton.add(result);
painelCadastro.add(“South”, painelButton);
salvar.addActionListener(this);
limpar.addActionListener(this);
report.addActionListener(this);
sair.addActionListener(this);
}
93
AppCadastro exec = new AppCadastro();
exec.setVisible(true);
}
System.exit(0);
}
CardLayout pilha = CardLayout) geral.getLayout();
pilha.next(geral);
}
}
if(e.getSource()==salvar){
c.setNome(nome.getText());
c.setDescricao(descricao.getText());
incluir();
limpar();
}
if(e.getSource()==limpar){
limpar();
}
if(e.getSource()==report){
gerarReport();
}
if(e.getSource()==sair){
System.exit(0);
}
}
public void gerarReport() {
try {
Connection con = connection();
String query = “Select * from Curso”;
JRResultSetDataSource jrRS =
new JRResultSetDataSource(rs);
JRExporter jrpdf = new JRPdfExporter();
JasperPrint print;
OutputStream fos = null;
print = JasperFillManager.fillReport
(“.\\reports\\Curso.jasper”, null, jrRS);
fos = new FileOutputStream(“.\\reports\\Curso.pdf”);
jrpdf.setParameter(JRExporterParameter.OUTPUT_STREAM,fos);
jrpdf.setParameter(JRExporterParameter.JASPER_PRINT,print);
jrpdf.exportReport();
fos.close();
JasperViewer.viewReport(print);
} catch (IOException e) {
} catch (JRException e) {
}
}
94
public void incluir(){
try {
Statement statement =
Statement) connection().createStatement();
String sql = “Insert into Curso VALUES (null,
\’”+
c.getNome()+”\’, \’”+
c.getDescricao()+”\’)”;
statement.executeUpdate(sql);
result.setText(“CURSO INSERIDO COM SUCESSO!”);
result.setText(“OCORRERAM ERROS NA INSEÇÃO!”);
}
}
public void consultar(){
ResultSet resultadoBanco = null;
String consulta = “Select * from Curso”;
try {
PreparedStatement comandoBanco =
connection().prepareStatement(consulta);
resultadoBanco = (ResultSet)comandoBanco.executeQuery();
connection().close();
} catch (Exception Erro) {
result.setText(“OCORRERAM ERROS NA CONSULTA!”);
}
}
public void limpar(){
nome.setText(“”);
descricao.setText(“”);
}
public Connection connection() {
Connection connection = null;
try {
Class.forName(“com.mysql.jdbc.Driver”).newInstance();
} catch (InstantiationException e) {
} catch (IllegalAccessException e) {
}
try {
connection = (Connection) DriverManager.getConnection
(“jdbc:mysql://localhost:3306/universidade?user=root&password=
root”);
}
return connection;
}
}
System.exit(0);
}
}
95
class Curso {
Integer id = new Integer(0);
String nome = new String();
String descricao = new String();
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
Se tudo ocorreu como o esperado, teremos, como resultado final, nossa
aplicação, na qual poderemos realizar um novo cadastro, bem como gerar o
relatório destes cadastros.
Assim finalizamos nossa 7ª aula e logo nossa disciplina. Esperamos que
todos tenham tirado o máximo de proveito e que agora todos sejam capazes
de criar programas visuais, utilizando a biblioteca AWT, bem como gerar relatórios. Boa sorte a todos!
Síntese da aula
Nesta aula, aplicamos todos os conceitos e componentes apresentados durante esta aula, além de utilizar o paradigma de orientação a objetos, criando
um estudo de caso, no qual pode ser realizado o cadastro em um banco de
dados, geração de relatório e trabalhar com diversas janelas e componentes,
fixando todo o conhecimento adquirido e alicerçando a idéia geral, para que
novas aplicações possam ser construídas.
96
Atividades
1. Conforme utilizado em nosso estudo de caso, como pode ser realizado o
processo de navegação entre painéis em uma aplicação visual Java?
2. Assinale a alternativa incorreta, referente aos componentes gráficos apresentados em nosso estudo de caso.
a) A classe Panel consiste em uma classe do tipo container.
b) P
or meio da classe Frame, é possível criar diversas janelas para
aplicações visuais.
c) O
componente Button é o responsável por executar as funcionalidades
do sistema.
d) As classes TextField e TextArea permitem o trabalho com textos.
Na atividade 1, é possível se realizar todo o processo de navegação entre
painéis, utilizando o gerenciador de layout CardLayout, e com o auxilio de
um listener reagir a eventos e efetuar a mudança entre os painéis com a invocação do método next() ou after(). É válido relembrar que pode se trabalhar
com outras janelas, por meio da instanciação de diversas classes derivadas
da classe Frame. Na atividade 2, se você respondeu o item (c), parabéns,
você acertou. No caso o botão, é apenas utilizado para passar ao sistema
operacional uma mensagem de que um evento foi realizado, não executar ou
mesmo fazer a chamada a uma funcionalidade do sistema, sendo que todo
o comportamento deve ser implementado nos métodos oriundo dos listeners
que são implementados. O item (a) está correto, uma vez que a classe Panel
deriva da classe Container. O (b) também está correto, uma vez que por meio
da classe Frame podemos criar diversas janelas. E, finalmente, o item (d) está
correto, já que ambos os componentes trabalham com textos.
Referências
Hall, 2005.
Érica, 2005.
97
MANZANO, José Augusto Navarro Garcia; COSTA JR., Roberto Affonso da.
Java 2: programação de computadores. São Paulo: Érica, 2006.
THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo:
Érica, 2002.
Anotações
98

Apostila Programação 3º Período.

Transcrição

Documentos relacionados

Houve um problema com o certificado digital do nosso

Programação III

Vídeo captura utilizando Java e DirectX Introdução

CONFIGURAÇÕES DO INTERNET EXPLORER E DO JAVA PARA

Introdução à Java - Professor Baesse

WILLIANS MARTINS DE MORAIS Rua: Estrada do Morro grande

Batik de Java - Museu da Marioneta

Núcleo Desenvolvimento

Lista de Exercícios 2 Curso de Java Básico

Contato com a imprensa: Capital Informação