Introdução a aplicações gráficas em Java

Neste artigo vamos ver como criar aplicações gráficas em Java, mais precisamente usando um Framework ( conjunto de classes ) chamado Swing. Veremos três exemplos, começando com um simples programa que apenas escreve uma mensagem na tela, passando para um programa que já trabalha com caixas de texto e botões, e por final veremos como trabalhar com listas. Há ainda uma seção especialmente sobre gerenciamento de layout, os chamados "Layout Managers", item muito importante quanto se trata de programação GUI. Não é necessário que você tenha alguma experiência anterior em programação gráfica com Java, porém um minimo de conhecimento da tecnologia ajudaria, apesar de não ser imprensindível, uma vez que é bastante comum as pessoas terem o primeiro contato com Java através de programação gráfica. Conhecimentos de lógica de programação são necessários, mesmo que seja apenas uma base. Para digitar os programas você pode usar qualquer editor de textos ou código de sua preferência, tais como Notedad, UltraEdit, VI, Emacs, KWrite e assim por diante. Programas em Java necessitam do JDK para serem desenvolvidos e, uma vez compilados, apenas a JRE faz-se ncessário. O JDK, por já ser um ambiente completo de desenvolvimento, já trás uma versão da JRE, portanto você não precisa ter os dois pacotes instalados na mesma máquina. Se você nunca mexeu com Java ou não tem ( ou não sabe como instalar ) o JDK, dê uma lida nos tutoriais "Instalando e configurando o JDK no Linux" ( ou "Instalando e configurando o JDK no Windows" caso seja usuário de Windows ), " Classpath, entendendo o que é e para que serve", "Sopa de letrinhas sabor Java" e "Os erros e dúvidas de um iniciante", disponíveis no site do GUJ seção "Artigos" e "Tutoriais".
Conhecendo o Swing
Nas primeiras versões do Java a única forma de fazer programas gráficos era através da AWT, uma biblioteca de baixo-nível que dependia de código nativo da plataforma onde rodava. Ela traz alguns problemas de compatibilidade entre as plataformas, fazendo que nem sempre o programa tinha aparência desejada em todos os sistemas operacionais, sendo também mais difícil de ser usada. Para suprir as necessidades cada vez mais freqüentes de uma API mais estável e fácil de usar, o Swing foi criado como uma extensão do Java a partir da versão 1.2. Swing fornece componentes de mais alto nível, possibilitando assim uma melhor compatibilidade entre os vários sistemas onde Java roda. Ao contrário da AWT, Swing não contém uma única linha de código nativo, e permite que as aplicações tenham diferentes tipos de visuais ( skins ), os chamados "Look and Feel". Já com AWT isso não é possível, tendo todos os programas a aparência da plataforma onde estão rodando. Apesar da AWT ainda estar disponível no Java, é altamente recomendável que sejam usado Swing, pelas razões descritas aqui e por várias outras. Componentes Swing contém um "J" na frente, como em JButton por exemplo. Componentes AWT não contém inicial alguma ( "Button" no caso ). Além disso tudo, as vantagens do Swing não param por ai. Há uma enorme gama de controles extras disponíveis, tais como áreas de texto que nativamente podem mostrar conteúdo RTF ou HTML, botões com suporte a imagens, sliders, selecionadores de cores etc. É também possível alterar o tipo de borda para a maior parte dos componentes, todos podem ter imagens associadas e é possível até ter controle de como são desenhados os mínimos detalhes de apresentação.
Começando
O código completo do programa, que não é grande, vai ser mostrado completo primeiramente, para depois então analizarmos cada instrução dele. Digite o seguinte código em um arquivo chamado "SwingExemplo1.java". Note que é muito importante ficar atendo em relação à maiúsculas e minúsculas, o Java nota a diferença entre tais caracteres. 
view plainprint?
import java.awt.BorderLayout; 

import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.JPanel; 


