Programação 3° Período - Blog do ConsultorTI | Porque ... · Aplicando lógica orientada a...

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(){ ... painelCadastro.setLayout(new FlowLayout()); painelCadastro.add(new Label("Nome:")); painelCadastro.add(nome); painelCadastro.add(new Label("Descrição:")); painelCadastro.add(descricao);

rio");

Apr

esen

taçã

o

Caro estudante,

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 conheci-mento adquirido. A tecnologia Java, nos últimos anos, tornou-se muito po-pular 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ân-cia na criação de software.

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, conhe-ceremos 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, possibili-tando 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.

Fundação Universidade do Tocantins

ReitorHumberto Luiz Falcão Coelho

Vice-ReitorLívio William Reis de Carvalho

Pró-Reitor de GraduaçãoGalileu Marcos Guarenghi

Pró-Reitor de Pós-Graduação e ExtensãoClaudemir Andreaci

Pró-Reitora de PesquisaAntônia Custódia Pedreira

Pró-Reitora de Administração e FinançasMaria Valdênia Rodrigues Noleto

Diretor de EaD e Tecnologias EducacionaisMarcelo Liberato

Coordenador PedagógicoGeraldo da Silva Gomes

Coordenador do CursoIgor Yepes

EADCON – Empresa de Educação Continuada Ltda

Diretor PresidenteLuiz Carlos Borges da Silveira

Diretor ExecutivoLuiz Carlos Borges da Silveira Filho

Diretor de Desenvolvimento de ProdutoMárcio Yamawaki

Diretor Administrativo e FinanceiroJúlio César Algeri

Organização de Conteúdos AcadêmicosAlex Coelho

Material Didático – Equipe Unitins

Coordenação EditorialMaria Lourdes F. G. Aires

Assessoria EditorialMarinalva do Rêgo Barros Silva

Assessoria Produção GráficaKatia Gomes da Silva

Revisão Lingüístico-TextualKyldes Batista Vicente

Revisão DigitalKatia Gomes da Silva

Projeto GráficoDouglas Donizeti SoaresIrenides TeixeiraKatia Gomes da Silva

Programação VisualDouglas Donizeti SoaresKatia Gomes da Silva

Material Didático – Equipe Univali

Coordenação Geral - Gerência de EaDMargarete Lazzaris Kleis

Coordenação Técnica e LogísticaJeane Cristina de Oliveira Cardoso

Coordenação de CursoLuis Carlos Martins

Editoração GráficaDelinea Design Soluções Gráficas e Digitais LTDA

Coordenação EditorialCharlie Anderson OlsenLarissa Kleis Pereira

Logística EditorialMichael Bernardini

DiagramaçãoMichael Bernardini

IlustraçãoAlexandre Beck

ReitorJosé Roberto Provesi

Vice-ReitorMário César dos Santos

Procurador GeralVilson Sandrini Filho

Secretário ExecutivoNilson Scheidt

Pró-Reitora de EnsinoAmândia Maria de Borba

Pró-Reitor de Pesquisa, Pós-Graduação, Extensão e CulturaValdir Cechinel Filho

Plan

o de

Ens

ino

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, Connec-tion, 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 •interfaces gráficas.

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.

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•

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

Aula 7 – Estudo de Caso .......................................................................83

Sum

ário

Aula 1Programação Visual em java

Univali/UniTinS • SUPERiOR DE TEcnOlOgia • 3º PERÍODO 9

Objetivo

Esperamos que, ao final desta aula, você seja capaz de:

conhecer• 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 é impor-tante 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 es-paç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

“A linguagem Java disponibiliza duas bibliotecas para a construção de interfaces gráficas, utilizando componentes GUI.”

10 3º PERÍODO • SUPERiOR DE TEcnOlOgia • Univali/UniTinS

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

Nesta aula, veremos mais a fundo os conceitos relacionados à progra-mação com interfaces visuais, apresentados na aula 5 da disciplina de pro-gramaçã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, é pos-sí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 interes-santes 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 te-clado 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 uti-lizaçã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 é 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.

A classe abstrata Component consiste na base para construção de qual-quer 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 ge-neralizaçã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



para as quais foram destinadas e se propõem a resolver garantindo a portabi-lidade do sistema. A Sun define a Java como (SUN, 2007):

simples, distribuída, interpretada, robusta, segura, de arqui-tetura 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 com-ponentes 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.

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 (FLA-NAGAN, 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.

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.



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 te-clado 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 bi-bliotecas gráficas AWT. Então transcreva o código a seguir e execute-o.

// Classe PrimeiroExemplo.javaimport 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(); }}



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 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).

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 clas-ses 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



adicionados e posicionados a interface. No caso, qualquer classe que herda da classe Container pode agregar a seu escopo outros componentes. Alguns exem-plos 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 componen-tes da AWT, conhecendo suas principais aplicações e utilizando, para isso, a construção de pequenos exemplos. Nosso primeiro componente a ser explora-do 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 mencio-nado, 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 compo-nentes 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 compo-nentes 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.



// FrameExemplo.javaimport 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 anteriormen-te, 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 importan-te, 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 de-sejado, 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 men-sagem 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 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.

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 ante-rior (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.



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.

// FrameExemplo.javaimport java.awt.*;import java.awt.event.*;

public class FrameExemplo extends Frame implements WindowListener{ // 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){}}

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 compo-nentes 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.



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 utiliza-do 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 aces-sados para uma instância da classe Label, porém, com certeza, os mais utiliza-dos 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 compo-nente, no qual alteramos nosso o exemplo anterior (MANZANO, 2006).


public class FrameExemplo extends Frame implements WindowListener{

// 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.



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 possibi-litar 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 uti-lizaçã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.


public class FrameExemplo extends Frame implements WindowListener, ActionListener{ // metodo construtor public FrameExemplo (){ super(“Titulo: Botão Exemplo”); Label texto = new Label(“Para sair aperte o botão!”); Button botao = new Button(“Sair”); setSize(150, 100); setLocation(100, 100); addWindowListener(this); setLayout(new FlowLayout()); botao.addActionListener(this); add(texto); add(botao); } //metodo listener public void actionPerformed(ActionEvent e) { System.exit(0); }...}



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.


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ó é acio-nado 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.




public class FrameExemplo extends Frame implements WindowListener, ActionListener{// metodo construtor public FrameExemplo (){ 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); setLocation(300, 300); addWindowListener(this); setLayout(new FlowLayout()); botao.addActionListener(this); 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 disponibili-zados 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. Apren-demos 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.



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 apli-caçõ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 WindowListe-ner, que fornece os métodos: windowClosing(), windowClosed(), windowIconified(), windowOpened(), windowDeiconified(), windowActivated(), windowDeactivated().

referências


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 utili-zando a biblioteca AWT, que enriquecerão a interação com o usuário.

Anotações



Aula 2Componentes visuais


Objetivo


conhecer os componentes visuais básicos da biblioteca AWT relaciona-•dos 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 ago-ra iremos nos aprofundar na utilização da tecnologia Java, para a crição de programas com outros componentes visuais que interagem com os apresenta-dos 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 in-teraçã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.



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 é relati-vamente 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 com-ponente 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.



//NovaJanela.javaimport 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);

janela.setVisible(true); }}

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 diferen-tes 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 pai-né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.



2.1.2 Componente textArea

Na aula anterior, foi apresentado o componente TextField que apre-senta 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éto-dos, 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 particularida-des, como linhas, colunas ou mesmo a barra de rolagem (FLANAGAN, 2006). Assim, vejamos o exemplo abaixo com a utilização deste componente visual.

// NovaJanela.javaimport java.awt.*;import java.awt.event.*;

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”); botao.addActionListener(this); 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); }

public void actionPerformed(ActionEvent e) { if (e.getSource()==botao) { multTexto.append(texto.getText()); } texto.setText(“”); }}



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, finali-zamos 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.javaimport java.awt.*;import java.awt.event.*;

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); }

