Divisão de Engenharia

Engenharia Informática
Diurno

Programação Orientada à Objectos

JavaOptionPane

Discentes:
Anderson Belarmino Gȇmo
Belarmino Joaquim Roque
Luisa Silvestre Fernandes

Docente:
Msc. Lourenço Sansão Roberto

Tete, aos 21 de Março de 2025

Índice
Introdução..........................................................................................................................3
Caixas de Dialogo..............................................................................................................4
JOptionPane.......................................................................................................................5
Como usar um construtor?.................................................................................................6
Métodos JavaOptionPane..................................................................................................7
Dialogos de Mensagem ou informação “showMessageDialog”....................................7
Diálogos de Confirmação................................................................................................10
Dialogos de Confirmação “showConfirmDialog”......................................................10
Diálogos de entrada.........................................................................................................13
Diálogos de entrada ou “showInputDialog”................................................................13
Diálogos de Opção..........................................................................................................16
Diálogos de Mensagem interna.......................................................................................17
Conclusão........................................................................................................................19
Referências Bibliográficas...............................................................................................20

2
Introdução
No desenvolvimento de aplicações ou softwares em Java, a interação entre o usuário e o
sistema é um aspecto essencial para a usabilidade e eficiência do programa, uma das
formas mais simples e diretas de implementar essa interação é por meio da classe
JOptionPane, pertencente ao pacote [Link], essa classe fornece métodos prontos
para a criação de caixas de diálogo que permitem exibir mensagens, solicitar entradas de
dados e apresentar opções de escolha ao usuário por sua simplicidade e praticidade, o
JOptionPane é amplamente utilizado em projetos didáticos e aplicações de pequeno
porte, servindo como uma introdução acessível ao desenvolvimento de interfaces
gráficas em Java. Este trabalho tem como objetivo apresentar os principais recursos do
JOptionPane, demonstrando seu funcionamento e aplicações por meio de exemplos
práticos.

3
Caixas de Dialogo
Uma caixa de diálogo é um elemento gráfico de interface do usuário que permite que os
usuários interajam com o computador para fornecer entrada, visualizar saída e receber
mensagens.É um tipo de janela que contém campos para inserir dados, botões para
confirmar ou cancelar uma ação e outros elementos que podem variar dependendo do
[Link] caixa de diálogo geralmente aparece quando o usuário precisa inserir
informações em um programa ou sistema.

4
JOptionPane
JOptionPane é uma classe da biblioteca Swing do java, usada para criar caixas de
diálogo simples e rápidas que permitem a interacção com o usuário.
A classe JOptionPane faz parte do pacote “[Link]” e é amplamente utilizada em
aplicações gráficas java para facilitar a comunicação com o usuário de forma intuitiva e
eficaz. O JOptionPane é usado em vez do JDialog para minimizar a complexidade do
código,
Exibe as caixas de diálogo com um dos quatro ícones padrão ( pergunta, informação,
aviso e erro ) ou os ícones personalizados especificados pelo usuário.

Construtores Descrição

Este é o construtor padrão para JOptionPane. Ele é usado para

JOptionPane( )
criar um JOptionPane sem opções e mensagens.

JOptionPane(Object Ele cria um diálogo de mensagem com uma mensagem

message) especificada.

JOptionPane(Object Ele cria uma caixa de diálogo de mensagem com uma

message, int messageType) mensagem especificada e seu Tipo.

JOptionPane(Object
Ela nos ajuda a criar um diálogo com uma mensagem, tipo de
message, int messageType,
mensagem e tipo de opção especifica.
int optionType)

5
Como usar um construtor?
Para usar um construtor ou até o método JOptionPane na realização de um código em
Java, primeiro temos que importar a biblioteca “[Link];” que ficaria
assim na nossa IDE:
import [Link];
Após a importação da biblioteca temos que criar um construtor JOptionPane.
JOptionPane variavel = new JOptionPane(“Tchau Mundo”);
Logo a variável que foi usada vai armazenar o texto “Tchau Mundo”.