public class SwingExemplo1 extends JFrame 
{ 
JPanel panel; 
JLabel msg; 

public SwingExemplo1() 
{ 
super("Java!"); 
} 

public void criaJanela() 
{ 
panel = new JPanel(); 
msg = new JLabel("GUJ.com.br"); 

panel.add(msg); 

getContentPane().add(panel, BorderLayout.CENTER); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 
} 

public static void main(String args[]) 
{ 
SwingExemplo1 s = new SwingExemplo1(); 
s.criaJanela(); 
} 
} 

Não se assuste e muito menos não se intimide com o código, o qual pode parecer um pouco complicado no início. À medida que você vai pegando experiência em programação Java, as nomemclaturas e nomes de classes e métodos vão se tornando comuns, ficando fácil de lembrar. Vamos ver agora as partes mais importantes do programa e o que cada uma delas fazem. Primeiramente temos as declarações que importam as bibliotecas necessárias para o nosso programa: 
view plainprint?
import java.awt.BorderLayout; 

import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.JPanel; 

Estas linhas são muito importantes, pois caso alguma falte ou esteja errada, o programa não irá nem compilar. Os nomes podem parecer estranhos, mas tudo tem um padrão bem definido e fácil de ser lembrado. Por exemplo, o nome "javax.swing.JLabel" diz que estamos requisitando a classe "JLabel", que faz parte do pacote de utilidades gráficas "swing", o qual pertence ao pacote "javax". Seguindo temos a declaração da classe em si, na linha 
view plainprint?
public class SwingExemplo1 extends JFrame 

. Isso diz que o nome do nosso programa será "SwingExemplo1", e que ele deve já herdar por padrão tudo o que a classe "JFrame" disponibiliza. Em 
view plainprint?
JPanel panel; 
JLabel msg; 

temos a declaração de 2 variáveis que representam o painel onde ficarão os componentes e uma label de texto, respectivamente. A próxima instrução, 
view plainprint?
public SwingExemplo1() 
{ 
super("Java!"); 
} 

tem o mesmo nome do nosso programa, e é chamada de "construtor". Dentro dele chamamos um método da classe pai - JFrame - a qual herdamos. Esta linha configura o título da janela para "Java!". Em seguida criamos um método chamado "criaJanela", o qual usaremos para criar os componentes e mostrar a nossa aplicação. Dentro deste método ( para quem não sabe, um método é nada mais do que uma função normal, porém pertencente a uma determinada classe ) é que fazemos todo o "trabalho sujo". Primeiramente criamos um painel para acomodar os componentes e por fim é criado um label de texto contendo a frase "GUJ.com.br". Tudo isso pode é feito nas linhas 
view plainprint?
panel = new JPanel(); 
msg = new JLabel("GUJ.com.br"); 

A linha 
view plainprint?
panel.add(msg); 

executa a tarefa de adicionar o nosso componente de texto ao painel. Um programa gráfico em Java pode conter 3 tipos diferentes de janela: Um JFrame, o qual usamos em nosso exemplo, para representar a janela "principal" da aplicação, um JDialog para representar uma janela de diálogo (uma janela secundária, como uma janela de formatação de fonte do texto, por exemplo ), e, por último, um JApplet para ser usado em Browsers. Importante: você não precisa saber essas coisas decoradas! O java possui um poderosíssimo sistema de documentação, e você tem acesso a isto em https://java.sun.com/j2se/1.4/docs/api/index.html. Por fim, neste método, as linhas 
view plainprint?
getContentPane().add(panel, BorderLayout.CENTER); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 

Dizem ao Java que queremos os componentes centralizados na tela, que ao clicar no "xizinho" da janela é para terminar o programa, faz com que a janela seja redimensionada de maneira a acomodar corretamente os componentes nela contidos, e, por último mas não menos importante, fazemos a janela ser mostrada, respectivamente. Salve o arquivo com o nome SwingExemplo1.java ( não esqueça das maiúsculas e minúsculas ) e depois compile: 
view plainprint?
javac SwingExemplo1.java 

