Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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,
Apresentação
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.
Diretor Presidente
Luiz Carlos Borges da Silveira
Diretor Executivo
Luiz Carlos Borges da Silveira Filho
Objetivos
• Apresentar conceitos básicos da linguagem de programação Java para
programação visual.
Plano de Ensino
• Proporcionar a compreensão aos alunos sobre a utilização de banco de da-
dos em aplicações visuais utilizando componentes e conceitos de conexão.
Conteúdo programático
• Componentes visuais básicos
• Label
• Button
• TextField
• Pane
• TextArea
• Choice
• List
• Checkbox
• CheckboxGroup
• Menu
• Tratamento de eventos
• Gerenciamento de layouts
• Applets
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 6 – Relatórios................................................................................ 71
Sumário
Aula 1
Programação Visual em Java
Objetivo
Pré-requisitos
Introdução
“
interfaces gráficas um sucesso. Pela utilização de componentes visuais, é pos-
sível que usuários interajam por meio de operações realizadas pelo teclado
A linguagem 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 interes-
Java
santes ao usuário conforme demonstrado nas aulas finais do módulo anterior.
disponibiliza
duas Estes componentes também conhecidos como GUI componentes, são elementos
bibliotecas que compõem uma interface GUI. Segundo Deitel (2005), um componete GUI é:
para a
construção um objeto pelo qual o usuário interage através do mouse, do te-
de interfaces clado ou outra forma de entrada, como reconhecimento de voz.
gráficas,
A linguagem Java disponibiliza duas bibliotecas para a construção de
utilizando
interfaces gráficas, utilizando componentes GUI. A primeira consiste na uti-
componentes lização da biblioteca Swing, vista anteriormente, com a implementação de
GUI.” aplicações simples. A outra biblioteca e que será tema de nossos estudos nesta
aula, consiste na biblioteca AWT (Abstract Window Toolkit) que é disponibi-
lizada 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.
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.
// Classe PrimeiroExemplo.java
import java.awt.*;
Com isso, torna-se possível criar aplicações gráficas que utilizem os com-
ponentes GUI da biblioteca AWT. Então, para que possamos criar efetivamen-
te uma aplicação, é interessante que sejam conhecidos quais são os compo-
nentes 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).
// FrameExemplo.java
import java.awt.*;
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 Ma-
chine, para conseguirmos finalizar nossa janela. Então vamos tornar nosso se-
gundo exemplo mais interessante: é necessário que sejam construídos métodos
que processem os eventos que irão reagir à interação com a janela.
// FrameExemplo.java
import java.awt.*;
import java.awt.event.*;
// metodo construtor
public FrameExemplo (){
super(“Titulo: Janela Exemplo”);
setSize(50, 100);
setLocation(100, 100);
addWindowListener(this);
}
// metodo executavel
static public void main(String args[]){
FrameExemplo janela = new FrameExemplo();
janela.setVisible(true);
}
// 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){}
}
// FrameExemplo.java
import java.awt.*;
import java.awt.event.*;
// metodo construtor
public FrameExemplo (){
super(“Titulo: Segundo Exemplo”);
setSize(50, 100);
setLocation(100, 100);
addWindowListener(this);
}
// metodo executavel
static public void main(String args[]){
FrameExemplo janela = new FrameExemplo();
Label texto = new Label(“Novo Texto!”);
janela.add(texto);
janela.setVisible(true);
}
...
}
Note que no exemplo apenas criamos uma instância da classe Label, denomi-
nada texto e, com a utilização de seu construtor, definimos o texto a ser apresenta-
do 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.
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.
// FrameExemplo.java
import java.awt.*;
import java.awt.event.*;
Neste exemplo, podemos notar que, assim como na janela, na qual defini-
mos qual é o seu listener, que será o responsável por receber e tratar as men-
sagens, 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 interfa-
ce 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 compo-
nentes na janela. Retornaremos a este assunto na nossa 3ª aula.
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.
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.
// FrameExemplo.java
import java.awt.*;
import java.awt.event.*;
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
Síntese da aula
Atividades
Referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice
Hall, 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
Anotações
Objetivo
Pré-requisitos
Introdução
//NovaJanela.java
import java.awt.*;
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);
janela.setVisible(true);
}
}
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.
// NovaJanela.java
import java.awt.*;
import java.awt.event.*;
public NovaJanela() {
super(“TextArea”);
setSize(300, 300);
texto = new TextField(20);
texto.addActionListener(this);
// NovaJanela.java
import java.awt.*;
import java.awt.event.*;
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.
//Crie sua janela e seu painel conforme demonstrado nos exemplos anteriores
import java.awt.*;
import java.awt.event.*;
//Classe JanelaCheck
import java.awt.*;
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);
}
Diversos Checkboxs podem ser criados, sem que exista referência entre
estes componentes; para tanto, quando isto é necessário, utilizamos uma ins-
tância da classe CheckboxGroup para que seja realizado um agrupamento
de componentes Checkbox.
//Classe JanelaCheck
import java.awt.*;
public JanelaCheck() {
...
grupo = new CheckboxGroup();
checkCorreio = new Checkbox(“Correios”,grupo,true);
checkEmail = new Checkbox(“Email”,grupo,false);
...
}
...
}
//metodo executável
public static void main(String[] args) {
JanelaMenu janela = new JanelaMenu();
janela.setVisible(true);
}
//métodos listeners
public void windowClosing(WindowEvent e){
System.exit(0);
}
...
public void actionPerformed(ActionEvent e) {
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);
}
}
}
}
...
//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);
...
...
public void actionPerformed(ActionEvent e) {
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);
}
}
}
...
...
new MenuItem(“Sair”, new MenuShortcut(KeyEvent.VK_R));
...
Síntese da aula
Atividades
Referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice
Hall, 2005.
FLANAGAN, David. Java: o guia essencial. 5. ed. Porto Alegre. Bookman, 2006.
Na próxima aula
Anotações
Objetivos
Pré-requisitos
Introdução
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 even-
tos, 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.
// GerenciadorLayout.java
import java.awt.*;
import java.awt.event.*;
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 exem-
plo anterior, substituindo pelo código no quadro a seguir e execute o programa.
// GerenciadorLayout.java
import java.awt.*;
import java.awt.event.*;
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, sen-
do 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
// GerenciadorLayout.java
import java.awt.*;
import java.awt.event.*;
// método construtor
public GerenciadorLayout() {
super(“Janelas”);
setSize(250, 100);
// Painel Múltiplo
windows = new Panel();
windows.setLayout(new CardLayout());
windows.add(new Label(“Primeiro Painel”), “Janela2”);
windows.add(painel1, “Janela2”);
add(“Center”, windows);
}
3.1.5 GridBagLayout
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 quanti-
dade 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.*;
import javax.swing.*;
Container c = this.getContentPane();
this.setSize(600,600);
}
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.
Assim como vimos em diversos exemplos até aqui, os eventos ocorrem quan-
do existe uma interação dos usuários por meio de operações com o mouse (pres-
sionar um botão ou arrastar) ou através do teclado (pressionando alguma tecla).
Interface ou
Evento Métodos
Adaptador
componentMoved
ComponentListener
ComponentEvent componentHidden
ComponentAdapter
componentResized
ContainerListener componentAdded
ContainerEvent
ContainerAdapter componentRemoved
FocusListener focusGained
FocusEvent
FocusAdapter focusLost
ItemEvent ItemListener itemStateChanged
keyPressed
KeyListener
KeyEvent keyReleased
KeyAdapter
keyTyped
mousePressed
MouseListener mouseReleased
MouseAdapter mouseEntered
MouseEvent MouseMotionListener mouseExited
MouseMotionAdapter mouseClicked
mouseDragged
mouseMoved
// GerenciadorLayout.java
import java.awt.*;
import java.awt.event.*;
Síntese da aula
Atividades
Referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice
Hall, 2005.
FLANAGAN, David. Java: o guia essencial. 5. ed. Porto Alegre. Bookman, 2006.
Na próxima aula
Objetivo
Pré-requisitos
Introdução
4.1 JDBC
4.1.1.1 JDBC-ODBC
Este drive, por sua vez, converte as chamadas JDBC diretamente no pro-
tocolo do banco de dados. Este, que é implementado na linguagem Java, nor-
malmente 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.
• 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;
• P
reparedStatement, gerencia e executa instruções SQL, permitin-
do 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.
4.1.3 DriverManager
4.1.4 Connection
4.1.5 Statement
4.1.6 PreparedStatement
4.1.7 ResultSet
• 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.
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. En-
tão, mãos à obra, transcreva o código a seguir.
import java.awt.Frame;
import java.awt.List;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
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 é ape-
nas 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.
O método alterar() é bem parecido com o inserir(). Apenas foi utilizada ou-
tra 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 va-
lor 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.
Síntese da aula
Atividades
Referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice
Hall, 2005.
THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo: Éri-
ca, 2002.
Na próxima aula
Anotações
Objetivo
Pré-requisitos
Introdução
As classes Applets são muito úteis para escrever aplicativos para a Inter-
net, pois podem ser incorporadas a documentos HTML e executadas usando-
se navegadores que sejam compatíveis com Java, no caso, que suportem os
plugins disponibilizados para a execução do código pela JVM.
1. Instanciação – (create);
2. Inicialização – (init);
3. Início – (start);
5. Parada – (stop);
É executado uma única vez, assim que a página que executa o Applet está
sendo carregada pela primeira vez, sendo invocado pelo navegador, atra-
vé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).
// MetodosApplet.java
import java.applet.Applet;
import java.awt.Graphics;
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.
Para carregar um Applet Java em uma página HTML (HyperText Markup Lan-
guage), 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>
import java.awt.Graphics;
javac PrimeiroApplet.java
appletviewer index.html
Assim como programas podem receber argumentos vindos das linhas de co-
mando, 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).
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 va-
lor está definido no campo VALUE, se encontra disponível para ser utilizado.
...
<applet code=”param.class” height=115 width=115>
<param name=”cor” value=”FFF000”>
<param name=”valor” value=”10”>
</applet>
...
Método Descrição
Lista as applets contidas na exibição do
getApplets()
documento.
Um clip de áudio da URL solicitada é
getAudioClip(URL)
retornado.
Retorna uma referência para a tag <APPLET>
getApplet(String)
no documento atual.
getImage(URL) A URL retorna uma imagem.
Requisita ao navegador que substitua a página
showDocument(URL) atual pela contida na URL dada.
A string será fornecida na linha de status ou
showStatus(String)
na janela.
Requisita ao navegador que substitua a página
showDocument(URL,
atual pela contida na URL dada na janela
String)
especificada como alvo.
Tabela 1 - Métodos da Interface AppletContext
Síntese da aula
Nesta aula, foram apresentados os conceitos de Applets, bem como o seu funcio-
namento 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 documen-
tos HTML e alguns métodos para auxiliar na criação de Applets mais sofisticadas.
Atividades
2. Uma classe Applet, conforme pôde ser observado em nossa aula, pode ser exe-
cutado 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?
Referências
DEITEL, Harvey M. Java: como programar. 6. ed. São Paulo: Pearson Prentice
Hall, 2005.
Na próxima aula
Objetivo
Pré-requisitos
Introdução
6.1 JasperReports
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.
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).
Com o uso do XML, o layout poderá ser definido com formas geométricas, ima-
gens e textos padronizados estaticamente e/ou principalmente dinamicamente, atra-
vé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.
OBJETO DESCRIÇÃO
Objeto de definição do relatório é criado a partir do
JasperDesign
template XML.
Objeto de compilação do JasperDesign, é criado após o
JasperReport
processo de compilação e verificação do layout do relatório.
Objeto final, é criado a partir de um JasperReport e
JasperPrint
contém o relatório preenchido.
Tabela 5.1 – Objetos do JasperReports para criação de relatórios
...
<field name=“Matricula” class=“java.lang.Integer”/>
...
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 ante-
rior, 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>
...
NÍVEIS DESCRIÇÃO
Este nível indica que a variável nunca é inicializada com o
None valor inicial da expressão, ela apenas guarda o valor obtido
pela expressão principal;
Este nível indica que a variável somente será inicializada no inicio
Report
do relatório e terá seu valor acumulado até o término do mesmo;
Este nível indica que a variável será inicializada no início de
Page
cada página do relatório;
Este nível indica que a variável será inicializada no início de
Column
cada coluna;
Este nível indica que a variável será inicializada quando o
Group
grupo especificado pelo atributo de resetGroup for modificado;
Default O valor padrão do nível é Report;
...
<parameter name=“Titulo” class= “java.lang.String”/>
...
...
SELECT * FROM aluno WHERE matricula=$P{Matricula}
...
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>
...
6.2 iReport
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.
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 ferra-
menta, acrescente novos elementos como Fields e Texts, para obter mais co-
nhecimento dos elementos que a compõe.
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.awt.event.*;
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”);
botao.addActionListener(this);
add(botao);
setLayout(new FlowLayout());
setSize(200, 60);
setLocation(300, 300);
addWindowListener(new Eventos());
}
// método de execução
public static void main(String[] args) {
Report programa = new Report();
programa.setVisible(true);
}
// Eventos da Janela
class Eventos extends WindowAdapter{
...
}
Síntese da aula
Atividades
Referências
FURUTANI, Roberto J. Como criar relatórios Java para Web com Jas-
perReports e iReport. <http://www.furutani.eti.br/tutoriais/Mini-Tutorial_
Relatorios_Java_JasperReports_e_iReport.pdf> Acessado em 12 out. 2007.
Na próxima aula
Anotações
Objetivo
Pré-requisitos
Introdução
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 definire-
mos o método executável, então, transcreva o código a seguir, salve-o e execute.
//AppCadastro.java
import java.awt.Frame;
//AppCadastro.java
import java.awt.*;
import java.awt.event.*;
public class AppCadastro extends Frame{
...
}
class EvtJanela extends WindowAdapter{
public void windowClosing(WindowEvent e){
System.exit(0);
}
}
...
public class AppCadastro extends Frame{
//método construtor
public AppCadastro(){
...
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.
...
public class AppCadastro extends Frame{
//método construtor
public AppCadastro(){
...
MenuBar barraMenu = new MenuBar();
Menu menuArquivo = new Menu(“Arquivo”);
MenuItem itemCadastro = new MenuItem(“Cadastro de Curso”);
MenuItem itemSair = new MenuItem(“Sair”);
menuArquivo.add(itemCadastro);
menuArquivo.add(itemSair);
barraMenu.add(menuArquivo);
setMenuBar(barraMenu);
}
...
}
...
...
public class AppCadastro extends Frame implements ActionListener{
//método construtor
public AppCadastro(){
...
itemCadastro.addActionListener(this);
itemSair.addActionListener(this);
}
...
public void actionPerformed(ActionEvent e) {
if (e.getSource() instanceof MenuItem) {
MenuItem item = (MenuItem) e.getSource();
if(item.getLabel().equals(“Sair”)){
System.exit(0);
}
if(item.getLabel().equals(“Novo de Curso”)){
}
}
}
}
...
...
public class AppCadastro extends Frame implements ActionListener{
Panel geral;
//método construtor
public AppCadastro(){
...
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);
}
...
public void actionPerformed(ActionEvent e) {
...
if(item.getLabel().equals(“Novo de Curso”)){
CardLayout pilha = (CardLayout) geral.getLayout();
pilha.next(geral);
}
…
}
}
...
...
import javax.swing.*;
...
class AppCadastro extends Frame{
public
...
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(){
...
painelCadastro.setLayout(new FlowLayout());
painelCadastro.add(new Label(“Nome:”));
painelCadastro.add(nome);
painelCadastro.add(new Label(“Descrição:”));
painelCadastro.add(descricao);
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 reagi-
rã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 class AppCadastro extends Frame implements ActionListener{
...
public void actionPerformed(ActionEvent e) {
...
}
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) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try {
connection = (Connection) DriverManager.getConnection(con);
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
}
...
//AppCadastro.java
...
public class AppCadastro extends Frame{
...
}
class EvtJanela extends WindowAdapter{
...
}
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 res-
ponsá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.
//AppCadastro.java
...
import java.sql.*;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.ResultSet;
import com.mysql.jdbc.Statement;
public class AppCadastro extends Frame{
...
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!”);
} catch (SQLException e) {
e.printStackTrace();
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();
...
importjava.io.*;
importnet.sf.jasperreports.engine.*;
importnet.sf.jasperreports.engine.export.*;
importnet.sf.jasperreports.view.*;
class AppCadastro extends Frame implements ActionListener{
public
Panel geral;
//método construtor
public AppCadastro(){
...
}
...
public void actionPerformed(ActionEvent e) {
...
}
public void gerarReport() {
try {
Connection con = connection();
Statement stm = (Statement) con.createStatement();
String query = “Select * from Curso”;
ResultSet rs = (ResultSet) stm.executeQuery(query);
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) {
e.printStackTrace();
} catch (JRException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
...
...
public class AppCadastro extends Frame implements ActionListener{
Panel geral;
//método construtor
public AppCadastro(){
...
salvar.addActionListener(this);
limpar.addActionListener(this);
report.addActionListener(this);
sair.addActionListener(this);
}
...
public void actionPerformed(ActionEvent e) {
...
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);
}
}
}
...
AppCadastro.java
//AppCadastro.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
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.Connection;
import com.mysql.jdbc.ResultSet;
import com.mysql.jdbc.Statement;
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;
}
}
Síntese da aula
Atividades
Referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice
Hall, 2005.
FLANAGAN, David. Java: o guia essencial. 5. ed. Porto Alegre. Bookman, 2006.
MANZANO, José Augusto Navarro Garcia; COSTA JR., Roberto Affonso da.
Java 2: programação de computadores. São Paulo: Érica, 2006.
Anotações