Interface Gráfica

Introdução à Interface Gráfica com o Usuário (GUI) e ao pacote javax.swing.

1. API Java Swing

A API Java Swing está contida no pacote javax.swing. Essa API provê funcionalidades para criação de componentes e containers “leves” (puramente criados em Java). A API Swing foi feita para substituir a API AWT. Muitas das novas classes refeitas foram chamadas com o nome antigo que recebiam do componente AWT legado prefixado com um “J”.

Por exemplo, Swing utiliza a classe JButton para representar um container de botão, onde AWT utiliza a classe Button.

Swing também fornece o suporte ao conceito look-and-feel, permitindo mudanças universais no estilo dos componentes da interface gráfica com o usuário. Outras características são: inclusão de tooltips, funcionalidades de acessibilidades, modelo de eventos e componentes sofisticados como tabelas, árvores, componentes de texto, sliders, e barras de progresso.

A API Swing faz um excelente uso de subpacotes, com 16 deles na versão Java SE 6. Como já fora mencionado, quando classes comuns são separadas em seus próprios pacotes, a usabilidade do código e manutenção são alavancadas.

Swing tira proveito da arquitetura model-view-controller (MVC). O modelo representa o estado atual de cada componente. A visão é a representação dos componentes sobre a tela. O controle é a funcionalidade que liga os componentes de interface com usuário aos eventos.

Algumas das classes principais da API Swing são representadas abaixo:


A tabela a seguir mostra funcionalidades de algumas subpartes da API Swing:

Subpacote Funcionalidade
//Pacote Java Swing
import javax.swing.*;
Criação de componentes básicos como botões, painéis e caixas de diálogo. Fornece o código para importar as classes necessárias do pacote
//Subpacote Java Swing text
import javax.swing.text.*; 
Dá suporte a aspectos relacionados com textos de seus componentes Swing. Fornece o código para importar as necessárias classes do pacote
//Subpacote Java Swing plaf
import javax.swing.plaf.*;
Ajuda a implementar e configurar suporte básico adaptável look-and-feel. Fornece o código para importar as necessárias classes do pacote
//Subpacote Java Swing event
import javax.swing.event.*;
Ajuda a criar observadores de eventos e adaptadores. Fornece o código para importar as necessárias classes do pacote

pacote javax.swing.

Pacote Finalidade
javax.swing contém os mais básicos componentes, modelos e interfaces .
javax.swing.border classes e interfaces usadas para definir estilos de bordas. Note que bordas são compartilhadas para qualquer componente Swing.
javax.swing.colorchooser classes e interfaces que proporcionam suporta para o componente JColorChooser, usado para a seleção de cores.
javax.swing.event o pacote event contém todos tipos de events e listeners específicos do Swing. Componentes Swing também suportam events e listeners definidos no java.awt.event e java.beans.
javax.swing.filechooser classes e interfaces que porporcionam suporte para o componente JFileChooser, usado para a seleção de arquivos.
javax.swing.plaf contem a API plugavél “look-and-fell” usada para definir interfaces de usuário customizadas. Muitas das classes são abstract. São subclasseadas ou implementadas pela implementação do “look-and-fell” tal como metal, motif e basic.
javax.swing.plaf.basic consiste da implementação do “look-and-fell” Basic. Subclassear classes deste pacote somente se quiser criar componentes customizados.
javax.swing.plaf.metal metal é o “look-and-fell” defaul dos componentes Swing.
javax.swing.table classes e interfaces que proporcionam suporte ao componente JTable. Este componente é usado para manipular dados tabulares em planilha.
javax.swing.text classes e componente que proporcionam suporte a componentes de documento de texto.
javax.swing.text.html extensão do pacote text contém suporte a componentes de texto HTML.
javax.swing.text.html.parser suporte a parsing HTML.
javax.swing.text.rtf suporte a documentos RTF
javax.swing.tree classes e interfaces que proporcinam suporte ao componente JTree. Este componente é usado para apresentar e gerenciar dados hierárquicos.
javax.swing.undo Suporte a funcionalidade undo/redo.

A Java Standard Edition API contém vários pacotes.
A tabela a seguir mostra os pacotes mais comuns utilizados em Java e suas funcionalidades:

Pacote Funcionalidade
Java AWT Criação de gráficos e imagens básicos além de interfaces com o usuário.
Java Swing Criação de componentes de interface com o usuário mais sofisticadas.
Java Basic I/O Utilização de streams de dados.
Java Networking Desenvolvimento de aplicações de rede.
Java Utilities Para trabalhar com coleções, modelo de eventos e componentes de data e hora.
Java Language Para utilizar as classes e interfaces core da linguagem Java.

2. Interface Gráfica - I

A interface gráfica é formada por uma grande quantidade de componentes que são colocados em containers. Os containeres mais usados são janelas (instâncias de JFrame) e painéis (JPanel).
Componentes podem ser dispostos (colocados) sobre containeres, e incluem botões, menus, rótulos (labels), e também outros painéis menores.


Nas primeiras versões de Java, a GUI era formada pelas classes do pacote java.awt (Automatic Windowing Toolkit). Essas classes (Frame, Panel, Button, etc) apenas repassavam para o Sistema Operacional subjacente (Windows, MacOS, Linux, etc) a tarefa de desenhar a interface, de modo que a aparência mudava com a plataforma. A partir do Java 2 (1.2 em diante) foi introduzido o pacote javax.swing. Nele, as classe antigas foram refeitas (JFrame,JPanel, JButton, etc) e sua aparência passou a ser independente de plataforma.


2.1. JFrame (Janela)

Quase todas as interfaces gráficas são compostas de uma janela principal ou de alto-nível, onde são montados os outros componentes. Na Swing essas janelas são geralmente uma instância das classes JFrame ou JWindow. A diferença entre essas duas classes está na simplicidade, JWindow não tem a barra de título e não coloca botões na barra de tarefas, portanto utilizaremos a JFrame.
JFrame é a versão Swing do Frame(AWT) , porém ela é descendente direta da classe Frame, por isso ao adicionarmos componentes ao JFrame teremos que utilizar o JPanel para gerenciar estes componentes .
Características da JFrame: Janela com título, bordas, barra de menu (opcional) e componentes especificados pelo usuário. Esta pode ser movida , ter o tamanho ajustado e permitir a adição de ícones. Veremos a seguir um exemplo de um JFrame.

Exemplo:

import javax.swing.*;

public class ExemploJFrame {

    private JFrame f;

    public ExemploJFrame() {
        f = new JFrame("Exemplo de JFrame");

    }

    public void CriaFrame() {
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300, 300);
        f.setVisible(true);
    }

    public static void main(String args[]) {
        ExemploJFrame janela = new ExemploJFrame();
        janela.CriaFrame();
    }
}

run:


2.2. Geradores de Layout:

O construtor da classe PainelBotoes cria os 3 botões, e adiciona cada um ao painel (a si mesmo) com o método add(). Os botões são adicionados ao painel usando um objeto layout manager. A expressão significa "gerenciador de layout", ou "gerenciador de disposição", ou seja, um objeto que possui métodos já programados com uma estratégia definida para dispor os diversos componente sobre a área do painel. A palavra layout de tão usada ganhou recentemente um aportuguesamento oficial, recebendo a grafia "leiaute".

Instâncias da classe JPanel, ou de suas subclasses, já são construídas tendo como gerenciador de layout default um gerenciador da classe java.awt.FlowLayout. Esse gerenciador dispõe os componentes sobre a área do painel de forma similar às linhas de um texto, ou seja, de cima para baixo, e da esquerda para a direita.
Existem diversas outras classes de gerenciadores de layout em Java. A classe BorderLayout (gerenciador padrão da classe JFrame) dispõe os componentes em cinco áreas: Norte, Sul, Leste, Oeste, e Centro. A classe GridLayout dispõe os componentes na forma de uma grade de células como uma matriz de linhas e colunas. É possível alterar o gerenciador de layout de um painel enviando a ele a mensagem setLayout(<instancia de um gerenciador>).

2.3. Painéis e Janelas

Para entender o restante do programa, um painel precisa estar dentro de um container, como mencionado acima. Containeres são objetos que podem conter componentes. Uma janela (JFrame) contém um container predefinido que se obtém através do método getContentPane(). Todos os componentes que não são menus devem ser colocados nesse container. No exemplo, é definida uma classe JanelaBotoes (extensão de JFrame). O construtor de JanelaBotoes adiciona uma instância de PainelBotoes ao seu container, com a linha:
add(new PainelBotoes);
Isso a partir da versão 5.0. Até a versão 1.4 era necessário escrever: contentPane.add(new PainelBotoes); Finalmente, uma classe TestaBotoes é criada, com um método main() que cria uma instância de JanelaBotoes, e envia a ela o método setVisible(true) para que a janela apareça.
Nesta primeira versão, a classe PainelBotoes implementa ActionListener, e o próprio painel será ouvinte dos 3 botões. As classes estão no pacote PainelOuvinte:

a) Classe do painel com os 3 botoes, onde o painel será o ouvinte dos 3 botões:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PainelBotoes extends JPanel implements ActionListener {
// variaveis de instancia:
    private JButton botaoAmarelo;
    private JButton botaoAzul;
    private JButton botaoVermelho;
// Construtor
    public PainelBotoes() {
        botaoAmarelo = new JButton("Amarelo");
        this.add(botaoAmarelo); //this é opcional. Referencia o painel.
        botaoAmarelo.addActionListener(this);
        botaoAzul = new JButton("Azul");
        add(botaoAzul);
        botaoAzul.addActionListener(this);//registrando o painel como ouvinte
        botaoVermelho = new JButton("Vermelho");
        add(botaoVermelho);
        botaoVermelho.addActionListener(this);
    }
// metodo de ouvinte, para tratar os eventos gerados ao clicar um botao
    public void actionPerformed(ActionEvent evt) {
        Object source = evt.getSource();
// A variavel color precisa ter um valor inicial
// pois os if's poderiam todos falhar, em teoria.
        Color color = getBackground();
        if (source == botaoAmarelo) {
            color = Color.yellow;
        } else if (source == botaoAzul) {
            color = Color.blue;
        } else if (source == botaoVermelho) {
            color = Color.red;
        }
        setBackground(color);
        repaint();
    }
}

