Caso de estudio de GUI y gráficos: uso de cuadros de diálogo

Este caso de estudio está diseñado para empezar a conocer las poderosas herramientas de Java para crear interfaces gráficas de usuario (GUI) y gráficos.


Cada sección introduce unos cuantos conceptos básicos y proporciona ejemplos con capturas de pantalla que muestran interacciones de ejemplo y resultados. En las primeras secciones, creará sus primeras aplicaciones gráficas.

Cómo mostrar texto en un cuadro de diálogo

Los programas que hemos presentado hasta ahora muestran su salida en la ventana de comandos. Muchas aplicaciones utilizan ventanas, o cuadros de diálogo (también llamados diálogos) para mostrar la salida.

Por ejemplo, los navegadores Web como Firefox, Internet Explorer, Chrome y Safari muestran las páginas Web en sus propias ventanas. Los programas de correo electrónico le permiten escribir y leer mensajes en una ventana. Por lo general, los cuadros de diálogo son ventanas en las que los programas muestran mensajes importantes a los usuarios. La clase JOptionPane cuenta con cuadros de diálogo prefabricados, los cuales permiten a los programas mostrar ventanas que contengan mensajes; a dichas ventanas se les conoce como diálogos de mensaje. En el siguiente  ejemplo muestra el objeto String “Bienveni do\na\nJava" en un diálogo de mensaje.







// Uso de JOptionPane para imprimir varias lineas en un cuadro de diálogo.
package panel;
import javax.swing.JOptionPane;

public class Panel {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
      // muestra un cuadro de diálogo con un mensaje
      JOptionPane.showMessageDialog(null,"Bienvenido\na\nJava\ncon cuadtros de dialogo");
    }
   
}
 

El programa utiliza la clase JOptionPane del paquete javax.swing . El cual contiene muchas clases que le ayudan a crear interfaces gráficas de usuario (GUI). Los componentes de la GUI facilitan la entrada de datos al usuario del programa, y la presentación de los datos de salida.

Se llama al método showMessageDialog de JOptionPane para mostrar un cuadro de diálogo que contiene un mensaje. El método requiere dos argumentos. El primero ayuda a Java a determinar en dónde colocar el cuadro de diálogo. Por lo general, un diálogo se muestra desde una aplicación de GUI con su propia ventana. El primer argumento hace referencia a esa ventana (conocida como ventana padre) y hace que el diálogo se presente centrado sobre la ventana de la aplicación. Si el primer argumento es null, el cuadro de diálogo se ve en el centro de la pantalla de la computadora. El segundo argumento es el objeto String a mostrar en el cuadro de diálogo.

El método showMessageDialog de la clase JOptionPane es lo que llamamos un método static . A menudo, dichos métodos definen las tareas que se utilizan con frecuencia. Por ejemplo, muchos programas muestran cuadros de diálogo, y el código para hacer esto es el mismo siempre. En vez de que usted tenga que “reinventar la rueda” y crear código para realizar esta tarea, los diseñadores de la clase JOptionPane declararon un método static que realiza esta tarea por usted. La llamada a un método static se realiza mediante el uso del nombre de su clase, seguido de un punto (.) y del nombre del método, como en:

NombreClase.nombre Método ( argumentos )

Observe que no tiene que crear un objeto de la clase JOptionPane para usar su método static llamado showMessageDialog.

Introducir texto en un cuadro de diálogo.

La aplicación siguiente utiliza otro cuadro de diálogo JOptionPane predefinido, conocido como diálogo de entrada, el cual permite al usuario introducir datos en un programa. Éste pide el nombre del usuario, y responde con un diálogo de mensaje que contiene un saludo y el nombre introducido por el usuario.

Se utiliza el método showInputDialog de JOptionPane para mostrar un diálogo de entrada que contiene un indicador y un campo (conocido como campo de texto), en donde el usuario puede escribir texto. El argumento del método showInputDialog es el indicador que muestra lo que el usuario debe escribir. El usuario escribe caracteres en el campo de texto, y después hace clic en el botón Aceptar u oprime la tecla Intro (Enter)  para devolver el objeto String al programa. El método showInputDialog devuelve un objeto String que contiene los caracteres escritos por el usuario. Almacenamos el objeto String en la variable nombre. [Nota: si oprime el botón Cancelar en el cuadro de diálogo u oprime Esc, el método devuelve null y el programa muestra la palabra clave “null” como el nombre].

Se utiliza el método static String llamado format para devolver un objeto String que contiene un saludo con el nombre del usuario. El método format es similar al método System.out.printf, excepto que format devuelve el objeto String con formato, en vez de mostrarlo en una ventana de comandos.








package panelnombre;
import javax.swing.JOptionPane;

public class PanelNombre {
   
    public static void main(String[] args) {
      // pide al usuario que escriba su nombre
      String nombre = JOptionPane.showInputDialog("Cual es su nombre?");
      // crea el mensaje
      String mensaje = String.format("Bienvenido, %s, a la programación en J a v a !",nombre);
      // muestra el mensaje para dar la bienvenida al usuario por su nombre
      JOptionPane.showMessageDialog(null, mensaje);
    }
   
}

Una característica atractiva de Java es su soporte para gráficos, el cual permite a los programadores mejorar sus aplicaciones en forma visual.

JAVA SWING.

Swing es una biblioteca gráfica para Java. Incluye widgets para interfaz gráfica de usuario tales como cajas de texto, botones, listas desplegables y tablas.

Es un framework MVC (Modelo-vista-controlador  es un patrón de arquitectura de software, que separa los datos y la lógica de negocio de una aplicación de su representación y el módulo encargado de gestionar los eventos y las comunicaciones) para desarrollar interfaces gráficas para Java con independencia de la plataforma. Sigue un simple modelo de programación por hilos, y posee las siguientes características principales:

Independencia de plataforma.

Extensibilidad: es una arquitectura altamente particionada: los usuarios pueden proveer sus propias implementaciones modificadas para sobrescribir las implementaciones por defecto. Se puede extender clases existentes proveyendo alternativas de implementación para elementos esenciales.

Personalizable: dado el modelo de representación programático del framework de Swing, el control permite representar diferentes estilos de apariencia "look and feel" (desde apariencia MacOS hasta apariencia Windows XP, pasando por apariencia GTK+, IBM UNIX o HP UX, entre otros). Además, los usuarios pueden proveer su propia implementación de apariencia, que permitirá cambios uniformes en la apariencia existente en las aplicaciones Swing sin efectuar ningún cambio al código de aplicación.

Ventajas

El diseño en Java puro posee menos limitaciones de plataforma.

El desarrollo de componentes Swing es más activo.

Los componentes de Swing soportan más características.

NOTA: AQUI SOLO SE MENCIONA COMO SE GENERAN, MAS ADELANTE SE EXPLICARA COMO SE CONTROLAN ESTOS EVENTOS.

Se comenzará con JFrame:

Las ventanas que se realizan en un programa se conocen también como Frame o Marco, un Combobox es una ventana, un botón es una ventana, solo que con características diferentes, en JAVA existen 2 librerías para manejar objetos gráficos: AWT-Abstract Window ToolKit y el Swing que está apoyado por AWT, la clase que usaremos es JFrame.

package bibliotecajframe;
import javax.swing.JFrame;
import java.awt.Graphics;
import java.awt.Frame;

//definimos nuestra propia clase ventana
class MyWindow extends JFrame //extends JFrame es una clase derivada de javax.swing.JFrame
{
    //constructor
    public MyWindow()
    {
        //llama al constructor del titulo de la ventana
        super("Hola, Java en ventanas"); // recuerde que esto es el titulo de la ventana
        //establece el tamaño
        setSize(200,250); //ancho y alto
        //la ubica en pantalla
        setLocation(100,200); //x,y
        //la maximiza si esta ya est visible retirar el comentario para ver efecto
        //setExtendedState(Frame.MAXIMIZED_BOTH);
        //centra la ventana
        //this.setLocationRelativeTo(getParent());//centra en base a la ventana Padre si la hay
        //setLocationRelativeTo(null); //centra en base a la ventana
        // la hace visible, pueden estar declaradas las ventanas pero no se ven
        setVisible(true);
    }// termina MyWindow
    //rescribimos em metodo paint en JFrame
    public void paint (Graphics g) //es de la biblioteca java.awt.Graphics
    {
        g.drawString("Primer Ventana En JAVA",40,160);
    }
}
// la clase principal
public class BibliotecaJframe
{

    public static void main(String[] args)
    {
    MyWindow xWindow = new MyWindow(); //se crea el objeto xWindow de la clase MyWindow
    }
}

El proposito de mostrarlo  de esta manera es que se pueda acomodar en cualquier programa antes de main.


Prueba cambiando los valores de la posicion de la ventana, tamaño y de la posicion del texto. Debes tener cuidado al terminar la ejecucion ya que la ventana sigue funcionando.



JLabel

JLabel es un control que permite desplegar un mensaje de texto con varias características, y esta asociado con informacion que puede ingresar el usuario y se pueden usar en conjunto con JTextField y JTextArea.



package mywindowlabel;
import javax.swing.JFrame;// es el metodo al que se hace referencia y la creacion de objetos
import javax.swing.JLabel; // es el metodo al que se hace referencia y la creacion de objetos