6
Métodos JavaOptionPane
Dialogos de Mensagem ou informação “showMessageDialog”.
Ao usarmos o JOptionPane numa IDE, o programa nos dá várias opções de mostrar
texto, e vamos aqui falar de cada uma delas e para que serve.
O showMessageDialog serve simplesmente para exibir uma mensagem na tela sem
inserir dados ou cancelar opções, é simples e direto.
Primeiro exemplo:
[Link](parentComponent, object message);
Exibe uma caixa de diálogo com uma mensagem para o usuário e não solicita nenhuma
entrada.
Exemplo:
parenteComponente = null;
object message = “Bom dia”.
[Link](null, “Bom dia”);

7
Segundo exemplo:
[Link](Component, parentComponent, object message,
String title, int messageType);
Exibe uma caixa de diálogo com uma mensagem para o usuário e contém o título da
caixa;
Componet, parentComponent = null;
Object message = “Dia de tete”;
String title = “Semana”;
int messageType =JOptionPane. INFORMATION_MESSAGE
[Link](null, "Dia de Tete", "Semana",
JOptionPane.INFORMATION_MESSAGE);

Terceiro exemplo:
[Link](Component, parentComponent, object message,
String title, int messageType);
Exibe uma caixa de diálogo com uma mensagem de Erro;
Componet, parentComponent = null;
Object message = “Error Message”;
String title = “Message Dialog”;
int messageType =JOptionPane.ERROR_MESSAGE

8
Quarto exemplo:
Exibir mensagens com um pequeno ícone.
NB: Primeiro importar a biblioteca “[Link]”.
Depois criar a imagem com o método abaixo;
ImageIcon fotoMundo = new ImageIcon(“Caminho/para/[Link]”);
[Link](Component, parentComponent, object message,
String title, int messageType, Icon icon);
Componet, parentComponent = null;
Object message = “Hello world”;
String title = “Hello”;
int messageType =JOptionPane. INFORMATION_MESSAGE ;
Icon icon = fotoMundo;

9
Diálogos de Confirmação
Dialogos de Confirmação “showConfirmDialog”.
Para diálogos de confirmação, nós usamos o método “showComfirmDialog”.
Este metodo nos permite seguir opções após a visualização de uma informação.
Primeiro exemplo:
[Link](Component, parentComponent, object
message, String title, int messageType, optionType);
Componet, parentComponent = null;
Object message = “Click any button”;
String title = “Option Pane”
int messageType =JOptionPane. INFORMATION_MESSAGE .
optionType= JOptionPane.YES_NO_CANCEL_OPTION.

Segundo exemplo:
Vamos criar um diálogo de confirmação simples e básico que mostra os botões “sim” ,
“não” “cancelar”.
[Link](Component, parentComponent, object
message, int messageType, OptionType);
Componet, parentComponent = null;
Object message = “Quer Continuar?”;
String title = “Jogo da vida”;
optionType= JOptionPane.YES_NO_CANCEL_OPTION.

10
Terceiro exemplo:
Primeiro importar a biblioteca “[Link]”.
Vamos chamar a imagem ou ícone com o método abaixo.
ImageIcon fotoTartaruga = new ImageIcon(“Caminho/para/foto_tartaruga.png”);
[Link](Component, parentComponent, object
message,String title, messageType, optionType, Icon icon);
Componet, parentComponent = null;
Object message = “Do you like turtles?”;
String title = “Be honest…”;
int messageType =JOptionPane. INFORMATION_MESSAGE ;
optionType= JOptionPane.YES_NO_CANCEL_OPTION
Icon icon = fotoTartaruga.

11
Quarto exemplo:
vamos colocar uma caixa de diálogo com opções personalizadas além do “Yes No
Cancel” como nos exemplos passados.
[Link](Component, parentComponent, object
message,String title, messageType, optionType, Icon icon, opcoes, opcoes[0] );
Primeiro devemos criar um Vetor ou Array com as respetivas opções (em ordem).
Object[ ] opcoes = {"Guardar", "Nao Guardar", "Cancelar"};
Object message = “Deseja salvar alteracoes?”;
String title = “Salvar alterações ”;
int messageType =JOptionPane.QUESTION_MESSAGE ;
Icon = null.
optionType= opcoes.
opcoes[0].

12
Diálogos de entrada
Diálogos de entrada ou “showInputDialog”.
Dialogos de entrada tem haver com dados inseridos na caixa pelo usuário.
Primeiro exemplo:
Como se trata de texto usaremos String para armazenar o nome do usuário.
String nome = [Link]("Digite seu nome!");
Obviamente que o texte digitado no campo de entrada será armazenado na variavel
String nome;

Segundo exemplo:
Agora vamos colocar um campo de diálogo que recebe e mostra os dados digitados pelo
usuário na tela.
Simplesmente usaremos o metodo de exibir mensagens o “showMessageDialog”.
[Link](null, “Bem vindo ”+nome);

13
Terceiro exemplo:
Agora vamos colocar uma caixa de diálogo com várias seleções de escolha.
Em primeiro lugar temos de fazer um vetor String (porque vai conter texto) que vai
conter as opções :
String[ ] opcoes = {"Real Madrid", "Barcelona", "Outro"};
Depois vamos colocar outro String que vai fazer a caixa do Diálogo com o título, campo
de mensagem, tipo de mensagem e as opções do vetor.
String clube = (String) [Link](null, "Selecione o seu
Clube", opcoes).
A variavel “clube” vai armazenar o clube escolhido pelo usuário.

Ao clicar na seta de opcoes vai aparecer desse jeito:

14
Quarto exemplo:
Vamos fazer uma caixa de diálogo para mostrar qual clube escolheu.
[Link](null,"Escolheu "+ clube);

15
Diálogos de Opção
O showOptionDialog é um método da classe JOptionPane em java que permite criar
caixas de de diálogo personalizadas com múltiplas opções para o usuário escolher.
E contém a seguinte estrutura:
ShowOptionDialog(component, parentComponent, object message, String title int
optionType, messageType, Icon icon, Object[] options, Object initial value);
Vamos criar uma caixa de diálogo com 3 opções (Sim, não e cancelar).
Primeiro criamos um Array que contem as opções.
Object[ ] opcoes = {"Sim", "Nao", "Cancelar",};
int escolha = [Link](null, "Quer continuar?",
"Confirmacao", JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE, null,
opcoes, opcoes[2]
);

Vamos colocar condições de escolha para cada opção.

if (escolha == JOptionPane.YES_OPTION){
[Link]("Voce escolheu sim");
}
else if (escolha== JOptionPane.NO_OPTION){
[Link]("Voce escolheu nao");
}
else if (escolha == JOptionPane.CANCEL_OPTION){
[Link]("Voce escolheu cancelar");
}
else if (escolha == JOptionPane.CLOSED_OPTION){
[Link]("A caixa foi fechada sem escolha "); }

16
Diálogos de Mensagem interna
O método “showInternalMessageDialog” exibe um tipo específico de diálogo chamado
caixa de diálogo de mensagem interna. Esse tipo de diálogo é usado para mostrar uma
mensagem ao usuário dentro dentro de uma janela interna (JInternalFrame), em vez de
uma janela separada (como ocorre com os metodos anteriores).
Criar a janela principal
O frame é uma variável
JFrame frame = new JFrame("Exemplo");
[Link](400,300);
Cria a janela interna
JInternalFrame internalFrame = new JInternalFrame("Janela Interna");
[Link](200, 150);
[Link](true);
Adiciona a janela interna à janela principal
[Link](internalFrame);

Exibe a caixa de dialogo de mensagem interna

[Link](internalFrame, "Esta Mensagem", "Aviso",
JOptionPane.WARNING_MESSAGE);
Adiciona a janela principal visivel
[Link](true);

17
Conclusão
O JOptionPane é uma ferramenta fundamental da biblioteca Swing do Java que facilita
a criação de interfaces gráficas simples e interativas. Por meio de caixas de diálogo
intuitivas, ele permite que o programador interaja com o usuário de maneira prática, seja
para exibir mensagens, coletar informações ou apresentar opções. Sua utilização é
especialmente útil em programas iniciais ou didáticos, pois reduz a complexidade da
interface e torna a interação com o sistema mais amigável. Ao explorar seus diferentes
tipos de diálogos como mensagens, confirmações e entradas de dados fica evidente a
versatilidade e a importância do JOptionPane no desenvolvimento de aplicações Java
com foco em usabilidade e interação direta com o usuário.

18
Referências Bibliográficas
[Link]
[Link]
[Link]

19