b) A classe que define a janela:

import javax.swing.*;
public class JanelaBotoes extends JFrame {
    public JanelaBotoes() {
        setTitle("Teste de Botoes"); //metodo de JFrame
        setSize(450, 300);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        add(new PainelBotoes());
        setVisible(true);
    }
}

c) Classe para testar:

public class TesteBotoes {

    public static void main(String[] args) {
        JanelaBotoes frame = new JanelaBotoes();
    }
}

Execução da classe TesteBotoes:



Melhorando o programa:

Há um defeito básico na forma como programamos o ouvinte dos eventos de botão: cada vez que um botão é clicado, um mesmo ouvinte é avisado. O método actionPerformed precisa usar um comando if para testar de qual botão partiu o evento. Isso não é bom porque um mesmo método determina o comportamento de vários botões. E em um programa O-O bem feito, cada método deve fazer apenas uma ação.
Imagine se mais tarde desejamos retirar um dos botões, ou incluir um botão novo, ou alterar o comportamento de um deles. Teremos que alterar partes desse único método, potencialmente introduzindo erros nos comportamentos dos demais botões, e obrigando a retestar todos os botões.

O ideal é ter um ouvinte separado para cada botão.
A solução usualmente adotada é criar uma classe interna para cada ouvinte. Uma classe interna é definida dentro de outra classe, e tem acesso a todas as variáveis e métodos privados da classe hospedeira.

Com o uso de três classes internas, podemos ter três métodos actionPerformed diferentes, o que seria impossível dentro de uma única classe. Veja como fica a nova solução abaixo, onde o painel não é mais o ouvinte dos eventos dos botões:


Classe PainelBotoes.java, contendos as classes OuvinteAmarelo, OuvinteAzul e OuvinteVermelho:

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JPanel;

public class PainelBotoes extends JPanel {

    private static final long serialVersionUID = 1L;
// variaveis de instancia:
    private JButton botaoAmarelo;
    private JButton botaoAzul;
    private JButton botaoVermelho;
// Construtor
    public PainelBotoes() {
        botaoAmarelo = new JButton("Amarelo");
        this.add(botaoAmarelo); //this é opcional. Referencia o painel.
        botaoAmarelo.addActionListener(new OuvinteAmarelo());
        botaoAzul = new JButton("Azul");
        add(botaoAzul);
        botaoAzul.addActionListener(new OuvinteAzul()); // ouvinte interno
       // botaoAzul.addActionListener(new ImprimeConsole()); //ouvinte externo
        botaoVermelho = new JButton("Vermelho");
        add(botaoVermelho);
        botaoVermelho.addActionListener(new OuvinteVermelho());
    }

// Classes ouvintes internas
    class OuvinteAmarelo implements ActionListener {

        public void actionPerformed(ActionEvent evt) {
            Color color = Color.yellow;
            setBackground(color);
            repaint();
        }
    }

    class OuvinteAzul implements ActionListener {

        public void actionPerformed(ActionEvent evt) {
            Color color = Color.blue;
            setBackground(color);
            repaint();
        }
    }

    class OuvinteVermelho implements ActionListener {

        public void actionPerformed(ActionEvent evt) {
            Color color = Color.red;
            setBackground(color);
            repaint();
        }
    }
}

Classe PainelColoridoComBotoes.java

import javax.swing.JFrame;
public class PainelColoridoComBotoes {

    public static void main(String[] args) {
        PainelColoridoComBotoes gui = new PainelColoridoComBotoes();
        gui.go();
    }

    public void go() {
        JFrame frame = new JFrame();
        frame.setTitle("Teste de Botoes"); //metodo de JFrame
        frame.setSize(450, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new PainelBotoes());
        frame.setVisible(true);
    }
}

Execução da classe PainelColoridoComBotoes.java:



3. Componentes de Interface Gráfica - II

3.1. JButton (botão)

Um botão, ou JButton, é um componente gráfico que permite que o usuário solicite alguma ação.
Um elemento JButton é inicializado de maneira similar a qualquer outro componente Java, através da palavra new.
Após a criação das instâncias dos botões (new), é recomendável, adicionar métodos listeners.
A instância de JButton pode ser adicionada no painel através da instrução add(Component) do componente JPanel.

Classe: MeuFormulario.java

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

class Eventos extends WindowAdapter {

    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
}

public class MeuFormulario extends JFrame {

    private JPanel conteudo = new JPanel();
    private JButton botao1 = new JButton("amarelo");
    private JButton botao2 = new JButton("verde");
    private JButton botaoSair = new JButton("Exit");

    private void centraliza() {
        int x =
                ((Toolkit.getDefaultToolkit()).getScreenSize()).width;
        int y =
                ((Toolkit.getDefaultToolkit()).getScreenSize()).height;
        setLocation((x - getSize().width) / 2, (y - getSize().height) / 2);
    }

    public MeuFormulario(String titulo) {
        addWindowListener(new Eventos());
        conteudo.setBackground(new Color(159, 154, 151));
        setTitle(titulo);

        setSize(320, 240);
        centraliza();
        botao1.addActionListener(
                new AbstractAction() {

                    public void actionPerformed(ActionEvent evt) {
                        conteudo.setBackground(Color.YELLOW);
                    }
                });
        botao2.addActionListener(
                new AbstractAction() {

                    public void actionPerformed(ActionEvent evt) {
                        conteudo.setBackground(Color.GREEN);
                    }
                });
        botaoSair.addActionListener(
                new AbstractAction() {

                    public void actionPerformed(ActionEvent evt) {
                        System.exit(0);
                    }
                });
        conteudo.add(botao1);
        conteudo.add(botao2);
        conteudo.add(botaoSair);
        Container fundo = getContentPane();
        fundo.add(conteudo);
    }
}

Classe: TesteMeuFormulario.java

import javax.swing.*;

public class TesteMeuFormulario {

    public static void main(String[] a) {
        (new MeuFormulario("Entrada de Dados")).show();
    }
}

Execução da classe TesteMeuFormulario:

Observe que não foi definido no código do programa o posicionamento dos botões. Esse posicionamento aleatório pode ser melhor observado se for inserido uma quantidade elevada de componentes. Por exemplo, o código abaixo depois do método conteudo.add(botaoSair) do arquivo MeuFormulario.java:


        for (int i = 4; i < 34; i++) {
            conteudo.add(
                    new JButton(
                    "Botao #" + i));
        }

Execução da classe TesteMeuFormulario:


3.2. Gerente de Layout.

Tipos de gerenciadores de layout, a saber:
a) FlowLayout
b) BorderLayout
c) GridLayout
d) BoxLayout
e) GridBagLayout

Usa-se setLayout(null) para que se possa colocar um componente em qualquer lugar do "conteiner" (frames, etc). Tem-se maior liberdade em posicionar os componentes. Ou seja, não usa nenhum gereciador de layout.

Existem diversos problemas em usar o layout null:
1. Não tem tratamento para redimensionar a janela (e se precisar, vai exigir muito código);
2. Não funciona em múltiplas plataformas (o layout pode quebrar mesmo entre variações de uma mesma plataforma);
3. Não suporta múltiplos look&feel;

a) FlowLayout
FlowLayout é um gerente de Layout que procura alinhar os componentes em um contexto de fluxo de elementos. Representa um fluxo, sendo os componentes adicionados apresentados em uma linha, da esquerda para a direita
Exemplo de FlowLayout:
O seguinte código ao ser inserido antes do método  conteudo.add(botao1), permitirá definir o posicionamento dos componentes.

conteudo.setLayout(new FlowLayout(0,10,1));

Uma instância de FlowLayout é chamada através da palavra new. O construtor dessa classe pode receber três parâmetros inteiros a saber:

new FlowLayout(int p1, int p2, int p3)

- p1: define o alinhamento de acordo com os seguintes valores:

inteiros: { 0: alinhamento a esquerda, 1: alinhamento no centro e 2: alinhamento a direita}.
- p2: define o espaçamento horizontal em pixels.
- p3: define o espaçamento vertical em pixels.

A Figura  a seguir exemplifica a modificação no posicionamento dos componentes com o método conteudo.setLayout(new FlowLayout(0,10,1)) inserido antes do método  conteudo.add(botao1).

Execução da classe TesteMeuFormulario:

 

b) BordeLayout:
Outro LayOut que poderia ser utilizado é o BorderLayout(). Ideal para receber JPanel criados anteriormente, posicionando-os no frame principal. O BorderLayout posiciona os componentes nas “bordas” do container, deixando a maior parte de sua área disponível para o componente inserido no centro.No código manipulado até o presente momento, realize as seguintes modificações:

Não use o trecho de código abaixo:

for (int i = 4; i < 34; i++)
{
      conteudo.add(
            new JButton(
            "Botao #"+i));
}

Exclua o método conteudo.setLayout(new FlowLayout(0,10,1)) inserido antes do método  conteudo.add(botao1), e insira o método:

conteudo.setLayout(new BorderLayout());

Esse Layout define quatro regiões, conforme ilustra a Figura abaixo. Nessas regiões, qualquer componente pode ser inserido:

Modifique o método da classe MeuFormulario.java para:

conteudo.setLayout(new BorderLayout());
conteudo.add(botao1,"East");
conteudo.add(botao2,"North");
conteudo.add(botaoSair,"South");
Container fundo = getContentPane();
fundo.add(conteudo);

Execução da classe TesteMeuFormulario:


c) GridLayout:

GridLayout é uma implementação de LayoutManager que permite distribuir componentes ao longo de linhas e colunas. A distribuição dá-se na ordem de adição do componente ao container, da esquerda para a direita e de cima para baixo. Cada célula definida no grid pode armazenar qualquer componente gráfico.

Essa classe oferece um construtor que permite especificar o número de linhas e colunas desejado para o grid,  para o construtor padrão, um grid de uma única coluna é usado. Adicionalmente, há outro construtor que permite especificar, além da quantidade de linhas e colunas, o espaço em pixels entre esses componentes nas direções horizontal e vertical.

