c
 

 
 



Swing é uma das 5 APIs que formam a JFC (Java Foundation Classes), que
abrangem um grupo das características para construir Interfaces Gráficas com
o Usuários (GUIs) e adição de ricas funcionalidades e interatividade com
aplicações Java. O Swing veio como uma extensão do AWT(Abstract Window
Toolkit) que dependia de componentes específicos de cada plataforma, o que
não acontece com Swing, pois este contém apenas códigos java , o que
permite rodar em qualquer plataforma(Run Everywhere), entretanto estes
componentes são sensivelmente mais lentos que componentes nativos de
qualquer plataforma. Apesar da criação da Swing, o AWT ainda é suportado.
Para um bom rendimento neste curso o aluno deve ter um conhecime nto
básico em Java e ser capaz de criar e compilar um aplicativo básico nesta
linguagem.

 

A API Swing é poderosa, flexível e imensa, que possui pacotes públicos, cada
um com sua própria finalidade distinta:

V
 |

Pacote swing de alto nível , consiste primariamente de componentes,

adaptadores, modelos padrão de componentes e interface.

V

 

O pacote border declara a interface Border e classes, que define específico

estilo de borda.

V




 

O pacote colorchooser contém classes de suporte para componentes color

chooser .

V



O pacote de event é para eventos e listeners específicos Swing. Adiciona ao

java.awt.event types, componentes Swing podem gerar seus próprios tipos de
eventos.

V
 

O pacote filechooser contém classes de suporte para componentes de seleção

de arquivos.

V
 

Plug-in look-and-feel (PLAF) pacote que contém Interfaces com usuário(UI)

classes (delegadas) que implementam diferentes look -and-feel aspects para
componentes Swing. Há também alguns pacotes de PLAF sob a hierarquia.

V
 

O pacote table contém suporte para interfaces e classes para o componente

Swing table.

V
 

O pacote text contém classes de suporte para o framework do Swing de

documento.

V
 

O pacote text.html contém classes de suporte para HTML versão 3.2

interpretador e analisador.

V
 

O pacote text.rtf contém classes de suporte para um básico interpretados Rich

Text Format (RTF).

V


O pacote tree contém interface e classes para o componente tree do Swing.

V


O pacote undo provê classes de suporte para implementar a capacidade de

fazer/desfazer nos GUI.

V
   

O pacote de acessibilidade da JFC é incluido nas classes Swing. Entretanto,

seu uso não será discutido aqui.

ë

  
O widget é um termo sem tradução que designa componentes de interface
gráfica com o usuário (GUI). Qualquer item de uma interface gráfica é chamada
de widget, por exemplo: janelas, botões, menus ítens de menus, ícones, barras
de rolagem, etc.

O pacote de acessibilidade da JFC é incluído nas classes Swing. Entretanto,

seu uso não será discutido aqui.

˜
|   |
| |  || |
˜
|||   |
| ||
| 
 |

c
 
 


 




JApplet JBorders JButton JCheckBox

JCheckBoxMenuItem JColorChooser JComboBox ImageIcon

JDialog JFileChooser JInternalFrame JLabel

JList JMenu JMenuBar JOptionPane

JPopupMenu JRadioButton JRadioButtonMenuItem JScrollBar

JScrollPane JSlider JSplitPane JTabbedPane

JTable JTextArea JTextField JToggleButton

 JToolBar JToolTip JTree

c
ë 

ë



ë 


ë 


Quase todas as interfaces gráficas são compostas de uma janela principal ou

de alto-nível, onde são montados os outros componentes. Na Swing essas
janelas são geralmente uma instância das classes JFrame ou JWindow. A
diferença entre essas duas classes está na simplicidade, JWindow não tem a
barra de título e não coloca botões na barra de tarefas, portanto utilizaremos a
JFrame.

JFrame é a versão Swing do Frame(AWT) , porém ela é descendente direta da

