Java

http://es.wikipedia.org/wiki/Tipo_de_dato_abstracto
Búsqueda en Google sobre TADs árboles

Construyendo el escenario

Creando el árbol

nodoroot
– nodo1 (indice 0)
— nodo1.1 (indice 0)
— nodo1.2 (indice 1)
– nodo2 (indice 1)
— nodo2.1 (indice 0)
—  nodo2.2 (indice 1)

DefaultMutableTreeNode nodoroot, nodo1, nodo11, nodo12, nodo2, nodo21, nodo22;
nodoroot = new DefaultMutableTreeNode("Éste es el nodo principal.");
nodo1 = new DefaultMutableTreeNode("nodo1");
nodo11 = new DefaultMutableTreeNode("nodo11");
nodo12 = new DefaultMutableTreeNode("nodo12");
nodo2 = new DefaultMutableTreeNode("nodo2");
nodo21 = new DefaultMutableTreeNode("nodo21");
nodo22 = new DefaultMutableTreeNode("nodo22");
arbol.setRoot(nodoroot);
arbol.insertNodeInto(nodo1, nodoroot, 0);
arbol.insertNodeInto(nodo2, nodoroot, 1);
arbol.insertNodeInto(nodo11, nodo1, 0);
arbol.insertNodeInto(nodo12, nodo1, 1);
arbol.insertNodeInto(nodo21, nodo2, 0);
arbol.insertNodeInto(nodo22, nodo2, 1); 

btnCargarrbolDe.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent arg0) {

		DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
		DefaultMutableTreeNode nroot = new DefaultMutableTreeNode("Árbol de directorios");

		arbol.setRoot(nroot);

		CargaEstructuraDirectorios(arbol, nroot, "/");
	}
});

private void CargaEstructuraDirectorios(DefaultTreeModel arbol, DefaultMutableTreeNode padre, String ruta) {
	DefaultMutableTreeNode aux = null;

	File archivo = new File(ruta);
	File[] archivos = archivo.listFiles();

	if (archivos != null) {
		for (int i = 0; i < archivos.length; i++) {

			aux = new DefaultMutableTreeNode(archivos[i].getName());
			arbol.insertNodeInto(aux, padre, i);

			if (archivos[i].isDirectory()) {
				try {
					CargaEstructuraDirectorios(arbol, aux, archivos[i].getAbsolutePath() + "/");
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
			}

		}

	}
}

Borrar un nodo

Click, empieza el juego

final JTree tree = new JTree();
tree.addTreeSelectionListener(new TreeSelectionListener() {
	public void valueChanged(TreeSelectionEvent e) {
		DefaultMutableTreeNode nseleccionado = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
		JOptionPane.showMessageDialog(frame, nseleccionado.getPath());
	}
});

Códigos del ejemplo

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.event.TreeModelListener;
import javax.swing.JButton;
import javax.swing.JTree;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.io.File;
import javax.swing.JScrollPane;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeSelectionEvent;

// La clase principal
public class Principal extends JFrame {

	// el panel contenedor
	private JPanel contentPane;
	// el JFrame
	static Principal frame;

	/**
	 * esta es la función que primero se ejecuta creando el JFRame y visualizándolo
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					frame = new Principal();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * la creación del JFrame principal donde está programado todo lo de éste ejemplo
	 */
	public Principal() {
		// título de ventana
		setTitle("Java Swing 8 El JTree by Jnj");
		// operación al cerra el JFrame
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// dimensiones y posición en el escritorio
		setBounds(100, 100, 450, 306);
		// se crea el panel
		contentPane = new JPanel();
		// los bordes
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		// se establece
		setContentPane(contentPane);
		contentPane.setLayout(null);

		// se pone el botón en la ventana
		JButton btnCargarrbolDe = new JButton(
				"Cargar u00E1rbol de directorios");
		btnCargarrbolDe.setBounds(10, 11, 200, 23);
		contentPane.add(btnCargarrbolDe);

		// las barras de escroll para el JTree
		JScrollPane scrollPane = new JScrollPane();
		scrollPane.setBounds(10, 45, 414, 206);
		contentPane.add(scrollPane);

		// el JTree
		final JTree tree = new JTree();
		// que captura el evento click
		tree.addTreeSelectionListener(new TreeSelectionListener() {
			public void valueChanged(TreeSelectionEvent e) {
				// se obtiene el nodo seleccionado
				DefaultMutableTreeNode nseleccionado = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
				// visualiza el path del nodo
				JOptionPane.showMessageDialog(frame, nseleccionado.getPath());
			}
		});
		// se pone el árbol en el panel de las barras de scroll
		scrollPane.setViewportView(tree);

		// aquí el botón que borra el último elemento de los primeros hijos
		// es decir, desde el nodo root, borra sólo el último hijo
		JButton btnBorrarltimoNodo = new JButton("Borrar u00FAltimo nodo");
		btnBorrarltimoNodo.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {

				DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
				DefaultMutableTreeNode padre = (DefaultMutableTreeNode) arbol.getRoot();
				int numeroDeHijos = arbol.getChildCount(padre);

				// borra el último hijo del padre
				arbol.removeNodeFromParent((MutableTreeNode) arbol.getChild(
						padre, numeroDeHijos - 1));
			}
		});
		btnBorrarltimoNodo.setBounds(220, 11, 204, 23);
		contentPane.add(btnBorrarltimoNodo);

		// evento click del botón de carga del árbol
		// simplemente añade el nodo root y llama a la función de carga
		// para añadir todos los nodos hijos al nodo root
		btnCargarrbolDe.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {

				DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
				DefaultMutableTreeNode nroot = new DefaultMutableTreeNode(
						"Árbol de directorios");

				arbol.setRoot(nroot);

				CargaEstructuraDirectorios(arbol, nroot, "/");

			}
		});
		
	
	}

	// función recursiva que lista todos los directorios y subdirectorios
	// a partir de una ruta, añadiéndolos a la estructura en árbol
	private void CargaEstructuraDirectorios(DefaultTreeModel arbol,
			DefaultMutableTreeNode padre, String ruta) {
		DefaultMutableTreeNode aux = null;

		File archivo = new File(ruta); // puntero al directorio de la ruta
		File[] archivos = archivo.listFiles(); // lista todos los archivos de la ruta

		// recorre lo que hay en la ruta
		if (archivos != null) {
			for (int i = 0; i < archivos.length; i++) {

				// creando un nodo con cada cosa del directorio
				aux = new DefaultMutableTreeNode(archivos[i].getName());
				// inserta el nodo hijo 
				arbol.insertNodeInto(aux, padre, i);

				// si encontramos un directorio volvemos a hacer lo mismo con sus hijos
				if (archivos[i].isDirectory()) {
					try {
						
						// llamando recursivamente de nuevo a ésta misma función
						CargaEstructuraDirectorios(arbol, aux,
								archivos[i].getAbsolutePath() + "/");
						
					} catch (Exception e) {
						System.out.println(e.getMessage()); // por si acaso le he puesto un try xD
					}
				}

			}

		}
	}
	
	// termina la creación del frame
}