//Definimos nuestra clase
class my_Window_Label extends JFrame //metodo import
{
    //Definiendo objetos de etiquetas
    private JLabel label1,label2; //JLabel clase para definir y del la biblioteca JLabel import
    public my_Window_Label()
    {
        //Coloca el titulo
        //setTitle("Etiquetas JLabel"); // se sustituye por super tambien es posible
        super("Etiquetas JLabel");
        // establece la operacion al cerrar la ventana
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        
        //this.dispose(); // cierra la ventana en uso pero no las otras que se estan trabajando.
       
        // establece posicion y tamaño
        setBounds(100,100,450,300);// x,y ancho y alto
        // establece que no hay un layout para controlar la posicion
        setLayout(null); //layout es la forma de organizar la ventana
        // crea la primer etiqueta
        label1 = new JLabel("Primer etiqueta ..");  //JLabel es un constructor, label1 es un objeto de JLabel
        //establece posicion y tamaño
        label1.setBounds(10,20,300,30);
        //añade la etiqueta a la ventana
        add(label1); //esto hace referncia a JFrame
        // crea ala segunda etiqueta
        label2 = new JLabel("Segunda etiqueta ..");
        // establece posicion y tamaño
        label2.setBounds(10,100,300,30);
        // añade etiqueta a la ventana
        add(label2); // esto hace referencia a JFrame
        // la hace visible
        setVisible(true); //metodo para hacer visible la ventana
      }    
  }

public class MyWindowLabel
{
    public static void main(String[] args)
    {
     //Declaramos un objeto, que se llamara xwindow
        my_Window_Label xwindow = new my_Window_Label();
     // se establece posicion y tamaño
     xwindow.setBounds(150, 250, 300, 300);//x,y, ancho, alto
     //Evitamos que sea redimencionable
     xwindow.setResizable(false);
    
     JLabel xEtiqueta = new JLabel("Tercer etiqueta"); // se define una etiqueta fuera del constructor
    
     //se define posicion y tamaño
     xEtiqueta.setBounds(10,180,150,50);
     // se agrega la etiqueta a la ventana
     xwindow.add(xEtiqueta);
    }
}



Ejercicio:

Modifique el programa anterior en class my_Window_Label extends JFrame, modifique el nombre de la clase  y cambie las posiciones de las etiquetas, realice los cambios necesarios para que funcione adecuadamente.

JTextField

Es un campo de texto, que permite al uisuario capturar datos, es el control de datos por excelencia, la clase para crear un campo de texto es JTextField.







package campo_de_texto;
import java.awt.Frame;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

//Definimos la clase
class myWindowTextField extends JFrame
{
    //Elemntos privados
    private JLabel lblUsuario,lblClave;
    private JTextField txtUsuario,txtClave;
   
    //Constructor de la clase
    public myWindowTextField()
    {
        //Colocamos el titulo
        setTitle("JTextField campo de texto");
       
        //establecer accion a realizar cuando se cierra la ventana
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       
        // no existe un layout
        setLayout(null);
       
        //Crea las etiqueras de usuario y clave
        lblUsuario = new JLabel("Usuario : ");
        lblUsuario.setBounds(10,20,300,30);
        lblClave = new JLabel("Clave : ");
        lblClave.setBounds(10,70,300,30);
       
        // añade las etiquetas a la ventana
        add(lblUsuario);
        add(lblClave);
       
        // crea los campos de texto
        txtUsuario = new JTextField("Capture al usuario : ");
        txtUsuario.setBounds(120,20,300,30);
        txtClave = new JTextField("La clave : ");
        txtClave.setBounds(120,70,300,30);
       
        // añade etiquetas a las ventanas
        add(txtUsuario);
        add(txtClave);
       
    }
}

public class Campo_de_Texto {

   
    public static void main(String[] args)
    {
       myWindowTextField xwindow = new myWindowTextField(); //creacion del objeto xwindow
       //posicion y tamaño de la ventana
       xwindow.setBounds(100,100,500,500);
       //evitando que sea resisable
       xwindow.setResizable(false);
       //haciendo visible la ventana
       xwindow.setVisible(true);
      }
  }

JTextArea

Se capturan datos que poseen una longitud grande pudiéndose abarcar la el renglón completo y saltando a la siguiente línea.




package areadetexto;

import java.awt.Color;
import java.awt.Frame;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.BorderFactory;
import javax.swing.border.BevelBorder;
import javax.swing.JTextArea;

//definimos la ventana
class myWindowTextArea extends JFrame
  {
  // Elementos Privados
     private JLabel lblUsuario,lblClave,lblComentarios; //Etiquetas
     private JTextField txtUsuario,txtClave; //campos de texto
     private JTextArea txtArea1; //Text Area

  //Constructor
   public myWindowTextArea()
   {
   //Coloca el titulo
   setTitle("Area de Texto ");
   //Establece accion al cerrar la ventana
   setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   //Establece que no existe Layout
   setLayout(null);
  
   // Crea etiquetas de Usuario y Clave
   lblUsuario = new JLabel("Usuario: ");
   lblUsuario.setBounds(10,20,300,30);
   lblClave = new JLabel("Calve : ");
   lblClave.setBounds(10,70,300,30);
  
   //añande etiquetas a la ventana
   add(lblUsuario);
   add(lblClave);
  
   //Crea campos de texto
   txtUsuario = new JTextField("Usuario ");
   txtUsuario.setBounds(120,20,300,30);
   txtClave = new JTextField("Clave ");
   txtClave.setBounds(120,70,300,30);
  
   //Añade etiquetas a ventana
   add(txtUsuario);
   add(txtClave);
  
   // Crea la etiqueta del comentario
   lblComentarios = new JLabel("");// se puede colocar un texto ("Comenarios en esta area");
   lblComentarios.setBounds(10,150,413,320); //x , y, ancho y alto
   add(lblComentarios);
  
   //Añade el area de texto, puede agregar texto en el constructor
   txtArea1 = new JTextArea(""); //añade texto
   txtArea1.setBounds(10,150,413,320);
  
  
   //agrega texto
   txtArea1.setText("Tus comentarios : ");
  
   //Lo hace no editable o si, se puede usar en otros controles
   txtArea1.setEditable(true);
  
   //coloca un borde, usando los valores por defecto del sistema RAISED = aparencia sobrerelieve
   // LOWERED = bajo relieve
   txtArea1.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
  
   //Agrega el area del texto al JFrame
   add(txtArea1);
 
   //Agregar colores si se desea cambiar estos colorees de lo contrario comente estas lineas
   //txtArea1.setForeground(Color.BLUE);
   //txtArea1.setBackground(Color.GRAY);
  
   //Editable en los JText
   txtUsuario.setEditable(false); // puede cambiar a true para modificar el area
  
   //El borde de JText
   txtUsuario.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
  
    }

}

public class AreaDeTexto
{
  
    public static void main(String[] args)
  {
       myWindowTextArea xwindow = new myWindowTextArea(); //se declara un objeto en la clase
       // posicion
       xwindow.setBounds(100,100,440,500);
       //no se redimensiona
       xwindow.setResizable(false);
       // se hace visible la ventana y area
       xwindow.setVisible(true);
          
    }
 
}

Panel de Desplazamiento

Es un control que define un área donde la información que desborde los datos mostrando una barra de desplazamiento, de forma vertical y horizontal.





package paneldesplazamiento;
import java.awt.Frame;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.BevelBorder;

class myWindowScollPanel extends JFrame
{
    private JLabel lblUsuario,lblClave,lblComentarios;
    private JTextField txtUsuario,txtClave;
    private JScrollPane pnlComentarios; //panel comentarios
    private JTextArea txtArea1;
   
   
 public myWindowScollPanel()
 {
     //Coloca el titulo
     setTitle("Scroll Panel");
     // Al cerrar la ventana
     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     //Sin layout
     setLayout(null);
     // se crean las etiquetas de Usuario y clave
     lblUsuario = new JLabel("Usuario");
     lblUsuario.setBounds(10,20,300,30);
     lblClave = new JLabel("Clave :");
     lblClave.setBounds(10,70,300,30);
     //Añade las etiquetas a la ventana
     add(lblUsuario);
     add(lblClave);
    
     //Crea los campos para Usuario y clave
     txtUsuario = new JTextField("Capture Usuario: ");
     txtUsuario.setBounds(120,20,300,30);
     txtClave = new JTextField("Capture Clave: ");
     txtClave.setBounds(120,70,300,30);
     //Añada etiquetas a la ventana
     add(txtUsuario);
     add(txtClave);
    
     //Crea etiqueta comentario
     lblComentarios = new JLabel("Comentarios :");
     lblComentarios.setBounds(10,120,300,30);
     add(lblComentarios);
     //Crea area de texto
     txtArea1 = new JTextArea();
     txtArea1.setBounds(10,150,410,300);//puede o no colocarse este se ajusta al panel
     //txtArea1.setEditable(false); //evita que sea editable
     //Le coloca un borde
     txtArea1.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
    
     //Crea el panel de control
     pnlComentarios = new JScrollPane(txtArea1);//se agrega el objeto a controlar txtArea1, y queda dentro del panel de comentarios
     pnlComentarios.setBounds(10,150,390,300); //debe ser menor al tamaño de de pantalla
     add(pnlComentarios);
    
     //habilita o deshabilita el panel
     //pnlComentarios.show(false);//aqui no se presenta el panel
     //pnlComentarios.show(true);// aqui muestra el panel
     //pnlComentarios.hide();//oculta el panel
      
 }
}

public class PanelDesplazamiento {
  
    public static void main(String[] args) {
        //se declara el objeto
       myWindowScollPanel xwindow = new myWindowScollPanel();
       //posicion en pantalla
       xwindow.setBounds(100,100,410,500);
       xwindow.setResizable(false);
       xwindow.setVisible(true);
        }
    }

JComboBox

Coloca una serie de datos en una ventana Popup desendente para seleccionar los datos de el.





package combo_box;
import java.awt.Color;
import java.awt.Frame;

import javax.swing.JComboBox;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.BevelBorder;


