O documento discute o uso de interfaces gráficas no Java, especificamente o JOptionPane e os componentes JFrame, JPanel e JLabel para criação de janelas, painéis e rótulos. Explica como adicionar componentes visuais como botões e imagens às interfaces e tratar eventos do usuário.

2. GUI: Graphical user interface ou Interface gráfica com o usuário no português, tem o papel de dar ao
programa uma aparência mais amigável aos usuários, no lugar de usar apenas janelas de comandos
para mostrar e receber dados como no println, o GUI oferece telas bem mais amigáveis como por
exemplo as telas criadas pelo JOptionPane.
Janela de comando GUI (criada pelo comando JOptionPane)
E existem também as constantes do JOptionPane que permitem ao programador mudar os
ícones exibidos nas janelas criadas pelo mesmo:

3. • Encontra-se no pacote javax.swing, e por ser um componente
faz parte da Classe JComponent, permitindo ao usuário inserir
informações nas caixas de diálogos, podendo exibir
informações ou avisos.

4. import javax.swing.JOptionPane;
public class SaidaNomeJOptionPane {
public static void main(String[] args) {
String nome, sobreNome, nomeCompleto;
nome= JOptionPane.showInputDialog("Digite o nome: ");
sobreNome = JOptionPane.showInputDialog("Digite o sobrenome: ");
nomeCompleto = nome + " " + sobreNome;
JOptionPane.showMessageDialog(null, "Nome Completo:
"+nomeCompleto,"Informação",JOptionPane.INFORMATION_MESSAGE);
}
}

5. É necessário fazer uma conversão das Strings para tipo de dados int, que são inseridas nas
variáveis, pois seus tipos são inteiros e caso seja inserido outro tipo, irá gerar um erro.
import javax.swing.JOptionPane;
public class SaidaValoresInteiros { public static void main(String[] args) {
int valorA=Integer.parseInt(JOptionPane.showInputDialog("Informe o valor A: "));
int valorB = Integer.parseInt(JOptionPane.showInputDialog("Informe o valor B: "));
int resultado = valorA * valorB; JOptionPane.showMessageDialog(null,"Resultado final:
"+resultado, "Resultado",JOptionPane.INFORMATION_MESSAGE); } }

6. • Abaixo mostramos as constantes que representam os tipos das mensagens quando são
mostradas na saída de um resultado através JOptionPane.

7. Tudo bem que o JOptionPane faz telas bonitas, mas programas bem elaborados
pedem telas mais elaboradas, por isso o Java oferece mais recursos através do
pacote Javax.swing que são usados para construir essas telas esses comandos
são:

8. • A melhor definição para frame é: quadro ou moldura.
• Vamos imaginar uma moldura, onde você vai colocar
uma foto.
• Esse frame é basicamente a base de tudo, para criar
aplicações gráficas em Java.
• Onde todas as janela de um programa, Caixas de
diálogos e as janelas onde ocorrer as aplicações gráficas
são todos o frames.

9. • Ele vai armazenar, exibir coisas. Como imagens, textos, botões, opções
para marcar, caixa de texto para escrever entre outras coisas.
• Por exemplo, uma foto que você revela não é impressa na moldura de
madeira, e sim é colocada, encaixada lá.
• Onde você pode trocar a foto quando necessário, a moldura é só um suporte
pra ajudar na exibição. Ela não possui informação e detalhes das imagens.
• Da mesma maneira é com o JFrame, ele vai servir para exibir e trabalhar
com esses elementos (botões, textos, imagens etc).

10. • Se podemos comparar os frames com molduras.
• Então, o Jpanel é como se fosse a foto, o conteúdo das molduras.
• Este painel vai ser encaixado no molde, no JFrame, e é ele que vai contar
os componentes gráficos de nossos programas.
• Os componentes, em Java, são os JComponents, e são muitos!
• Podem ser botões, caixas de seleção para você marcar, um bloco de texto
para ler (iguais aqueles de "Aceito os termos e condições"), imagens,
campos de texto para você escrever (para inserir login e senha, por
exemplo).

11. • Os JLabels são classes derivadas da JComponent e fazem parte do pacote swing.
• Logo, para usar, fazemos o import:
• import javax.swing.JLabel;
• Vamos colocar labels em frames.
• Portanto, precisamos fazer o import do JFrame também:
• import javax.swing.JFrame;
• Pense no JLabel como rótulos que podemos exibir em nossos frames.
• São elementos estáticos, não sendo usado para interagir com o usuário.

12. • Se olharmos a documentação do JLabel, veremos que podemos inicializar
um JLabel passando só uma String , só uma imagem, uma string e uma
imagem, uma string e um inteiro, uma imagem e um inteiro ou podemos
inicializar a JLabel passando tudo: imagem, texto e inteiro.
• Sendo esse inteiro o alinhamento que o JLabel vai ter no JFrame.
• Agora vamos criar um label que só exiba um simples texto.
• Para fazer isso, vamos criar uma classe chamada "Rotulo", que vai herdar a
classe JFrame. (“extends JFrame”)
• Declaramos o JLabel da seguinte maneira:
• private JLabel texto;

13. • Como nesse exemplo queremos apenas fornecer uma String, inicializamos
nosso JLabel dentro do construtor da classe "Rotulo":
• texto = new JLabel(“Sou Jedi na linguagem Java!!");
• Criado o componente JLabel, vamos adicioná-lo ao nosso JFrame, através
do método add:
• add(texto);
• Tudo isso dentro de nosso construtor, que também fornece uma String que
será o título do JFrame:
• super(“Rótulos em JFrame");

14. • Criaremos agora a nossa main, para isso crie uma classe com o
nome mainRotulo, criamos um objeto do tipo Rotulo o rotulo1.
• Rotulo label1 = new Rotulo();
• fazemos entao com que ele feche quando clicarmos no
botão close.
• label1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
• Tornamos ele visível.
• label1.setVisible(true);
• E definimos um tamanho de nosso JFrame.
• label1.setSize(300,100);

15. • Package mainRotulo;
• import javax.swing.JFrame;
• public class mainRotulo { public static void main(String[] args) { Rotulo label1 =
new Rotulo(); label1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
label1.setSize(300,100);
label1.setVisible(true); } }
• Package Rotulo;
• import javax.swing.JFrame;
• import javax.swing.JLabel;
• public class Rotulo extends JFrame{
• private JLabel texto;
• public Rotulo(){
• super("Usando rótulos em JFrame");
• texto = new JLabel("Meu primeiro JLabel!"); add(texto); } }

16. • De início, vamos usar imagens simples, de rótulos, que são os ícones.
• Vamos usar a seguinte imagem.
• Salve com o nome “iconJava.png".
• Não esqueça: a imagem deve ficar dentro da pasta de seu projeto.
• Ela deve ficar na pasta que tem as Subpastas 'bin' e 'src' de seu projeto.
• Para manipular este tipo de imagem, precisamos usar as classe Icon e ImageIcon,
do pacote swing entao importaremos :
• import javax.swing.Icon;
• import javax.swing.ImageIcon;

17. • Percebemos que o JLabel recebe imagens que são objetos da classe Icon.
• Vamos criar esse objeto, chamando-o de “iconJava", e fazendo o polimorfismo,
fazendo o objeto “iconJava" ser um objeto definido da classe ImageIcon.
• Como argumento, passamos o caminho da imagem.
Como esse caminho está no mesmo local do projeto, apenas colocamos o nome e
extensão da imagem.
• Assim, nosso objeto da classe Icon é declarado da seguinte maneira:
• Icon iconJava = new ImageIcon(“iconJava.png");
• Tendo o objeto “iconJava", passamos ele para o nosso JLabel "imagem":
• imagem = new JLabel(iconJava);
• E adicionamos nosso JLabel ao nosso JFrame.

18. Criaremos uma classe chamada "Botao", que vai estender a JFrame onde vamos criar nossos
JButtons, assim como fizemos com JLabels.
Como o JButton é um componente da JComponent, importaremos sua classe do pacote swing:
import javax.swing.JButton;
• Para usar o botão, apenas instanciamos um objeto da classe JButton.
• Vamos criar o botão 'ok':
• private JButton ok;
• Vamos inicializar esse botão com uma string, que será o texto exibido no botão:
• ok = new JButton("OK");
• Depois apenas usamos o método add para adicionar o objeto 'ok'.
• OBS: como não definimos o layout dobotaoelesera apresentado na tela inteira.
• Para mais informações leia a documentação do Jbutton.

19. • Package mainBotao;
• import javax.swing.JFrame;
• public class mainBotao {
• public static void main(String[] args) {
• Botao botao1 = new Botao();
botao1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
botao1.setSize(350,80); botao1.setVisible(true); } }
• Package Botao;
• import javax.swing.JFrame;
• import javax.swing.JButton;
• public class Botao extends JFrame{
• private JButton ok;
• public Botao(){
• super("Criando botões"); ok = new JButton("OK"); add(ok); } }
•

20. • Se você parar para reparar, um aplicativo gráfico é como se fosse como um
cardápio de um restaurante. Você chega, faz seus pedidos e suas ordens são
atendidas.
• Cada pessoa vai fazer pedidos diferentes, tanto dos pratos como do número de
coisas ordenadas.
• Da mesma maneira é uma aplicação gráfica em Java.
• Um programa nada mais é que uma série de opções, onde cada usuário vai fazer o
que quiser, clicando em botões, apertando teclas do teclado, rolando a barra de
informações, marcando, selecionando, escrevendo, minimizando, fechando e uma
infinidade de possibilidades.
• Cada vez que o usuário faz uma destas coisas, dizemos que foi realizado um evento.
• Ou seja, um click, o mouse passou em alguma região e algo mudou, ele escreveu
algo, deu enter etc etc.

21. • O que a GUI (Graphic User Interface) faz é nada mais que
tratar estes eventos.
• Se ele apertar isso, acontece aquele, Se digitar isso, aquilo
abre.
• Se clicar aqui, aquilo vai fechar. Se apertar enter, vai pra
próxima janela etc etc.
• Ou seja, um aplicativo gráfico é uma maneira do usuário
realizar pedidos e comandos de uma maneira bem mais
simples e intuitiva.
• O usuário realiza o evento, e uma ação ocorre