// fin de la clase

Un saludo.

JLabel

JTextField

JComboBox

JButton

btnBotn.addActionListener(new ActionListener() {
 public void actionPerformed(ActionEvent arg0) {
  JOptionPane.showMessageDialog(frame, "Ésto es un botón simple.");
 }
});

JCheckBox

JRadioButton

ButtonGroup radioGroup = new ButtonGroup();
radioGroup.add(rdbtn1);
radioGroup.add(rdbtn2);

JToggleButton

JTextArea

txtrAreaDeTexto.setText("Arearnderntexto.");

JPasswordField

JSpinner

JList

entero = list.getSelectedIndex();
vectorDeEnteros = list.getSelectedIndices();
elemento = list.getSelectedValue();
vectorDeElementos = list.getSelectedValues();

JProgressBar

JScrollBar

JSlider

slider.addChangeListener(new ChangeListener() {
 public void stateChanged(ChangeEvent arg0) {
  progressBar.setValue(slider.getValue());
  scrollBar.setValue(slider.getValue());
 }
});

JSeparator

Terminando

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;

import javax.swing.AbstractListModel;
import javax.swing.ButtonGroup;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JProgressBar;
import javax.swing.JRadioButton;
import javax.swing.JScrollBar;
import javax.swing.JSeparator;
import javax.swing.JSlider;
import javax.swing.JSpinner;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JToggleButton;
import javax.swing.SwingConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

// ÉSTO ES LA CLASE PRINCIPAL QUE EXTIENDE DE JFRAME...
public class Principal extends JFrame {

 private JPanel contentPane;
 private JTextField txtCajaDeTexto;
 static Principal frame;
 private JPasswordField passwordField;