e execute-o: 
view plainprint?
java SwingExemplo1 

Se tudo ocorrer perfeitamente, você irá ver uma pequena janela com o título "Java!" e escrito 'GUJ.com.br" no meio dela. Gerenciamento de layout Gerenciamento de layout ( Layout Management ) é o processo de determinar o tamanho e a posição dos componentes na janela gráfica do programa. É ele o responsável por determinar onde o componente irá ficar, como irá ficar, qual o comportamento a ser tomado na hora de redimensionar a tela. Por padrão o Java vem com cinco gerenciadores de layout: BorderLayout, BoxLayout, FlowLayout, GridBagLayout, GridLayout e um adicional chamado CardLayout. São os gerenciadores de layout que determinam como os componentes irão ficar em seu programa, portanto um bom conhecimento sobre o funcionamento dos mesmos faz-se necessário para ter domínio de programação gráfica em Java. Geralmente, quando chamamos o método "add" para adicionar um componente na tela, ele será posicionado de acordo com o gerenciador de layout previamente configurado. A maior parte simplemente vai adicionando os componentes com base na ordem em que foram programados, porém alguns outros, como o BorderLayout, necessitam que você informe a posição relativa no container. A escolha do gerenciador de layout depende muito das necessidades do programa. Por padrão todos objetos JPanel são configurados para usar o FlowLayout, enquanto um JFrame e JDialog já usam o BorderLayout como padrão. Em ambos os casos é usado o método "setLayout" para especificar um novo layout manager, sendo necessário passar para este método o tipo que desejamos. Abaixo há um exemplo para cada tipo de gerenciador de layout, ficando assim fácil para vermos como cada um se comporta.
O programa BorderLayoutTest.java
O primeiro exemplo mostra como um BorderLayout funciona. Digite o seguinte código e salve como "BorderLayoutTest.java": 
view plainprint?
import javax.swing.*; 
import java.awt.*; 

public class BorderLayoutTest extends JFrame 
{ 
public BorderLayoutTest() 
{ 
JButton botao1 = new JButton("Botão 1"); 
JButton botao2 = new JButton("Botão 2"); 
JButton botao3 = new JButton("Botão 3"); 
JButton botao4 = new JButton("Botão 4"); 
JButton botao5 = new JButton("Botão 5"); 

// Como o padrao de um JFrame é o 
// BorderLayout, simplesmente adicionamos 
// os componentes na tela 
getContentPane().add(botao1, BorderLayout.NORTH); 
getContentPane().add(botao2, BorderLayout.CENTER); 
getContentPane().add(botao3, BorderLayout.WEST); 
getContentPane().add(botao4, BorderLayout.SOUTH); 
getContentPane().add(botao5, BorderLayout.EAST); 

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 
} 

public static void main(String args[]) 
{ 
new BorderLayoutTest(); 
} 
} 

Compile usando 
view plainprint?
javac BorderLayoutTest.java 

e execute com o comando 
view plainprint?
java BorderLayoutTest 

Usando BoxLayout
Um BoxLayout coloca os componentes em uma única linha ou coluna, permitindo ainda que você especifique o alinhamento deles. Digite o seguinte programa e salve em um arquivo chamado "BoxLayoutTest.java": 
view plainprint?
import java.awt.*; 
import javax.swing.*; 

public class BoxLayoutTest extends JFrame 
{ 
public BoxLayoutTest() 
{ 
JPanel panel = new JPanel(); 
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); 

JButton botao1 = new JButton("Botão 1"); 
JButton botao2 = new JButton("Botão 2"); 
JButton botao3 = new JButton("Botão 3"); 
JButton botao4 = new JButton("Botão 4"); 
JButton botao5 = new JButton("Botão 5"); 

panel.add(botao1); 
panel.add(botao2); 
panel.add(botao3); 
panel.add(botao4); 
panel.add(botao5); 

getContentPane().add(panel); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 
} 