public void actionPerformed(ActionEvent e) { if (e.getSource()==botao) { lista.add(texto.getText()); } texto.setText(“”); }}



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.

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 à inter-face ItemListener, assim como no objeto List apresentado na seção anterior. Então, utilizando os conhecimentos adquiridos até aqui, construa uma ja-nela 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.

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 anterioresimport java.awt.*;import java.awt.event.*;

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 Che-ckbox cria graficamente, nos programas visuais, caixas de opção. Este componente é geralmente utilizado para representar que uma opção deve ser escolhida, sendo ver-dadeira, 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 ItemListe-ner 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.



//Classe JanelaCheckimport 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()); } } public static void main(String args[]) { JanelaCheck janela = new JanelaCheck(); janela.addWindowListener(new WindowAction()); janela.setVisible(true); }}

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.



2.1.6 Componente Checkboxgroup

Conforme mencionado, o componente Checkboxgroup realiza o agru-pamento de diversos objetos da classe Checkbox, tornando-se um único com-ponente visual no qual seja capaz de selecionar apenas um item dentro des-te 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 radio-buttons 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 Checkbox-group e nos construtores de cada objeto Checkbox criado, associe ao grupo, conforme é apresentado abaixo.

//Classe JanelaCheckimport 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 con-siste na definição de qual será apresentado como verdadeiro. Certo, pessoal? Conforme pode ser observado no exemplo anterior, isso torna esse componen-te 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.



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 asso-ciada ao objeto Frame, no caso a janela. O componente Menu conforme men-cionado, 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 sis-temas, além de uma melhor disposição das funcionalidades. Vamos a um exem-plo no qual criamos um menu, então transcreva o código abaixo e o execute.