 // la función que primero se ejecuta que crea 
 // el frame en memoria...
 public static void main(String[] args) {
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     frame = new Principal();
     // ... y lo visualiza
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // aquí está el constructor de la clase que todo
 // lo programa...
 public Principal() {
  // se contruye la ventana
  setTitle("JavaSwing 6 Componentes bu00E1sicos by Jnj");
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  setBounds(100, 100, 458, 363);
  contentPane = new JPanel();
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  setContentPane(contentPane);
  contentPane.setLayout(null);
  
  // la etiqueta
  JLabel lblEtiqueta = new JLabel("Etiqueta");
  lblEtiqueta.setBounds(10, 11, 67, 14);
  contentPane.add(lblEtiqueta);
  
  // la caja de texto
  txtCajaDeTexto = new JTextField();
  txtCajaDeTexto.setText("Caja de texto");
  txtCajaDeTexto.setBounds(10, 36, 152, 20);
  contentPane.add(txtCajaDeTexto);
  txtCajaDeTexto.setColumns(10);
  
  // el cuadro combinado
  JComboBox comboBox = new JComboBox();
  // los elementos
  comboBox.setModel(new DefaultComboBoxModel(new String[] {"Elemento 1", "Elemento 2", "Elemento 3"}));
  // comienza seleccionado el elemento 1
  comboBox.setSelectedIndex(1);
  comboBox.setBounds(10, 67, 191, 20);
  contentPane.add(comboBox);
  
  // el botón
  JButton btnBotn = new JButton("Botu00F3n");
  // cuando se pulsa hace ésto
  btnBotn.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    JOptionPane.showMessageDialog(frame, "Ésto es un botón simple.");
   }
  });
  btnBotn.setBounds(53, 95, 89, 23);
  contentPane.add(btnBotn);
  
  // la casilla de verificación  
  JCheckBox chckbx = new JCheckBox("Casilla de verificaciu00F3n");
  chckbx.setSelected(true);
  chckbx.setBounds(10, 125, 191, 23);
  contentPane.add(chckbx);
  
  // los botones de radio
  JRadioButton rdbtn1 = new JRadioButton("RadioButton 1");
  rdbtn1.setBounds(10, 151, 109, 23);
  contentPane.add(rdbtn1);
  
  JRadioButton rdbtn2 = new JRadioButton("RadioButton 2");
  rdbtn2.setBounds(10, 177, 109, 23);
  contentPane.add(rdbtn2);
  
  // el grupo para los botones
  ButtonGroup radioGroup = new ButtonGroup();
  radioGroup.add(rdbtn1);
  radioGroup.add(rdbtn2);
  
  // otras casillas de verificación que se van a agrupar
  // para ver el comportamiento
  JCheckBox chckbx1 = new JCheckBox("CheckBox 1 agrupado");
  chckbx1.setBounds(10, 203, 166, 23);
  contentPane.add(chckbx1);
  
  JCheckBox chckbx2 = new JCheckBox("CheckBox 2 agrupado");
  chckbx2.setBounds(10, 229, 152, 23);
  contentPane.add(chckbx2);
  
  // el grupo para las casillas de verificación
  ButtonGroup chkGroup = new ButtonGroup();
  chkGroup.add(chckbx1);
  chkGroup.add(chckbx2);
  
  // el botón de activación
  JToggleButton tglbtn = new JToggleButton("Botu00F3n de activaciu00F3n");
  // que está seleccionado inicialmente
  tglbtn.setSelected(true);
  tglbtn.setBounds(10, 259, 166, 23);
  contentPane.add(tglbtn);
  
  // el área de texto
  JTextArea txtrAreaDeTexto = new JTextArea();
  // con una linea en el borde
  txtrAreaDeTexto.setBorder(new LineBorder(new Color(0, 0, 0)));
  // tres lineas de texto permitidas
  txtrAreaDeTexto.setRows(3);
  // el texto
  txtrAreaDeTexto.setText("Arearnderntexto.");
  txtrAreaDeTexto.setBounds(224, 11, 205, 58);
  contentPane.add(txtrAreaDeTexto);
  
  // el texto de contrasela
  passwordField = new JPasswordField();
  passwordField.setBounds(224, 80, 152, 20);
  // contraseña inicial
  passwordField.setText("supercontraseña");
  contentPane.add(passwordField);

  // el llamado 'hilandero'
  JSpinner spinner = new JSpinner();
  spinner.setBounds(224, 111, 101, 20);
  contentPane.add(spinner);
  
  // la lista 
  JList list = new JList();
  // la declaración de los elementos
  list.setModel(new AbstractListModel() {
   String[] values = new String[] {"Elemento 1", "Elemento 2", "Elemento 3"};
   // función que deveuelve el número de elementos
   public int getSize() {
    return values.length;
   }
   // función para acceder a cada elemento
   // por ejemplo usando 
   //
   //   list.getModel().getElementAt(1)
   //
   // nos devolverá el elemento "Elemento 2"
   public Object getElementAt(int index) {
    return values[index];
   }
  });
  list.setSelectedIndex(1);
  list.setBounds(224, 142, 67, 52);
  contentPane.add(list);
  
  // el separador
  JSeparator separator = new JSeparator();
  separator.setOrientation(SwingConstants.VERTICAL);
  separator.setBounds(211, 11, 2, 297);
  contentPane.add(separator);
  
  // inicializacion de la barra de progreso,
  // la barra de desplazamiento y el deslizador.
  // los he puesto aquí juntos porque los uso
  // después y era necesario.
  final JProgressBar progressBar = new JProgressBar();
  final JScrollBar scrollBar = new JScrollBar();
  final JSlider slider = new JSlider();
  
  // configuraciones de la barra de progreso
  progressBar.setValue(50);
  progressBar.setBounds(224, 203, 205, 14);
  contentPane.add(progressBar);
  
  // la barra de desplazamiento
  scrollBar.addAdjustmentListener(new AdjustmentListener() {
   public void adjustmentValueChanged(AdjustmentEvent arg0) {
    // mueve a la vez la barra de progreso y el deslizador 
    progressBar.setValue(scrollBar.getValue());
    slider.setValue(scrollBar.getValue());
   }
  });
  // valor inicial
  scrollBar.setValue(50);
  scrollBar.setOrientation(JScrollBar.HORIZONTAL);
  scrollBar.setBounds(224, 233, 205, 23);
  contentPane.add(scrollBar);
  
  // el deslizador, capturando evento
  slider.addChangeListener(new ChangeListener() {
   public void stateChanged(ChangeEvent arg0) {
    // mueve la barra de progreso y la de desplazamiento
    // cada vez que se mueve el deslizador.
    progressBar.setValue(slider.getValue());
    scrollBar.setValue(slider.getValue());
   }
  });
  // valores para que salga la regla numerada
  slider.setMinorTickSpacing(1);
  slider.setMajorTickSpacing(10);
  slider.setToolTipText("");
  slider.setPaintTicks(true);
  slider.setPaintLabels(true);
  slider.setBounds(224, 267, 200, 52);
  contentPane.add(slider);
  
 } // termina el constructor de la ventana
}  // termina la clase