class myWindowComboBox extends JFrame
{
private JLabel lblUsuario,lblClave,lblComentarios,lblHost;
private JTextField txtUsuario,txtClave;
private JScrollPane pnlComentarios;
JTextArea txtArea1;
JComboBox cboHost;

public myWindowComboBox()
  {
    setTitle("JCombo Box");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLayout(null);
   
    lblUsuario = new JLabel("Usuario :");
    lblUsuario.setBounds(10,20,300,30);
   
    lblClave = new JLabel("Clave :");
    lblClave.setBounds(10,70,300,30);
   
    add(lblUsuario);
    add(lblClave);
   
    txtUsuario = new JTextField("Capture usuario : ");
    txtUsuario.setBounds(120,20,300,30);
   
    txtClave =new JTextField("Capture su Clave :");
    txtClave.setBounds(120,70,300,30);
   
    add(txtUsuario);
    add(txtClave);
   
    //Crea etiqueta comentario
     lblComentarios = new JLabel("Comentarios :");
     lblComentarios.setBounds(10,120,300,30);
     add(lblComentarios);
     //Crea area de texto
     txtArea1 = new JTextArea();
     txtArea1.setBounds(10,150,300,300);//puede o no colocarse este se ajusta al panel
     //txtArea1.setEditable(false); //evita que sea editable
     //Le coloca un borde
     txtArea1.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
    
     //Crea el panel de control
     pnlComentarios = new JScrollPane(txtArea1);//se agrega el objeto a controlar txtArea1, y queda dentro del panel de comentarios
     pnlComentarios.setBounds(10,150,390,250);
     add(pnlComentarios);
    
     //habilita o deshabilita el panel
     //pnlComentarios.show(false);//aqui no se presenta el panel
     //pnlComentarios.show(true);// aqui muestra el panel
     //pnlComentarios.hide();//oculta el panel
   
    //etiqueta del JComboBox
    lblHost = new JLabel("Hosts :");
    lblHost.setBounds(50,400,300,30);
   
    cboHost = new JComboBox();
    cboHost.setBounds(50,430,180,20);
    add(cboHost);
    add(lblHost);
    
    cboHost.addItem("localhost");
    cboHost.addItem("192.168.2.1");
    cboHost.addItem("www.sitioweb.com");
    //retira la seleccion
    cboHost.setSelectedIndex(-1); //con -1 no seleccione algun elemento al inicio
                                  // con 0 seria localhost
                                  // con 1 seria 192.168.2.1
                                  // con 2 seria www.sitioweb.com
    //cboHost.removeItemAt(0); //remueva de la lista el elemento indicado en est caso seria localhost
   
    //Color
    cboHost.setForeground(Color.BLUE);
    cboHost.setBackground(Color.GRAY);
   
    //Visible
    cboHost.setVisible(true);
    cboHost.enable(true); //lo habilita o deshabilita
   
    //Colocar un borde
    cboHost.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
      
   }
}

public class Combo_box {
   
    public static void main(String[] args) {
        myWindowComboBox xwindow =new myWindowComboBox();
        xwindow.setBounds(100,50,450,500);
        xwindow.setResizable(false);
        xwindow.setVisible(true);
       
    }
 }

JList

Es una lista de datos con una dimensión para su visualización específica, de la cual es posible seleccionar una o más opciones, que es la diferencia de ComboBox.





package jlist_control;

import java.awt.Frame;
import javax.swing.JComboBox;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.BevelBorder;
import javax.swing.JList;
import javax.swing.DefaultListModel;// se agrega para el modelo por default de la lista


class myWindowJList extends JFrame
{
  //etiqueta de lenguajes
  private JLabel lblLenguajes;
  //Scroll panel
  private JScrollPane pnlLenguajes;
  // Vector de las cadenas
  private String srtLenguajes[];
  // JList para la lista de datos
  private JList lstLenguajes;
  // ListModel para usar con el JList
  private DefaultListModel dmlLenguajes = new DefaultListModel();
 
   //Constructor
  public myWindowJList()
  {
    setTitle("Control JLIst");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLayout(null);
    //Etiqueta para JList
    lblLenguajes = new JLabel("Lenguajes ");
    lblLenguajes.setBounds(10,10,300,30);
   
    //prepara el vector para los lenguajes a JList
    srtLenguajes = new String[5]; // crea un arreglo
    srtLenguajes[0]="Java";
    srtLenguajes[1]="C++";
    srtLenguajes[2]="PHP";
    srtLenguajes[3]="Ruby";
    srtLenguajes[4]="Phyton";
   
    //Se crea el Jlist
    lstLenguajes = new JList(srtLenguajes); // pasan las opciones anteriores para crear el vector
    lstLenguajes.setBounds(100,320,320,120);
   
    //se puede agregar una nueva lista de datos de la forma anterior no es posible agregar o retirar
    // se crea una nueva lista para modificar la anterior
   
    srtLenguajes = new String[7];// se forma la nueva lista con otros 2 elementos mas.
    srtLenguajes[0]="Java";
    srtLenguajes[1]="C++";
    srtLenguajes[2]="PHP";
    srtLenguajes[3]="Ruby";
    srtLenguajes[4]="Phyton";
    srtLenguajes[5]="Fortram";
    srtLenguajes[6]="Cobol";

    //Establece una nueva lista
    lstLenguajes.setListData(srtLenguajes);
    // puede comentar estas lineas y la lista se vera como la anterior
   
    //Añade la lista al JList
    pnlLenguajes = new JScrollPane(lstLenguajes);
   
    // definimos el tamaño del panel
    pnlLenguajes.setBounds(100,10,320,120);
   
    // añade la forma
   
    add(pnlLenguajes);
    add(lblLenguajes);
   
    //Agrega elementos JList
    dmlLenguajes.addElement("SQL");
    dmlLenguajes.addElement("Visual Basic");
    dmlLenguajes.addElement("Java");
    dmlLenguajes.addElement("JavaScript");
    lstLenguajes.setModel(dmlLenguajes);// cuando se agregan los elemntos pasan al objeto lstLenguajes
                                                              // de la lista dmlLenguajes
    dmlLenguajes.addElement("C Turbo");
    dmlLenguajes.addElement("Perl");
    dmlLenguajes.addElement("Pascal");
    dmlLenguajes.addElement("Java");
    dmlLenguajes.addElement("Asp");  //ya establecido el modelo se pueden agregar mas opciones
   
    // Selecciona la posicion 0
    lstLenguajes.setSelectedIndex(0);
   
    //Establece un borde
    lstLenguajes.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
   
    //Elementos en el JList
    System.out.println("Elementos: "+dmlLenguajes.size());
   
    //Agrega un elemento en una posicion especifica
    dmlLenguajes.insertElementAt("Pos 1",1); //coloca Pos 1 en al posicion 1 de la lista
    dmlLenguajes.add(5,"Pos 5");             // coloca Pos 5 en la posicion 5 de la lista
                                                              // dos formas de agregar elementos
   
    //Obtiene el elemento de la possicion especifica
    System.out.println("Elemento en la posicion 3: "+dmlLenguajes.getElementAt(3));
   
    //Encontrar elementos
    System.out.println("Encontro Asp en "+dmlLenguajes.indexOf("Asp"));
    System.out.println("Encontro Java en "+dmlLenguajes.lastIndexOf("Java"));// desde el final se busca
   
    //Elimina un elemento
    //dmlLenguajes.remove(0);
    //dmlLenguajes.removeElement("Java");
   
    //Elimina todos los elementos
    //dmlLenguajes.clear();
    //dmlLenguajes.removeAllElements();
   
    }
  
}
public class JList_Control {

   
    public static void main(String[] args) {
      myWindowJList xwindow =new myWindowJList();
        xwindow.setBounds(100,50,450,500);
        xwindow.setResizable(false);
        xwindow.setVisible(true);
    }
   
}

JButton

Un botón es un componente muy útil y uno de los mas usados ya que nos permite manejar datos en tiempo de ejecución, un botón puede tener solo texto, una imagen o texto con imagen.





package jbutton_control;
import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import javax.swing.JButton;
import javax.swing.JFrame;
import java.awt.FlowLayout;

class myWindowButton extends JFrame
{
 //Declara 2 botones
 JButton btnAceptar,btnCancelar;
 
    public myWindowButton()
            {
             setTitle("Objeto Boton");
             setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             setLayout(null);
             //setLayout(new FlowLayout()); // sirve para distribuir los componentes
                                            // que se van añadiendo de izquierda a derecha,
                                            // existen varios distribuidores como son el
                                            // borderLayout(), el GridLayout(), el BoxLayout(),
             // crea el boton Aceptar
             btnAceptar = new JButton("Aceptar");
             // posicion y tamaño
             btnAceptar.setBounds(30,310,100,30);
             //crea el boton Cancelar
             btnCancelar = new JButton("Cancelar");
             // posicion y tamaño
             btnCancelar.setBounds(270,310,100,30);
             //agrega el boton
             add(btnAceptar);
             add(btnCancelar);
           
             //Modificando la fuente y el Color
             btnAceptar.setForeground(Color.BLUE);
             btnCancelar.setBackground(Color.RED);
           
             //Creamos una nueva fuente
             Font font = new Font("Courier",Font.ITALIC|Font.BOLD,14);
             //establecemos fuente
           
             btnAceptar.setFont(font);
            }
}

public class JButton_control {

    public static void main(String[] args) {
       myWindowButton xwindow = new myWindowButton();
       xwindow.setBounds(100,100,400,400);
       // Centra  el objeto
       xwindow.setLocationRelativeTo(null);
       xwindow.setResizable(false);
       xwindow.setVisible(true);
     
    }
  
}

JPanel

Es un contenedor usado para agrupar objetos en el, se utiliza para tener un distribucion de objetos de forma especifica que se realiza por medio de Layout.


para el primer caso (ver codigo del programa) se mostrará de la siguiente forma



y para la modificación de Layout plnBotones.setLayout(new FlowLayout()); lo que hace es acomodar de la mejor manera posible los botónes en el panel.



otra forma de presentarlo es en un grid, vease la linea que contiene:

     plnBotones.setLayout(new GridLayout(4,2)); //  desde import java.awt.GridLayout;

puede comentarla o no para producir lo siguiente:



package jpanel_contenedor;
import java.awt.Frame;
import java.awt.FlowLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;

import javax.swing.JPanel;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.border.BevelBorder;