//JanelaMenu.javaimport java.awt.*;import java.awt.event.*;

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); addWindowListener(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); }



//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); } } }}

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 constru-tor 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 cons-trutor, consiste na instanciação dos objetos que compõem um menu, ou seja, componentes do tipo MenuBar, Menu e MenuItem. Note o agrupamento hie-rá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); menuArquivo.add(itemSair); menuSobre.add(itemAjuda); barra.add(menuArquivo); barra.add(menuSobre); setMenuBar(barra);...



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, confor-me mencionado, é uma janela. Com isto, finalizando, são criados os métodos exigidos pelas interfaces que nossa classe implementa a ActionListener e Win-dowListener.

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 to-dos 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.

... 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); } } }...

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 funcio-nalidades 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 apresen-taçã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.



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 com-ponentes, 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, Oes-te 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



FLANAGAN, David. Java: o guia essencial. 5. ed. Porto Alegre. Bookman, 2006.



na próxima aula

Continuaremos a relembrar e explorar mais a fundo conceitos vincu-lados ao gerenciamento de layout, bem como o tratamento de eventos para os componentes.

Anotações

Aula 3gerenciadores 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 entendimen-to 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 pro-porcionam 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, locali-zaçã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 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.



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 ou-tros 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 gerencia-dores 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 concei-to 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 im-plementaçã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 determina-da janela, bem como definidos os gerenciadores para os componentes que serão agregados aos painéis. A biblioteca AWT disponibiliza alguns ge-renciadores 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-



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.javaimport java.awt.*;import java.awt.event.*;