Estoy pegándole un repaso a todo lo referente a los menús con Swing usando Eclipse. No deja de sorprenderme lo fácil y rápido que lo tenemos una vez que te has familiarizado con Eclipse, y en concreto con el Swing Designer. En pocos minutos tenemos nuestro esqueleto de la aplicación listo para codificar sus funciones o encajarlo con códigos ya hechos, cada uno para lo que lo necesite…

Para todo ésto he usado la zona del Swing Designer que vemos a continuación:

Para hacer la estructura del ejemplo he puesto los siguientes componentes todos dentro del JMenuBar:

Archivo (JMenu)
– Poner título (JMenuItem)
– Barra separadora (JSeparator)
– Un JCheckBoxMenuItem (JCheckBoxMenuItem)
– Un JRadioButtonMenuItem (JRadioButtonMenuItem)
– Otro JRadioButtonMenuItem (JRadioButtonMenuItem)
– Salir (JMenuItem)
Colores (JMenuItem)
– Blanco (JMenuItem)
– Negro (JMenuItem)
– Cambiar el color de fondo con otros colores (JMenu)
— Verde (JMenuItem)
— Rojo (JMenuItem)
— Azul (JMenuItem)
Minimizar (JMenuItem)

En el JPopupMenu que pone ¡Hola! ¡Feliz Navidad! simplemente hay dos JMenuItem. En medio de la ventana he puesto un JSeparator para mostrar que se puede poner no sólo como un elemento de menú. Y luego tenemos un JLabel con la frase explicatoria.

Sólo hay que ponerse a juguetear con el Swing Designer y seguro que bien rápido que se le coge el truco.

Queda añadir cómo hacer que haga algo al hacer click, ésto se llama ponerle un manejador de evento, en éste caso al evento click del ratón. De nuevo usando el Swing Designer, que para eso está, para hacernos la vida más fácil xD le damos en cualquier componente Swing con el botón derecho y nos sale un menú desplegable como el siguiente:

En la opción ‘Add event handler’ tenemos todos los eventos disponibles que podemos asociar con casi cualquier componente. El que nos interesa ahora es el mousePressed que significa apretar el ratón, que en la imagen de arriba ya sale programado, por eso pone -> line 110, porque está en la línea 110 del código fuente. Ésto lo hacemos para cada cosa que queramos que haga algo al hacer click y al darle a mousePressed nos dirigirá al código para que lo programemos, creando el esqueleto del programa asociado a dicho evento del ratón.

Los elementos JCheckBoxMenuItem y JRadioButtonMenuItem también tienen el evento del click de ratón, y podemos usar una propiedad llamada ‘selected’ para saber si estan seleccionados o no y hacer lo correspondiente en cada caso.

Aquí tienes el código del ejemplo:

// el paquete del programa
package principal;

// las librerias de java para hacer todo...
import java.awt.Color;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.Frame;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JSeparator;
import javax.swing.border.EmptyBorder;

// la clase principal
public class Principal extends JFrame {

 // el panel que todo lo contiene
 private JPanel contentPane;