Exemplo de definição de um GridLayout:

A instrução new GridLayout(int Linhas , int Colunas, pixels horizontal, pixels vertical )

Permite especificar como será dividia a área.

No código, da classe MeuFormulario.java realize as seguintes modificações:

conteudo.setLayout(new GridLayout(2,2));
conteudo.add(botao1);
conteudo.add(botao2);
conteudo.add(botaoSair);
Container fundo = getContentPane();
fundo.add(conteudo);

Execução da classe TesteMeuFormulario:

O GridLayout permite ainda a definição de um espaçamento entre os componentes. Esse aspecto pode ser definido no seu construtor. Por
exemplo, realize as seguintes modificações:

conteudo.setLayout(new GridLayout(2,2,5,10));

Nesse caso, o construtor o espaçamento horizontal é 5 pixels e o vertical 10 pixels.

Execução da classe TesteMeuFormulario:


d) BoxLayout:

Componente que possui um bom grau de flexibilidade na organização dos componentes, podendo os mesmos serem alinhados de acordo com o eixo x, ou seja horizontalmente, ou de acordo com o eixo y, ou seja, verticalmente;
Além disso podem ser definidas propriedades como espaçamento entre os componentes e alinhamentos entre os mesmos;
Ideal para ser utilizado em combinação com vários painéis, cada um com seu layout do tipo BoxLayout, a serem adicionados a um Jframe.

Classe BoxLayoutDemo:

import java.awt.Component;
import java.awt.Container;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;

public class BoxLayoutDemo {

    public static void addComponentsToPane(Container pane) {
        pane.setLayout(new BoxLayout(pane,
                BoxLayout.Y_AXIS));
        addAButton("Button 1", pane);
        addAButton("Button 2", pane);
        addAButton("Button 3", pane);
        addAButton("Long-Named Button 4", pane);
        addAButton("5", pane);
    }

    private static void addAButton(String text,
            Container container) {
        JButton button = new JButton(text);
        button.setAlignmentX(Component.RIGHT_ALIGNMENT);
        container.add(button);
    }