public static void main(String args[]) 
{ 
new BoxLayoutTest(); 
} 
} 

Usando FlowLayout
Como dito anteriormente, um FlowLayout é o gerenciador padrão de todo JPanel, caso não seja especificado outro. FlowLayout posiciona os componentes lado-a-lado, e em termos seria a mesma coisa que usar um Boxlayout com a propriedade X_AXIS setada ( no nosso exemplo anterior usamos Y_AXIS ). O seguinte programa, "FlowLayoutTest.java", demostra isso: 
view plainprint?
import javax.swing.*; 
import java.awt.*; 

public class FlowLayoutTest extends JFrame 
{ 

public FlowLayoutTest() 
{ 
JPanel panel = new JPanel(); 

JButton botao1 = new JButton("Botão 1"); 
JButton botao2 = new JButton("Botão 2"); 
JButton botao3 = new JButton("Botão 3"); 
JButton botao4 = new JButton("Botão 4"); 
JButton botao5 = new JButton("Botão 5"); 

panel.add(botao1); 
panel.add(botao2); 
panel.add(botao3); 
panel.add(botao4); 
panel.add(botao5); 

getContentPane().add(panel); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 
} 

public static void main(String args[]) 
{ 
new FlowLayoutTest(); 
} 
} 

Usando GridLayout
Um GridLayout atua como uma grade de uma planilha de cálculo, colocando os componentes em linhas e colunas pré-determinadas e deixando os componentes com o mesmo tamanho. Veja isso no programa "GridLayoutTest.java": 
view plainprint?
import javax.swing.*; 
import java.awt.*; 

public class GridLayoutTest extends JFrame 
{ 

public GridLayoutTest() 
{ 
// 3 linhas, 2 colunas 
getContentPane().setLayout(new GridLayout(3, 2)); 

JButton botao1 = new JButton("Botão 1"); 
JButton botao2 = new JButton("Botão 2"); 
JButton botao3 = new JButton("Botão 3"); 
JButton botao4 = new JButton("Botão 4"); 
JButton botao5 = new JButton("Botão 5"); 

getContentPane().add(botao1); 
getContentPane().add(botao2); 
getContentPane().add(botao3); 
getContentPane().add(botao4); 
getContentPane().add(botao5); 

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 
} 

public static void main(String args[]) 
{ 
new GridLayoutTest(); 
} 
} 

Usando GridBabLayout
O mais flexível gerenciador de layout é o GridBagLayout. Ele permite colocar componentes em grades de colunas, sendo possíve um componente ocupar mais de uma coluna ao mesmo tempo. As linhas também não precisam necessariamente ter os mesmos tamanhos, ou seja, você pode configurar diferentes larguras e alturas de acordo com a necessidade. Eis o programa "GridBaglayoutTest.java": 
view plainprint?
import javax.swing.*; 
import java.awt.*; 

public class GridBagLayoutTest extends JFrame 
{ 
public GridBagLayoutTest() 
{ 
GridBagLayout layout = new GridBagLayout(); 
GridBagConstraints c = new GridBagConstraints(); 

getContentPane().setLayout(layout); 

JButton botao1 = new JButton("Botão 1"); 
JButton botao2 = new JButton("Botão 2"); 
JButton botao3 = new JButton("Botão 3"); 
JButton botao4 = new JButton("Botão 4"); 
JButton botao5 = new JButton("Botão 5"); 

// Configura as proridades de cada botao 
// Botao 1 
c.gridy = 0; // primeira linha 
c.gridx = 0; // primeira coluna 
layout.setConstraints(botao1, c); 
getContentPane().add(botao1); 

// Botao 2 
c.gridy = 0; // primeira linha 
c.gridx = 1; // segunda coluna 
layout.setConstraints(botao2, c); 
getContentPane().add(botao2); 

// Botao 3 
c.gridy = 0; // primeira linha 
c.gridx = 2; // terceira coluna 
layout.setConstraints(botao3, c); 
getContentPane().add(botao3); 

// Botao 4 
c.gridy = 1; // segunda linha 
c.gridx = 0; // primeira coluna 
c.gridwidth = 3; // Ocupar o espaço de 3 colunas 
layout.setConstraints(botao4, c); 
getContentPane().add(botao4); 

// Botao 5 
c.gridy = 2; // terceira linha 
c.gridx = 1; 
c.gridwidth = 2; 
layout.setConstraints(botao5, c); 
getContentPane().add(botao5); 

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
pack(); 
setVisible(true); 
} 

public static void main(String args[]) 
{ 
new GridBagLayoutTest(); 
} 
} 