classe Frame, por isso ao adicionarmos componentes ao JFrame teremos que
utilizar o JPanel para gerenciar estes componentes .

Características da JFrame: Janela com título, bordas, barra de menu (opcional)

e componentes especificados pelo usuário. Esta pode ser movida , ter o
tamanho ajustado e permitir a adição de ícones. Veremos a seguir um exemplo
de um JFrame.


 V



   
   


   

  
  
    ! 
   !

"

 

#   
 $  #
 %  
  &'()%*)#+%,
 ,- .//0.//
 1   
"
   

 , 23

 
  V      
  
V   #   
"

"

Copie o código e salve um um arquivo chamado "ExemploJFrame.java"

compile com o comando V
!
 )
) 4

V
! (sem aspas) e
rode com o comando V
!
 )
) 4

! (sem aspas e sem o .java).
o resultado esperado é este:

Figura 3 - Exemplo JFrame.|

Vamos ver o código: para usar os elementos do java swing temos que utilizar o
"import javax.swing.*" , em seguida declaramos a classe ExemploJFrame e
instanciamos um JFrame chamado de f com o parâmetro que define o título da
janela("Exemplo JFrame"), em seguida temos o método construtor da classe, o
CriaFrame(), neste método utilizamos 3 setings importantes . O primeiro será
utilizado em todos os exemplos do curso e serve para encerrar o programa ou
a interface, ao clicarmos no b otão fechar da janela. Sem esta linha nada
aconteceria ao tentarmos fechar a janela, esta só fecharia ao encerrarmos o
programa. O segundo set define o tamanho da tela, neste caso 300 x 300
pixels, mais à frente no curso veremos que em alguns casos não ser á
necessário definir o tamanho da tela, vamos utilizar gerênciadores de layout
que ajustam a tela de forma que todos os componentes estejam visíveis.
Finalmente o último "set" mostra a janela na tela.

Em Java, a classe Container é a classe abstrata que def ine as funcionalidades

básicas associadas a um container, tais como adicionar e remover
componentes, o que é possível através dos métodos add() e remove(),
respectivamente. É possível também estabelecer qual a estratégia de
disposição de componentes no container, ou seja, qual o método de gerência
de layout, através do método setLayout(). Estudaremos layouts na próxima
lição.

Agora vamos adicionar um botão ao exemplo anterior, para isso vamos

adicionar um botão JButton ao JPanel e o JPanel ao JFrame . Veja o código:

‘

‘ 


‘ 
 |

ï



ï
 
 

ï
 ï

ï

ï




ï


 

  ï

ï 

ï
  


!"  #ï 

!$%&'#(' )#*

!*+,--.,-- //

0


ï! 
  //  
   

! ï //  ï 


1 


!2
 

ï
 
*3 345 


ï
6  
ï


6  !  


Ú|

Lembrando que para salvar o arquivo devemos utilizar o mesmo nome da

classe ,ou seja, neste caso seria "Exemplo2fb.java". O resultado do código é:
 i

 4   
 Pl  
t
.|

A l ifi i i i t i t t
f , ti li i l ti P l. A f i t
ifi t t j l .E t f i
fi i t t , t l t f if t
i i P l? A t t t
t li i t.

i

    
 B
t
|

P t i i t li S i l
t i tij l , j i i
i tili t i i i ti
objetos desejados ou componentes, b otões , campos de texto , etc. Por
definição, Containers são componentes que podem conter outros
componentes. Como exemplo de containers temos JWindow , JFrame e
JPanel, porém o JPanel deve ser adicionado a um dos dois anteriores.

c
ë 

ë



ë



ë



Os componentes são como tijolos nas aplicações Swing, estes podem ser
agrupados em containers para construir uma interface gráfica. Temos uma
infinidade de componentes e a maioria deles pode ser configurada de diversas
formas o que oferece uma grande flexibilidade no desenvolvimento de
interfaces gráficas.

