Interfaz en Java

Incluso el código de un programa Java básico con interfaz gráfica es relativamente complejo, pero he diseñado una pequeña aplicación muy simple para ilustrar el funcionamiento de las ventanas, los controles y los eventos.
Antes de pasarte el código, te voy a explicar cómo funcionan las interfaces gráficas en Java:
Tanto las ventanas como los controles (botones, áreas de texto,...) son instancias de clases definidas en Java. Estos objetos reciben acciones, como el clic del ratón o la pulsación de una tecla, y deben responder adecuadamente. Estas acciones se llaman eventos.
Pero, en principio, el objeto no sabe qué hacer cuando recibe un evento. Para tomar esta decisión, existen los "listeners" u oyentes, que se asocian a uno o más controles y detectan cualquier evento que se produce sobre ellos para dar una respuesta deseada (por ejemplo, cerrar la ventana).
Por tanto, cualquier programa Java necesita al menos tres librerías fundamentales:
java. Awt, que permite crear ventanas.
java. Awt. Event, que aporta mecanismos de detección de eventos.
Javax. Swing, que proporciona controles como cajas de texto, botones,...
El código del programa es el siguiente:
// Ventana.java
// Ejemplo de aplicación en Java que trata de ilustrar el proceso de
// creación de ventanas y controles y manejo de eventos.
// Se añaden oyentes de eventos para gestionar el clic del ratón
// tanto sobre el botón de cierre de la esquina de la ventana como
// sobre el botón central de la misma.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
// Ventana (clase principal)
public class Ventana {
// main
public static void main(String[] args) {
JFrame vent = new JFrame(); // Una ventana
JButton btnCerrar = new JButton("Cerrar"); // Un botón
Container cnt = vent.getContentPane(); // Contenedor de la ventana
// Propiedades del botón
btnCerrar.addActionListener(new OyenteBoton());
// Añadir botón a la ventana:
cnt.add(btnCerrar);
// Propiedades de la ventana
vent.setLocation(100, 100);
vent.setSize(400, 300);
vent.setTitle("Hola, mundo");
// Un Layout es la forma en que los controles se colocan
// en la ventana a medida que se añaden. FlowLayout
// coloca cada control a continuación del anterior.
vent.setLayout(new FlowLayout());
// Añadir el oyente a la ventana y mostrarla:
vent.addWindowListener(new OyenteVentana());
vent.setVisible(true);
}
}
// Oyente de la ventana
class OyenteVentana extends WindowAdapter {
// Oyente del evento de cierre de ventana
public void windowClosing(WindowEvent e) {
System.exit(0); // Salir del programa
}
}
// Oyente del botón
class OyenteBoton implements ActionListener {
// Oyente del evento de clic en el botón
public void actionPerformed(ActionEvent e) {
// Si el texto del control es "Cerrar",
// el programa termina.
if (e.getActionCommand() == "Cerrar")
System.exit(0);
}
}
Puedes aprender más sobre creación de ventanas en la siguiente dirección:
http://www.ulpgc.es/otros/tutoriales/java/Cap4/awt.html
Espero haberte ayudado. Suerte.

Te recomiendo que visites el tutorial de Swing, es lo mejor que hay para aprender a usar los componentes gráficos de java para crear una interfaz gráfica decente, la página es: http://java.sun.com/docs/books/tutorial/uiswing/
Espero que te sirva y no olvides finalizar la pregunta.

Hablar de interfaz gráfica en un par de lineas no es en absoluto fácil. Si quieres hacer cosas "rapido y fácil" con interfaz gráfica usa NetBeans, tiene una herramienta ("matisse" creo que se llama) que permite crear interfaces gráficas muy rapido y visualmente. Te lo recomiendo, además en la página de NetBeans encontraras algunos tutoriales de como empezar.
En la web debes de buscar Swing, es la forma de crear interfaces gráficas en Java, hay miles de tutoriales.
A modo de resumen, te comento como funciona todo esto.
Para crear interfaces, java usa contenedores, a los contenedores se le van añadiendo elementos y al aplicarle un "Layout" ( un objeto que te lo ordena) se dibuja todo.
Una vez "renderizado" el interfaz, la forma de proceder es usando "eventos". Casi todos los elementos de Swing pueden recibir eventos (click, mouseOver... etc), la forma de procesar estos eventos es usando "listeners". Pondré un ejemplo a ver si soy capaz de explicártelo.
Supongamos una aplicación con un botón.
... JFrame ... {
private JButton boton;
....
}
A esta aplicación queremos que al pulsar el botón nos muestre una salida por consola. Pues en el punto en que estamos definiendo el botón hacemos :
// Definimos el boton y demas
boton.setText("Texto del boton");
...
// Y ahora le asignamos un listener
boton.addActionListener(new ClaseQueImplementaIterfazActionListener());
// listo
A partir de ahora cada vez que se pulse un boton se llamara al método :
actionPerformed(ActionEvent e) ;
de la clase que implementa el intefaz ActionEvent.
Esta es la teoria, podrás encontrarte esto mismo tambien de dos formas :
1 --> boton.addActionListener(this);
2 --> boton.addActionListener (new ActionListener() {
void actionPerformed(ActionEvent e) {
// codigo
}
});
Para el método 1, el mismo JFrame implementa el interfaz ActionListener, por lo que tendrá un método actionPerformed defino que será el que se ejecute cuando se pulse el botón.
Para el método 2, que queda un poco más feo :) pero que suele ser el más utilizado, lo que se hace es crear una "subclase" anónima (sin nombre) dentro de la clase actual, que permite simplificar el proceso.