Logicamente é possível fazer muito mais com os gerenciadores de layout, há várias maneiras de configurar e utilizar. Para obter mais informações sobre so métodos disponíveis para cada um consulte a API, disponível em https://java.sun.com/j2se/1.4.1/docs/api/index.html
Mitos sobre programação gráfica com Java
Existem muitos mitos sobre Java, uns são verdadeiros, outros, devido ao amadurecimento da tecnologia, não são mais, e há ainda os mitos puramente existentes para falar mal. Um dos maiores e mais comentados até hoje é "o Java é lento". Não, o Java não é lento, pelo menos não mais, como antigamente. Pelo fato do Java ter um código intermediário, indepentende de plataforma e sistema operacional, o sistema de carregamento é um pouco diferente de programas dependentes de plataforma, como Delphi, C e VB. Atualmente tecnologias como HotSpot e compiladores JIT ( Just-In-Time ) fazem que programas em Java rodem de maneira extremamente satisfatória, muitas vezes comparando-se com programas compilados nativamente. Programas em Java tendem a necessitar de mais memória, mas isso não chega a ser um impecilho nos dias de hoje, visto que peças de hardware como memória RAM estão extremamente baratos. Obviamente tentar rodar uma aplicação complexa em uma máquina antiga e pouca memória não será muito agradável, apesar de não ser impossível. É muito importante tem a consiência que a velocidade de um programa não depende apenas da tecnologia e compiladores, mas sim do programador também, pois um código mal escrito só ajuda a piorar a performance.
Um segundo exemplo
Tendo tudo isso em mente, vamos ver um segundo exemplo de programa gráfico, o qual faz uso de um botão e caixa para digitação de texto. Veremos também como manipular a ação de cliques do mouse. Abra seu editor de códigos preferido e digite o seguinte programa: 
view plainprint?
import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 

public class SwingExemplo2 extends JFrame implements ActionListener 
{ 
JButton botao; 
JPanel panel; 
JTextField texto; 

public SwingExemplo2() 
{ 
super("GUJ - Java"); 
} 

public void criaJanela() 
{ 
texto = new JTextField("Digite algo..."); 

panel = new JPanel(); 
panel.setLayout(new GridLayout(2, 1)); 

botao = new JButton("Me clique"); 
botao.addActionListener(this); 

panel.add(texto); 
panel.add(botao); 

getContentPane().add(panel, BorderLayout.CENTER); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

pack(); 
setVisible(true); 
} 

public void actionPerformed(ActionEvent event) 
{ 
botao.setText(texto.getText()); 
} 

public static void main(String args[]) 
{ 
SwingExemplo2 ex2 = new SwingExemplo2(); 
ex2.criaJanela(); 
} 
} 

Salve este arquivo com o nome "SwingExemplo2.java" e compile como fizemos no primeiro exemplo. Ao executar com o comando 
view plainprint?
java SwingExemplo2 

, deverá aparecer uma telinha com o título "GUJ - Java", um campo para digitação de texto e um botãozinho escrito "Me clique". Ao clicar no botão o texto existente no campo de texto se tornará o título do botão! Muito do código que fizemod agora é igual ou parecido com o do exemplo 1. As novidades marcantes são a palavra-chave "implements", em 
view plainprint?
public class SwingExemplo2 extends JFrame implements ActionListener 