Neste curso veremos apenas os componentes mais básicos, porém

conhecendo estes será muito mais fácil utilizar qualquer outro. Os principais
componentes são :

+  - JLabel é um componente utilizado principalmente para mostrar

textos e nomear outros componentes. Se comparado ao Label do AWT, o
JLabel tem 3 vantagens importantes: a primeira é que este pode ser utilizado
também para mostrar imagens, a segunda é a possibilidade de usar bordas
delimitando campos em uma janela. E a terceira é a possibilidade de utilizar
HTML para formatar o label, isto é feito adicionando <html> ao início da string
do label, assim ele é interpretado como HTML possibilitando mudar fontes,
cores dentre outros efeitos. O JLabel pode ter fonte, tamanho e cor
configurados, porém se for utilizado o HTML os controles padrões do JLabel
serão ignorados.

Vejamos alguns exemplos:

‘

‘ 




‘ 


‘ |

‘ |

‘ |

‘ 
|

‘ 
|
   ! 
"!|
   ! # !|
   !$%%&%'%()*+)+,)(*!
|

   |
Ú|

‘‘-.‘ |
 
/.'
‘  
&0%1'21.'$|

$‘34556455|


-- |


-- |

--
|

7‘‘|
Ú|

‘‘‘- ‘ $‘ 89|

 
    
|
 
.‘ |
Ú|
Ú

Resultado:

˜
|| |   |

Agora usando HTML, veremos ícones mais a frente em JButons.

V

‘


 |

‘ 
 |

‘  |

‘ |

‘ |

‘ 
 |

‘ 
 |

   ! 
:! |

  !;< =;'2%

.''> >/=;*=‘- 
  %);?*=;?'2%=;?< =! |


*-*-@
%‘-*-!
 -! |

  !  ! |

    |

Ú|

‘‘-.‘  |


/.'
‘  
&0%1'21.'$ |


$‘34556455 |

@ *-@ |

--6*-@
2'>%  |

--6*-@
.2%> |


--
 |


7‘‘ |

Ú|

‘‘‘- ‘ $‘ 89 |

 
    
 |

 
.‘  |

Ú|

Ú|

Note que neste caso foi necessário importar o "java.awt" devido ao uso de Layouts. O resultado do
exemplo é:
 ˜
|!|| | | |"

5
 - Botão que pode conter um texto ou um ícone, suas
funcionalidades são controladas pelo actionlistener, existem muitas
fucionalidades que podem ser atribuídas a um botão, neste curso abordaremos
apenas princípios básicos, assim fica a cargo do alun o pesquisar uma
funcionalidade específica na documentação da Sun ou nos vários sites sobre
Swing na Internet. Uma grande vantagem do swing é que você pode
redimensionar e arrastar a janela sem configurar nada e os componentes são
reorganizados também de acordo com o layout escolhido.

Exemplo JButton com imagem:

‘
 


‘
 
‘ 



‘*  - 

‘‘‘- ‘ $‘ 89 
* 
Ú

‘* 

! 
* ! 
      
. ‘    .    
/.'
‘  
&0%1'21.'$ 
  
@ @ 
* A  * !*  ! 
  
--A 
0 0 -  0 0 !A

! 
*   * - 

*B -.
@ ?? /‘    -
 --C 


 

  
  
 
 
     
  


 



Result
:

˜
|||
 | |

j

 text iel uma ea ara text ue e ser muit til ara
f rmul ri s. Este mponente eralmente usado ombinado om o abel
ue adciona um nome ao campo.

j 

similar ao Button, porém esse é usado para marcar 1 ou
mais opções dentre as disponí eis.

Exemplo ext ield e RadioButton :

  
  


     
 !" #
     
$
%&  #|

  |
|
    #|
'( !"'|
!" )
 !"  

 !"|
*

 

 ) *

+
  * 

 |