public class GerenciadorLayout extends Frame { // método construtor public GerenciadorLayout() { super(“Gerenciador Layout”); setSize(200, 115); setLayout(new FlowLayout()); for (int i=1; i<7; i++) add(new TextField(“Texto “+i)); } // método executavel public static void main(String args[]) { GerenciadorLayout gerente = new GerenciadorLayout(); EventosWindows evt = new EventosWindows(); gerente.addWindowListener(evt); gerente.setVisible(true); }}class EventosWindows implements WindowListener{ 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){}}

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.




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 arruma-dos 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 li-nhas 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 exem-plo anterior, substituindo pelo código no quadro a seguir e execute o programa.


public class GerenciadorLayout extends Frame{ // método construtor public GerenciadorLayout(){ ... setLayout(new GridLayout(2,3)); ... } // método executavel public static void main(String args[]){ ... }}class EventosWindows implements WindowListener{ ... }



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 dis-põe do gerenciador BorderLayout, CardLayout e GridBagLayout.

3.1.3 gerenciador borderlayout

Assim como em uma bússola, o gerenciador de layout BorderLayout execu-ta 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, 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.

3.1.4 Cardlayout

A partir desta seção, trabalharemos com gerenciadores de layout diferen-ciados frente aos demais apresentados. Embora bem mais flexíveis, estes são muitas vezes ineficientes para resolver alguns problemas. No caso, a classe Car-dLayoout é responsável por gerenciar um layout mais incrementado, que trata os componentes presentes no container como uma pilha de cartas (FILHO, 2005).

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).



Este gerenciador disponibiliza formas de acesso aos diversos componen-tes que podem ser “empilhados” no container, sendo que este permite a exi-biçã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 compo-nentes, conforme demonstrado nas aulas anteriores. Assim, conseguimos obter o aspecto de aplicações com diversas janelas, sendo que estas podem ser acessa-das 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 resul-tados 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.


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 static void main(String args[]) { ... }

// método construtor 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);



// Painel Múltiplo windows = new Panel(); windows.setLayout(new CardLayout()); windows.add(new Label(“Primeiro Painel”), “Janela2”); windows.add(painel1, “Janela2”); add(“Center”, windows); }

public void actionPerformed(ActionEvent e) { 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 geren-ciador consiste no mais complexo, mas também o que mais dispõe de funcio-nalidades 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 Car-dLayout, 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, dife-rentemente 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).



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.javaimport java.awt.*; import javax.swing.*; 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.



3.2 tratadores de eventos

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).

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 re-ceptores, 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

ComponentEventComponentListenerComponentAdapter

componentMovedcomponentHiddencomponentResized

ContainerEventContainerListenerContainerAdapter

componentAddedcomponentRemoved

FocusEventFocusListenerFocusAdapter

focusGainedfocusLost

ItemEvent ItemListener itemStateChanged

KeyEventKeyListenerKeyAdapter

keyPressedkeyReleased

keyTyped

MouseEvent

MouseListenerMouseAdapter

MouseMotionListenerMouseMotionAdapter

mousePressedmouseReleasedmouseEnteredmouseExited

mouseClickedmouseDraggedmouseMoved



TextEvent TextListener textValueChanged

WindowEventWindowListenerWindowAdapter

windowClosingwindowOpenedwindowIconified

windowDeiconifiedwindowClosed

windowActivatedwindowDeactivated

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 lis-tener 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.




public class GerenciadorLayout extends Frame{ // método construtor public GerenciadorLayout(){ ... setLayout(new GridLayout(2,3)); ... } // método executavel public static void main(String args[]){ ... }}class EventosWindows extends WindowAdapter{ public void windowClosing(WindowEvent e){ System.exit(0); }}

Note que apenas alteramos nossa classe EventosWindows e, consideran-do 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 neces-sá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 tra-tados, de suma importância para aplicações visuais.

Síntese da aula

Nesta aula, foram apresentados os conceitos relacionados aos métodos cons-trutores, 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ân-cia 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, es-conder 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.



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, Gri-dBagLayout, sendo que este podem ser definidos a qualquer componente que seja um container. Já na atividade 2, a outra possibilidade fornecida pela lin-guagem Java para tratar os eventos de um sistema consiste nas classes adapta-doras, 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




na próxima aula

Serão expostos os conceitos sobre conexão de aplicações Java com ban-co de dados, possibilitando a construção de programas que realizem as ope-rações básicas com o manuseio de dados, além de, com isto, enriquecê-los.

Aula 4trabalhando com banco de dados


Objetivo


compreender 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 ban-co de dados já apresentada e, além disso, ter assimilado todo conhecimento referente às aulas anteriores. Sendo mais específico: serão necessários, co-nhecimento 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, permi-tindo uma padronização no acesso a distintos bancos de dados. Esta API é a Java DataBase Connectivity (JDBC).



4.1 jdbC

A API JDBC consiste em uma biblioteca, implementada em Java, que disponi-biliza 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 inter-faces, 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éto-dos 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 chama-da 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 con-siste no modelo de conexão mais flexível e abrangente (THOMPSON, 2002).



4.1.1.4 driver nativo

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).