    /**
     * Create the GUI and show it. For thread safety, this method should be
     * invoked from the event-dispatching thread.
     */
    private static void createAndShowGUI() {
//Create and set up the window.
        JFrame frame = new JFrame("BoxLayoutDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Set up the content pane.
        addComponentsToPane(frame.getContentPane());
//Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
//Schedule a job for the event-dispatching
        thread:
//creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

run:



e) GridBagLayout


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

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

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

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

gridx e gridy
Especificam a posição X,Y para adicionar o componente. Não é necessário alterar seus valores, pois seu valor padrão é a constante RELATIVE e portanto o layout adicionará após o último componente que foi colocado.
- gridx: Permite especificar qual a posição absoluta horizontalmente que o componente será adicionado;
- gridy: Permite especificar qual a posição absoluta verticalmente que o componente será adicionado.

gridheight e gridwidth
Especificam o tamanho do componente baseado em células. É com essa propriedade que você indicará que um componente seu ocupará duas células ou ocupurá tantas quanto forem necessárias para ir até o final da tela. Lembrem-se é células e não pixels.
Nestes valores podem ser utilizadas duas constantes: REMAINDER e RELATIVE. REMAINER fará com que o componente se estique até a última célula. Já o RELATIVE fará com que o componente ocupe todas as casas com excessão da última.
- gridheight: Especifica o número de células que o componente ocupará verticalmente. Valor padrão é 1;
- gridwidth: Especifica o número de células que o componente ocupará horizontalmente. Valor padrão é 1.

insets
Indica as distâncias entre os componentes do layout. Um Insets possui valores para as 4 direções, cima, baixo, direita e esquerda. Permitindo com isso muita flexibilidade no gerenciador. Valor padrão é new Insets(0, 0, 0, 0).

weight
Essas propriedades especificam um percentual de crescimento da célula, não do componente, quando a mesma precisa ser redimensionada. É dito isso, porque se o componente não pode se redimensionar, pois a propriedade fill do constraint afirma isso, o componente não vai sofrer as alterações, mas a célula irá aumentar.
Com este layout é possível informar que uma célula redimensionará 75% e o outra 25%, portanto, o primeiro componente receberá 3 vezes mais tamanho do que o segundo.

O valor padrão é 0 e os valores percentuais são dados em casas decimais, por exemplo: 0.03 é igual a 3%, 1.00 é igual a 100% e por aí vai.
- weightx: Peso em x. Especifica um peso no redimensionamento. Este peso será utilizado para um cálculo que o layout faz para determinar quais as células irão redimensionar horizontalmente, quais não irão e quais aumentarão mais que as outras.
- weighty: Peso em y. Especifica um peso no redimensionamento. Este peso será utilizado para um cálculo que o layout faz para determinar quais as células irão redimensionar verticalmente, quais não irão e quais aumentarão mais que as outras.

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

Podemos afirmar com segurança que qualquer disposição de componentes pode ser configurada em um GridBagLayout. Por outro lado, a quantidade de constraints(propriedades e restrições de layout) possível para cada componente também deu a este gerenciador a fama de ser difícil de programar.


Classe DemoGridBagLayout:


import java.awt.*;
import javax.swing.JButton;
import javax.swing.JFrame;

public class DemoGridBagLayout {

    final static boolean shouldFill = true;
    final static boolean shouldWeightX = true;
    final static boolean RIGHT_TO_LEFT = false;

    public static void addComponentsToPane(Container pane) {
        if (RIGHT_TO_LEFT) {
            pane.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
        }

        JButton button;
        pane.setLayout(new GridBagLayout());
        GridBagConstraints c = new GridBagConstraints();
        if (shouldFill) {
//altura natural, largura maxima.
            c.fill = GridBagConstraints.HORIZONTAL;
        }

        button = new JButton("Botao 1");
        if (shouldWeightX) {
            c.weightx = 0.5;
        }
        c.gridx = 0;
        c.gridy = 0;
        pane.add(button, c);

        button = new JButton("Botao 2");
        c.gridx = 1;
        c.gridy = 0;
        pane.add(button, c);

        button = new JButton("Botao 3");
        c.gridx = 2;
        c.gridy = 0;
        pane.add(button, c);

        button = new JButton("Botao 4 - Nome-Longo");
        c.ipady = 40; //faz o componente no alto.
        c.weightx = 0.0;
        c.gridwidth = 3;
        c.gridx = 0;
        c.gridy = 1;

        pane.add(button, c);

        button = new JButton("5");
        c.ipady = 0; //esvazia por padrao
        c.weighty = 1.0; //requisita um espaco vertical extra.
        c.anchor = GridBagConstraints.PAGE_END; //espaco em baixo.
        c.insets = new Insets(10, 0, 0, 0); //top padding
        c.gridx = 1; //alinhamento do botao 2.
        c.gridwidth = 2; //2 colunas largas.
        c.gridy = 2; //terceira linha.
        pane.add(button, c);
    }

    /**
     * Cria um GUI e o exibe. Para thread safety, este metodo podera invocar
     * para uma thread de disparo de evento(event-dispatching thread).
     */
    private static void createAndShowGUI() {
//Faz com que tenha uma decoracao de janela.
        JFrame.setDefaultLookAndFeelDecorated(true);

//Cria e organiza a janela.
        JFrame frame = new JFrame("DemoGridBagLayout");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Organiza o conteudo no painel.
        addComponentsToPane(frame.getContentPane());

//Exibe janela.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
//Agenda um trabalho para o event-dispatching thread:
//cria e exibe uma aplicacao GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

run:


3.3. JFrame

Esta classe pertence ao pacote swing, a qual gera uma janela com barra de título e bordas. É nesta classe que são incluídos os botões, textos, etc, que constituirão o programa propriamente dito.

Centralizando na tela um JFrame

Repare que a classe principal é a ExemploComponentes.java, pois em um arquivo.java só pode have uma classe publica, dentro desse mesmo arquivo contém as classes Acoes, eventos e Janela.


Classe ExemploComponentes.java:

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

class Acoes implements ActionListener {

    public void actionPerformed(ActionEvent evt) {
        if (evt.getSource() instanceof JMenuItem) {
            JMenuItem quem = (JMenuItem) evt.getSource();
            if (quem.getActionCommand() == "Exit") {
                System.exit(0);
            }
        }
    }
}


class Eventos extends WindowAdapter {

    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
}

class Janela extends JFrame {

    private void centraliza() {
        int x1 = getToolkit().getScreenSize().width;
        int y1 = getToolkit().getScreenSize().height;
        int x2 = (x1 - getSize().width) / 2;
        int y2 = (y1 - getSize().height) / 2;

        setLocation(x2, y2);
    }

    private JMenuBar criarMenus() {
        JMenuBar menu = new JMenuBar();
        JMenu mFile = new JMenu("File");
        mFile.setMnemonic('F');
        JMenuItem mExit = new JMenuItem("Exit", 'E');
        mExit.addActionListener(new Acoes());

        mFile.add(mExit);
        menu.add(mFile);
        return menu;
    }

    public Janela() {
        this("exemplo");
    }

    public Janela(String titulo) {
        setJMenuBar(criarMenus());
        addWindowListener(new Eventos());
        setTitle(titulo);
        setSize(500, 300);
        centraliza();
    }
}

public class ExemploComponentes {

    public static void main(String[] a) {
        (new Janela()).show();
    }
}

run:


 

Observações: x1 e y1 são a largula e a altura da tela, enquanto que getSize().width e getSize().height  são a largura e a altura do JFrame, e x2 e y2 são as distâncias horizontais e verticais dos eixos ox e oy.

Exemplo de uso de JFrame,  classe Janela1.java:

import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Janela1 extends JFrame {

    private JLabel label1;

    public Janela1() {
        setTitle("*****");
        setSize(400, 50);
        setLocation(150, 150);
        setResizable(false);
        getContentPane().setBackground(Color.LIGHT_GRAY);
        label1 = new JLabel();
        label1.setText("Testando");
        label1.setHorizontalAlignment(JLabel.CENTER);
        add(label1);
    }
}


Execução da classe JanelaMain:

import javax.swing.JFrame;

public class JanelaMain {

    public static void main(String[] args) {
        JFrame janela = new Janela1();
        janela.setVisible(true);
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}


Exemplo de JFrame com icone:

Classe: LabelFrame.java


import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class LabelFrame extends JFrame {

    private JLabel label1, label2, label3, label4;

    public LabelFrame() {
        label1 = new JLabel("Label1 com texto somente, ", JLabel.LEFT);
        label1.setToolTipText("Label1...");
        Icon fig = new ImageIcon("img/icone.gif");
        label2 = new JLabel(fig);
        label2.setToolTipText("Label 2 com figura");
        label3 = new JLabel(", Label 3, ", JLabel.RIGHT);
        label4 = new JLabel(", Label 4 texto e Imagem", fig, JLabel.CENTER);
//
        label4 = new JLabel();
//
        label4.setText("Texto e Imagem");
//
        label4.setIcon(fig);
        label4.setFont(new Font("Serif", Font.BOLD, 20));
        label4.setForeground(Color.red);
        setLayout(new FlowLayout());
        add(label1);
        add(label2);
        add(label3);
        add(label4);
        Toolkit tk = Toolkit.getDefaultToolkit();
        Image fig2 = tk.getImage("img/icone.gif");
        setIconImage(fig2);
    }
}


Classe LabelFrameApl

import javax.swing.JFrame;
import javax.swing.JRootPane;

public class LabelFrameApl {

    public static void main(String[] args) {
        JFrame janela = new LabelFrame();
        janela.setTitle("Inserindo Texto e figuras");
        janela.setSize(350, 200);
        janela.setLocation(150, 150);
        janela.setUndecorated(true);
        janela.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
        janela.setVisible(true);
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

Execução da classe: LabelFrameApl.java:

Obs: foi criado a pasta img detro do respectivo projeto, diretamente pelo Internet Explore, onde está o arquivo icone.gif


3.4. A classe JLabel

Label significa rótulo, etiqueta, ou seja, são textos informativos que geralmente ficam próximo a caixas de textos ou outros componentes para indicar o tipo de dados a ser entrado, exemplo de sintaxe para declaração e criação:

JLabel lbEndereco = new JLabel("Endereço Completo:", JLabel.RIGHT);

Métodos da classe JLabel

Método
Função
JLabel()
Cria um Label vazio (sem texto)
JLabel(Sting)
Cria um Label com o texto dado
JLabel(String, int)
Cria um Label com o texto e o alinhamento dados
JLable(String, Image)
Cria um Label com o texto e a imagem dados
JLabel(String, Image, int)
Cria um Label com o texto, a imagem e o alinhamento dados
getText()
Obtém o texto do Label
setText()
Especifica o texto do Label


Classe ExemploJlabel


public class ExemploJlabel {

    public JFrame f;
    public JLabel texto;
    public JLabel texto2;
    public JPanel p;

    public ExemploJlabel() {
        f = new JFrame("Exemplo4 JLabel ");
        texto = new JLabel("Este texto é um JLabel");
        texto2 = new JLabel("ESTE TEXTO TAMBÉM É UM JLABEL");
        p = new JPanel();
    }

    public void CriaFrame() {
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300, 100);
        p.add(texto);
        p.add(texto2);
        f.add(p);
        f.setVisible(true);
    }

    public static void main(String args[]) {
        ExemploJlabel janela = new ExemploJlabel();
        janela.CriaFrame();
    }
}

run:


Classe: ExemploJLabel2


import javax.swing.*;
import java.awt.*;

public class ExemploJLabel2 {

    public JFrame f;
    public JLabel label;
    public JLabel label2;
    public JPanel p;

    public ExemploJLabel2() {
        f = new JFrame("Exemplo JLabel ");
        label = new JLabel("<html><FONT COLOR=RED><B>JLabel colorido com HTML</B></FONT></html>");
        label.setBorder(BorderFactory.createTitledBorder("JLabel com borda"));
        label2 = new JLabel("JLabel comum ");
        p = new JPanel();
    }

    public void CriaFrame() {
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setSize(300, 150);
        p.setLayout(new BorderLayout());
        p.add(label, BorderLayout.NORTH);
        p.add(label2, BorderLayout.CENTER);
        f.add(p);
        f.setVisible(true);
    }

    public static void main(String args[]) {
        ExemploJLabel2 janela = new ExemploJLabel2();
        janela.CriaFrame();
    }
}

run:

3.5. A Classe JTextField

Campo de texto ou caixa de texto, utilizado geralmente para entrada de dados tipo texto pelo usuári

JTextField  tfEndereco = new JTextField();

Métodos da classe JTextField

Método
Função
JTextField() Cria uma caixa de texto vazia
JTextField(String) Cria uma caixa de texto com a string dada
JTextField(String,int) Cria uma caixa de texto com a string e a quantidade de colunas especificada
JTextField(int) Cria uma caixa de texto com a quantidade de colunas especificada
getText()
Obtém o texto do objeto
getSelectedText()
Obtém o texto selecionado do objeto
isEditable()
Verifica se o componente é editável ou não
selectAll()
Seleciona todo o texto
setEditable(boolean)
Especifica se o componente é editável ou não
setText()
Especifica o texto contido no componente

3.6. A Classe JPasswordField

Esta classe é semelhante a JTextField, apenas que o texto digitado não aparece, em seu luvar aparecerá caracteres previamente definidos pelo método setEchoChar, que por default é um asterisco (*). É utilizada para entrada de senha para o progra abrir.

JPasswordField  pfSenha = new JPasswordField ();

Métodos da classe JPasswordField

Método
Função
JPasswordField ()
Cria uma caixa de texto vazia
JPasswordField (String)
Cria uma caixa de texto com a string dada
JPasswordField (int)
Cria uma caixa de texto com a quantidade de colunas especificadas
getPassword()
Obtém o texto do objeto, porém retornando um array do tipo char. Cada caractere é armazenado num elemento do array
getEchoChar()
Obtém o caractere usado na substituição dos caracteres digitados
setEchoChar()
Define o caractere a ser usado em substituição aos caracteres digitados

3.7. A Classe JButton

Geralmente é utilizado para efetuar uma ação.

JButton btEnviar = new JButton("ENVIAR");

Métodos da classe JButton

Método
Função
Button()
Cria um botão sem texto
Button(Sting)
Cria um botão com o texto dado
Button(String, Image)
Cria um botão com o texto e a imagem dados
getText()
Obtém o texto do botão
setText(String)
Escpecifica o texto do botão
setEnabled(boolean)
Define se o botão está habilidado(true) ou desabilitado(false)
setHorizontalTextPosition()
Defeine o tipo de alinhamento horizontal do texto em relação a uma imagem. Pode assumir LEFT (esquerda) ou RIGHT (direita)
setMnemonic(char)
Define uma
setToolTipText(String)

setVerticalTextPosition()


3.8. Component: setBounds(int x,int y,int width,int height)

Posiciona os componentes dentro do conteiner, janelas, etc.

Exemplo:

Classe Senha.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Senha extends JFrame {
    private JTextField tfLogin;
    private JLabel lbSenha;
    private JLabel lbLogin;
    private JButton btLogar;
    private JButton btCancelar;
    private JPasswordField pfSenha;
    private static Senha frame;

    public Senha() {
        inicializarComponentes();
        definirEventos();
    }

    private void inicializarComponentes() {
        setTitle("Login no Sistema");
        setBounds(0,0,250,200);
        setLayout(null);
        tfLogin = new JTextField(5);
        pfSenha = new JPasswordField(5);
        lbSenha = new JLabel("Senha:");
        lbLogin = new JLabel("Login:");
        btLogar = new JButton("Logar");
        btCancelar = new JButton("Cancelar");
        tfLogin.setBounds(100, 30, 120, 25);
        lbLogin.setBounds(30, 30, 80, 25);
        lbSenha.setBounds(30, 75, 80, 25);
        pfSenha.setBounds(100, 75, 120, 25);
        btLogar.setBounds(20, 120, 100, 25);
        btCancelar.setBounds(125, 120, 100, 25);
        add(tfLogin);
        add(lbSenha);
        add(lbLogin);
        add(btLogar);
        add(btCancelar);
        add(pfSenha);
        //obs:setBounds(int x,int y,int width,int height)
    }

    private void definirEventos() {
        btLogar.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String senha = String.valueOf(pfSenha.getPassword()); // Conversão do arry de caractere em string
                if(tfLogin.getText().equals("password") && senha.equals("password")){
                    frame.setVisible(false);  
                    //Classe.metodo();
                }
                else{
                   JOptionPane.showMessageDialog(null,"Login ou Senha incorretas!");
                }
            }
        });

        btCancelar.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                frame = new Senha();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                Dimension tela = Toolkit.getDefaultToolkit().getScreenSize();
                frame.setLocation((tela.width - frame.getSize().width) / 2,
                        (tela.height - frame.getSize().height) / 2);
                frame.setVisible(true);
            }
        });
    }
}

Execução da classe:


A figura abaixo mostra as coordenadas da tela dos componentes do exemplo acima:

width e height: em pixels por polegada
x e y: em pixels


Resumo da classe gráfica:

1. public class Classe extends JFrame {

2. Declaração dos Componentes:

...

3. Implementação do Construtor da Classe com as assinaturas dos dois métodos:

public Classe() {

metodoGrafico()

metodoEvento()

}

4. implementar (desenvolver) os métodos:

private void metodoGrafico() {

Cria e adiciona os objetos

}

private void metodoEventos() {

ação a ser executada

}

5. Método principal: execução do JFrame

public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                frame = new Classe();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                Dimension tela = Toolkit.getDefaultToolkit().getScreenSize();
                frame.setLocation((tela.width - frame.getSize().width) / 2,
                        (tela.height - frame.getSize().height) / 2);
                frame.setVisible(true);
            }
        });
    }
}

3.9. JRadioButton


Similar ao JButton, porém esse é usado para marcar 1 ou mais opções dentre as disponíveis.
Exemplo JTextField e JRadioButton :