class myWindowPanel extends JFrame
{
    //Botones a utilizar 5
    private JButton btnUno,btnDos,btnTres,btnCuatro,btnCinco;
    //Panel de Distribucion
    JPanel plnBotones;
   
    public myWindowPanel()
    {
        setTitle("Jpanel agrupar objetos");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(null);
       
        //crea los botones
        btnUno = new JButton ("Uno");
        btnDos = new JButton ("2");
        btnTres = new JButton ("Tres");
        btnCuatro = new JButton ("IV");
        btnCinco = new JButton ("Cinco");
       
        //Dimension de los botones
        btnUno.setBounds(10,10,50,50);
        btnDos.setBounds(10,70,50,50);
        btnTres.setBounds(10,130,50,50);
        btnCuatro.setBounds(10,190,50,50);
        btnCinco.setBounds(10,230,50,50);
       
        //Crea el panel
        plnBotones = new JPanel();
       
        // establecemos el layuot a null
        //plnBotones.setLayout(null); // con esto los botones se crean segun los valores
                                                   // indicados anteriormente, retira y/o coloca el comentario
        // comenta la linea anterior y agrega esto 
        plnBotones.setLayout(new FlowLayout());  //puedes comentar esta si aplicas el layout siguiente                        
       
        //aqui se puede agregar un grid, descomenta esta linea
        //plnBotones.setLayout(new GridLayout(4,2)); //  desde import java.awt.GridLayout;
                                                                               // (4,2) significa cuatro renglones y 2 columnas
       
        // se establece el borde
        plnBotones.setBorder(BorderFactory.createBevelBorder(BevelBorder.RAISED));
       
        //establece posicion y tamaño del Panel
        plnBotones.setBounds(10,10,180,180);
       
        //agrega la etiqueta al panel
        plnBotones.add(btnUno);
        plnBotones.add(btnDos);
        plnBotones.add(btnTres);
        plnBotones.add(btnCuatro);
        plnBotones.add(btnCinco);
       
        // añade el panel a la forma
        add(plnBotones);   
       }
}

public class Jpanel_contenedor {

    public static void main(String[] args) {
        myWindowPanel xwindow = new myWindowPanel();
        xwindow.setBounds(100,100,200,200);
        xwindow.setResizable(false);
        xwindow.setVisible(true);
       
    }
   
}

JCheckBox

Este control permite activar o desactivar una casilla, es posible seleccionar mas uno de ellos.





existe una línea en el código del programa: chkMensajes.setLabel("Modificando"); que esta comentado esto lo que hace es cambiar el valor de la etiqueta del check box, esta instrucción tiene una característica si se des comenta la línea esta mostrara una línea en medio de setLabel, esto es porque esta especificación se ha vuelto obsoleta y se ha mejorado, pero igual se puede usar.

hay otra instrucción en el programa chkBitacora.setEnabled(false); esto hace el primer checkbox no este habilitado (estado en gris), si se desea habilitar cambie de false a true.

package jcheck_box_contenedor;
import java.awt.Frame;

import javax.swing.JFrame;
import javax.swing.JCheckBox;

class myWindowCheckBox extends JFrame
{
 // declaracion de las variables de checkbox
    private JCheckBox chkBitacora,chkMensajes; //estos son los objetos, chk es un prefijo arbitrario
   
    //Constructor
    public myWindowCheckBox()
    {
        //Prepara y agrega el checkbox
        chkBitacora = new JCheckBox("Guardar en bitacora");
        chkBitacora.setBounds(10,10,180,30);
        chkBitacora.setEnabled(false);
        add(chkBitacora);
       
        // el segundo checkbox
        chkMensajes = new JCheckBox("Mensajes ");
        chkMensajes.setBounds(10,50,180,30);
        //chkMensajes.setLabel("Modificando");
        chkMensajes.setSelected(true);
        add(chkMensajes);
       
        setTitle("JCheck Box");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(null);
   }
   
}

public class JCheck_box_Contenedor {
   
    public static void main(String[] args) {
        myWindowCheckBox xwindow = new myWindowCheckBox();
        xwindow.setBounds(100,100,490,500);
        xwindow.setResizable(false);
        xwindow.setVisible(true);
    }
   
}

JRadioButton

Selecciona una opción entre varias, para que sea efectivo es necesario otro control llamado buttongroup, que realiza una agrupación.




package ctl_jradiobutton;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;

import javax.swing.JFrame;
import javax.swing.JRadioButton;
import javax.swing.ButtonGroup;


class myWindowRadioButton extends JFrame
{
  private JRadioButton rbtVisualBasic, rbtVisualC,rbtJava;
  private ButtonGroup bg; //bg el objeto que agrupa
 
  //Constructor
  public myWindowRadioButton()
  {
      //Titulo de la clase
      setTitle("JRadioButton");
      setLayout(null);
      // boton del grupo
      bg = new ButtonGroup();
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      //creacion de cada boton
      rbtVisualBasic = new JRadioButton ("Visual Basic");
      rbtVisualBasic.setBounds(10,20,200,30);
      add(rbtVisualBasic); //se agrega al frame
      bg.add(rbtVisualBasic);
     
      rbtVisualC = new JRadioButton ("Visual Basic");
      rbtVisualC.setBounds(10,70,200,30);
      add(rbtVisualC);
      bg.add(rbtVisualC);
     
      rbtJava =new JRadioButton ("Java");
      rbtJava.setBounds(10,120,200,30);
      add(rbtJava);
      bg.add(rbtJava);
     
  }
}

public class Ctl_JRadioButton {
   
    public static void main(String[] args)
    {
    myWindowRadioButton xwindow = new myWindowRadioButton();
    xwindow.setBounds(100,100,440,300);
    xwindow.setResizable(false);
    xwindow.setVisible(true);
    }
   
}

JTable

Administra informacion en celdas conocido como grid (Rejilla), se debe de encontrar dentro de JScrollPanel,



package control_jtable;
import java.awt.Frame;
import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;
import javax.swing.JTable;
import javax.swing.JScrollPane;

//se define la clase
class myWindowTable extends JFrame // INICIA LA CLASE
{
//constructor
 public myWindowTable() // INICIA EL METODO
  {
   setTitle("JTable");
   //Variables para la modificacion de la tabla
   DefaultTableModel dtmCalendario; //es el modelo de la tabla por default
   TableModel tbmCalendario;        //es el modelo de la tabla que necesito
  
   setLayout(null);
   //matriz de los datos en la tabla
   // se crea un objeto (Object)
   Object[][] matDatos =
   {
       {"","","","","","",""},
       {"","","","","","",""},
       {"","","","","","",""},
       {"","","","","","",""},
       {"","","","","","",""},
       {"","","","","","",""}
   };
   // array de datos, Titulos de las columnas
   String[] arrTitulos = {"Dom","Lun","Mar","Mie","Jue","Vie","Sab"};
  
   //Modelo de la tabla
   JTable tblCalendario = new JTable(matDatos,arrTitulos);
   tblCalendario.setCellSelectionEnabled(true); //permite seleccionar celda por celda
  
   //se crea un JscrollPanel y agregamos la tabla
   JScrollPane pnlCalendario = new JScrollPane(tblCalendario); // se pasa como parametro el calendario
  
   //posicion y tamaño
   pnlCalendario.setBounds(0,0,400,150);
  
   //agregamos el JScrollPanel al contenedor
   add(pnlCalendario,BorderLayout.CENTER);//observar la , son parametros
   // modelo de la tabla
   tbmCalendario = tblCalendario.getModel();
   //establecer valores en la rejilla
   tblCalendario.setValueAt("Hoy",1,1);
   tblCalendario.setValueAt(123,1,2);
  
   //Obtener valores
   System.out.println("Valor de 1,1 "+tbmCalendario.getValueAt(1,1)); // se llama desde el modelo
  
   //obtener el numero de columnas
   System.out.println("Columns :"+tbmCalendario.getColumnCount());
  
   //obtener el numero de renglones
   System.out.println("Renglones :"+tbmCalendario.getRowCount());
  
   //obtener el nombre de las columnas
   System.out.println("Nombre de la columna 6 :"+tbmCalendario.getColumnName(6));
  
   //retire el comentario de las siguientes expresiones y ve los resultados
  
  
   //para agregar columnas
   //dtmCalendario = new DefaultTableModel(matDatos,arrTitulos);
  
   //colocamos el modelo en el Jtable
   //tblCalendario.setModel(dtmCalendario);
  
   //se manipula DefaultTableModel
   //dtmCalendario.addColumn("Extra");
  
   //para eliminar la columna
   //dtmCalendario.setColumnCount(6);
  
   //agregamos columnas
   //dtmCalendario.setColumnCount(8);
  
   //agregar renglon
   //Object[] newRow ={"Dom","Lun","Mar","Mie","Jue","Vie","Sab","Ext 1","Ext 2"};
   //dtmCalendario.addRow(newRow);
  
   //establecer valores
   //dtmCalendario.setValueAt("7",2,2);
  
   //modificar columna colocando en el ultimo renglon
   //dtmCalendario.setColumnIdentifiers(newRow);
  
   //lo hace visible
   //this.setVisible(true);
  
   setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }//TERMINA EL METODO

}//TERMINA LA CLASE
public class Control_JTable
{
    public static void main(String[] args) {
       myWindowTable xwindow = new myWindowTable();
       xwindow.setBounds(100,100,440,300);
       xwindow.setResizable(false);
       xwindow.setVisible(true);       
    }
}

JMenu

Es uno de los controles más importantes, para diseñar el JMenu se requieren 4 clases JMenuBar, JMenu, JMenuItem, y JSeparator.

JMenuBar es una Barra horizontal en la cual se colocan, la opciones del menú.

JMenu es un control que contiene una opción del menú y se le agrega al JMenuBar, tambien es posible agregarlos a otro JMenu.

JMenuItem son las sub-opciones del JMenu.

JSeparator crea una línea de separación en la opciones del menú.





package j_menu;
import java.awt.Frame;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JSeparator;
import javax.swing.KeyStroke;