4.1.2 Pacote java.sql

O pacote java.sql é o responsável por fornecer a API para acesso e pro-cessamento 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):

DriverManager, • responsável por criar uma conexão com o banco de dados;

Connection, • classe responsável por manter uma conexão aberta com o banco;

Statement, • gerencia e executa instruções SQL;

PreparedStatement, • gerencia e executa instruções SQL, permitin-do também a passagem de parâmetros em uma instrução;

ResultSet, • 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 armazena-mento e recuperação de informação em base de dados.

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.3 drivermanager

A Classe DriverManager é a responsável pelo gerenciamento de drivers JDBC. Esta classe também proporciona o estabelecimento de conexões a ban-cos de dados (THOMPSON, 2002).

// Carregando um driver em tempo de execuçãoClass.forName(“org.gjt.mm.mysql.Driver”);

// Tentando estabelecer conexão com o Banco de DadosConnection conn = DriverManager.getConnection(“jdbc:mysql://localhost/aula04?autoReconnect=true”, “conta”, “senha”);

No código apresentado, primeiramente um driver é carregado em tem-po 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):

commit()• , 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.



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 Sta-tement, 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.



// 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 Prepare-dStatement, 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 da-dos resultante de uma consulta SQL, realizada ao banco de dados. Ela propor-ciona métodos capazes de acessar os dados provenientes da consulta SQL. Alguns dos métodos desta interface frequentemente utilizados (SUN, 2007):

next()• , 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.


getString(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 houver resultados, posiciona-se o cursor na próxima linha de dadoswhile (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 con-junto 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.



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. 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;

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) { e.printStackTrace(); }}

public void close() { try { if (stmt != null) stmt.close(); conn.close(); } catch (SQLException e) { e.printStackTrace(); }}



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.

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(); } catch (SQLException e) { // Fechando a conexão com o banco close(); e.printStackTrace(); }}

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 ins-tâ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”); // Fechando a conexão com o banco pstmt.execute(); close(); } catch (SQLException e) { // Fechando a conexão com o banco close(); e.printStackTrace(); }}



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.

public ResultSet buscarAlunos(){ try { open(); stmt = conn.createStatement(); rs = stmt.executeQuery(“SELECT id, nome FROM ALUNO”); return rs; } catch (SQLException e) { close(); e.printStackTrace(); } 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 Alu-no. 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); janela.setVisible(true);}



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 buscarA-lunos(), 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(); } catch (SQLException e) { e.printStackTrace(); }}

Finalmente, o código acima apresenta o método main(), de execução pa-drã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 fizes-se uso de todos os conceitos vistos anteriormente.



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 Con-nection, 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 obje-to. 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


THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo: Éri-ca, 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.

Anotações



Aula 5Applets 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 ante-riores, bem como conceitos relacionados à orientação ao objeto. Esse conheci-mento é 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 integra-dos a páginas WEB, sendo que este têm um ciclo de vida diferente dos progra-mas 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!



5.1 funcionamento das Applets

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.

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 au-xilia 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).

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.

Figura 1 - Ciclo de vida das Applets



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, 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).

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 Ap-plet 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



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 expli-citá-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.javaimport 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 invo-cados 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.



