Programação. 3 Período

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

Apresentação

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.

Vice-Reitor

Lívio William Reis de Carvalho Pró-Reitor de Graduação Galileu Marcos Guarenghi

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

Pró-Reitora de Pesquisa Antônia Custódia Pedreira

Pró-Reitora de Administração e Finanças Maria Valdênia Rodrigues Noleto Diretor de EaD e Tecnologias Educacionais Marcelo Liberato

Coordenador Pedagógico Geraldo da Silva Gomes Coordenador do Curso Igor Yepes

EADCON – Empresa de Educação Continuada Ltda

Diretor Presidente

Luiz Carlos Borges da Silveira Diretor Executivo

Luiz Carlos Borges da Silveira Filho Diretor de Desenvolvimento de Produto

Coordenação Editorial Maria Lourdes F. G. Aires Assessoria Editorial

Marinalva do Rêgo Barros Silva Assessoria Produção Gráfica Katia Gomes da Silva Revisão Lingüístico-Textual Kyldes Batista Vicente Revisão Digital Katia Gomes da Silva Projeto Gráfico Douglas Donizeti Soares Irenides Teixeira Katia Gomes da Silva Programação Visual Douglas Donizeti Soares Katia Gomes da Silva

Material Didático – Equipe Univali Coordenação Geral - Gerência de EaD Margarete Lazzaris Kleis

Coordenação Técnica e Logística Jeane Cristina de Oliveira Cardoso Coordenação de Curso

Luis Carlos Martins Editoração Gráfica

Delinea Design Soluções Gráficas e Digitais LTDA Coordenação Editorial

Charlie Anderson Olsen Larissa Kleis Pereira Logística Editorial Michael Bernardini Diagramação Michael Bernardini Ilustração Alexandre Beck Reitor

José Roberto Provesi Vice-Reitor

Mário César dos Santos Procurador Geral Vilson Sandrini Filho Secretário Executivo Nilson Scheidt Pró-Reitora de Ensino Amândia Maria de Borba

Pró-Reitor de Pesquisa, Pós-Graduação, Extensão e Cultura

Plano de Ensino

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 •

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

Aula 1

Programação Visual em java

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

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 apresentautiliza-çã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.java import java.awt.*;

public class PrimeiroExemplo extends Frame{

public static void main (String args[]) {

Frame f = new Frame ();

Button botao = new Button (“SAIR”);

//botao. addActionListener(Evento); f.add(botao); f.setSize(50, 100); f.setLocation(50, 50); f.show(); } }

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, é inefetivamen-teressanefetivamen-te 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

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

import java.awt.*;

public class FrameExemplo extends Frame{

// metodo construtor public FrameExemplo(){ super(“Janela Exemplo”); setSize(50, 100); setLocation(100, 100); } // metodo executável

public static void main (String args[]) { FrameExemplo janela = new FrameExemplo(); janela.setVisible(true);

} }

Note que no nosso segundo exemplo, conforme mencionado 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.java

import 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 utiliza-do tipo container, exibinutiliza-do 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étoutiliza-dos construtores, nos quais já podem ser definiutiliza-dos 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).

// FrameExemplo.java

import java.awt.*; import java.awt.event.*;

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 utilizaapresenta-do o métoapresenta-do add() apresenta-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.

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

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.

Pensando sobre o assunto

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.

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

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

DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice Hall, 2005.

FILHO, Renato Rodrigues. Desenvolva aplicativos com Java 2. São Paulo: Érica, 2005.

MANZANO, José Augusto Navarro Garcia; COSTA JR., Roberto Affonso da.

Java 2: programação de computadores. São Paulo: Érica, 2006.

THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo: Érica, 2002.

na próxima aula

Veremos outros componentes para a construção de aplicações visuais utili-zando a biblioteca AWT, que enriquecerão a interação com o usuário.

Aula 2

Componentes visuais

Objetivo

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

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, paago-ra 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.java import java.awt.*; public class NovaJanela{

public static void main(String[] args) {

Panel painelTopo = new Panel(); Panel painelDireita = new Panel();

Panel painelBaixo = new Panel(new FlowLayout(FlowLayout.LEFT)); Panel painelCentro = new Panel(new FlowLayout(FlowLayout.CENTER)); Panel painelEsquerda = new Panel();

Frame janela = new Frame(“Painel”); janela.setSize(100, 100); janela.setLocation(300, 300); painelTopo.setBackground(Color.RED); painelDireita.setBackground(Color.GREEN); painelBaixo.setBackground(Color.BLUE); painelCentro.setBackground(Color.CYAN); painelEsquerda.setBackground(Color.ORANGE); janela.add(painelTopo, BorderLayout.NORTH); janela.add(painelDireita, BorderLayout.EAST); janela.add(painelBaixo, BorderLayout.SOUTH); janela.add(painelCentro, BorderLayout.CENTER); janela.add(painelEsquerda, BorderLayout.WEST); 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.

Pensando sobre o assunto

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.java import 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.java import 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 anteriores import 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 JanelaCheck

import java.awt.*;

public class JanelaCheck extends Frame implements ItemListener { private Checkbox checkEmail;

private Checkbox checkCorreio; private Label texto;

public JanelaCheck() { super(“Checkbox”); setSize(800, 200);

texto = new Label(“Indique os meios de envio:”); Panel p = new Panel();

checkCorreio = new Checkbox(“Correios”); checkEmail = new Checkbox(“Email”); checkCorreio.addItemListener(this); checkEmail.addItemListener(this); p.setLayout(new FlowLayout()); p.add(texto); p.add(checkCorreio); p.add(checkEmail); add(p, BorderLayout.NORTH); }

public void itemStateChanged(ItemEvent e) { if (checkCorreio.getState()) { texto.setText(“Selecionado:”+checkCorreio.getLabel()); } if (checkEmail.getState()&& checkCorreio.getState()) { texto.setText(“Selecionado:”+checkEmail.getLabel()+” e “ +checkCorreio.getLabel()); } if (checkEmail.getState()) { texto.setText(“Selecionado:”+checkEmail.getLabel()); } }

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 componendes-te. Porém, vale ressaltar que o componendes-te 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 JanelaCheck

import java.awt.*;

public class JanelaCheck extends Frame implements ItemListener { private Checkbox checkEmail;

private Checkbox checkCorreio; private CheckboxGroup grupo; private Label texto;

public JanelaCheck() { ...

grupo = new CheckboxGroup();

checkCorreio = new Checkbox(“Correios”,grupo,true); checkEmail = new Checkbox(“Email”,grupo,false); ...

} ... }

O último parâmetro passado nos construtores dos objetos Checkbox 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 garancomponen-te 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.java

import 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 confor-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étoto-dos 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?

Comentário das atividades

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

DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice Hall, 2005.

FILHO, Renato Rodrigues. Desenvolva aplicativos com Java 2. São Paulo: Érica, 2005.

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.

Aula 3

gerenciadores de layout e

tratadores de evento

Objetivos

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

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 conceientendimen-tos exposentendimen-tos 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 conceiconcei-to 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.java

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

Pensando sobre o assunto

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.

// GerenciadorLayout.java

import java.awt.*; import java.awt.event.*;

public class GerenciadorLayout extends Frame{

// método construtor public GerenciadorLayout(){ ... setLayout(new GridLayout(2,3)); ... } // método executavel

public static void main(String args[]){ ... } }

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 conexecu-tainer 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 adicionasen-do um componente, ele ocupará toda a região. Tusen-do 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.

// GerenciadorLayout.java

import java.awt.*; import java.awt.event.*;

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