import java.awt.*;
import javax.swing.*;

public class Textfield extends JFrame {

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

    public Textfield() {
        super("Exemplo JTextField");
        JFrame frame = new JFrame(); // instancia JFrame
        Container content = getContentPane(); // Cria o container
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// finaliza programa ao fechar
        setSize(500, 120); // determina o tamanho da janela
        content.setLayout(new BorderLayout());// define o layout do container
        JPanel painel1 = new JPanel(); // cria o painel que conterá o label nome e o campo texto
        FlowLayout layout = new FlowLayout();//instancia o flowlayout para alinhar componentes
        layout.setAlignment(FlowLayout.LEFT);// define alinhamento à esquerda
        painel1.setLayout(layout); // define o layout do painel1 flowlayout à esquerda.
        JPanel painel2 = new JPanel();//cria o painel que conterá o label endereço e o texto
        painel2.setLayout(layout); //define o layout do painel3 flowlayout à esquerda
        JPanel painel3 = new JPanel(); //painel3 contem o label sexo e os botoes do tipo radio
        painel3.setLayout(layout);
        JLabel nome = new JLabel("Nome");//cria um label
        painel1.add(nome); //adiciona o label ao painel 1
        JTextField nomef = new JTextField(10);
        painel1.add(nomef);
        JLabel endereco = new JLabel("Endereço");
        painel2.add(endereco);
        JTextField endf = new JTextField(30);
        painel2.add(endf);
        JLabel sexo = new JLabel("Sexo:");
        painel3.add(sexo);
        JRadioButton masculino = new JRadioButton("Masculino");
        painel3.add(masculino);
        JRadioButton fem = new JRadioButton("Feminino");
        painel3.add(fem);

        content.add(painel1, BorderLayout.NORTH); // define o painel1 como parte norte do container
        content.add(painel2, BorderLayout.CENTER);// define o painel2 como parte centro do container
        content.add(painel3, BorderLayout.SOUTH); // define o painel3 como parte sul do container
        setVisible(true);
    }
}

run e entrada dos dados:



3.10. Menu com abas


ButtonTabComponent.java

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.*;   
import javax.swing.plaf.basic.BasicButtonUI;
 
/**  
* Component to be used as tabComponent;  
* Contains a JLabel to show the text and  
* a JButton to close the tab it belongs to  
*/   
public class ButtonTabComponent extends JPanel {   
    private final JTabbedPane pane;   
 
    public ButtonTabComponent(String title, final JTabbedPane pane) {   
        //unset default FlowLayout' gaps   
        super(new FlowLayout(FlowLayout.LEFT, 0, 0));   
        if (pane == null) {   
            throw new NullPointerException("TabbedPane is null");   
        }   
        this.pane = pane;   
        setOpaque(false);   
           
        //make JLabel read titles from JTabbedPane   
        JLabel label = new JLabel(title) {   
            public String getText() {   
                int i = pane.indexOfTabComponent(ButtonTabComponent.this);   
                if (i != -1) {   
                    return pane.getTitleAt(i);   
                }   
                return null;   
            }   
        };   
           
        add(label);   
        //add more space between the label and the button   
        label.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 5));   
        //tab button   
        JButton button = new TabButton();   
        add(button);   
        //add more space to the top of the component   
        setBorder(BorderFactory.createEmptyBorder(2, 0, 0, 0));   
    }   
 
    private class TabButton extends JButton implements ActionListener {   
        public TabButton() {   
            int size = 17;   
            setPreferredSize(new Dimension(size, size));   
            setToolTipText("close this tab");   
            //Make the button looks the same for all Laf's   
            setUI(new BasicButtonUI());   
            //Make it transparent   
            setContentAreaFilled(false);   
            //No need to be focusable   
            setFocusable(false);   
            setBorder(BorderFactory.createEtchedBorder());   
            setBorderPainted(false);   
            //Making nice rollover effect   
            //we use the same listener for all buttons   
            addMouseListener(buttonMouseListener);   
            setRolloverEnabled(true);   
            //Close the proper tab by clicking the button   
            addActionListener(this);               
        }   
 
        public void actionPerformed(ActionEvent e) {   
            int i = pane.indexOfTabComponent(ButtonTabComponent.this);   
            if (i != -1) {   
                pane.remove(i);   
            }   
        }   
 
        //we don't want to update UI for this button   
        public void updateUI() {   
        }   
 
        //paint the cross   
        protected void paintComponent(Graphics g) {   
            super.paintComponent(g);   
            Graphics2D g2 = (Graphics2D) g.create();   
            //shift the image for pressed buttons   
            if (getModel().isPressed()) {   
                g2.translate(1, 1);   
            }   
            g2.setStroke(new BasicStroke(2));   
            g2.setColor(Color.BLACK);   
            if (getModel().isRollover()) {   
                g2.setColor(Color.MAGENTA);   
            }               
            int delta = 6;   
            g2.drawLine(delta, delta, getWidth() - delta - 1, getHeight() - delta - 1);   
            g2.drawLine(getWidth() - delta - 1, delta, delta, getHeight() - delta - 1);   
            g2.dispose();   
        }   
    }   
 
    private final static MouseListener buttonMouseListener = new MouseAdapter() {   
        public void mouseEntered(MouseEvent e) {   
            Component component = e.getComponent();   
            if (component instanceof AbstractButton) {   
                AbstractButton button = (AbstractButton) component;   
                button.setBorderPainted(true);   
            }   
        }   
 
        public void mouseExited(MouseEvent e) {   
            Component component = e.getComponent();   
            if (component instanceof AbstractButton) {   
                AbstractButton button = (AbstractButton) component;   
                button.setBorderPainted(false);   
            }   
        }   
    };   
}


TabComponentsDemo.java

/*  
* TabComponentDemo.java requires one additional file:  
*   ButtonTabComponent.java  
*/   
 
 
 
import javax.swing.*;   
import java.awt.*;   
import java.awt.event.ActionListener;   
import java.awt.event.ActionEvent;   
import java.awt.event.InputEvent;   
import java.awt.event.KeyEvent;   
 
/*  
* Creating and using TabComponentsDemo example    
*/   
public class TabComponentsDemo extends JFrame {       
 
    private final int tabNumber = 5;   
    private final JTabbedPane pane = new JTabbedPane();   
    private JMenuItem tabComponentsItem;   
    private JMenuItem scrollLayoutItem;   
       
    public static void main(String[] args) {   
        //Turn off metal's use of bold fonts   
    UIManager.put("swing.boldMetal", Boolean.FALSE);   
    //Schedule a job for the event dispatch thread:   
        //creating and showing this application's GUI.   
        SwingUtilities.invokeLater(new Runnable(){   
            public void run(){   
                new TabComponentsDemo("TabComponentsDemo").runTest();   
            }   
        });   
    }   
       
    public TabComponentsDemo(String title) {   
        super(title);   
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);   
        initMenu();           
        add(pane);           
    }   
       
    public void runTest() {   
        pane.removeAll();   
        for (int i = 0; i < tabNumber; i++) {   
            String title = "Tab " + i;   
            pane.add(title, new JLabel(title));   
            initTabComponent(i);   
        }   
        tabComponentsItem.setSelected(true);   
        pane.setTabLayoutPolicy(JTabbedPane.WRAP_TAB_LAYOUT);   
        scrollLayoutItem.setSelected(false);   
        setSize(new Dimension(400, 200));   
        setLocationRelativeTo(null);   
        setVisible(true);   
    }   
       
       
    private void initTabComponent(int i) {   
        pane.setTabComponentAt(i,   
                 new ButtonTabComponent("TabComponent " + i, pane));   
    }       
 
    //Setting menu   
       
    private void initMenu() {   
        JMenuBar menuBar = new JMenuBar();   
        //create Options menu   
        tabComponentsItem = new JCheckBoxMenuItem("Use TabComponents", true);   
        tabComponentsItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T, InputEvent.ALT_MASK));   
        tabComponentsItem.addActionListener(new ActionListener() {   
            public void actionPerformed(ActionEvent e) {   
                for (int i = 0; i < pane.getTabCount(); i++) {   
                    if (tabComponentsItem.isSelected()) {   
                        initTabComponent(i);   
                    } else {   
                        pane.setTabComponentAt(i, null);   
                    }   
                }   
            }   
        });   
        scrollLayoutItem = new JCheckBoxMenuItem("Set ScrollLayout");   
        scrollLayoutItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.ALT_MASK));   
        scrollLayoutItem.addActionListener(new ActionListener() {   
            public void actionPerformed(ActionEvent e) {   
                if (pane.getTabLayoutPolicy() == JTabbedPane.WRAP_TAB_LAYOUT) {   
                    pane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);   
                } else {   
                    pane.setTabLayoutPolicy(JTabbedPane.WRAP_TAB_LAYOUT);   
                }   
            }   
        });   
        JMenuItem resetItem = new JMenuItem("Reset JTabbedPane");   
        resetItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.ALT_MASK));   
        resetItem.addActionListener(new ActionListener() {   
            public void actionPerformed(ActionEvent e) {   
                runTest();   
            }   
        });   
         
        JMenu optionsMenu = new JMenu("Options");   
        optionsMenu.add(tabComponentsItem);   
        optionsMenu.add(scrollLayoutItem);   
        optionsMenu.add(resetItem);   
        menuBar.add(optionsMenu);   
        setJMenuBar(menuBar);   
    }   
}  

run:

Dê um clique no menu Opções:


3.11. JTree

Um editor simples:


import java.io.*; //importa pra poder usar File, FileReader e FileWriter
import javax.swing.JFileChooser; //Importa componente pra janela de escolha de arquio
import javax.swing.JFrame; //Janela Principal
import javax.swing.JOptionPane; //Painel

/**
 * Classe Principal do Editor de Texto Simples
 */
public class Editor extends JFrame {