5.2 rodando Applets java em uma Página WEb

É isso, pessoal, depois de alguns conceitos básicos na seção anterior, ire-mos 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 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>

Pronto, agora que já sabemos como apresentar nosso Applet em um na-vegador, iremos apresentar um programa simples que escreverá na página HTML a mensagem “Olá Mundo !!!”. O código a seguir ilustra a classe res-ponsável por isto.

import java.awt.Graphics;

public class PrimeiroApplet extends Applet{ public void paint(Graphics g){ g.drawString(“Oi Mundo!!!”, 50, 25); }}

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.



Conforme já mencionado, após a criação de nossa classe Applet, é neces-sário que o código de nossa classe seja compilado, para que o Applet inserido no navegador possa funcionar corretamente. Para compilar nossa classe é ne-cessário digitar o comando javac, conforme é realizado com qualquer classe.

javac PrimeiroApplet.java

A partir disso, será gerado um arquivo PrimeiroApplet.class que é um byte-code 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 dis-ponibilizar 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 ferra-menta, que deve indicar qual arquivo html deve ser apresentado.

appletviewer index.html

Este aplicativo é, na maioria das vezes, utilizado para verificar a consistên-cia dos Applets, antes que a página seja disponibilizada, uma vez que a maio-ria 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 Ap-plet desconhecida possa prejudicar o sistema onde está sendo executa-da, 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):



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 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).

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 va-lor 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 <PA-RAM> 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.



...<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 recupe-rar 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 especi-ficado 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 setBack-ground(), 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.



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 infor-mações sobre o ambiente em que são executados utilizando-se da interface Ap-pletContext, cujos métodos são relacionados na tabela a seguir (DEITEL, 2005).

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 showDocu-ment(), no qual pode-se gerenciar um navegador, para criar novas janelas ou mesmo exibir um novo documento em uma janela já existente. Assim finaliza-mos 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 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.

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



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 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?


Na atividade 1, uma classe Applet possui um ciclo de vida pré-determi-nado, 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 se-tParameter(), 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 apli-cações Java com a utilização do framework jasperReport, bem como a apre-sentação de ferramentas que auxiliem neste processo.

Aula 6relató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 conhe-cimento é 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 con-siste 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 pro-prietária Crystal Reports e as ferramentas de código aberto JasperReports e iReport que serão tratadas nesta aula.

Figura 1 - JasperReports - Processo para gerar um relatório



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 (fra-mework) 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.

6.1.1 Xml a chave do funcionamento

Aqui, pessoal, é onde começamos o processo de criação dos nossos rela-tórios. Logo, temos que compreender como o processo funciona, e a Figura 1 tem como objetivo nos mostrar como se dá este processo.

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.

objeto Descrição

JasperDesignObjeto de definição do relatório é criado a partir do template XML.

JasperReportObjeto de compilação do JasperDesign, é criado após o processo de compilação e verificação do layout do relatório.

JasperPrintObjeto 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



Você deve estar se perguntando: “Qual o objetivo do arquivo XML?”. Cal-ma, iremos falar sobre isso agora.

Na introdução da aula falamos que o processo de criação de relatórios consis-tia 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, 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.

As etapas de geração de relatório são representadas utilizando diferentes objetos do JasperReports, que serão apresentadas na Tabela 5.1.



6.1.2 dados, a alma do conteúdo

Nesta parte, pessoal, trataremos do preenchimento com os dados neces-sá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 rea-lizar 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. JRRe-sultSetDataSource é 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 colu-na referenciada deve conter o mesmo nome do campo do relatório (HEFFELFIN-GER, 2006). Como exemplo, pegaremos os dados da coluna ‘Matricula’ com o tipo ‘Integer’ de uma tabela ‘aluno’. Para mapearmos esse dado, devemos defi-nir, no arquivo XML, um campo com o nome ‘matricula’, como segue abaixo:

Para a simplificação do projeto do relatório, utilizamos as variáveis (varia-ble) 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 re-latório. As variáveis podem referenciar, internamente, tipos de cálculos como