//definicion de la clase propia myWindowMenu
class myWindowMenu extends JFrame
{
    private JMenuBar mbPrincipal;
    private JMenu mnuSistema, mnuExtra;
    private JMenuItem opcEntrada,opcSalida,opcConfiguracion,cpcExtra1,cpcExtra2;
 
    //Constructor
    public myWindowMenu()
    {
        setTitle("J Menu");
        setLayout(null);
        // se crea la barra de titulo
        mbPrincipal = new JMenuBar();
        //colocamos la barra en la ventana
        setJMenuBar(mbPrincipal);//setJMenuBar pertenece a JFrame
        //creacion del menu
        mnuSistema = new JMenu("Sistema");
        //añadimos el menu a la barra
        mbPrincipal.add(mnuSistema);
        // se crean las opciones Entrada y le agregamos el menu Sistema
        opcEntrada = new JMenuItem("Entrada");
        mnuSistema.add(opcEntrada);
       
        opcSalida = new JMenuItem("Salida");
        mnuSistema.add(opcSalida);
       
        //creamos loa opcion llamada configuracion
        opcConfiguracion = new JMenuItem("Configuracion");
        mnuSistema.add(opcConfiguracion);
       
        // agregamos el separador
        mnuSistema.add(new JSeparator());
       
        // creamos el menu extra
        mnuExtra = new JMenu("Extra");
        mnuSistema.add(mnuExtra); //se agrega un menu dentro de otro
       
        //se crean la opciones extra 1 y extra 2
        cpcExtra1 = new JMenuItem("Extra1");
        mnuExtra.add(cpcExtra1);
        cpcExtra2 = new JMenuItem("Extra2");
        mnuExtra.add(cpcExtra2);
        //agregamos un acelerador
        KeyStroke F5 = KeyStroke.getKeyStroke(KeyEvent.VK_F5,KeyEvent.SHIFT_DOWN_MASK);
        KeyStroke keyEscape = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,KeyEvent.CTRL_DOWN_MASK);
       
        cpcExtra1.setAccelerator(F5);
        cpcExtra2.setAccelerator(keyEscape);
       
        this.setVisible(true);
     
    }
}

public class J_Menu {

    public static void main(String[] args) {
       myWindowMenu xwindow = new myWindowMenu();
       xwindow.setVisible(true);
       xwindow.setExtendedState(Frame.MAXIMIZED_BOTH);
    }
   
}


JBorderLayout

Los layout son formas predefinidas de organizar la posición de los controles, dentro de una forma. Cuando se usan los layouts JAVA ignora las propiedades de posición del control, y solamente se permite indicar cuál es primero, después arriba abajo, a la izquierda, etc. en este caso JBorderLayout organiza los controles de acuerdo a sus posiciones, CENTER, NORTH, SOUTH, EAST, WEST.



    o este otro cuando damos un tamaño especificó

package border_layout;
import java.awt.Frame;
import java.awt.BorderLayout;
import java.awt.Label;
import java.awt.Button;
import java.awt.event.KeyEvent;

import javax.swing.JFrame;
class myWindowBorderLayout extends JFrame
{
//Controles agregar forma
Label lblNorte = new Label("Norte");
Label lblSur   = new Label("Sur");
Label lblEste  = new Label("Este");
Label lblOeste = new Label("Oeste");
Label lblCentro = new Label("Centro");

//Constructor
public myWindowBorderLayout()
    {
    setTitle("JBorderLayout");
    //se establece el borde que va a usar la ventana
    setLayout(new BorderLayout());
    // se añaden la etiquetas
    add(lblNorte,BorderLayout.NORTH);
    add(lblSur,BorderLayout.SOUTH);
    add(lblEste,BorderLayout.EAST);
    add(lblOeste,BorderLayout.WEST);
    add(lblCentro,BorderLayout.CENTER);
   
    //si no se indica el tamaño de la ventana usar:
    pack();
   
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
    //y lo hacemos visible
    this.setVisible(true);
   
    }
}

public class Border_Layout {

    public static void main(String[] args) {
      myWindowBorderLayout xwindow = new myWindowBorderLayout();
      xwindow.setResizable(false);
      xwindow.setVisible(true);
      // se estable un tamaño para la ventana, si se usa esto ya no
      // usaremos pack()
      // xwindow.setSize(400,400);
    }
   
}

Flowlayout

Organiza los controles de izquierda a derecha, hasta terminar la pantalla, y el siguiente control lo coloca en la línea que sigue.


Usando el codigo sin propiededes del FlowLayout



Usando el codigo  FlowLayout.CENTER


Usando el codigo  FlowLayout.LEFT


Usando el codigo  FlowLayout.RIGHT



Usando el codigo  FlowLayout.LEADING


Usando el codigo  FlowLayout.TRAILING


package flow_layout;
import java.awt.FlowLayout;
import java.awt.Button;
import java.awt.Label;
import javax.swing.JFrame;

class myWindowFlowLayout extends JFrame
{
    Label lblUno = new Label("Uno");
    Label lblDos = new Label("Dos");
    Label lblTres = new Label("Tres");
    Label lblCuatro = new Label("Cuatro");
    Label lblCinco = new Label("Cinco");
    Button btnSeis = new Button ("Seis");
   
    //constructor
    public myWindowFlowLayout()
    {
        setTitle("Flow Layout");
      //coloca el Flowlayout en Layout
      setLayout(new FlowLayout());
      // añade controles de uno a uno
      //dependiendo del tamaño de la ventana
      // se desplazan a la izquierda cuando se llenan del lado derecho
     
      add(lblUno);
      add(lblDos);
      add(lblTres);
      add(lblCuatro);
      add(lblCinco);
      //add(btnSeis);
     
      // lo pone en el centro
      //add(btnSeis,FlowLayout.CENTER);
     
      // lo coloca a la izquierda
      //add(btnSeis,FlowLayout.LEFT)
     
      // lo coloca a la derecha
      //add(btnSeis,FlowLayout.RIGHT);
     
      // lo justifica
      //add(btnSeis,FlowLayout.LEADING);
      // lo justifica desde la esquina del layout
      //add(btnSeis,FlowLayout.TRAILING);
     
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
      pack();
     
    }
}
       
public class Flow_Layout {
  
    public static void main(String[] args) {
      myWindowFlowLayout xwindow = new myWindowFlowLayout();
      xwindow.setResizable(false);
      xwindow.setVisible(true);
      xwindow.setSize(200,200);
    }
   
}

GridLayout

Organiza los controles dentro de un grid en columnas, y filas con celdas de posición fija,




package grid_layout;
import java.awt.GridLayout;
import java.awt.Button;
import java.awt.Label;

import javax.swing.JFrame;

class myWindowGridLayout extends JFrame
{
    //controles
    Label lblUno = new Label("Uno");
    Label lblDos = new Label("Dos");
    Label lblTres = new Label("Tres");
    Label lblCuatro = new Label("Cuatro");
    Label lblCinco = new Label("Cinco");
    Button btnSeis = new Button("Seis");
   
    //constructor
    myWindowGridLayout()
    {
       setTitle("Grid Layout");
       //coloca el GridLayout, si no se indica el Grid (el tamaño) sera un solo renglon
       //y colocara un elemento en cada colunma segun se agrere
       //setLayout(new GridLayout());
      
       // el grid con 2 columnas y 3 renglones
       setLayout(new GridLayout(2,3)); //simpre y cuando se tenga espacio, de lo contrario se desajusta por el espacio creado
      
       //se agregan los controles
       add(lblUno);
       add(lblDos);
       add(lblTres);
       add(lblCuatro);
       add(lblCinco);
       add(btnSeis);
      
       //pack();
       setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      
       this.setVisible(true);
    }
           
}
public class Grid_Layout {

   
    public static void main(String[] args)
    {
    myWindowGridLayout xwindow = new myWindowGridLayout();
      xwindow.setResizable(false);
      xwindow.setVisible(true);
      xwindow.setSize(400,400);   
    }
   
}

Eventos

Un evento es un objeto que representa un cambio en un componente, este es generalmente producido por el usuario al realizar alguna operación, por ejemplo, escribir en un campo de texto o hacer click sobre un botón. El método que se sigue para atender un evento es el siguiente:

1) Se relaciona a un oyente (listener) con un componente para que el componente le notifique al listener cuando ocurra un evento específico.


2) Cuando se produce el evento, el listener atiende el evento. En este método la implementación de la interface de usuario donde se produce el evento y la implementación del oyente están en clases separadas.

Para que un evento tenga efecto debemos  de invocar el metodo:

public addActionListener(ClaseControlaEvento)

Las clases que se disponen en Java para manejo de eventos son:


ActionListener .- Cuando se requieren capturar eventos del tipo ActionEvent, como pulsar el botón del mouse. El método debe implementarse con:


public void actionPerformed(ActionEvent x)


ItemListener.- Es para los objetos JCheckBox, JList y JCheckboxMenuItem, el método de implementación:

public void itemStateChanged(ItemEvent)


WindowListener.- Se implementa en el caso control de eventos del tipo WindowEvent los productores de estos son del tipo JDialog y JFrame se asocia el evento a través del método:


public void addWindowListener(WindowListener x)


Los métodos que deberán de implementarse :


public void windowOpened(WindowOpened e)  detecta si se abrió la ventana.


public void windowDeactivated(WindowEvent x) detecta la ventana si ha sido desactivada.


public void windowIconified(WindowEvent e) detecta si la ventana ha sido minimizada


public void windowClosed(WindowEvent e) detecta si la ventana a ha sido cerrada (cuando se hace una llamada al método dispose() ).


public void windowDeiconified(WndowEvent e) detecta si la ventana ha sido restaurada o maximizada.


public void windowClosing(WindowEvent e) detecta si se al pulsado el botón de cerrar.


ComponetListener .- es la capacidad de escuchar eventos del tipo ComponetEvent se debe de implementar la clase ComponentListener, los objetos que producen los eventos son JDialog y los JFrames