    private javax.swing.JPanel jContentPane = null;
    private javax.swing.JPanel jPanel = null;
    private javax.swing.JButton jButton = null;
    private javax.swing.JButton jButton1 = null;
    private javax.swing.JButton jButton2 = null;
    private javax.swing.JScrollPane jScrollPane = null;
    private javax.swing.JTextArea jTextArea = null;
    private javax.swing.JFileChooser jFileChooser = null; //  @jve:visual-info  decl-index=0 visual-constraint="582,36"
    private boolean hasChanged = false; //Indica se o texto foi alterado
    private static final String title = "Editor de Texto Simples"; //Titulo da janela

    /**
     * Construtor Default
     */
    public Editor() {
        super(); //chama super de JFrame
        initialize(); //Inicializa o Objeto
    }

    /**
     * This method initializes jContentPane
     *
     * @return javax.swing.JPanel
     */
    private javax.swing.JPanel getJContentPane() {
        if (jContentPane == null) {
            jContentPane = new javax.swing.JPanel();
            jContentPane.setLayout(new java.awt.BorderLayout());
            jContentPane.add(getJPanel(), java.awt.BorderLayout.SOUTH);
            jContentPane.add(getJScrollPane(), java.awt.BorderLayout.CENTER);
            jContentPane.setBorder(javax.swing.BorderFactory.createEmptyBorder(5, 5, 5, 5));
        }
        return jContentPane;
    }

    /**
     * Inícializa a classe
     *
     * @return void
     */
    private void initialize() {
        this.setContentPane(getJContentPane());
        this.setSize(480, 284); //Tamanho da janela
        this.setTitle(title);
        this.setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE); //Isso é pra não fechar
        //pois preciso de um evento que trate o fechamento ao sair   
        this.addWindowListener(new java.awt.event.WindowAdapter() { //Listener pra tratar o fechamento
            public void windowClosing(java.awt.event.WindowEvent e) {
                doExit();
            }
        });

    }

    /**
     * This method initializes jPanel
     *
     * @return javax.swing.JPanel
     */
    private javax.swing.JPanel getJPanel() {
        if (jPanel == null) {
            jPanel = new javax.swing.JPanel();
            jPanel.add(getJButton(), null);
            jPanel.add(getJButton1(), null);
            jPanel.add(getJButton2(), null);
        }
        return jPanel;
    }

    /**
     * This method initializes jButton
     *
     * @return javax.swing.JButton
     */
    private javax.swing.JButton getJButton() {
        if (jButton == null) {
            jButton = new javax.swing.JButton();
            jButton.setText("Abrir arquivo");
            jButton.addActionListener(new java.awt.event.ActionListener() { //Listener pra carregar arquivo no clique do botão
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    loadFile();
                }
            });
        }
        return jButton;
    }

    /**
     * This method initializes jButton1
     *
     * @return javax.swing.JButton
     */
    private javax.swing.JButton getJButton1() {
        if (jButton1 == null) {
            jButton1 = new javax.swing.JButton();
            jButton1.setText("Salvar arquivo");
            jButton1.addActionListener(new java.awt.event.ActionListener() { //Listener pra salvar arquivo no clique do botão
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    saveFile();
                }
            });
        }
        return jButton1;
    }

    /**
     * This method initializes jButton2
     *
     * @return javax.swing.JButton
     */
    private javax.swing.JButton getJButton2() {
        if (jButton2 == null) {
            jButton2 = new javax.swing.JButton();
            jButton2.setText("Sair");
            jButton2.addActionListener(new java.awt.event.ActionListener() { //Listener pra fechar programa no clique do botão
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    doExit();
                }
            });
        }
        return jButton2;
    }

    /**
     * This method initializes jScrollPane
     *
     * @return javax.swing.JScrollPane
     */
    private javax.swing.JScrollPane getJScrollPane() {
        if (jScrollPane == null) {
            jScrollPane = new javax.swing.JScrollPane();
            jScrollPane.setViewportView(getJTextArea());
        }
        return jScrollPane;
    }

    /**
     * This method initializes jTextArea
     *
     * @return javax.swing.JTextArea
     */
    private javax.swing.JTextArea getJTextArea() {
        if (jTextArea == null) {
            jTextArea = new javax.swing.JTextArea();
            jTextArea.addKeyListener(new java.awt.event.KeyAdapter() {
                public void keyTyped(java.awt.event.KeyEvent e) { //Detecta modificação e seta tbm
                    if (!hasChanged) {
                        setTitle(title + " *");
                        hasChanged = true;
                    }
                }
            });
        }
        return jTextArea;
    }

    /**
     * This method initializes jFileChooser
     *
     * @return javax.swing.JFileChooser
     */
    private javax.swing.JFileChooser getJFileChooser() {
        if (jFileChooser == null) {
            jFileChooser = new javax.swing.JFileChooser();
            jFileChooser.setMultiSelectionEnabled(false);
        }
        return jFileChooser;
    }

    //função que carrega o texto
    private void loadFile() {
        int state = getJFileChooser().showOpenDialog(this); //chama janela pra selecionar arquivo
        if (state == JFileChooser.APPROVE_OPTION) { //verifica o status
            File f = getJFileChooser().getSelectedFile(); //pega o file selecionado na janela
            try { //Tenta ler o arquivo para o controle de texto
                FileReader fr = new FileReader(f); //cria o FileReader com o file previamente selecionado
                String temp = ""; //String temporaria
                //Vai lendo um caractere por vez e concatenando em temp.
                //A função read retorna um inteiro pois pode vir -1 significando o fim do arquivo
                //E um char não permite negativos
                //a função read pode gerar IOException
                int i = fr.read();
                while (i != -1) {
                    temp += ((char) i);
                    i = fr.read();
                }
                fr.close(); //fecha arquivo
                getJTextArea().setText(temp); //atribui temp ao controle
                setTitle(title); //seta o titulo pra remover o * se houver
                hasChanged = false; //Não alterado
            } catch (FileNotFoundException e) { //Não encontrou arquivo
                e.printStackTrace();
            } catch (IOException e) { //Algum erro na leitura
                e.printStackTrace();
            }
        }
    }

    //função que salva
    private void saveFile() {
        int state = getJFileChooser().showSaveDialog(this); //Abre dialogo pra selecionar
        if (state == JFileChooser.APPROVE_OPTION) { //se selecionou
            File f = getJFileChooser().getSelectedFile(); //pega file
            try {
                //tenta salvar     
                FileWriter fw = new FileWriter(f);
                //pega o texto do TextArea e envia pra stream no arquivo
                //A função write escreve uma string para o arquivo. Existem outras opções
                //a função write pode gerar IOException
                fw.write(getJTextArea().getText());
                fw.close();//fecha arquivo
                setTitle(title); //seta o titulo pra remover o * se houver
                hasChanged = false; //marca como não alterado
            } catch (FileNotFoundException e) { //Não encontrou o arquivo
                e.printStackTrace();
            } catch (IOException e) { //Algum outro erro de io, não conseguiu gravar pois não tem permissão por exemplo
                e.printStackTrace();
            }
        }
    }

    //Na saida verifica se quer salvar
    private void doExit() {
        if (hasChanged) {
            int state = JOptionPane.showConfirmDialog(this,
                    "O Arquivo foi moficado. Quer salva antes de sair?");
            if (state == JOptionPane.YES_OPTION) {
                saveFile();
            } else if (state == JOptionPane.CANCEL_OPTION) {
                return;
            }
        }
        System.exit(0); //Sae fora =)
    }

    //Função Princial, apenas cria classe e mostra, depois os Listener adicionados em Editor fazem o resto
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() { //Adiciona o código run abaixo a thread que maipula os eventos graficos
            public void run() {
                Editor e = new Editor(); //Cria objeto
                e.setVisible(true); //Mostra
            }
        });

    }
}

run:



4. Exemplos de JFrame

4.1. Com JFrame simples:

// Importa todas as classes do pacote javax.swing.
// Este pacote fornece um amplo conjunto de componentes para desenvolvimento
// de interfaces gráficas.
import javax.swing.*;

public class ExemploGUI1 {
   
   // Cria uma janela, adiciona um componente e mostra a janela.
   private static void criaEMostraGUI() {
    
      // Cria uma janela com o título "Exemplo 1".
      JFrame frame = new JFrame("Exemplo 1");
     
      // Define a operação que será efetuada quando o usuário tentar fechar
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      // Cria um texto constante (rótulo) que será adicionado à janela.
      JLabel label = new JLabel("Texto dentro da janela");
     
      // Adiciona o texto à janela.
      frame.getContentPane().add(label);

      // Dimensiona a janela de modo a acomodar todos os componentes
      // adicionados.
      // (note que a classe javax.swing.JFrame deriva indiretamente
      // da classe java.awt.Window).
      frame.pack();
     
      // Mostra a janela.
      // (note que javax.swing.JFrame deriva indiretamente da classe
      // java.awt.Component).
      frame.setVisible(true);
   }   

   // Método principal.
   public static void main(String[] args) {
  
      // Cria um objeto Runnable que invoca criaEMostraGUI() quando executado
      // por um thread.
      Runnable coisa = new Runnable() {
         // Implementação do método run(). Note que este código declara uma
         // classe sem nome, aninhada à classe ExemploGUI1.
         public void run() {
            criaEMostraGUI();
         }
      }; // aqui termina a criação do objeto "coisa"
                      
      // O código abaixo faz com que o método run de "coisa" seja executado
      // pelo thread que manipula eventos da interface gráfica.
      javax.swing.SwingUtilities.invokeLater(coisa);
   }
}

run:



3.12. JMenuBar


Método setJMenuBar() insere o menu em uma janela;
Menus são criados instanciando-se objetos da classe JMenu;
Ítens de menu são criados instanciando-se objetos da classe JMenuItem.


Classe Janela:

// MenuDemo.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

class Janela extends JFrame {

    JTextArea texto;