 // la entrada al programa, lo que primero
 // se ejecuta
 public static void main(String[] args) {
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     // crea el frame en memoria
     // y lo visualiza
     Principal frame = new Principal();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // ésto es el constructor de la clase
 // aquí está todo
 public Principal() {

  // al cerrar la ventana sale del programa
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  // dimensiones y posición al arrancar del JFrame
  setBounds(100, 100, 450, 300);

  // la barra de menú
  JMenuBar menuBar = new JMenuBar();
  setJMenuBar(menuBar);

  // el menú Archivo empieza aquí ---------------------------------------
  JMenu mnArchivo = new JMenu("Archivo");
  menuBar.add(mnArchivo);

  JMenuItem mntmPonerTtulo = new JMenuItem("Poner tu00EDtulo");
  mntmPonerTtulo.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    setTitle("Java Swing 5: Menús by jnj");
   }
  });
  mnArchivo.add(mntmPonerTtulo);

  JMenuItem mntmSalir_1 = new JMenuItem("Salir");
  mntmSalir_1.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    dispose();
   }
  });

  JSeparator separator_1 = new JSeparator();
  mnArchivo.add(separator_1);

  JCheckBoxMenuItem chckbxmntmUnJcheckboxmenuitem = new JCheckBoxMenuItem(
    "Un JCheckBoxMenuItem");
  mnArchivo.add(chckbxmntmUnJcheckboxmenuitem);

  JRadioButtonMenuItem rdbtnmntmUnJradiobuttonmenuitem = new JRadioButtonMenuItem(
    "Un JRadioButtonMenuItem");
  mnArchivo.add(rdbtnmntmUnJradiobuttonmenuitem);

  JRadioButtonMenuItem rdbtnmntmOtroJradiobuttonmenuitem = new JRadioButtonMenuItem(
    "Otro JRadioButtonMenuItem");
  mnArchivo.add(rdbtnmntmOtroJradiobuttonmenuitem);
  mnArchivo.add(mntmSalir_1);

  // el menú Colores empieza aquí ---------------------------------------
  JMenu mnColores = new JMenu("Colores");
  menuBar.add(mnColores);

  JMenuItem mntmBlanco = new JMenuItem("Blanco");
  mntmBlanco.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.WHITE);
   }
  });
  mnColores.add(mntmBlanco);

  JMenuItem mntmNegro = new JMenuItem("Negro");
  mntmNegro.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.BLACK);
   }
  });
  mnColores.add(mntmNegro);

  JMenu mnCambiarElColor = new JMenu(
    "Cambiar el color de fondo con otros colores");
  mnColores.add(mnCambiarElColor);

  JMenuItem mntmVerde = new JMenuItem("Verde");
  mntmVerde.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.GREEN);
   }
  });
  mnCambiarElColor.add(mntmVerde);

  JMenuItem mntmRojo = new JMenuItem("Rojo");
  mntmRojo.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.RED);
   }
  });
  mnCambiarElColor.add(mntmRojo);

  JMenuItem mntmAzul = new JMenuItem("Azul");
  mntmAzul.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.BLUE);
   }
  });
  mnCambiarElColor.add(mntmAzul);

  // el elemento del menú para minimizar está aquí ---------------------------------------
  JMenuItem mntmNewMenuItem = new JMenuItem("Minimizar");
  menuBar.add(mntmNewMenuItem);
  mntmNewMenuItem.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    setState(Frame.ICONIFIED);
   }
  });
  
  // aquí termina la barra de menú ...
  
  
  // el panel que todo lo contiene se crea
  contentPane = new JPanel();
  // se le pone un borde
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  // se establece en el JFrame
  setContentPane(contentPane);

  // se hace JPopupMenu y lo pongo en el panel contenedor
  JPopupMenu popupMenu = new JPopupMenu();
  popupMenu.setBounds(0, 0, 319, 58);
  addPopup(contentPane, popupMenu);

  // el primer elemento del desplegable
  JMenuItem mntmhola = new JMenuItem("u00A1Hola!");
  popupMenu.add(mntmhola);

  // el segundo elemento del desplegable
  JMenuItem mntmfelizNavidad = new JMenuItem("u00A1Feliz Navidad!");
  popupMenu.add(mntmfelizNavidad);
  
  // el resto del JPanel con la raya separadora y la etiqueta explicatoria  
  contentPane.setLayout(null);

  JSeparator separator = new JSeparator();
  separator.setBounds(31, 88, 372, 24);
  contentPane.add(separator);

  JLabel lblHazClickCon = new JLabel(
    "Haz click con el botu00F3n derecho en la ventana para que salga el menu00FA.");
  lblHazClickCon.setBounds(10, 118, 414, 76);
  contentPane.add(lblHazClickCon);
 }

 // ésto es lo relativo al menú desplegable
 // lo que hace es mostrar éste menú donde sea que hagamos click 
 private static void addPopup(Component component, final JPopupMenu popup) {
  component.addMouseListener(new MouseAdapter() {
   public void mousePressed(MouseEvent e) {
    if (e.isPopupTrigger()) {
     showMenu(e);
    }
   }

   public void mouseReleased(MouseEvent e) {
    if (e.isPopupTrigger()) {
     showMenu(e);
    }
   }

   private void showMenu(MouseEvent e) {
    popup.show(e.getComponent(), e.getX(), e.getY());
   }
  });
 }
}

