INTERFACE GRÁFICAS

EM JAVA
Apresentação
[Link]
 ENTENDO O SWING

 Contrário ao que muitos desenvolvedores e estudantes de

Java pensam, o Swing não é um subtítulo do AWT (Abstract
Window Toolkit). Em vez disso, o Swing é visto como uma
cama disposta confortavelmente sobre o AWT. É
praticamente impossível falar de Swing sem mencionar
alguns aspectos relevantes e no momento oportuno
veremos como eles se complementam.
 O papel principal do AWT era fornecer um conjunto de
componentes gráfi cos destinados a facilitar a construção
das interfaces gráfi cas para aplicativos e applets em
versões mais antigas do Java. De fato, o AWT continua
sendo uma das partes mais importantes do JFC (Java
Foundation Classes) ao lado de
 Swing, Accessibility Java 2D e Drag na Drop. Java 2 é agora
parte do AWT e o suporte Accessibility já está incluso no
Swing.
ENTENDO O SWING( C O N T )
 ENTENDO O SWING( C O N T )

 Esta hierarquia não está completa, apenas alguns dos

componentes para que voce veja como todos eles
descendem de um componente em comum, ou seja, a
classe Component. Atenção deve ser à classe
Container, descendente direta da classe Component.
 Um Component tem uma representação gráfi ca, de
modo que ele possa ser exibido na tela e forneça
meios de interação com o usuário. A classe
Component defi ne os métodos, propriedades e
eventos que pode ser aplicados a todos os
componentes derivados dessa classe, incluído as
classes Button, Canvas, Label, Container, etc.
 ENTENDO O SWING( C O N T )

O Swing é um grande grupo de

componentes visuais escritos em Java
puro (diferentes de alguns componentes
AWT, que estão associados às
capacidades de renderização de
interfaces gráfi cas da plataforma em
que o aplicativo está sendo
executado).
 ENTENDO O SWING( C O N T )

Um componente do Swing é

reconhecido pela letra “J” antecedendo
o nome do mesmo componente na
hierarquia AWT. Assim, se no AWT
temos o componente Button, em Swing
esse componente é chamado de
JButton. Label passa a ser chamado de
JLabel, Frame de JFrame e assim por
diante. Uma recomendação é que você
investigue na documentação on-line a
diferença, por exemplo, entre a
funcionalidade de um button e um
 JFRAME

Uso do JFrame na construção de janelas no

aplicativo Se você já leu outro material sobre
interfaces gráfi cas em Java, deve estar se
perguntando por que preferimos não iniciar a
apostila falando de caixas de texto, rótulos,
botões e outros componentes de interface. A
razão é simples. A janela do aplicativo é a
parte mais importante da interface, além de
ser o fundamento sobre o qual os demais
componentes serão construídos. Mas, o fato
de não reservamos muita atenção ao estudo
das janelas dos aplicativos provém do uso
excessivo dos IDEs visuais (os famosos
Ambientes de Desenvolvimento Integrado).
 JFRAME( C O N T )

A classe JFrame é uma versão melhorada de

Frame que traz consigo suporte aos
componentes Swing. Essa classe fornece
todas as propriedades, métodos e eventos
que precisamos para construir janela, tais
como as que nossos usuários estão
acostumados a visualizar em seus sistemas.
Ora, o usuário sabe que a janela de um
aplicativo pode ser minimizada, maximizada,
redimensionada, e etc. Então vamos
demonstrar a classe JFrame serve aos nossos
propósitos.
 JFRAME( C O N T )

 A janela principal de um aplicativo de interface

gráfi ca em Java é criada como uma instância da
classe JFrame (com exceção de Applets). A classe
Jframe herda diretamente de Frame, como mostra a
fi gura seguinte:
 JANELA NORMAL

 import [Link].*;
public class PrimeiraJanela extends JFrame{
public PrimeiraJanela(){
super("Nossa primeira janela");
setSize(300, 150);
setVisible(true); }
public static void main(String args[]){
PrimeiraJanela app = new PrimeiraJanela();
[Link](JFrame.EXIT_ON_CLOSE);
} }
 ANALISANDO APLICATIVO

 Vamos analisar cada linha do aplicativo.

Tenha a certeza de importar esse pacote em todos os
aplicativos de interface gráfi ca que estiver escrevendo:
import [Link].*;
Em seguida temos a defi nição da classe principal:
public class PrimeiraJanela extends JFrame
{
// a implementação da classe vai aqui.
}
 ANALISANDO APLICATIVO ( C O N T )

 Observe como a classe PrimeiraJanela, que será a janela do

aplicativo, herda da classe JFrame. A partir desse ponto,
nossa classe possui todas as propriedades, métodos e
eventos que precisamos para que o aplicativo possa ser
minimizado, maximizado e fechado por meios dos botões na
barra de títulos.
 Dentro da classe temos o construtor padrão, que será
invocado quando uma instância dessa classe for criada (o
que acontecerá quando a janela for exibida na tela):
import [Link].*;
public class PrimeiraJanela extends JFrame
{
public PrimeiraJanela(){
super("Nossa primeira janela");
setSize(300, 150);
setVisible(true); }
 ANALISANDO APLICATIVO ( C O N T )

 Uma classe JFrame pode ser instanciada de duas

maneiras: app = new() que cria uma instância da
classe que é inicialmente invisível, mas sem um título
na barra de títulos, ou: app = new(String Título)
que cria uma instância da classe inicialmente
invisível e com um objeto String representando o
texto da barra de títulos. Assim, no construtor da
classe PrimeiraJanela, invocamos o segundo
construtor da superclasse Jframe fornecendo o texto
que queremos como título da janela.
 ANALISANDO APLICATIVO ( C O N T )

 Após a defi nição do título da janela, temos uma

chamada ao método setSize:
setSize(300, 150); - (300 – Altura e 150 – largura)
Finalmente exibimos a janela efetuando uma chamada
ao método setVisible o qual apresenta a seguinte
sintaxe: setVisible(true);
Para finalizar o código para a janela, temos a definição
do método main():
public static void main(String args[])
{
PrimeiraJanela app = new PrimeiraJanela();
[Link](JFrame.EXIT_ON_CLOSE);
}
 ANALISANDO APLICATIVO ( C O N T )

Na primeira linha criamos uma instância da

classe PrimeiraJanela e a atribuímos à
referência app, então acessamos o método
setDefaultCloseOperation e fornecemos o
valor EXIT_ON_CLOSE, que é uma das
constantes da classe JFrame que defi ne como
o aplicativo vai se comportar quando o
usuário tentar fechar a janela, seja clicando
no botão fechar na barra de títulos ou
pressionando ALT + F4.
 JANELA MAXIMIZADA

 Método: setExtendedState(MAXIMIZED_BOTH);
 JANELA MINIMIZADA:

Método: setExtendedState(ICONIFIED)
 JANELA QUE NÃO PODE SER
REDIMENSIONADA
 Por padrão, as janelas dos aplicativos em Java podem ser
redimensionadas em tempo de execução, ou seja, durante
a execução do programa. Algumas vezes não queremos
que o usuário seja capaz de alterar o tamanho da janela.
Com a lista abaixo podemos fazer com que a janela não
seja redimensionada:
 Método: : setResizable(false)
 JANELA CENTRALIZADA

 Método: setLocationRelativeTo(null);
 TROCANDO A COR DO FUNDO DA
JANELA
Embora as propriedades mais importantes da
janela do aplicativo já tenham sido vista a
possibilidade de alterar a cor de fundo da
janela só pôde ser apresentada agora. Isso se
deve ao fato de a cor do fundo ser defi nida
não para a classe JFrame, mas para o painel
de conteúdo, ou seja o objeto Container que
contém os controles da janela.
O aplicativo seguinte exibe uma janela com a
cor azul defi nida como cor de fundo.
Observado que a cor de fundo para painel
não afetará os demais controles da janela.
Veja o aplicativo a seguir:
 TROCANDO A COR DO FUNDO DA
JANELA ( C O N T )
 Trocando a cor do fundo da janela
 TROCANDO A COR DO FUNDO DA
JANELA ( C O N T )
 Temos que importar o pacote import [Link].*;, pois
a classe Container está nele. Veja como uma
instância dessa classe é criada e atribuída à
referência tela: Container tela = getContentPane();
 Após essa declaração o tela é um objeto Container
que representa a janela do aplicativo. Por meio dessa
referência podemos adicionar e manipular os novos
componentes. Comando que troca a cor de fundo da
janela:
 [Link]([Link]);
 [Link](new Color(255,128,128));
 EXERCÍCIOS

 Criar três aplicativos que possuam as cores RGB

255,120,120), (128,125,150) e yellow
SEGUNDA
PARTE
 DEFININDO UM ÍCONE PARA A
JANELA DO APLICATIVO
 Defi nir ícone
 DEFININDO UM ÍCONE PARA A
JANELA DO APLICATIVO ( C O N T )
 A defi nição de um ícone para a janela pode ser
realizada com apenas duas linhas de código:
 ImageIcon icone = new ImageIcon("[Link]");
 setIconImage([Link]());
 Na primeira linha criamos uma instância da classe
ImageIcon e a atribuímos àreferência ícone. Objetos
desta classe podem ser criados por meio de nove
construtores [Link] por aquele que
recebe o caminho e/ou nome da imagem como
argumento. Veja sua sintaxe:
 ImagemIcon(String caminho_e_nome_da_imagem);
 ImageIcon("[Link]");
 DEFININDO UM ÍCONE PARA A