, * -
!"(./0-10*2-$( 
3     |
$345567
5  
 
  
|


28 
 9 28   
 8   

 |
!+
 
7 )
 !+
   
 : 
;  
 
  |
" 28  8  )
 " 28 

  8   

 

|
8 <

" 28 2("  
 

 = : |

728 8    
 8   
7  8  =
:|
!+
 

)
 !+
 
 : 
;   
> 
 |


28 8   
 8   
?  8  = : |
!+
 
? )
 !+
 
? 
        
  |

?28 8  |
!2 
 )
 !2 '1 '   |

7
 
    
 7|
% ‘-    % ‘-A5

‘ A
--  
 -  ! -D!

‘ 
-- -
% ‘- -  % ‘-45

‘ 
-- -
   !$ E!

‘ 4
-- 
>-‘*  ‘   >-‘* !)‘ !


‘ 4
-- ‘ 
>-‘*    >-‘* ! ‘ ‘ !

‘ 4
-- 

  
--
‘ A6*-@
2'>% ??-‘ 
‘ A 
  
- ‘ 
  
--
‘ 6 *-@
.2%>?? -‘  
‘   

 - ‘ 
  
--
‘ 46 *-@
$',%  ?? -‘  
‘ 4  
 
- ‘ 
7‘‘
Ú
Ú
Resultado:

˜
|#||˜ 
| |$
% |

6 
  - este é o campo utilizado para senhas, sua utilização é
idêntica ao do JTextField e o texto digitado aparece como "*" (o caractere que
aparece no JPasswordField também pode ser configurado).

6   - é container intermediário, pois deve ser adicionado a um outro

container(JFrame ou JWindow). É a forma mais simples de se construir uma
interface, basta instanciá-lo adicionar os componentes a ele e então adiconar o
JPanel a algum container. No exemplo aci ma utilizamos 3 instâncias do JPanel
e adicionamos a cada uma um JLabel e um Componente e em seguida
adicionamos cada JPanel a uma área do JFrame.

Uma das razões de se utilizar o JPanel é que Componentes em um JPanel

dentro do frame não são reajustados, o u seja, podemos aumentar a janela e o
tamanho dos componentes permanecerá o mesmo, o que observamos que não
acontece se adicionarmos direto ao JFrame(como visto na primeira página
desta lição) .

c


 

c


 

c
4s erenciadores de ayout são responsáveis por organi ar os componentes
em um container, não só ao adicionarmos mas também uando
redimensionamos as janelas. É possível usar diversos tipos de gerenciadores
em uma mesma interface, assim como é possível desligar" o gerenciador de
layout para um dado container e definir manualmente a posição , o tamanho e
outras configurações de cada componente adicionando ao container. ada tipo
de container tem um layout padrão, porém freqüentemente temos que mudar o
layout do container para obter a disposição dos componentes desejados.
Veremos agora as principais características de alguns gerenciadores de layout.

˜
4 gerenciador de layout de ³fluxo´ apenas posiciona os componentes em fila,
um após o outro, cada qual com suas dimensões mínimas. 4 lowLayout imita
o fluxo de textos e pode alinhar os componentes direita, esquerda, ou
centrali a-los dentro do container. 4 uso mais comum deste layout é para
preencher uma linha com maior quantidade possível de compone ntes, por
exemplo em barras de ferramentas ou de status.

igura 1 - Exemplo lowLayout |

igura 11 - Exemplo lowLayout redimensionado |

‰

 

4 BorderLayout posiciona os componentes nas ³bordas´ do container,