que nos diz que, além dos recursos de um JFrame, queremos ter disponível o acesso aos recursos de um ActionListener, o qual usamos para processar os eventos de vários componentes, como o botão no nosso caso. Anteriormente falamos que aplicações gráficas em Java trabalham muito com grades, e é isso que fazemos na linha 
view plainprint?
panel.setLayout(new GridLayout(2, 1)); 

Aqui estamos dizendo que o nosso painel é para ter o formato de 2 linhas e 1 coluna, como se fosse uma grade mesmo. A outra adição significativa é o método "actionPerformed", o qual se encarrega de processar eventos de componentes. Geralmente é necessário verificar qual componente esta requisitanto processamento no momento, mas como no nosso caso só queremos saber do botão, nao fazemos tal verificação. Isso pode ser visto na parte de código 
view plainprint?
public void actionPerformed(ActionEvent event) 
{ 
botao.setText(texto.getText()); 
} 

O nome "public void actionPerformed(ActionEvent event)" não é um nome aleatório, mas sim um método definido na interface "ActionListener", a qual requisitamos na declaração da classe. A chamada a 
view plainprint?
botao.setText(texto.getText()); 

muda o texto do botão para o conteúdo do nosso campo de texto.
IDE's & RAD's
Se você já tem experiência, ou ao menos já mexeu com alguma outra linguagem de programação que utilize nativamente ferramentas RAD como Delphi e Visual Basic, deve te notado que em nosso exemplo muita coisa deve ser feita no braço, como por exemplo a criação de janelas e posicionamento de componentes. Apesar de existirem ambientes puramente RAD para Java, como o Borland Jbuilder - encontrado no endereço https://www.borland.com/jbuilder - em Java é bastante comum o programador ter um contato mais "baixo nível" com o código. Os mais atentos também devem ter notado que apesar do componente de texto ter ficado centralizado corretamente na tela, nós sequer ao menos especificamos as coordenadas x/y do mesmo. Em Java, o funcionamento dos componentes do programa depende muito de grades ( uma grade funciona como uma planilha, com linhas e colunas ) e posicionamento cardinas, como norte, sul e oeste, por exemplo. Pode parecer estranho e complicado, mas isso é o que garante ao desenvolvedor que independentemente do sistema operacional que a aplicação for executada, o visual será exatamente o mesmo em todos ambientes. Uma IDE extremamente poderosa e versátil existente é o Eclipse ( https://www.eclipse.org ), produzido pela IBM. O Eclipse possui uma enorme quantidade de recursos, que vão desde auxiliadores para a criação de aplicações, passando por recuros de auto-completar código, mapeamento de classes e objetos relacionados, verificação de erros em tempo de edição, debugador integrado e muito mais. Apesar dele não ser um editor RAD por default, o seu sistema de plugins permite a adição de componentes para tal tarefa. O JBuilder, produzido pela Borland, é um ambiente RAD por natureza, onde o visual gráfico das aplicações são criadas simplesmente com o arrastar e soltar do mouse, exatamente como no Delphi. Isso auxilia bastante o desenvolvimento, uma vez que já é possível ver em tempo de desenvolvimento como irá ficar a interface do programa. O JBuilder é uma ferramenta paga, porém há uma versão grátis disponível chamada "Personal", a qual dispõe de bem menos componentes prontos, mas já ajuda quem esta começando.
Um exemplo mais avançado
Nosso último programa de exemplo irá mostrar um controle chamado JList, e dará uma visão melhor de como posicionar os elementos na tela O programa é simples, consiste em um campo de texto, uma lista e um botão. 
view plainprint?
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 

