Uma aplicação pode ser dividida em duas categorias: MDI e SDI.
Aplicações SDI são compostas de várias telas diferentes, ou seja, cada opção do sistema abre em uma janela diferente. Já as
aplicações MDI abrem todas as telas do sistema dentro de uma única janela, tornando a aplicação mais organizada. Para isso utilizaremos, além do
JFrame, o
JDesktopPane e o
JInternalFrame.
Para criarmos uma aplicação MDI temos que criar um JFrame primeiramente. Ele será a janela em que os demais serão abertos. Vamos criar a classe pública Menu do tipo JFrame e implementar ActionListener para que possamos capturar eventos na barra de menus, que abrirá as janelas de cada módulo da aplicação.
import java.awt.event.*;
import javax.swing.*;
public class Menu extends JFrame implements ActionListener {
//cria barra de menu
private JMenuBar jmPrincipal = new JMenuBar();
//cria menu "cadastro" na barra de menu
private JMenu jmCadastro = new JMenu("Cadastros");
//cria item "cliente" dentro do menu "cadastro"
private JMenuItem jmCadCliente = new JMenuItem("Cliente");
private JMenuItem jmCadFornecedor = new JMenuItem("Fornecedor");
//cria objeto jdPane, do tipo JDesktopPane. Ele vai dentro d JFrame
public JDesktopPane jdPane = new JDesktopPane();
Tela telaCadCliente, telaCadFornecedor, telaCadProduto;
//método main instancia o objeto menu A inicialização fica com o construtor da classe
public static void main(String args[]) {
Menu menu = new Menu();
}
O código acima cria uma classe pública chamada Menu, onde colocamos uma barra de menu com a opção "cadastro" (JMenu) e com as opções "cliente" e "fornecedor" (JMenuItem).
Criamos também uma variável jdPane do tipo JDesktopPane e 3 variáveis: telaCadCliente, telaCadFornecedor e telaCadProduto. A variável jdPane será nosso JDesktopPane e as demais serão JInternalFrame. O JDesktopPane será colocado "dentro" do JFrame. Dentro dele serão colocados todos os JInternalFrame que criarmos.
As variáveis telaCadCliente, telaCadFornecedor e telaCadProduto serão do tipo JInternalFrame e serão colocadas dentro do JDesktopPane, fazendo com que elas sejam abertas dentro da janela principal da aplicação. Nossos JInternalFrame são do tipo Tela. Esse é o nome da classe que usaremos para instanciá-los, ou seja, criaremos uma classe do tipo JInternalFrame e instanciaremos quantas telas quisermos. Esse é o lado bom da orientação a objetos :) .
Abaixo temos o construtor da classe Menu que, entre outras tarefas, coloca o JDesktopPane dentro do JFrame.
//método construtor da aplicação
public Menu() {
//"pegue o conteúdo do painel" - adiciona o jDesktopPane ao JFrame (janela principal
getContentPane().add(jdPane);
//adiciona o menu cadastro à barra de menus (jmPrincipal)
jmPrincipal.add(jmCadastro);
//adiciona o item cliente ao menu cadastro
jmCadastro.add(jmCadCliente);
//adiciona o item fornecedor ao menu cadastro
jmCadastro.add(jmCadFornecedor);
//"ajusta" a barra de menu dentro da janela principal
setJMenuBar(jmPrincipal);
//adiciona actionlistener ao item "cliente" do menu,
//para que os eventos sejam tratados
jmCadCliente.addActionListener(this);
//adiciona o actionlistener ao item "fornecedor do menu
jmCadFornecedor.addActionListener(this);
setSize(800,600);
setVisible(true);
}
Dica: deixe sempre o setVisible() por último. Assim ele só mostrará a tela quando terminar de criá-la, evitando muitos erros e comportamentos indesejáveis. :)