JANELA DO APLICATIVO ( C O N T )
 É importante observar que esse caminho é sempre
transformado em uma URL antes de ser passado para
o construtor da classe. Assim, você pode fornecer
uma imagem usando apenas o nome da imagem:
 ImageIcon icone = new ImageIcon("[Link]");
 O Caminho e o nome da imagem:
 ImageIcon icone = new
ImageIcon("imagens/[Link]");
 Após iniciamos a classe ImageIcon, fazemos uso do
método getImage dessa classe para obter a imagem e
a defi nimos como ícone da janela com uma chamada
a setIconImage da classe JFrame.
setIconImage([Link]());
 ADICIONANDO COMPONENTES
JLABEL OU RÓTULOS NA SUA
JANELA
Freqüentemente chamado de rótulo, esse
componente raramente tem seu conteúdo
alterado e, quando usado corretamente,
possibilita manipulações bem interessantes,
como veremos a segui. Vamos começar
escrevendo um aplicativo que permite
instanciar as classe JLabel de maneiras
diferentes.
Esse aplicativo que adiciona JLabel,
posiciona na janela, altera a cor e altera a
fonte desse componente:
T RA B A L H A N D
O COM
JLABEL
 ADICIONANDO COMPONENTES
JLABEL OU RÓTULOS NA SUA
JANELA ( C O N T )
 Apos fazermos as importações vamos criar os objetos
do tipo JLabel: JLabel rotulo1,rotulo2,rotulo3,rotulo4;
 Em seguida atribuir o conteúdo ao JLabel:
 rotulo1 = new JLabel ("Nome");
 rotulo2 = new JLabel ("Idade");
 rotulo3 = new JLabel ("Telefone");
 rotulo4 = new JLabel ("Celular");
 Próximo passo defi nir o largura e altura do JLabel e a
coluna e a linha que ele irá ocupar na janela.
 [Link](50,20,80,20);
 [Link](50,60,80,20);
 [Link](50,100,80,20);
 [Link](50,140,80,20);
 ADICIONANDO COMPONENTES
JLABEL OU RÓTULOS NA SUA
JANELA ( C O N T )
 D e fi n in do pos icion am e nto n a te la

 Próx im o p as s o d e fi n ir a cor da le tra dos com p one n te s JLab e l,

le m b r an do q u e s e e s s e s ob je tos n ão fore m ad icion ad os ao
ap licati v o, a cor de faul t é p re to.
 rotu lo1. s e tFore g rou n d([Link] d);
 rotu lo2. s e tFore g rou n d(Color.b lue );
 ADICIONANDO COMPONENTES
JLABEL OU RÓTULOS NA SUA
JANELA ( C O N T )
 Esses dois trechos abaixo especifi ca como criar cores
personalizadas para o componente JLabel.
 [Link](new Color(190,152,142));
 [Link](new Color(201,200,100));
 E ainda podemos defi nir a fonte, o estilo e o tamanho
