Introdução ao pacote Swing
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
Peer based
• Delega ao toolkit nativo a criação de elementos gráficos
• Look & feel da plataforma de execução
Limitações
• Falta de consistência entre plataformas
• “Denominador comum” para atender a todas as plataformas
• “Bugs” diferentes em plataformas diferentes
• “Write once, test everywhere”
Non-peer-based GUI toolkit
Conjunto maior de elementos
• Mais funcionalidade
Maior consistência de uso entre plataformas
• Mais “robusto”, maior portabilidade
Pacote javax.swing
• Pacote de extensão no Java 1.1
• Incorporado como pacote básico no Java 2
Componentes leves
Não substitui integralmente o AWT
• Estende o AWT
• Diagramadores & Listeners
Look& Feel configurável
• Windows, Motif, Metal
Double-buffering automático
Arquitetura MVC
O Swing adota uma arquitetura conhecida como Model-View-Controller (MVC)
Modelo = dados/conteúdo
• estado de um botão, texto
Visão = aparência
• cor, tamanho
Controle = comportamento
• reação a eventos
Qualquer componente, antes de ser exibido em uma interface, precisa ser adicionado em um contêiner.
Conteiner nada mais é um “componente que pode conter outros componentes”
O contêiner mais simples do Swing é o painel:
JPanel.
Exemplo:
Todo programa que utiliza componentes Swing tem pelo menos um TLC
• raiz de uma “containment hierarchy”
Todo TLC possui um “content pane” que contém os elementos visíveis
• opcionalmente, uma “menu bar”
JFrame, JDialog, JApplet
• aplicações tipicamente possuem pelo menos uma hierarquia com um JFrame como raiz (janela
principal)
1. Crie um projeto Java normal (Aplicação Java)
2. Desmarque a opção “Criar a Classe Principal...”
3. Crie pacotes para organizar seu projeto.
Sugestão:
I. classes
II. forms
Logo acima da área de design, há uma barra de controle que alterna entre a área de Código-Fonte (onde se programa as rotinas do formulário) e a área de design da tela Projeto.
Ao lado observe que tem um botão (com um
olhinho verde), onde pode-se visualizar como o
formulário está ficando.
Primeiro passo: criar uma classe que
representa a interface gráfica com o usuário (JWindow ou JFrame);
O mais indicado de todos os conteiners para representar uma “janela” ou formulário visual no swing é o JFrame.
Criação:
public class Janela extends JFrame {
....
}
O construtor da classe deve tratar das seguintes tarefas:
• Chamar o construtor de uma superclasse
para dar um título ao frame e tratar de outros procedimentos de configuração;
• Definir o tamanho da janela de um frame;
• Decidir o que fazer se um usuário fechar a janela;
• Exibir o frame;
Clique com o botão direito em cima do pacote ‘forms’ e escolhe a opção Novo >
Form JFrame
Área de Desenho
Título
• JFrame(String) – construtor
• setTitle(String)
Tamanho
• setSize(int,int) – largura,altura
• pack( ) - mantém a disposição dos elementos
• setBounds(int,int,int,int) – x,y,largura,altura
Exibição
• setVisible(boolean)
• show( )
• hide( )
Comportamento
• setDefaultCloseOperation( argumento )
EXIT_ON_CLOSE = sai da aplicação;
DISPOSE_ON_CLOSE = fecha o frame, descarta o objeto e segue a aplicação;
DO_NOTHING_ON_CLOSE = mantém o frame aberto
HIDE_ON_CLOSE = fecha o frame e continua
executando;
Todos esses métodos podem ser acessados através das propriedades
dos componentes que possuem essa
característica, mudar os aspectos visuais do
componente;
Abaixo estão listados as propriedades mais importantes (ou mais comumente acessadas) para um JFrame
defaultCloseOperation: define o comportamento da janela ao ser fechada;
title: define o título da janela que aparece no seu cabeçalho
alwaysOnTop: se a janela permanecerá fixa no topo da tela ou não
resizable: se a janela poderá ser redimensionada pelo
usuário ou não (recomenda-se deixa-la desativada)
Na área designada por “Código” da paleta de propriedades, possuem características adicionais de um componente.
No caso do JFrame, ali se encontra as opções de tamanho padrão para o formulário:
Política de Tamanho de Form: qual o padrão adotado pelo formulário em relação ao seu tamanho, podendo ser:
Gerar Pack(): admite o tamanho ajustado dos componentes que estão dispostos em sua área;
Gerar Código de Redimensionamento: mantém o tamanho designado pelo designer
Gerar Código de Redimensionamento: mantém o tamanho
designado nas propriedades de dimensão, independente do que
foi estabelecido pelo designer.
Ainda na opção “Código”
Se a opção escolhida para o tamanho for Gerar Código de Redimensionamento, você pode escolher a opção Gerar Centralizado para que o formulário apareça no centro da tela.
Para que o formulário ocupe toda a tela (maximizado),
basta preencher a propriedade extendedState com o
valor 6
Se o desejo for iniciar o JFrame de forma maximizada via código-fonte, basta fazer:
this.setExtendedState(this.MAXIMIZED_BOTH);
ATENÇÃO USUÁRIOS DE LINUX, use:
this.setPreferredSize(Toolkit.getDefaultToolkit().getScreenSize());
this é a referência ao próprio JFrame corrente.
Caso você fez todos os procedimentos anteriores e
o formulário não apareceu maximizado,
desmarque a opção Gerar Tamanho da aba de
propriedades Código
Diagramadores
Como definir o layout dos componentes
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
Arrumam um grupo de elementos (ou os componentes) quanto à sua disposição no JFrame;
Estão associados a todos os containers
Há diferentes estilos de arrumação
• como fluxo de texto
• orientada pelas bordas
• em forma de grade
• e outros...
Coloca os componentes lado a lado, uma linha após a outra
Alinhamento: centralizado (default), à esquerda ou à direita
Default para o JPanel
Divide o container em 5 áreas: norte, sul, leste, oeste e centro
Default para contentPane do JFrame
Células do mesmo tamanho especificadas pelo
número de linhas e colunas
Como ele é um container,
precisa-se definir seu
layout
Fora as opções já mencionadas, o NetBeans oferece algumas opções interessantes e importantes:
Desenho Livre: você tem toda liberdade de colocar o componente em qualquer local do seu form, porém, ele oferece um algumas guias de orientação e combinação com os demais componentes dispostos;
Layout Absoluto: mantém a questão da liberdade de disposição, porém, sem as guias (promove maior liberdade ainda).
Layout Nulo: semelhante ao Absoluto.
JPanel é um container que pode delimitar uma
área dentro de um JFrame em diversos
formatos (borda):
Conhecendo os primeiros e mais básicos
componentes Swing
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
Vamos conhecer os componentes e seus funcionamentos da melhor maneira: NA PRÁTICA!
Para isso, vamos construir uma aplicação-
exemplo de autenticação de usuário (famoso
“login”)
Vamos trabalhar com o arquivo
Aula_Visual_Login.pdf que possui o passo-a-
passo de nossa aplicação.
Indicado para colocar uma informação textual no form, tal como uma descrição de um
campo ou mensagem de texto qualquer;
Propriedades mais importantes:
◦ text: texto que será exibido;
◦ background: cor de fundo (do próprio botão)
◦ foreground: cor do texto;
◦ font: configurações da fonte do texto (tipo, cor,
estilo, etc);
Indicado para que o usuário preencha com uma informação textual (ex: nome, endereço, cidade, etc) em uma linha de edição.
Propriedades mais importantes:
◦ text: texto que será exibido (não é uma prática);
◦ background: cor de fundo (do próprio botão)
◦ foreground: cor do texto;
◦ font: configurações da fonte do texto (tipo, cor, estilo, etc);
◦ editable: se estará impedida a edição ou preenchimento, ou não
◦ enabled: se ele estará habilitado para edição ou não
Métodos mais importantes para
manipulação do componente dentro do código:
getText( ): captura o texto do campo
setText(String): coloca um texto no campo
getSelectedText( ):captura o texto do campo que foi selecionado.
setEditable(boolean): tornar ou não o campo editável
isEditable( ): retorna true ou false, se o campo
é ou não editável
Cada componente deverá ser identificado no código-fonte para que ocorra sua manipulação, tais como pegar o que foi preenchido pelo usuário ou selecionado, bem como trocar suas características durante sua execução.
Para isso você deverá renomear o nome do componente, daquele que já é dado pelo Netbeans (que é jTextField1, jTextField2, jButton1, etc)
Esta opção só está disponível acessando via botão direito do
mouse em cima do componente:
Define as características de um botão;
Principais propriedades:
◦ text: define o texto que será exibido no botão;
◦ icon: define um ícone;
◦ background: cor de fundo (do próprio botão)
◦ foreground: cor do texto;
◦ font: configurações da fonte do texto (tipo, cor, estilo, etc);
◦ enabled: se estará habilitado ou não;
Maiores propriedades e características de
um botão poderá ser conhecido quando da
manipulação de BARRA DE FERRAMENTAS,
onde exploraremos melhor outras
propriedades interessantes!
Usado em botões e outros componentes para adicionar ícones;
Apesar de ser uma classe específica para isso, os componentes possuem uma agregação com essa classe para adicionar a imagem, descrita pela
propriedade icon;
Ao incluir uma imagem no botão, pode-se desejar modificar a posição do texto em relação a imagem. Logo, podemos mudar as propriedades do botão:
CENTER TOP BOTTOM
LEFT CENTER RIGHT
Podemos usar um ícone para inserir uma imagem
num formulário, por exemplo. O macete é utilizar
um Label para isso.
Enviar o foco para um componente específico:
jComponente.requestFocus();
Extende (herda) de JTextField, ou seja, possui as mesmas propriedades, porém com um
comportamento diferente de “esconder” os dados que estão sendo digitados;
Mesmos métodos de sua classe “pai”;
Depois de montada a interface, como fazemos para programar o seu funcionamento?
Faremos um programa main() com começo - meio - e fim?
Repare que agora não temos mais um “fluxo contínuo” de um programa único, e sim
componentes (por exemplo, os botões) que respondem ao serem acionados.
Para continuarmos então, precisamos conhecer o
que são EVENTOS!
Trabalhando com Eventos
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
Um modelo de programação que tornou-se bastante difundido com o uso de interfaces gráficas foi a programação orientada por eventos.
Segundo esse modelo, o programa deixa de ter o controle do fluxo de execução, que passa a um sistema encarregado de gerenciar a interface.
Assim, o programa passa a ser chamado pelo
sistema quando algum evento é gerado na interface.
Para que o programa possa ser chamado pelo sistema, ele deve registrar uma função para cada evento de interface que ele desejar tratar.
Tais funções são chamadas de callbacks
por serem ‘chamadas de volta’ pelo
sistema.
Esse modelo é orientação por
ortogonal ao modelo de objetos. É perfeitamente possível projetar um sistema OO que use o modelo de orientação por eventos para tratar eventos de interface, comunicações, etc.
Porém, temos um problema: uma linguagem
puramente OO não possui o conceito de
função. Como resolver então?
A solução é utilizar um objeto que faça o papel de callback. Ou seja, onde registraríamos uma função, passamos a registrar um objeto.
Assim, quando o sistema precisar
executar a callback, ele deverá executar
um determinado método do objeto. Esse
método, então, fará o tratamento do evento.
Como Java é uma linguagem OO na qual não existe o conceito de função, callbacks devem ser implementadas através de
objetos
Um objeto que implementa uma
callback em Java é chamado de listener
Os listeners fazem o papel das callbacks.
Listeners são definidos por interfaces e podem estar aptos a tratar mais de um tipo de evento.
Quando um listener tem um de seus métodos
chamados, ele recebe um parâmetro que
descreve o evento ocorrido. Esse parâmetro é um
objeto: existem classes para modelar diferentes
grupos de eventos.
Definem interfaces que representam um grupo de callbacks
São registrados junto aos componentes
Exemplo: java.awt.event.MouseListener
public abstract void mouseClicked(MouseEvent e) public abstract void mousePressed(MouseEvent e) public abstract void mouseReleased(MouseEvent e) public abstract void mouseEntered(MouseEvent e) public abstract void mouseExited(MouseEvent e)
Evento ocorrido que é um evento de mouse Métodos do Listener
que tratam os eventos
Modela a callback de um evento do tipo ActionEvent.
Esse tipo de evento é o mais simples e significa a ação principal do componente, tal como um clique do botão, seleção de um item num combo, etc.
public abstract void actionPerformed(ActionEvent e)
Trazem informações sobre o evento ocorrido
São passados aos listeners (callbacks)
Modela o evento que representa uma ação executada sobre um componente.
O significado depende do componente.
Esse tipo de evento é o mais simples e pode significar a ação principal do componente, tal como:
Exemplos:
◦ “um clique do botão”
◦ “seleção de um item num combo,”
◦ “botão pressionado“
◦ “entrada de texto finalizada”
◦ • …
Modela os eventos que podem ocorrer em uma janela.
Essa classe declara constantes que identificam os diversos eventos
• WINDOW_OPENED: quando a janela é aberta
• WINDOW_CLOSING : quando a janela está sendo fechada
• WINDOW_CLOSED : quando a janela foi fechada
• WINDOW_ICONIFIED : quando a janela é maximizada
• WINDOW_DEICONIFIED : quando a janela é minimizada
• WINDOW_ACTIVATED: quando a janela é ativada (mostrada)
• WINDOW_DEACTIVATED: quando a janela é desativada.
Modela os eventos que podem ocorrer com mouse. Essa classe declara constantes que identificam os diversos eventos de mouse:
MouseClicked(MouseEvent e): quando o mouse é clicado (clica e solta) MousePressed(MouseEvent e): quando o mouse é pressionado (aperto) MouseReleased(MouseEvent e): quando se passa o mouse sobre
MouseEntered(MouseEvent e): quando o foco chega ao mouse
MouseExited(MouseEvent e): quando solta o botão do mouse
(despressiona)
Modela os eventos que podem ocorrer de foco. Essa classe declara constantes que identificam os diversos focos ao componente:
FocusGained(FocusEvent evt): quando um componente recebe o foco
FocusLost(FocusEvent evt): quando um componente perde o foco
Modela os eventos que podem ocorrer com digitação de texto. Essa classe declara constantes que identificam os diversos eventos de teclado:
KeyPressed(KeyEvent evt): quando se aperta uma tecla
KeyReleased(KeyEvent evt): quando se digita pelo menos dois caracteres (pois um seria o evento anterior)
KeyTyped(KeyEvent evt): quando se digitou um caracter (apertou e
soltou). Pode-se utilizar para verificar o que foi digitado pelo usuário.
Basta clicar com o botão direito do mouse em cima de cada componente e acessar a opção “Eventos” e depois qual
categoria de eventos para aquele componente você deseja;
Exemplo: acessando
eventos de um Botão
Observe que a categoria Action significa a ação para aquele componente, no caso, o Botão;
Ao acessa-la, você visualiza o Listener previsto que é o actionPerformed que significa “acionar o botão” ou
simplesmente “clica-lo”.
Clicando no Listener, ele cria o método para o evento na área
de código para você programar como convier:
Agora você já pode dar funcionalidade à
sua interface, fazendo a manipulação
(programação) dos eventos que desejar de
seus componentes relacionados!
Caixas de Diálogos
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
A entrada de dados pelo dispositivo padrão pode ser um problema;
Vamos ver uma alternativa, tanto para entrada como para saída de dados;
Para tanto utilizaremos Caixas de Diálogo
implementadas através da classe JOptionPane;
import javax.swing.JOptionPane; // Importa a Classe JOptionPane
public class PrimeiraJanelaDialogo { public static void main(String [] args) {
// Mostra uma mensagem na tela // Primeiro parâmetro é sempre null
// Segundo parâmetro é a mensagem que se deseja exibir
JOptionPane.showMessageDialog (null, "Para continuar clique no botão \"OK\"!");
System.exit(0); // Termina o programa
} A Classe System faz parte do
pacote java.lang, que é automaticamente importado em
todo programa Java.
ÍCONE
BOTÕES DE
OPÇÃO
CAMPO DE
ENTRADA MENSAGEM
TÍTULO
68
A Classe JOptionPane possui os seguintes métodos:
showMessageDialog
Mostra algum aviso ao usuário
showConfirmDialog
Solicita uma confirmação do tipo SIM/NÃO/CANCELAR
showInputDialog
Solicita alguma entrada
showOptionDialog
É uma unificação dos três métodos anteriores
JOptionPane.showMessageDialog (...);
showMessageDialog (null, “mensagem”);
showMessageDialog (null, “mensagem”, “título”, messageType);
showMessageDialog (null, “mensagem”, “título”, messageType, icone);
Tipo do ícone
messageType
JOptionPane.ERROR_MESSAGE
JOptionPane.INFORMATION_MESSAGE
JOptionPane.WARNING_MESSAGE
JOptionPane.QUESTION_MESSAGE
JOptionPane.PLAIN_MESSAGE
int resultado;
resultado = JOptionPane.showConfirmDialog (...);
showConfirmDialog (null, “mensagem”);
showConfirmDialog (null, “mensagem”, “título”, optionType);
showConfirmDialog (null, “mensagem”, “título”, optionType, messageType);
showConfirmDialog (null, “mensagem”, “título”, optionType, messageType, “ícone”);
Botões desejados
optionType
JOptionPane.DEFAULT_OPTION (botão de Ok)
JOptionPane.YES_NO_OPTION
JOptionPane.YES_NO_CANCEL_OPTION
JOptionPane.OK_CANCEL_OPTION
showInputDialog (“mensagem”);
showInputDialog (null, “mensagem”);
showInputDialog (null, “mensagem”, “título”, messageType);
showInputDialog (“mensagem”, “valorInicial”);
showInputDialog (null, “mensagem”, “valorInicial”);
showInputDialog (null, “mensagem”, “título”, messageType, ícone , valoresSelecao[] , valoresSelecao[1]);
String resultado;
resultado = JOptionPane.showInputDialog (...);
int resultado;
resultado = JOptionPane.showOptionDialog (...);
showOptionDialog (null, “mensagem”, “título”, optionType, messageType, icone, opcoes[], opcoes[1]);
Conhecendo os demais componentes Swing
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
O componente JFormattedTextField, similar a uma caixa de texto JTextField, fornece a possibilidade da validação e exibição de dados formatados em tempo real, ao seja, à medida que seu conteúdo é inserido.
• Esse componente é conhecido nas linguagens Visual Basic, Delphi, C++ como MaskEdit, ou simplesmente caixa de texto tipo máscara.
A vantagem de usar uma caixa de texto tipo máscara é
que o usuário é forçado a digitar os dados no formato
especificado. O controle não aceita conteúdo que não
siga os padrões predefinidos.
Para configurar a máscara (no NetBeans): propriedade
formatterFactory:
Antes de usar o componente JFormattedTextField, é preciso entender o funcionamento da classe
MaskFormatter (do pacote javax.swing.text).
Essa classe é usada para especificar a máscara que
será usada na caixa de texto.
Para pegar os dados com a máscara:
• getText()
• (Classe especifica)getValue() faz-se o casting
Para pegar os dados sem a máscara:
Exemplo:
String str = jFormattedTextField1.getText();
String result = str.replace(".","").replace("-", "");
Vamos conhecer os demais componentes através de outro exemplo prático!
Para isso, vamos construir uma aplicação- exemplo de controle de automóveis.
Vamos trabalhar com o arquivo
Aula_Visual_Automovel.pdf que possui o passo-
a-passo de nossa aplicação.
Semelhante ao Campo de Tetxo, porém, permite que a inserção de texto seja em mais linhas (e colunas);
Proporciona maior autonomia e quantidade de texto, tais
como um corpo de mensagem de um email, ou campo
de observações, dentre outros.
Basicamente possui propriedades para configurar como as barras de rolagem (vertical e horizontal) aparecerão e se comportarão no componente;
As propriedades para se definir esse padrão são:
horizontalScrollBarPolicy (para barra horizontal) e verticalScrollBarPolicy (para barra vertical)
Valores que podem assumir:
◦ ALWAYS: as barras sempre estão aparecendo;
◦ AS_NEEDED: somente quando extrapolar a área (vertical ou horizontal);
◦ NEVER: as barras não aparecem em hipótese alguma.
Possui as mesmas propriedades do Campo de Texto: getText( ), setText( ), getSelectedText( );
A propriedade lineWrap, quando acionada, permite que o texto quebre automaticamente quando chegar à margem (inclusive aparecendo automaticamente a barra de rolagem)
Métodos principais e expecíficos:
append(String texto) – acrescenta linha no final
insert(String texto,int posição) – insere linha numa posição;
setLineWrap(boolean) – determina se o texto quebrará
automático quando chegar a margem final
Também identificada como Lista Drop-Down, é um componente de seleção de itens previamente definidos;
Sua vantagem em relação aos demais
componentes de seleção é o espaço reduzido que
ocupa num formulário e a facilidade de manipulação
via código-fonte;
Para montagem de seus itens, acessa-se via
propriedade model, que abrirá uma caixa para
inserção dos itens:
Para manipular os itens da caixa, é preciso saber que a lista de itens funciona como um “vetor” e cada item ocupa uma posição e, portanto, possui um índice;
Este índice é automático e cada item possui seu valor de acordo com a posição que está na lista, sendo o primeiro a começar de zero e segue sequencialmente até o final.
Logo, este índice pode ser utilizado em alguns métodos para acessar valores selecionados ou “selecionar” um item específico.
0 1
2 3
Principais métodos para manipulação do componente no código-fonte:
addItem(Object): acrescenta itens;
getItemAt(int): retorna o texto do item na posição de índice especificada pelo argumento inteiro;
getItemCount( ): retorna o nº de itens;
getSelectedIndex( ): retorna a posição do índice do item selecionado;
getSelectedItem( ): retorna o texto do item selecionado;
setSelectedIndex(int): seleciona na lista o item na
posição de índice indicada;
São também componentes para seleção de itens, onde estes aparecem dispostos inteiramente no formulário (portanto, ocupam mais espaço);
Possuem o mesmo comportamento, porém a principal diferença entre eles é:
◦ Botão de Radio: permite somente a seleção de UM item somente;
◦ Caixa de seleção: permite a seleção de mais de um item
Radio
Check
Todos possuem as propriedades comuns aos demais campos, com a mesmas características: foreground, background, text, icon, font.
Porém, como se trata de um campo de seleção, pode ter situações que um determinado item possa se apresentar já selecionado para o usuário;
Esta propriedade é selected: basta selecionar o item
desejado e marcar essa opção.
Vários métodos em comum:
• setSelected(boolean): seleciona o componente se o argumento for true.
• isSelected( ): retorna um booleano se o componente está selecionado.
• getText(): pegar o texto do item
No caso específico dos campos Radio, se você testar sua aplicação verá que não ocorre a exclusão mútua, ou seja, se selecionar um item desmarca automaticamente os demais;
Para que esse comportamento padrão ocorra, precisamos vincular todos os campos Radio a um Grupo de Botões;
Ao arrasta-lo para seu formulário, ele fica invisível, pois é um componente de “comportamento” ao invés de um componente
“visual”;
Você poderá acessa-lo e visualiza-lo através da área Navegador
do NetBeans (canto inferior esquerdo)
No NetBeans
Selecionar todos para que eles estejam submetidos ao mesmo Grupo de Botões
O uso de Grupo de Botões facilita a manipulação global dos Radios, como por exemplo:
Para limpar o grupo de RadioButtons
buttongroup1.clearSelection();
Preparando os campos Radio para definir qual valor será capturado quando a opção for selecionada, podendo ser o próprio texto da opção.
Para isso, precisamos definir a propriedade
actionCommand (que já deve ter o texto colocado na
propriedade text)
Vamos clicar no botão de 3 pontinhos ao lado e abrirá a
janela de definição da propriedade
Iremos escolher a opção Código Personalizado, pois é
ali que definiremos qual valor do Radio será capturado
quando for marcado:
Observe que foi selecionado o Radio da opção ‘Casado’.
Basta preencher no campo designado o valor que se
queira capturar quando for selecionado. Nesse caso,
iremos manter o texto de identificação do campo, mas
poderia ser qualquer valor desejado.
Com todos os campos Radio definidos os valores que serão capturados em cada opção:
Para pegar a opção selecionada, usamos o buttonGroup:
String valor;
valor = buttonGroup1.getSelection().getActionCommand();
valor terá o texto colocado em actionCommand da opção
selecionada
Serão dados vários códigos de exemplo de como manipular campos Radio,
ComboBox, TextField e outros, na seção
DICAS DE IMPLEMENTAÇÃO
mais à frente!
É um container semelhante a um JPanel, porém com a capacidade de se incluir várias guias (ou “orelhinhas”), que são na verdade subáreas do painel que funcionam como novos containers;
Desta forma podemos ter várias áreas de componentes e
um único componente ou local;
Incluindo Abas
O Painel de Guias possui a propriedade border similar a qualquer JPanel para melhorar seu layout.
A propriedade font configura os textos e títulos de todas as
abas (como colocar em negrito, por exemplo)
A ordem em que as guias aparecem podem ser modificadas no Navegador “puxando”
uma pra cima ou pra baixo de acordo com o
local desejado:
Principais métodos para manipulação do componente no código-fonte:
getTabCount( ): retorna o número total de abas;
setEnabledAt(int index, boolean status):
desabilita ou não uma aba específica;
setTitleAt(int index, String titulo): muda o título de uma aba espcífica pelo seu indice;
setSelectedIndex(int): seleciona uma aba específica, sendo a primeira contendo índice 0;
Os demais métodos GET capturam as mesmas
informações que são setadas.
Também é uma lista drop-down, porém com a
particularidade de se selecionar mais de uma opção;
Destacamos a propriedade selectionMode, que define como será o método de seleção dos itens:
SINGLE: seleciona somente um item selecionado; funciona como um Combo Box
SINGLE_INTERVAL: captura um item do intervalo selecionado;
MULTIPLE_INTERVAL: seleciona vários itens
Principais métodos:
setVisibleRowCount(int): define quantas linhas serão exibidas;
getSelectedValues( ): retorna um array de
objetos que contém todos os itens selecionados;
Os demais métodos são aqueles encontrados
numa Caixa de Combinação.
Verifique que um componente JList é colocado dentro de um container, que é a Barra de Rolagem
(JScrollPane);
Este componente é responsável por definir as barras de
rolagem de um componente que pode possui-las, que é
o caso do JList e pode ser também do JTextArea.
Dicas de implementações Úteis para componentes
Prof. Giuliano Prado de Morais Giglio, M.Sc.
A Plataforma Java
Aplicações Visuais com
Swing
Limpando todos os campos jTextField de um JFrame de uma só vez:
for (int i=0; i < getContentPane().getComponentCount(); i++) {
Component c = getContentPane().getComponent(i);
if (c instanceof JTextField) {
JTextField field = (JTextField) c;
field.setText(" ");
}
}
Explicando....
getContetPane(): método do JFrame para acessar TODO o conteúdo (componentes) do container.
Deste conteúdo, o método getComponentCount() fornece a quantidade de componentes que o container possui.
Faze-se um for então em cada um desses componentes, pois eles estão dispostos em uma espécie de vetor.
for (int i=0; i < getContentPane().getComponentCount(); i++) {
}
Explicando....
Para pegar um componente, acesse-o pelo método
getComponent() passando o índice do mesmo, que é a posição que ele ocupa no “vetor” de componentes
Todo componente swing herda da classe “pai”
Component , porém, por polimorfismo, ele possui a interface de Component , porém ele é um componente específico (JButton, JTextField, etc...)
Component c = getContentPane().getComponent(i);
Explicando...
Logo precisamos ver qual componente precisamos e, se for (caso do IF abaixo, que procuramos JTextField),
fazemos o casting (ou seja, tiramos a interface
Component para a interface correta do componente) e fazemos o desejado com ele, no caso, limpar o campo de texto.
if (c instanceof JTextField) {
JTextField field = (JTextField) c;
field.setText(" ");
}
Caso os campos jTextField estejam dentro de um JPanel:
for(int i = 0; i < getContentPane().getComponentCount(); i++) { Component c = getContentPane().getComponent(i);
if ( c instanceof JPanel) {
JPanel p = (JPanel)c;
for(int j = 0; j < p.getComponentCount(); j++) {
Component c2 = p.getComponent(j);
if (c2 instanceof JTextField) {
JTextField field = (JTextField)c2;
field.setText("");
} } } }
O processo é o mesmo que o anterior, porém primeiro eu verifico se os componentes estão em um JPanel e deste eu pego seus componentes internos.
Podemos fazer um campo de texto só aceitar a digitação de números ou de letras.
Para isso usamos o evento KeyTyped do campo. Vejamos:
String caracteres = "0987654321";
if(!caracteres.contains(evt.getKeyChar()+"")) {
evt.consume();
}
Explicando....
Neste código, na variável String estamos determinando quais caracteres devem ser aceitos.
Neste caso estamos apenas aceitando números.
E no if verificamos se o caracter que gerou o evento não está na variável caracteres, caso esteja acionamos a propriedade consume do evento.
Acrescentamos o ! que é a negação do teste, ou
seja se o caractere que gerou o evento NÃO estiver
na lista, esse caractere deve ser removido, no caso
acionando Consume.
Explicando....
O método consume( ) pode ser interpretado como:
“consome este evento de modo que não será processado na maneira padrão pela fonte que a originou”.
Traduzindo, este evento não deve ser executado.
