Os componentes Swing são semelhantes aos componentes AWT, mas adicionam novos métodos a cada componente e fornecem componentes mais avançados.
Componentes básicos do Swing:
1. Botão (JButton):
Os botões no Swing podem exibir imagens, e o botão pode ser definido como o ícone padrão para uma janela, e várias imagens podem ser atribuídas a um botão.
(1) Métodos de construção de JButton comumente usados.
JButton(String text): Caracteres exibidos no botão.
JButton (Ícone): Exibe o ícone do botão.
JButton (String text, Icon icon): Ícones e caracteres são exibidos no botão.
(2). Métodos comumente usados:
b1.setEnabled(false); //Torna o botão indisponível no momento
b1.setToolTipText("..."): //Definir texto da dica do botão
b1.setMnemonic(KeyEvent.VK_D); // Vincula b1 à tecla alt+D
(3).Código do caso:
Copie o código do código da seguinte forma:
classe pública JButtonExample3 estende JPanel implementa ActionListener {
JButton protegido b1, b2, b3;
public JButtonExample3() {
ImageIcon leftButtonIcon = createImageIcon("direita.gif");
ImageIcon middleButtonIcon = createImageIcon("middle.gif");
ImageIcon rightButtonIcon = createImageIcon("esquerda.gif");
b1 = new JButton("Botão do meio inválido (D)", leftButtonIcon);
b1.setVerticalTextPosition(AbstractButton.CENTER);//Alinhamento central horizontal
b1.setHorizontalTextPosition(AbstractButton.LEADING);//Equivalente a ESQUERDA
b1.setMnemonic(KeyEvent.VK_D); // Vincula b1 à tecla alt+D
b1.setActionCommand("desabilitar");
b2 = new JButton("M botão do meio", middleButtonIcon);
b2.setVerticalTextPosition(AbstractButton.BOTTOM);
b2.setHorizontalTextPosition(AbstractButton.CENTER);
b2.setMnemonic(KeyEvent.VK_M); // Vincula b2 à tecla alt+M
b3 = new JButton("E ativa o botão do meio", rightButtonIcon);
b3.setMnemonic(KeyEvent.VK_E); // Vincula b3 à tecla alt+E
b3.setActionCommand("habilitar");
b3.setEnabled(falso);
//Adiciona ouvintes de eventos a 1 e 3
b1.addActionListener(este);
b3.addActionListener(este);
//Definir o texto do prompt do botão
b1.setToolTipText("Clicar neste botão invalidará o botão do meio!");
b2.setToolTipText("Clique neste botão, nenhum evento ocorre!");
b3.setToolTipText("Clicar neste botão tornará o botão do meio efetivo");
//Adiciona botão ao JPanel
adicionar(b1);
adicionar(b2);
adicionar(b3);
}
public void actionPerformed(ActionEvent e) {
if ("desabilitar".equals(e.getActionCommand())) {
b2.setEnabled(falso);
b1.setEnabled(falso);
b3.setEnabled(verdadeiro);
} outro {
b2.setEnabled(verdadeiro);
b1.setEnabled(verdadeiro);
b3.setEnabled(falso);
}
}
ImageIcon estático protegido createImageIcon (caminho da string) {
java.net.URL imgURL = JButtonExample3.class.getResource(caminho);
if (imgURL! = nulo) {
retornar novo ImageIcon(imgURL);
} outro {
System.err.println("Não foi possível encontrar o arquivo: " + caminho);
retornar nulo;
}
}
public static void main(String[] args) {
//Configure para usar a nova interface swing
//Fornece uma dica se o JFrame recém-criado deve ter as decorações de janela fornecidas pela aparência atual (como bordas, widgets para fechar a janela, títulos, etc.).
JFrame.setDefaultLookAndFeelDecorated(true);
//Cria um formulário
Quadro JFrame = new JFrame("Botão Pequeno Dragão");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Cria um painel
JButtonExample3 newContentPane = new JButtonExample3();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//exibe o formulário
frame.pack();
frame.setLocation(300, 200);
frame.setVisible (verdadeiro);
}
}
Captura de tela em execução:
2. Caixa de combinação (JComboBox):
Explicação detalhada de como usar a caixa de combinação (lista suspensa JComboBox) e exemplos:
Método de construção:
* JComboBox() cria um componente JComboBox.
* JComboBox(modelo ComboBoxModel) Crie um componente JComboBox baseado no modelo.
* JComboBox(Objext[] items) usa objetos array para criar um componente JComboBox.
* JComboBox (itens vetoriais) usa objetos Vector para criar um componente JComboBox.
Métodos comumente usados:
....
Exemplo abrangente:
Copie o código do código da seguinte forma:
import java.awt.* /* Contém todas as classes para criar interfaces de usuário e desenhar imagens gráficas. */
import javax.swing.* /* Forneça um conjunto de componentes "leves" e tente fazer com que esses componentes funcionem da mesma maneira em todas as plataformas */
classe pública JComboBoxDemo estende JFrame {
publicJComboBoxDemo(){
/*
* Container é a classe pai de todos os containers e uma subclasse da classe de componentes da linguagem Java Component. Um container é um componente que tem a função de acomodar outros componentes e containers.
* O elemento mais básico de uma interface gráfica de usuário Java é um componente. Um componente é um objeto que pode ser exibido graficamente na tela e interagir com o usuário, como um botão, uma caixa de texto, etc.
* Em Java, os componentes geralmente são colocados em um determinado contêiner e o método this.getContentPane() é usado para retornar o objeto contentPane deste formato.
*/
ContentPane do contêiner = this.getContentPane();
/* Crie um objeto de painel, especifique o gerenciador de layout como GridLayout, 1 linha e 2 colunas O gerenciamento de layout padrão do Jpanel é FlowLayout */.
JPanel jPanel1 = novo JPanel(novo GridLayout(1, 2));
//Cria JComboBox usando array String
String[] fruta = { "maçã", "banana", "laranja", "pêra", "manga" };
JComboBox jComboBox1 = novo JComboBox(fruta);
jComboBox1.addItem("Other"); //Adiciona outra opção "Outro" no final das opções da caixa de listagem
//Define a borda intitulada do objeto jList1
jComboBox1.setBorder(BorderFactory.createTitledBorder("Sua fruta favorita:"));
//Adiciona a caixa de listagem jComboBox1 ao painel
jPanel1.add(jComboBox1);
//Use ComboBoxModel para criar JComboBox
ComboBoxModel meuModelo = new MeuModelo();
JComboBox jComboBox2 = new JComboBox(meuModelo);
//Define a borda intitulada do objeto jList1
jComboBox2.setBorder(BorderFactory.createTitledBorder("Sua fruta favorita:"));
//Adiciona a caixa de listagem jComboBox2 ao painel
jPanel1.add(jComboBox2);
//Adiciona painel ao contêiner pai
contentPane.add(jPanel1);
//Define o título deste formulário
this.setTitle("JComboBoxDemo");
//Define o tamanho inicial exibido por este formulário
this.setSize(350, 90);
this.setLocation(300, 200);
//Define este formulário para ficar inicialmente visível
this.setVisible(verdadeiro);
}
class MyModel estende DefaultComboBoxModel {
String[] fruta = { "maçã", "banana", "laranja", "pêra", "manga" };
MeuModelo() {
for (int i = 0; i < fruta.comprimento; i++) {
/* O método addElement() é usado para adicionar elementos de opção à caixa de listagem */
this.addElement(fruta[i]);
}
}
}
public static void main(String args[]) {
Teste JComboBoxDemo = novo JComboBoxDemo();
}
}
captura de tela:
3. Caixa de listagem (JList):
A função da caixa de listagem é semelhante à da caixa de listagem suspensa. Ela também permite que os usuários façam escolhas entre vários itens, mas existem algumas diferenças. Ela fornece aos usuários modos de seleção mais diversos, incluindo seleção única e seleção contínua. e seleção múltipla, correspondendo às 3 constantes em ListSelectionModel:
(1) static int SINGLE_SELECTION Somente um pode ser selecionado.
(2) static int SINGLE_INTERVAL_SELECTION Pressione e segure a tecla [Shift] para selecionar o intervalo de contato.
(3) static int MULTIPLE_INTERVAL_SELECTION Mantenha pressionada a tecla [Ctrl] para selecionar vários itens.
O construtor é o seguinte:
(1) JList() cria um componente JList.
(2) JList (modelo ListModel) Crie um componente JList baseado no modelo.
(3) JList(Object[] items) usa objetos array para criar um componente JList.
(4) JList (itens vetoriais) Use objetos Vector para criar um componente JList.
Adicionar a caixa de listagem JList ao JScrollPane pode conseguir a rolagem da caixa de listagem.
O exemplo 1 de uso do componente List (JList) é o seguinte:
Copie o código do código da seguinte forma:
classe pública JListDemo1 estende JFrame{
Painel de conteúdo do contêiner;
JPanel jp;
JList jList1,jList2,jList3;
public JListDemo1(){
contentPane = this.getContentPane();
jp = novo JPanel(novo GridLayout(1,3));
//Use o array String para criar o objeto JList
String[] fruta={"maçã","banana","laranja","pêra","manga"};
jList1=new JList(fruta);
//Define a borda intitulada do objeto jList1
jList1.setBorder(BorderFactory.createTitledBorder("Sua fruta favorita: "));
//Define o modo de seleção do objeto jList1 para seleção única
jList1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jp.add(jLista1);
//Use ListModel para criar um objeto JList para realizar a dinâmica do conteúdo da lista
ListModel myModel=new MyModel(); //Cria um objeto de modelo de lista
jList2=new JList(myModel); //Cria uma lista baseada no objeto do modelo de lista
jList2.setBorder(BorderFactory.createTitledBorder("Sua fruta favorita: "));
//Defina o modo de seleção do objeto jList2 para manter pressionado [Ctrl] para seleções múltiplas
jList2.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jp.add(jLista2);
jList3=new JList(fruta);
jList3.setBorder(BorderFactory.createTitledBorder("Sua fruta favorita: "));
jList3.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jList3.setVisibleRowCount(3);
jList3.setFixedCellWidth(120);
jList3.setFixedCellHeight(30);
JScrollPane jScrollPane = novo JScrollPane(jList3);
add(jScrollPane);
contentPane.add(jp);
this.setTitle("JListDemo");
this.setSize(340.200);
//pacote();
this.setLocation(400, 300);
this.setVisible(verdadeiro);
}
//Ao herdar a classe DefaultListModel, a seleção de lista de conteúdo dinâmico pode ser alcançada
classe MyModel estende DefaultListModel{
String[] fruta={"maçã","banana","laranja","pêra","manga"};
MeuModelo(){
for(int i=0;i<fruta.comprimento;i++){
/* void addElement(Objeto obj)
* Adiciona o componente especificado ao final dessa tabela. */
this.addElement(fruta[i]);
}
}
}
public static void main(String[] args){
JListDemo1 test=new JListDemo1();
}
}
Os resultados da execução são mostrados na figura abaixo:
Código do exemplo 2 da caixa de listagem:
Copie o código do código da seguinte forma:
classe pública JListDemo2 estende JFrame {
Painel de conteúdo do contêiner;
JPanel jp;
JList jListFont, jListSize;
//Construtor
public JListDemo2() {
contentPane = this.getContentPane();
jp = novo JPanel(novo GridLayout());
setJListFont();
setJListFontSize();
contentPane.add(jp);
this.setTitle("JListDemo");
this.setSize(240, 200);
this.setLocation(400, 300);
this.setVisible(verdadeiro);
} // Fim do JListDemo2
public void setJListFont() {
GraphicsEnvironment ge = GraphicsEnvironment
.getLocalGraphicsEnvironment();
final String fontName[] = ge.getAvailableFontFamilyNames(); // Obtém a fonte local do sistema
jListFont = new JList(nomedafonte);
//Define a borda intitulada do objeto jList1
jListFont.setBorder(BorderFactory.createTitledBorder("Fonte do sistema: "));
//Define o modo de seleção do objeto jList1 para seleção única
jListFont.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jListFont.setVisibleRowCount(3);
jListFont.setFixedCellWidth(120);
jListFont.setFixedCellHeight(20);
JScrollPane jScrollPane1 = novo JScrollPane(jListFont);
add(jScrollPane1);
}
public void setJListFontSize() {
String final tamanho da fonte[] = { "8", "9", "10", "12", "14", "15", "16",
"18", "20", "21", "22", "24", "26", "28", "30", "36", "48",
"54", "72", "89"};
//Cria uma caixa de listagem de tamanhos de fonte listSize
jListSize = new JList(fontSize);
jListSize.setBorder(BorderFactory.createTitledBorder("Tamanho da fonte: "));
//Defina o modo de seleção do objeto jList2 para manter pressionado [Ctrl] para seleções múltiplas
jListSize
.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jListSize.setVisibleRowCount(3);
jListSize.setFixedCellWidth(120);
jListSize.setFixedCellHeight(20);
JScrollPane jScrollPane2 = novo JScrollPane(jListSize);
add(jScrollPane2);
}
public static void main(String[] args) {
Teste JListDemo2 = novo JListDemo2();
}
}
Diagrama esquemático da operação do programa:
4.javax.swing
Classe JColorChooser:
JColorChooser (caixa de diálogo de seleção de cores) fornece um painel controlador que permite ao usuário manipular e selecionar cores.
Construtor JColorChooser:
JColorChooser(): Crie um objeto JColorChooer, a cor padrão é branco.
JColorChooser (Color inicialColor): Crie um objeto JColorChooer e defina a cor inicial.
JColorChooser (modal ColorSelectionModel): Constrói um objeto JColorChooser com ColorSelectionModel.
A maneira mais comum de usar JColorChooser é usar o método estático showDialog() do JColorChooser. Ou seja, na maioria dos casos, não criaremos um novo objeto JColorChooser, mas usaremos diretamente o método estático (showDialog()) do JColorChooser. para gerar a caixa de diálogo de seleção de cores. Usando este método, também podemos obter a cor selecionada pelo usuário. Se o usuário não escolher, um valor nulo será retornado.
Código simples do caso 1 para caixa de diálogo de seleção de cores:
Copie o código do código da seguinte forma:
classe pública JColorChooserDemo {
public static void main(String[] args) {
Quadro JFrame = new JFrame("JColorChooserDemo");
painel MeuPainel = new MeuPainel();
frame.getContentPane().add(painel);
frame.pack();
frame.setLocation(300, 200);
frame.setVisible (verdadeiro);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MyPanel estende JPanel implementa ActionListener {
privado estático final longo serialVersionUID = 1L;
botão JButton privado, rgb, vermelho, verde, azul;
cor privada cor = nova cor (255, 51, 150);
public MeuPainel() {
botão = new JButton("Obter cor");
rgb = new JButton("RGB: ");
vermelho = new JButton("Vermelho: ");
verde = new JButton("Verde: ");
azul = new JButton("Azul: ");
button.addActionListener (este);
setPreferredSize(nova Dimensão(550, 250));
setLayout(novo FlowLayout(FlowLayout.CENTER, 5, 5));
setBackground(cor);
adicionar(botão);
adicionar(rgb);
adicionar(vermelho);
adicionar(verde);
adicionar(azul);
}
public void actionPerformed(ActionEvent e) {
color = JColorChooser.showDialog(this, "Escolher Cor", cor);
if (cor! = nulo) {
setBackground(cor);
button.setText("Obter novamente");
rgb.setText("RGB: " + color.getRGB());
red.setText("Vermelho: " + color.getRed());
green.setText("Verde: " + color.getGreen());
blue.setText("Azul: " + color.getBlue());
}
}
}
O diagrama de resultados em execução é o seguinte:
Outra maneira comum de usar JColorChooser é usar o método estático createDialog(). Depois de usar este método estático, você obterá um objeto JDialog. No entanto, podemos usar este objeto JDialog. Para utilizar este método, você deve cooperar com o objeto JColorChooser, ou seja, você deve criar um novo objeto JColorChooser. O exemplo a seguir apresenta o JColorChooser mais simples e prático. Após selecionar a cor, você pode alterar a cor de fundo no JLabel.
Código simples do caso 2 para caixa de diálogo de seleção de cores:
Copie o código do código da seguinte forma:
importar java.awt.*;
importar java.awt.event.*;
importar javax.swing.*;
classe pública ColorChooserDemo1 estende MouseAdapter {
JFrame f = nulo;
Rótulo JLabel = null;
JLabel rótulo1 = nulo;
JLabel rótulo2 = nulo;
Retângulo rec1 = nulo;
Retângulo rec2 = nulo;
public ColorChooserDemo1() {
f = new JFrame("Exemplo ColorChooser");
ContentPane do contêiner = f.getContentPane();
contentPane.addMouseListener (este);
rótulo = novo JLabel(" ", JLabel.CENTER);
label.setPreferredSize(nova Dimensão(300, 20));
Painel JPanel = novo JPanel();
painel.setLayout(novo GridLayout(1, 2));
label1 = new JLabel("Etiqueta Esquerda", JLabel.CENTER);
label1.setBackground(Color.vermelho);
label1.setForeground(Color.preto);
rótulo1.setOpaque(true);
rótulo1.setBounds(0, 0, 150, 150);
painel.add(rótulo1);
label2 = new JLabel("Etiqueta Direita", JLabel.CENTER);
label2.setBackground(Color.verde);
label2.setForeground(Color.preto);
label2.setOpaque(true);
rótulo2.setBounds(150, 0, 150, 150);
painel.add(rótulo2);
rec1 = rótulo1.getBounds();
rec2 = rótulo2.getBounds();
contentPane.add(painel, BorderLayout.CENTER);
contentPane.add(rótulo, BorderLayout.SOUTH);
f.setSize(nova Dimensão(300, 150));
f.setVisible(verdadeiro);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
Sistema.exit(0);
}
});
}
// Implemente os métodos mousePressed() e mouseClicked() em MouseAdapter Quando o mouse é pressionado, você pode saber a posição atual do cursor do mouse.
//Duas vezes, se o cursor estiver na etiqueta, uma caixa de diálogo de seleção de cores aparecerá, e o usuário poderá escolher qualquer cor para alterar a cor da etiqueta.
public void mousePressed(MouseEvent e) {
label.setText("As coordenadas atuais do mouse (X,Y) são: (" + e.getX() + "," + e.getY() + ")");
}
public void mouseClicked(MouseEvent e) {
Ponto ponto = e.getPoint();
if (e.getClickCount() == 2) {
if (rec1.contains(ponto)) {
/*
* Use o método estático showDialog() do JColorChooser para gerar a caixa de diálogo de seleção de cores
*, os três parâmetros em showDialog() são: componente pai da caixa de diálogo, título da caixa de diálogo de seleção de cor
*, com a cor padrão da caixa de diálogo Após o usuário selecionar a cor, pressione o botão “OK” para retornar.
* Objeto de cor, se o botão "Cancelar" for pressionado, será retornado valor nulo.
*/
Cor cor = JColorChooser.showDialog(f,
"Alterar cor do rótulo1", Color.white);
if (color != null) // Se o valor for nulo, significa que o usuário pressionou o botão Cancelar
label1.setBackground(cor);
}
if (rec2.contains(ponto)) {
Cor cor = JColorChooser.showDialog(f,
"Alterar cor do rótulo2", Color.yellow);
if (color != null) // Se o valor for nulo, significa que o usuário pressionou o botão Cancelar
label2.setBackground(cor);
}
}
}
public static void main(String[] arg) {
novo ColorChooserDemo1();
}
}