para invocar los metodos usaremos:

public void addComponentListener(componentListener e)

los metodos que se deben definir para implementacion de esta interface.

public void componetResized(ComponentEvent e)

public void componetMoved(ComponentEvent e)

public void componetShow(ComponentEvent e)

public void componetHidden(ComponentEvent e)

AjustmentListner.- para ecuchar los eventos producidos por la clase JScrollbar de debe de implementar la clase

public void AjustmenListener(AdjustmentListenet ev)

para captar el evento se usa:

public void ajustmentValueChanged(ajustmentValueChanged adj)

El manejo de eventos se puede implementar a través de las clases abstractas e interfaces que java proporciona en el paquete java.awt.event. No hay que olvidar esto último.


Interfaces Clases Abstractas
ActionListener
ComponentAdapter
AdjustmentListener ContainerAdapter
AWTEventListener ContainerEvent
ComponentListener FocusAdapter
ContainerListener KeyAdapter
FocusListener MouseMotionAdapter
InputMethodListener WindowAdapter
ItemListener
KeyListener
MouseListener
MouseMotionListener
TextListener
WindowListener

Eventos generados por un marco (Frame)

En el siguiente ejemplo, se implementó una clase anidada para el manejo de Eventos, esta extiende a la clase Window Adapter y define todos sus métodos. Para vincular a la clase que maneja los eventos con el componente que los produce (en este caso el frame), se agrega un oyente (monitor) al frame.






Nota: deberás de redimensionar la ventana, y agrega la instrucción correcta para establecerla de un tamaño adecuado y al centro de la pantalla



estos son los eventos que se realizan con el objeto

El codigo del programa, realiza algunas deducciones del programa :

package pruebaeventosframe;

import java.awt.*;
import java.awt.event.*;

class EventosFrame
{
    Frame ventana;
    void forma()
     { 
        ventana=new Frame();
        ventana.setTitle("Prueba de Eventos de Frame");
        ventana.setSize(200,400);
        ventana.setBackground(new Color(100,200,1));
        ventana.setLayout(new FlowLayout());
        ventana.add(new Label("Hola"));
        ventana.pack();
        ventana.setVisible(true);
        ManejoDeEventosFrame manejador=new ManejoDeEventosFrame();
        ventana.addWindowListener(manejador);
     }// termina metodo ventana
   
class ManejoDeEventosFrame extends WindowAdapter
   {
       @Override
           public void windowActivated( WindowEvent evento)
            {
            System.out.println("Ventana activada");
        }
       @Override
        public void windowClosed( WindowEvent evento)
        {
        System.out.println("Ventana desactivada");
        }
       @Override
       public void windowClosing(WindowEvent evento)
        {
        System.out.println("Cerrando Ventana");
        if (evento.getSource()==ventana){
        System.out.println("Cerrando ventana");
        ventana.setVisible(false);
        ventana.dispose();
            }
        }
  
    @Override
     public void windowDeactivated( WindowEvent evento)
      {
      System.out.println("Ventana desactivada");
      }
    @Override
     public void windowDeiconified (WindowEvent evento)
      {
      System.out.println("Ventana maximizada");
      }
    @Override
     public void windowIconified( WindowEvent evento)
      {
      System.out.println("Ventana minimizada");
      }
     @Override
     public void windowOpened( WindowEvent evento)
     {
     System.out.println("Ventana abierta por primera vez");
     }
}//termina clase ManejoDeEventosFrame

} //termina clase EventosFrame
public class PruebaEventosFrame
{
public static void main(String args[])
    {
    System.out.println("Creando Marco");
    EventosFrame obj= new EventosFrame();
    obj.forma();
    }
}

Eventos generados por Botones

En el ejemplo, para atender los eventos generados por componentes Button, se usa una clase anidada que implementa a la interface ActionListener y se define el método actionPerformed. Es posible que dos o más botones sean atendidos por el mismo método si a cada uno se le añade el ActionListener.



       




El codigo del programa, realiza algunas deducciones del programa :

package pruebaeventosboton;

import java.awt.*;
import java.awt.event.*;

class EventosBotones {
    Button boton1,boton2;
        Frame v1,v2;
            ManejadorEventosBoton oyeBoton;

            void forma1(){
            v1=new Frame();
            v1.setLayout(new FlowLayout());
            boton1=new Button("Abrir Frame");
            boton2= new Button("Cancelar");
            v1.add(boton1);
            v1.add(boton2);
            oyeBoton=new ManejadorEventosBoton();
            boton1.addActionListener(oyeBoton);
            boton2.addActionListener(oyeBoton);
            v1.pack();
            v1.setVisible(true);
       }

void forma2(){
        v2=new Frame();
        v2.setTitle("Prueba de Eventos de Boton");
        v2.setSize(200,400);
        v2.setLocation(100,100);
        v2.setBackground(new Color(100,200,1));
        v2.setLayout(new FlowLayout());
        v2.add(new Label("Hola"));
        v2.pack();
        v2.setVisible(true);
    }

class ManejadorEventosBoton implements ActionListener
{
@Override
public void actionPerformed(ActionEvent evento){
        Object fuente=evento.getSource();
                if (fuente==boton1) forma2();
                if (fuente==boton2){
                v2.setVisible(false);
                v2.dispose();
            }
        }
     }
}
    public class PruebaEventosBoton {
        public static void main(String args[]){
            EventosBotones obj=new EventosBotones();
            obj.forma1();
            }
}

Eventos Generados por componentes de Texto.

Para el manejo de eventos producidos por áreas de texto y/o campos texto, se inserta una clase anidada que implemente la interface TextListener. El método getText nos permite recuperar el texto escrito en el componente.





package pruebaeventostexto;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.TextEvent;
import java.awt.event.TextListener;

class EventosTexto
    {
        TextField tf1;
        TextArea areaTexto;
        Frame v;
        String txt1,txt2;
        Label etiqueta1, etiqueta2;
        ManejaEventosTexto oyeTexto;
        ManejaEventosBoton oyeBoton;
        Button b;
            class ManejaEventosTexto implements TextListener
           {
                @Override
                public void textValueChanged(TextEvent e)
                {
                    Object fuente=e.getSource();
                    if (fuente==tf1){ txt1=new String(tf1.getText() );
                     }
                    if (fuente==areaTexto){
                        txt2=new String(areaTexto.getText() );
                    }
                } //termina el metodo textValueChanged
            } // termina ManejaEventosTexto
           class ManejaEventosBoton implements ActionListener
        {
            @Override
            public void actionPerformed(ActionEvent evento)
            {
                Object fuente=evento.getSource();
                if(fuente==b) recuperaTexto();
            }// termina metodo actionPerformed
        }// termina metodo ManejaEventosBoton

            void forma()
            {
            v=new Frame();
            v.setLayout(new FlowLayout() );
             tf1 = new TextField();
            b=new Button("Mostrar Texto");
            areaTexto = new TextArea("",5, 40,TextArea.SCROLLBARS_NONE);
            areaTexto.setBackground(Color.white);
            oyeTexto=new ManejaEventosTexto();
            oyeBoton=new ManejaEventosBoton();
            tf1.addTextListener(oyeTexto);
            areaTexto.addTextListener(oyeTexto);
            b.addActionListener(oyeBoton);
            v.add(tf1);
            v.add(areaTexto);
            v.add(b);
            v.add(etiqueta1=new Label( ) ); v.add(etiqueta2=new Label( ) );
            v.pack();
            v.setVisible(true);
            }//termina forma()

            void recuperaTexto()
            {
             etiqueta1.setText(txt1);
             etiqueta2.setText(txt2);
            }//termina metodo recuperaTexto
    } //termina EventosTexto

            public class PruebaEventosTexto
{
            public static void main(String args[])
            {
            EventosTexto pagina=new EventosTexto();
            pagina.forma();
            }
}

Es el codigo del programa, realiza por tu cuenta algunas deducciones de lo que consiste el programa.

Aplicaciones con eventos generados por distintos componentes.




Aqui se muestra el programa que lleva estos eventos:

package pruebaconviertedolares;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.*;

class ConvierteDolares //se definen lo que lleva el frame
{        
    TextField tPesos,tDolares;  //texto de Pesos y Dolares en el frame
    Frame v; //genera el frame
    ManejaEventosTexto oyeTexto; //evento del texto
    ManejaEventosBoton oyeBoton; //evento del boton ambos a la escucha de l proceso con el texto y el mouse
    Button b;                    //define el boton para conversion

    // dentro de la clase Convierte dolares estan los eventos a usar
    // eventos de texto
class ManejaEventosTexto implements TextListener //clase para los eventos de texto
{
    public void textValueChanged(TextEvent e)// realiza el evento
    {
    Object fuente=e.getSource();
    /*if (fuente==tPesos){ System.out.println(tPesos.getText() );}*/
    }
}// termina evento

class ManejaEventosBoton implements ActionListener  //evento del boton cuando se hace clic
{
public void actionPerformed(ActionEvent evento)
    {
    Object fuente=evento.getSource();
    if(fuente==b) cambiaDolares();
    }
} //termina evento
void forma() // genera el evento del frame con Frame y FlowLayout
{
    v=new Frame();
    v.setLayout(new FlowLayout() );
    tPesos = new TextField();
    tDolares= new TextField("0") ;
    b=new Button("Convertir");
    oyeTexto=new ManejaEventosTexto();
    oyeBoton=new ManejaEventosBoton();
    tPesos.addTextListener(oyeTexto);
    b.addActionListener(oyeBoton);
    v.add(new Label("Pesos")); v.add(tPesos);
    v.add(new Label("Dolares") ); v.add(tDolares);
    v.add(b);
    v.pack();
    v.setVisible(true);
}
void cambiaDolares() // realiza la conversion de pesos a dolares
 {
    double pesos=0;
    try{ pesos=new Double(tPesos.getText() ).doubleValue() ; }
    catch(Exception exp){ tPesos.setText(""); }
    double dolares=pesos/19.00; // valor de la conversion
    System.out.println("Pesos=" +pesos);
    String cambio= new String();
    System.out.println("Dolares="+ cambio.valueOf(dolares));
    tDolares.setText(cambio.valueOf(dolares) );
 }
} // termina la clase ConvierteDolares