public class SwingExemplo3 extends JFrame implements ActionListener 
{ 
JList lista; 
JButton botaoAdicionar; 
JTextField textField; 
JPanel listPanel; 
JPanel botaoPanel; 
JScrollPane scroll; 
DefaultListModel listModel; 

public SwingExemplo3() 
{ 
super("GUJ - JList"); 

textField = new JTextField("Digite algo"); 
botaoAdicionar = new JButton("Adicionar"); 
listModel = new DefaultListModel(); 
listPanel = new JPanel(); 
botaoPanel = new JPanel(); 


// Adiciona um item inicial na lista 
listModel.addElement("Item 1"); 
listModel.addElement("Item 2"); 
listModel.addElement("Item 3"); 

// Configura a lista e adiciona ao painel 
lista = new JList(listModel); 
lista.setVisibleRowCount(3); 

scroll = new JScrollPane(lista); 

listPanel.add(scroll); 
getContentPane().add(listPanel, BorderLayout.CENTER); 

// Adiciona o campo de texto e o botao ao painel 
botaoAdicionar.addActionListener(this); 
botaoPanel.add(textField); 
botaoPanel.add(botaoAdicionar); 

getContentPane().add(botaoPanel, BorderLayout.SOUTH); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

// Mostra a janela 
pack(); 
setVisible(true); 
} 

public void actionPerformed(ActionEvent event) 
{ 
if (textField.getText() != "") { 
listModel.addElement(textField.getText()); 
getContentPane().invalidate(); 
getContentPane().validate(); 
} 
} 

public static void main(String args[]) 
{ 
SwingExemplo3 s = new SwingExemplo3(); 
} 
} 

Salve em um arquivo chamado "SwingExemplo3.java", compile e rode. Neste exemplo temos 4 novos tipos de componentes: o JTextField, que é um campo de texto simples de uma única linha, um JList, que é nada mais que um componente onde itens são disponibilizados para seleção, um JScrollPane, que serve para adicionar barras de rolagem a um determinado componente, e por último temos o DefaultListModel, o qual é usado em conjunto com o Jlist. Adicionar itens em um JList é simples, basta usar o método 
view plainprint?
addElement 

para adicionar um item ao final da lista ou 
view plainprint?
add 

para adicionar um item em uma posição específica. A chamada ao método 
view plainprint?
lista.setVisibleRowCount(3); 

diz ao Java que queremos deixar visíveis apenas 3 itens da lista, e caso haja mais do que isso, é para adicionar as barras de rolagem. O método 
view plainprint?
actionPerformed 

, 
view plainprint?
public void actionPerformed(ActionEvent event) 
{ 
if (textField.getText() != "") { 
listModel.addElement(textField.getText()); 
getContentPane().invalidate(); 
getContentPane().validate(); 
} 
} 

primeiramente verifica se o campo de texto não esta vazio, então adiciona o texto na lista usado a chamada 
view plainprint?
listModel.addElement(textField.getText()); 

e por fim as duas últimas linhas mandam que aplicação seja "redesenhada", para que os componentes notem que novos itens foram adicionados ao JList.
Conclusão
Ao longo deste tutorial tivemos uma breve demostração do funcionamento do Swing, o conjuto de classes disponibilizadas no Java para a criação de aplicações gráficas de alto nível. Vimos também alguns componentes básicos como JButtom e JTextField e aprendemos o funcionamento dos Layout Managers. Antes de mais nada, programar em Java, e em especial Swing, requer uma maneira de pensar um pouco diferente, o que pode ser um pouco estranho no início, uma vez que precisamos estar "conectando" os componentes uns com os outros, escrevendo métodos para processar os cliques de mouse e outras coisas relacionadas, os chamados Event e Action Listeners Porém, com o tempo isso tudo vai se firmando, e você verá que programar em Java é ao mesmo tempo prazeiroso e desafiador. No site do GUJ você pode contar com a ajuda de várias pessoas da comunidade Java brasileira no fórum, dentre outras várias coisas relacionadas a Java. Até a próxima.