Y también como viene siendo costumbre el fichero con todo…

Un saludo!

Para hacer un programa con pestañas repartiendo así los componentes se hace fácil con Swing y Eclipse. En pocos minutos, usando el generador de código esqueleto y con el Swing Designer te genera código.

Antes de poner el código, a saber, con el Swing Designer lo que tendremos será la ventana vacía, para poder posicionar los elementos tenemos que añadir en medio un Absolute layout. Luego dibujamos donde va a ir con el JTabbedPane. Después tenemos que añadir dos paneles encima del JTabbedPane, es decir, dos JPanel normales y corrientes. Las pestañas las creará el JTabbedPane cuando añadimos los paneles. Entonces ya tenemos las pestañas creadas, pero tenemos que decirle, en cada pestaña cómo vamos a posicionar los elementos y ponemos otros Absolute layout, uno en cada pestaña. Ahroa ya tenemos las pestañas y además podremos poner los elementos en la zona de la pestaña en que queramos, que en éste caso es una etiqueta JLabel en cada pestaña.

Aquí está el código:

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.border.EmptyBorder;

// Ésta es la clase principal
// es un JFrame...
public class Principal extends JFrame {

 // el panel principal donde se pone todo
 private JPanel contentPane;
 
 // ejecuta primero todo ésto
 public static void main(String[] args) {
  // arranca en un hilo de ejecución... 
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     // creando el frame y lo muestra
     Principal frame = new Principal();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // Constructor de la clase: se configura aquí toda 
 // la ventana y los controles...
 public Principal() {
  
  // título de la ventana
  setTitle("Pestau00F1as con Swing by jnj");
  // operación al cerra la ventana 
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  // coordenadas de las esquinas del frame en el escritorio
  setBounds(100, 100, 419, 234);
  
  // el panel que contiene todo se crea y se pone en el frame
  contentPane = new JPanel();
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  setContentPane(contentPane);
  // distribución nula para poder posicionar los elementos
  // en las coordenadas que queramos
  contentPane.setLayout(null);
  
  // se crea el panel de pestañas
  JTabbedPane panelDePestanas = new JTabbedPane(JTabbedPane.TOP);
  // se posiciona en el panel
  panelDePestanas.setBounds(10, 11, 383, 174);
  contentPane.add(panelDePestanas);
  
  // éste es el primer panel
  // que se añade como pestaña al 'tabbedPane'
  JPanel panel1 = new JPanel();
  panelDePestanas.addTab("Panel 1", null, panel1, null);
  // al panel le pongo distribución nula para
  // posicionar los elementos en las coordenadas que
  // quiera
  panel1.setLayout(null);
  
  // una etiqueta en el panel de la pestaña 1
  JLabel lbl1 = new JLabel("Primera pestau00F1a..");
  lbl1.setBounds(10, 11, 348, 14);
  panel1.add(lbl1);
  
  // otro panel de igual forma
  JPanel panel2 = new JPanel();
  panelDePestanas.addTab("Panel 2", null, panel2, null);
  panel2.setLayout(null);
  
  // otra etiqueta ésta vez en el segundo panel
  JLabel lbl2 = new JLabel("Segunda pestau00F1a..");
  lbl2.setBounds(10, 11, 290, 14);
  panel2.add(lbl2);
 }
}

Un saludo!

Para éste microtutorial he usado el Swing Designer de Eclipse y la versión 1.7 update 9 de Java, el JDK y el JRE.

En Eclipse tenemos tenemos varias opciones para generar código esqueleto para nuestro programa. En la ventana del explorador de proyectos, en el lugar elegido le damos con el botón derecho a New -> Other… y nos saldrá una ventana como la siguiente con las opciones disponibles con respecto a Swing:

En el árbol de Swing Designer tenemos las opciones para crear programas con ventanas Swing, valga la redundancia. Todos los códigos generados con el Swing Designer también se pueden crear a mano y se pueden llevar a otros entornos de desarrollo y te van a funcionar. Ésto lo digo porque no ocurre siempre, según en qué entorno de desarrollo estés, a veces pasa que si te sales de él ya no te sirven los códigos porque se les han puesto «extras» que te atan a ellos. Ésto no te va a pasar con los Swing en Eclipse, o por lo menos yo no me encontrado con éste problema.

Vamos al grano…

Application Window

Si elegimos una Application Window nos va a crear la clase siguiente:

package pruebasSwing;

import java.awt.EventQueue;
import javax.swing.JFrame;

public class ApplicationWindowPrueba {

    private JFrame frame;