public class PruebaConvierteDolares
{
    public static void main(String args[])
    {
    ConvierteDolares pagina=new ConvierteDolares();
    pagina.forma();
    }
}

En este programa tiene un paso de programa que no esta incluido que es de cerrar la ventana al terminar el frame, debes agregarlo.

Eventos generados por el componente List.

Los eventos producidos por un componente de la clase List se manejan a través de una clase anidada que implementa la interface ItemListener y define el método itemStateChanged. Los elementos seleccionados pueden recuperarse como String usando los métodos getSelectedItem y getSelectedItemes. También pueden recuperarse los índices de los elementos seleccionados con getSelectedIndex y getSelectedIndexes.

Componente List - Selección Simple

En este programa tiene un paso de programa que no esta incluido que es de cerrar la ventana al terminar el frame, debes agregarlo.





package pruebaeventoslistasimple;
import java.awt.*;
import java.awt.event.*;
    class EventosListaSimple
    {
        Frame v;
        List lista;
        ManejaEventosListaSimple oyeLista;
    class ManejaEventosListaSimple implements ItemListener
    {
        public void itemStateChanged(ItemEvent e)
            {
            Object fuente=e.getSource();
            if (fuente==lista)
                {
                System.out.println(lista.getSelectedItem());
                }
            }
    }

    void forma()
        {
            v=new Frame();
            v.setLayout(new FlowLayout() );
            lista = new List(4,false);
            lista.add("lunes");
            lista.add("martes");;
            lista.add("miercoles");
            lista.add("jueves");
            lista.add("viernes");
            lista.add("sabado");
            lista.add("domingo");

            lista.addItemListener(oyeLista=new ManejaEventosListaSimple() );
            v.add(lista);
            v.pack();
            v.setVisible(true);
        }
} //termina la clase EventosListaSimple

public class PruebaEventosListaSimple
{
    public static void main(String args[])
    {
        EventosListaSimple pagina=new EventosListaSimple();
        pagina.forma();
    }
}

Componente List - Selección Múltiple

En este programa tiene un paso de programa que no esta incluido que es de cerrar la ventana al terminar el frame, debes agregarlo.




package pruebaeventoslistamultiple;
import java.awt.*;
import java.awt.event.*;

    class EventosListaMultiple
    {
        Frame v;
        List lista;
        ManejaEventosListaMultiple oyeLista;
        class ManejaEventosListaMultiple implements ItemListener
        {
        public void itemStateChanged(ItemEvent e)
            {
            Object fuente=e.getSource();
            if (fuente==lista)
                {
                    for(int i=0;i<lista.getSelectedItems().length;i++)
                        {
                        System.out.println(lista.getSelectedItems()[i]);
                        System.out.println();
                        }
                }
            }
        }

        void forma()
        {
        v=new Frame();
        v.setLayout(new FlowLayout() );
        lista = new List(4,true);
        lista.add("lunes");
        lista.add("martes");;
        lista.add("miercoles");
        lista.add("jueves");
        lista.add("viernes");
        lista.add("sabado");
        lista.add("domingo");
        lista.addItemListener(oyeLista=new ManejaEventosListaMultiple() );
        v.add(lista);
        v.pack();
        v.setVisible(true);
        }
} //termina EventosListaMultiple
public class PruebaEventosListaMultiple{
public static void main(String args[]){
EventosListaMultiple pagina=new EventosListaMultiple();
pagina.forma();
}
}

Eventos generados por el componente Choice.

Los eventos generados por los componentes Choice pueden atenderse con la implementación de la interface ItemListener y la definición del método itemStateChanged. El método getSelectedItem regresa el elemento que haya sido seleccionado por el usuario.


En este programa tiene un paso de programa que no esta incluido que es de cerrar la ventana al terminar el frame, debes agregarlo.





package pruebaeventoschoice;
import java.awt.*;
import java.awt.event.*;

class EventosChoice
{
Frame v;
Choice selec;
ManejaEventosChoice oyeChoice;
    class ManejaEventosChoice implements ItemListener
        {
        public void itemStateChanged(ItemEvent e)
            {
            Object fuente=e.getSource();
            if (fuente==selec)
            System.out.println("Se eligio la opcion " + selec.getSelectedItem() );
            }
        }

    void forma()
    {
        v=new Frame();
        v.setLayout(new FlowLayout() );
        selec= new Choice();
        selec.add("< 18");
        selec.add("18-30");
        selec.add("30-40");
        selec.add("> 40");
        selec.setForeground(Color.yellow);
        selec.setBackground(Color.pink);
        selec.addItemListener(oyeChoice =new ManejaEventosChoice() );
        v.add(selec);
        v.pack();
        v.setVisible(true);
    }
} //termina EventChoice
public class PruebaEventosChoice{
public static void main(String args[]){
EventosChoice pagina=new EventosChoice();
pagina.forma();
}
}

Eventos generados por el componente Checkbox.

En el siguiente programa, el manejo de los eventos que se provocan al hacer cambios en alguno de los componentes Checkbox se implementa usando una clase anidada que define el método itemState. La clase Checkbox proporciona el método getState(), el cual regresa el estado (true/false) del componente que provocó el evento.


Evento de CheckBox en video.

El programa esta abajo.

En este programa tiene un paso de programa que no esta incluido que es de cerrar la ventana al terminar el frame, debes agregarlo.

package pruebaeventoscheckbox;
import java.awt.*;
import java.awt.event.*;

class EventosCheckbox
    {
    Frame v;
    Checkbox caja1,caja2,caja3;
    ManejaEventosCheckbox oyeCheckbox;
        class ManejaEventosCheckbox implements ItemListener
        {
            public void itemStateChanged(ItemEvent e)
                {
                Object fuente=e.getSource();
                if (fuente==caja1)
                System.out.println("opcion 1= " + caja1.getState() );
                if (fuente==caja2)
                System.out.println("opcion 2=" + caja2.getState() );
                if (fuente==caja3)
                System.out.println("opcion 3=" + caja3.getState() );
                }
        }
    void forma()
    {
        v=new Frame();
        v.setLayout(new FlowLayout() );
        caja1= new Checkbox("Opcion 1");
        caja2= new Checkbox("Opcion 2");
        caja3= new Checkbox("Opcion 3", true);
       
        caja1.addItemListener(oyeCheckbox=new ManejaEventosCheckbox () );
        caja2.addItemListener(oyeCheckbox);
        caja3.addItemListener(oyeCheckbox);

        v.add(caja1);
        v.add(caja2);
        v.add(caja3);
        v.pack();

        v.setVisible(true);
    }
}
public class PruebaEventosCheckbox{
public static void main(String args[]){
EventosCheckbox pagina=new EventosCheckbox();
pagina.forma();
}
}

Eventos generados por un componente CheckboxGroup

Al igual que en el ejemplo anterior, se requiere implementar la interfaz ItemListener y que cada componente Checkbox este vinculado con un objeto Itemlistener. En este caso una vez que se produce el evento, el método getSelectedCheckbox regresa el objeto Checkbox que lo generó y con getLabel se obtiene la etiqueta que lo identifica.




Evento CheckBoxGroup Video


package pruebaeventoscheckboxgroup;

import java.awt.*;
import java.awt.event.*;
    class EventosCheckboxGroup
    {
    Frame v;
    Checkbox caja1,caja2,caja3;
    ManejaEventosCheckboxGroup oyeCheckboxGroup;
    CheckboxGroup grupo;
        class ManejaEventosCheckboxGroup implements ItemListener
        {
            public void itemStateChanged(ItemEvent e)
            {
             System.out.println("Se selecciono "+grupo.getSelectedCheckbox().getLabel() );
            }
        }
    void forma()
    {
        v=new Frame();
        Panel p=new Panel();
        v.setLayout(new FlowLayout() );
        grupo= new CheckboxGroup();
        Checkbox caja1= new Checkbox("azul", grupo, true);
        Checkbox caja2= new Checkbox("rojo", grupo, false);
        Checkbox caja3= new Checkbox("amarillo", grupo, false);
        caja1.addItemListener(oyeCheckboxGroup=new ManejaEventosCheckboxGroup () );
        caja2.addItemListener(oyeCheckboxGroup);
        caja3.addItemListener(oyeCheckboxGroup);
        p.add(caja1);
        p.add(caja2);
        p.add(caja3);
        v.add(p);
        v.pack();
        v.setVisible(true);
    }// termina forma
} //termina EventosCheckBoxGroup

public class PruebaEventosCheckboxGroup{
public static void main(String args[]){
EventosCheckboxGroup pagina=new EventosCheckboxGroup();
pagina.forma();
}
}

Eventos generados por el componente MenuBar

El componente MenuBar por sí mismo no genera eventos, MenuBar trabaja en conjunto con MenuItem y es este quién si genera eventos. El manejo de eventos de MenuItem se hace implementado en una clase anidada el método actionPerformed de la interfaz ActionListener. A cada elemento MenuItem del menú de barra debe asociarsele con el oyente (listener). Cuando se produce el evento, getSource identifica el componente que fue activado y mediante una comparación se pueden ejecutar las acciones  correspondientes a la opción seleccionada.



Evento MenuBar video

package pruebaeventoscomponentesmenubar;
import java.awt.*;
import java.awt.event.*;

