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:

• 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.

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);

}

}

É 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); } }

• Abaixo mostramos as constantes que representam os tipos das mensagens quando são

mostradas na saída de um resultado através JOptionPane.

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:

• 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.

• 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).

• 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).

• 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.

• 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;

• 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");

• 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);

• 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); } }

• 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;

• 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.

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.

• 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); } }

•

• 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.

• 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