...<field name=“Matricula” class=“java.lang.Integer”/>...

níveis Descrição

NoneEste 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;

ReportEste 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;

PageEste nível indica que a variável será inicializada no início de cada página do relatório;

ColumnEste nível indica que a variável será inicializada no início de cada coluna;

GroupEste 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)



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.

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, des-de que elas tenham sido pré-definidas.

Quando usamos variáveis para a realização de cálculos, podemos defi-nir quando elas devem ser reinicializadas. Para isso, existem vários níveis de reinicialização, que são apresentadas na Tabela 5.2.

A ferramenta também oferece variáveis pré-definidas para uso nas expres-sõ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.

...<variable name=“ValorMedia” class=“java.lang.Double” calculation= “Average”><variable expression> ${Nota} </variable expression></variable>...

... <parameter name=“Titulo” class= “java.lang.String”/>...

... Map param = new HashMap( ); param.put( “Aluno”, “Vinny Coelho Frota” );...

...SELECT * FROM aluno WHERE matricula=$P{Matricula}...

...<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> ...



Então passados, através da classe HashMap, via código Java, conforme é demonstrado a seguir.

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.

Assim, como resultado desta consulta, os dados contidos no relatório se-rão apenas aluno cuja matrícula foi passada por parâmetro.

Para podermos especificar o conteúdo de campos de texto, que freqüen-temente 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

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.

Figura 2 - Tela inicial do iReport



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 re-cursos 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 des-compactaçã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.

Pensando sobre o assuntoExistem 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 ma-neira desejada, teremos como resultado da execução do iReport a tela apresentada na Figura 2.

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.



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.

Com isso, a ferramenta acelera, significativamente, o processo de desen-volvimento 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 Data-Source, JavaBeans Set DataSource, Custom DataSource e Empty DataSour-ce. 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 neces-sá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 ferra-menta, acrescente novos elementos como Fields e Texts, para obter mais co-nhecimento dos elementos que a compõe.

Figura 3 - Criação do layout do relatório

//Report.javaimport 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()); }



Conforme já mencionado, um arquivo do iReport, quando salvo, consiste em uma arquivo XML, com a extensão .jrxml. Este deve ser nomeado como cur-so.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.

// 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 public static void main(String[] args) { Report programa = new Report(); programa.setVisible(true); }

// listener que reage ao evento public void actionPerformed(ActionEvent e) { try { geraRelatorio(); } catch (JRException e1) { e1.printStackTrace(); } catch (Exception e1) { e1.printStackTrace(); } }}

// Eventos da Janelaclass Eventos extends WindowAdapter{ ...}



Se tudo correu como esperado, através do botão “Relatório”, realizamos a exe-cuçã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.



Síntese da aula

Nesta aula, foram apresentados os conceitos fundamentais do JasperRe-ports 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 geren-ciar 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 bi-blioteca 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 Jas-perReports 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.

Anotações



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.

Aula 7Estudo 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 con-ceito 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 con-ceitos 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.



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 definire-mos o método executável, então, transcreva o código a seguir, salve-o e execute.

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 ar-quivo, 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.

//AppCadastro.javaimport java.awt.Frame;

public class AppCadastro extends Frame{ //método construtor public AppCadastro(){ super(“Aplicação de cadastro”); setSize(600, 600); setLocation(200, 100); } //método executável public static void main(String[] args) { AppCadastro exec = new AppCadastro(); exec.setVisible(true); }}



Verifique que apenas foram adicionados um import e a nova classe, ao final da apresentada no exemplo anterior. Note que, ao invés de implemen-tarmos a interface WindowListener, fazendo com que obrigatoriamente tivés-semos 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.

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.

//AppCadastro.javaimport 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); } ...}...

...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); } ...}...