class EventosComponentesMenuBar
    {
    MenuBar principal;
    Menu quimicas,contab;
    Frame v;
    MenuItem quim1,quim2,quim3,cont1,cont2,cont3;
    ManejaEventosMenuBar oyeMenu;
        class ManejaEventosMenuBar implements ActionListener
     {
        public void actionPerformed(ActionEvent e)
        {
        Object fuente=e.getSource();
        if (fuente==quim1) System.out.println("Se eligio Ing. en Computacion");
        if (fuente==quim2) System.out.println("Se eligio Ing. en Electronica");
        if (fuente==quim3) System.out.println("Se eligio Ing. Quimico");
        if (fuente==cont1) System.out.println("Se eligio Contador Publico");
        if (fuente==cont2) System.out.println("Se eligio LAE");
        if (fuente==cont3) System.out.println("Se eligio Lic. Informatica");
        }
     }
        void forma()
        {
            v=new Frame();
            principal=new MenuBar();
            quimicas=new Menu("FCQI");
            contab=new Menu("FCA");
            quim1 =new MenuItem(" Ing.en Computacion ");
            quim2 =new MenuItem(" Ing.en Electronica ");
            quim3 =new MenuItem(" Ing.Quimico ");
            cont1 =new MenuItem(" Contador Publico ");
            cont2 =new MenuItem(" LAE ",new MenuShortcut(KeyEvent.VK_L,false) );
            cont3 =new MenuItem(" Lic. Inf");
            Panel p=new Panel(); v.setTitle("Prueba de Eventos de MenuBar");
            v.setLayout(new FlowLayout() );
            v.setMenuBar(principal);
            principal.add(quimicas);
            quimicas.add(quim1); quimicas.add(quim2); quimicas.add(quim3);
            principal.add(contab);
            contab.add(cont1); contab.add(cont2); contab.add(cont3);
            quim1.addActionListener(oyeMenu=new ManejaEventosMenuBar() );
            quim2.addActionListener(oyeMenu);
            quim3.addActionListener(oyeMenu);
            cont1.addActionListener(oyeMenu);
            cont2.addActionListener(oyeMenu);
            cont3.addActionListener(oyeMenu);
            v.pack();
            v.setVisible(true);
       } //termina forma
} //termina clase EventosComponentesMenuBar

class PruebaEventosComponentesMenuBar
    {
    public static void main(String args[]){
    EventosComponentesMenuBar pagina=new EventosComponentesMenuBar();
    pagina.forma();
    }
}

Componente MenuPopUp y Eventos generados por el Mouse

La clase MenuPopUp implementa un menú el cual puede ser desplegado en forma dinámica; es decir, puede ubicarse en distintas posiciones de la pantalla. Generalmente esta ligado a un evento del mouse.

Constructores de la Clase MenuPopUp.


Constructor Descripción
MenuPopUp() Crea un nuevo menú Pop-up sin etiqueta.
MenuPopUp(String) Crea un nuevo menú Pop-up con la etiqueta.

Métodos de la clase MenuPopUp


Método Descripción
add(MenuItem m); Agrega la opción m al menú.
add(String e); Agrega una opción con la etiqueta e al menú.
addSeparator();  Inserta una línea (separador) en el menú
 

 Métodos de la interface MouseEvent


Método Descripción
short getButton(); En eventos ocasionados por oprimir o liberar un botón del mouse, regresa el botón que haya cambiado de estado.
int getScreenX(); Regresa la coordenada horizontal en la cual el evento ocurrió.
int getScreenY(); Regresa la coordenada vertical en la cual el evento ocurrió.

Las opciones que presenta un Menú Pop-Up son componentes MenuItem y se tratan de la misma manera que las opciones de un componente Menu.

En el ejemplo, el menú pop-up aparecerá cada vez que el usuario hace click con el boton derecho del mouse, por lo que es necesario implementar el manejo de eventos generados por el mouse. Esto se hace extendiendo la clase abstracta MouseAdapter y agregando el oyente para el mouse al frame. Cuando se presiona un botón del mouse se genera un objeto de la clase MouseEvent. El método getButton() regresa el botón presionado representado por alguno de los campos estáticos de MouseEvent: BUTTON1, BUTTON2 y BUTTON3.


Para desplegar el menú Pop-Up la clase encargada del evento recibe el frame donde se generó el evento y el menú que se desea mostrar. Para que el menú aparezca en la posición (x,y) donde se hizo click es necesario extraer las coordenadas del objeto MouseEvent, esto se hace con los métodos getX() y getY().

 

  Evento PopUp Video


package pruebamenupopup;
import java.awt.event.*;
import java.awt.*;

class MenuPopUp
        {
        MenuBar principal;
        Menu quimicas,contab;
        Frame v;
        MenuItem quim1,quim2,quim3,cont1,cont2,cont3;
        ManejaEventosMenuBar oyeMenu;

        class ManejaEventosMenuBar implements ActionListener
        {
        public void actionPerformed(ActionEvent e)
            {
            Object fuente=e.getSource();
            if (fuente==quim1) System.out.println("Se eligio Ing. en Computacion");
            if (fuente==quim2) System.out.println("Se eligio Ing. en Electronica");
            if (fuente==quim3) System.out.println("Se eligio Ing. Quimico");
            if (fuente==cont1) System.out.println("Se eligio Contador Publico");
            if (fuente==cont2) System.out.println("Se eligio LAE");
            if (fuente==cont3) System.out.println("Se eligio Lic. Informatica");
            }// termina metodo actionPerformed
        }//termina clase ManejaEventosMenuBar
       
        class ManejaEventosMouse extends MouseAdapter
        {
        Frame marco;
        PopupMenu mpopup;
        ManejaEventosMouse( Frame frame,PopupMenu mP )
        {
        marco = frame;
        mpopup = mP;
        }
            public void mousePressed( MouseEvent event )
            {
            if( event.getButton()==MouseEvent.BUTTON1)
            System.out.println("Se presiono el boton 1");
            if( event.getButton()==MouseEvent.BUTTON2)
            System.out.println("Se presiono el boton 2");
            if( event.getButton()==MouseEvent.BUTTON3)
            System.out.println("Se presiono el boton 3");
            if( event.getY() > 0 && event.getButton()==MouseEvent.BUTTON3 )
            mpopup.show( marco,event.getX(),event.getY() );
            }//termina metodo mousePressed
    }// termina metodo ManejaMetodoMouse
       
    class ManejaEventosMenuItem implements ActionListener
    {
    public void actionPerformed( ActionEvent evt )
        {
        System.out.println( evt.getSource() );
        }
    }//termina actionPerformed

    class EventoFrame extends WindowAdapter
    {
    public void windowClosing( WindowEvent evt )
        {
        System.exit( 0 );
        }
    }//termina windowClosing

    public void forma()
    {
    principal=new MenuBar();
    quimicas=new Menu("FCQI");
    contab=new Menu("FCA");
    quim1 =new MenuItem(" Ing.en Computacion ");
    quim2 =new MenuItem(" Ing.en Electronica ");
    quim3 =new MenuItem(" Ing.Quimico ");
    cont1 =new MenuItem(" Contador Publico ");
    cont2 =new MenuItem(" LAE ",new MenuShortcut(KeyEvent.VK_L,false) );
    cont3 =new MenuItem(" Lic. Inf");
    Panel p=new Panel();
    v=new Frame("Prueba de Eventos de Menu Pop-Up");
    v.setLayout( new FlowLayout() );
    v.setMenuBar(principal);
    principal.add(quimicas);
    quimicas.add(quim1);
    quimicas.add(quim2);
    quimicas.add(quim3);
    principal.add(contab);
    contab.add(cont1);
    contab.add(cont2);
    contab.add(cont3);
    MenuItem primerElementoMenu = new MenuItem( "Primer Elemento" );
    MenuItem segundoElementoMenu= new MenuItem( "Segundo Elemento" );
    MenuItem tercerElementoMenu = new MenuItem( "Tercer Elemento" );
    primerElementoMenu.addActionListener ( new ManejaEventosMenuItem() );
    segundoElementoMenu.addActionListener( new ManejaEventosMenuItem() );
    tercerElementoMenu.addActionListener ( new ManejaEventosMenuItem() );
    PopupMenu menuPopup = new PopupMenu( "Menu Popup" );
    menuPopup.add( primerElementoMenu );
    menuPopup.add( segundoElementoMenu);
    menuPopup.add( tercerElementoMenu );
    quim1.addActionListener(oyeMenu=new ManejaEventosMenuBar() );
    quim2.addActionListener(oyeMenu);
    quim3.addActionListener(oyeMenu);
    cont1.addActionListener(oyeMenu);
    cont2.addActionListener(oyeMenu);
    cont3.addActionListener(oyeMenu);
    v.addMouseListener( new ManejaEventosMouse( v,menuPopup ) );
    v.addWindowListener( new EventoFrame() );
    v.setSize( 250,100 );
    v.add( menuPopup );
    v.pack();
    v.setVisible( true );
    }//termina metodo forma
}//termina class popup

class PruebaMenuPopUp {
public static void main( String args[] ) {
MenuPopUp objeto= new MenuPopUp();
objeto.forma();
}
}





 




http://panamahitek.com/creacion-de-eventos-en-java/
http://fcqi.tij.uabc.mx/usuarios/palacios/java8.pdf
Dietel Como programar en Java 9na.edicion pag. 131
Sección 3.8 Uso de cuadros de diálogo: entrada y salida básica con cuadros de diálogo
Sección 4.14 Creación de dibujos simples: mostrar y dibujar líneas en la pantalla
Sección 5.10 Dibujo de rectángulos y óvalos: uso de figuras para representar datos
Sección 6.13 Colores y figuras rellenas: dibujar un tiro al blanco y gráficos aleatorios
Sección 7.15 Dibujo de arcos: dibujar espirales con arcos
Sección 8.16 Uso de objetos con gráficos: almacenar figuras como objetos
Sección 9.8 Mostrar texto e imágenes usando etiquetas: proporcionar información de estado
Sección 10.8 Realizar dibujos usando polimorfismo: identificar las similitudes entre figuras Ejercicio 14.17 Caso de estudio de GUI y gráficos: expansión de la interfaz Ejercicio 15.31 Caso de estudio de GUI y gráficos: Agregar Java 2D