    // primero se ejecuta ésto…
    public static void main(String[] args) {
        // en un hilo de ejecución aparte hace todo
        // porque todo lo hace en un new Runnable
        // a continuación…
        EventQueue.invokeLater(new Runnable() {
            // run es el método que se ejecuta
            // al arrancar el hilo
            public void run() {
                try {
                    // crea una variable de la clase y se inicializa
                    // con el constructor de la misma                  
                    ApplicationWindowPrueba window = new ApplicationWindowPrueba();
                    // muestra la ventana
                    window.frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // éste es el constructor de la clase
    public ApplicationWindowPrueba() {
        initialize();
    }

    // la función que inicializa
    private void initialize() {
        // crea el frame
        frame = new JFrame();
        // coordenadas de la ventana
        frame.setBounds(100, 100, 450, 300);
        // establece la operación a ejecutar cuando
        // se cierra el JFrame
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

}

Se trata de una clase que no hereda de ninguna otra, y lo que simplemente hace es crear un JFrame en un hilo de ejecución separado.

JApplet

Un Applet es una programa de Java que se ejecuta en un navegador de Internet. Éste programa se le envía al cliente mientras que navega y se ejecuta en su máquina. Nos crea lo básico para hacer uno, pero a fecha de hoy están totalmente en desuso y los navegadores los desactivan por defecto.. Así que mejor ni probarlo…

package pruebasSwing;

import javax.swing.JApplet;

// clase que extiende de JApplet,
// que a su vez extiende de la clase
// Applet y ésta en sí es un Panel…
public class JAppletPrueba extends JApplet {

    // el constructor
    public JAppletPrueba() {

    }
}

JDialog

Con ésta opción generaremos el código para hacer un típico cuadro de diálogo con el usuario para que se le informe de algo o elija entre las opciones que queramos. Éste tipo de ventanas se usan asociadas a otra ventana padre, aunque al tener un main se puede generar un .jar ejecutable que sólo tenga un cuadro de diálogo de éstos.

El código que genera:

package pruebasSwing;

import java.awt.BorderLayout;
import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

// la clase que extiende de JDialog,
// que a su vez extiende de Dialog,
// y ésta de Window…
public class JDialogPrueba extends JDialog {

    private final JPanel contentPanel = new JPanel();

    public static void main(String[] args) {
        try {
            // crea un nuevo objeto de la clase
            JDialogPrueba dialog = new JDialogPrueba();
            // operacion al cerrar
            dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            // lo muestra
            dialog.setVisible(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // constructor de la clase
    public JDialogPrueba() {
        // propiedades de la ventana
        setBounds(100, 100, 450, 300);
        getContentPane().setLayout(new BorderLayout());
        contentPanel.setLayout(new FlowLayout());
        contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
        getContentPane().add(contentPanel, BorderLayout.CENTER);
       
        // los botones para confirmar o cancelar
        {
            JPanel buttonPane = new JPanel();
            buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT));
            getContentPane().add(buttonPane, BorderLayout.SOUTH);
            {
                JButton okButton = new JButton(«OK»);
                okButton.setActionCommand(«OK»);
                buttonPane.add(okButton);
                getRootPane().setDefaultButton(okButton);
            }
            {
                JButton cancelButton = new JButton(«Cancel»);
                cancelButton.setActionCommand(«Cancel»);
                buttonPane.add(cancelButton);
            }
        }
    }

}

JFrame

Con el asistente del JFrame, hace casi lo mismo que con el de Application Window, pero hay dos ligeras diferencias. La primera es que con Application Window tenemos una variable interna a la clase que es el JFrame, y con el éste lo que tenemos es que la clase misma extiende a JFrame, con lo que realmente tenemos un JFrame en sí que se puede reutilizar en otros lugares del programa. La segunda diferencia es que añade un JPanel al JFrame, cosa que con el asistente de Application Window no lo hace.

El código es el siguiente:

package pruebasSwing;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

// la clase extiende de JFrame, realmente ES un JFrame
public class JFramePrueba extends JFrame {

    private JPanel contentPane;

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    JFramePrueba frame = new JFramePrueba();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public JFramePrueba() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        // añade el panel…
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);
    }

}

JInternalFrame

Ésta clase se usa para hacer ventanas que se ejecutan dentro de un JDesktopPane. Es decir, dentro de la misma ventana padre, tendremos una zona que será un panel de escritorio, el anterior JDesktopPane. Y en éste panel es donde veremos el JInternalFrame. Así que necesitaremos un JFrame padre para poder ejecutarlo dentro.

Ésta clase tiene un main pero no se puede ejecutar en un .jar aparte.

El código:

package pruebasSwing;

import java.awt.EventQueue;
import javax.swing.JInternalFrame;

public class JInternalFramePrueba extends JInternalFrame {

    // arranca en un hilo el formulario hijo
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    JInternalFrame frame = new JInternalFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // aquí estará construida la ventana
    public JInternalFramePrueba() {
        setBounds(100, 100, 450, 300);

    }

}

JPanel

Ésto es una clase básica que podemos usar en otros formularios o ventanas. Es decir, podemos poner paneles dentro de JFrames. Así que puede ser útil tener un panel programado aparte. El código que genera es:

package pruebasSwing;

import javax.swing.JPanel;

public class JPanelPrueba extends JPanel {

    // constructor de la clase
    public JPanelPrueba() {

    }

}

Swing Automatic Databinding

Aquí tenemos un asistente que nos va a crear lo necesario para crear una ventana con Databindings. Necesitaremos un Bean, y configurar las diversas opciones. Ésto es bastante extenso así que ya tengo tema para otro post.. 🙂

Terminando

Las principales clases que primero se van a usar van a ser la ApplicationWindow o la JFrame. De éstas la JFrame es bueno usarla de un principio porque luego la puede incluir dentro de otros proyectos sin muchos cambios.

Dentro de Eclipse podemos visualizar todos los anteriores con F11, menos el JInternalFrame y el JPanel que se podrá visualizar dentro de otro. Una vez generado el código correspondiente, podremos entrar a editar el diseño visualmente, con lo que nos ahorraremos un considerable esfuerzo.

Con ésto me voy a la cama y mañana más…

Un saludo!

Estado actual

Contenedores externos

1. JFrame -> es la madre del cordero, la clase que normalmente se usa para que contenga el resto de componentes, es la principal.
2. JApplet -> para construir un applet.
3. JDesktopPane -> crea una zona donde podemos poner ventanas internas (JInternalFrame).
4. JDialog -> es una ventana de diálogo.
5. JInternalFrame -> ventana hija que debe estar dentro de un escritorio (JDesktopPane).
6. JLayer -> crea un borde alrededor de otro componente.
7. JLayeredPane -> es un panel con borde.
8. JPanel -> un panel simple sin adornos ni nada.
9. JRootPane -> panel principal que puede contener otros objetos.
10. JScrollPane -> es un panel que sirve para contener objetos que se salen del campo, entonces con barras de scroll podemos movernos por ellos.
11. JSplitPane -> sirve para dividir una zona en dos, en cada subdivisión podemos poner otros elementos.
12. JTabbedPane -> parecido al JSplitPane pero divide las zonas en pestañas.
13. JViewPort -> es un objeto que sirve para visualizar los otros objetos que se mueven en una ventana, como por ejemplo con barras de scroll.
14. JWindow -> es como un JFrame pero sin bordes ni botones para cerrar, maximizar y minimizar.

El resto de componentes

1. JButton -> para hacer botones.
2. JCheckBox -> cajas chequeables.
3. JComboBox -> pues el combo de siempre, creo que se llama «caja de selección desplegable».
4. JLabel -> para poner etiquetas.
5. JList -> implementa una lista seleccionable.
6. JOptionPane -> panel donde podemos poner opciones a elegir.
7. JPasswordField -> campo de contraseña.
8. JProgressBar -> barras de progreso.
9. JRadioButton -> estos son los elementos que dan varias opciones a elegir, en la que sólo una es posible.
10. JEditorPane -> para poner textos complejos, admite HTML y  texto en el formato Rich Text Format (RTF).
11. JFormattedTextField -> para poner textos con formato.
12. JTextArea -> areas de texto donde podemos poner textos grandes, multilínea.
13. JTextField -> areas de textos pequeños, de una sola linea de texto.
14. JTextPane -> admite textos formateados, iconos y componentes.

1. JColorChooser -> nos sirve para mostrar una ventana donde podemos elegir un color.
2. JFileChooser -> éste objeto es una ventana para elegir un archivo.

1. JMenu -> ésto es un menú que podemos poner dentro de una barra de menú o dentro de otro menú.
2. JMenuBar -> barra de menús, dentro de ésta se ponen el resto de los elementos de los menús.
3. JMenuItem -> es un elemento de menú.
4. JCheckBoxMenuItem -> cajas de texto seleccionable en un menú.
5. JPopupMenu -> implementa un menú desplegable.
6. JRadioButtonMenuItem -> para poner opciones a elegir en un menú.
7. JSeparator -> es una raya entre elemento y elemento de menú.

1. JToolBar -> es una barra de herramientas para personalizar.
2. JToolTip -> muestra un texto al pasar por encima de un componente.
3. JScrollBar -> barras de scroll.
4. JSlider -> es una barra que puedes mover arriba y abajo con la que elijes un valor.
5. JSpinner -> es una caja de texto con dos botones arriba y abajo para cambiar el valor de la caja.
6. JToggleButton -> botón con dos estados, presionado y no presionado.
7. JTable -> se usa para mostrar tablas de datos, como su nombre indica.
8. JTree -> es un árbol, que puede servir para mostrar por ejemplo un árbol de directorios.