    public Janela() {
        setTitle("Visualizador de Arquivos");
        JMenuBar bar = new JMenuBar();
        setJMenuBar(bar);
        JMenu menuArquivo = new JMenu("Arquivo");
        menuArquivo.setMnemonic('A');
        JMenu menuEstilo = new JMenu("Estilo");
        menuEstilo.setMnemonic('E');
        JMenu menuAjuda = new JMenu("Ajuda");
        menuAjuda.setMnemonic('U');
        bar.add(menuArquivo);
        bar.add(menuEstilo);
        bar.add(menuAjuda);
        JMenuItem itemAbrir = new JMenuItem("Abrir");
        itemAbrir.setMnemonic('A');
        itemAbrir.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                JFileChooser fileChooser = new JFileChooser();
                int result = fileChooser.showSaveDialog(Janela.this);
            }
        });
        menuArquivo.add(itemAbrir);
        menuArquivo.addSeparator();
        menuArquivo.add(new JMenuItem("Sair"));
        menuEstilo.add(new JMenuItem("Copiar"));
        menuEstilo.add(new JMenuItem("Colar"));
        menuEstilo.add(new JMenuItem("Recortar"));
        JMenuItem itemSobre = new JMenuItem("Sobre...");
        itemSobre.setMnemonic('S');
        itemSobre.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(null, "Mini Visualizador");
            }
        });
        menuAjuda.add(itemSobre);

        setSize(400, 200);
        texto = new JTextArea();
        getContentPane().add(texto);
    }
}


Classe MenuDemo:

public class MenuDemo {

    public static void main(String args[]) {
        Janela j = new Janela();
        j.show();
    }
}

run:


3.13. JComboBox
Assemelha-se a um botão, porém, quando clicado, abre uma lista de possíveis valores ou opções. Mais precisamente é uma caixa de combinação que permite ao usuário fazer uma seleção a partir de uma lista de itens.
Atende-se para que a lista da caixa de combinação, quando aberta, não ultrapasse os limites da janela da aplicação. Também é possível digitar nas linhas de uma caixa de combinação. Elas são implementadas com a classe JComboBox, herdada de JComponent. Tais caixas de combinação geram ItemEvents, assim como as JCheckBoxes.

// Demonstra o uso de uma JComboBox para
// selecionar uma figura

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class TesteJComboBox extends JFrame {

    private JComboBox comboBox, comboBoxEdit;
    private JLabel rotulo;
    private JPanel esquerdo, direito;
    private String nomes[] = {"Wanderson", "Leonardo",
        "Gabriel", "Daniel"};
private String nomesDasFiguras[] = {"img/quadrado.jpg","img/circulo.jpg", "img/triangulo.jpg","img/triangulo.jpg"};
    private Icon figuras[] = {new ImageIcon(nomesDasFiguras[ 0]),
        new ImageIcon(nomesDasFiguras[ 1]),
        new ImageIcon(nomesDasFiguras[ 2]),
        new ImageIcon(nomesDasFiguras[ 3])};
// a pasta img foi criada dentro do respectivo projeto do netbeans
    // configura a GU
    public TesteJComboBox() {
        super("Testando uma JComboBox");

        // obt´em pain´el de conte´udo
        Container container = getContentPane();

        // e configura seu leiaute
        container.setLayout(new GridLayout(1, 2));

        // cria a JComboBox
        comboBox = new JComboBox(nomesDasFiguras);

        // configura a JComboBox para, quando clicada,
        // exibir 3 linhas
        comboBox.setMaximumRowCount(3);

        // configura a JComboBox para exibir a figura de
        // indice 2 do array nomeDasFiguras
        comboBox.setSelectedIndex(2);

        comboBoxEdit = new JComboBox(nomes);
        comboBoxEdit.setEditable(true);

        // registra tratador de eventos
        comboBox.addItemListener(
                // classe interna an^onima para tratar eventos
                // da JComboBox
                new ItemListener() {
            // trata os eventos da JComboBox
            public void itemStateChanged(ItemEvent evento) {
                // determina se a caixa de marca¸c~ao est´a selecionada
                if (evento.getStateChange() == ItemEvent.SELECTED) {
                    rotulo.setIcon(figuras[comboBox.getSelectedIndex()]);
                }
            }
        });

        comboBoxEdit.addItemListener(
                // classe interna an^onima para tratar eventos da JComboBox
                new ItemListener() {
            // trata os eventos da JComboBox
            public void itemStateChanged(ItemEvent evento) {
                // determina se a caixa de marca¸c~ao est´a selecionada
                if (evento.getStateChange() == ItemEvent.SELECTED) {
                    JOptionPane.showMessageDialog(null,
                            "Voc^e selecionou : " + (comboBoxEdit.getSelectedItem()));
                }
            }
        });
// configura o JLabel para mostrar as figuras
        rotulo = new JLabel(figuras[ 0]);

        // anexando componentes ao painel esquerdo
        esquerdo = new JPanel();
        esquerdo.setLayout(new BorderLayout());
        esquerdo.add(comboBox, BorderLayout.NORTH);
        esquerdo.add(rotulo, BorderLayout.CENTER);
        container.add(esquerdo);

// anexando componentes ao painel direito
        direito = new JPanel();
        direito.setLayout(new BorderLayout());
        direito.add(comboBoxEdit, BorderLayout.NORTH);
        container.add(direito);

        setSize(350, 150);
        setVisible(true);
    }

    // executa a aplicacao
    public static void main(String args[]) {
        TesteJComboBox aplicacao = new TesteJComboBox();

        aplicacao.setDefaultCloseOperation(
                JFrame.EXIT_ON_CLOSE);
    }
}

run:

Selecione no comobox a figura desejada:


Obs: foi criado a pasta img dentro do projeto do netbeans (menus),  onde estão todas as figuras.


4.2. Texto Formatado

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;

import java.text.*;

/**
 * FormattedTextFieldDemo.java requires no other files.
 *
 * It implements a mortgage calculator that uses four JFormattedTextFields.
 */
