Swing
April 10, 2023 | Author: Anonymous | Category: N/A
Short Description
Download Swing...
Description
PROGRAMACIÓN GRÁFICA CON SWING........................................ ............................................................................... ....................................... 3 CARACTERISTICAS DE SWING ................................................................................................ 4 JERARQUÍA DE COMPONENTES DEL SWING ....................................................................... 5 COMPONENTES........................................ ..................................................................................... .................................................................................... ....................................... 9 EVENTOS ....................................................................................................................................... 9 ¿Qué es un evento? .................................................................................................................... 10 El modelo de delegación de eventos.......................................................................................... 10 Tipos de Eventos ....................................................................................................................... 14 Origen de eventos ...................................................................................................................... 16 Adapters ..................................................................................................................................... 19 COMPONENTES ATÓMICOS DEL SWING S WING ........................................ ............................................................................. ..................................... 24 JButton ....................................................................................................................................... 24 JCheckBox ................................................................................................................................. 24 JRadioButton ............................................................................................................................. 26 JList ........................................................................................................................................... 29 JComboBox ............................................................................................................................... 31 JLabel ........................................................................................................................................ 32 JTextField y JPasswordField ..................................................................................................... 33 JTextArea................................................................................................................................... 36 CUADROS DE DIALOGO ESTÁNDAR .................................................................................... 38 JOptionPane ............................................................................................................................... 38 JFileChooser .............................................................................................................................. 43 JColorChooser ........................................................................................................................... 45 LAYOUTS .................................................................................................................................... 47 FlowLayout ................................................................................................................................ 48 BorderLayout ............................................................................................................................. 49 GridLayout ................................................................................................................................ 51 CONTENEDORES DE ALTO NIVEL ........................................................................................ 54 JDialog ....................................................................................................................................... 55 CONTENEDORES DE NIVEL INTERMEDIO .......................................................................... 56 JScrollPane ................................................................................................................................ 56 JPanel ......................................................................................................................................... 59
JtabbedPane ............................................................................................................................... 61 JSplitPane .................................................................................................................................. 63 JToolBar .................................................................................................................................... 65 MENUS ......................................................................................................................................... 67 JMenuBar .................................................................................................................................. 67 JMenu ........................................................................................................................................ 67 JMenuItem ................................................................................................................................. 68 OTRAS CLASES BÁSICAS ........................................................................................................ 74 Evento con Teclado ................................................................................................................... 74 CLASE Color ............................................................................................................................ 78 CLASE Font .............................................................................................................................. 80 CLASE MouseAdapter .............................................................................................................. 81 CLASE ImageIcon .................................................................................................................... 83 CLASE Graphics ....................................................................................................................... 85 "Look & Feel"
CONFIGURANDO EL DE UNA APLICACIÓN ........................................... 92 APPLETS ...................................................................................................................................... 98 Ciclo de vida de un applet ......................................................................................................... 98 El tag Applet en HTML HT ML .......................................... ....................................................................................... ................................................................. .................... 104 Paso de parámetros a un applet desde HTML ......................................................................... 111 Ejemplos con el método m étodo getParameter() ............................................... .................................................................................. ................................... 112
PROGRAMACIÓN GRÁFICA CON SWING El objetivo de este tema es enseñar a diseñar pequeñas interfaces gráficas empleando para ello las librerías gráficas Swing. Una interfaz es lo que le permite a un usuario comunicarse con un programa, una interfaz es lo que nosotros vemos al arrancar, por ejemplo, navegador de internet: de menús, botones,a barras.... queweb, nos permiten un activar un código que es un el conjunto que realmente nos llevará una página salvará la imagen en el disco duro.... Las librerías gráficas que usaremos vienen a sustituir a las antiguas AWT. Las nuevas librerías a parte de tener una mayor cantidad de opciones sobre los componentes (como distintas apariencias, control sobre el focus, mayor número de campos que modifican su aspecto, mayor facilidad para pintar al hacer el buffering transparente al usuario....) se diferencian de las anteriores radicalmente en su implementación.
Ojo: En AWT cuando añadíamos un botón, por ejemplo, a nuestro diseño el compilador generaba código que le pedía al sistema operativo la creación de un botón en un determinado sitio con unas determinadas propiedades; en Swing ya no se pide al sistema operativo nada: se dibuja el botón sobre la ventana en la que lo queríamos. Con esto se eliminaron muchos problemas que existían antes con los códigos de las interfaces gráficas, que debido a depender del sistema operativo para obtener sus componentes gráficos, era necesario probar los programas en distintos sistemas operativos, pudiendo tener distintos bugs en cada uno de ellos. Esto evidentemente iba en contra de la filosofía de Java, supuestamente un lenguaje que no dependía de la plataforma. Con Swing se mejoró bastante este aspecto: lo único que se pide al sistema operativo es una ventana, una vez que tenemos la ventana dibujamos botones, listas, scroll-bars... y todo lo que necesitemos sobre ella. Evidentemente esta aproximación gana mucho en lo que a independencia de la plataforma se refiere. Además el hecho de que el botón no sea un botón del sistema operativo. sino un botón pintado por Java nos da un mayor control sobre su apariencia. Una estrategia para estudiar SWING es dividirlas en:
Componentes.
Contenedores. Layouts (Administ (Administradores radores de diseño). Eventos.
Componentes. Son clases o interfaces que permiten crear los objetos gráficos que componen una GUI (Graphics User Interface) tales como; botones, listas desplegables, cuadros de texto, casillas de verificación, botones de opción, campos de texto, etiquetas, menús, etc.
Contenedores. Son clases o interf interfaces aces que permi permiten ten crear obj objetos etos gráficos para contener a los componentes, tales como; paneles, cuadros de diálogo, marcos, ventanas, etc.
Layouts. Son clases o interfaces que permiten crear objetos que administren el diseño, la distribución y colocación de los objetos componentes dentro de los objetos contenedores. Por ejemplo el FlowLayout distribuye los componentes de izquierda a derecha y de arriba a abajo, el BorderLayout los distribuye en cinco áreas geográficas; norte, sur, este, oeste y centro, etc.
Eventos. Son las cl clases ases o interf interfaces aces que permi permiten ten crear obj objetos etos que captur capturen en y manejen los eventos. Un evento es una acción sobre algún componente, componente, por ejemplo, clic a un botón, pulsar la tecla de enter en un botón, mover un elemento con las teclas de navegación, eventos ev entos especiales como los progr programados amados por ttiempo, iempo, etc. Sin los eventos las GUI serían interfaces gráficas sin vida, y por lo tanto no serían muy útiles que digamos.
CARACTERISTICAS CARACTERISTICA S DE SWING
Se creo como una extensión de la AWT añadiendo las siguientes características: Componentes Swing. Soporte de Look& Feel. accesibilidad. dad. API de accesibili Java 2D API. Soporte de Drag& Drop.
Habitualmente también se usa como término genérico para referirse a las JFC (Java Foundation Classes). Su diferencia más importante con la AWT es que los componentes son “lightweight”. Para diferenciar los componentes Swing de los AWT, sus nombres están precedidos por una ‘J’. Todas las clases Swing se encuentran en el paquete javax.swing.* Nunca debemos mezclar componentes Swing con componentes AWT en una misma aplicación: “Lightweight” vs. “Heavyweight”. Swing sigue trabajando con los conceptos de la AWT: Contenedores. Componentes. LayoutManagers. Eventos.
JERARQUÍA DE COMPONENTES DEL SWING
COMPONENTES Como habíamos mencionado al principio de este capítulo, los componentes son clases o interfaces que permiten crear los objetos gráficos que componen una GUI. La tabla siguiente nos introduce brevemente a la amplia gama de los componentes deL SWING.
Tipo de Componente
Descripción
JButton Es un botón usado para recibir el clic del ratón. JCanvas Un lienzo o panel usado para dibujar. JCheckbox Cuadro de verificación. Es un componente que le permite seleccionar un elemento. JCheckboxMenuItem Es un cuadro de verificación dentro de un menú. JChoice Es una lista desplegable de elementos estáticos. JComponent JContainer JDialog JFrame JLabel JList JMenu JMenuItem JPanel JScroollbar JScroolPane JTextArea
Se trata de una clase abstracta que implementa toda la funcionalidad básica de las clases visuales. Es el padre de todos los contenedores. Es un cuadro de diálogo o una ventana de alto nivel con titulo y bordes. Es un marco o ventana y es la clase base de todas las ventanas ventanas GUI con controles para ventana. Etiqueta. Es una cadena de texto como componente. Un componente que contiene un conjunto dinámico de elementos. Es un elemento dentro de la barra de menú, el cual contiene un conjunto de elementos de tipo menú. Un elemento dentro de un menú. Una clase contenedora básica usado frecuentemente para crear diseños (layouts) complejos. Un componente que permite al usuario hacer una selección dentro de un rango de valores. Una clase contenedora que implementa un deslizador horizontal y vertical para un único componente hijo. Un componente que permite al usuario introducir texto en un bloque o rectángulo.
Tabla. Componentes básicos de SWING. SWING.
EVENTOS El sistema de gestión de eventos de Java 1.2 es el mismo que Java 1.1 y por lo tanto el mismo que para las librerías AWT. Aunque los desarrolladores de Java considerasen que para mejorar el lenguaje se necesitaba dejar a un lado las librerías AWT e introducir las Swing no sintieron lo mismo del sistema de gestión de eventos, consideraron que era lo suficientemente bueno. Realmente este sistema de gestión de eventos es bastante elegante y sencillo, sobre todo si se compara con el sistema de gestión de eventos de Java 1.0, mucho más engorroso de usar y menos elegante.
¿Qué ¿Q ué es un even evento to Un evento es una acción sobre algún componente. Todos los sistemas operativos tendie diend ndo o a llos os e eve vento ntos s ge gene nerad rados os por los usuarios. Estos están constantemente ten eventos p pu ueden s se er p pu ul ar una tecla, mover el ratón, hacer clic con el ratón, pulsar el (Jav (Java a disti distingu ngue e ent entre re simp simplemen lementt pulsar el ratón en un ratón sobre un botón o menú si siti tio oc cua ualq lqui uier era aoh hac acer erll , por ejemplo, en un botón). El sistemaeoperativo notifica a las curriend endo o esto estos s even eventos, tos, y e ellas llas d decid ecide e si han de responder o aplicaciones que están curri no de a algú lgún nm mod odo oae est st evento.
El modelo de deleg ción de eventos El modelo de Java se asa en la delegación de eventos : el evento se produce en un dete de term rmin ina ado co comp mpon onen ente, por ejemplo un botón. Dónde se produce el evento se denomina “fuente del e ento”. A continuación ión e ell e ev vento se ttrransmite a un ”manejador de eventos” (event liste er) que este asignado al componente n el que se produjo el evento. El objeto que escucha cucha los event eventos os e es s el q que ue s se e en enca carga rgará de responder a ellos adecuadamente. Esta separación de código entre generación el evento y actuación resp spe ecto cto a él ffa acili lita ta la labor d de el p prrograma mad dor y da una ma may yor c cla laridad a los códigos.
Figura. Gestión de eventos en Java.
Explicación de la Figura: A la fuente del evento, en este caso un botón, le indicamos quién será su manejador de eventos (es el método que atenderá el evento), manejador que ha de extender la clase Adapter correspondiente o implementar la interfaz Listener (interfaz ActionLitener en este caso). Cuando el usuario genere el evento deseado (en este caso pulse el botón), el objeto fuente empaqueta información a cerca del evento generando un objeto de tipo Event (ActionEvent en este caso) e invoca el método correspondiente del manejador (actionPerformed(actionEvent)) pasándole como información objeto de altipo Eventpor generado. Es responsabilidad del manejador, no de la fuente,elresponder evento, ello se dice que la fuente delega la gestióny del evento en el manejador. Lo que la fuente de eventos le pasa al objeto encargado de escuchar los eventos es, como no, otro objeto. Es un objeto tipo Event. En este objeto va toda la información necesaria para la correcta gestión del evento por parte del objeto que escucha los eventos. El objeto que escucha los eventos ha de implementar para ello una
interface. El nombre de esta interface es siempre el nombre del evento más “Listener”. Para que un objeto escuche eventos de ratón ha de implementar la interface MouseListener, para que escuche eventos de teclado KeyListener.....
import java.awt.FlowLayout; import java.awt.e java.awt.event.*; vent.*; import javax.swing.JButton; import javax.swing.JFrame; { public public class static JButtonTest1 void main(String[] args) { JFrame f=new JFrame(); f.setTitle("JButtonTest"); f.setTitle("JButtonTest" ); //(Largo,Alto)dimensió lto)dimensión n de la ventana ventana del frame frame f.setSize(300,150); //(Largo,A f.setSize(300,150); //Coloca los componentes componentes de forma consecutiva consecutiva f.getContentPane().setLayout( new FlowLayout()); /*Manejador jador de Eventos Eventos para todos los botones Utiliza Clase Clase Anónima*/ /*Mane ActionListener actionListener = new ActionListener() { //Agrega { //Agregamos mos un oyente oyente al botón botón public void actionPerformed(ActionEvent ev) { //Tratamiento //Tratamiento del evento evento out .println("Etiqueta .println("Etiqueta del botón: "" + + ev.getActionCommand()); System.out System. } }; JButton b1= new JButton( JButton("Aceptar" "Aceptar"); ); //Crea //Crea un Botón con con la Etiqueta Etiqueta Aceptar Aceptar //se dispa dispara ra el evento evento b1.addActionListener(actionListener); //se b1.addActionListener(actionListener); al Contenedor Contenedor f.getContentPane().add(b1); //Agrega //Agrega el botón al JButton b2= new JButton( JButton("Cancelar" "Cancelar"); ); //Crea //Crea un Botón con la Etiqueta Cancelar Cancelar //se dispa dispara ra el evento evento b2.addActionListener(actionListener); //se b2.addActionListener(actionListener); f.getContentPane().add(b2); //Agrega //Agrega el botón al al Contenedor Contenedor JButton("Reintentar" "Reintentar"); ); //Crea //Crea un Botón con con la Etiqueta Etiqueta Reintentar Reintentar JButton b3= new JButton( //se dispa dispara ra el evento evento b3.addActionListener(actionListener); //se b3.addActionListener(actionListener); f.getContentPane().add(b3); //Agrega //Agrega el botón al al Contenedor Contenedor // jdk1.3+=> Cerrar una ventana ventana f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ));; //
f.setVisible( true); } //end //end main() main() } ///:~ ///:~
import java.awt.FlowLayout; import java.awt.event.*; import javax.swing.JButton; import javax.swing.JFrame; public class JButtonTest2 { public static void main(String[] args) { JFrame f=new JFrame(); "JButtonTest"); ); f.setTitle("JButtonTest" f.setTitle( f.setSize(200,150); //(Largo,Alto)dimensión de la ventana del frame f.setSize(200,150); //(Largo,Alto)dimensión frame FlowLayout()); //Coloca //Coloca los componentes de forma consecutiva consecutiva f.getContentPane().setLayout( new FlowLayout()); /*Manejador de Eventos en cada uno de los botones botones *Utiliza Clase Anónima*/ JButton b1= new JButton( JButton("Aceptar" "Aceptar"); ); //Crea //Crea un Botón con la Etiqueta Aceptar Aceptar //Agregamos un oyente al botón botón b1.addActionListener(new ActionListener() { //Agregamos public void actionPerformed(ActionEvent ev) { //Tratamiento //Tratamiento del evento evento out .println("Etiqueta .println("Etiqueta del botón: " + " + ev.getActionCommand()); System.out System. } }); Contenedor ontenedor f.getContentPane().add(b1); //Agrega //Agrega el botón al C JButton b2= new JButton( JButton("Cancelar" "Cancelar"); ); //Crea //Crea un Botón con la Etiqueta Cancelar Cancelar //Agregamos un oyente al botón botón b2.addActionListener( new ActionListener() { //Agregamos public void actionPerformed(ActionEvent ev) { //Tratamiento //Tratamiento del evento evento System.out System. out .println("Etiqueta .println("Etiqueta del botón: " + " + ev.getActionCommand()); } }); f.getContentPane().add(b2); //Agrega //Agrega el botón al C Contenedor ontenedor f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ));; // f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE // jdk1.3+=> Cerrar una ventana ventana f.setVisible(true); } } ///:~ ///:~
Tipos de Eventos Físicos:
ComponentEvent
Esconder, mover, redimensionar, mostrar un componente.
ContainerEvent
Añadir o eliminar un componente de un container.
FocusEvent
Obtener o perder el focus.
KeyEvent
Pulsar, soltar una tecla.
MouseEvent
Pulsar o soltar un botón del ratón; entrar o salir de un componente; mover o arrastrar el ratón (tener en cuenta que este evento tiene dos Listener). MouseListener y MouseMotionListener.
MouseMotionEvent Arrastrar o mover el mouse. WindowEvent
Maximizar, minimizar, abrir, cerrar, activar o desactivar una ventana.
Semánticos:
ActionEvent
Clic en el botón.
AdjustmentEvent
Cambiar el valor de un componente.
ItemEvent
Seleccionar o deseleccionar un Item.
TextEvent
Un texto ha cambiado.
Nuevos tipos de eventos AncestorEvent CaretEvent ChangeEvent DocumentEvent HyperlinkEvent InternalFrameEvent ListDataEvent
Un padre se ha añadido, movido o eliminado. El cursor en un texto ha cambiado. El estado ha cambiado. Los atributos de un Document han cambiado, se ha insertado o se ha eliminado contenido. Se ha activado, entrado o salido de un hyperlink. Se ha activado, cerrado, desactivado, minimizado, maximizado o abierto un internal frame. Ha cambiado el contenido.
Nuevos tipos de eventos ListSelectionEvent MenuDragMouseEvent
Ha cambiado la selección en una lista. El ratón se ha arrastrado, entrado, salido, soltado en un menú. Se ha seleccionado o deseleccionado un menú. MenuEvent MenuKeyEvent Se ha pulsado, soltado o tecleado sobre un menú. PopupMenuEvent Se ha mostrado, ocultado o seleccionado un menú emergente. TableColumnModelEvent Se ha añadido, eliminado, movido, redimensionada o seleccionada una columna. TableModelEvent El modelo de la tabla ha cambiado.
Nuevos tipos de eventos TreeExpansionEvent Se ha abierto o cerrado el árbol. TreeModelEvent TreeSelectionEvent UndoableEditEvent
Se ha cambiado, añadido o eliminado un elemento del árbol. Ha cambiado la selección en el árbol. Se ha realizado una operación que no se puede deshacer.
Origen de eventos Evento Listener interface Método que escucha el evento
Componente Swing Swing
ActionEvent ActionListener addActionListen er() AbstractButton
AdjustmenEvent AdjustmenListener addAdjustmenListe ner()
ComponentEvent ComponentListener addComponentListe ner()
ContainerEvent ContainerListener addContainerListen er()
FocusEvent FocusListener addFocusListen er()
ItemEvent ItemListener addItemListen er()
x
KeyEvent KeyListener addKeyListen er()
MouseEvent MouseListener addMouseListen er()
MouseMotionEvent MouseMotionListener addMouseMotionListe ner()
xx x x
xx x x
xx x x
x x x x
x x x x
x x x x
TextEvent TextListener addTextListen er()
WindowEvent WindowListener addWindowListen er()
x
JApplet JButton
xx x x
x
JCanvas JCheckBox JCheckBoxMenuI tem JChoice
x
JComboBox
x
x x x x
JComponent JContainer DefaultButtonMod el JDialog
x
JFileChooser
x
JFrame JLabel JList
x x x
JPanel JPopupMenu
xx x x
x x x x
x x
x x x
JFileDialog
JMenu JMenuItem
x
x
x
x
x
x
x
x
x
x x x x
x x
x x x x
x x x x
x x x x
x x x x
x x
x x
x
x
x
x
x
x
x x x x x
x x x x x
x x x x x
x x x x x
x x x
x
x
x
JScrollBar
x
x x x x x
JScrollPane JTextArea JTextField
x
Window
x x
Tabla. Listeners de los componentes básicos de Swing.
Componente Swing Swing
AncestorEvent
CaretEvent
CellEditorEvent
ChangeEvent
ColumnModelEvent
DocumentEvent
AncestorListener addAncestorListener()
CaretListener addCaretListener()
CellEditorListener addCellEditorListener()
ChangeListener addChangeListener()
ColumnModelListener addColumnModelListener()
DocumentListener addDocumentListener()
AbstractBut ton AbstractButton AbstractDocument DefaultBoundedRangeModel DefaultButtonModel DefaultCaret DefaultCellEditor DefaultColorSelectionModel DefaultSingleSelectionModel DefaulStyledDocument DefaultTableColumnModel DefaultTreeCellEditor JComponent MenuSelectionManager JProgressBar JTabbedPane JTextComponent JSlider
x
x
x x x x x x x x x x x x x x x
JViewport StyleContext StyleContext.NamedStyle
xx x
Tabla. Listeners de los componentes avanzados de Swing. Componente Swing AbstractListModel DefaultListSelectionModel JEditorPane JInternalFrame JMenuItem JList
HyperlinkEvent HyperlinkListener addHyperlinkListener()
InternalFrameEvent InternalFrameListener addInternalFrameListener()
ListDataEvent ListDataListener addListDataListener()
ListSelectionEvent ListSelectionListener addListSelectionListener()
MenuDragMouseEvent MenuDragMouseListener add MenuDragMouseListener()
MenuKeyEvent MenuKeyListener addMenuKeyListener()
x x x x x
x
x
Tabla. Listeners de los componentes avanzados de Swing.
Componente Swing
MenuEvent MenuListener addMenuListener()
AbstractAction AbstractTableModel DefaultTreeModel DefaultTreeSelectionModel JComponent JMenu JPopupMenu JTree SwingPropertyChangeSupport TableColumn UIDefaults UIManager
PopupMenuEvent PopupMenuListener addPopupMenuListener()
PropertyChangeEvent PropertyChangeListener addPropertyChangeListener() x
TableModelEvent TableModelListener addTableModelListener() x
x x x
x x x x x
Tabla. Listeners de los componentes avanzados de Swing.
Componente Swing
TreeExpansionEvent TreeExpansionListener addTreeExpansionListener()
AbstractDocument DefaultTreeModel DefaultTreeSelectionModel JComponent JTree UndoableEditSupport
TreeModelEvent TreeModelListener addTreeModelListener()
TreeSelectionEvent TreeSelectionListener addTreeSelectionListener()
UndoableEditEvent UndoableEditListener add UndoableEditListener() x
VetoableChangeEvent VetoableChangeListener add VetoableChangeListener()
x x X
x
x x
Tabla. Listeners de los componentes avanzados de Swing.
Adapters Cabe preguntarse ahora qué métodos tiene cada interface, ya que hemos de implementar todos ellos, incluso aunque no los usemos, usemos, sino la clase que se encargaría de escuchar los eventos sería abstracta y no podríamos crear ningún objeto de ella. Parece un poco estúpido implementar métodos que no hagan nada sólo porque la interface de la que heredamos los tenga. Así por ejemplo si estamos interesados en escuchar cerrar la ventana de un JFrame hemos de crear una clase que implemente WindowListener, pero nosotros sólo estaremos interesados en un método de dicha interfase: windowClosing(WindowEvent ev). ev). Los creadores de Java también pensaron en esto y por ello para cada interface que tiene más de un método crearon una clase llamada [nombre_evento]Adapter (WindowAdapter), (WindowAdapter), que lo que hace es implementar todos los métodos de la interface sin hacer nada en ellos. Nosotros lo único que tendremos que hacer es que nuestra clase que escuche eventos extienda esta clase y sobrescriba los métodos que nos interesen. import java.awt.event.*; import java.awt.event.*; import javax.swing.JFrame; import javax.swing.JFrame; public public class class WindowListenerTest WindowListenerTest{{ public public static static void main(String[] void main(String[] args) { JFrame(); JFrame f=new f=new JFrame();
Listener"); ); f.setTitle("Probando cerrar Window con Listener" f.setTitle("Probando f.setSize(300,150); //(Largo,Alto)dimensión f.setSize(300,150); frame //(Largo,Alto)dimensión de la ventana del frame /*Como es una Interface se deben de implementar *todos sus métodos de WindowListener*/ f.addWindowListener(new f.addWindowListener( new WindowListener() WindowListener() { public void void windowClosing(WindowEvent windowClosing(WindowEvent ev) { System. exit (0); (0); } public windowActivated(WindowEvent ev) {} public void windowActivated(WindowEvent public void windowClosed(WindowEvent ev) {} public void public void windowClosed(WindowEvent public void public void windowDeactivated(WindowEvent windowDeactivated(WindowEvent ev) {} public void windowDeiconified(WindowEvent windowDeiconified(WindowEvent ev) {} public void public void public void windowIconified(WindowEvent windowIconified(WindowEvent ev) {} public void windowOpened(WindowEvent windowOpened(WindowEvent ev) {} public void }); //f.setDefaultCloseOperation(JFrame. //f.setDefaultCloseOpera tion(JFrame.EXIT_ON_CL EXIT_ON_CLOSE);//jdk1 OSE);//jdk1.3+=>Cerrar .3+=>Cerrar una una ventana ventana
); f.setVisible(true); f.setVisible(true
} } ///:~ ///:~
import java.awt.event.*; import java.awt.event.*; import javax.swing.JFrame; import javax.swing.JFrame; public class public class WindowAdapterTest WindowAdapterTest { { public static static void main(String[] void main(String[] args) { public JFrame(); JFrame f=new f=new JFrame(); "Probando Cerrar Window con Adpaters" Adpaters"); ); f.setTitle("Probando f.setTitle( //(Largo,Alto)dimensión de la ventana del frame f.setSize(300,150); //(Largo,Alto)dimensión f.setSize(300,150); frame Java /* Código obsoleto para cerrar ventanas en Java *Como es una clase Adapter solo se implementa el método método *que se requiere para cerra la ventana*/ new WindowAdapter() WindowAdapter() f.addWindowListener( f.addWindowListener(new { public void void windowClosing(WindowEvent windowClosing(WindowEvent ev) { public System.exit (0); (0); } }); //f.setDefaultCloseOperation(JFrame.E //f.setDefaultCloseOperat ion(JFrame.EXIT_ON_CLO XIT_ON_CLOSE);// SE);// jdk1.3+=> jdk1.3+=> Cerrar una una ventana ventana
f.setVisible(true f.setVisible( true); );
}
} ///:~ ///:~ A continuación en la siguiente tabla damos un listado de las principales interfaces junto a sus respectivas clases clases “Adapter” y los métodos que poseen:
Evento Listener interface Y Adapter ActionEvent ActionListener AdjustmentEvent AdjustmentListener ComponentEvent ComponentListener ComponentAdapter ContainerEvent ContainerList ContainerAdapter FocusEvent FocusListener FocusAdapter ItemEvent ItemListener KeyEvent KeyListener KeyAdapter
Métodos con su evento (ev ev es es una instancia del objeto event, puede ser cualquier otro nombre). nombre). actionPerformed(ActionEvent ev) adjustmentValueChanged(AdjustmentEvent ev) componentHidden(ComponentEvent ev) componentShown(ComponentEvent ev) componentMoved(ComponentEvent ev) componentResized(ComponentEvent ev) componentAdded(ContainerEvent ev) componentRemoved(ContainerEvent ev) focusGained(FocusEvent ev) focusLost(FocusEvent ev) itemStateChanged(ItemEvent ev) keyPressed(KeyEvent ev) keyReleased(KeyEvent ev) keyTyped(KeyEvent ev)
MouseEvent MouseListener MouseAdapter MouseEvent MouseMotionListener MouseMotionAdapter TextEvent TextListener WindowEvent WindowListener WindowAdapter
mouseClicked(MouseEvent ev) mouseEntered(MouseEvent ev) mouseExited(MouseEvent ev) mousePressed(MouseEvent ev) mouseReleased(MouseEvent ev) mouseDragged(MouseEvent ev) mouseMoved(MouseEvent ev) textValueChanged(TextEvent ev) windowActivated(WindowEvent ev) windowClosed(WindowEvent ev) windowClosing(WindowEvent ev) windowDeactivated(WindowEvent ev) windowDeiconified(WindowEvent ev) windowIconified(WindowEvent ev) windowOpened(WindowEvent ev)
Tabla. Interfaces y Adapters con sus respectivos métodos.
Evento Listener interface AncestorEvent AncestorListener CaretEvent CaretListener CellEditorEvent CellEditorListener ChangeEvent ChangeListener DocumentEvent DocumentListener HyperlinkEvent HyperlinkListener InternalFrameEvent InternalFrameListener
Métodos con su evento (ev ev es es una instancia del objeto event, puede ser cualquier otro nombre). nombre). ancestorAdded(AncestorEvent ev) ancestorMoved(AncestorEvent ev) ancestorRemoved(AncestorEvent ev) caretUpdate(CareEvent ev) editingCanceled(CellEditorEvent ev) editingStopped(CellEditorEvent ev) stateChanged(ChangedEvent ev) changedUpdate(DocumentEvent ev) insertUpdate(DocumentEvent ev)ev) removeUpdate(DocumentEvent hyperlinkUpdate(HyperlinkEvent ev) internalFrameActivated(InternalFrameEvent ev) internalFrameClosed(InternalFrameEvent ev) internalFrameClosing(InternalFrameEvent ev) internalFrameDeactivated(InternalFrameEvent ev) internalFrameDeiconified(InternalFrameEvent ev) internalFrameIconified(InternalFrameEvent ev)
internalFrameOpened(InternalFrameEvent ev) contentsChanged(ListDataEvent ev) intervalAdded(ListDataEvent ev) intervalRemoved(ListDataEvent ev) valueChanged(ListSelectionEvent ev)
ListDataEvent ListDataListener
ListSelectionEvent ListSelectionListener MenuDragMouseEvent menuDragMouseDragged(MenuDragMouseEvent ev) MenuDragMouseListener menuDragMouseEntered(MenuDragMouseEvent ev) menuDragMouseExited(MenuDragMouseEvent ev) menuDragMouseReleased(MenuDragMouseEvent ev) MenuKeyEvent menuKeyPressed(MenuKeyEvent ev) MenuKeyListener menuKeyReleased(MenuKeyEvent ev) menuKeyTyped(MenuKeyEvent ev) MenuEvent menuCanceled(MenuEvent ev) MenuListener menuDeselected(MenuEvent ev) menuSelected(MenuEvent ev) Tabla. Interfaces y Adapters nuevos con sus respectivos métodos.
Evento Listener interface MouseInputEvent MouseInputListener
PopupMenuEvent PopupMenuListener
Métodos con su evento (ev ev es es una instancia del objeto event, puede ser cualquier otro nombre). nombre). mouseClicked(MouseInputEvent ev) mouseDragged(MouseInputEvent ev) mouseEntered(MouseInputEvent ev) mouseExited(MouseInputEvent ev) mouseMoved(MouseInputEvent ev) mousePressed(MouseInputEvent ev) mouseReleased(MouseInputEvent ev) popupmenuCanceled(PopupMenuEvent ev) popupMenuWillBecomeInvisible(PopupMenuEvent ev) popupMenuWillBecomeVisible(PopupMenuEvent ev)
TableColumnModelEvent ev) TableColumnModelListener columnAdded(TableColumnModelEvent columnMarginChanged(TableColumnModelEvent ev) columnMoved(TableColumnModelEvent ev) columnRemoved(TableColumnModelEvent ev) columnSelectionChanged(TableColumnModelEvent ev) TableModelEvent tableChanged(TableModelEvent ev) TableModelListener TreeExpansionEvent treeCollapsed(TreeExpansionEvent ev) TreeExpansionListener treeExpanded(TreeExpansionEvent ev) TreeModelEvent treeNodesChanged(TreeModelEvent ev)
TreeModelListener TreeSelectionEvent TreeSelectionListener UndoableEditEvent UndoableEditListener
treeNodesInserted(TreeModelEvent ev) treeNodesRemoved(TreeModelEvent ev) treeStructureChanged(TreeModelEvent ev) valueChanged(TreeSelectionEvent ev) undoableEditHappened(UndoableEditEvent ev)
Tabla. Interfaces y Adapters nuevos con sus respectivos métodos.
COMPONENTES ATÓMICOS DEL SWING En esta sección veremos ejemplos que hacen uso de los componentes, del paquete los cuales puede escoger esc oger para crear su GUI. java.x.swing los java.x.swing
JButton Ya nos es familiar que un objeto de la clase JButton sea un componente. El manejo de JButton sea botones ya se abordo en la sección de El modelo de delegación de eventos, eventos, por tal motivo se dará por visto este tema. Evento: if(ev.getStateChan if(ev.getStateChange()== ge()== ItemEvent.SELECT ItemEvent.SELECTED ED
JCheckBox El componente JCheckBox JCheckBox nos provee de un simple dispositivo de encendido/apagado con una etiqueta de texto a un lado. Veamos el siguiente ejemplo: Si se selecciona el JCheckBox JCheckBox correspondiente desplegará el sabor del helado correspondiente, si se quita la marca de verificación o la palomita escribirá que se
deselecciono ese sabor correspondiente. import javax.swing.JFrame; import javax.swing.JCheckBox; import java.awt.FlowLayout; import import java.awt.Color; java.awt.event.Item java.awt.event.ItemListener; Listener; import java.awt.event.Item java.awt.event.ItemEvent; Event; public class JCheckBoxTest{ public static void main(String args[]){ JFrame f = new JFrame(); f.setTitle("Ricos f.setTitle( "Ricos Helados" Helados"); ); // // titulo del JFrame Establece el titulo de la ventana f.setSize(370,145); Establece el tamaño de la ventana f.getContentPane().setLayout(new FlowLayout());
JCheckBox ckBox // se crean los componentes JChe new JCheckBox("FRESA" JCheckBox( "FRESA"); ); //Se //Se inicializa con FRESA JCheckBox fresa = JCheckBox mango = new JCheckBox(); JCheckBox limon = new JCheckBox(); ; // color del fondo, hereda de la clase JComponent JComponent fresa.setBackground(Color.pink )); // ItemListener() // // se agrega un oyente fresa.addItemListener(new ItemListener() { public void it itemStateChanged(Item emStateChanged(ItemEvent Event ev){ //se implementa un método por clar claridad idad del código fresita (ev); evento (ev); //// se delega el evento } });
mango.setText("MANGO"); mango.setText("MANGO" ); mango.setBackground(Color.yellow ));; mango.addItemListener(new ItemListener() { public void it itemStateChanged(Item emStateChanged(ItemEvent Event ev){ //se hace la implementación aqui mismo mismo if (ev.getStateChange (ev.getStateChange()== ()== ItemEvent.SELECTED ) System.out .println("Rico .println("Rico helado de mango"); mango"); else System.out .println("Deselecciono .println("Deselecciono mango" mango"); ); } }); ); limon.setText("LIMON"); limon.setText("LIMON" limon.setBackground(Color.green ); limon.addItemListener(new ItemListener() { public void itemStateChanged(ItemEvent ev){ if(ev.getStateChange() == ItemEvent.SELECTED ) System.out .println("Rico .println("Rico helado de limón"); limón"); else System.out .println("Deselecciono .println("Deselecciono Limón"); Limón"); } });
f.getContentPane().add(fresa); //Agrega //Agrega el componente al Contenedor Contenedor f.getContentPane().add(mango); //Agrega //Agrega el componente al Contenedor Contenedor f.getContentPane().add(limon); //Agrega //Agrega el componente al Contenedor f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ));; // // jdk1.3+=> Cerrar una ventana la ventana f.setVisible( ); Hace //el método true setVisible se hereda de la visible super superclase clase Component } //end //end main()
private static void fresita(ItemEvent ev){ if (ev.getStateChang (ev.getStateChange() e() == ItemEvent.SELECTED ) System.out .println("Rico .println("Rico helado de Fresa"); Fresa"); else System.out .println("Deselecciono .println("Deselecciono Fresa"); Fresa"); SELECTED ECTED =>This state-change value indicates that an item was selected. //static int SEL //int getStateChange()=>Returns getStateChange()=>Returns the type of state change change (selected or deselected). } } ///:~ ///:~
La selección o deselección de un JCheckBox JCheckBox es enviada a la interface es enviado conteniendo el método getStatedChange() ItemListener.. El ItemEvent ItemListener ItemEvent es getStatedChange(),, el cual regresa ItemEvent.DESELECTED ItemEvent.DESELECTED o un ItemEvent.SELECTED ItemEvent.SELECTED,, según sea el caso. Es posible usar otro tipo de eventos como el clic o el action, pero el itemEvent se ejecuta antes
JRadioButton Si se quieren botones de selección única, los conocidos como botones radio, que tienen la particularidad de que solamente puede haber uno seleccionado. Cuando añadimos estos componentes (JRadioButtons) a nuestro diseño se añaden por grupos (ButtonGroup ButtonGroup), ), añadiendo botones a ese grupo uno a uno; la selección de uno distinto dentro de unSegrupo provoca la inmediata estaba seleccionado. emplean para darle a elegir aldeselección usuario entredelun que grupoantes de opciones mutuamente excluyentes. Swing permite que cualquier AbstractButton AbstractButton pueda ser añadido a un ButtonGroup ButtonGroup.. En este ejemplo se utiliza un solo manejador de eventos para cada pulsación del JRadioButton y se crea una clase interna. import java.awt.*; import java.awt.event.*;
import javax.swing.*; javax.swing.*; public class JRadioButtonTest{ /*static y g global lobal por k se utilizan en la clase ManejadorBotonOpcion clase ManejadorBotonOpcion Se crea un cuadro de texto inicializado con 30 columnas*/ columnas */ = new JTextField( "cambia el estilo del tipo de letra" letra",, 30); private static JTextField campo =
public static void main(String args[]){ JFrame f = new JFrame(); f.setTitle("JRadioButton f.setTitle("JRadioButto n Tipos Ti pos de Letras" Letras"); ); // // titulo del del JFrame f.setSize(350,100); f.getContentPane().setLayout( new FlowLayout()); FlowLayout()); componentes JCheckBox JCheckBox // // se crean los componentes JRadioButton botonSimple = new JRadioButton( JRadioButton("Simple" "Simple",,true); JRadioButton botonNegrita = new JRadioButton( JRadioButton("Negrita" "Negrita",,false); JRadioButton botonCursiva = new JRadioButton( JRadioButton("Cursiva" "Cursiva",,false); // crear relación lógica entre objetos objetos JRadioButton JRadioButton para para que sean sean exclusivos exclusivos ButtonGroup grupoBotonesOpcion = new ButtonGroup(); grupoBotonesOpcion.add(botonSimple); Tambien es posible añadir los botones al grupo a trves de la interfaz grafica de grupoBotonesOpcion.add(botonNegrita); netbeans, que lo hará en el metodo init grupoBotonesOpcion.add(botonCursiva);
components. objetos de tipo de letra // crear objetos letra Font("Serif" "Serif",, Font.PLAIN Font.PLAIN , 14); Font tipoLetraSimple = new Font( Font tipoLetraNegrita = new Font( Font("Serif" "Serif",, Font.BOLD Font.BOLD , 14);
Font tipoLetraCursiva = new Font( Font("Serif" "Serif",, Font.ITALIC Font.ITALIC , 14); tipoLetraNegritaCursiva //Font tipoLetraNegritaCu rsiva = new Font("Serif" Font("Serif",, Font.BOLD + Font.ITALIC, Font.ITALIC, 14); 14); // registrar eventos para para objetos JRadioBu JRadioButton tton botonSimple.addItemListener( new ManejadorBotonOpcion(tipoLetraSimple)); botonNegrita.addItemListener( new ManejadorBotonOpcion(tipoLetraNegrita)); botonCursiva.addItemListener( new ManejadorBotonOpcion(tipoLetraCursiva)); f.getContentPane().add( campo ); ) //Agrega ;//Agrega el componente componente al Contenedor Contenedor f.getContentPane().add(botonSimple); //Agrega f.getContentPane().add(botonSimple); //Agrega el el componente componente al Contenedor Contenedor f.getContentPane().add(botonNegrita); //Agrega f.getContentPane().add(botonNegrita); //Agrega el el componente componente al Contenedor Contenedor f.getContentPane().add(botonCursiva); //Agrega f.getContentPane().add(botonCursiva); //Agrega el componente componente al Contenedor Contenedor f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ));; // // jdk1.3 jdk1.3+=> +=> Cerrar una ventana f.setVisible(true); } //end //end main() main() //clase static static pork se utilizan utilizan componentes componentes que que estan en el main()y es static static private static class ManejadorBotonOpcion implements ItemListener { tipoDeLetra ; private Font tipoDeLetra;
public ManejadorBotonOpcion(Font f) { tipoDeLetra = f; tipoDeLetra =
} manejarr eventos de de botn de de opcin opcin // maneja public void itemStateChanged(ItemEvent ev) { campo .setFont(tipoDeLetra .setFont( tipoDeLetra); ); } interna privada ManejadorB ManejadorBotonOpcion otonOpcion } //~ //~ fin de la clase interna } ///:~ ///:~
En este otro ejemplo se utilizan diferentes manejadores de eventos, es decir, uno para cada pulsación de JRadioButton. Estos ejemplos se programaron de diferente manera para aprender a crear o manipular diversos códigos con interfaces graficas del swing. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JRadioButtonTest2{ public static void main(String args[]){ JFrame f = new JFrame(); f.setTitle("JRadioButton f.setTitle( "JRadioButton Tipos de Letras" Letras"); ); // // titulo del JFrame f.setSize(350,120); f.getContentPane().setLayout(new FlowLayout());
//Se //Se crea un cuadro de ttexto exto inicializado con 30 columnas es final ya k utiliza clases internas internas final JTextField campo = new JTextField( "cambia el estilo del tipo de letra", letra" , 30); componentes JCheckBox // se crean los componentes JCheckBox JRadioButton botonSimple = new JRadioButton( JRadioButton("Simple" "Simple",,true); JRadioButton botonNegrita = new JRadioButton( JRadioButton("Negrita" "Negrita",,false); JRadioButton botonCursiva = new JRadioButton( JRadioButton("Cursiva" "Cursiva",,false); objetos tos JRadioButton para que sean exclusivos exclusivos // crear relación lógica entre obje
ButtonGroup grupoBotonesOpcion = new ButtonGroup(); grupoBotonesOpcion.add(botonSimple); grupoBotonesOpcion.add(botonNegrita); grupoBotonesOpcion.add(botonCursiva); JRadioButton JRadioButton //botonSimple.addItemListener( registrar eventos para objetos new ItemListener(){ public void itemStateChanged(ItemEvent ev) { Font tipoLetraSimple = new Font( Font("Serif" "Serif",, Font.PLAIN , 14); campo.setFont(tipoLetraSimple); } }); // registrar eventos para objetos JRadioButton JRadioButton botonNegrita.addItemListener(new ItemListener(){ public void itemStateChanged(ItemEvent ev) { Font("Serif" "Serif",, Font.BOLD , 14); Font tipoLetraNegrita = new Font( campo.setFont(tipoLetraNegrita); } }); // registrar eventos para objetos JRadioButton JRadioButton botonCursiva.addItemListener(new ItemListener(){ public void itemS itemStateChanged(ItemEvent tateChanged(ItemEvent ev) { Font("Serif" "Serif",, Font.ITALIC , 14); Font tipoLetraCursiva = new Font( campo.setFont(tipoLetraCursiva); } });
f.getContentPane().add(campo); //Agrega //Agrega el componente al Contenedor Contenedor f.getContentPane().add(botonSimple); //Agrega //Agrega el componente al Contenedor Contenedor f.getContentPane().add(botonNegrita); //Agrega //Agrega el componente al Contenedo Contenedorr f.getContentPane().add(botonCursiva); //Agrega //Agrega el componente al Contenedor Contenedor f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ));; //// jdk1.3+=> Cerrar una ventana f.setVisible(true); } //end //end main() } ///:~ ///:~
JList Se trata de un componente función similar a los anteriores JRadioButton), sólo que aquícon lasuna posibles selecciones se dos encuentran en (JCheckBox una lista, quey normalmente lleva un scroll incorporado, y se seleccionan haciendo clic directamente sobre ellas. Se emplea cuando el número de opciones entre las que ha de escoger el usuario es demasiado grande para presentársela en forma de radiobuttons o checkboxes. Posee métodos para permitir simple o múltiple selección, seleccionar o deseleccionar un componente, averiguar que componente está seleccionado... import java.awt.FlowLayout; import javax.swing.JFrame;
import javax.swing.JList; public class JListTest1 { main(String[] args) { main(String[] public static void
JFrame f=new JFrame(); ); f.setTitle("JListTest"); f.setTitle("JListTest" f.setSize(200,180); f.getContentPane().setLayout( new FlowLayout()); Crea un array de strings y se String[] labels={"Primero" ,"Segundo", "Segundo","Tercero", "Tercero", labels={"Primero", los pasa al JList para que "Cuarto","Quinto" "Cuarto", "Quinto", ,"Sexto" "Sexto", , cree la lista. "Septimo", ,"Octavo", "Octavo","Noveno" "Noveno"}; }; "Septimo" JList list=new JList(labels); f.getContentPane().add(list); ); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); f.setVisible(true); }// end main() main() }///:~
import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JList; import javax.swing.JScrollPane;
de swing //nuevos eventos de swing import javax.swing.event.ListSelectionEvent; import javax.swing.event.ListSelectionListener; public class JListTest2 { public static void main(String[] args) { main(String[] JFrame f=new JFrame();
f.setTitle( "JListTest"); f.setTitle("JListTest" ); f.setSize(200,230); f.getContentPane().setLayout( new FlowLayout()); String labels[] = { "OPCION_1", "OPCION_1", "OPCION_2" "OPCION_2", , "OPCION_3" "OPCION_3", , "OPCION_4" "OPCION_4", , "OPCION_5", "OPCION_6" "OPCION_5", "OPCION_6", , "OPCION_7" "OPCION_7", , "OPCION_8" "OPCION_8", , "OPCION_9", "OPCION_10" }; "OPCION_9", "OPCION_10" }; JList lista = new JList(labels); f.getContentPane().add(lista); JScrollPane scrollPane = new JScrollPane(lista); f.getContentPane().add(scrollPane); ListSelectionListener listSelectionListener = new ListSelectionListener() { public void valueChanged(ListSelectionEvent ev) {
valueChanged(ListSelectionEvent ev) { valueChanged(ListSelectionEvent public void JList list = (JList) ev.getSource(); int indice = list.getSelectedIndex(); Object valor = list.getSelectedValue(); .println("Indice=> "Indice=> " " + + indice + "valor=> " " + + valor); System.out.println( } }; lista.addListSelectionListener(listSelectionListener); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) ); ; f.setVisible( true); }// end main() main() }///:~
JComboBox Su filosofía es idéntica a la de JList JList,, pero en esta ocasión las opciones no se ven en un principio. El usuario ha de hacer un clic sobre una pestaña que desplegará una lista de opciones sobre las cuales escoge el usuario una mediante un clic. import java.awt.FlowLayout; import java.awt.event.ActionE java.awt.event.ActionEvent; vent; import java.awt.event.ActionListene java.awt.event.ActionListener; r; import javax.swing.JComboBox; import javax.swing.JFrame; public class JComboBoxTest { public static void main(final String args[]) { final String labels[]= {"OPCION_A" {"OPCION_A",, "OPCION_B", "OPCION_B", "OPCION_C", "OPCION_C" , "OPCION_D" "OPCION_D",, "OPCION_E"}; "OPCION_E" }; JFrame f = new JFrame( JFrame("JComboBox" "JComboBox"); ); f.setSize(350,100); FlowLayout()); //Coloca //Coloca los componentes de form formaa consecutiva f.getContentPane().setLayout(new FlowLayout());
JComboBox comboBox = new JComboBox(labels); comboBox.setSelectedIndex(0); Contenedor edor f.getContentPane().add(comboBox); //Agrega //Agrega el el combo al Conten /*Forma /*Forma 1*/ { /*comboBox.addActionListener(new ActionListener() {
public void acti actionPerformed(A onPerformed(ActionEvent ctionEvent ev){ ev){ (JComboBox)ev.getSource(); ource(); JComboBox cb = (JComboBox)ev.getS String opcionSelec = (String)cb.getSelectedItem() (String)cb.getSelectedItem();; System.out.println("Selected: " + opcionSelec); opcionSelec); */
} }); });
/*Forma 2*/ ActionListener actionListener = new ActionListener() { public void actionPerformed(ActionEvent ev){ JComboBox cb = (JComboBox)ev.getS (JComboBox)ev.getSource(); ource(); String opcionSelec = (String)cb.getSelectedItem() (String)cb.getSelectedItem();; System.out .println("Selected: .println("Selected: " + " + opcionSelec);
} }; comboBox.addActionListener(actionListener);
; //Cierra la ventana f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE )); //Cierra f.setVisible(true); } //// end main() main() } ///:~ ///:~
JLabel No es más que una etiqueta de texto que podemos colocar al lado de cualquier componente para darle una indicación al usuario de cual es la función de dicho componente. import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JLabel; public class JLabelTest { main(String[] args) { main(String[] public static void JFrame f=new JFrame();
f.setTitle("JLabelTest"); f.setTitle("JLabelTest" ); f.setSize(200,100); f.getContentPane().setLayout( new FlowLayout()); JLabel("Una "Una etiqueta" etiqueta"); ); JLabel l1=new JLabel( JLabel l2=new JLabel(); "Otra etiqueta"); l2.setText("Otra l2.setText( etiqueta"); f.getContentPane().add(l1); f.getContentPane().add(l2); f.setVisible(true); ); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); }// end main() main() }///:~
JTextField y JPasswordField JTextField: Está pensado para obtener texto del usuario, este tecleará en él y cuando JTextField: pulse intro podremos disponer del texto que tecleó. Únicamente se puede recoger una línea de texto. Tiene métodos para recoger el texto del usuario, poner un texto en él, recoger solo el texto seleccionado, seleccionar una parte del texto, insertar texto, cortar texto, pegar texto, etc. JPasswordField: No es más que un JTextField JPasswordField: JTextField en en el cual al escribir no se ve lo que se escribe, sino un carácter (*, por ejemplo). Se emplea para pedirle passwords al usuario y evitar que puedan ser leídas por alguien.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JTextFieldTest extends JFrame { private JTextField campoTexto1 campoTexto1,, campoTexto2 campoTexto2,, campoTexto3 campoTexto3;; private JPasswordField campoContrasenia campoContrasenia;; public JTextFieldTest() { super("JTextField y JPasswordField" JPasswordField" ); );
Container contenedor = getContentPane(); contenedor.setLayout( new FlowLayout() ); //f.getContentPane().setLayout(new FlowLayout()); //f.getContentPane().setLayout(new FlowLayout()); JLabel etiqueta= new JLabel( JLabel("" "" + + componente"); "Introducir texto y dar enter en cada componente"); contenedor.add(etiqueta); // crear campo de texto con tamaño predeterminado predeterminado campoTexto1 = campoTexto1 = new JTextField(10); contenedor.add(campoTexto1 contenedor.add( campoTexto1); ); // crear campo de texto con texto predeterminado predeterminado campoTexto2 = JTextField("Escriba "Escriba el texto aquí" aquí"); ); campoTexto2 = new JTextField(
contenedor.add(campoTexto2); contenedor.add(campoTexto2 ); predeterminado, // crear campo de texto con texto predeterminado, eventos // 20 elementos visibles y sin manejador de eventos campoTexto3 = = new JTextField( "Campo de texto no editable" editable",, 20); campoTexto3 false ); campoTexto3.setEditable( campoTexto3.setEditable( ); contenedor.add( campoTexto3 campoTexto3 );
// crear campo de contraseña predeterminado contraseña con texto predeterminado campoContrasenia = new JPasswordField( campoContrasenia = JPasswordField("Texto "Texto oculto"); oculto"); contenedor.add( campoContrasenia campoContrasenia ); ); eventos // registrar manejadores de eventos campoTexto1.addActionListener(new ManejadorCampoTexto()); campoTexto1.addActionListener( campoTexto2.addActionListener( campoTexto2.addActionListener(new ManejadorCampoTexto()); campoTexto3.addActionListener( campoTexto3.addActionListener(new ManejadorCampoTexto()); campoContrasenia.addActionListener( campoContrasenia.addActionListener(new ManejadorCampoTexto()); setSize(325,150); setVisible(true); ); setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); } // fin del constructor de JTextFieldTest() JTextFieldTest()
manejo de eventos // clase interna privada para el manejo eventos private class ManejadorCampoTexto implements ActionListener { // procesar eventos de camp campoo de texto texto public void actionPerformed(ActionEvent ev) { "";; String cadena = "" // el usuario oprimió Intro en objeto objeto JTextField campoTexto1 campoTexto1 if (ev.getSource() == campoTexto1 campoTexto1)) cadena = "campoTexto1: "" + + ev.getActionCommand(); //getActionComma //getActionCommand()=> nd()=> Returns the command string string associated with this action action // el usuario oprimió Intro en objeto campoTexto2 objeto JTextField campoTexto2 else if (ev.getSource() == campoTexto2 campoTexto2)) cadena = "campoTexto2: "" + + ev.getActionCommand(); // el usuario oprimió Intro en objeto campoTexto3 objeto JTextField campoTexto3 else if (ev.getSource() == campoTexto3 campoTexto3)) cadena = "campoTexto3: "" + + ev.getActionCommand(); objeto JTextField campoContrasenia // el usuario oprimió Intro en objeto campoContrasenia else if (ev.getSource() == campoContrasenia campoContrasenia)) { cadena = "campoContrasenia: "" + + ev.getActionCommand ev.getActionCommand(); (); // new String(campoContrasenia.getPassword()); String(campoContrasenia.getPassword()); }
JOptionPane.showMessageDialog ( null, cadena,"Resultados" cadena,"Resultados",JOptionPane. ,JOptionPane.CANCEL_OPTION ));; } // fin del método actionPerformed() actionPerformed() } // fin de la clase interna privada ManejadorCampoTexto ManejadorCampoTexto {public static void main( String args[] ) JTextFieldTest aplicacion = new JTextFieldTest(); } } ///:~ ///:~
JTextArea Todo lo dicho para JTextField JTextField es es válido aquí también; la diferencia entre ambos es que permite al usuario introducir más de una línea l ínea de texto. JTextArea permite JTextArea En este ejemplo primero se selecciona el texto y después se pulsa el botón Copiar para pegar el texto en el cuadro vacío.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JTextAreaTest extends JFrame { private JTextArea areaTexto1 areaTexto1,, areaTexto2 areaTexto2;; private JButton botonCopiar botonCopiar;; public JTextAreaTest() { super("JTextArea" "JTextArea"); ); setSize(450,150); getContentPane().setLayout(new FlowLayout());
String cadena = "Ésta es una cadena de\ndemostración para\n" + para\n" + "ilustrar cómo copiar texto\nde un área de texto a \n" + \n" + "otra, utilizando un\nevento externo" externo";; // establecer areaTexto1 areaTexto1 areaTexto1 = areaTexto1 = new JTextArea(cadena,5,10); JScrollPane jsp1= new JScrollPane( JScrollPane(areaTexto1 areaTexto1); ); getContentPane().add(jsp1); // establecer botonCopiar botonCopiar botonCopiar = >>>" ); ); botonCopiar = new JButton( "Copiar >>>"
); getContentPane().add(botonCopiar); getContentPane().add(botonCopiar botonCopiar.addActionListener(new ActionListener() botonCopiar.addActionListener( { // clase interna anónima // establecer en areaTexto2 el texto seleccionado seleccionado de areaTexto1 areaTexto1 public void actionPerformed(ActionEvent ev)
});
{ areaTexto2.append( areaTexto2.append(areaTexto1 areaTexto1.getSelectedText()); .getSelectedText()); }
// establecer areaTexto2 areaTexto2 areaTexto2 = areaTexto2 = new JTextArea(5,10); areaTexto2.setEditable( areaTexto2.setEditable(false); JScrollPane jsp2= new JScrollPane( JScrollPane(areaTexto2 areaTexto2); ); getContentPane().add(jsp2); ; // jdk1.3+=> Cerrar una ventana ventana setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE )); // setVisible(true); constructor } //// fin del constructor public static void main( String args[] ) { JTextAreaTest aplicacion = new JTextAreaTest(); } } ///:~ ///:~
CUADROS DE DIALOGO ESTÁNDAR JOptionPane Muchas clases Swing soportan diálogos -- ventanas que son más limitadas que los JFrame.. Para crear un diálogo, simple y estándar se utiliza JOptionPane JFrame JOptionPane.. Para crear diálogos personalizados, se utiliza directamente la clase JDialog JDialog.. JOptionPane JOptionPane proporciona soporte para mostrar diálogos standards, proporcionando iconos, especificando el título y el texto del diálogo diálog o y personalizando el texto del botón. Para la mayoría de los diálogos modales sencillos, se crea y se muestra el diálogo utilizando uno de los métodos showXxxDialog showXxxDialog de de JOptionsPane JOptionsPane.. showMessageDialog Muestra un diálogo modal con un botón, etiquetado "OK". Se puede especificar fácilmente el mensaje, el icono y el título que mostrará el diálogo. showConfirmDialog Muestra un diálogo modal con dos botones, etiquetados "Yes" y "No". Estas etiquetas no son siempre terriblemente descriptivas con las acciones específicas del programa que causan.
showInputDialog Muestra un diálogo modal que obtiene una cadena del usuario. Un diálogo de entrada muestra un campo de texto para que el usuario teclee en él, o un JComboBox no editable, desde el que el usuario puede pue de elegir una de entre varias cadenas. showOptionDialog Muestra un diálogo modal con los botones, los iconos, el mensaje y el título especificado, etc. Con este método, podemos cambiar el texto que aparece en los botones de los diálogos estándar. También podemos realizar cualquier tipo de personalización. El soporte de iconos de JOptionPane JOptionPane permite especificar qué icono mostrará el diálogo. Podemos utilizar un icono personalizado, no utilizar ninguno, o utilizar uno de los cuatro iconos estándard de JOptionPane (question (question,, information information,, warning warning,, y error error). ). Cada aspecto y comportamiento tiene sus propias versiones de los cuatro iconos estándard. Por defecto,unundiálogo diálogo creado showMessageDialog showMessageDialog muestra el icono de información, creado con con showConfirmDialog showConfirmDialog o showInputDialog showInputDialog muestra muestra un icono question. Para especificar qué un diálogo estándard no tenga icono o tenga otro icono estándard, se añade un parámetro que especifica el tipo de mensaje. El valor del tipo de mensaje puede ser una de las siguientes constantes: PLAIN_MESSAGE PLAIN_MESSAGE (sin (sin icono), QUESTION_MESSAGE QUESTION_MESSAGE,, INFORMATION_MESSAGE INFORMATION_MESSAGE,, WARNING_MESSAGE WARNING_MESSAGE,,
o ERROR_MESSAGE ERROR_MESSAGE.. Si especificamos un objeto Icon Icon distinto de null, el diálogo muestra ese icono, no importa el tipo de mensaje m ensaje que sea. import javax.swing.*; public class JOptionPaneTest { public static void main(String args[]) throws Exception { main(String
opciones //Menú de opciones guardará int opcion; //La opción que se guardará //Este string contiene los labels de todos los botones botones , "Opcion2" "Opcion2", ,"Mensaje Simple" Simple", , String[] menu = {"Opcion1" {"Opcion1", "HTML","PideCadena" "PideCadena", , "Otro Menú", Menú","HTML", "PideEntero" "PideEntero", ,"Salir" "Salir"}; }; //Inicia el Menu de botones botones do{
opcion= JOptionPane.showOptionDialog ( //sin parentesco puede ser Frame f f null, opción", "Selecciona una opción", //texto que sale sale "Ejemplos con JOptionPane", caja JOptionPane", //titulo de la caja JOptionPane. YES_NO_CANCEL_OPTION ,//tipo de caja caja mensaje JOptionPane. QUESTION_MESSAGE , //tipo de mensaje null, //icono de la caja caja menu, arreglo //lista de botones, este es el arreglo menu[0]); //boton por default default switch (opcion) { case 0: //Instrucciones aqui Opcion 1 1 System.out.println( .println("Seleccionó "Seleccionó la Opción 1"); 1"); break;
2 case 1: //Instrucciones aqui Opcion 2
case
System.out.println( .println("Seleccionó "Seleccionó la Opción 2"); 2"); break;
Simple case 2: //Mensaje Simple JOptionPane. showMessageDialog (null,"Hola Mundo" Mundo"); ); break; case 3: //Otro menu dentro de esta opción opción
//Menú de opciones opciones
int opcion2;
//Este string contiene los labels de todos los botones String[] menu2 = {"Opción { "Opción 1" 1", ,"Opción 2", 2","Salir"}; "Salir" }; //Inicia el Menu de botones botones do{ opcion2 = JOptionPane.showOptionDialog ( null, "Selecciona una opción" opción", , "JOptionPane.showOptionDialog" , JOptionPane. YES_NO_CANCEL_OPTION , JOptionPane. INFORMATION_MESSAGE , null, menu2, menu2[0]); switch(opcion2) { .println("Seleccionó "Seleccionó la Opción 1"); 1"); case 0: System. out.println( break; .println("Seleccionó "Seleccionó la Opción 2"); 2"); case 1: System. out.println( break; do-while case 2: //Para que se salga del do-while
opcion2 = -1; break;
}//end switch(opcion2) switch(opcion2) (-1));// fin del do-while do-while }while(opcion2 != (-1));// break;
//HTML case 4: //HTML /* Puedes usar tags de HTML dentro de la string del del */ * message dialog */ String htmlTags = "" + "" + "" + ""+ "" + Centrado" + + "Mensaje Centrado" //Tambien se pueden hacer Tablas Tablas BGCOLOR=WHITE>"+ + "" "unoDosTres" + "celda1celda2celda3" + "" + "" ""; ; JOptionPane. showMessageDialog (null, htmlTags); break; case 5: //PideCadena //PideCadena
""; ; String input = "" //Se entiende por si solo solo try { input = JOptionPane.showInputDialog ("Escribe algo"); algo"); }catch (Exception e) { //en caso de algún error muestra mensaje mensaje JOptionPane. showMessageDialog (null, "Error"); "Error"); break; //sale de esta opción opción }//end try try " + + input); JOptionPane. showMessageDialog (null, "Cadena: " break; case 6: //PideEntero //PideEntero int entero = 0;
//se inicializa inicializa
try { //Hacemos parse para convertir a entero entero entero = Integer. parseInt ( JOptionPane. showInputDialog ("Escribe un entero")); entero")); } catch (Exception e) {
/* en caso de algun error muestra mensaje por ejemplo ejemplo * si se introduce algo diferente de un entero */ */ JOptionPane. showMessageDialog (null, "Error"); "Error"); break;
} JOptionPane. showMessageDialog (null, "Número: " + " + entero);
//Se pueden hacer operaciones como siempre siempre if(entero < 5) { JOptionPane. showMessageDialog ( null, "El Núumero: " + " + entero + " es menor a 5" 5"); ); } break; case 7: //Salir del programa
opcion = -1; break;
switch }// fin del switch } while(opcion != (- 1) );// );// fin del do-while do-while } //end main() main() }///:~
Menu Principal
Opcion1
Opcion2
Mensaje Simple
Otro Menú
HTML
Pide Cadena
PideEntero
Salir Sale del Menú principal
JFileChooser La ventana que permite la selección de archivos, suele ser una ventana modal, ya que los cambios que se produzcan en ella, o la selección que se haga, repercutirán en el funcionamiento de la aplicación general. Normalmente, la ventana de selección de archivos se utiliza para presentar una lista de archivos y permitir al usuario seleccionar cuál de ellos debe abrir la aplicación; o, por el contrario, permitir al usuario la introducción de un nombre o selección del archivo con que se quieren salvar datos. El objeto JFileChooser JFileChooser no no realiza ninguna de estas acciones, es decir, no abre ni salva nada, sino que se limita a sleccionar el nombre del archivo con el que se desea realizar la acción; es responsabilidad del programa el llevar a cabo la apertura del archivo o la grabación de datos. import javax.swing.JFileChooser; import javax.swing.JFrame; public class JFileChooserTest { public static void main(String[] args) { main(String[] JFrame f=new JFrame();
f.setTitle("JFileChooserTest"); f.setTitle("JFileChooserTest" ); f.setSize(200,150);
JFileChooser fc=new JFileChooser(); int op=fc.showOpenDialog(f); if(op==JFileChooser.APPROVE_OPTION ) System.out.println(fc.getSelectedFile()); f.setVisible(true); ); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); }//end main() main() }///:~
JColorChooser Panel de controles que permite al usuario seleccionar un color. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JColorChooserTest extends JFrame
{ private JButton cambiarColorBoton; cambiarColorBoton ; color = = Color.LIGHT_GRAY ; private Color color contenedor; ; private Container contenedor
GUI // configurar GUI public JColorChooserTest() { super( "JColorChooserTest" ); "JColorChooserTest" ); contenedor contenedor = = getContentPane(); contenedor.setLayout( contenedor .setLayout(new FlowLayout()); // configurar cambiarColorBoton y registrar su manejador de eventos eventos cambiarColorBoton = cambiarColorBoton = new JButton( "Cambiar color" ); color" );
cambiarColorBoton.addActionListener( cambiarColorBoton .addActionListener( new ActionListener(){ // mostrar JColorChooser cuando el usuario haga clic en el botón public void actionPerformed( ActionEvent evento ) actionPerformed( { color = color = JColorChooser.showDialog ( JColorChooserTest. this, "Seleccione un color" color", , color color ); ); color // establecer color predeterminado, si no se devuelve un color // Si se dá clic en el botón Cancelar Cancelar if ( color == color == null ) color = color = Color.RED; // cambiar color de fondo del panel de contenido contenido contenedor contenedor.setBackground( .setBackground( color color ); ); } }); contenedor .add( cambiarColorBoton contenedor.add( cambiarColorBoton ); ); setSize( 400, 130 ); setVisible( true ); } // fin del constructor constructor main( String args[] ) main( public static void {
JColorChooserTest aplicacion = new JColorChooserTest(); ); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }//end main() main() }///:~
LAYOUTS La distribución de los componentes en un contenedor usualmente esta controlada con un administrador de diseño (layout manager). Cada contenedor (como un Panel o un Frame) tiene por omisión un administrador de diseño asociado con este, el cual puede ser cambiado invocando al método setLayout() setLayout().. Cada administrador de diseño es responsable de definir el tamaño de cada componente en sus contenedores. Los siguientes administradores de diseño son incluidos en el lenguaje de programación Java: FlowLayout FlowLayout : Es el administrador de diseño por default en el JPanel JPanel y en el hacia JApplet.. Coloca los componentes de izquierda a derecha y de arriba hacia JApplet abajo. Les modifica la posición pero no les l es modifica el tamaño.
BorderLayout: BorderLayout: Es el administrador de diseño por default de JWindow JWindow,, JDialog JDialog y JFrame Sur, r, Este, Oeste y JFrame.. Coloca los componentes en 5 regiones, Norte, Su Centro. Modifica tanto la posición como el tamaño de los componentes.
CardLayout: CardLayout: Es raramente usado y coloca los componentes en capas, donde cada capa es como una carta de naipes, de ahí su nombre. Modifica tanto la posición como el tamaño de los componentes.
GridLayout GridLayout:: Es un administrador de diseño que provee flexibilidad para colocar
componentes a manera todas las celdas es igualde celdillas de una hoja de cálculo (Matriz). El tamaño de GridBagLayout GridBagLayout : Es parecido al GridLayout, pero no fuerza a que todos los componentes tengan el mismo tamaño.
La siguiente figura muestra los administradores de diseño di seño (Layout managers).
FlowLayout Es el administrador de diseño por default para la clase JPanel y los componentes son JPanel y agregados de izquierda a derecha. Su alineación por omisión es centrada y permite colocar los componentes a sus tamaños preferidos. Con los argumentos del constructor de FlowLayout FlowLayout se permite definir los componentes para que fluyan de izquierda a derecha o de derecha a izquierda. También es posible especificar los espacios mínimos de separación entr entree cada componente. Aquí tenemos tenemos los constructores: FlowLayout() FlowLayout(int align) FlowLayout(int align, int hgap, int vgap) vgap) Los valores para la alineación deben ser FlowLayout.LEFT FlowLayout.LEFT,, FlowLayout.RIGHT FlowLayout.RIGHT,, o FlowLayout.CENTER , así por ejemplo: setLayot( new FlowLayout( FlowLayout.RIGHT, FlowLayout.RIGHT, 20, 40 ) ); Crea un administrador de diseño diseño de tipo FlowLayout con una alineación centrada y con
las unidades de espacios mínimos especificados, por default da 5 unidades para espacio horizontal y 5 unidades para el vertical. import java.awt.*; import javax.swing.JButton; import javax.swing.JFrame; public class FlowLayoutTest
{ main(String[] args){ main(String[] public static void JFrame f = new JFrame(); ); f.setTitle("FlowLayoutTest"); f.setTitle("FlowLayoutTest" f.setSize(300,100); f.setLayout(new FlowLayout()); JButton b1 = new JButton( JButton("Button "Button 1" 1"); ); JButton("Button "Button 2" 2"); ); JButton b2 = new JButton( JButton b3 = new JButton( JButton("Button "Button 3" 3"); ); f.add(b1); f.add(b2); f.add(b3); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); f.setVisible(true); }//end main() main() }///:~
import java.awt.*; import javax.swing.JButton; import javax.swing.JFrame; public class FlowLayoutTest2
{ public static void main(String[] args){ main(String[] JFrame f = new JFrame();
); f.setTitle("FlowLayoutTest2"); f.setTitle("FlowLayoutTest2" f.setSize(500,150); f.setLayout(new FlowLayout(FlowLayout.RIGHT ,20,40)); ,20,40)); JButton("Button "Button 1" 1"); ); JButton b1 = new JButton( JButton b2 = new JButton( JButton("Button "Button 2" 2"); ); JButton("Button "Button 3" 3"); ); JButton b3 = new JButton( f.add(b1); f.add(b2); f.add(b3); ); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); f.setVisible(true); }//end main() main() }///:~
BorderLayout Es el administrador de diseño por default de la clase JFrame JFrame.. Los componentes son agregados a 5 regiones específicas dentro de la ventana o frame:
NORTH ocupa la parte de arriba. NORTH ocupa SOUTH ocupa SOUTH ocupa la parte inferior. EAST ocupa EAST ocupa el lado derecho. WEST ocupa WEST ocupa la parte izquierda. CENTER ocupa CENTER ocupa la parte central.
Cuando ajustamos verticalmente el tamaño de la ventana o frame, las regiones EAST, WEST y CENTER son ajustadas.
Cuando ajustamos horizontalmente el tamaño de la ventana o frame, las regiones NORT, SOUTH y CENTER son ajustadas. Cuando añadimos botones a las posiciones relativas los botones no cambian si la ventana es cambiada de tamaño, pero los tamaños de los botones si cambian. El siguiente constructor crea un administrador de diseño de tipo BorderLayout sin espacios entre sus componentes: setLayout(new BorderLayout() ); Usando el siguiente constructor podemos indicarle los espacios entre los componentes especificados por hgap y vgap: BorderLayout( int hgap, int vgap ); Se deben agregar los componentes en las regiones específicas respetando mayúsculas y minúsculas ya que no es lo mismo add( boton, BorderLayout.CENTER ) ) que add( boton, BorderLayout.center ) ) en el administrador de diseño , o de otra forma no serán visibles. Si se quiere evitar esto se puede usar add (boton, "center"). "center").
Si se deja una región sin utilizar, esta se comportará como si se hubiera preferido un tamaño de 0 x 0. La región CENTER CENTER seguirá apareciendo como fondo cuando incluso si no tiene componentes. Ojo: Solo se puede agregar un solo componente por cada una de las cinco regiones. Si Ojo: se trata de agregar más de una, solo la última agregada será la visible. Cuando deseamos agregar más componentes por región usaremos la clase JPanel, lo cual veremos después.
import java.awt.*; import javax.swing.JButton; import javax.swing.JFrame; public class BorderLayoutTest { main(String[] args){ main(String[] public static void JFrame f = new JFrame();
); f.setTitle( "BorderLayoutTest"); f.setTitle("BorderLayoutTest" f.setLayout( new BorderLayout()); JButton b1 = new JButton( JButton("Button "Button 1 (NORTH)"); (NORTH)"); ); ; f.add(b1,BorderLayout. NORTH ) JButton("Button "Button 2 (WEST)"); (WEST)"); JButton b2 = new JButton( ); ; f.add(b2,BorderLayout. WEST ) JButton b3 = new JButton( JButton("Button "Button 3 (CENTER)"); (CENTER)"); f.add(b3,BorderLayout. CENTER); JButton("Button "Button 4 (EAST)"); (EAST)"); JButton b4 = new JButton( f.add(b4,BorderLayout. EAST ) ); ; JButton("Button "Button 5 (SOUTH)"); (SOUTH)"); JButton b5 = new JButton( f.add(b5,BorderLayout. SOUTH ) ); ; f.pack(); // El método pack, hace que el contenedor pregunte a su su
f.setVisible( true); // LayoutManager el tamaño mínimo para que todos sus sus tamaño. // componentes se puedan ver. Y se ajusten a ese tamaño.
); ; f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) }// end main() main() }///:~
GridLayout Este administrador de diseño proporciona flexibilidad flexibilidad para colocar componentes en celdillas de izquierda a derecha y de arriba a abajo en una rejilla al estilo de una hoja electrónica de cálculo con filas y columnas. Por ejemplo un GridLayout GridLayout con tres renglones y dos columnas puede ser creado mediante la sentencia new lo que se traduce en 6 celdas. GridLayout(3,2) lo GridLayout(3,2)
Con un administrador de tipo GridLayout GridLayout siempre se ignoran los tamaños preferidos para cada componente. c omponente. El ancho de todas celdas es idéntico y es determinado mediante la división del ancho disponible sobre el número de columnas, así como el alto de todas las celdas es también determinado mediante el alto disponible entre el número de renglones. El orden en el cual los componentes son agregados a la rejilla es determina la celda que ocupa. Los renglones de celdas son llenados de izquierda a derecha, como un texto de una página que es llenada con líneas de arriba abajo.
Contenedor Layout Manager JPanel FlowLayout JApplet FlowLayout Júrame BorderLayout JDialog BorderLayout JScrollPane FlowLayout Tabla. Layuts por defecto de los contenedores Swing
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class GridLayoutTest extends JFrame implements ActionListener
{ botones []; private JButton botones[]; nombres[] = private final String nombres[] "dos", "tres", "tres", "cuatro" "cuatro", , "cinco" "cinco", , "seis" }; "seis" }; { "uno", "uno", "dos", alternar = true; private boolean boolean alternar = contenedor ; private Container contenedor; private GridLayout cuadricula1, cuadricula1 , cuadricula2; cuadricula2 ; // configurar GUI GUI public GridLayoutTest()
{ super( "GridLayoutTest" );
esquemas // establecer esquemas /*GridLayout() Creates a grid layout with a default of one column per component, in a single row. row. GridLayout(int rows, int cols) Creates a grid layout with the specified number of rows and columns. GridLayout(int rows, int cols, int hgap, int vgap) Creates a grid layout with the specified number of rows and columns. */ */ cuadricula1 = = new GridLayout( 2, 3, 10, 10 ); cuadricula1 cuadricula2 = cuadricula2 = new GridLayout( 3, 2 ); // obtener panel de contenido y establecer su esquema esquema contenedor = getContentPane(); contenedor =
contenedor.setLayout( cuadricula1 ); contenedor .setLayout( cuadricula1 ); // crear y agregar botones botones botones = new JButton[ nombres. botones = nombres.length length ]; ]; nombres.length length; ; cuenta++ ) { for ( int cuenta = 0; cuenta < nombres. botones botones[ [ cuenta ] = new JButton( nombres[ nombres[ cuenta ] ); botones botones[ [ cuenta ].addActionListener( this ); botones botones[ [ cuenta ].setToolTipText("Cambia ].setToolTipText("Cambia el esquema de GridLayout"); GridLayout"); contenedor.add( botones[ cuenta ] ); contenedor .add( botones[ } setSize( 300, 150 ); setVisible( true ); } // fin del constructor de DemoGridLayout DemoGridLayout // manejar eventos de botn, alternando entre los esquemas public void actionPerformed( ActionEvent evento ) actionPerformed(
{ alternar ) ) if ( alternar contenedor.setLayout( .setLayout( cuadricula2 cuadricula2 ); ); contenedor else
contenedor .setLayout( cuadricula1 contenedor.setLayout( cuadricula1 ); ); alternar = !alternar; ; // establecer alternar en el valor opuesto opuesto alternar = !alternar contenedor.validate(); // Validates this container and all of its subcomponents. contenedor .validate();// componentes // Se realiza en cambio físico de los componentes } public static void main( String args[] ) main(
{ GridLayoutTest aplicacion = new GridLayoutTest(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }//end main() }///:~
CONTENEDORES DE ALTO NIVEL Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores . Los Contenedores contienen y organizan la situación de los Componentes; además, los Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. También contienen el código necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicación. Hay dos tipos principales de contenedores: la clase JWindow JWindow y y JPanel JPanel.. Una ventana (JWindow (JWindow)) es un rectángulo que flota libremente en la pantalla. Hay dos tipos de ventanas. El JFrame JFrame y y el JDialog JDialog.. Un JFrame JFrame es es una ventana con una barra de titulo y esquinas que pueden ser cambiadas de tamaño. Un JDialog es una simple JDialog es ventana que no puede tener una barra de menú y aunque se puede mover no puede ser cambiada de tamaño. El JPanel JPanel debe debe estar contenido dentro de otro contenedor, o dentro de una ventana de un navegador Web. El JPanel es un área rectangular dentro de la cual se puede colocar otros componentes.
JDialog Un JDialog JDialog es una ventana que depende de otra ventana (de una JFrame). Si un JFrame se cierra, se cierran también los JDialog que dependen de ella; si se restablece, sus JDialog aparecen de nuevo. Este comportamiento se obtiene de forma automática. Las Applets estándar no soportan JDialogs porque no son Frames de Java. Las Applets que abren JFrames sí pueden soportar JDialogs. Un JDialog modal require la atención inmediata del usuario: no se puede hacer ninguna otra cosa hasta no haber cerrado el JDialog. Por defecto, los JDialogs son no modales. m odales. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JDialogTest { private static JFrame ventanaPrincipal ; private static JDialog ventanaSecundaria ; public static void main(String[] args) { main(String[] JButton boton = new JButton( JButton("Abre "Abre secundaria" secundaria"); );
// Construcción de ventana principal principal JFrame("Ventana "Ventana principal"); principal"); ventanaPrincipal = new JFrame( ventanaPrincipal .setSize(300,100); ventanaPrincipal .getContentPane().setLayout( new FlowLayout()); ventanaPrincipal .getContentPane().add(boton); //ventanaPrincipal.pack();
JButton boton2 = new JButton( JButton("Abre "Abre principal"); principal"); secundaria // Construcción de ventana secundaria ventanaSecundaria = new JDialog(ventanaPrincipal ,"Ventana secundaria" secundaria"); ); //ventanaSecundaria = new JDialog(ventanaPrincipal ,"Ventana secundaria",true secundaria",true);//modal );//modal ventanaSecundaria .getContentPane().setLayout( new FlowLayout()); ventanaSecundaria .getContentPane().add(boton2); ventanaSecundaria .setSize(300,100); //ventanaSecundaria.pack(); secundaria // Hacer que el botón abra la ventana secundaria boton.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { actionPerformed(ActionEvent ventanaSecundaria .setVisible( true); } }); principal // Hacer que el botón abra la ventana principal boton2.addActionListener( new ActionListener() { actionPerformed(ActionEvent e) { actionPerformed(ActionEvent public void ventanaPrincipal .setVisible( true); ventanaSecundaria .setVisible( false); } }); // Hacer que al cerrarse la secundaria con la x de arriba a la // derecha, se muestre la primaria primaria ventanaSecundaria .addWindowListener( new WindowAdapter() { windowClosing(WindowEvent e) { windowClosing(WindowEvent public void ventanaPrincipal .setVisible( true); }
ventanaSecundaria .setVisible( true);
}); ventanaPrincipal .setDefaultCloseOperation( ventanaPrincipal .setVisible( true);
JFrame.EXIT_ON_CLOSE );
main() }// end main() }///:~
CONTENEDORES DE NIVEL INTERMEDIO JScrollPane Un JScrollPane JScrollPane provee de un contenedor general que no puede ser usado como un componente libre. Siempre esta asociado con un contenedor c ontenedor (por ejemplo, un ). Provee un área de visualización dentro de una región grande y con barras de JFrame). JFrame deslizamiento para manipularla.
El JScrollPane JScrollPane crea crea y maneja las barras de desplazamiento y las contiene en un solo componente. No es posible controlar el administrador de diseño que usa, en lugar de esto se puede agregar a un JPanel JPanel para para que el JScrollPane configure el administrador
de diseño y coloque los componentes en dicho panel. Ojo: Generalmente, no es posible manejar eventos en un JScrollPane Ojo: JScrollPane;; los eventos son manejados a través de los componentes que se contengan. Se presentan dos y versiones diferentes de ver código fuente deformas la misma aplicación JScrollPaneTest1 y JScrollPaneTest1 JScrollPaneTest2, JScrollPaneTest2 , para las diferentes de programar el mismo código pero con diversa estructura y así poder enriquecer más la comprensión de códigos de Java ya sea para programar nuevas aplicaciones desde cero o entender y extraer fragmentos de código de otros programadores y adaptarlos a nuestras necesidades.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JScrollPaneTest1 extends JFrame { listaColores, , listaCopia; listaCopia; private JList listaColores private JButton botonCopiar; botonCopiar ; jsp1, , jsp2 jsp2; ; private JScrollPane jsp1 nombresColores[] [] = { "Negro" "Negro", , "Azul" "Azul", , "Cyan", "Cyan", private final String nombresColores
oscuro", "Gris" "Gris oscuro", "Gris", , "Verde" "Verde", , "Gris claro", claro", "Magenta", "Magenta" , "Naranja", "Naranja", "Rosa" "Rosa", , "Rojo" "Rojo", , "Blanco" "Blanco", , "Amarillo" "Amarillo" }; }; public JScrollPaneTest1()
{ //Pasa el mensaje al constructor del JFrame JFrame múltiple"); super("Listas de selección múltiple"); getContentPane().setLayout( new FlowLayout()); // establecer objeto JList listaColores listaColores = listaColores = new JList( JList(nombresColores nombresColores); ); listaColores.setVisibleRowCount(5); listaColores .setVisibleRowCount(5);//Mostrados //Mostrados en el JScrollPane listaColores.setSelectionMode( listaColores .setSelectionMode( ListSelectionModel. MULTIPLE_INTERVAL_SELECTION ); jsp1= jsp1= new JScrollPane( JScrollPane(listaColores listaColores); ); jsp1); ); getContentPane().add(jsp1 getContentPane().add(
//getContentPane().add(new JScrollPane(listaColores)); // crear botón copiar y registrar su componente de escucha botonCopiar = botonCopiar = new JButton( JButton("Copiar "Copiar >>>"); >>>"); botonCopiar ); ); getContentPane().add( botonCopiar botonCopiar.addActionListener( new ActionListener() { botonCopiar.addActionListener( // manejador del evento del botón public void actionPerformed( ActionEvent evento ) actionPerformed( { // colocar valores seleccionados en listaCopia listaCopia.setListData( listaCopia .setListData(listaColores listaColores.getSelectedValues()); .getSelectedValues()); } } // fin de clase interna anónima ); // fin de la llamada a addActionListener // establecer objeto JList listaCopia listaCopia = listaCopia = new JList(); listaCopia.setVisibleRowCount(5); .setVisibleRowCount(5); listaCopia listaCopia .setFixedCellWidth(100); listaCopia.setFixedCellWidth(100); listaCopia.setFixedCellHeight(15); listaCopia .setFixedCellHeight(15); listaCopia .setSelectionMode( listaCopia.setSelectionMode( ListSelectionModel. SINGLE_INTERVAL_SELECTION ); ); jsp2= JScrollPane(listaCopia listaCopia); ); jsp2= new JScrollPane( ); getContentPane().add( jsp2); getContentPane().add(jsp2 //getContentPane().add(new JScrollPane(listaCopia)); setSize(325,130); setVisible( true ); }// fin constructor JScrollPaneTest1
main(String args[]){ main(String public static void JScrollPaneTest1 aplicacion = new JScrollPaneTest1(); ); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() }///:~ ///:~ import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JScrollPaneTest2 { private static JList listaColores , listaCopia ; private static JButton botonCopiar ; private static JScrollPane jsp1, jsp2; private final static String nombresColores [] = { "Negro", "Negro", "Azul" "Azul", , "Cyan" "Cyan", ,
"Gris oscuro", "Gris", , "Verde" "Verde", , "Gris claro", claro", "Magenta", "Magenta" , "Naranja", "Naranja", oscuro", "Gris" "Rosa" "Rosa", , "Rojo" "Rojo", , "Blanco" "Blanco", , "Amarillo" "Amarillo" }; }; main(String args[]) main(String public static void { JFrame("Listas "Listas de selección múltiple" múltiple"); ); JFrame f= new JFrame( f.setSize(325,130); f.getContentPane().setLayout( new FlowLayout());
// establecer objeto JList listaColores listaColores = new JList(nombresColores ); .setVisibleRowCount(5);//Mostrados //Mostrados en el JScrollPane listaColores .setVisibleRowCount(5); listaColores .setSelectionMode( ListSelectionModel. MULTIPLE_INTERVAL_SELECTION ); jsp1= new JScrollPane(listaColores ); f.getContentPane().add( jsp1);
//f.getContentPane().add(new JScrollPane(listaColores)); // crear botón copiar y registrar su componente de escucha botonCopiar = = new JButton( JButton("Copiar "Copiar >>>" >>>"); ); ); f.getContentPane().add( botonCopiar ); .addActionListener( new ActionListener() { botonCopiar .addActionListener( actionPerformed(ActionEvent evento) actionPerformed(ActionEvent public void { // colocar valores seleccionados en listaCopia listaCopia .setListData( listaColores .getSelectedValues()); } }); // establecer objeto JList listaCopia listaCopia = new JList(); listaCopia.setVisibleRowCount(5); listaCopia listaCopia.setFixedCellWidth(100); .setFixedCellHeight(15); listaCopia.setSelectionMode( ); ListSelectionModel. SINGLE_INTERVAL_SELECTION ); jsp2= new JScrollPane(listaCopia ); f.getContentPane().add( jsp2);
//f.getContentPane().add(new JScrollPane(listaCopia));
f.setVisible( true ); ); ; f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) }// end main() }///:~
JPanel Los Paneles Paneles son los contenedores de propósito general más frecuentemente utilizados. Implementados con la clase JPanel JPanel,, los paneles no añaden casi ninguna funcionalidad más allá de las que tienen los objetos JComponent JComponent.. Normalmente se usan para agrupar componentes , porque los componentes están relacionados o sólo porque agruparlos hace que la distribución Un fácilmente. panel puede usar cualquier controlador de distribución, y se les puede pusea edemás dotarsencilla. de bordes Un Panel Panel es como un Frame Frame y provee del espacio para que el programador coloque cualquier componente GUI, incluyendo también otros paneles. Cada panel hereda de la clase Container todos sus métodos y atributos, y puede tener su propio administrador de diseño. Ojo: Una de las ventajas de añadir paneles sobre nuestro frame es que los paneles al
derivar de JComponent JComponent poseen el método paintComponent() paintComponent() que permite dibujar y escribir texto sobre el panel de modo sencillo. Además cuando deseamos agregar más componentes en los Layouts por p or región (BorderLayout ) usaremos la clase JPanel JPanel.. import java.awt.*; import javax.swing.*;
GRAFICAS*/ /*JPANEL PARA PINTAR GRAFICAS*/ public class PanelPersonalizado extends JPanel {
/*los miembros y métodos son public * para ser llamados por la otra clase*/ clase*/ public final static int CIRCULO = = 1, CUADRADO = = 2; private int figura; figura; rectángulo // usar figura para dibujar un óvalo o rectángulo public void paintComponent( Graphics g ){ paintComponent( super.paintComponent( g ); if ( figura == figura == CIRCULO ) )
g.fillOval( 50, 10, 60, 60 ); figura == == CUADRADO ) ) else if ( figura g.fillRect( 50, 10, 60, 60 ); } // establecer valor de figura y repintar PanelPersonalizado PanelPersonalizado dibujar( int figuraADibujar ) dibujar( public void { figura = figura = figuraADibujar; repaint();//llama repaint(); paintComponent //llama a paintComponent } }///:~
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JPanelTest extends JFrame
{ private JPanel panelBotones; panelBotones ; private PanelPersonalizado miPanel; miPanel ; botonCirculo, , botonCuadrado; botonCuadrado ; private JButton botonCirculo
GUI // configurar GUI public JPanelTest() { super( "JPanelTest" "JPanelTest" ); ); // crear área personalizada de dibujo dibujo miPanel miPanel = = new PanelPersonalizado(); miPanel.setBackground( Color.GREEN ); miPanel.setBackground( ); // establecer botonCuadrado botonCuadrado botonCuadrado = = new JButton( "Cuadrado" ); "Cuadrado" ); botonCuadrado botonCuadrado.addActionListener( .addActionListener( new ActionListener(){ botonCuadrado actionPerformed( ActionEvent evento ){ actionPerformed( public void miPanel.dibujar( .dibujar( PanelPersonalizado.CUADRADO ); ); miPanel } });
botonCirculo = new JButton( "Círculo" botonCirculo = "Círculo" ); ); botonCirculo.addActionListener( .addActionListener( new ActionListener(){ botonCirculo actionPerformed( ActionEvent evento ){ actionPerformed( public void miPanel.dibujar( .dibujar( PanelPersonalizado.CIRCULO ); ); miPanel } }); COMPONENTES*/ /*JPANEL PARA AGRUPAR COMPONENTES*/ // establecer panel con botones botones panelBotones = = new JPanel(); panelBotones panelBotones.setLayout( panelBotones .setLayout( new GridLayout( 1, 2 ) ); panelBotones.add( .add( botonCirculo botonCirculo ); ); panelBotones panelBotones.add( .add( botonCuadrado botonCuadrado ); ); panelBotones /* adjuntar panel de botones y área personalizada personalizada de dibujo al panel de contenido*/ contenido*/ Container contenedor = getContentPane(); contenedor.add( miPanel, miPanel, BorderLayout.CENTER ); panelBotones, , BorderLayout.SOUTH ); ); contenedor.add( panelBotones setSize(300,150); setVisible( true); } // fin del constructor JPanelTest JPanelTest main( String args[] ) main( public static void {
JPanelTest aplicacion = new JPanelTest(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); ); }//end main() main() }///:~
JtabbedPane Con la clase JTabbedPane JTabbedPane,, podemos tener varios componentes (normalmente objetos JPanel)) compartiendo el mismo espacio. El usuario puede elegir qué componente ver JPanel seleccionando la pestaña del componente deseado. Para crear un TabbedPane, simplemente se ejemplariza un JTabbedPane JTabbedPane,, se crean los componentes que deseemos mostrar, y luego los añadimos al JTabbedPane utilizando el método addTab addTab..
import java.awt.*; import javax.swing.*; public class JTabbedPaneTest extends JFrame public JTabbedPaneTest() "JTabbedPane"); ); { super("JTabbedPane"
{
/*SwingConstants:=> A collection of constants generally used for for screen. positioning and orienting components on the screen. horizontalAlignment) JLabel(String text, int horizontalAlignment) Creates a JLabel instance with the specified text and horizontal alignment.*/ alignment.*/ JLabel("panel "panel uno", uno", SwingConstants.CENTER); JLabel etiqueta1 = new JLabel( JLabel etiqueta2 = new JLabel( JLabel("panel "panel dos", dos", SwingConstants.CENTER); JLabel("panel "panel tres"); tres"); JLabel etiqueta3 = new JLabel( JTabbedPane // crear objeto JTabbedPane JTabbedPane panelConFichas = new JTabbedPane(); /* establecer pane11 y agregarlo al objeto JTabbedPane*/ JTabbedPane*/ JPanel panel1 = new JPanel(); panel1.add(etiqueta1); /*addTab(String title, Icon icon, Component component, String tip)*/ tip)*/ panelConFichas.addTab("Ficha panelConFichas.addTab( "Ficha uno" uno", , null, panel1, "Primer panel" panel"); );
JTabbedPane // establecer panel2 y agregarlo al objeto JTabbedPane JPanel panel2 = new JPanel(); ); ; panel2.setBackground(Color. PINK ) panel2.add(etiqueta2); "Ficha dos" dos", , null, panel2, "Segundo panel" panel"); ); panelConFichas.addTab("Ficha panelConFichas.addTab( // establecer panel3 y agregarlo al objeto JTabbedPane JTabbedPane JPanel panel3 = new JPanel(); panel3.setLayout( new BorderLayout()); panel3.add( new JButton( JButton("Norte" "Norte"), ), BorderLayout.NORTH ); ); JButton("Sur" "Sur"), ), BorderLayout.SOUTH ); ); panel3.add( new JButton( panel3.add( new JButton( JButton("Oeste" "Oeste"), ), BorderLayout.WEST ); ); panel3.add( new JButton( JButton("Este" "Este"), ), BorderLayout.EAST ); ); panel3.add( etiqueta3, BorderLayout.CENTER ); panelConFichas.addTab("Ficha panelConFichas.addTab( tres", null, panel3, "Tercer panel"); "Ficha tres", panel"); contenedor // agregar objeto JTabbedPane al contenedor getContentPane().add(panelConFichas); setSize(300, 200); setVisible( true ); } // fin del constructor constructor public static void main(String args[]) main(String {
JTabbedPaneTest demoPanelConFichas = new JTabbedPaneTest(); ); demoPanelConFichas.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() main() }///:~
JSplitPane JSplitPane se usa para dividir con una barrita divisoria dos y solo dos componentes, JSplitPane se mismos que pueden ser alineados de izquierda a derecha o de arriba hacia abajo. Arrastrando el divisor, el usuario puede especificar qué cantidad de área pertenece a cada componente. Un yJSplitPane JSplitPane cuando doscambiar componentes contienen información relacionada queremos se que utiliza el usuario pueda el tamaño de los componentes en relación a uno o a otro. Un uso común de un JSplitPane JSplitPane es para contener listas de elecciones y una visión de la elección actual.
import java.lang.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JSplitPaneTest1 { static JFrame f = new JFrame(); ); ; static JSplitPane jsplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT ) JLabel("en "en split1 label1"); label1"); static JLabel etiqueta1 = new JLabel( static JLabel etiqueta2 = new JLabel( JLabel("en "en split2 label2"); label2");
main(String[] args){ main(String[] public static void f .setTitle("JSplitPane" .setTitle( "JSplitPane"); ); .setSize(300,200); f .setSize(300,200); //cargando jsplitpane con sus dos componentes componentes jsplitPane .add(etiqueta1 ); jsplitPane .add(etiqueta2 ); //cargando la ventana con splitpanel splitpanel f .getContentPane().add( .getContentPane().add( jsplitPane,BorderLayout. CENTER); .setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); ); f .setDefaultCloseOperation(JFrame. f .setVisible( .setVisible( true); }; //end main() main()
}///:~
JToolBar Un objeto JToolBar JToolBar crea crea una barra de herramientas con iconos dentro de una fila o una columna. Normalmente las barras de herramientas proporcionan acceso a funcionalidades que también se encuentran en ítems de menús.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JToolBarTest { static JLabel etiqueta = new JLabel();
main(String[] args) { main(String[] public static void JFrame f= new JFrame(); ); f.setTitle( "JToolBarTest"); f.setTitle("JToolBarTest" f.setSize(400,150); f.getContentPane().add( etiqueta,BorderLayout. EAST ) ); ; JToolBar toolbar=new JToolBar(); ImageIcon("open.gif" "open.gif")); )); final JButton b1= new JButton(new ImageIcon( ImageIcon("save.gif" "save.gif")); )); final JButton b2= new JButton(new ImageIcon( JButton b3= new JButton(new ImageIcon( ImageIcon("copy.gif" "copy.gif")); )); ImageIcon("cut.gif" "cut.gif")); )); JButton b4= new JButton(new ImageIcon( JButton b5= new JButton(new ImageIcon( ImageIcon("paste.gif" "paste.gif")); )); toolbar.add(b1); toolbar.add(b2);toolbar.addSeparator(); toolbar.add(b3); toolbar.add(b4); toolbar.add(b5);
//Forma1: se utiliza la etiqueta dentro del manejador de eventos {//Agregamos un oyente al botón botón b1.addActionListener( new ActionListener() {//Agregamos actionPerformed(ActionEvent ev) {//Tratamiento actionPerformed(ActionEvent {//Tratamiento del evento evento public void //Si se elige el boton de Open en el JToolBar JToolBar if (ev.getSource() == b1) { etiqueta
}
.setText("Seleccionaste .setText( "Seleccionaste el botón OPEN"); OPEN");
} }); //Forma2: mandamos a llamar a un método openFile() para tratar la etiqueta b2.addActionListener( new ActionListener() {//Agregamos {//Agregamos un oyente al botón botón actionPerformed(ActionEvent ev) {//Tratamiento actionPerformed(ActionEvent {//Tratamiento del evento evento public void //Si se elige el botón de Save en el JToolBar JToolBar if (ev.getSource() == b2) { openFile(); } } }); f.getContentPane().add(toolbar,BorderLayout. NORTH ) ); ; f.setVisible( true); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) ); ; main() }//end main() openFile(){ openFile(){ public static void etiqueta.setText( .setText("Seleccionaste "Seleccionaste el botón SAVE" SAVE"); ); } }///:~
MENUS
Un Menu Menu es un componente diferente a otros componentes porque no se puede agregar a un Menu a los contenedores comunes. Solo se puede agregar menús a un "menu container".
JMenuBar Un componente JMenuBar JMenuBar es un menú horizontal. Puede solamente agregarse a un objeto JFrame JFrame,, y forma la raíz de todos los árboles menú. Un JFrame JFrame despliega un JMenuBar a la vez. Se puede comenzar un árbol de menú poniendo un JMenuBar JMenuBar JMenuBar "una barra barra de menú" en un JFrame JFrame,, usando el método setJMenuBar() setJMenuBar().. Desde este punto, se pueden agregar menús a la barra de menú y menús o elementos de menú dentro del menú. El JMenuBar JMenuBar no no soporta oyentes. Como parte normal del comportamiento de un menú, los eventos anticipados que ocurran en la región de la barra de menú son procesados automáticamente.
JMenu Es posible crear entradas a una barra de menú agregando objetos de la clase proveen al JMenuBar elementos de tipo menú pullJMenu.. Los componentes JMenu JMenu JMenu proveen JMenuBar elementos down "menús desplegables".
JMenuItem Un componente JMenuItem JMenuItem son son los nodos hoja de un árbol de menú. Son agregados a un menú para completarlo. Swing también soporta JCheckBox JCheckBox y JRadioButton JRadioButton en menus, utilizando las clases correspondientes JCheckBoxMenuItem,, JCheckBoxMenuItem JRadioButtonMenuItem.. JRadioButtonMenuItem
Si a una aplicación le quisieramos añadir un menú tendríamos hacer las siguientes cosas siguiendo un órden cualquiera: Crear los objetos JMenuItem JMenuItem.. Crear los objetos JMenu JMenu y y pegarles los JMenuItem: JMenuItem: JRadioButtonMenuItem) (JMenuItem, JCheckBoxMenuItem, JRadioButtonMenuItem) Crear una JMenuBar JMenuBar y y pegarles los JMenu JMenu..
Es decir: JMenuBar => contiene JMenu JCheckBoxMenuItem, JRadioButtonMenuItem.
=>
contiene
import javax.swing.*; public class JMenuBarTest { main(String[] args) { main(String[] public static void JFrame f=new JFrame();
"JMenuBarTest"); ); f.setTitle("JMenuBarTest" f.setTitle( f.setSize(250,150); JMenuBar menuBar=new JMenuBar(); f.setJMenuBar(menuBar); //Sets the menuBar for this frame.
JMenuItem,
MENUS*/ /*NOMBRE DE LOS MENUS*/ // establecer menú Archivo y sus elementos de menú menú JMenu menu1=new JMenu( JMenu("Menu1" "Menu1"); ); menu1.setMnemonic('1' menu1.setMnemonic('1'); ); JMenu menu2=new JMenu( JMenu("Menu2" "Menu2"); ); menu2.setMnemonic('e' menu2.setMnemonic('e'); ); /*ELEMENTOS DEL MENU1*/ MENU1*/ JMenuItem menuItem1= new JMenuItem( JMenuItem("Opcion1" "Opcion1"); ); new JMenuItem("Opcion2" "Opcion2"); ); JMenuItem menuItem2= menu1 JMenuItem( //SE AGREGAN AL menu1 menu1.add(menuItem1); menu1.add(menuItem2);
/*ELEMENTOS DEL MENU2*/ MENU2*/ JCheckBoxMenuItem("Opcion1" "Opcion1"); ); JCheckBoxMenuItem jcbmenuItem1= new JCheckBoxMenuItem( JCheckBoxMenuItem jcbmenuItem2= new JCheckBoxMenuItem( JCheckBoxMenuItem("Opcion2" "Opcion2", ,true); JRadioButtonMenuItem jcbmenuItem3= new JRadioButtonMenuItem("Opcion3" JRadioButtonMenuItem( "Opcion3", ,true); menu2 //SE AGREGAN AL menu2 menu2.add(jcbmenuItem1); menu2.add(jcbmenuItem2); menu2.addSeparator(); //Agrega un separador menu2.add(jcbmenuItem3); /*MENU 1 Y MENU2 SE AGREGAN AL MENUBAR*/ MENUBAR*/ menuBar.add(menu1); menuBar.add(menu2); f.setVisible( true); ); ; f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) }//end main() main() ///:~ }///:~
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JMenuBarTest2 extends JFrame { private final Color valoresColor[]={Color. valoresColor []={Color. black,Color.blue,Color.red ,Color. ,Color.green }; elementosColor [], tiposLetra[]; tiposLetra []; private JRadioButtonMenuItem elementosColor[], elementosEstilo []; private JCheckBoxMenuItem elementosEstilo[]; private JLabel pantallaEtiqueta; pantallaEtiqueta ; grupoTiposLetra , grupoColores grupoColores; ; private ButtonGroup grupoTiposLetra, estilo; private int estilo; public JMenuBarTest2(){
super("JMenuBarTest2" );
// establecer etiqueta para mostrar texto texto JLabel("Texto "Texto de ejemplo" ejemplo", , SwingConstants.CENTER ); pantallaEtiqueta = new JLabel( .setForeground(valoresColor valoresColor[0]); [0]); pantallaEtiqueta .setForeground( pantallaEtiqueta .setFont( new Font( Font("Serif" "Serif", , Font.PLAIN , 72)); getContentPane().add( pantallaEtiqueta, pantallaEtiqueta , BorderLayout.CENTER); // crear barra de menús y adjuntarla a la ventana del Frame Frame JMenuBar barra = new JMenuBar(); setJMenuBar(barra); // establecer menú Archivo y sus elementos de menú menú JMenu menuArchivo = new JMenu( JMenu("Archivo" "Archivo"); ); 'A'); ); menuArchivo.setMnemonic( 'A' de... // establecer elemento de menú Acerca de... de..." ); JMenuItem elementoAcerca = new JMenuItem( "Acerca de..." ); elementoAcerca.setMnemonic( 'c'); 'c'); menuArchivo.add(elementoAcerca); elementoAcerca.addActionListener( new ActionListener(){ // mostrar cuadro de diálogo de mensaje cuando se seleccione Acerca de... actionPerformed( ActionEvent evento ){ actionPerformed( public void JOptionPane.showMessageDialog (JMenuBarTest2.this, "Éste es un ejemplo\ndel uso de menús", menús" , "Acerca de..." de...", , JOptionPane. JOptionPane.PLAIN_MESSAGE ); } }); // establecer elemento de menú Salir Salir JMenuItem elementoSalir = new JMenuItem("Salir" "Salir"); ); 'S'); ); elementoSalir.setMnemonic( 'S' JMenuItem( menuArchivo.add(elementoSalir); elementoSalir.addActionListener( new ActionListener(){ // terminar la aplicación cuando el usuario haga clic en elementoSalir public void actionPerformed(ActionEvent evento) { System.exit(0); } });
MENUARCHIVO*/ /*AGREGA LOS MENUITEMS A MENUARCHIVO*/ barra.add(menuArchivo); // crear menú Formato, con sus submenús y elementos de menú menú JMenu menuFormato = new JMenu( JMenu("Formato" "Formato"); ); menuFormato.setMnemonic( 'F'); 'F'); // crear submenú Color Color String colores[] = {"Negro" {"Negro", , "Azul", "Azul", "Rojo", "Rojo" , "Verde"}; "Verde"}; JMenu("Color" "Color"); ); JMenu menuColor = new JMenu( menuColor.setMnemonic( 'C'); 'C'); elementosColor = new JRadioButtonMenuItem[colores.length elementosColor = JRadioButtonMenuItem[colores.length]; ]; grupoColores = ButtonGroup();// // Se agrupa para k sean exclusivos exclusivos grupoColores = new ButtonGroup(); ManejadorEventos manejadorEventos = new ManejadorEventos(); // crear elementos de menú tipo botones de opción para el menú Color Color for(int cuenta= 0; cuenta < colores.length colores. length; ; cuenta++) { elementosColor[cuenta]= [cuenta]= new JRadioButtonMenuItem(colores[cuenta]); elementosColor
menuColor.add(elementosColor menuColor.add( elementosColor[cuenta]); [cuenta]); grupoColores.add( .add(elementosColor elementosColor[cuenta]); [cuenta]); grupoColores elementosColor elementosColor[cuenta].addActionListener(manejadorEventos); [cuenta].addActionListener(manejadorEventos); } // seleccionar primer elemento del menú Color Color elementosColor[0].setSelected( elementosColor [0].setSelected( true); // agregar el Menu Color al Menu Formato de la barra de menús menús menuFormato.add(menuColor);
menuFormato.addSeparator(); letra // crear submenú Tipo de letra String nombresTiposLetra[] = {"Serif" {"Serif", , "Monospaced", "Monospaced" , "SansSerif"}; "SansSerif"}; JMenu("Tipo "Tipo de letra"); letra"); JMenu menuTiposLetra = new JMenu( menuTiposLetra.setMnemonic( 'T'); 'T'); tiposLetra = JRadioButtonMenuItem[nombresTiposLetra.length]; ]; tiposLetra = new JRadioButtonMenuItem[nombresTiposLetra.length grupoTiposLetra = = new ButtonGroup(); grupoTiposLetra // crear elementos de menú tipo botones de opción para el menú Tipos de letra letra for ( int cuenta = 0; cuenta < tiposLetra. tiposLetra .length; length ; cuenta++ ) { tiposLetra[cuenta] tiposLetra [cuenta] = new JRadioButtonMenuItem(nombresTiposLetra[cuenta]); menuTiposLetra.add( tiposLetra[cuenta]); tiposLetra [cuenta]); grupoTiposLetra .add( .add(tiposLetra tiposLetra[cuenta]); [cuenta]); tiposLetra [cuenta].addActionListener(manejadorEventos); tiposLetra[cuenta].addActionListener(manejadorEventos); } // seleccionar el primer elemento del menú Tipo de letra letra tiposLetra [0].setSelected( true); tiposLetra[0].setSelected( menuTiposLetra.addSeparator(); // establecer elementos del menú Estilo Estilo String nombresEstilo[]= {"Negrita" {"Negrita", , "Cursiva"}; "Cursiva"}; elementosEstilo = new JCheckBoxMenuItem[nombresEstilo.length elementosEstilo = JCheckBoxMenuItem[nombresEstilo.length]; ]; ManejadorEstilo manejadorEstilo = new ManejadorEstilo(); // crear elementos de menú tipo casilla de verificación para el menú Estilo nombresEstilo. length; ; cuenta++ ) { for ( int cuenta = 0; cuenta < nombresEstilo.length elementosEstilo [cuenta]= new JCheckBoxMenuItem(nombresEstilo[cuenta]); menuTiposLetra.add( elementosEstilo[cuenta]); elementosEstilo [cuenta]); elementosEstilo [cuenta].addItemListener(manejadorEstilo); } Formato // colocar menú Tipo de letra en el menú Formato menuFormato.add(menuTiposLetra); // agregar menú Formato a la barra de menús menús barra.add(menuFormato);
setSize(550, 200); setVisible( true); } // fin del constructor constructor /* clase interna para manejar eventos de acción de los elementos de menú menú Ambos son JRadioButtonItem */ */ private class ManejadorEventos implements ActionListener { letra // procesar selecciones de color y tipo de letra actionPerformed(ActionEvent evento) public void // procesar selección de color { color elementosColor. .length length; ; cuenta++) for (int cuenta = 0; cuenta < elementosColor (elementosColor elementosColor[cuenta].isSelected()){ [cuenta].isSelected()){ if ( pantallaEtiqueta .setForeground( .setForeground(valoresColor valoresColor[cuenta]); [cuenta]); break; } // ( procesar selección de tipo letra letra .length; int cuenta = 0; cuenta < de tiposLetra tiposLetra. length; cuenta++) for mismo //if (evento.getSource() == tiposLetra[cuenta]) { //lo mismo (tiposLetra tiposLetra[cuenta].isSelected()) [cuenta].isSelected()) { if ( pantallaEtiqueta .setFont( new Font( Font(tiposLetra tiposLetra[cuenta].getText(), [cuenta].getText(), estilo estilo, , 72)); break; } repaint(); //Repaints this component. } // fin del método actionPerformed actionPerformed ManejadorEventos } // fin de la clase ManejadorEventos // clase interna para manejar eventos de los elementos de menú tipo casilla de verificación
private class ManejadorEstilo implements ItemListener {
letra // procesar selecciones de estilo de tipo de letra itemStateChanged(ItemEvent ev){ public void estilo estilo = = 0; negrita // checar selección de negrita (elementosEstilo elementosEstilo [0].isSelected()) if ( estilo += += Font.BOLD; estilo // checar selección de cursiva cursiva if ( (elementosEstilo elementosEstilo [1].isSelected()) estilo += += Font.ITALIC ; estilo
pantallaEtiqueta .setFont( pantallaEtiqueta.setFont( Font(pantallaEtiqueta pantallaEtiqueta .getFont().getName(), estilo, estilo, 72)); new Font( repaint();//Repaints repaint(); //Repaints this component. component. } } // fin de la clase ManejadorEstilo ManejadorEstilo main( String args[] ) main( public static void { JMenuBarTest2 aplicacion = new JMenuBarTest2(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() main() }///:~
OTRAS CLASES BÁSICAS Evento con Teclado En este apartado se mostrara un ejemplo del manejo de pulsación de teclas y el mismo código se mostrará en otras dos clases diferentes para recalcar aún más lo aprendido en swing y las diversas maneras de programar código Java.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class KeyListenerTest1 extends JFrame implements KeyListener { linea1 = "", "", linea2 linea2 = = "", "", linea3 = linea3 = "" ""; ; private String linea1 = areaTexto ; private JTextArea areaTexto; public KeyListenerTest1()
{ tecla"); ); super("Demostración de eventos de pulsación de tecla" // establecer objeto JTextArea JTextArea areaTexto = new JTextArea(10,15); areaTexto = areaTexto.setText( "Oprima cualquier tecla en el teclado..."); teclado..."); areaTexto .setText("Oprima areaTexto .setEnabled( false); areaTexto.setEnabled( areaTexto.setDisabledTextColor(Color. areaTexto .setDisabledTextColor(Color. blue); getContentPane().add( areaTexto); areaTexto); JTextArea addKeyListener( this); // eventos de teclas para el JTextArea setSize(400, 100); setVisible( true); } // fin del constructor constructor // manejar evento de pulsación de cualquier tecla tecla keyPressed(KeyEvent evento) keyPressed(KeyEvent public void { /*getKeyText(int keyCode)=>Returns a String describing the keyCode, keyCode, * such as "HOME", "F1" or "A". "A". * getKeyCode()=> getKeyCode()=>Returns Returns the integer (ASCII)keyCode ( ASCII)keyCode associated as sociated with the key in this th is event.
*getKeyChar()=> Returns the character associated with the key in this event.*/ event.*/ //System.out.println(evento.getKeyChar());*/ linea1 = "Se oprimió tecla: " + linea1 = " + evento.getKeyText (evento.getKeyCode()); establecerLineas2y3(evento); } // manejar evento de liberación de cualquier tecla tecla keyReleased(KeyEvent evento) keyReleased(KeyEvent public void { linea1 linea1 = = "Se soltó tecla: " + " + evento.getKeyText (evento.getKeyCode()); establecerLineas2y3(evento); } acción // manejar evento de pulsación de una tecla de acción keyTyped(KeyEvent evento) keyTyped(KeyEvent public void { nada // no hay nada } // establecer segunda y tercera líneas de salida salida private void establecerLineas2y3(KeyEvent evento)
{
//F1-F12, ImpPant, Inicio, Supr, etc.. etc.. linea2 = "Esta tecla " + linea2 = " + (evento.isActionKey() ? "" : "" : "no " ") ) + "es una tecla de acción"; acción"; String temp = evento.getKeyModifiersText (evento.getModifiers()); Ctrl+Alt //Ctrl, Shift, Alt, Ctrl+Alt linea3 = "Teclas modificadoras oprimidas: " + linea3 = " + "") ) ? "ninguna" : "ninguna" : temp); (temp.equals("" (temp.equals( areaTexto.setText( .setText(linea1 linea1 + + "\n" "\n" + + linea2 + linea2 + "\n" "\n" + + linea3 linea3 + + "\n"); "\n"); areaTexto
} public static void main(String args[]) main(String
{ KeyListenerTest1 aplicacion = new KeyListenerTest1(); aplicacion.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); }//end main() main() }///:~
import java.awt.*; import java.awt.event.*; import javax.swing.*;
// Se elimino public class KeyListenerTest1 extends JFrame implements KeyListener { public class KeyListenerTest2 extends JFrame { linea1 = "", "", linea2 linea2 = = "", "", linea3 = linea3 = "" ""; ; private String linea1 = areaTexto ; private JTextArea areaTexto;
// configurar GUI GUI public KeyListenerTest2()
{ tecla"); ); super("Demostración de eventos de pulsación de tecla" // establecer objeto JTextArea JTextArea areaTexto = new JTextArea(10, 15); areaTexto = areaTexto.setText( teclado..." ); areaTexto .setText( "Oprima cualquier tecla en el teclado..." ); //areaTexto.setEnabled( false ); ); areaTexto.setDisabledTextColor( Color.blue ); areaTexto .setDisabledTextColor( areaTexto ); ); getContentPane().add( areaTexto ManejadorTeclas teclas = new ManejadorTeclas(); //addKeyListener(this); // eventos de teclas para el JTextArea JTextArea areaTexto areaTexto.addKeyListener(teclas); .addKeyListener(teclas); // eventos de teclas para el JTextArea JTextArea setSize(400,100); setVisible( true ); } // fin del constructor constructor {// manejar evento de pulsación de private class ManejadorTeclas implements KeyListener {//
cualquier tecla tecla tecla // manejar evento de pulsación de cualquier tecla keyPressed(KeyEvent evento) keyPressed(KeyEvent public void { /*getKeyText(int keyCode)=>Returns a String describing the keyCode, keyCode, such as "HOME", "F1" or "A". "A". * * getKeyCode() getKeyCode()=>Returns =>Returns the integer intege r (ASCII)keyCode associated as sociated with the key in this th is *event. *getKeyChar()=> Returns the character associated with the key in this event.*/ event.*/ //System.out.println(evento.getKeyChar());*/ linea1 = "Se oprimió tecla: " linea1 = " + + evento.getKeyText (evento.getKeyCode()); establecerLineas2y3(evento); } // manejar evento de liberación de cualquier tecla keyReleased(KeyEvent evento) keyReleased(KeyEvent public void { linea1 linea1 = = "Se soltó tecla: " " + + evento.getKeyText (evento.getKeyCode()); establecerLineas2y3(evento); } acción // manejar evento de pulsación de una tecla de acción keyTyped(KeyEvent evento) keyTyped(KeyEvent public void { // no hay nada nada } salida // establecer segunda y tercera líneas de salida establecerLineas2y3(KeyEvent evento) private void {
//F1-F12, ImpPant, Inicio, Supr, etc.. etc.. linea2 = = "Esta tecla " " + + (evento.isActionKey() ? "" : "" : "no ") ") + linea2 "es una tecla de acción"; acción"; String temp = evento.getKeyModifiersText (evento.getModifiers()); //Ctrl, Shift, Alt, Ctrl+Alt Ctrl+Alt linea3 = " + + linea3 = "Teclas modificadoras oprimidas: " (temp.equals("" (temp.equals( "") ) ? "ninguna" : "ninguna" : temp);
areaTexto areaTexto.setText( .setText(linea1 linea1 + + "\n" + "\n" + linea2 + linea2 + "\n" "\n" + + linea3 + linea3 + "\n" "\n"); ); } }//end manejador manejador
main( String args[] ) main( public static void { KeyListenerTest2 aplicacion = new KeyListenerTest2(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() main() }///:~
import java.awt.*; import java.awt.event.*; import javax.swing.*;
//Se elimino public class KeyListenerTest1 extends JFrame implements KeyListener { public class KeyListenerTest3 extends JFrame { linea1 = "", "", linea2 linea2 = = "", "", linea3 = linea3 = "" ""; ; private String linea1 = areaTexto ; private JTextArea areaTexto; public KeyListenerTest3()
{ tecla"); ); super("Demostración de eventos de pulsación de tecla" // establecer objeto JTextArea JTextArea areaTexto = areaTexto = new JTextArea(10,15); areaTexto.setText( areaTexto .setText( "Oprima cualquier tecla en el teclado..." ); teclado..." ); areaTexto areaTexto.setDisabledTextColor(Color. .setDisabledTextColor(Color. blue); getContentPane().add( areaTexto); areaTexto); //ManejadorTeclas teclas = new ManejadorTeclas(); ManejadorTeclas();
//addKeyListener(this); // eventos de teclas para el JTextArea JTextArea areaTexto areaTexto.addKeyListener( .addKeyListener( new KeyListener() { // manejar evento de pulsación de cualquier tecla tecla keyPressed(KeyEvent evento) keyPressed(KeyEvent public void { /*getKeyText(int keyCode)=>Returns a String describing the keyCode, keyCode, * such as "HOME", "F1" or "A". "A". * getKeyCode() getKeyCode()=>Returns =>Returns the integer intege r (ASCII)keyCode associated as sociated with the key in this th is * event. *getKeyChar()=> Returns the character associated with the key in this event.*/ event.*/ //System.out.println(evento.getKeyChar());*/ linea1 = "Se oprimió tecla: " linea1 = " + + evento.getKeyText (evento.getKeyCode()); establecerLineas2y3(evento); } // manejar evento de liberación de cualquier tecla public void keyReleased(KeyEvent evento) keyReleased(KeyEvent
{ linea1 linea1 = = "Se soltó tecla: " " + + evento.getKeyText (evento.getKeyCode()); establecerLineas2y3(evento); } // manejar evento de pulsación de una tecla de acción acción keyTyped(KeyEvent evento) keyTyped(KeyEvent public void { nada // no hay nada } // establecer segunda y tercera líneas de salida salida establecerLineas2y3(KeyEvent evento) private void {
//F1-F12, ImpPant, Inicio, Supr, etc.. etc.. linea2 linea2 = = "Esta tecla " " + + (evento.isActionKey() ? "" : "" : "no ") ") + "es una tecla de acción"; acción"; String temp = evento.getKeyModifiersText (evento.getModifiers()); //Ctrl, Shift, Alt, Ctrl+Alt Ctrl+Alt linea3 = " + + linea3 = "Teclas modificadoras oprimidas: " (temp.equals("" (temp.equals( "") ) ? "ninguna" : "ninguna" : temp); areaTexto areaTexto.setText( .setText(linea1 linea1 + + "\n" + "\n" + linea2 + linea2 + "\n" "\n" + + linea3 + linea3 + "\n" "\n"); );
}
}); setSize(400, 100 ); setVisible( true ); constructor } // fin del constructor main( String args[] ) main( public static void { KeyListenerTest3 aplicacion = new KeyListenerTest3(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() main() } ///:~
CLASE Color Red,, Green, Green, La clase java.awt.Color encapsula colores utilizando el formato RGB (Red Blue). Las componentes de cada color primario en el color resultante se expresan con Blue). números enteros entre 0 y 255, siendo 0 la intensidad mínima de ese color y 255 la máxima. En la clase Color existen constantes para colores predeterminados de uso frecuente: black , white , green , blue , red , yellow , magenta , cyan , orange , pink , gray , darkGray , lightGray .
Se puede construir mediante un valor RGB: Color amarillo = new Color(255,255,0); O utilizar colores predefinidos mediante constantes: Color amarillo = Color.YELLOW; Soporta transparencias (alpha) mediante un valor entre 0.0 y 1.0 La Tabla muestra algunos métodos de la clase Color .
import java.awt.*; import javax.swing.*; public class ColorTest { main(String[] args) { main(String[] public static void JFrame f=new JFrame();
); f.setTitle( "Colores"); f.setTitle("Colores" f.setSize(200,150); f.getContentPane().setLayout( new FlowLayout()); JLabel JLabel JLabel JLabel
JLabel("Hola "Hola etiqueta1=new JLabel( JLabel("Hola "Hola etiqueta2=new JLabel( etiqueta3=new JLabel( JLabel("Hola "Hola etiqueta4=new JLabel( JLabel("Hola "Hola
JLabel JLabel JLabel JLabel JLabel JLabel
JLabel("Hola "Hola "); etiqueta5= etiqueta6=new new JLabel( JLabel("Hola JLabel( "Hola a a Todos Todos"); Todos"| );"); etiqueta7=new JLabel( JLabel("Hola "Hola a Todos | "); "); JLabel("Hola "Hola a Todos"); Todos"); etiqueta8=new JLabel( etiqueta9=new JLabel( JLabel("Hola "Hola a Todos | "); "); etiqueta10=new JLabel( JLabel("Hola "Hola a Todos" Todos"); );
f.getContentPane().add(etiqueta1); f.getContentPane().add(etiqueta2); f.getContentPane().add(etiqueta3);
a a a a
Todos | "); "); Todos"); Todos"); Todos | "); "); Todos"); Todos");
f.getContentPane().add(etiqueta4); f.getContentPane().add(etiqueta5); f.getContentPane().add(etiqueta6); f.getContentPane().add(etiqueta7); f.getContentPane().add(etiqueta8); f.getContentPane().add(etiqueta9); f.getContentPane().add(etiqueta10); etiqueta1.setForeground( new Color(255,255,0)); ); ; etiqueta2.setForeground(Color. YELLOW ) etiqueta3.setForeground( new Color(255,255,255)); ); ; etiqueta4.setForeground(Color. WHITE ) etiqueta5.setForeground( new Color(0,0,0)); etiqueta6.setForeground(Color. BLACK ) ); ; etiqueta7.setForeground(Color. RED); etiqueta8.setForeground(Color. BLUE ) ); ; ); ; etiqueta9.setForeground(Color. GREEN ) etiqueta10.setForeground(Color. GRAY ) ); ; f.setVisible( true); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) ); ; main() }// end main() }///:~
CLASE Font Cada tipo de letra está representado por un objeto de la clase Font Font.. Las clases y Graphics disponen de métodos setFont() y getFont() Component y Component Graphics disponen setFont() y getFont().. El constructor de Font tiene la forma: Font(String name, int style, int size) Donde el style style se se puede definir con las constantes: Font.PLAIN,, Font.BOLD y Font.ITALIC Font.PLAIN Estas constantes se pueden combinar en la forma: Font.BOLD | Font.ITALIC. Font.ITALIC. La clase Font tiene tres variables protected , llamadas name Font name,, style style y size size.. Además tiene tres constantes enteras: PLAIN e ITALIC PLAIN,, BOLD BOLD e ITALIC.. Esta clase dispone de los métodos: String getName(), int getStyle(), int getSize(), boolean isPlain(), boolean isBold() isBold() y boolean isItalic(), isItalic(), cuyo significado es inmediato. Para mayor portabilidad se recomienda utilizar nombres lógicos de fonts, tales como Serif Serif (Times New Roman), SansSerif (Arial) y Monospaced Monospaced (Courier). (Courier). import java.awt.*; import javax.swing.*; public class FontTest {
public static void main(String[] args){ main(String[] JFrame f = new JFrame();
); f.setTitle("FontTest"); f.setTitle("FontTest" f.setSize(180,200); f.setLayout(new FlowLayout()); JLabel l1 = new JLabel( JLabel("Serif" "Serif"); ); Font("Serif" "Serif", , Font.PLAIN , 20)); l1.setFont(new Font( JLabel("SansSerif" "SansSerif"); ); JLabel l2 = new JLabel( l2.setFont(new Font( Font("SansSerif" "SansSerif", , Font.PLAIN , 20)); JLabel("Monospaced" "Monospaced"); ); JLabel l3 = new JLabel( l3.setFont(new Font( Font("Monospaced" "Monospaced", , Font.ITALIC , 20)); JLabel("Dialog" "Dialog"); ); JLabel l4 = new JLabel( l4.setFont(new Font( Font("Dialog" "Dialog", , Font.BOLD,20)); JLabel("DialogInput" "DialogInput"); ); JLabel l5 = new JLabel( l5.setFont(new Font( Font("DialogInput" "DialogInput", , Font.BOLD | Font.ITALIC , 20)); f.add(l1); f.add(l2); f.add(l3); f.add(l4); f.add(l5); f.setVisible(true); ); ; f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ) }// end main() main() }///:~
CLASE MouseAdapter Los eventos de Mouse nos cuentan cuando el usuario usa el ratón (o un dispositivo de entrada similar) para interactuar con un componente. Los eventos Mouse ocurren cuando el cursor entra o sale del área de pantalla de un componente, o cuando el usuario pulsa o libera el botón del ratón. Como seguir la pista del movimiento del ratón
significa mas sobrecarga del sistema que seguir la pista de los eventos de ratón, los eventos MouseMotion MouseMotion se han separado en otro tipo de oyente (MouseMotionListener MouseMotionListener). ). El interface MouseListener MouseListener y su correspondiente clase adaptadora, MouseAdapter MouseAdapter,, contienen estos métodos: void mouseClicked(MouseEvent): mouseClicked(MouseEvent): Llamado justo después de que el usario pulse sobre el componente escuchado. void mouseEntered(MouseEvent): mouseEntered(MouseEvent): Llamado justo después de que el cursor entre en los límites del componente escuchado. void mouseExited(MouseEvent): mouseExited(MouseEvent): Llamado justo después de que el cursor salga de los límites del componente escuchado. void mousePressed(MouseEvent): mousePressed(MouseEvent): Llamado justo después de que el usuario pulse un botón del ratón mientras el cursor está sobre el componente escuchado. void mouseReleased(MouseEvent): mouseReleased(MouseEvent): Llamado justo después de que el usuario libere un botón del ratón después de una pulsación sobre el componente esuchado.
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class MouseAdapterTest MouseAdapterTest extends JFrame { xPos, yPos yPos; ; private int xPos, private JLabel etiqueta; etiqueta; public MouseAdapterTest(){ ratón" ); super( "Clics y botones del ratón" );
Container contenedor= getContentPane(); addMouseListener( new ManejadorClicsRaton()); etiqueta etiqueta= = new JLabel( JLabel("" ""); ); etiqueta); ); contenedor.add(etiqueta contenedor.add( setSize(450,300); setVisible(true); constructor }// fin del constructor // clase interna para manejar eventos de ratón ratón private class ManejadorClicsRaton extends MouseAdapter {
// manejar evento de clic del ratón y determinar cuál botón se oprimió oprimió mouseClicked(MouseEvent evento){ mouseClicked(MouseEvent public void xPos = xPos = evento.getX(); yPos yPos = = evento.getY();
String titulo = "Se hizo clic " " + + evento.getClickCount() + " Veces" Veces" ; ; [" + + xPos + xPos + ", " " + + yPos + yPos + "]" "]"; ; String titulo2 = "Se hizo clic en: [" if (evento.isMetaDown()) (evento.isMetaDown())// // botón derecho del ratón
titulo += " con el botón derecho del ratón" ratón"; ; (evento.isAltDown())// // botón de en medio del ratón ratón else if (evento.isAltDown()) ratón"; ; titulo += "izquierdo con el botón central del ratón" else // botón del ratón titulo += " con el botón izquierdo del ratón"; ratón"; etiqueta etiqueta.setText(titulo2); .setText(titulo2); setTitle( titulo ); // establecer barra de título de la ventana ventana } // fin del método mouseClicked mouseClicked } // fin de la clase interna privada ManejadorClicsRaton ManejadorClicsRaton main(String args[]) main(String public static void { MouseAdapterTest aplicacion = new MouseAdapterTest(); ); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() main() }///:~
CLASE ImageIcon Java permite incorporar imágenes de tipo gif gif,, jpg jpg y png png definidas en archivos. Se
dispone para ello de la clase javax.swing.ImageIcon javax.swing.ImageIcon.. Algunos componentes Swing, como JLabel y JLabel y JButton JButton, , pueden decorados un icono al-- una imagenIcon de .tamaño fijo. En Swing, un icono es unserobjeto que con se adhiere interface Icon. Swing proporciona una implementación particularmente útil del interface Icon Icon..
import java.awt.*; import javax.swing.*; public class ImageIconTest { public static void main(String[] args) { main(String[] JFrame f=new JFrame();
); f.setTitle("ImageIconTest"); f.setTitle("ImageIconTest" f.setSize(250,100); f.getContentPane().setLayout( new FlowLayout()); JLabel etiqueta1=new JLabel(); PNG // soporta formatos GIF, JPG y PNG ImageIcon("save.gif" "save.gif")); )); etiqueta1.setIcon(new ImageIcon( JLabel etiqueta2=new JLabel(); etiqueta2.setIcon(new ImageIcon( ImageIcon("open.gif" "open.gif")); )); JButton boton1=new JButton( JButton("Copiar" "Copiar"); ); boton1.setIcon(new ImageIcon( ImageIcon("copy.gif" "copy.gif")); ));
JButton("Pegar" "Pegar"); ); JButton boton2=new JButton( boton2.setIcon(new ImageIcon( ImageIcon("paste.gif" "paste.gif")); )); f.getContentPane().add(etiqueta1); f.getContentPane().add(etiqueta2); f.getContentPane().add(boton1); f.getContentPane().add(boton2); f.setVisible(true); ); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); }// end main() main() }///:~
CLASE Graphics La clase Graphics: Sirve para dibujar (se suele u usar sar con los canvas). Todos los componentes AWT son dibujados en pantalla a través del método de la clase java.awt.Component java.awt.Component:: public void paint(Graphics g); La clase Graphics permite: Trabajar con primitivas gráficas: figuras, colores, textos, … Trabajar con imágenes: GIF y JPEG. que ue sea repint repintado ado mediante el el método: Un componente puede pedir q
public void repaint(); Dibujando figuras: Líneas: drawLine(). Rectángulos: drawRect(), fillRect(), clearRect(). Rectángulos 3D: draw3DRect(), fill3DRect(). Rectáng. redondeados: drawRoundRect(), fillRoundRect(). Óvalos: drawOval(), fillOval(). drawArc, rawArc, fifillArc(). llArc(). Arcos: d
Polígonos:
ddrawPolygon(), rawPolygon(), fil fillPolygon(). lPolygon().
Escribiendo texto: drawBytes(), drawChars(), drawString().
En esta parte final del AWT se van a describir, también muy sucintamente, algunas clases y métodos para realizar dibujos y añadir texto e imágenes a la interface gráfica Component de usuario. La clase tiene. Cuando tres métodos muy importantes relacionados gráficos: paint() , repaint() y update() el usuario llama al método repaint()con de un componente, el AWT llama al método update() de ese componente, que por defecto llama al método paint() . Método paint(Graphics g)
El método paint() está definido en la clase Component , pero ese método no hace nada y hay que redefinirlo en una de sus clases derivadas. El programador no tiene que preocuparse de llamar a este método: el sistema operativo lo llama al dibujar por primera vez una ventana, y luego lo vuelve a llamar cada vez que entiende que la ventana o una parte de la ventana debe ser redibujada (por ejemplo, por haber estado tapada por otra ventana y quedar que dar de nuevo a la vista). Método update(Graphics g)
El método update() hace dos cosas: primero re-dibuja la ventana con el color de fondo y luego llama al método paint() . Este método también es llamado por p or el AWT, y también puede ser llamado por el programador, quizás porque ha realizado algún cambio en la ventana y necesita que se dibuje de nuevo.
La propia estructura de este método -el comenzar pintando de nuevo con el color de fondohace que se produzca parpadeo (flicker ) en las animaciones. Una de las formas de evitar este efecto es redefinir este método de una forma diferente, cambiando de una imagen a otra sólo lo que haya que cambiar, en vez de re-dibujar todo otra vez desde el principio. Este método no siempre proporciona los resultados buscados y hay que recurrrir al método del doble buffer . Método repaint()
Este es el método que con más frecuencia es llamado por el programador. El método repaint() llama “lo antes posible” al método update() del componente. Se puede también especificar un número de milisegundos para que el método update() se llame transcurrido ese tiempo. El método repaint() tiene las cuatro formas siguientes: repaint() repaint(long time) repaint(int x, int y, int w, int h) repaint(long time, int x, int y, int w, int h)
Las formas tercera y cuarta permiten definir una zona rectangular de la ventana a la
que aplicar el método. El único argumento de los métodos update() y paint() es un objeto de esta clase. La clase Graphics dispone de métodos para soportar dos tipos de gráficos: 1. Dibujo de primitivas gráficas (texto , líneas , círculos , rectángulos , polígonos , …). 2. Presentación de imágenes en formatos *.gif y *.jpeg . Además, la clase Graphics mantiene un contexto gráfico : un área de dibujo actual, un color de dibujo del background y otro del foreground, un font con todas sus propiedades, etc. La siguiente Figura muestra el sistema de coordenadas utilizado en Java . Como es habitual en Informática, los ejes están situados en la esquina superior izquierda, con la orientación indicada en la Figura (eje de coordenadas descendente). Las coordenadas se miden siempre en pixels .
Ejemplo: g.fillRect(25,25,100,20);
Java dispone de métodos para realizar dibujos sencillos, llamados a veces “primitivas” gráficas. Como se ha dicho, las coordenadas se miden en pixels , empezando a contar
desde cero. La clase Graphics dispone de los métodos para primitivas gráficas reseñados en la siguiente Tabla. Excepto los polígonos y las líneas, todas las formas geométricas se determinan por el rectángulo que las comprende, cuyas dimensiones son w y h . Los polígonos admiten un argumento de la clase java.awt.Polygon .
La clase Graphics permite “dibujar” texto, como alternativa al texto mostrado en los componentes JLabel , JTextField y JTextArea . Los métodos de esta clase para dibujar texto son los siguientes: drawBytes(byte data[], int offset, int length, int x, int y);
drawChars(char data[], int offset, int length, int x, int y); drawString(String str, int x, int y); En estos métodos, los argumentos x e y representan las coordenadas de la línea base . import java.awt.*; import javax.swing.*; public class GraphicsTest1 extends JFrame { public GraphicsTest1()
{ super( "Uso de los colores" ); colores" );
setSize(400,130); setVisible(true); } // dibujar rectángulos y objetos String en distintos colores paint(Graphics g) paint(Graphics public void { // llamar al método paint de la superclase superclase super.paint( g );
// establecer nuevo color de dibujo utilizando enteros enteros g.setColor(new Color(255,0,0)); g.fillRect(25,25,100,20); //(columna,Renglón,ancho,alto); g.drawString("RGB g.drawString( " + g.getColor(),130,40); "RGB actual: " + //(String,columna,renglon) //(String,columna,renglon) // establecer nuevo color de dibujo utilizando valores float new Color(0.0f,1.0f,0.0f)); g.setColor( g.fillRect(25,50,100,20); "RGB actual: " + g.drawString("RGB g.drawString( " + g.getColor(),130,65);
estáticos // establecer nuevo color de dibujo utilizando objetos Color estáticos ); ; g.setColor(Color. BLUE ) g.fillRect(25,75,100,20); "RGB actual: " + g.drawString("RGB g.drawString( " + g.getColor(),130,90); individuales // mostrar valores RGB individuales Color color = Color.MAGENTA; g.setColor(color); g.fillRect(25,100,100,20); g.drawString("Valores g.drawString( " + color.getRed() + ", " + "Valores RGB: " + " + " + + color.getBlue(),130,115); color.getGreen() + ", " } // fin del método paint paint public static void main( String args[] ) main( {
GraphicsTest1 aplicacion = new GraphicsTest1(); ); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }// end main() main() }///:~
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class MouseAdapterTest2 MouseAdapterTest2 extends JFrame { xPos, yPos yPos; ; private int xPos,
//private JLabel etiqueta; etiqueta; public MouseAdapterTest2(){ ratón"); ); super("Clics y botones del ratón"
//Container contenedor= contenedor= getContentPane(); addMouseListener( new ManejadorClicsRaton()); //etiqueta = new JLabel(""); //etiqueta= //contenedor.add(etiqueta ); //contenedor.add(etiqueta);
setSize(450,150); setVisible(true); constructor }// fin del constructor // dibujar objeto String en la ubicación donde se hizo clic con el ratón ratón paint(Graphics g){ paint(Graphics public void // llamar al método paint de la superclase superclase super.paint(g); "Se hizo clic en: [" + xPos + ", " + " + yPos yPos + + "]", "]",xPos, xPos,yPos yPos); ); g.drawString("Se g.drawString( [" + xPos + } ratón // clase interna para manejar eventos de ratón private class ManejadorClicsRaton extends MouseAdapter { // manejar evento de clic del ratón y determinar cuál botón se oprimió oprimió mouseClicked(MouseEvent evento){ mouseClicked(MouseEvent public void xPos = xPos = evento.getX(); yPos = = evento.getY(); yPos String titulo = "Se hizo clic " " + + evento.getClickCount() + " Veces" Veces" ; ; //String titulo2 = "Se hizo clic en: [" + xPos + ", " + yPos + "]"; "]"; (evento.isMetaDown())// // botón derecho del ratón if (evento.isMetaDown()) titulo += " con el botón derecho del ratón" ratón"; ; (evento.isAltDown())// // botón de en medio del ratón ratón else if (evento.isAltDown()) titulo += " con el botón central del ratón" ratón"; ; else // botón izquierdo del ratón
titulo += " con el botón izquierdo del ratón" ratón"; ; //etiqueta.setText(titulo2); //etiqueta.setText(titulo2); ventana setTitle(titulo); // establecer barra de título de la ventana actual repaint(); //repinta el componente actual } // fin del método mouseClicked mouseClicked } // fin de la clase interna privada ManejadorClicsRaton ManejadorClicsRaton
main(String args[]) main(String public static void { MouseAdapterTest2 aplicacion = new MouseAdapterTest2(); ); ; aplicacion.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) main() }// end main() }///:~
Observar que cada vez que se dá clic en un a nueva posición del JFrame JFrame se se repinta el mensaje de las coordenadas.
import java.awt.*; import javax.swing.*; public class GraphicsTest2 extends JFrame{ public GraphicsTest2(){
setTitle( "GraphicsTest"); setTitle("GraphicsTest" ); //setBackground(Color.LIGHT_GRAY); setSize(300,150); setVisible( true); } paint(Graphics g) { paint(Graphics public void superclase // llamar al método paint de la superclase super.paint(g); //TODOS SOBRE EL RENGLON 35 g.setColor(Color. BLUE ) ); ; g.drawLine(15,35,65,65); g.drawRect(70,35,50,30); g.drawRoundRect(125,35,50,30,10,10); g.drawOval(180,35,50,30); g.drawArc(235,35,50,30,25,200);
int[] x = {15,65,15,65}; int[] y = {90,90,120,120};
//TODOS SOBRE EL RENGLON 90 length); ); g.drawPolygon(x,y,x.length g.drawPolygon(x,y,x. g.setColor(Color. RED); g.fillRect(70,90,50,30); g.fillRoundRect(125,90,50,30,10,10); g.fillOval(180,90,50,30); g.fillArc(235,90,50,30,25,200); ); ; g.setColor(Color. BLACK ) g.setFont( new Font( Font("SansSerif" "SansSerif",Font. ,Font.PLAIN ,9)); ,9)); //TODOS LOS MENSAJES EL RENGLON 80 g.drawString("Línea" g.drawString( "Línea",30,80); ,30,80); "Rectángulos",95,80); ,95,80); g.drawString("Rectángulos" g.drawString( g.drawString("Óvalo" g.drawString( "Óvalo",192,80); ,192,80); "Arco",250,80); ,250,80); g.drawString("Arco" g.drawString( //TODOS LOS MENSAJES EL RENGLON 135 "Polígono",22,135); ,22,135); g.drawString("Polígono" g.drawString( g.drawString("Rectángulos" g.drawString( "Rectángulos",95,135); ,95,135); "Óvalo",192,135); ,192,135); g.drawString("Óvalo" g.drawString( "Arco",250,135); ,250,135); g.drawString("Arco" g.drawString( }// end paint() paint() main(String[] args){ main(String[] public static void GraphicsTest2 aplicacion= new GraphicsTest2(); ); ; aplicacion.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) }// end main() main() }///:~
CONFIGURANDO EL "Look & Feel" DE DE UNA APLICACIÓN
Swing permite cambiar dinámicamente el aspecto y la forma de interacción de una aplicación, por ejemplo el siguiente código modifica mo difica el Look & Feel al estilo Java: J ava: visual // cambiar la apariencia visual try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel" "com.sun.java.swing.plaf.windows.WindowsLookAndFeel"); ); //UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel"); //UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel"); //UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel"); SwingUtilities.updateComponentTreeUI(f); } // procesar problemas al cambiar la apariencia visual visual catch ( Exception excepcion ) { excepcion.printStackTrace(); }
Existen los siguientes look look & feelLook & Feel: Java CDE/Motif look & feel look & feel Windows look UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.Windows LookAndFeel"); LookAndFeel" );
UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel ");
UIManager.setLookAndFeel ("com.sun.java.swing.plaf.motif.MotifLookAndFeel" "com.sun.java.swing.plaf.motif.MotifLookAndFeel"); );
import javax.swing.*; public class LookAndFeelJMenuBarTest { main(String[] args) { main(String[] public static void JFrame f=new JFrame();
f.setTitle("JMenuBarTest" f.setTitle( "JMenuBarTest"); ); f.setSize(250,150); visual // cambiar la apariencia visual try { "com.sun.java.swing.plaf.windows.WindowsLookAndFeel"); ); UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel"
//UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel"); //UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel"); } SwingUtilities. updateComponentTreeUI (f); // procesar problemas al cambiar la apariencia visual visual catch ( Exception excepcion ) { excepcion.printStackTrace(); } JMenuBar menuBar=new JMenuBar(); f.setJMenuBar(menuBar); //Sets the menuBar for this frame.
/*NOMBRE DE LOS MENUS*/ MENUS*/ menú // establecer menú Archivo y sus elementos de menú JMenu menu1=new JMenu( JMenu("Menu1" "Menu1"); ); menu1.setMnemonic('1' menu1.setMnemonic('1'); ); JMenu menu2=new JMenu( JMenu("Menu2" "Menu2"); ); menu2.setMnemonic('e' menu2.setMnemonic('e'); ); /*ELEMENTOS DEL MENU1*/ MENU1*/ JMenuItem menuItem1= new JMenuItem( JMenuItem("Opcion1" "Opcion1"); ); new JMenuItem("Opcion2" JMenuItem menuItem2= "Opcion2"); ); menu1 JMenuItem( //SE AGREGAN AL menu1 menu1.add(menuItem1); menu1.add(menuItem2);
MENU2*/ /*ELEMENTOS DEL MENU2*/ JCheckBoxMenuItem jcbmenuItem1= new JCheckBoxMenuItem( JCheckBoxMenuItem("Opcion1" "Opcion1"); ); JCheckBoxMenuItem("Opcion2" "Opcion2", ,true); JCheckBoxMenuItem jcbmenuItem2= new JCheckBoxMenuItem( JRadioButtonMenuItem jcbmenuItem3= new JRadioButtonMenuItem( JRadioButtonMenuItem("Opcion3" "Opcion3", ,true);
//SE AGREGAN AL menu2 menu2 menu2.add(jcbmenuItem1); menu2.add(jcbmenuItem2); menu2.addSeparator(); //Agrega un separador menu2.add(jcbmenuItem3); MENUBAR*/ /*MENU 1 Y MENU2 SE AGREGAN AL MENUBAR*/ menuBar.add(menu1); menuBar.add(menu2); f.setVisible( true); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) ); ; main() }//end main() }///:~ ///:~
import javax.swing.*; public class LookAndFeelJMenuBarTest2 { main(String[] args) { main(String[] public static void
visual // cambiar la apariencia visual try { //se debe de declarar antes de crear una instancia del contenedor JFrame.setDefaultLookAndFeelDecorated (true); } // procesar problemas al cambiar la apariencia visual visual catch ( Exception excepcion ) { excepcion.printStackTrace(); } JFrame f=new JFrame(); f.setTitle("JMenuBarTest" f.setTitle( "JMenuBarTest"); ); f.setSize(250,150); JMenuBar menuBar=new JMenuBar(); f.setJMenuBar(menuBar); //Sets the menuBar for this frame. /*NOMBRE DE LOS MENUS*/ MENUS*/ menú // establecer menú Archivo y sus elementos de menú
JMenu("Menu1" "Menu1"); ); menu1.setMnemonic( menu1.setMnemonic('1' '1'); ); JMenu menu1=new JMenu( JMenu("Menu2" "Menu2"); ); menu2.setMnemonic('e' menu2.setMnemonic('e'); ); JMenu menu2=new JMenu( MENU1*/ /*ELEMENTOS DEL MENU1*/ JMenuItem("Opcion1" "Opcion1"); ); JMenuItem menuItem1= new JMenuItem( JMenuItem("Opcion2" "Opcion2"); ); JMenuItem menuItem2= new JMenuItem( menu1 //SE AGREGAN AL menu1 menu1.add(menuItem1); menu1.add(menuItem2); /*ELEMENTOS DEL MENU2*/ MENU2*/ JCheckBoxMenuItem("Opcion1" "Opcion1"); ); JCheckBoxMenuItem jcbmenuItem1= new JCheckBoxMenuItem( JCheckBoxMenuItem jcbmenuItem2= new JCheckBoxMenuItem( JCheckBoxMenuItem("Opcion2" "Opcion2", ,true); JRadioButtonMenuItem("Opcion3" "Opcion3", ,true); JRadioButtonMenuItem jcbmenuItem3= new JRadioButtonMenuItem(
menu2 //SE AGREGAN AL menu2 menu2.add(jcbmenuItem1); menu2.add(jcbmenuItem2); menu2.addSeparator(); //Agrega un separador menu2.add(jcbmenuItem3); MENUBAR*/ /*MENU 1 Y MENU2 SE AGREGAN AL MENUBAR*/ menuBar.add(menu1); menuBar.add(menu2); f.setVisible( true); f.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ); main() }//end main() }///:~
import javax.swing.*; import java.awt.event.*; import java.awt.*; public class LookAndFeelJMenuBarTest3 extends JFrame
{ public LookAndFeelJMenuBarTest3()
{ 1"); ); super("Ejemplo 1" JButton("Mostrar "Mostrar dialogo" dialogo"); ); JButton boton = new JButton( boton.addActionListener( new ActionListener(){ actionPerformed(ActionEvent e){ actionPerformed(ActionEvent public void JOptionPane. showMessageDialog (null, "Y así- se ve un cuadro de dialogo de error", error" , "Mensaje" "Mensaje",JOptionPane. ,JOptionPane. ERROR_MESSAGE ) ); ; } }); getContentPane().add( new JLabel( JLabel("Asi "Asi se ve un Frame"), Frame"), BorderLayout. NORTH ) ); ; getContentPane().add(boton); setSize(200,80); setVisible(true); } main(String args[]) main(String public static void
{ JFrame.setDefaultLookAndFeelDecorated (true); JDialog.setDefaultLookAndFeelDecorated (true); LookAndFeelJMenuBarTest3 ventana = new LookAndFeelJMenuBarTest3(); ); ; ventana.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE ) }// end main() main() }///:~
APPLETS Un applet es un programa que se ejecuta mediante un navegador de Internet o con el programa herramienta del SDK appletviewer.exe . La clase Applet Applet y JApplet JApplet son contenedores visuales de estilo de los Frame Frame y Panel Panel o o los JFrame JFrame y JPanel JPanel.. Existen dos implementaciones: Awt Awt y y Swing Swing.. AWT: Se encuentra en el paquete java.applet.* AWT: java.applet.*,, por tanto, siempre que deseemos desarrollar un applet deberemos importar este paquete, se encuentra en el paquete java.applet.*.. Hereda de java.awt.Panel java.applet.* java.awt.Panel.. Se le aplican LayoutManagers y se le añaden componentes como ya hicierámos con los contenedores estándar AWT. Ocurre lo mismo con la gestión de eventos. Swing:: Se encuentra en el paquete javax.swing.* Swing javax.swing.*,, por tanto, siempre que deseemos desarrollar un applet deberemos importar este paquete. Hereda de java.applet.Applet java.applet.Applet.. Se le aplican LayoutManagers y se le añaden componentes como ya hicierámos con los contenedores estándar AWT. Ocurre lo mismo con la gestión de eventos.
Los applet tienen la ventaja de ejecutarse en Internet sobre el navegador en el equipo del cliente, pero los diseñadores de Java les colocaron algunas restricciones para evitar que estos dañen, roben información del sistema o inserten virus en las máquinas donde se ejecutan, entre ellas están: No pueden leer o escribir en el sistema de archivos desde un navegador. Solo tienen a acceso cceso al servidor definido dentro del applet en un programa que use
sockets. Impedimento para ejecutar progr programas amas en el cliente. cliente. Impedimento para cargar programas nativos incluidas las DLL.
Ciclo de vida de un applet A diferencia de las aplicaciones Java convencionales, los Applets no tienen un método: public static void main(String[] args) args) para ejecutarse. Por el contrario tiene cinco métodos que el usuario puede sobreescribir para darle la funcionalidad requerida. Estos métodos siguen un ciclo de vida que se explica en el diagrama de abajo, estos métodos son: public void init(); public void start(); public void paint(Graphics g); public void stop(); public void destroy();
public void init(): init(): Es el primer método que se ejecuta al cargar el applet y sólo se ejecuta una vez. Se debe utilizar para inicializar las variables. public void start(): start(): Se ejecuta después del init(). Permite reinicializar un applet después de que se haya parado, es decir, arranca el applet (reload, maximizar, etc…). El método start() start() se se ejecuta cada vez que se muestra en pantalla el documento HTML que contiene el applet. Se suele usar us ar para arrancar procesos. public void paint(Graphics g): g): Se ejecuta cada vez que se debe volver a pintar o escribir la salida de un applet, es decir, d ecir, se refresca el applet. public void stop():Se stop(): se utiliza ejecutapara cuando abandona página se HTML contiene el applet. pararelelnavegador applet; para volverlo laa iniciar llamaque el método start() start().. Se suele usar para parar procesos. public void destroy(): se destroy(): se ejecuta cuando el entorno determina que el applet debe ser borrado completamente de la memoria o cerrar el navegador web. El método stop() stop() siempre se ejecuta antes que el destroy. Solo se ejecuta una ve vezz en la vida del applet.
inic ial para ejecutar un applet es init() Ojo: En esta clase el método inicial Ojo: init() cuando se omite se usa el método start() start(),, si también se omite se usa el método paint() paint() (esto significa que no requiere de un método main() main()). ). En el ejemplo siguiente se muestra un applet llamado CicloVida CicloVida que despliega una serie de mensajes en la consola y en el visualizador del appletviewer, el cual demuestra el ciclo de vida del applet. Ejecutarlo con AppletViewer par aver los llamados a la consola de salida. Eclpise los ejecuta automáticamente con dicho ejecutable.
import java.awt.Graphics; import javax.swing.JApplet; public class AppletCicloVida AppletCicloVida extends JApplet { public AppletCicloVida(){ .println("El "El constructor se esta ejecutando...." ejecutando...."); ); System.out.println(
} /** /** Método Método init init del del applet. applet. Inicializa Inicializa el el applet. applet. */ */ public void init(){ init(){ System.out.println( .println("Este "Este es el método init().\n" init().\n"); ); } /** Método Método start. start. /**
Arranca Arranca o comienza comienza el el applet applet */ */
public void start(){ start(){ .println("Este "Este es el método start(). \n" \n"); ); System.out.println(
} /** Método /** Método paint. paint. Dibuja Dibuja o pinta pinta el el applet. applet. */ */ public void paint(Graphics g){ paint(Graphics "¡Hola , a todos mis pupilos!", g.drawString("¡Hola g.drawString( pupilos!" , 10,50); System.out.println( .println("El "El applet acaba de ser dibujado con paint() \n" \n"); ); }
/** Método /** Método stop. stop. Para Para el el applet. applet. */ */ stop(){ stop(){ public void System.out.println( .println("Este "Este es el método stop(), para el applet. \n" \n"); ); } /** Método Método destroy. destroy. Destructor Destructor del del applet. applet. */ */ /** destroy(){ destroy(){ public void .println("Este "Este es el método destroy(), destruye el applet.\n" applet.\n"); ); System.out.println( } }///:~ AppletCicloVida.html CHECA EL CICLO EL CICLO DE VIDA DEL APPLET CODE= = "AppletCicloVida.class" "AppletCicloVida.class" WIDTH="200" WIDTH="200" HEIGHT="150" HEIGHT="150"> >
View more...
Comments