deixando a maior parte de sua área disponível para o componente inserido no
centro. ada borda é identificada por um ponto cardeal 4RTH,S4 TH,
EAST, EST). Apenas um componente será visível em cada borda,
expandindo-se na altura ou largura para ocupar toda a borda do container,
porém assumindo o valor mínimo na outra dimensão. 4 BorderLayout é o
layout padrão do rame, por isso, na lição quando adicionamos um botão ao
rame ele automaticamente ocupou a posição central, como os outros pontos
norte, sul, etc.) não foram utili ados o botão ocupa todo espaço da janela
mesmo que ela seja redimensionada. Os pontos norte e sul podem ser
reajustados horizontalmente. Os pontos leste e oeste podem ser reajustados
verticalmente e o central em todas as direções ( Obs: Experimente adicionar
um botão a cada um deles e reajustar a janela).
Note que esta disposição reflete o padrão na maioria das aplicações desktop,
como processadores de texto ou prog ramas de desenho: uma barra de
ferramentas ao norte, uma barra de status ao sul, opcionalmente outras barras
de ferramentas ao leste e oeste e uma área de edição ao centro.


V
 5
 + 


V
 #
  

V
 $ 


V
5


V
  

V
+ 

  $ 
5
 + 

  

 7'89()(%)+(   

  

 #

 (
6  #
     
:   + 
 
5
 + 

    + !%#
  ;<
 5
 + 
:! 
 
"

7'89()(%)+(
   #

 %  

V
 #

 %  
7'89()(%)+(
"

5
 
  5
!5

=6>8'*>)'*'#'>7! 
    
05
 + 
6>8),(>7(

?? -   - @A
   

  0  4 
??


 5
 + 


  5
!5

B#*(7%!

 6   ,-  $ 
B//0=//
    
05
 + 
#*(7


  5
!5

.'*'#'>7)+'*9>!
    
05
 + 
+'*),(>7(


  5
!*%CD+%*8%5

E'C)6>8'*>!
    
05
 + 
6>8)*$


  5
!F'C)+'*9>!
    
05
 + 
+'*)*$
"
?
# 8G' 
  6     0
   


  

     
  
 


D  
?

  

  >,
8G'
?? -
4     
 
 V   
   $  +

H> $ 
   

??#  
 -  V   
        !$ 
5
 + 
!
   $  #
 %  
  &'()%*)#+%, 

??% - 

 

  
#

 (
6     #
 6  
 ??G


 

  
 ;<

5
 + 
*A
I   

 
?? + 
 5
 + 


?? V   
   H
   1   
"

  

 ,23 
??>   
  

D  J
??       
8G'
V
,G 

H +   7   
 


  >,
8G'
"
"
"
"
Resultado:

˜
|| | |%
& |

 c

O GridLayout organiza os componentes em uma grade´ ou tabela com número

de linhas e colunas pré-fixado no momento da sua criação. Todas as células
possuem o mesmo tamanho e são expandidas igualmente para ocupar a área
total disponível no container. Caso haja menos componentes do que células, o
espaço das células vazias é distribuído entre os componentes; mas podem
ficar células vazias nas últimas colunas da última linha.
O GridLayout é adequado quando se deseja que um grupo de componentes
(ex: Um grupo de botões) tenha dimensões uniformes, como na c aixa de
ferramentas de um programa de desenho ou par de botões OK´ e Cancelar´
de um diálogo.

V
  |


V
 |


  $ 
8+ 
 |
    

 7'89()(%)+(    |


  

 #

 (
6  #
     |

7'89()(%)+( |

   #

 %  
 |

#

 %  
7'89()(%)+( |

"|


   + 
 8+ 
/0B |


    5
!5


=! |

    5
!5


B! |

    5
!5


.! |

    5
!5

*
 D+

E! |

    5
!F! |

"|


?|

# 8G' 
  6     0 |

   


  

      |

  
 


 D   |

?|


  

  >,
8G' |

?? -
4     
 
 V    |

   $  +

H> $ 
    |


??#  
 -  V    |

        !$ 
8+ 
! |

   $  #
 %  
  &'()%*)#+%, |
 
??% - 

 

   |

#

 (
6     #
 6   |


?? V    |

   H |

   1    |

"|


  

 ,23  |

??>   
  

 D  J |

??       

8G' |

V
,G 

H +   7   |

 

 |

  >,
8G' |

"|

"|

"|

"|

Resultado:

˜
|'| | |(

&| |

 c

Com nome estranho( saco de grades´), o GridBagLayout é o mais poderoso e

o mais flexível dos gerenciadores fornecidos com o J2EE. Ele imita em linhas
gerais o funcionamento de uma tabela HTML, em que um componente pode
ocupar várias células, ou seja, se estender por várias colunas e linhas.
Os componentes podem ser expandidos para ocupar toda a área das suas
células, ou serem alinhados em qualquer posição do conjunto de células.
Linhas e colunas assumem as dimensões do maior componente, mas é
necessário que tenham todas o mesmo tamanho. E algumas células podem ser
configuradas para ocuparem toda a área disponível no container.

Este layout tem como base a utilização de um GridBagConstraints para cada

componente inserido. É este objeto que proporcionará a lib erdade que
queremos com o layout. A GridBagConstraints é uma classe que não possui
métodos, ela servirá simplesmente para armazenar as informações para cada
componente adicionado. Vamos dar uma olhada nas propriedades da classe:

anchor: Essa propriedade é utilizada somente quando o tamanho do

componente é menor que a área que lhe foi concedida. Normalmente,
queremos que nosso componente ocupe toda a área disponível, mas em casos
especiais, não podemos redimensionar os componentes. Sendo assim, o layout
precisa saber em que posição da célula deixará o componente. Os valores para
esse campo são de dois tipos: Absolutos (CENTER, NORTH, NORTHEAST,
EAST, SOUTHEAST, SOUTH, SOUTHWEST, WEST, e NORTHWEST) e
Relativos (PAGE_START, PAGE_END, LINE_START, LINE_END,
FIRST_LINE_START, FIRST_LINE_END, LAST_LINE_START and
LAST_LINE_END). O valor padrão é CENTER.

fill: Determina como redimensionar o componente. Valores possíveis para esta

propriedade são:
NONE: Não redimensiona o componente;
HORIZONTAL: Redimensiona horizontalmente, fazendo com que o mesmo
ocupe toda a área horizontal na célula;
VERTICAL: Redimensiona verticalmente, fazendo com que o mesmo ocupe
toda a área vertical na célula;
BOTH: Redimensiona para ambas as direções.
Valor padrão é NONE

 
 
Especificam a posição X,Y para adicionar o componente. Não é necessário
alterar seus valores, pois seu valor padrão é a constante RELATIVE e portanto
o layout adicionará após o último componente que foi colocado.

- gridx: Permite especificar qual a posição absoluta horizontalmente que o

componente será adicionado;

- gridy: Permite especificar qual a posição absoluta verticalmente que o

componente será adicionado.

 
 
   
Especificam o tamanho do componente baseado em células. É com essa
propriedade que você indicará que um componente seu ocupará duas células
ou ocupurá tantas quanto forem necessárias para ir até o final da tela.
Lembrem-se é células e não pixels.

Nestes valores podem ser utilizadas duas constantes: REMAINDER e

RELATIVE. REMAINER fará com que o componente se estique até a última
célula. Já o RELATIVE fará com que o componente ocupe todas as casas com
excessão da última.
- gridheight: Especifica o número de células que o componente ocupará
verticalmente. Valor padrão é ;
- gridwidth: Especifica o número de células que o componente ocupará
horizontalmente. Valor padrão é .




Indica as distâncias entre os componentes do layout. Um Insets possui valores

para as direções, cima, baixo, direita e esquerda. Permitindo co m isso muita
flexibilidade no gerenciador. Valor padrão é new Insets(0, 0, 0, 0).


 
Essas propriedades especificam um percentual de crescimento da célula, não
do componente, quando a mesma precisa ser redimensionada. É dito isso,
porque se o componente não pode se redimensionar, pois a propriedade fill do
constraint afirma isso, o componente não vai sofrer as alterações, mas a célula
irá aumentar.
Com este layout é possível informar que uma célula redimensionará 75% e o
outra 25%, portanto, o primeiro componente receberá 3 vezes mais tamanho
do que o segundo.
O valor padrão é 0 e os valores percentuais são dados em casas decimais, por
exemplo: 0.03 é igual a 3%, .00 é igual a 00% e por aí vai.
- weightx: Peso em x. Especifica um peso no redimensionamento. Este peso
será utilizado para um cálculo que o layout faz para determinar quais as células
irão redimensionar horizontalmente, quais não irão e quais aumentarão mais
que as outras.
- weighty: Peso em y. Especifica um peso no redimensionamento. Este peso
será utilizado para um cálculo que o layout faz para determinar quais as células
irão redimensionar verticalmente, quais não irão e quais aumentarão mais que
as outras.


 
Determina um adicional nas bordas internas do componenete. Essa
propriedade modifica o tamanho mínimo de cada componente. O tamanho
mínimo será o ipad + o valor mínimo do componente.
- ipadx: Valor para ser adicionado horizontalmente.
- ipady: Valor para ser adicionado verticalmente.

Podemos afirmar com segurança que qua lquer disposição de componentes

pode ser configurada em um GridBagLayout. Por outro lado, a quantidade de
constraints(propriedades e restrições de layout) possível para cada
componente também deu a este gerenciador a fama de ser difícil de programar.
|
‘



‘

‘ 
*  
‘

‘ 
  


‘/ F‘-*@ 
‘ ‘ <-‘  
‘ ‘ <-G‘<&  
‘ ‘ >0F %1%'1%  


‘‘‘---.
  % . ‘ 
  
‘>0F %1%'1%

 
.
  '‘ ‘ .
  '‘ ‘
>0F %1%'1
%
Ú

*  

 
@ F‘-*@ 
F‘-*. ‘   F‘-*. ‘  
‘<-‘
?? 6  ‘ 


‘ F‘-*. ‘ 
 '>0H'2%( 
Ú

   * !*A! 
‘<-G‘<&

‘<  5
:
Ú

‘-  5

‘-@ 5

 
-- 6

   * !*! 

‘-  A

‘-@ 5

 
-- 6

   * !*4! 

‘-  

‘-@ 5

 
-- 6

   * !*" I2 I !

‘
-@ "5??3
   

 
‘<  5
5

‘-‘-< 4

‘-  5

‘-@ A


 
-- 6

   * !:! 

‘
-@ 5??3‘

- 

‘<@ A
5??J‘‘ 
‘ 


 < F‘-*. ‘ 
(F12/??
 ‘ 


‘   0 A5656565??

--‘  

‘-  A??‘ <  - 


‘-‘-< ?? 


‘-@ ??‘‘ <


 
-- 6
Ú

?
.‘ F,0 ‘
<-@6 
 -
-‘ 
 <- 
--‘
-   I-‘
<‘ <-

?

‘‘‘-( -$<F,0 
??3 J < -- 

 
/B( -/- 

??.‘ ‘3 

     !/ F‘-*@! 
 
/.'
‘  
&0%1'21.'$ 

??' ‘3 - 
‘ 

--.
  %  
.    

?? ‘ 

 

B
 
7‘‘
Ú


‘‘‘- ‘ $‘ 89 
??( - <
  I-‘
<‘ <-E
??‘ ‘ 
‘F,0


‘ 
$‘ ,‘‘‘
‘ B >  

‘‘- 
( -$<F,0
Ú
Ú
Ú
Ú
Resultado:
 ˜
|)| | |(
%
& |

c
!"  
#
$  

"  
#
$  

Agora que você já aprendeu como colocar componentes na tela, você vai saber
como responder as ações do usuário com os componentes. O principal
mecanismo para isso é o padrão Observer, implementado em Swing com os
"event listeners"(ou observadores de eventos). Os componentes emitem
notificações sobre eventos e o event listener recebe essas notificações. Por
exemplo, para executar um código quando o usuário aperta um botão, você
deve definir um listener para o evento "pressionar botão" e ligar o evento a
esse botão.

‘



‘


 
(‘   
‘


 
(‘ ‘  
‘

‘ 
 

‘)‘    -  



‘‘‘- ‘ $‘ 89 

)‘  
Ú|

‘)‘   




! 
(‘ ‘ ! 

$‘34556455 

/.'
‘  

&0%1'21.'$ 

. ‘    .    

  
@ *-@ 
  
‘     @ 

* A  * !*A! 

‘ 
--A

A
--(‘ ‘  )@* ‘ 
<‘ 

‘ 
-- * !*! 

‘ 
-- * !*4! 

  
--
‘ 6*-@
$',%  

  
-- $  % (6
*-@
.2%> 

‘     @ 

‘ 
-- !/‘‘  ! 

‘ 
-- % ‘-A5 

$‘ 
89  $‘ 89!'
DCA!6!'
DC!6

!'
DC4!Ú 

‘ 
-- . * 
 

  
--
‘ 6*-@
2'>%  

B 

7‘‘ 

Ú

‘)@* ‘ ‘
  

(‘ ‘  



‘ 
 .
   

)@* ‘  
 .
   



<‘

 .
   
 .
   

Ú
     
+  <
(
 

!-
+
 @,  
* 

6 '9-A-

7 +B($$/-1<,-C'

Resultado:

igura 1 - Exemplo ActionListener |

igura 16 - Exemplo botão pressionado |

este exemplo, nós criamos um ActionListener e ligamos apenas ao botão1. A
interface do ActionListener tem apenas um método: actionPerformed. Esse
método é chamado quando uma ação ocorre. 4 evento ActionEvent é o tipo
mais comum em Swing - a maioria dos componentes produzem um
ActionEvent. omponentes podem também produzir outros eventos - como a
mudança da seleção atual, texto ou tamanho. Por enquanto, o nosso foco é no
ActionEvent. Em todo o caso, procure ,em uma I E que exibe métodos de uma
classe, por métodos que começam com add e terminam com Listener por
exemplo, addFocusListener) para ver que tipos de event/Listener um
componente suporta.

ais uma coisa interessante neste exemplo é a utilização da classe

4ptionPane. Essa classe contém muitos métodos teis que ajudam na
exibição padronizada de diálogos entradas e diálogos d e mensagem.

4 exemplo acima não está escrito no estilo usual para Swing. á que a nica
fução do listener é chamar um método, ele é freqüentemente escrito como uma
classe interna anónima inner class).
 *A
--(‘ ‘  |

(‘ ‘  



K‘‘-‘  -(‘   



'
‘  
<)/‘)‘  
<‘6!*'%L'>$$0'2
(/'M! 

Ú

Ú

Podemos observar que existem também outras formas de receber notificações

eventos e, em seguida, instalar um listener para cada objeto n a tela. Por
exemplo, o código abaixo instala um listener global para pressionar a tecla F :

ß@$BB ß@$B
ß@$Bß@ 
7ß1A65

.
  
0
)

.
  
G 21(2.$%'>1'1'.,$/1.')'22%

B6! 
!


.
  
(‘ )


! !6
((‘ 


‘‘-‘  -(‘   

??J -‘N   J‘ 
Ú
Ú

Este curso abordou apenas alguns tópicos do Java Swing já que qualquer
abordagem profunda de qualquer tópico da linguag em Java se torna muito
extensa.

Parte deste curso foi retirada do site

www.javanoroeste.com.br/200 /tutoriais/swing_basico.html (tutorial escrito por
Marli Esprega Gonçalves)
|