public class FormattedTextFieldDemo extends JPanel
        implements PropertyChangeListener {
    //Values for the fields

    private double amount = 100000;
    private double rate = 7.5;  //7.5%
    private int numPeriods = 30;
    //Labels to identify the fields
    private JLabel amountLabel;
    private JLabel rateLabel;
    private JLabel numPeriodsLabel;
    private JLabel paymentLabel;
    //Strings for the labels
    private static String amountString = "Loan Amount: ";
    private static String rateString = "APR (%): ";
    private static String numPeriodsString = "Years: ";
    private static String paymentString = "Monthly Payment: ";
    //Fields for data entry
    private JFormattedTextField amountField;
    private JFormattedTextField rateField;
    private JFormattedTextField numPeriodsField;
    private JFormattedTextField paymentField;
    //Formats to format and parse numbers
    private NumberFormat amountFormat;
    private NumberFormat percentFormat;
    private NumberFormat paymentFormat;

    public FormattedTextFieldDemo() {
        super(new BorderLayout());
        setUpFormats();
        double payment = computePayment(amount,
                rate,
                numPeriods);

        //Create the labels.
        amountLabel = new JLabel(amountString);
        rateLabel = new JLabel(rateString);
        numPeriodsLabel = new JLabel(numPeriodsString);
        paymentLabel = new JLabel(paymentString);

        //Create the text fields and set them up.
        amountField = new JFormattedTextField(amountFormat);
        amountField.setValue(new Double(amount));
        amountField.setColumns(10);
        amountField.addPropertyChangeListener("value", this);

        rateField = new JFormattedTextField(percentFormat);
        rateField.setValue(new Double(rate));
        rateField.setColumns(10);
        rateField.addPropertyChangeListener("value", this);

        numPeriodsField = new JFormattedTextField();
        numPeriodsField.setValue(new Integer(numPeriods));
        numPeriodsField.setColumns(10);
        numPeriodsField.addPropertyChangeListener("value", this);

        paymentField = new JFormattedTextField(paymentFormat);
        paymentField.setValue(new Double(payment));
        paymentField.setColumns(10);
        paymentField.setEditable(false);
        paymentField.setForeground(Color.red);

        //Tell accessibility tools about label/textfield pairs.
        amountLabel.setLabelFor(amountField);
        rateLabel.setLabelFor(rateField);
        numPeriodsLabel.setLabelFor(numPeriodsField);
        paymentLabel.setLabelFor(paymentField);

        //Lay out the labels in a panel.
        JPanel labelPane = new JPanel(new GridLayout(0, 1));
        labelPane.add(amountLabel);
        labelPane.add(rateLabel);
        labelPane.add(numPeriodsLabel);
        labelPane.add(paymentLabel);

        //Layout the text fields in a panel.
        JPanel fieldPane = new JPanel(new GridLayout(0, 1));
        fieldPane.add(amountField);
        fieldPane.add(rateField);
        fieldPane.add(numPeriodsField);
        fieldPane.add(paymentField);

        //Put the panels in this panel, labels on left,
        //text fields on right.
        setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
        add(labelPane, BorderLayout.CENTER);
        add(fieldPane, BorderLayout.LINE_END);
    }

    /**
     * Called when a field's "value" property changes.
     */
    public void propertyChange(PropertyChangeEvent e) {
        Object source = e.getSource();
        if (source == amountField) {
            amount = ((Number) amountField.getValue()).doubleValue();
        } else if (source == rateField) {
            rate = ((Number) rateField.getValue()).doubleValue();
        } else if (source == numPeriodsField) {
            numPeriods = ((Number) numPeriodsField.getValue()).intValue();
        }

        double payment = computePayment(amount, rate, numPeriods);
        paymentField.setValue(new Double(payment));
    }

    /**
     * Create the GUI and show it. For thread safety, this method should be
     * invoked from the event-dispatching thread.
     */
    private static void createAndShowGUI() {
        //Create and set up the window.
        JFrame frame = new JFrame("FormattedTextFieldDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //Create and set up the content pane.
        JComponent newContentPane = new FormattedTextFieldDemo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }

    //Compute the monthly payment based on the loan amount,
    //APR, and length of loan.
    double computePayment(double loanAmt, double rate, int numPeriods) {
        double I, partial1, denominator, answer;

        numPeriods *= 12;        //get number of months
        if (rate > 0.01) {
            I = rate / 100.0 / 12.0;         //get monthly rate from annual
            partial1 = Math.pow((1 + I), (0.0 - numPeriods));
            denominator = (1 - partial1) / I;
        } else { //rate ~= 0
            denominator = numPeriods;
        }

        answer = (-1 * loanAmt) / denominator;
        return answer;
    }

    //Create and set up number formats. These objects also
    //parse numbers input by user.
    private void setUpFormats() {
        amountFormat = NumberFormat.getNumberInstance();

        percentFormat = NumberFormat.getNumberInstance();
        percentFormat.setMinimumFractionDigits(3);

        paymentFormat = NumberFormat.getCurrencyInstance();
    }
}

run:

 5. Exemplos:

Formulario.java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class Formulario extends JFrame implements ActionListener {
    /* grid: posicionamento */
    /* painel: agrupamento */
    /* conteiner: inserção no Jframe */

    private JLabel lblNome, lblIdade, lblEndereco, lblCep, lblCidade, lblEstado, lblSexo, lblEmail;
    private JTextField txtNome, txtIdade, txtEndereco, txtCep, txtCidade, txtEstado, txtEmail;
    private JRadioButton rdbMasculino, rdbFeminino;
    private ButtonGroup grpSexo;
    private JTextArea txtMensagem;
    private JButton btnCadastrar, btnLimpar, btnFechar;

    public Formulario() {
        setTitle("Formulário");

        lblNome = new JLabel("Nome");
        lblIdade = new JLabel("Idade");
        lblEndereco = new JLabel("Endereco");
        lblCep = new JLabel("CEP");
        lblCidade = new JLabel("Cidade");
        lblEstado = new JLabel("Estado");
        lblSexo = new JLabel("Sexo");
        lblEmail = new JLabel("E-mail");

        txtNome = new JTextField(10);
        txtIdade = new JTextField(10);
        txtEndereco = new JTextField(10);
        txtCep = new JTextField(10);
        txtCidade = new JTextField(10);
        txtEstado = new JTextField(10);
        txtEmail = new JTextField(20);

        rdbMasculino = new JRadioButton("Masculino");
        rdbFeminino = new JRadioButton("Feminino");
        grpSexo = new ButtonGroup();
        grpSexo.add(rdbMasculino);
        grpSexo.add(rdbFeminino);

        txtMensagem = new JTextArea(10, 40);

        btnCadastrar = new JButton("Cadastrar");
        btnLimpar = new JButton("Limpar");
        btnFechar = new JButton("Fechar");

        JPanel pnlNome = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlNome.add(lblNome);
        pnlNome.add(txtNome);

        JPanel pnlIdade = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlIdade.add(lblIdade);
        pnlIdade.add(txtIdade);

        JPanel pnlEndereco = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlEndereco.add(lblEndereco);
        pnlEndereco.add(txtEndereco);

        JPanel pnlCep = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlCep.add(lblCep);
        pnlCep.add(txtCep);

        JPanel pnlCidade = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlCidade.add(lblCidade);
        pnlCidade.add(txtCidade);

        JPanel pnlEstado = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlEstado.add(lblEstado);
        pnlEstado.add(txtEstado);

        JPanel pnlSexo = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlSexo.add(lblSexo);
        pnlSexo.add(rdbMasculino);
        pnlSexo.add(rdbFeminino);

        JPanel pnlEmail = new JPanel(new FlowLayout(FlowLayout.LEFT));
        pnlEmail.add(lblEmail);
        pnlEmail.add(txtEmail);

        JPanel pnlNomeIdade = new JPanel(new GridLayout(1, 2));
        pnlNomeIdade.add(pnlNome);
        pnlNomeIdade.add(pnlIdade);

        JPanel pnlEnderecoCep = new JPanel(new GridLayout(1, 2));
        pnlEnderecoCep.add(pnlEndereco);
        pnlEnderecoCep.add(pnlCep);

        JPanel pnlCidadeEstado = new JPanel(new GridLayout(1, 2));
        pnlCidadeEstado.add(pnlCidade);
        pnlCidadeEstado.add(pnlEstado);

        JPanel pnlFormulario = new JPanel(new GridLayout(5, 1));
        pnlFormulario.add(pnlNomeIdade);
        pnlFormulario.add(pnlEnderecoCep);
        pnlFormulario.add(pnlCidadeEstado);
        pnlFormulario.add(pnlSexo);
        pnlFormulario.add(pnlEmail);

        JPanel pnlBotoes = new JPanel(new FlowLayout());
        pnlBotoes.add(btnCadastrar);
        pnlBotoes.add(btnLimpar);
        pnlBotoes.add(btnFechar);

        Container c = getContentPane();
        c.add(pnlFormulario, BorderLayout.NORTH);
        c.add(txtMensagem, BorderLayout.CENTER);
        c.add(pnlBotoes, BorderLayout.SOUTH);

        pack();

        setDefaultCloseOperation(EXIT_ON_CLOSE);

        btnCadastrar.addActionListener(this);
        btnLimpar.addActionListener(this);
        btnFechar.addActionListener(this);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        Object botao = e.getSource();

        if (botao == btnFechar) {
            System.exit(0);
        } else if (botao == btnLimpar) {
            txtNome.setText("");
            txtIdade.setText("");
            txtEndereco.setText("");
            txtCep.setText("");
            txtCidade.setText("");
            txtEstado.setText("");
            txtEmail.setText("");
            grpSexo.clearSelection();
            txtMensagem.setText("");
        } else if (botao == btnCadastrar) {
            String mensagem = "";

            mensagem += "Nome: " + txtNome.getText() + "\n";
            mensagem += "Idade: " + txtIdade.getText() + "\n";
            mensagem += "Endereço: " + txtEndereco.getText() + "\n";
            mensagem += "CEP: " + txtCep.getText() + "\n";
            mensagem += "Cidade: " + txtCidade.getText() + "\n";
            mensagem += "Estado: " + txtEstado.getText() + "\n";
            mensagem += "Sexo: " + (rdbMasculino.isSelected() ? "Masculino" : (rdbFeminino.isSelected() ? "Feminino" : "")) + "\n";
            mensagem += "E-mail: " + txtEmail.getText() + "\n";

            txtMensagem.setText(mensagem);
        }
    }

    public static void main(String[] args) {
        Formulario janela = new Formulario();
        janela.setVisible(true);
    }
}

Resultado:


Calculadora.java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextField;

public class Calculadora extends JFrame implements ActionListener {
    /* grid: posicionamento */
    /* painel: agrupamento */
    /* conteiner: inserção no Jframe */
    private JLabel lblN1, lblN2, lblResultado;
    private JTextField txtN1, txtN2, txtResultado;
    private JRadioButton rbSoma, rbSubtracao, rbMultiplicacao, rbDivisao, rbResto;
    private ButtonGroup operacoes;
    private JButton btnCalcular;
   
    public Calculadora() {
        setTitle("Calculadora");
       
        lblN1 = new JLabel("N1");
        lblN2 = new JLabel("N2");
        lblResultado = new JLabel("Resultado");
        txtN1 = new JTextField(20);
        txtN2 = new JTextField(20);
        txtResultado = new JTextField(20);
        rbSoma = new JRadioButton("Soma (+)");
        rbSubtracao = new JRadioButton("Subtraçãoo (-)");
        rbMultiplicacao = new JRadioButton("Multiplicação (*)");
        rbDivisao = new JRadioButton("Divisão (/)");
        rbResto = new JRadioButton("Resto (%)");
        operacoes = new ButtonGroup();
        operacoes.add(rbSoma);
        operacoes.add(rbSubtracao);
        operacoes.add(rbMultiplicacao);
        operacoes.add(rbDivisao);
        operacoes.add(rbResto);
        btnCalcular = new JButton("Calcular");
       
        JPanel pnlN1 = new JPanel(new FlowLayout(FlowLayout.LEFT));
        JPanel pnlN2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
        JPanel pnlResultado = new JPanel(new FlowLayout(FlowLayout.LEFT));
       
        pnlN1.add(lblN1);
        pnlN1.add(txtN1);
        pnlN2.add(lblN2);
        pnlN2.add(txtN2);
        pnlResultado.add(lblResultado);
        pnlResultado.add(txtResultado);
       
        JPanel pnlEntradas = new JPanel(new GridLayout(2, 1, 5, 5));
        pnlEntradas.add(pnlN1);
        pnlEntradas.add(pnlN2);
       
        JPanel pnlOperacoes = new JPanel(new GridLayout(5, 1, 5, 5));
        pnlOperacoes.add(rbSoma);
        pnlOperacoes.add(rbSubtracao);
        pnlOperacoes.add(rbMultiplicacao);
        pnlOperacoes.add(rbDivisao);
        pnlOperacoes.add(rbResto);
       
        JPanel pnlCalcular = new JPanel(new FlowLayout(FlowLayout.CENTER));
        pnlCalcular.add(btnCalcular);
       
        JPanel pnlCentro = new JPanel(new GridLayout(1, 2, 5, 5));
        pnlCentro.add(pnlOperacoes);
        pnlCentro.add(pnlCalcular);
       
        Container c = getContentPane();
        c.add(pnlEntradas, BorderLayout.NORTH);
        c.add(pnlCentro, BorderLayout.CENTER);
        c.add(pnlResultado, BorderLayout.SOUTH);
        pack();
       
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        btnCalcular.addActionListener(this);
    }
   
    @Override
    public void actionPerformed(ActionEvent e) {
        double n1 = Double.parseDouble(txtN1.getText());
        double n2 = Double.parseDouble(txtN2.getText());
        double resultado = 0;
       
        if (rbSoma.isSelected()) {
            resultado = n1 + n2;
        } else if (rbSubtracao.isSelected()) {
            resultado = n1 - n2;
        } else if (rbMultiplicacao.isSelected()) {
            resultado = n1 * n2;
        } else if (rbDivisao.isSelected()) {
            resultado = n1 / n2;
        } else if (rbResto.isSelected()) {
            resultado = n1 % n2;
        } else {
            JOptionPane.showMessageDialog(this, "Selecione uma operação!");
        }
       
        txtResultado.setText(String.valueOf(resultado));
    }
   
    public static void main(String[] args) {
        Calculadora app = new Calculadora();
        app.setVisible(true);
    }
}

Resultado: