13ª LISTA DE EXERCÍCIOS Classe E13J1

JMenus import javax.swing.*;

Disciplina: PC-II
import java.awt.*;
import java.awt.event.*;

public class J12E1 extends JFrame implements ActionListener

Exercício 1: Criar uma interface gráfica que emprega JMenus para modificar a
{
cor de fundo de um painel tal como dado na Figura 1.1. Os comandos para a
// Local de desenho.
construção dos JMenus em acordo com a hierarquia fornecida na Figura 1.1,
private JPanel p1;
são descritos esquematicamente na Figura 1.2. Para maiores detalhes de como
// Elementos para construção de JMenu.
construir a interface gráfico é fornecido o código Java na Figura 1.3.
private JMenuBar barra;
private JMenu fjm1, fjm2, fjm3;
private JMenuItem fcor1, fcor2, fcor3, fcor4, fcor5, fcor6;

// Dimensoes iniciais do JFrame.

private int WIDTH = 720;
private int HEIGHT = 460;

public J13E1()
Figura 1.1: Interface gráfica que permite definir a cor de fundo através de {
JMenus. setTitle("JMenu I");
setSize(WIDTH,HEIGHT);
setLocation(250,250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

// Criação do JPanel e dos JMenus.

public void createContents()
{
// Criando JPanel de desenho e menus.
p1 = createJPanel1();
createJMenu1();
// Adicionando p1 na janela.
add(p1);
}

// Método que constrói o JPanel de controle.

public JPanel createJPanel1()
{
// Criando o JPanel p1.
p1 = new JPanel();
Figura 1.2: Desenho esquemático que resume como realizar a construção de
// Retorna o JPanel p1 criado vazio.
JMenus de acordo a hierarquia fornecida na interface da Figura 1.1.
return p1;
}

1 2
// Criando o JMenu de cores. // Adicionando itens ao sub JMenu.
public void createJMenu1() fjm3.add(fcor4);
{ fjm3.add(fcor5);
// Criando objeto JMenuBar. fjm3.add(fcor6);
barra = new JMenuBar();
//----------------------------------------//
// Criando objeto JMenu principal.
fjm1 = new JMenu("Cores de Fundo"); // Adicionando os sub JMenus ao JMenu de Cores.
fjm1.add(fjm2);
//----------------------------------------// fjm1.add(fjm3);
// Criando objetos dos sub JMenu. //
//----------------------------------------// // Adicionando o JMenu de cores na barra.
fjm2 = new JMenu("Quentes"); barra.add(fjm1);

// Criando elementos do sub JMenu de cores quentes. // Modificando a barra de menus para a Janela.
fcor1 = new JMenuItem("Vermelho"); setJMenuBar(barra);
fcor2 = new JMenuItem("Laranja");
fcor3 = new JMenuItem("Amarelo"); }

// Adicionando tratamento de evento aos itens de menu. public void actionPerformed(ActionEvent event)
fcor1.addActionListener(this); {
fcor2.addActionListener(this); // Verificando as fontes de evento, que sao
fcor3.addActionListener(this); // os itens de menu de cor de fundo, e para
// cada uma definir a cor de fundo adequada.
// Adicionando itens ao sub JMenu. if (event.getSource() == fcor1)
fjm2.add(fcor1); p1.setBackground(Color.RED);
fjm2.add(fcor2); else if (event.getSource() == fcor2)
fjm2.add(fcor3); p1.setBackground(Color.ORANGE);
else if (event.getSource() == fcor3)
//----------------------------------------// p1.setBackground(Color.YELLOW);
else if (event.getSource() == fcor4)
//----------------------------------------// p1.setBackground(Color.GREEN);
// Criando objetos dos sub JMenu. // else if (event.getSource() == fcor5)
//----------------------------------------// p1.setBackground(Color.BLUE);
fjm3 = new JMenu("Frias"); else if (event.getSource() == fcor6)
p1.setBackground(Color.WHITE);
// Criando elementos do sub JMenu de cores quentes. }
fcor4 = new JMenuItem("Verde");
fcor5 = new JMenuItem("Azul"); public static void main(String args[])
fcor6 = new JMenuItem("Branco"); {
J13E1 janela1 = new J13E1();
// Adicionando tratamento de evento aos itens de menu. }
fcor4.addActionListener(this);
fcor5.addActionListener(this); }
fcor6.addActionListener(this); Figura 1.3 : Código Java para a interface gráfica da Figura 1.1.

3 4
Exercício 2: Modificar a interface gráfica do Exercício 1 de modo que todos os Por
itens de menu sejam declarados em um vetor. Para tanto será necessário // Criando elementos do sub JMenu de cores quentes e frias.
realizar modificações nos seguintes trechos do código: for(int i=0; i < cores.length; i++)
fcor[i].addActionLister(this);
Modificação 1: No campo da classe
Modificação 4: No método createJMenu1
Trocar
private JMenuItem fcor1, fcor2, fcor3, fcor4, fcor5, fcor6; Trocar
// Adicionando itens ao sub JMenu.
Por fjm2.add(fcor1);
private JMenuItem fcor[] = new JMenuItem[6]; fjm2.add(fcor2);
private String nomes[] = {"Vermelho", "Laranja", "Amarelo", "Verde", "Azul", fjm2.add(fcor3);
"Branco"};
private Color cores[] = {Color.RED, Color.ORANGE, Color.YELLOW, // Adicionando itens ao sub JMenu.
Color.GREEN, Color.BLUE, Color.WHITE}; fjm2.add(fcor4);
fjm2.add(fcor5);
Modificação 2: No método createJMenu1 fjm2.add(fcor6);

Trocar Por
// Criando elementos do sub JMenu de cores quentes. // Adicionando itens ao sub JMenu cores quentes.
fcor1 = new JMenuItem("Vermelho"); for(int i=0; i < 3; i++)
fcor2 = new JMenuItem("Laranja"); fjm2.add (fcor[i]);
fcor3 = new JMenuItem("Amarelo");
// Adicionando itens ao sub JMenu cores frias.
// Criando elementos do sub JMenu de cores frias. for(int i=3; i < cores.length; i++)
fcor4 = new JMenuItem("Verde"); fjm3.add (fcor[i]);
fcor5 = new JMenuItem("Azul");
fcor6 = new JMenuItem("Branco"); Modificação 5: No método actionPerformed

Por Trocar
// Criando elementos do sub JMenu de cores quentes e frias. // Verificando as fontes de evento, que sao
for(int i=0; i < cores.length; i++) // os itens de menu de cor de fundo, e para
fcor[i] = new JMenuItem(nomes[i]); // cada uma definir a cor de fundo adequada.
if (event.getSource() == fcor1)
Modificação 3: No método createJMenu1 p1.setBackground(Color.RED);
else if (event.getSource() == fcor2)
Trocar p1.setBackground(Color.ORANGE);
// Adicionando tratamento de evento aos itens de menu. else if (event.getSource() == fcor3)
fcor1.addActionListener(this); p1.setBackground(Color.YELLOW);
fcor2.addActionListener(this); else if (event.getSource() == fcor4)
fcor3.addActionListener(this); p1.setBackground(Color.GREEN);
else if (event.getSource() == fcor5)
// Adicionando tratamento de evento aos itens de menu. p1.setBackground(Color.BLUE);
fcor4.addActionListener(this); else if (event.getSource() == fcor6)
fcor5.addActionListener(this); p1.setBackground(Color.WHITE);
fcor6.addActionListener(this);

5 6
Por GRUPO 1 - Empregando Menus – O Menu Arquivo
// Laco para identificar a fonte de evento e realizar a ação correspondente.
for(int i=0; i < cores.length; i++)
if (event.getSource() == fcor[i])
p1.setBackground(cores[i]);

Exercício 3: O propósito deste exercício é o de apresentar quatro interfaces

gráficas que empregam JMenu para alterar as propriedades de um texto
contido em um JPanel. Cada uma das interfaces é parte de uma interface mais
complexa. Para integrar as quatro interfaces propõem-se os seguintes passos:

Passo 1: Separar a turma em quatro grupos distintos: G1, G2, G3 e G4.

Passo 2: Cada grupo deverá responder as perguntas do questionário abaixo de

modo a entender o funcionamento da sua interface.
Figura 3.1: Telas da Interface para o Menu Arquivo.
Passo 3: Serão formados novos grupos de modo que estes novos grupos
tenham pelo menos um integrante de cada dos grupos G1, G2, G3 e G4. Estes
novos grupos terão como objetivo construir a interface completa que emprega import java.awt.*;
o código das interfaces G1, G2, G3 e G4. import java.awt.event.*;
import javax.swing.*;
Uma observação importante é que esta atividade incentiva e procura treinar em
seus participantes a habilidade de trabalhar em equipe e que servirá para public class J13G1 extends JFrame implements ActionListener
atividades a serem desenvolvidas em laboratórios posteriores. {
private JPanel p1;
Todos os grupos deverão responder as perguntas contidas no questionário a private Color cores[] = {Color.black, Color.blue, Color.red, Color.green};
seguir para entender sua interface e posteriormente integrar a mesma com as private String cor[] = {"Preto", "Azul", "Vermelho", "Verde"};
demais interfaces. private JLabel mostra;
private JMenu arqMenu;
Questionário private JMenuItem sobreItem, fimItem;
(i) O que faz a sua interface gráfica? private JMenuBar barra;
(ii) Coloque em uma tabela o tipo dos componentes empregados e seus nomes.
(iii) Utilize uma figura similar a Figura 1.2 para explicar a hierarquia existente // Dimensoes iniciais do JFrame.
entre os componentes da sua interface. private int WIDTH = 500;
(iv) Qual o nome dos componentes para os quais é realizado o tratamento de private int HEIGHT = 200;
eventos?
(v) Quais são as ações realizadas pela interface? // Definindo configuracoes da janela.
public J13G1()
{
Se tiver dúvidas em relação aos comandos apresentados faça uma lista e setTitle("JMenu G1");
chame o professor para realizar eventuais esclarecimentos. setSize(WIDTH,HEIGHT);
setLocation(250,250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

7 8
public void createContents() public void actionPerformed(ActionEvent e)
{ {
p1 = createJPanel1(); // Aparece caixa de mensagem.
createJMenu1(); if (e.getSource() == sobreItem)
add(p1); JOptionPane.showMessageDialog(null,
} "Este é um exemplo\nde uso de menus", "Sobre",
JOptionPane.PLAIN_MESSAGE);
public JPanel createJPanel1() // Termina o programa.
{ else if (e.getSource() == fimItem)
p1 = new JPanel(); System.exit( 0 );
return p1; }
}
public static void main(String args[])
public void createJMenu1() {
{ J13G1 j1 = new J13G1();
JFrame frame = new JFrame("Teste de menus"); }
barra = new JMenuBar(); // a barra de menus é um contêiner
}
//--------------------------------------------------------------//
// Menu Arquivo
//--------------------------------------------------------------//
arqMenu = new JMenu("Arquivo");
sobreItem = new JMenuItem("Sobre...");
sobreItem.addActionListener(this);
fimItem = new JMenuItem("Fim");
fimItem.addActionListener(this);

// Menu Arquivo
arqMenu.setMnemonic('A');
sobreItem.setMnemonic('S');
fimItem.setMnemonic('F');
arqMenu.add(sobreItem);
arqMenu.add(fimItem);
//--------------------------------------------------------------//

// Anexa o arqMenu ao contêiner

barra.add(arqMenu);
// Configura a barra de menus para a Janela.
setJMenuBar(barra);

// Definições iniciais acerca do texto que ira aparecer no JPanel p1.

mostra = new JLabel("Texto teste", SwingConstants.CENTER);
mostra.setForeground(cores[0]);
mostra.setFont(new Font("TimesRoman", Font.PLAIN, 72));
p1.setBackground(Color.white);
p1.add(mostra, BorderLayout.CENTER);
//--------------------------------------------------------------//
}

9 10
 GRUPO 2 - Empregando Menus – O Menu Formatar e Submenu Cores setLocation(250,250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

public void createContents()

{
p1 = createJPanel1();
createJMenu2();
add(p1);
}

public JPanel createJPanel1()

{
p1 = new JPanel();
Figura 3.2: Telas da Interface para o Menu Formatar e o Submenu Cores.
return p1;
}
import java.awt.*;
public void createJMenu2()
import java.awt.event.*;
{
import javax.swing.*;
JFrame frame = new JFrame("JMenu G2");
public class J13G2 extends JFrame implements ActionListener
barra = new JMenuBar(); // a barra de menus é um contêiner
{
private JPanel p1;
//--------------------------------------------------------------//
private JLabel mostra;
// Menu Formatar
private Color cores[] = {Color.black, Color.blue, Color.red, Color.green};
//--------------------------------------------------------------//
private String cor[] = {"Preto", "Azul", "Vermelho", "Verde"};
formatMenu = new JMenu("Formatar");
private String fonte[] = {"TimesRoman", "Courier", "Helvetica"};
// Menu Formatar
private String estilos[] = {"Negrito", "Itálico"};
formatMenu.setMnemonic('r');
private JRadioButtonMenuItem corItem[], fontItem[];
//--------------------------------------------------------------//
private JCheckBoxMenuItem estItem[];
private JMenu arqMenu, formatMenu, corMenu, fontMenu;
// Submenu Cores
private JMenuItem sobreItem, fimItem;
corMenu = new JMenu("Cores");
private JMenuBar barra;
corItem = new JRadioButtonMenuItem[cor.length];
private ButtonGroup fontGrupo, corGrupo;
corGrupo = new ButtonGroup();
private int estilo;
for (int i = 0; i < cor.length; i++)
{
// Dimensoes iniciais do JFrame.
corItem[i] = new JRadioButtonMenuItem(cor[i]);
private int WIDTH = 500;
}
private int HEIGHT = 200;

// Definindo configuracoes da janela.

public J13G2()
{
setTitle("JMenu G2");
setSize(WIDTH,HEIGHT);

11 12
 //--------------------------------------------------------------// GRUPO 3 - Empregando Menus – O Menu Formatar e Submenu Fontes
// Submenu Cores //
//--------------------------------------------------------------//
corMenu.setMnemonic('C');
for (int i = 0; i < cor.length; i++)
{
corMenu.add(corItem[i]);
corGrupo.add(corItem[i]);
corItem[i].addActionListener(this);
}
corItem[0].setSelected(true);
// Adiciona opcoes de cores ao Format Menu.
formatMenu.add(corMenu);
formatMenu.addSeparator();
// Adiciona o Format Menu ao conjunto de Menus.
barra.add(formatMenu);
Figura 3.3: Telas da Interface para o Menu Formatar e o Submenu Fontes.
//--------------------------------------------------------------//
// Configura a barra de menus para o JFrame
//--------------------------------------------------------------//
setJMenuBar(barra);
// Definições iniciais sobre o texto que aparece no p1.
mostra = new JLabel("Texto teste", SwingConstants.CENTER);
mostra.setForeground(cores[0]);
mostra.setFont(new Font("TimesRoman", Font.PLAIN, 72)); import java.awt.*;
p1.setBackground(Color.white); import java.awt.event.*;
p1.add(mostra, BorderLayout.CENTER); import javax.swing.*;
//--------------------------------------------------------------//
} public class J13G3 extends JFrame implements ActionListener
{
public void actionPerformed(ActionEvent e) private JPanel p1;
{ private JLabel mostra;
for (int i = 0; i < corItem.length; i++) private Color cores[] = {Color.black, Color.blue, Color.red, Color.green};
{ private String cor[] = {"Preto", "Azul", "Vermelho", "Verde"};
if (corItem[i].isSelected()) private String fonte[] = {"TimesRoman", "Courier", "Helvetica", "Arial"};
{ private String estilos[] = {"Negrito", "Itálico"};
mostra.setForeground(cores[i]); private JRadioButtonMenuItem corItem[], fontItem[];
break; private JCheckBoxMenuItem estItem[];
} private JMenu arqMenu, formatMenu, corMenu, fontMenu;
} private JMenuItem sobreItem, fimItem;
repaint(); private JMenuBar barra;
} private ButtonGroup fontGrupo, corGrupo;
private int estilo;
public static void main(String args[])
{ // Dimensoes iniciais do JFrame.
J13G2 exemplo = new J13G2(); private int WIDTH = 500;
} private int HEIGHT = 200;
}

13 14
// Definindo configuracoes da janela. fontGrupo = new ButtonGroup();
public J13G3() for (int i = 0; i < fonte.length; i++)
{ {
setTitle("JMenu G2"); fontItem[i] = new JRadioButtonMenuItem(fonte[i]);
setSize(WIDTH,HEIGHT); fontMenu.add(fontItem[i]);
setLocation(250,250); fontGrupo.add(fontItem[i]);
setDefaultCloseOperation(EXIT_ON_CLOSE); fontItem[i].addActionListener(this);
createContents(); // Metodo que adiciona componentes. }
setVisible(true); fontItem[0].setSelected(true);
} //--------------------------------------------------------------//

public void createContents() // Adiciona o Font Menu ao Format Menu.

{ // O Format Menu, por sua vez, ja foi
p1 = createJPanel1(); // colocado na barra de menus.
createJMenu3(); formatMenu.add(fontMenu);
add(p1); // Adiciona o Format Menu ao conjunto de Menus.
} barra.add(formatMenu);
// Configura a barra de menus para o JFrame.
public JPanel createJPanel1() setJMenuBar(barra);
{
p1 = new JPanel(); // Definições iniciais sobre o texto que aparece em p1.
return p1; mostra = new JLabel("Texto teste", SwingConstants.CENTER);
} mostra.setForeground(cores[0]);
mostra.setFont(new Font("TimesRoman", Font.PLAIN, 72));
public void createJMenu3() p1.setBackground(Color.white);
{ p1.add(mostra, BorderLayout.CENTER);
JFrame frame = new JFrame("Teste de menus"); //--------------------------------------------------------------//
barra = new JMenuBar(); // a barra de menus é um contêiner }

//--------------------------------------------------------------// public void actionPerformed(ActionEvent e)

// Menu Formatar {
//--------------------------------------------------------------//
formatMenu = new JMenu("Formatar"); for (int i = 0; i < fontItem.length; i++)
// Menu Formatar {
formatMenu.setMnemonic('F'); if (e.getSource() == fontItem[i])
//--------------------------------------------------------------// {
mostra.setFont(new Font(fontItem[i].getText(), Font.PLAIN, 72));
//--------------------------------------------------------------// break;
// Submenu Fontes. }
//--------------------------------------------------------------// }
fontItem = new JRadioButtonMenuItem[fonte.length]; repaint();
fontMenu = new JMenu("Fontes"); }
// Submenu Fontes.
fontMenu.setMnemonic('n'); public static void main(String args[])
{
//--------------------------------------------------------------// J13G3 j1 = new J13G3();
// Submenu Negrito ou Italico. }
//--------------------------------------------------------------// }

15 16
 GRUPO 4 - Empregando Menus – O Menu Formatar e Submenu Fontes setDefaultCloseOperation(EXIT_ON_CLOSE);
createContents(); // Metodo que adiciona componentes.
setVisible(true);
}

public void createContents()

{
p1 = createJPanel1();
createJMenu3();
add(p1);
}

public JPanel createJPanel1()

{
p1 = new JPanel();
return p1;
Figura 3.4: Telas da Interface para o Menu Formatar e o Submenu Fontes.
}
import java.awt.*; public void createJMenu3()
import java.awt.event.*; {
import javax.swing.*; JFrame frame = new JFrame("Teste de menus");
barra = new JMenuBar(); // a barra de menus é um contêiner
public class J13G4 extends JFrame implements ActionListener
{ //--------------------------------------------------------------//
private JPanel p1; // Menu Formatar
private JLabel mostra; //--------------------------------------------------------------//
private Color cores[] = {Color.black, Color.blue, Color.red, Color.green}; formatMenu = new JMenu("Formatar");
private String cor[] = {"Preto", "Azul", "Vermelho", "Verde"}; // Menu Formatar
private String fonte[] = {"TimesRoman", "Courier", "Helvetica", "Arial"}; formatMenu.setMnemonic('F');
private String estilos[] = {"Negrito", "Itálico"}; //--------------------------------------------------------------//
private JRadioButtonMenuItem corItem[], fontItem[]; //--------------------------------------------------------------//
private JCheckBoxMenuItem estItem[]; // Submenu Fontes.
private JMenu arqMenu, formatMenu, corMenu, fontMenu; //--------------------------------------------------------------//
private JMenuItem sobreItem, fimItem; fontItem = new JRadioButtonMenuItem[fonte.length];
private JMenuBar barra; fontMenu = new JMenu("Fontes");
private ButtonGroup fontGrupo, corGrupo; // Submenu Fontes.
private int estilo = 0; fontMenu.setMnemonic('n');
//--------------------------------------------------------------//
// Dimensoes iniciais do JFrame. // Submenu Estilos.
private int WIDTH = 500; //--------------------------------------------------------------//
private int HEIGHT = 200; estItem = new JCheckBoxMenuItem[estilos.length];
for (int i = 0; i < estilos.length; i++)
// Definindo configuracoes da janela. {
public J13G4() estItem[i] = new JCheckBoxMenuItem(estilos[i]);
{ fontMenu.add(estItem[i]);
setTitle("JMenu G4"); estItem[i].addActionListener(this);
setSize(WIDTH,HEIGHT); }
setLocation(250,250); //--------------------------------------------------------------//

17 18
 // Adiciona barra de separacao entre submenus. GRUPO 5 - Empregando Todos os Menus
fontMenu.addSeparator();
// Adiciona o Font Menu ao Format Menu.
// O Format Menu sera adicionado na barra de menus.
formatMenu.add(fontMenu);
// Adiciona o Format Menu ao conjunto de Menus.
barra.add(formatMenu);
// Configura a barra de menus para o JFrame
setJMenuBar(barra);

// Definições iniciais sobre o texto que aparece em p1.

mostra = new JLabel("Texto teste", SwingConstants.CENTER);
mostra.setForeground(cores[0]);
mostra.setFont(new Font("TimesRoman", Font.PLAIN, 72));
p1.setBackground(Color.white);
p1.add(mostra, BorderLayout.CENTER);
//--------------------------------------------------------------// Figura 3.5: Telas da Interface para os JMenus Arquivo e Formatar.
}

import java.awt.*;
public void actionPerformed(ActionEvent e) import java.awt.event.*;
{ import javax.swing.*;

if (e.getSource() == estItem[0] || e.getSource() == estItem[1]) public class J13G5 extends JFrame implements ActionListener
{ {
estilo = 0; private JPanel p1;
if (estItem[0].isSelected()) estilo += Font.BOLD; private JLabel mostra;
if (estItem[1].isSelected()) estilo += Font.ITALIC; private Color cores[] = {Color.black, Color.blue, Color.red, Color.green};
mostra.setFont(new Font(mostra.getFont().getName(), estilo, 72)); private String cor[] = {"Preto", "Azul", "Vermelho", "Verde"};
} private String fonte[] = {"TimesRoman", "Courier", "Helvetica", "Arial"};
repaint(); private String estilos[] = {"Negrito", "Itálico"};
} private JRadioButtonMenuItem corItem[], fontItem[];
private JCheckBoxMenuItem estItem[];
public static void main(String args[]) private JMenu arqMenu, formatMenu, corMenu, fontMenu;
{ private JMenuItem sobreItem, fimItem;
J13G4 j1 = new J13G4(); private JMenuBar barra;
} private ButtonGroup fontGrupo, corGrupo;
} private int estilo = 0;

// Dimensoes iniciais do JFrame.

private int WIDTH = 500;
private int HEIGHT = 200;

// Definindo configuracoes da janela.

public J13G5()
{
setTitle("JMenu G5");
setSize(WIDTH,HEIGHT);

19 20
 setLocation(250,250); //--------------------------------------------------------------//
setDefaultCloseOperation(EXIT_ON_CLOSE); // Submenu Cores //
createContents(); // Metodo que adiciona componentes. //--------------------------------------------------------------//
setVisible(true);
} // Submenu Cores
corMenu = new JMenu("Cores");
public void createContents() corItem = new JRadioButtonMenuItem[cor.length];
{ corGrupo = new ButtonGroup();
p1 = createJPanel1(); for (int i = 0; i < cor.length; i++)
createJMenu3(); {
add(p1); corItem[i] = new JRadioButtonMenuItem(cor[i]);
} }

public JPanel createJPanel1() corMenu.setMnemonic('C');

{ for (int i = 0; i < cor.length; i++)
p1 = new JPanel(); {
return p1; corMenu.add(corItem[i]);
} corGrupo.add(corItem[i]);
corItem[i].addActionListener(this);
public void createJMenu3() }
{ corItem[0].setSelected(true);
JFrame frame = new JFrame("Teste de menus"); // Adiciona opcoes de cores ao Format Menu.
barra = new JMenuBar(); // a barra de menus é um contêiner formatMenu.add(corMenu);
formatMenu.addSeparator();
//--------------------------------------------------------------// // Adiciona o Format Menu ao conjunto de Menus.
// Menu Formatar barra.add(formatMenu);
//--------------------------------------------------------------//
formatMenu = new JMenu("Formatar"); //--------------------------------------------------------------//
// Menu Formatar // Submenu Fontes.
formatMenu.setMnemonic('F'); //--------------------------------------------------------------//
//--------------------------------------------------------------// fontItem = new JRadioButtonMenuItem[fonte.length];
fontMenu = new JMenu("Fontes");
//--------------------------------------------------------------// // Submenu Fontes.
// Menu Arquivo fontMenu.setMnemonic('n');
//--------------------------------------------------------------//
arqMenu = new JMenu("Arquivo"); //--------------------------------------------------------------//
sobreItem = new JMenuItem("Sobre..."); // Submenu Negrito ou Italico.
sobreItem.addActionListener(this); //--------------------------------------------------------------//
fimItem = new JMenuItem("Fim"); fontGrupo = new ButtonGroup();
fimItem.addActionListener(this); for (int i = 0; i < fonte.length; i++)
{
// Menu Arquivo fontItem[i] = new JRadioButtonMenuItem(fonte[i]);
arqMenu.setMnemonic('A'); fontMenu.add(fontItem[i]);
sobreItem.setMnemonic('S'); fontGrupo.add(fontItem[i]);
fimItem.setMnemonic('F'); fontItem[i].addActionListener(this);
arqMenu.add(sobreItem); }
arqMenu.add(fimItem); fontItem[0].setSelected(true);
//--------------------------------------------------------------//

21 22
 // Laco para verificar a cor escolhida.
// Adiciona barra de separacao entre submenus. for (int i = 0; i < corItem.length; i++)
fontMenu.addSeparator(); {
if (corItem[i].isSelected())
//--------------------------------------------------------------// {
// Submenu Estilos. mostra.setForeground(cores[i]);
//--------------------------------------------------------------// break;
estItem = new JCheckBoxMenuItem[estilos.length]; }
for (int i = 0; i < estilos.length; i++) }
{
estItem[i] = new JCheckBoxMenuItem(estilos[i]); // Laco para verificar estilo de texto.
fontMenu.add(estItem[i]); for (int i = 0; i < fontItem.length; i++)
estItem[i].addActionListener(this); {
} if (e.getSource() == fontItem[i])
//--------------------------------------------------------------// {
mostra.setFont(new Font(fontItem[i].getText(), Font.PLAIN, 72));
// Anexa o arqMenu ao contêiner break;
barra.add(arqMenu); }
// Adiciona o Font Menu ao Format Menu. }
// O Format Menu sera adicionado na barra de menus.
formatMenu.add(fontMenu); // Verifica se foi escolhido Negrito ou Italico.
// Adiciona o Format Menu ao conjunto de Menus. if (e.getSource() == estItem[0] || e.getSource() == estItem[1])
barra.add(formatMenu); {
// Configura a barra de menus para o JFrame estilo = 0;
setJMenuBar(barra); if (estItem[0].isSelected()) estilo += Font.BOLD;
if (estItem[1].isSelected()) estilo += Font.ITALIC;
// Definições iniciais sobre o texto que aparece em p1. mostra.setFont(new Font(mostra.getFont().getName(), estilo, 72));
mostra = new JLabel("Texto teste", SwingConstants.CENTER); }
mostra.setForeground(cores[0]); repaint();
mostra.setFont(new Font("TimesRoman", Font.PLAIN, 72)); }
p1.setBackground(Color.white);
p1.add(mostra, BorderLayout.CENTER); public static void main(String args[])
//--------------------------------------------------------------// {
} J13G5 j1 = new J13G5();
}
public void actionPerformed(ActionEvent e) }
{
// Aparece caixa de mensagem.
if (e.getSource() == sobreItem)
JOptionPane.showMessageDialog(null,
"Este é um exemplo\nde uso de menus", "Sobre",
JOptionPane.PLAIN_MESSAGE);
// Termina o programa.
else if (e.getSource() == fimItem)
System.exit( 0 );

23 24