da letra do componente JLabel.
 [Link](new Font("Arial",[Link],14));
 [Link](new Font("Comic Sans
MS",[Link],16));
 [Link](new Font("Courier
New",[Link],18));
 [Link](new Font("Times New
Roman",[Link],20));
 E a numeração corresponde o tamanho da fonte.
 [Link](new Font("Arial",[Link],14));
 ADICIONANDO COMPONENTES
JLABEL OU RÓTULOS NA SUA
JANELA ( C O N T )
E fi nalmente o método tela que representa a
janela deverá ser chamado, onde vai exibir o
rótulo o conteúdo do JLabel na janela.
 [Link](rotulo1);
 [Link](rotulo2);
 [Link](rotulo3);
 [Link](rotulo4);
EXERCÍCIO COM JLABEL
 ADICIONANDO IMAGEM AO
COMPONENTE JLABEL

 É Possível exibir imagem em rótulos como instâncias

da classe JLabel. Tais rótulos podem conter apenas
imagens ou imagens e texto. O aplicativo seguinte
mostra apenas uma imagem adicionada com um
JLabel na janela.
 Exemplo:
Trabalhando com
JTextField
 ADICIONANDO COMPONENTES
JTEXTFIELD OU CAIXA DE TEXTO
(CONT)

A classe JTextField possibilita a

criação de caixas de texto de uma única
linha. Os usos mais freqüentes desse
controle são para receber e validar
dados informados pelo usuário do
aplicativo. Essa classe herda a maioria
de seus atributos, eventos e métodos
da classe JTextComponent.
T RA B A L H A N D
O COM
J T E XT F I E L D
 ADICIONANDO COMPONENTES
JTEXTFIELD OU CAIXA DE TEXTO
(CONT)

 Declarar os objetos: TextField

texto1,texto2,texto3,texto4;
 Estipular a quantidade de caracteres para as caixas
de texto:
 texto1 = new JTextField(50); texto2 = new
JTextField(3);
 texto3 = new JTextField(10); texto4 = new
JTextField(10);
 Especifi car posicionamento das caixas:
 [Link](110,20,200,20);
 [Link](110,60,20,20);
 [Link](110,100,80,20);
 [Link](110,140,80,20);
 ADICIONANDO COMPONENTES
JTEXTFIELD OU CAIXA DE TEXTO
(CONT)

 E chamar o método tela para exibir as caixas na janela:

 [Link](texto1); [Link](texto2); [Link](texto3);
[Link](texto4);

 Foco para uma caixa de texto

 Podemos também utilizar o comando requestFocus(); para
apontar o foco para uma determinada caixa de texto:
 texto1. requestFocus();
 ADICIONANDO COMPONENTES
JTEXTFIELD OU CAIXA DE TEXTO
(CONT)

 Cor da fonte para a caixa de texto

 Podemos também utilizar o comando setForeground([Link]); para
alterar
 a cor da fonte da caixa de texto: texto1. setForeground([Link]);
 Trocando a fonte, estilo e tamanho da fonte do JtextField:
 [Link](new Font("NomeFonte",[Link],TAMANHO));
 Alinhamento do texto de uma caixa de texto
 O comando setHorizontalAlignment() defi ne o alinhamento dentro da
caixa de texto: texto1. setHorizontalAlignment([Link]);
 setHorizontalAlignment ([Link]); posiciona o texto dentro da
caixa de compra da direita pra esquerda,
 setHorizontalAlignment([Link]); posiciona o texto dentro da
caixa da esquerda pra direita.
 setHorizontalAlignment([Link]); centraliza o texto dentro da
caixa de texto.
 Alteração da cor de fundo da caixa de texto Como visto
anteriormente podemos efetuar essa alteração chamando o
comando: [Link]([Link]);
 EXERCÍCIO DE FIXAÇÃO

 Criar um aplicativo que melhor representa a interface

abaixo:
 EXERCÍCIO DE FIXAÇÃO

 Criar um aplicativo que melhor representa a interface

abaixo:
ADICIONANDO COMPONENTES JBUTTON
OU BOTÕES A SUA JANELA

 A classe JButton herda de AbstractButton, uma classe

que herda de JComponet e defi ne o comportamento
básico para os botões e itens de menu.
 Como ocorre com instâncias da classe JLabel, objetos
da classe Jbutton podem conter texto, texto e
imagem ou apenas [Link] os mesmo
métodos dos outros aplicativos de como adicionar
componentes na janela esse também segue o mesmo
modelo.
 Botão somente com texto: Veja o exemplo de botão
sem imagem:
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Botão somente com texto
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Botão com texto e imagem
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Botão somente com imagem:
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Muito simples fazer esse tipo de botão com o
aplicativo anterior de botão com imagem basta você
retirar o texto de dentro da linha que somente a
imagem será adicionada, veja a linha:
 Linha do botão com texto e imagem: botão = new JButton
(“Abrir”,icone);
 Linha do botão somente com imagem: botão = new JButton
(icone);
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Adicion ando vários botões na
janela.
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Defi nir a cor de fundo para um componente Jbutton.
 Para trocar a cor de fundo basta adicionar no
aplicativo anterior as seguintes linhas:
 [Link]([Link]);
 [Link]([Link]);
 [Link]([Link]);
 [Link]([Link]);
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Defi nir teclas de atalho para objetos Jbutton
 import [Link].*; no inicio do programa
 import [Link].*;
 import [Link].*;
 import [Link].*;
 E adicione as seguintes linhas dentro do aplicativo
anterior:
 [Link](KeyEvent.VK_P);
 [Link](KeyEvent.VK_V);
 [Link](KeyEvent.VK_X);
 [Link](KeyEvent.VK_S);
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Qual botão reagirá ao pressionamento da tecla
enter
 Você pode passar o foco para um determinado botão
assim que pressionar a tecla enter, Com o comando
getRootPane().setDefaultButton(). Basta digitar o
comando getRootPane().setDefaultButton(botao);
 Botão é o nome do botão que você defi niu no
programa, nesse exemplo defi nir o último botão.
 Quando você pressionar a tecla Enter o botão que
receberá o foco piscará.
 ADICIONANDO COMPONENTES
JBUTTON OU BOTÕES A SUA
JANELA( C ON T )
 Alterando a cor do texto de um componente Jbutton
 Basta adicionar as seguintes linhas dentro do
aplicativo:
 [Link]([Link]);
 [Link]([Link]);
 [Link]([Link]);
 [Link]([Link]);
 ADICIONANDO COMPONENTES
JPASSWORDFIELD

A classe JPasswordField possibilita

a criação de caixas de texto para a
digitação de senhas. Esta classe
herda diretamente de JTextField e,
portanto, permite a aplicação de
todas as técnicas já vista na classe
JTextField.
ADICIONANDO COMPONENTES
JPASSWORDFIELD( C O N T .)
 ADICIONANDO COMPONENTES
JPASSWORDFIELD( C O N T .)
 1–Alterando a cor de fonte de um J Pa s s w o r d F i e l d
c a i x a . s e t Fo r e g r o u n d ( C o l o r. b l u e ) ; v o c ê p o d e r á t ro c a r a c o r d a l e t r a d a
c a i x a d e t ex t o. N o c a s o e s s a l e t r a v a i fi c a r a z u l .
 2 – D e fi n i r u m a c o r p e r s o n a l i z a d a p a r a o c o m p o n e n t e J Pa s s w o r d F i e l d Vo c ê
t a m b é m p o d e d e fi n i r u m a c o r p a r a l e t r a c o n f o rm e s e u g o s t o u s a n d o e s s a
l i n h a c a i x a . s e t Fo r e g r o u n d ( n e w C o l o r ( 1 1 5 , 9 9 , 1 2 8 ) ) ;
 3 – A l t e r a n d o a c o r d e f u n d o d e u m c o m p o n e n t e J Pa s s w o r d F i e l d Vo c ê p o d e
digitar essa linha no aplicativo a n t e r i o r:
c a i x a . s e t B a c k g r o u n d ( C o l o r. y e l l o w ) ; A c a i x a d e t ex t o d e n t ro fi c a r á c o m a
c o r a m a re l a p o r d e n t ro
 4 – C o r d e f u n d o p e r s o n a l i z a d a p a r a o c o m p o n e n t e J Pa s s w o r d F i e l d . Ao
d i g i t a r e s s a l i n h a n o a p l i c a t i v o d e n t ro d a c a i x a d e t ex t o fi c a r á c o m a c o r
ro s a . O n d e v o c ê m e s m o p o d e d e fi n i r s u a c o r. c a i x a . s e t B a c k g r o u n d ( n e w
Color(255,128,128));
 5 – Alterar tipo de fonte, estilo e tamanho da letra do componente Com essa
linha você pode alterar o estilo da fonte o tipo e o tamanho da fonte.
c a i x a . s e t Fo n t ( n e w Fo n t ( " A r i e l " , Fo n t . B O L D , 2 0 ) ) ;
 6 – A l t e r a n d o o c a r a c t e r q u e a p a re c e n o c o m p o n e n t e J Pa s s w o r d F i e l d
 Vo c ê p o d e p e r s o n a l i z a r q u a l c a r a c t e r v a i a p a re c e r n a s u a c a i x a d e t ex t o
basta digitar essa linha [Link]('*');
 D e n t ro d o s p a rê n t e s e s v o c ê p o d e a d i c i o n a r q u a l q u e r c a r a c t e r.
 TRABALHANDO COM CONTROLE
JFORMATTEDTEXTFIELD
 Controle JFormattedTextField para data, telefone, CEP, CPF
O componente JFormattedTextField , similar a uma caixa de
texto JTextField, fornece a possibilidade da validação e
exibição de dados formatados tempo real, ao seja, à medida
que seu conteúdo é inserido A vantagem de usar uma caixa
de texto tipo máscara é que o usuário é forçado a digitar os
dados no formato especifi cado. O controle não aceita
conteúdo que não siga os padrões predefi nidos.
 Antes de usar o componente JFormattedTextField , é preciso
entender o funcionamento da classe MaskFormatter (do
pacote [Link]) . Essa classe é usada para
especifi car a máscara que será usada na caixa de texto.
 Para defi nir os caracteres que serão aceitos, você deve usar a
seguinte tabela al, ao seja, à medida que seu conteúdo é
inserido.
TRABALHANDO COM CONTROLE
JFORMATTEDTEXTFIELD( C O N T )
Trabalhando
com
Controle
JFormattedTe
xtField ( c o n t )
 TRABALHANDO COM CONTROLE
JFORMATTEDTEXTFIELD( C O N T )
 Para construir o exemplo, usaremos as variáveis globais:
 FormattedTextField cep,tel, cpf, data;
 MaskFormatter mascaracep,mascaratel, mascaracpf,
mascaradata ;
 O código que inicializa a máscara foi inserido em um bloco try{ }
de modo a evitar uma exceção:
try{
mascaracep = new MaskFormatter("#####-###");
mascaratel = new MaskFormatter("(##)####-####");
mascaracpf = new MaskFormatter("#########-##");
mascaradata = new MaskFormatter("##/##/####");
[Link](‘_’);
[Link](‘_’);
[Link](‘_’);
[Link](‘_’);
}
catch(ParseException excp){}
 TRABALHANDO COM CONTROLE
JFORMATTEDTEXTFIELD( C O N T )
Observe o uso do símbolo # para permitir
somente valores numéricos e uma chamada
ao método setPlaceholderCharacter para
defi nir o caractere que será exibido como
marcador para a máscara, geralmente o
caractere de sublinhado. Essa máscara é
fornecida como argumento para o construtor
da classe JFormattedTextField:
cep = new JFormattedTextField(mascaracep);
tel = new JFormattedTextField(mascaratel);
cpf = new JFormattedTextField(mascaracpf);
data = new JFormattedTextField(mascaradata);
 TRABALHANDO COM CONTROLE
JFORMATTEDTEXTFIELD( C O N T )
 1 Adicionando cores na letra do JFormattedTextField
Essas linhas podem ser adicionadas no programa
anterior acima do objeto tela.
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link](new Color(255,128,128));
 2 Adicionando cores no fundo do JFormattedTextField
Já esses códigos podem ser adicionados logo abaixo ao
anterior.
[Link]([Link]);
[Link]([Link]);
[Link](new Color(255,255,204));
[Link](new Color(255,255,204));
 TRABALHANDO COM CONTROLE
JFORMATTEDTEXTFIELD( C O N T )
 3 Alterando o tipo, estilo, tamanho da fonte do
JFormattedTextField Já esses códigos podem ser
adicionados logo abaixo ao anterior.
[Link](new Font("Times New
Roman",[Link],14));
[Link](new Font("Comic Sans
MS",[Link],14));
[Link](new Font("Arial",[Link],14));
[Link](new Font("Tahoma",[Link],14));
 Aplicativo sendo executado depois de todos os
códigos Java, estarem adicionados no aplicativo, veja
os efeitos com as cores:
 JBUTTON EXECUTANDO UMA AÇÃO

 Como funciona o
aplicativo:
 import [Link].*; -
pacote que exibe
conteúdos na janela
 import [Link].*; -
pacote que exibe
conteúdos na janela
 import
[Link].*; -
pacote que trabalha com
os eventos
 JBUTTON EXECUTANDO UMA
AÇÃO( C O N T )
 Declarar o componente como JButton: JButton botaosair;
 Atribuir o texto ao botão: botaosair = new JButton ("Sair");
 Posicionar o botão na janela:
[Link](100,50,100,20);
 E chama o objeto tela para exibir o componente:
[Link](botaosair);
 Explicando o funcionamento do botão:
[Link](
new ActionListener(){
public void actionPerformed(ActionEvent e){
[Link](0);
}
}
);
 JBUTTON EXECUTANDO UMA
AÇÃO( C O N T )
 addActionListener – Adicionar ação a lista que estará
dentro do botão.
 new ActionListener – Chamando nova ação a ser listada.
 public void actionPerformed(ActionEvent e) –
performance da ação que o evento público chamara que
será o exit.
 [Link](0); - Finaliza o aplicativo
 Use sempre essa lista para fazer qualquer botão
funcionar ou chama algum evento:
[Link]( new ActionListener(){
public void actionPerformed(ActionEvent e){
}
}
);
 CLICANDO NO MOSTRAR PARA
DESCOBRIR A SENHA DIGITADA
 Um aplicativo simples
mais muito interessante
de ser observado, o
usuário digita a senha e
clicando em mostrar será
habilitado um JLabel
mostrando qual a senha
que foi digitada. Veja o
exemplo:
 CLICANDO NO MOSTRAR PARA
DESCOBRIR A SENHA DIGITADA( C O N T )
 Clicando
no botão
somar
com evento
CLICANDO NO BOTÃO SOMAR COM
EVENTO( C O N T .)
CLICANDO NO BOTÃO SOMAR COM
EVENTO( C O N T .)
 Foram declaradas três variáveis do tipo inteira: int
numero1, numero2, soma;
 Foi atribuído zero a variável soma, para a variável ser
iniciada vazia: soma=0;
 Como texto1, texto2 são String, melhor dizer texto
para armazená-las nas variáveis numero1 e numero2,
será necessário converte a String em números.
 Nesse caso estamos convertendo o texto1 em inteiro
para isso usamos o [Link](), e
armazenamos na variável numero1 que é inteira.
 Isso ocorrerá para a texto2 e a variável numero2.
 numero1 = [Link]([Link]());
 numero2 = [Link]([Link]());
CLICANDO NO BOTÃO SOMAR COM
EVENTO( C O N T .)
Depois de convertido os valores agora é só
fazer a soma e armazenar na variável
correspondente a soma, veja: soma =
numero1 + numero2;
Chamamos o comando para habilitar o JLabel
exibir e jogamos o valor de soma dentro do
texto do Jlabel exibir para se apresentado no
aplicativo.
 [Link](true);
 [Link]("A soma é: "+soma);
 Para variáveis do tipo Float, usaremos:
[Link]();
 Para variáveis do Double, usaremos
Doublé.parseDouble();
Limpand
o caixa
de Texto
 LIMPANDO CAIXA DE TEXTO( CONT .)

Nada de diferente no aplicativo somente as

linhas que vão limpar as caixas de texto e
passar o foco para a primeira caixa vejam:
 [Link](null); ou [Link](“”);
 [Link](null); ou [Link](“”);
 [Link]();
É atribuído null dentro das caixas, pois nulo
signifi ca vazio e requestFocus() passa o
foco para a caixa selecionada pelo usuário.
 OCULTAR E EXIBIR COMPONENTES

Esse aplicativo é só para teste não tem

muito que ser explicado, pois a
únicacoisa diferente é que quando você
clica em ocultar os JLabels some e
você clica em exibir os JLabels
aparecem novamente na janela. Isso
ocorre por que o comando
setVisible(false), oculta e o comando
setVisible(true), exibe mostra na
janela. Vejamos o exemplo a seguir:
 Ocultar e
exibir
componente
s
 DESABILITAR E HABILITAR EXIBIR
COMPONENTES
Como podem observar, nada de
diferente também somente o comando
setEnabled(true) que habilita e o
setEnabled(false) eu desabilita.
Vejamos o exemplo a seguir :
 Desabilitar
e Habilitar
Exibir
componente
s
 CLASSE JLIST

 A classe JList permite a criação do componente

conhecido como caixa de listagem ou ListBox
(nome popular entre programadores delphi e VB).
Uma caixa de listagem é um controle visual que
exibe uma série de itens dos quais o usuário pode
selecionar um ou mais itens.
 A maneira mais usual de criar um caixa de listagem
em Java é usar um vetor de Strings para defi nirmos
os itens que serão exibidos na lista. O aplicativo
seguinte apresenta uma janela que contém uma
caixa de listagem e um botão. O usuário pode
selecionar uma entre oito cidades. Ao clicar no
botão exibir, o valor selecionado será exibido em
um JLabel.
classe
Jlist
( cont. )
 CLASSE JLIST( C ON T. )

 Experimente selecionar um dos itens da lista e clicar

no botão Exibir. Observe que o texto do item
selecionado é exibido em uma caixa de mensagem.
 Analisandor o código e ver como isso foi possível.
 O primeiro passo é declarar uma instância da classe
JList chamada lista:
JList lista;
Em seguida declaramos e inicializamos um vetor de
objetos String que contém os itens que estarão
disponíveis na list:
String cidades[] = {"Rio de Janeiro","São
Paulo","Minas Gerais","Esprito Santo",
"Bahia","Pernambuco","Rio Grande do Sul","Acre"};
 CLASSE JLIST ( C ON T. )

 Os itens do vetor cidades são atribuídos à caixa de

listagem por meio da seguinte instrução:
 lista = new JList(cidades);
É importante observar que o vinculo entre a caixa de
listagem e o vetor cidades não termina após essa instrução.
Mais tarde, se alguma alteração for feita nos elementos do
vetor, você poderá atualizar a lista com uma chamada ao
método repaint da classe JComponent.
[Link]();
Após a atribuição dos itens do vetor cidades à lista, temos
que defi nir a
quantidade de elementos que serão visíveis sem a
necessidade de acionar as barras de rolagem isso é feito na
linha:
[Link](5);
 CLASSE JLIST ( C ON T. )

 Como queremos que o usuário seja capaz de

selecionar apenas um item por vez efetuaremos uma
chamada ao método setSelectionMode e usaremos
uma das constantes da classe ListSelectionModel para
defi nir a lista como sendo de seleção única:

[Link]([Link]
_SELECTION);
 Uma lista não fornece barras de rolagem por padrão.
Dessa forma, uma instância da classe JScrollPane é
usada para essa fi nalidade:
JScrollPane painelRolagem = new
JScrollPane(lista);
 CLASSE JLIST( C ON T. )

 Quando clicamos no botão exibir, o método

actionPerformed da classe publica. Chamado:
[Link](
new ActionListener(){
public void actionPerformed(ActionEvent e){
[Link](“o estado é:
“+[Link]().toString());
} } );
 Nós efetuamos uma chamada ao método
getSelectedValue().toString()); da classe JList para
obter o valor inteiro correspondente ao item
selecionados. Esse valor inicia em 0 e vai até a
quantidade de itens menos 1. Obtido o valor, só
precisamos fornece-lo como índice para o valor o vetor
cidades exibir o resultado fi nal na caixa de listagem.
 CLASSE JLIST( C ON T. )

 Selecionando múltiplos itens em uma caixa de

listagem
 No tópico anterior escrevemos um aplicativo que permita
selecionar um item em uma caixa de listagem e exibir seu
valor e, um JLabel. No exemplo apenas um dos itens podia
ser selecionado. É possível, porém, selecionar mais de um
item em uma caixa de listagem. Tudo que temos a fazer é
alterar o valor da constante fornecida para o método
setSelectionMode. Veja os valores possíveis:
 CLASSE JLIST( C ON T. )

 O exemplo seguinte é uma pequena modifi cação

do exemplo anterior que mostra como vários itens
podem ser selecionados e como você pode atribuí-
los a um vetor de objetos de modo a manipulá-los
mais tarde:
CLASSE JLIST( C ON T. )
 CLASSE JLIST( C ON T. )

 Este exem plo a presenta poucas m odifi cações. A prim eira delas é
a modifi ca çã o do valor fornecido pa ra o método
setSelectionM ode:
 [Link](ListSelectionModel.SINGLE_SELECTION);
Seleção única
 [Link](ListSelectionModel.MULTIPLE_INTERVAL_SE
LECTION); seleção multipla
 Veja que a gora a lista perm ite que vários itens sejam
seleciona dos. A outra modifi cação aconteceu no evento do botão
exibir:
[Link](
new ActionListener(){
public void actionPerformed(ActionEvent e){
Object selecionados[] = [Link]();
String resultados = "Valores selecionados:\n";
for(int i=0;i<[Link];i++)
resultados += selecionados[i].toString()+"\n";
[Link](null,resultados);
} } );
 CLASSE JLIST( C ON T. )

A classe JList possui um método chamado

getSelectedValues que retorna um vetor de objetos da
classe Object. Este valor contém todos os itens
selecionados na caixa de listagem. Assim, a linha:
Object selecionados[ ] = [Link]();
 Quando foi adicionado \n no fi nal da frase Valores
selecionados, que como visto \n pula uma linha na próxima
palavra que será exibida e não ao lado. Criar um vetor
chamado selecionados e atribui a ele os itens retornados
pelo método getSelectedValues. Mantenha em mente
que temos um vetor objetos da classe Object. Esquecer-se
deste detalhe pode ser desastroso. O laço for interage com
cada um dos elementos do vetor selecionados, efetuando
chamadas ao método String de cada um e concatenando o
resultado obtido com o valor da variável resultados.
 CLASSE JLIST( C ON T. )

 Cada vez que selecionados jogar um item dentro

de resultado, cada item cada item vai com a
opção de pular uma linha por isso os itens são
exibidos um em baixo do outro.
 A caixa de mensagem JOptionPane será estuda
mais profundamente nos próximos capítulos da
apostila. A opção showMessageDialog, que
dizer uma mensagem de dialogo será exibida ao
usuário.
 Uma lista não fornece barras de rolagem por padrão. Dessa
forma, uma
 Instância da classe JScrollPane é usada para essa fi nalidade :
JScrollPane painelRolagem = new JScrollPane(lista);
 TROCANDO A COR DA LETRA DO
JLIST
 É possível trocar a cor da letra do componente JList
abaixo do comando onde você defi ne em qual linha e
coluna vai fi car o componente você pode digitar essa
linha: [Link]([Link]);
 Trocando a cor de fundo do JList
[Link]([Link]);
 Trocando tipo, estilo e tamanho da fonte do JList
[Link](new Font("Times New
Roman",[Link],16));
TRABALHANDO COM JTABLE
TRABALHANDO COM JTABLE
TRABALHANDO COM JTABLE
 CLASSE JCOMBOBOX

 Objetos da classe JComboBox são usados para a

criação de controles conhecidos como caixas de
combinação, combo box ou lista drop-down. A
diferença entre a caixa de listagem e caixa de
combinação é que esta última exibe seus itens
somente quando clicamos na seta (indicativo visual
de que o controle possui itens entre os quais
podemos escolher) ou pressionando F4 quando o foco
está no componente. Além, disso, caixas de
combinação são usadas quando o espaço é
insufi ciente para acomodar uma caixa de listagem. A
classe JcomboBox herda de JComponent, como mostra
o relacionamento seguinte:
CLASSE JCOMBOBOX (C ON T )
 CLASSE JCOMBOBOX (C ON T )

O aplicativo seguinte apresenta uma

janela que contém uma caixa de
combinação e um botão. Quando
selecionamos um item no JComboBox e
pressionamos o botão, Exibir o valor do
item selecionado é exibido em uma
caixa de mensagem. Eis a listagem para
o exemplo:
 Classe
JComboBo
x (cont)
 CLASSE JCOMBOBOX (C ON T )

 Em seguida temos um vetor de nomes de cidades que

será usado para defi nimos os itens da caixa de
combinação:
String cidades[] = {"Rio de Janeiro","São Paulo", "Minas
Gerais","Espírito Santo","Bahia","Pernambuco","Rio Grande
do Sul","Acre"};
 Temos um vetor de oito elementos que são atribuídos à
caixa de combinação com a seguinte instrução:
lista = new JComboBox(cidades);
 Um objeto da classe JComboBox já possui barras de
rolagem. Tiramos proveito desse fator efetuamos uma
chamada ao metido setMaximumRowCount para defi nir
a quantidade e itens visíveis na lista sem a
necessidade de acionar as barras de rolagem:
[Link](5);
 CLASSE JCOMBOBOX (C ON T )

 O processo usado para exibir o item selecionado é o

mesmo que usamos para as caixas de listagem.
[Link](new ActionListener(){public
void actionPerformed(ActionEvent e){[Link]("o
estado é: “+[Link]().toString());
}});
[Link](lista);
[Link](exibir);
[Link](rotulo);
setSize(400, 250);
setVisible(true);
}
 CLASSE JCOMBOBOX (C ON T )

Como criar uma caixa de

combinação editável
Se você experimentou com o exemplo
anterior deve ter percebido que a caixa de
combinação é somente leitura, ou seja,
estamos limitados aos itens disponíveis para
a escolha.
Existe, porém, uma forma de permitir que o
usuário digite o valor desejado em uma caixa
de combinação. Basta efetuar uma chamada
ao método setEditable fornecendo o valor
true como argumento:
[Link](true);
BOTÃO LIMPAR AS CAIXA DE TEXTO
BOTÃO LIMPAR AS CAIXA DE TEXTO
( C O N T. )

No aplicativo
somente as linhas
que vão limpar as
caixas de
texto e passar o foco
para a primeira
caixa vejam:
[Link](null);
ou
[Link](“”);
[Link](null);
ou
[Link](“”);
[Link](
);
É atribuído null
dentro das caixas,
pois nulo significa
 ENTENDENDO JCHECKBOX

 A classe JCheckBox é usada quando precisamos de

controles como caixas de seleção que podem ser
marcados ou desmarcados pelo usuário e oferecem
feedback visual de modo percebemos seu estado
atual. O uso de caixas de seleção é freqüente em
ambientes em que o usuário deve selecionar uma ou
mais das opções oferecidas.
ENTENDEND
O
JCHECKBOX
(CONT.)
ENTENDEN
DO
JCHECKBOX
(CONT.)
 ENTENDEN
DO
JCHECKBOX
(CONT.)

 O primeira passo para a construção deste

exemplo foi declarar as referências global das
instâncias da classe JCheckBox:
 JCheckBox
primeira,segunda,terceira,quarta,quinta;
 Mais adiante você entenderá por que essa
variável precisa ser global. Em
 Seguida temos a criação de cinco caixas de
seleção. Veja o código para a primeira:
 primeira = new JCheckBox("Java");
 segunda = new JCheckBox("C++");
 terceira = new JCheckBox("Delphi");
 quarta = new JCheckBox("Visual Basic");
 quinta = new JCheckBox("Python");
 ANALISE DO BOTÃO EXIBIR

 Na primeira linha desse método criamos uma variável

chamada escolhas do tipo String e defi nimos se conteúdo
inicial como vazio.
 Em seguida temos um laço IF, toda vez que você clicar no
botão exibir ele fará a verifi cação e se a caixa de seleção
for marcada o método isSelected() testa o retorno se
valor for verdadeira, o aplicativo armazenará o conteúdo
na variável escolhas.
 Toda vez que você marca uma caixa de seleção o método
setSelected() recebe o valor true (verdadeiro), e
quando você desmarca a caixa de seleção o valor do
método setSelected(), recebe o valor de false (falso).
 Utilize o método setSelected(true) para a caixa de
seleção desejada: [Link](true); inicia a
caixa de seleção marcada na linha 46.
 Na linha 47 altera a cor da Letra do
JCheckBox:[Link]([Link]) ;
 USO DA CLASSE JRADIOBUTTON PARA
CRIAR BOTÕES DE OPÇÃO COM
JCOMBOBOX E JCHECKBOX
As caixas de seleção fornecem uma maneira conveniente de
oferecer ao usuário alguns itens dos quais ele pode escolher um, vários
ou todos. Existem, no entanto, situações em que apenas um dos itens
pode ser selecionado. Para esses casos temos os botões de opção.
Botões de opção têm seu uso justificado em casos em que apenas uma
das opções pode ser selecionada.
Essa funcionalidade só é atingida quando usamos objeto da
classe ButtonGroup para agrupar os itens de modo, que sempre que um
item for selecionado, os demais sejam automaticamente desmarcados.
O aplicativo seguinte apresenta uma janela com cinco botões de
opção. Quando você clicar em exibir uma mensagem exibirá o valor
selecionado e quando você clicar em outra opção a anterior será
desmarcada.
APLICATIVO
COM
COMBOBOX
CHECKBOX
RADIOBUTT
ON
 APLICATIVO
COM
COMBOBOX
CHECKBOX
RADIOBUTTO
N
 APLICATIVO
COM
COMBOBOX
CHECKBOX
RADIOBUTTO
N
APLICATIVO
COM
COMBOBOX
CHECKBOX
RADIOBUTT
ON
APLICATIVO
COM
COMBOBOX
CHECKBOX
RADIOBUTT
ON
 USO DA CLASSE JRADIOBUTTON
PARA CRIAR BOTÕES DE OPÇÃO
 As caixas de seleção fornecem uma maneira conveniente de
oferecer ao usuário alguns itens dos quais ele pode escolher
um, vários ou todos. Existem, no entanto, situações em que
apenas um dos itens pode ser selecionado. Para esses casos
temos os botões de opção. Botões de opção têm seu uso
justifi cado em casos em que apenas uma das opções pode
ser selecionada.
 Essa funcionalidade só é atingida quando usamos objeto da
classe ButtonGroup para agrupar os itens de modo, que
sempre que um item dor selecionado, os demais sejam
automaticamente desmarcados.
 O aplicativo seguinte apresenta uma janela com cinco
botões de opção.
 Quando você clicar em exibir uma mensagem exibirá o valor
selecionado e quando você clicar em outra opção a anterior
será desmarcada.
 APLICATIVO
COM
JRADIOBUTTO
N
 APLICATIVO
COM
JRADIOBUTTO
N
(CONT.)
 APLICATIVO
COM
JRADIOBUTTO
N
(CONT.)
COMO ADICIONAR DICA AOS SEUS
BOTÕES
O processo de adicionar dicas aos
botões é sempre uma boa idéia defi nir
as dicas de ferramentas para que o
usuário, ao posicionar o ponteiro do
mouse sobre o controle (Botão), possa
ter mais informações sobre a
funcionalidade das ferramentas do
aplicativo.
Veja no aplicativo a seguir:
EXEMPLO
DE
BOTÕES
COM
DICAS
ADICIONAR CORES DIFERENTES AS
DICAS
Se você observou atentamente a dica de
ferramenta do exemplo anterior, deve ter
percebido que o Java defi ne o azul como cor
de fundo e o texto na cor preta. É possível
acessar e manipular algumas das propriedades
das dicas de ferramenta de modo a adequá-las
às cores propostas em seus
aplicativos. É uma técnica raramente usada,
mas que surte efeitos bem interessantes.
As dicas de ferramenta do Windows tem o
amarelo como cor de fundo.
Basta voce adicionar no seu
aplicativo a linha abaixo
 [Link]("[Link]",Sy
[Link]);

 Cor na fonte da dicas

 [Link]("[Link]",[Link]);
COMO ENTENDER OS DIÁLOGOS DE
CONFIRMAÇÃO
 Diálogos de confi rmação são usados para perguntar
ao usuário se uma determinada operação deve ser
iniciada, continuada ou interrompida.
 Aplicativos em Java geralmente usam esse tipo de
diálogo para confi rmar agravação de arquivos,
fechamento de janelas, etc.
 Exemplo:
 [Link] rmDialog(null,”Fechar?”,”Fechar ”,J
OptionPane.YES_NO_OPTION);
 Este método retorna um valor inteiro correspondente
à opção escolhida pelo usuário. Em diálogos de
confi rmação esse retorno pode ser um dos três
valores a seguir:
COMO ENTENDER OS DIÁLOGOS DE
CONFIRMAÇÃO ( C O N T. )
 YES_OPTION – indica que o usuário escolheu a opção
“Yes” ou “Sim”.
 NO_OPTION – indica que o usuário escolheu a opção “No”
ou “Não”.
 CANCEL_OPTION – indica que o usuário escolheu a opção
“Cancel” ou “Cancelar ”.
 Os parâmetros para o método são:
 [Link] rmDialog(parentComponent,”
message”,”title”,optionType);
 parentComponent – determina a janela na qual o diálogo
será exibido.
 Geralmente forncemos o valor null para esse parâmetro.
 message – o texto a ser exibido no diálogo.
 title – o texto para a barra de título do diálogo.
 optionType – valor inteiro equivalente às opções
disponíveis para o tipo de diálogo, ou seja ,
YES_NO_OPTION, ou YES_NO_CANCEL_OPTION.
 ENTENDER
OS
DIÁLOGOS
DE
CONFIRMAÇÃ
O
COMO OBTER DADOS POR MEIO DE
DIÁLOGOS DO TIPO PROMPT
Diálogos do tipo prompt são usados quando
precisamos recebe entrada de dados,
geralmente fornecidos pelo usuário do
aplicativo. A forma mais básica de um diálogo
do tipo prompt é obtida pelo método
showInputDialog com a seguinte sintaxe:
showInputDialog(mensagem);
Quando o usuário digita o conteúdo solicitado
e pressiona o botão OK, o conteúdo da caixa
é atribuído a variável nome. E o conteúdo
dessa variável será escrito dentro de um
rótulo na janela. Se o botão cancel for
acionado acontecerá um erro no aplicativo.
 Como
obter
dados por
meio de
diálogos
do tipo
prompt
  Quando você clicar no Ok.
 Veja o resultado, o nome vai aparecer todo em
maiúsculo
ENTENDIMENTO E USO DO MÉTODO
SHOWMESSAGEDIALOG
Como o leitor já conhece todos os
parâmetros, nos determinamos apenas no
parâmetro messaType. É aqui que defi nimos o
tipo de mensagem que será exibido. Os
valores possíveis são: ERROR_MESSAGE,
INFORMATION_MESSAGE,
WARNING_MESSAGE,
QUESTION_MESSAGE, PLAIN_MESSAGE.
Cada um desses valores produz uma
mensagem diferente, como mostra o seguinte
aplicativo:
ENTENDIMEN
TO E USO DO
MÉTODO
SHOWMESSA
G E D I A LO G
 ADICIONANDO DATA AO SEU
APLICATIVO
 O aplicativo abaixo mostra dos tipos de data,
somente com números e a outra com o dia da semana
e os meses escritos com o nome. Vamos ver o
aplicativo:
ADICIONANDO DATA AO SEU
APLICATIVO
ADICIONANDO HORAS AO SEU
APLICATIVO
ADICIONANDO HORAS AO SEU
APLICATIVO (C ON T. )
EXECUTADO O APLICATIVO HORAS
 ANALISANDO O APLICATIVO

 Vamos criar uma classe privada com o nome de

HORAS vamos defi nir os parâmetros para hora,
minutos e segundos.
 Depois criar um outra classe privada com o nome de
formatar para que você possa formatar a hora com
dois dígitos, e coloca a hora no rótulo com uma
string.
 Criar uma ação com o nome de tarefa, que vai
chamar a classe privada HORAS.
 Por último chamar a biblioteca com o nome de Timer,
e atribuir o tempo de um segundo que é
representado por mil. E chamar o método [Link](),
para que o relógio possa movimentar os segundos.
 ENTENDIMENTO DA CLASSE
JTEXTAREA COM BARRA DE
ROLAGEM
A classe JTextField permite a criação de
caixas de textos que aceitam a entrada de
apenas uma linha de texto. A classe
JTextArea permite a entrada e manipulação
de múltiplas linhas de texto. Embora a classe
JTextArea forneça uma série de métodos
úteis para a manipulação de seu conteúdo,
algumas operações mais avançadas, tais
como formatar e aplicar estilos diversos ao
texto de controle, são possíveis apenas com o
uso da classes JTextPane e JEditorPane. Esse
material não aborda estas duas classes mas,
você poderá pesquisa-las na documentação.
 ENTENDIMENTO DA CLASSE
JTEXTAREA COM BARRA DE
ROLAGEM
A classe JTextArea fornece seis construtores.
Dentre eles, o mais comumente usado é
aquele que cria uma área de texto em branco
com um determinado número de linhas e
colunas. Veja a sintaxe para esse construtor:
 JTextArea(int linhas, int colunas).
 Para controlar as linhas e colunas observe
que foi adicionado barra de rolagem da classe
JScrollPane.
A listagem seguinte apresenta um aplicativo
que contém um rótulo, uma área de texto.
EXECUTANDO O APLICATIVO
EXECUTANDO O APLICATIVO
 ADICIONANDO MENU A UM
APLICATIVO JAVA
 Menus são uma parte integrante de qualquer aplicativo de
interface gráfi ca. Seu uso ajuda a agrupar o acesso as
funcionalidades do programa em lugares já conhecidos pelo
usuário e evita a poluição desnecessárias de componentes na
tela do aplicativo.
 Menus são criados como objetos das classes JMenurBar,
JMenu, JMenuitem, JCheckBoxMenuItem e
JRadioButtonMenuItem.
 Todas essas classes têm sua relevância e uma aplicação de
cada um será apresentada em seguida. Por ora, saiba que o
menu pode ser adicionados apenas aos objetos de classes que
fornecem o método JMenuBar. A classe JMenuBar serve para
 criar a barra de menus. Já o JMenu adiciona os itens do menu.
Já os itens dos menus são colocados com JMenuItem.
 O Aplicativo seguinte apresenta uma barra de menus, que
contém o menu opções, com os itens limpar, fonte e sair:
Exempl
o de
Menu
 ANALISE DO CÓDIGO EXEMPLO DE
MENU
 Declarar na área pública a variável que vai receber a barra de
menu:
 JMenuBar barra;
 Criar a barra de menus: barra = new JMenuBar();
 Anexam a barra de menus à janela com uma chamada ao método
setJMenuBar da classe JFrame (janela): setJMenuBar(barra);
 Uma janela pode ter apenas uma barra de menus, disposta
horizontalmente na parte superior da janela.
 O menu Opções é criado com a seguinte instrução:
 opcoes = new JMenu("Opções");
 Depois é anexado a barra de menus: [Link](opções);
 Observe o o uso do método setMnemonic para defi nir as teclas
de atalho para o menu e todos os itens do menu.
 [Link](KeyEvent.VK_L);
 [Link](KeyEvent.VK_F);
 [Link](KeyEvent.VK_S);
 ANALISE DO CÓDIGO EXEMPLO DE
MENU (CONT.)
 Criar os itens do menu opções:
 limpar = new JMenuItem("Limpar");
 fonte = new JMenuItem("Fonte");
 sair = new JMenuItem("Sair");
 Declarar as variáveis que irão receber os itens do
menu como JMenuItem: JMenuItem limpar, fonte, sair;
 Agora vamos anexar os itens no menu opções:
 [Link](limpar);
 [Link](fonte);
 [Link](); //Adiciona um linha separadora no
menu
 [Link](sair);
EXEMPLO
DE MENU
EXEMPLO
DE MNEU
( C O N T. )
EXECUTANDO EXEMPLO DE MENU
 ANALISE DO APLICATIVO

 As variáveis que no aplicativo anterior foram

declaradas como JMenuItem,para que possam ser
anexado a submenus elas terão que mudar de classe
e passar a ser da classe JMenu. Veja: JMenu
opcões,fonte,cor;
Observe como o item Fonte
do menu Opções tem uma
seta para a direita,
indicando que tem nesse
item três submenus, Cor,
Estilo e Tamanho. O item
Cor também possui uma
seta para direita, indicando
que nesse item
possui, cinco subitens.
 ANÁLISE DO APLICATIVO ( C O N T. )

 A g o ra v a m o s c ria r o ite m f o nt e e c o r c o m o JM enu, e o s it ens a z ul,

v erd e, verm elho , a m a relo e p ret o s erã o c ria d o s c o m o JM enuIt em , v a i
ind ic a r q ue o JM enuIt em é um ite m d o JM enu d o it em C o r.
fonte = new JMenu("Fonte");
cor = new JMenu("Cor");
azul = new JMenuItem("Azul");
verde = new JMenuItem("Verde");
vermelho = new JMenuItem("Vermelho");
amarelo = new JMenuItem("Amarelo");
preto = new JMenuItem("Preto");
estilo = new JMenuItem("Estilo");
tamanho = new JMenuItem("Tamanho");

 A g o ra v a m o s a nexa r o s itens c o r, es tilo e ta m a nho no it em f o nte:

[Link](cor); [Link](estilo); [Link](tamanho);

 E fi na lm ente a nexa r a s c o re s d ent ro d o it em c o r:

[Link](azul); [Link](verde); [Link](vermelho);
[Link](amarelo); [Link](preto);
 COMO
USAR
 Neste tópico irei mostrar a CAIXA DE
técnica que usa as caixas de SELEÇÃO
seleção nos itens do menu. A COMO
vantagem de usar caixas de ITENS DO
MENU
seleção como itens de menu é
JCHECKBOX
que você pode marcar e
MENUITEM
desmarcar itens sem a exigência
de que no mínimo um
dos itens esteja selecionado.
Caixas de seleção como itens do
menu são criadas como instâncias
da classe
JCheckBoxMenuItem. As
propriedades, métodos e eventos
dessa classe são semelhantes aos
da classe JCheckBox, de modo que
você não terá nenhuma
dificuldade em usá-la em seus
aplicativos.
 COMO
USAR
CAIXA DE
SELEÇÃO
COMO
ITENS DO
MENU
JCHECKBO
XMENUITE
M
 SAR
CAIXA DE
SELEÇÃO
COMO
ITENS DO
MENU
JCHECKBO
XMENUITE
M
 SAR
CAIXA DE
SELEÇÃO
COMO
ITENS DO
MENU
JCHECKBO
XMENUITE
M
 ANÁLISE DO APLICATIVO

 Declarar as variáveis que vão receber as caixas de

seleção:
 JCheckBoxMenuItem normal, negrito, italico, negritoitalico;
 Anexar os estilos as caixas de seleção:
normal = new JCheckBoxMenuItem("Normal");
negrito = new JCheckBoxMenuItem("Negrito");
italico = new JCheckBoxMenuItem("Itálico");
negritoitalico = new JCheckBoxMenuItem("Negrito e Itálico");
 Defi nir as teclas de atalho:
[Link](KeyEvent.VK_M);
[Link](KeyEvent.VK_N);
[Link](KeyEvent.VK_I);
[Link](KeyEvent.VK_C);
 ANÁLISE DO APLICATIVO ( C O N T. )

 Anexar os estilos ao item estilo do menu fontes:

[Link](normal);
[Link](negrito);
[Link](italico);
[Link](negritoitalico);
 USANDO BOTÕES DE SELEÇÃO
COMO ITEM DO MENU
JRADIOBUTTONMENUITEM
 Botões de seleção pode ser adicionados a um menu
como instância da classe JRadioButtonMenuItem.
Usamos tais controles quando queremos que apenas
um item entre dois ou mais itens possam ser
selecionados. Um bom exemplo é quando queremos
fornecer um menu que permite escolhe o tamanho da
fonte que será aplicada a um determinado componente.
 O aplicativo seguinte contém o Menu Opções, com o
item Fonte e o submenu Tamanho, onde você pode
escolher o tamanho desejado para sua fonte.
 Lembrando que somente um tamanho pode ser
escolhido, e a mesma coisa foi defi nida para as caixas
de seleção (JRadioButtonMenuItem), somente um
estilo poderá ser defi nido:
EXECUTAND
O EXEMPLO
DE MENU04
EXECUTAND
O EXEMPLO
DE MENU04
EXECUTAND
O EXEMPLO
DE MENU04
 ANÁLISE DO APLICATIVO

 1º Passo:
Para este exemplo vamos usar dois vetores, veja as
declarações:
JCheckBoxMenuItem nomeE[];
JRadioButtonMenuItem tamanhoF[];
Um vetor é para a caixa de seleção (JCheckBoxMenuItem),
que recebe o nome de nomeE, e a letra E é para
representar estilo.
Esse vetor serve para defi nirmos os itens do submenu Cor.
O outro vetor é para o botão de seleção
(JRadioButtonMenuItem ), que recebe o nome de nomeF, e
letra F é para representar fonte.
Esse vetor serve para defi nirmos os itens do submenu
Estilo.
 ANÁLISE DO APLICATIVO ( C O N T. )

 2º Passo:
Agora declaramos duas instânciasda classe ButtonGroup:
ButtonGroup grupoT,grupoE;
Atribuimos os nomes grupoT, pertece ao tamanho da fonte,
e o grupoE, que pertence ao estilo da fonte.
Esse ButtonGroup agrupa as opções dos onde você só
poderá escolher um item de cada submenu.
 3º Passo:
Criamos dois vetores do tipo String que servirão para
defi nimos os valores dos itens do menu.
String tam[] = {"12","14","16","18"};
String est[] = {"Normal", "Negrito", "Itálico", "Negrito e
Itálico"};
O primeiro para tamanho da fonte e o segundo para o estilo.
 ANÁLISE DO APLICATIVO ( C O N T. )

 4º Passo:
Criar os submenus:
O submenu tamanho é criado com a seguinte instrução:
tamanho = new JMenu("Tamanho");
O submenu estilo é criado com a seguinte instrução:
estilo = new JMenu("Estilo");
 5ª Passo:
Em seguinda inicializamos as referências dos grupos:
grupoE = new ButtonGroup();
grupoT = new ButtonGroup();
 6ª Passo:
Atribuir a quantidade de itens a caixa de seleção:
nomeE = new JCheckBoxMenuItem[4];
Atribuir a quantidade de itens ao botão de seleção:
tamanhoF = new JRadioButtonMenuItem[4];
 ANÁLISE DO APLICATIVO ( C O N T. )

 7º Passo:
Para instanciar os itens do menu Cor, usamos o seguinte laço
for:
for(int i = 0; i < 4; i++){
nomeE[i] = new JCheckBoxMenuItem(est[i]);
[Link](nomeE[i]);
[Link](nomeE[i]);
}
 Esse laço é executado uma vez para cada um dos valores
contidos no vetor que no nosso caso são quatro estilo
(normal, negrito, itálico, negrito e itálico). A cada
interação atribuímos ao item de menu atual um dos
valores do vetor est, adicionamos o item ao menu Estilo e
também ao grupo de botões grupoE. Lembrando que o
primeiro índice do vetor é 0, o segundo é 1, o terceiro é 2
e o quarto é 3, por isso usamos no for i < 4, quando for
satisfeita a condição o for é encerrado e o menu recebe os
 ANÁLISE DO APLICATIVO ( C O N T. )

for(int i = 0; i < 4; i++){

tamanhoF[i] = new JRadioButtonMenuItem(tam[i]);
[Link](tamanhoF[i]);
[Link](tamanhoF[i]);
}
 Esse laço é executado uma vez para cada um dos valores
contidos no vetor tam que no nosso caso são quatro estilo
(12, 14, 16, 18). A cada interação atribuímos ao item de
menu atual um dos valores do vetor tam, adicionamos o
item ao menu Tamanho e também ao grupo de botões
grupoT. Lembrando que o primeiro índice do vetor é 0, o
segundo é 1, o terceiro é 2 e o quarto é 3, por isso usamos
no for i < 4, quando for satisfeita a condição o for é
encerrado e o menu recebe os tamanhos.
 OBS: Quando usamos vetores para criar itens de menus
não podemos adicionar teclas de atalho.
 MENU EXECUTANDO AÇÕES

 Quando um determinado item é selecionado, o código

do aplicativo deve detectar a seleção e efetuar as
ações determinadas. Esse procedimento é fácil. Uma
vez que a classe JMenuItem herda abstração de
botões e fornece o método addActionListener.
 No aplicativos foi adicionado ao exemplo um
componente JTextArea, para usar as opções dos
menus Limpar, Cor, Estilo e Tamanho. Use o menu
Limpar para apagar todo o conteúdo do JTextArea.
Use a caixa de seleção para defi nir os estilos da fonte
do JTextArea. Os estilos possíveis são: normal,
negrito, itálico, negrito e itálico. E utilize o botão de
seleção para obter o tamanho da fonte do JTextArea.
Os tamanhos possíveis são: 12, 14, 16 e 18.
EXECUTAND
O EXEMPLO
DE MENU
COM
JTEXTAREA
EXECUTAND
O EXEMPLO
DE MENU
COM
JTEXTAREA
EXECUTAND
O EXEMPLO
DE MENU
COM
JTEXTAREA
EXECUTAND
O EXEMPLO
DE MENU
COM
JTEXTAREA
EXECUTAND
O EXEMPLO
DE MENU
COM
JTEXTAREA
EXECUTAND
O EXEMPLO
DE MENU
COM
JTEXTAREA
CRIANDO UM MENU DE CONTEXTO –
CLASSE JPOPUPMENU
 Menus de contexto ou menu popup têm a mesma
funcionalidade dos menus convecionais. A única
diferença é que menus de contexto são exibidos quando
clicamos com o botão direito no componente para o qual
o menu foi defi nido. Para ver um exemplo de menu com
contexto, abra seu editor de texto favorito e clique com
o botão direito sobre a área de edição de texto. As
chances de um menu de contexto ser exibido são
enormes. Em Java menus de contexto são criados como
objetos da classe JPopupMenu. Os itens do menu são
criados a partir da classe JMenuItem, de modo que você
pode usar todas as técnicas que vimos nos tópicos
anteriores. O aplicativo seguinte cria um menu de
contexto para uma área de texto e oferece as opções de
recortar, copiar e colar. Veja a listagem para o exemplo:
EXECUTAND
O EXEMPLO
DE
JPOPUMENU
EXECUTAND
O EXEMPLO
DE
JPOPUMENU
 EXECUTANDO O APLICATIVO

 Quando você executar esse aplicativo, clique com o

botão direito na área de texto e o menu de contexto
será exibido. Escolha um dos itens do menu e veja o
resultado obtido.
 O menu de contexto usado para este exemplo é
criado na linha: opcoes = new JPopupMenu();
 Para exibi-lo, criamos uma classe anônima
MouseAdapter e a fornecemos como argumento para
o método addMouseListener da área de texto:
[Link](new MouseAdapter(){
public void mouseReleased(MouseEvent e) {
if([Link]())
[Link]([Link](),[Link](),[Link]()); }});
 EXECUTANDO O APLICATIVO

 Quando clicamos com o botão direito na área de texto

e o método mouseReleased é disparado, efetuamos
uma chamada ao método isPopupTrigger da classe
MouseEvent. Esse método retorna verdadeio se o
evento foi disparado com o botão direito do mouse.
Satisfeita a condição, o menu de contexto é exibido.
Observe os parâmetros para o método show da classe
JPopupMenu:
show(Componet invoker, int x, int y);
[Link]([Link](),[Link](),[Link]()); }});
 O parâmetro invoker é o componente para o qual o
menu de contexto esta defi nido. Os parâmetros x e y
são as coordenadas do mouse no momento em que o
menu de contexto é chamado.
EXECUTANDO O APLICATIVO
 USO DA CLASSE JTOOLBAR PARA
CRIAR BARRA DE FERRAMENTAS
 Uma barra de ferramentas é um contêiner para
agrupar botões e outros controles usados com maior
frequência no aplicativo. Grande parte dos aplicativos
atuais apresenta barras de ferramentas, de modo que
você deve analisar e verifi car a necessidade de
implementar essa funcionalidade em seus programas.
Barras de ferramentas em aplicativos Java são criadas
como objetos da classe JToolBar. Essa classe oferece
algumas funcionalidades bem interessantes, entre
elas a capacidade de ser arrastada pela janela do
aplicativo (e até fora deste). O aplicativo seguinte
mostra como incluir uma barra de ferramentas
semelhantes às encontradas em muitos programas
atuais. No momento os botões não fornecem
nenhuma funcionalidade, mas você será capaz de
arrastar a barra para qualquer um dos cantos da
 USO DA
CL ASSE
JTOOLBAR
PARA CRIAR
BARRA DE
FERRAMENTA
S
 USO DA
CL ASSE
JTOOLBAR
PARA CRIAR
BARRA DE
FERRAMENTA
S
EXECUTANDO O
APLICATIVO
 ANALISANDO O APLICATIVO

 Declarar o vetor que vai receber as imagens:

ImageIcon imagens[];
 Para defi nir as imagens dos botões da barra de
ferramentas, usamos o seguinte vetor de objetos com
seis posições da classe ImageIcon:
imagens = new ImageIcon[6];
 O nome e o caminho das imagens são defi nidos como
itens do vetor ícones:
 String
cones[]={"imagens/[Link]","imagens/esquerda.
gif",

"imagens/[Link]","imagens/[Link]",
"imagens/[Link]","imagens/[Link]"};
 ANALISANDO O APLICATIVO ( C O N T. )

 O próximo passo é instanciar os objetos da classe

ImageIcon com as imagens do vetor ícones. Isso é feito
no laço seguinte:
for(int i = 0;i < 6;i++){
imagens[i] = new ImageIcon(icones[i]); }

 São criados seis botões com imagens veja seguintes

instruções:
direita = new JButton(imagens[0]);
esquerda = new JButton(imagens[1]);
centralizar = new JButton(imagens[2]);
recortar = new JButton(imagens[3]);
copiar = new JButton(imagens[4]);
colar = new JButton(imagens[5]);
 ANALISANDO O APLICATIVO ( C O N T. )

 Próximo passo adicionar dicas aos botões da barra de

ferramentas:
[Link]("Direita (Ctrl+d)");
[Link]("Esquerda (Ctrl+e)");
[Link]("Centralizar (Ctrl+z)");
[Link]("Recortar (Ctrl+x)");
[Link]("Copiar (Ctrl+c)");
[Link]("Colar (Ctrl+v)");
 ANALISANDO O APLICATIVO ( C O N T. )

 A barra de ferramentas é criada na linha:

barra = new JToolBar("Barra de Ferramentas");
 Trocar a cor de fundo da dica dos botões da barra de
ferramentas:
[Link]("[Link]",[Link]);
 Trocar a cor da letra da dica dos botões da barra de ferramentas:
[Link]("[Link]",[Link]);
 Os botões são adicionados à barra de ferramentas pelo método
add:
[Link](direita);
[Link](esquerda);
[Link](centralizar);
[Link]();
[Link](recortar);
[Link](copiar);
[Link](colar);
 ANALISANDO O APLICATIVO ( C O N T. )

 Aplicar o efeito Rollover aos botões da barra de

ferramentas:
 O efeito Rollover modifi ca algum aspecto do controle
quando movemos o ponteiro sobre ele. Geralmente esse
efeito aplica cores e imagens diferentes. Em barras de
ferramentas a técnica mais comum é aplicar uma borda
diferenciada quando o ponteiro adentra ou sai da área do
componente. Java permite aplicar esse efeito a barras de
ferramentas por meio de uma chamada ao método
setRollover da classe JToolBar. Veja como isso pode ser
feito:
[Link](true);
Posicionar a barra de ferramentas na janela:
[Link](1,1,260,50);
Adicionar a barra de ferramentas na janela:
[Link](barra);
 COMO CRIAR JANELAS
SECUNDÁRIAS MODAIS
Janelas secundárias são modais ou não-modais
que dependem da janela principal do
aplicativo. Por meio dessas janelas podemos
efetuar novas operações acessando até mesmo
os componentes da janela principal. Janelas
secundárias são criadas como instâncias da
classe JDialog, e fornece praticamente todas
as funcionalidades da classe JFrame. Isso quer
dizer que podemos obter o painel de conteúdo
de um objeto dessa classe e incluir
componentes, interagir com o usuário,
enviando dados para a janela principal.
 COMO CRIAR JANELAS
SECUNDÁRIAS MODAIS (C ON T )
 O aplicativo seguinte é o nosso ponto de partida para
o estudo da classe JDialog. Trata-se de uma janela
principal com apenas um botão. Quando você clicar
no botão abrir, uma nova janela com apenas um
botão é aberta. Veja:
 JANEL AS
SECUNDÁRI
AS MODAIS
 JANEL AS
SECUNDÁRI
AS MODAIS
 EXECUTAND
Clique no O
abrir, uma O
nova
APLICATIVO
janela
será
aberta

Clique no
botão sair,
uma nova
janela será
aberta
 ANÁLISE DO APLICATIVO
 Após a execução do aplicativo, clique no botão Abrir. Você
visualizará a segunda janela com o botão de Sair. O
entendimento do código é muito importante para o uso correto de
janelas secundárias em um aplicativo Java. É Importante
acompanhar atentamente a análise que faremos.
 A classe privada Inicial:
private class Inicial extends JDialog{
JButton sair;
public Inicial(Frame owner, String title,boolean modal){
super(owner,title,modal);
Container tela1 = getContentPane();
[Link](null);
sair = new JButton("Sair");
[Link](50,50,100,20);
TBsair tsair = new TBsair();
[Link](tsair);
[Link](sair);
setSize(200,200);
setLocationRelativeTo(null); } }
 ANÁLISE DO APLICATIVO ( C O N T. )

 Declaram os a variável que vai fazer referência ao botão sair:

JButton sair;
 Declaram os a referência segundajanela que receberá a Incial:
Inicial segundajanela;
 Classe privada I ncial: E sta c lasse herda JDialog. Observe os
parâm etros para seu c onstrutor: public Inicial(Fram e ow ner,
S tring Title, boolean m odal);
 O parâm et ro ow ner é usado para especifi c ar a janela principal a
partir da qual a janela sec undária será c ham ada. O parâm et ro
title serve para fornec e o título para janela, m odal espec ifi ca se
a janela será m odal ou não -m odal. Um a janela m odal tem o foco
e deve ser fechada ant es que o usuário volt e à janela principal
do aplic ativo.
 Na linha linha do const rut or tem os um a cham ada ao construtor
da superc lasse JDialog: super(ow ner,title,m odal);
 O que fazem os aqui é transferir os valores rec ebidos para a
superclasse.
 ANÁLISE DO APLICATIVO ( C O N T. )

 Chamamos os métodos para adicionar componentes na

janela:
Container tela1 = getContentPane();
[Link](null);
 Em seguinda, adicionamos o texto a ser exibido no botão
Sair, logo após posicionamos o botão na janela, criamos
a variável que vai fazer referência a classe privada
TBsair, depois adicionamos essa classe ao botão sair
pelo evento addActionListener, e chamamos o método
add, e adicionamos o botão na janela secundária.
sair = new JButton("Sair");
[Link](50,50,100,20);
TBsair tsair = new TBsair();
[Link](tsair);
[Link](sair);
 ANÁLISE DO APLICATIVO ( C O N T. )

 Em seguida defi nimos o tamanho da janela secundária:

setSize(200,200);
 Por fi nal centralizamos a janela:
setLocationRelativeTo(null);
 Voltando à janela principal agora, para chamar a janela
secundária, usamos o seguinte trecho de código:
[Link](new ActionListener(){
public void actionPerformed(ActionEvent e){
segundajanela = new Inicial(null,"Segunda Janela",true);
[Link](JFrame.DISPOSE_O
N_CLOSE);
[Link](true);
}
}
);
 ANÁLISE DO APLICATIVO ( C O N T. )

 Quando clicamos no botão e o método actionPerformed

da classe anônima ActionListener é chamado,
instanciamos um objeto da janela secundária e o
atribuímos à referência segundajanela. Em seguida
defi nimos o modo como a janela vai se comportar
quando tentamos fecha-la:
[Link](JFrame.DISPOSE_ON_C
LOSE);
 A constate DISPOSE_ON_CLOSE esconde a janela e em
seguida a libera da memória. Este é o comportamente
mais adequado para janelas modais.
 A última linha: [Link](true);
 Exibe a janela colocando-a na frente da janela principal.
Caso queira, revise o tópico para posicionar a janela
secundária no centro da tela quando ela for exibida.
 ANÁLISE DO APLICATIVO ( C O N T. )

 Classe privada TBsair (Tratar Botão Sair)

private class TBsair implements ActionListener{
public void actionPerformed(ActionEvent evento){
int status = [Link] rmDialog(null,"Deseja
realmente
fechar o programa?","Mensagem de
saída",JOptionPane.YES_NO_OPTION);
if (status == JOptionPane.YES_OPTION)
{[Link](false);
[Link](); } } }
 Sem muita modifi cações dos exemplos anteriores, o que
tem de diferente é que quando você clicar em Sim para
fi nalizar a janela secundária, o aplicativo coloca a janela
invisível com o método setVisible(false); e depois retira
da memória com o método dispose().
COMO CRIAR JANELA SECUNDÁRIA
COM JFRAME
Como a classe JDialog, também podemos
criar uma janela com a classe JFrame, quando
você iniciar esse aplicativo, será executada a
tela principal com um botão chamado Abrir,
quando você abrir a janela secundária com o
botão Sair, a janela principal fi ca invisível
com o método setVisible(false); e depois é
retirada da memória com o método dispose(),
já na janela secundária quando você clicar
em sair uma mensagem será exibida,
perguntando se você quer fechar o aplicativo,
caso você responda sim a janela é fechada.
 JANEL A
SECUNDÁRI
A COM
JFRAME
 JANEL A
SECUNDÁRI
A COM
JFRAME