Agora, precisamos definir o listener de nosso menu. Para tanto, devemos mencionar que nossa classe AppCadastro implementa a interface ActionListe-ner e, com isso nos obriga a também implementar o método ActionPerformed. Então vamos a eles.

Continuamos nosso estudo de caso definindo os containers de componen-tes 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, ter-mos o efeito de novas janelas que serão trabalhadas.

...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); } … }}...



Criamos três painéis sendo que um consiste no mestre, denominado geral, por meio do qual conseguimos acessar os demais, criando como menciona-do 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 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(){ ... painelCadastro.setLayout(new FlowLayout()); painelCadastro.add(new Label(“Nome:”)); painelCadastro.add(nome); painelCadastro.add(new Label(“Descrição:”)); painelCadastro.add(descricao);

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); } ...}...



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.

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”.

...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; }}...



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.

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...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; }}



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 inte-ressa: copie o código a seguir, conforme exemplificado, na classe AppCadastro.

Pensando sobre o assuntoConforme 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.

//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();

} catch (Exception Erro) { result.setText(“OCORRERAM ERROS NA CONSULTA!”); } return resultadoBanco; } public void limpar(){ nome.setText(“”); descricao.setText(“”); }}



...import java.io.*;import net.sf.jasperreports.engine.*;import net.sf.jasperreports.engine.export.*;import net.sf.jasperreports.view.*;public class AppCadastro extends Frame implements ActionListener{ 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(); } }}...

Para que nosso código funcione, certifique-se que o arquivo Curso.jasper está no “report” dentro do diretório em que nossa classe AppCa-dastro está. Como mencionado, iremos fazer com que nossos botões, as-sim 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.



Chegamos ao fim de nosso estudo de caso. No quadro a seguir, é apre-sentado todo o código de nossa classe, auxiliando numa visão mais macro do exemplo apresentado.

AppCadastro.java//AppCadastro.javaimport 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;

...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); } }}...



public class AppCadastro extends Frame implements ActionListener{ 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”); Panel geral; Curso c = new Curso(); Label result = new Label(); public AppCadastro(){ super(“Aplicação de cadastro”); setSize(600, 285); setLocation(200, 100); EvtJanela evt = new EvtJanela(); addWindowListener(evt); MenuBar barraMenu = new MenuBar(); Menu menuArquivo = new Menu(“Arquivo”); MenuItem itemCadastro = new MenuItem(“Novo de Curso”); MenuItem itemSair = new MenuItem(“Sair”, new MenuShortcut(KeyEvent.VK_R)); menuArquivo.add(itemCadastro); menuArquivo.add(itemSair); barraMenu.add(menuArquivo); setMenuBar(barraMenu); itemCadastro.addActionListener(this); itemSair.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.setLayout(new FlowLayout()); painelCadastro.add(new Label(“Nome:”)); painelCadastro.add(nome); painelCadastro.add(new Label(“Descrição:”)); painelCadastro.add(descricao); 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); }



public static void main(String[] args) { AppCadastro exec = new AppCadastro(); exec.setVisible(true); } 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”)){ 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(); 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 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!”); } catch (SQLException e) { e.printStackTrace(); 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) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } try { connection = (Connection) DriverManager.getConnection

(“jdbc:mysql://localhost:3306/universidade?user=root&password=root”);

} catch (SQLException e) { e.printStackTrace(); } return connection; }}class EvtJanela extends WindowAdapter{ public void windowClosing(WindowEvent e){ System.exit(0); }}



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 re-latórios. Boa sorte a todos!

Síntese da aula

Nesta aula, aplicamos todos os conceitos e componentes apresentados du-rante 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.

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; }}



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 apre-sentados em nosso estudo de caso.

a) A classe Panel consiste em uma classe do tipo container.b) Por 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 invo-caçã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



Anotações




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.

Programação 3° Período - Blog do ConsultorTI | Porque ... · Aplicando lógica orientada a...

Documents

Transcript of Programação 3° Período - Blog do ConsultorTI | Porque ... · Aplicando lógica orientada a...