El documento describe las interfaces gráficas de usuario (GUI) en Java. Explica que las GUI ofrecen ventanas, botones y otros elementos visuales con los que los usuarios interactúan. La API de Java proporciona clases para crear GUI, incluyendo AWT y Swing. Swing reemplaza muchas clases AWT y proporciona nuevos componentes como árboles y tablas. Las aplicaciones GUI se construyen usando contenedores, componentes y manejadores de eventos.
Este documento presenta una introducción a las interfaces gráficas de usuario (GUIs) en Java. Explica los diferentes tipos de aplicaciones Java, las bibliotecas GUI principales como AWT y Swing, y los conceptos básicos para crear GUIs como componentes, contenedores, layouts y manejo de eventos. También incluye información sobre la jerarquía de clases Swing y pasos para construir una interfaz.
Este documento describe los conceptos básicos de la programación GUI en Java, incluyendo la librería Swing, la programación basada en eventos, la generación y manejo de eventos, los componentes atómicos y contenedores, y los layout managers. Explica que los programas GUI en Java son impulsados por eventos, donde las acciones del usuario generan eventos que el código del programa maneja para actualizar la interfaz.
This document discusses Java GUI interfaces created with JFC/Swing. It introduces key concepts like components, containers, and layout managers. It provides examples of creating buttons and handling click events. It also explains how containers group components and layout managers determine their positioning and sizing.
El documento describe las Java Foundation Classes (JFC) y Swing, que proporcionan una interfaz gráfica de usuario mejorada para aplicaciones Java. Se explica que Swing es un conjunto de nuevos componentes visuales que reemplazan a los componentes AWT originales, y que ofrecen características adicionales como soporte para diferentes estilos visuales y accesibilidad. Además, se detallan varios componentes Swing comunes como JButton, JTextField y JTable.
Este documento describe los conceptos básicos de la programación GUI en Java utilizando Swing. Explica que los programas GUI en Java son impulsados por eventos, donde las acciones del usuario generan eventos que invocan el código del programa. También describe la jerarquía de herencia y contenedores de Swing, los tipos básicos de componentes como botones y menús, y cómo crear una simple aplicación Swing "Hola Mundo".
Swing es una biblioteca gráfica para Java que incluye widgets como cajas de texto, botones y tablas. Tiene su origen en las Internet Foundation Classes desarrolladas por Netscape en 1996 y posteriormente fue adoptada por Sun Microsystems. Swing sigue una arquitectura MVC independiente de plataformas y permite personalizar la apariencia a través de diferentes "look and feel". El documento incluye un ejercicio sobre el uso de cuadros combinados en Swing.
Este documento describe los componentes básicos de Java como botones y cómo implementarlos. Explica que los botones permiten a los usuarios iniciar acciones y se soportan en la clase Button. También cubre cómo gestionar eventos de botón usando la interfaz ActionListener y sus métodos. Finalmente, muestra ejemplos de cómo determinar qué botón se presionó.
El documento habla sobre interfaces de usuario en Android. Explica cómo crear una aplicación llamada Yamba que permita publicar mensajes en Twitter. Detalla los pasos para agregar widgets básicos como TextView, EditText y Button y cómo implementar funcionalidad al hacer clic en los botones. También cubre temas como layouts, trazas y depuración.
Este documento presenta una introducción a las interfaces gráficas de usuario (GUIs) en Java. Explica los diferentes tipos de aplicaciones Java, las bibliotecas GUI principales como AWT y Swing, y los conceptos básicos para crear GUIs como componentes, contenedores, layouts y manejo de eventos. También incluye información sobre la jerarquía de clases Swing y pasos para construir una interfaz.
Este documento describe los conceptos básicos de la programación GUI en Java, incluyendo la librería Swing, la programación basada en eventos, la generación y manejo de eventos, los componentes atómicos y contenedores, y los layout managers. Explica que los programas GUI en Java son impulsados por eventos, donde las acciones del usuario generan eventos que el código del programa maneja para actualizar la interfaz.
This document discusses Java GUI interfaces created with JFC/Swing. It introduces key concepts like components, containers, and layout managers. It provides examples of creating buttons and handling click events. It also explains how containers group components and layout managers determine their positioning and sizing.
El documento describe las Java Foundation Classes (JFC) y Swing, que proporcionan una interfaz gráfica de usuario mejorada para aplicaciones Java. Se explica que Swing es un conjunto de nuevos componentes visuales que reemplazan a los componentes AWT originales, y que ofrecen características adicionales como soporte para diferentes estilos visuales y accesibilidad. Además, se detallan varios componentes Swing comunes como JButton, JTextField y JTable.
Este documento describe los conceptos básicos de la programación GUI en Java utilizando Swing. Explica que los programas GUI en Java son impulsados por eventos, donde las acciones del usuario generan eventos que invocan el código del programa. También describe la jerarquía de herencia y contenedores de Swing, los tipos básicos de componentes como botones y menús, y cómo crear una simple aplicación Swing "Hola Mundo".
Swing es una biblioteca gráfica para Java que incluye widgets como cajas de texto, botones y tablas. Tiene su origen en las Internet Foundation Classes desarrolladas por Netscape en 1996 y posteriormente fue adoptada por Sun Microsystems. Swing sigue una arquitectura MVC independiente de plataformas y permite personalizar la apariencia a través de diferentes "look and feel". El documento incluye un ejercicio sobre el uso de cuadros combinados en Swing.
Este documento describe los componentes básicos de Java como botones y cómo implementarlos. Explica que los botones permiten a los usuarios iniciar acciones y se soportan en la clase Button. También cubre cómo gestionar eventos de botón usando la interfaz ActionListener y sus métodos. Finalmente, muestra ejemplos de cómo determinar qué botón se presionó.
El documento habla sobre interfaces de usuario en Android. Explica cómo crear una aplicación llamada Yamba que permita publicar mensajes en Twitter. Detalla los pasos para agregar widgets básicos como TextView, EditText y Button y cómo implementar funcionalidad al hacer clic en los botones. También cubre temas como layouts, trazas y depuración.
Este documento describe los elementos básicos de Swing, la biblioteca de interfaces gráficas de usuario de Java. Explica que Swing mejora AWT y que sus componentes comienzan con "J". Detalla los objetivos principales de Swing como familiarizarse con sus componentes y eventos. También resume los paquetes y clases más importantes de Swing como JFrame, menús y componentes.
Este documento proporciona una introducción a Swing y sus componentes. Explica qué es Swing y cómo se relaciona con JFC, las versiones que contienen el API Swing, y los paquetes Swing más comunes. También describe brevemente las diferencias entre los componentes Swing y AWT. Finalmente, incluye ejemplos de código de una aplicación Swing sencilla para ilustrar sus características.
Este documento proporciona una introducción a los componentes gráficos de usuario (GUI) en Java, incluidos contenedores, componentes atómicos, componentes de texto, menús y componentes complejos. Explica cómo crear y personalizar interfaces gráficas mediante el uso de estas clases de GUI de Java como JFrame, JButton, JTextField, JMenuBar y JTable.
Diseño y validacion GUI con java usando NetbeansEmerson Garay
Guía básica para empezar a diseñar una Interfaz Gráfica de Usuario (IGU) y la validación de los datos ingresados por el usuario, por medio del Lenguaje de programación Java y utilizando el IDE NetBeans.
Este documento describe los elementos básicos de las interfaces gráficas de usuario (GUI) en Java, incluidos AWT y Swing. Explica que AWT proporciona clases básicas para crear GUI, como botones y ventanas, mientras que Swing es una biblioteca gráfica más avanzada. También enumera varias clases comunes de Swing como JFrame, JButton, JCheckBox y JList y describe sus funciones.
Este documento describe los principales componentes de la clase Abstract Window Toolkit (AWT) de Java. Explica la jerarquía de la clase Component y describe varios tipos de componentes como labels, botones, choice, list, text fields y text areas. También cubre los diferentes tipos de layout managers como FlowLayout, BorderLayout, GridLayout y CardLayout y cómo estos administran el diseño y posicionamiento de los componentes.
El documento describe los conceptos básicos de la programación GUI en Java, incluyendo la librería Swing, la programación impulsada por eventos, la generación y manejo de eventos, y los componentes y contenedores principales de Swing como JFrame y JPanel.
Swing es la evolución de AWT, que permitía crear interfaces gráficas pero tenía problemas de portabilidad entre sistemas operativos. Swing mejoró la portabilidad y el comportamiento de los componentes gráficos. Los componentes Swing heredan del paquete javax.swing, mientras que en AWT no anteponen la letra J. Swing requiere un contenedor como base para la aplicación donde agregar otros componentes.
Este documento presenta una introducción a la librería AWT de Java. Explica que AWT proporciona clases para crear interfaces gráficas independientes de la plataforma. Describe los componentes básicos como botones, etiquetas y cuadros de texto, y los contenedores como marcos y paneles. También cubre temas como la jerarquía de clases, la gestión de posicionamiento y los pasos para crear un componente. Finalmente, incluye ejemplos de uso de varios componentes AWT.
El documento describe los Applets de Java, programas con interfaz gráfica que se ejecutan en un navegador web. Explica cómo crear un Applet usando las clases Applet y Graphics, y cómo incluirlo en una página HTML. También explica el ciclo de vida de un Applet, incluyendo los métodos init(), start(), stop() y destroy().
Unidad 3 topicos avanzados de programacionIrving Che
Este documento describe los componentes, librerías y paquetes en programación. Explica que un componente puede ser visual o no visual, y que los componentes se agrupan en contenedores. También describe el uso de librerías como java.lang y java.io, y cómo los usuarios pueden crear sus propios componentes y paquetes.
Este documento proporciona una guía sobre cómo crear una aplicación Android básica. Explica las partes clave de un proyecto Android como el archivo AndroidManifest.xml, activities, layouts y recursos. También cubre cómo programar la lógica de la aplicación en Java y manejar múltiples pantallas. Finalmente, brinda información sobre cómo publicar la aplicación en la Google Play Store.
El documento describe el desarrollo de una aplicación de cajero automático en Eclipse usando formularios. El objetivo era aplicar conocimientos sobre formularios en Eclipse. Se creó un proyecto en Eclipse con dos formularios, uno para inicio de sesión y otro para simular las funciones de un cajero. El formulario de inicio de sesión incluye campos para usuario y contraseña. El formulario del cajero permite depósitos, retiros y muestra el saldo actual.
Este documento describe las características y componentes de Swing y JFC. Explica cómo crear programas Swing, compilarlos y ejecutarlos. También detalla cómo usar varios componentes Swing como botones, etiquetas, cuadros de lista y tablas. Además, explica conceptos como el manejo de eventos, los hilos y los controladores de distribución en Swing.
Este documento describe las diferentes partes y herramientas de la interfaz de desarrollador integrado (IDE) Eclipse, incluyendo la administración de archivos y proyectos, la edición y depuración de código, la búsqueda de elementos, y las vistas como Navegador y Explorador de paquetes. Explica cómo crear y configurar proyectos de Java en Eclipse para desarrollar aplicaciones móviles.
Este documento describe la arquitectura de las aplicaciones en Android. Explica los principales componentes de una aplicación como Activities, Broadcast Receivers, Content Providers y Services. Detalla cómo se comunican estos componentes utilizando Intents y cómo se declaran en el manifiesto de la aplicación.
Este documento explica cómo instalar el plugin EclipseME en Eclipse para desarrollar aplicaciones Java ME. Describe los pasos para instalar EclipseME, configurarlo para conectarlo al WTK, crear un proyecto MIDlet simple llamado "Hola Mundo", y ejecutarlo en el emulador. El documento guía al lector a través del proceso completo de configuración de EclipseME y creación de un primer proyecto MIDlet.
Llamamos Interfaz Gráfica GUI (Graphical User Interface) al conjunto de componentes gráficos que posibilitan la interacción entre el usuario y la aplicación. Es decir ventnas, botones, combos, listas, cajas de diálogo, campos de texto, etc.
Primero tenemos que diseñar la aplicación, programarla y por último los eventos que se generan a medida que el usuario interactúa con la Interfaz.
Los componentes son objetos de las clases que heredan de la clase base componente como Button, List, TextField, TextArea, Label, etc.
Este documento describe bibliotecas y herramientas para crear interfaces gráficas de usuario en Java, incluyendo Abstract Windowing Toolkit (AWT), Swing, Standard Widget Toolkit (SWT), JavaFX y XML User Interface Language (XUL). También describe herramientas WYSIWYG como NetBeans Swing GUI Builder y Eclipse WindowBuilder para crear GUIs sin código. Explica conceptos básicos como contenedores, componentes y gestores de disposición para componer interfaces gráficas.
Este documento describe los elementos básicos de Swing, la biblioteca de interfaces gráficas de usuario de Java. Explica que Swing mejora AWT y que sus componentes comienzan con "J". Detalla los objetivos principales de Swing como familiarizarse con sus componentes y eventos. También resume los paquetes y clases más importantes de Swing como JFrame, menús y componentes.
Este documento proporciona una introducción a Swing y sus componentes. Explica qué es Swing y cómo se relaciona con JFC, las versiones que contienen el API Swing, y los paquetes Swing más comunes. También describe brevemente las diferencias entre los componentes Swing y AWT. Finalmente, incluye ejemplos de código de una aplicación Swing sencilla para ilustrar sus características.
Este documento proporciona una introducción a los componentes gráficos de usuario (GUI) en Java, incluidos contenedores, componentes atómicos, componentes de texto, menús y componentes complejos. Explica cómo crear y personalizar interfaces gráficas mediante el uso de estas clases de GUI de Java como JFrame, JButton, JTextField, JMenuBar y JTable.
Diseño y validacion GUI con java usando NetbeansEmerson Garay
Guía básica para empezar a diseñar una Interfaz Gráfica de Usuario (IGU) y la validación de los datos ingresados por el usuario, por medio del Lenguaje de programación Java y utilizando el IDE NetBeans.
Este documento describe los elementos básicos de las interfaces gráficas de usuario (GUI) en Java, incluidos AWT y Swing. Explica que AWT proporciona clases básicas para crear GUI, como botones y ventanas, mientras que Swing es una biblioteca gráfica más avanzada. También enumera varias clases comunes de Swing como JFrame, JButton, JCheckBox y JList y describe sus funciones.
Este documento describe los principales componentes de la clase Abstract Window Toolkit (AWT) de Java. Explica la jerarquía de la clase Component y describe varios tipos de componentes como labels, botones, choice, list, text fields y text areas. También cubre los diferentes tipos de layout managers como FlowLayout, BorderLayout, GridLayout y CardLayout y cómo estos administran el diseño y posicionamiento de los componentes.
El documento describe los conceptos básicos de la programación GUI en Java, incluyendo la librería Swing, la programación impulsada por eventos, la generación y manejo de eventos, y los componentes y contenedores principales de Swing como JFrame y JPanel.
Swing es la evolución de AWT, que permitía crear interfaces gráficas pero tenía problemas de portabilidad entre sistemas operativos. Swing mejoró la portabilidad y el comportamiento de los componentes gráficos. Los componentes Swing heredan del paquete javax.swing, mientras que en AWT no anteponen la letra J. Swing requiere un contenedor como base para la aplicación donde agregar otros componentes.
Este documento presenta una introducción a la librería AWT de Java. Explica que AWT proporciona clases para crear interfaces gráficas independientes de la plataforma. Describe los componentes básicos como botones, etiquetas y cuadros de texto, y los contenedores como marcos y paneles. También cubre temas como la jerarquía de clases, la gestión de posicionamiento y los pasos para crear un componente. Finalmente, incluye ejemplos de uso de varios componentes AWT.
El documento describe los Applets de Java, programas con interfaz gráfica que se ejecutan en un navegador web. Explica cómo crear un Applet usando las clases Applet y Graphics, y cómo incluirlo en una página HTML. También explica el ciclo de vida de un Applet, incluyendo los métodos init(), start(), stop() y destroy().
Unidad 3 topicos avanzados de programacionIrving Che
Este documento describe los componentes, librerías y paquetes en programación. Explica que un componente puede ser visual o no visual, y que los componentes se agrupan en contenedores. También describe el uso de librerías como java.lang y java.io, y cómo los usuarios pueden crear sus propios componentes y paquetes.
Este documento proporciona una guía sobre cómo crear una aplicación Android básica. Explica las partes clave de un proyecto Android como el archivo AndroidManifest.xml, activities, layouts y recursos. También cubre cómo programar la lógica de la aplicación en Java y manejar múltiples pantallas. Finalmente, brinda información sobre cómo publicar la aplicación en la Google Play Store.
El documento describe el desarrollo de una aplicación de cajero automático en Eclipse usando formularios. El objetivo era aplicar conocimientos sobre formularios en Eclipse. Se creó un proyecto en Eclipse con dos formularios, uno para inicio de sesión y otro para simular las funciones de un cajero. El formulario de inicio de sesión incluye campos para usuario y contraseña. El formulario del cajero permite depósitos, retiros y muestra el saldo actual.
Este documento describe las características y componentes de Swing y JFC. Explica cómo crear programas Swing, compilarlos y ejecutarlos. También detalla cómo usar varios componentes Swing como botones, etiquetas, cuadros de lista y tablas. Además, explica conceptos como el manejo de eventos, los hilos y los controladores de distribución en Swing.
Este documento describe las diferentes partes y herramientas de la interfaz de desarrollador integrado (IDE) Eclipse, incluyendo la administración de archivos y proyectos, la edición y depuración de código, la búsqueda de elementos, y las vistas como Navegador y Explorador de paquetes. Explica cómo crear y configurar proyectos de Java en Eclipse para desarrollar aplicaciones móviles.
Este documento describe la arquitectura de las aplicaciones en Android. Explica los principales componentes de una aplicación como Activities, Broadcast Receivers, Content Providers y Services. Detalla cómo se comunican estos componentes utilizando Intents y cómo se declaran en el manifiesto de la aplicación.
Este documento explica cómo instalar el plugin EclipseME en Eclipse para desarrollar aplicaciones Java ME. Describe los pasos para instalar EclipseME, configurarlo para conectarlo al WTK, crear un proyecto MIDlet simple llamado "Hola Mundo", y ejecutarlo en el emulador. El documento guía al lector a través del proceso completo de configuración de EclipseME y creación de un primer proyecto MIDlet.
Llamamos Interfaz Gráfica GUI (Graphical User Interface) al conjunto de componentes gráficos que posibilitan la interacción entre el usuario y la aplicación. Es decir ventnas, botones, combos, listas, cajas de diálogo, campos de texto, etc.
Primero tenemos que diseñar la aplicación, programarla y por último los eventos que se generan a medida que el usuario interactúa con la Interfaz.
Los componentes son objetos de las clases que heredan de la clase base componente como Button, List, TextField, TextArea, Label, etc.
Este documento describe bibliotecas y herramientas para crear interfaces gráficas de usuario en Java, incluyendo Abstract Windowing Toolkit (AWT), Swing, Standard Widget Toolkit (SWT), JavaFX y XML User Interface Language (XUL). También describe herramientas WYSIWYG como NetBeans Swing GUI Builder y Eclipse WindowBuilder para crear GUIs sin código. Explica conceptos básicos como contenedores, componentes y gestores de disposición para componer interfaces gráficas.
Este documento describe las interfaces gráficas de usuario (GUI) en Java utilizando las clases AWT y Swing. Explica los componentes básicos de AWT como Frame, Panel y Graphics y los gestores de layout como FlowLayout y BorderLayout. También cubre los componentes GUI básicos de Swing como JButton, JCheckBox y JComboBox. El objetivo es escribir programas con interfaces de usuario elaboradas utilizando estas clases.
Este documento describe conceptos básicos sobre interfaces gráficas en Java, incluyendo cómo crear ventanas, paneles y añadir elementos como etiquetas y botones. También explica el uso de layouts para organizar los elementos y la gestión de eventos mediante escuchadores como ActionListener y WindowListener.
Interfaz gráfica de usuario y eventos (introducción)Omar B.
Este documento describe los conceptos básicos de las interfaces gráficas de usuario y los eventos en Java. Explica las librerías AWT y Swing que permiten crear interfaces gráficas y sus principales clases como contenedores, componentes y auxiliares. También introduce la programación dirigida por eventos donde la ejecución del programa depende de los eventos generados por el usuario.
Este documento describe los conceptos básicos de las interfaces gráficas de usuario (GUI) en Java. Explica que las aplicaciones GUI en Java se basan en eventos, donde los eventos del sistema controlan el flujo de ejecución en lugar del programa. También introduce las librerías Swing y AWT de Java para crear GUIs, y describe los conceptos clave como componentes, contenedores, manejo de eventos y jerarquías de herencia y contenedores.
Este documento habla sobre Swing, un toolkit para Java que provee componentes para crear interfaces gráficas de usuario. Explica que Swing ofrece ventajas como menos limitaciones de plataforma y componentes más avanzados. Luego describe controles básicos como JLabel para etiquetas, JTextField para cuadros de texto, y JButton para botones. Finalmente concluye que Swing permite crear vistas interactivas y manejar eventos de los componentes.
El documento describe las interfaces gráficas de usuario en Java. Explica que Java incluye componentes para crear interfaces gráficas portables como AWT y Swing. AWT depende de cada sistema operativo mientras que Swing es independiente de la plataforma. También describe cómo crear ventanas (frames) y manejar eventos como el cierre de una ventana para que la aplicación termine correctamente.
Cursos gratis de programación en Java. Swing y JavaFX. Orientado a Grado, DAM y DAW. Otros cursos disponibles para Android, Swift, Base de datos, javascript, servicios y procesos...
Este documento describe los componentes Swing para interfaces de usuario en Java, incluyendo menús, botones de opción, eventos de pintado y más. Explica cómo crear y manipular estos componentes, así como conceptos fundamentales como jerarquías de clases, eventos y patrones de diseño comunes.
Este documento describe los conceptos básicos de las interfaces gráficas de usuario, incluyendo sus componentes y paquetes en Java. Explica cómo crear una interfaz gráfica en NetBeans usando contenedores, componentes y manejadores de diseño de Swing. También resume los diferentes tipos de interfaces gráficas como las basadas en touchscreen y las interfaces naturales de usuario.
Este documento describe los componentes JButton, JCheckBox y JRadioButton de Swing en Java. Explica que estos son algunos de los componentes más importantes y comúnmente usados en aplicaciones modernas. También discute la evolución de las interfaces gráficas de usuario en Java, incluyendo AWT y Swing, y las ventajas de Swing sobre AWT.
Este documento presenta una introducción a las interfaces gráficas de usuario (GUI) en Java. Explica que una GUI es un puente entre el usuario y la máquina que permite la interacción mediante objetos y imágenes gráficas. Luego describe los principales componentes de una GUI en Java como contenedores, controles de entrada/salida, botones y elementos de organización. Finalmente, muestra un ejemplo paso a paso de cómo crear una GUI básica en Java para recolectar información personal.
Este documento describe los componentes JButton, JCheckBox y JRadioButton que forman parte de Swing en Java. Explica que Swing mejoró sobre AWT al proporcionar componentes más flexibles y con un diseño orientado a componentes. Luego describe las características y métodos de cada clase de componente junto con ejemplos de su uso.
Este documento presenta una introducción a las interfaces gráficas de usuario (GUIs) en Java usando Swing. Explica los conceptos básicos como componentes, contenedores, layouts, y eventos. También describe las principales clases de Swing como JFrame, JButton, y JPanel y cómo organizar los componentes en una jerarquía anidada para crear una interfaz gráfica.
Objetivo: Utilizar componentes gráficos, eventos, manejadores de eventos y animaciones sencillas, a través de librerías gráficas e hilos con el fin de permitir la interacción del usuario con la aplicación y comprender el procesamiento en paralelo.
Este documento presenta una introducción a las interfaces gráficas de usuario (GUIs) en Java utilizando Swing. Explica los tipos de aplicaciones Java, las bibliotecas GUI principales como AWT y Swing, y proporciona ejemplos básicos de cómo crear ventanas, agregar componentes y manejar eventos en Swing.
La biblioteca Swing fue desarrollada para mejorar la portabilidad de las interfaces gráficas de usuario en Java. Surge de la combinación de las Internet Foundation Classes con otras tecnologías para componentes gráficos. A diferencia de AWT que usa componentes nativos, Swing usa componentes desarrollados completamente en Java lo que asegura un comportamiento independiente de la plataforma.
Swing es un framework para desarrollar interfaces gráficas en Java que provee componentes como botones y tablas. Usa el patrón Modelo-Vista-Controlador para lograr independencia de plataforma y permite personalizar la apariencia de los componentes. Swing evolucionó a partir de las Internet Foundation Classes desarrolladas originalmente por Netscape para proveer una biblioteca gráfica más completa y compatible con diferentes estilos visuales.
Este documento trata sobre interfaces gráficas de usuario. Explica las librerías de interfaz gráfica y cómo crear aplicaciones GUI. También cubre conceptos de computación gráfica como áreas de dibujo y primitivas de dibujo como líneas y arcos.
El documento habla sobre herencia y polimorfismo en programación orientada a objetos en Java. Explica que la herencia permite que una clase herede atributos y métodos de otra clase y extienda su funcionalidad. También cubre clases abstractas, interfaces, y cómo el polimorfismo permite tratar objetos de subclases como si fueran de la clase base.
Este documento proporciona una introducción al desarrollo de componentes EJB. Explica que los EJBs son componentes distribuidos que permiten separar la lógica de negocio de los servicios proporcionados por el contenedor, como comunicaciones en red, transacciones y persistencia. También describe los tres tipos principales de EJBs, el proceso de creación de un EJB que incluye interfaces home y remotas y la clase bean, y cómo empaquetar y desplegar un EJB en un contenedor.
Tema 16 acceso a base de datos usando jpa por gioRobert Wolf
1) El documento describe el acceso a bases de datos usando JPA, una capa de software que reduce la tarea de conversión entre objetos y datos relacionales. 2) JPA mapea objetos a tablas mediante anotaciones y permite operaciones CRUD. 3) Se explican diferentes tipos de mapeo como uno a uno, muchos a uno, herencia y entidades.
Tema 15 aplicaciones de dos capas por gioRobert Wolf
Una aplicación de dos capas separa el código de la aplicación del sistema de administración de la base de datos. En una aplicación de dos capas, el cliente contiene la interfaz de usuario y lógica del negocio, mientras que el servidor contiene un administrador de bases de datos. La API JDBC de Java proporciona una forma estándar para que un cliente Java se comunique con diferentes administradores de bases de datos a través de un protocolo.
El documento describe cómo se representan y manipulan las imágenes en Java. Las imágenes se representan mediante las clases Image y BufferedImage, donde BufferedImage permite acceder directamente a los datos de los pixeles. Un objeto BufferedImage contiene un ColorModel que interpreta los colores de los pixeles y un Raster que almacena y organiza los datos de los pixeles. Las imágenes se pueden crear, dibujar, recortar y guardar usando métodos de estas clases.
Este documento describe la API de Java para gráficas. Explica que la clase Graphics2D es la clase central de la API 2D de Java y se encarga de representar figuras, texto e imágenes en dispositivos de salida. También describe los pasos involucrados en el proceso de presentación gráfica, incluyendo la transformación, entramado y composición de elementos gráficos.
El documento describe las diferencias entre procesos y hilos en la programación concurrente. Un proceso tiene sus propios recursos privados como memoria, mientras que los hilos comparten los recursos de un proceso. En Java, la programación concurrente se basa principalmente en hilos. La clase Thread permite crear nuevos hilos que ejecutan el método run() de forma concurrente al hilo principal. También es posible implementar la interfaz Runnable para crear hilos sin heredar de Thread.
Tema 11 expresiones regulares en java por gioRobert Wolf
Una expresión regular es un patrón que define un conjunto de cadenas y se puede usar para comparar y reemplazar texto. Las expresiones regulares incluyen caracteres, clases de caracteres, cuantificadores, metacaracteres y operadores lógicos que permiten crear patrones complejos. Las expresiones regulares se usan comúnmente para analizar datos como archivos, cadenas de entrada y formularios.
Las clases abstractas y las interfaces en Java sirven para definir comportamientos comunes en clases sin proporcionar una implementación completa. Las clases abstractas pueden contener métodos abstractos y métodos concretos, mientras que las interfaces sólo contienen métodos abstractos. Las subclases de una clase abstracta deben implementar los métodos abstractos, mientras que las clases que implementan una interfaz deben implementar todos sus métodos.
El documento describe los sistemas de archivos y la clase File en Java. Un sistema de archivos organiza los datos de una forma eficiente y está adaptado a las características del dispositivo de almacenamiento. La clase File proporciona una abstracción de los nombres de archivo y rutas que oculta las diferencias entre sistemas operativos al programador.
El documento describe las pruebas unitarias en Java. Explica que es responsabilidad del programador probar su código para asegurarse de que funcione correctamente. También describe cómo se pueden realizar pruebas manuales creando clases de prueba que ejecuten los métodos con diferentes valores de entrada y validen los resultados. Finalmente, introduce el marco JUnit, el cual automatiza el proceso de pruebas a través de anotaciones que indican qué métodos son pruebas y validan sus resultados.
Tema 9 aplicaciones de dos capas por gioRobert Wolf
Una aplicación de dos capas separa el código de la aplicación del sistema de administración de la base de datos. En Java, la API JDBC proporciona una interfaz estándar para que un cliente escrito en Java se comunique con administradores de bases de datos. La API JDBC consta de interfaces y clases que representan conexiones, sentencias SQL y resultados de consultas. Las aplicaciones de dos capas encapsulan esta funcionalidad en clases como Conexión y Tabla para establecer conexiones y ejecutar operaciones SQL de forma sencilla.
El documento describe los conceptos de archivos y flujos en Java. Explica que los archivos permiten almacenar datos de forma persistente en dispositivos de memoria secundaria y que los flujos proveen una interfaz común para acceder a archivos independientemente de su tipo. También describe las clases principales en Java para trabajar con archivos de caracteres de acceso secuencial como Reader, Appendable y las interfaces relacionadas.
Tema 8 desarrollo de aplicaciones en java por gioRobert Wolf
Este documento describe el desarrollo de una aplicación en Java utilizando diagramas de clases y secuencia. Explica cómo un diagrama de secuencia representa la interacción entre los componentes de una aplicación para lograr un caso de uso. Luego presenta un ejemplo de una aplicación de música que permite agregar canciones, mostrando el diagrama de secuencia y código Java correspondiente a este caso de uso.
1) El documento describe los componentes y conceptos clave para crear interfaces gráficas de usuario en Java como contenedores, manejadores de diseño, componentes activos y de texto, y programación por eventos. 2) También presenta un ejemplo de interfaz gráfica para una aplicación de música que ilustra el uso de estos conceptos. 3) La interfaz incluye ventanas, cuadros de diálogo, tablas, menús y captura de datos para administrar un catálogo de canciones.
Tema 7 desarrollo de aplicaciones en java - lsia por gioRobert Wolf
Este documento describe el desarrollo de aplicaciones en Java utilizando diagramas de secuencia. Explica cómo los diagramas de secuencia describen el orden en que ocurren las invocaciones de métodos entre objetos para implementar casos de uso. Luego presenta un ejemplo de una aplicación de música que permite agregar y actualizar canciones, mostrando el código Java que implementa estos casos de uso siguiendo el diagrama de secuencia correspondiente. Finalmente, describe las clases principales como Control, Conversiones y Tabla que interactúan para llevar a cabo las funcional
1) El documento describe los componentes principales de Java para crear interfaces gráficas de usuario, incluyendo contenedores, manejadores de diseño y componentes. 2) Explica el modelo de programación por eventos en Java y cómo los componentes generan y manejan eventos. 3) Proporciona un ejemplo de interfaz gráfica para una aplicación de música que ilustra el uso de estos componentes.
El documento describe las colecciones en Java. Explica que una colección agrupa múltiples elementos y que Java proporciona un marco de colecciones con interfaces y clases para representar y manipular colecciones de manera genérica. Describe los métodos principales de la interfaz Collection para agregar, remover y consultar elementos, y explica cómo recorrer colecciones usando iteradores o ciclos foreach. También define listas como colecciones ordenadas que permiten acceder a elementos por su índice.
El documento describe los arreglos y cadenas en Java. Explica que un arreglo es una lista de variables del mismo tipo almacenadas en memoria contigua, y cada elemento puede accederse por su posición. Describe arreglos unidimensionales, bidimensionales y tridimensionales, y cómo declarar, crear, inicializar y acceder a los elementos de un arreglo unidimensional. También cubre el uso de arreglos con métodos y el ciclo for-each.
Tema 5 arreglos y cadenas - lsia por gioRobert Wolf
Este documento describe los arreglos y cadenas en Java. Explica que un arreglo es una lista de variables del mismo tipo almacenadas en memoria contigua, y cada elemento puede accederse por su posición. Detalla los tipos de arreglos como unidimensionales, bidimensionales y tridimensionales. Luego profundiza en los arreglos unidimensionales, incluyendo cómo declararlos, crearlos, inicializarlos, acceder a sus elementos, y usarlos con métodos. Finalmente, presenta un ejemplo de clases para almacenar datos de música y pel
1. Interfaces gráficas
de usuario
P.O.O — Tema 6 — Interfaces gráficas de usuario
Carlos Cervigón
P.O.O Tema 6 – Interfaces gráficas de usuario - 1
Las interfaces gráficas de usuario
Hasta ahora hemos desarrollado programas que usan la consola
para interactuar con el usuario.
Esa forma de interfaz de usuario es muy simple y nos ha
permitido centrarnos en todo aquello que tiene que ver tan sólo
con la programación orientada a objetos con el lenguaje Java, sin
tener que tratar al mismo tiempo con ventanas, botones y otros
elementos similares.
Las interfaces gráficas de usuario (GUI) ofrecen al usuario
ventanas, cuadros de diálogo, barras de herramientas, botones,
listas desplegables y muchos otros elementos con los que ya
estamos muy acostumbrados a tratar.
Las aplicaciones son conducidas por eventos y se desarrollan
haciendo uso de las clases que para ello nos ofrece la API de Java.
P.O.O Tema 6 – Interfaces gráficas de usuario - 2
La API de Java para desarrollo de GUI
La interfaz de usuario es la parte del programa que permite
al usuario interaccionar con él.
La API de Java proporciona una biblioteca de clases para el
desarrollo de Interfaces gráficas de usuario (en realidad son dos).
La biblioteca proporciona un conjunto de herramientas para
la construcción de interfaces gráficas que tienen
una apariencia y se comportan de forma semejante
en todas las plataformas en las que se ejecuten.
La estructura básica de la biblioteca gira en torno a componentes
y contenedores. Los contenedores contienen componentes y
son componentes a su vez, de forma que los eventos pueden
tratarse tanto en contenedores como en componentes.
La API está constituida por clases, interfaces y derivaciones.
AWT y Swing
P.O.O Tema 6 – Interfaces gráficas de usuario - 3
Algunos componentes de AWT
TextArea
CanvasLabel
List
TextField Button
CheckBox
Frame
2. P.O.O Tema 6 – Interfaces gráficas de usuario - 4
Algunos componentes de Swing
P.O.O Tema 6 – Interfaces gráficas de usuario - 5
Algunos componentes de Swing
P.O.O Tema 6 – Interfaces gráficas de usuario - 6
Paquete de Java para la generación del GUI en aplicaciones
reales de gran tamaño. Disponible como paquete externo
en Java 1.1 e integrado desde Java 1.2.
Es una de las API de JFC (Java Foundation Classes):
AWT, Java 2D, Accessibility, Drag and Drop, Swing, ...
Escrito totalmente en Java. No reemplaza a AWT.
Se apoya sobre AWT y añade JComponents.
Utiliza el modelo de eventos de Java 1.1.
Elección entre diferentes aspectos (look & feel).
Arquitectura Model-View-Controller (MVC).
Nuevos componentes (árboles, tablas, frames internos, iconos,
bordes, tooltips, beans, etcétera).
Swing
P.O.O Tema 6 – Interfaces gráficas de usuario - 7
Jerarquía de clases para las GUI
Dimension
Font
FontMetrics
Component
Graphics
Object Color
Container
Panel Applet
Frame
Dialog
Window
JComponent
JApplet
JFrame
JDialog
Swing Components
in the javax.swing package
Lightweight
Heavyweight
Classes in the java.awt
package
1
LayoutManager
*
Las clases de AWT reemplazadas por Swing
se llaman igual pero con una J delante.
3. P.O.O Tema 6 – Interfaces gráficas de usuario - 8
Jerarquía de clases para las GUI
Component: superclase de todas las clases de interfaz gráfica.
Container: para agrupar componentes.
JComponent: superclase de todos los componentes de Swing
que se dibujan directamente en los lienzos (canvas).
Sus subclases son los elementos básicos de la GUI.
JFrame: ventana que no está contenida en otras ventanas.
JDialog: cuadro de diálogo.
JApplet: subclase de Applet para crear applets tipo Swing.
JPanel: contenedor invisible que mantiene componentes
de interfaz y que se puede anidar, colocándose en otros paneles
o en ventanas. También sirve de lienzo.
Graphics: clase abstracta que proporciona contextos gráficos
donde dibujar cadenas de texto, líneas y otras formas sencillas.
P.O.O Tema 6 – Interfaces gráficas de usuario - 9
Jerarquía de clases para las GUI
Color: color de los componentes gráficos.
Font: aspecto de los caracteres.
FontMetrics: clase abstracta para propiedades de las fuentes.
Categorías de clases:
Contenedores:
JFrame, JApplet, JWindow, JDialog
Componentes intermedios:
JPanel, JScrollPane
Componentes:
JLabel, JBbutton, JTextField, JTextArea, ...
Clases de soporte:
Graphics, Color, Font, ...
P.O.O Tema 6 – Interfaces gráficas de usuario - 10
.
JButton
JMenuItem
JCheckBoxMenuItem
AbstractButton
JComponent
JMenu
JRadioButtonMenuItem
JToggleButton JCheckBox
JRadioButton
JComboBox
JInternalFrame JLayeredPane
JList JMenuBar JOptionPane
JPopupMenu
JProgressBar
JPane
JFileChooser
JScrollBar JScrollPane
JSeparator
JSplitPane
JSlider
JTabbedPane
JTable
JTableHeader
JTextFieldJTextComponent
JEditorPane
JTextArea
JToolBar
JToolTip
JTree
JRootPane
JPanel
JPasswordField
JColorChooser
JLabel
Jerarquía de clases para las GUI: JComponent
P.O.O Tema 6 – Interfaces gráficas de usuario - 11
AWTEvent
Font
FontMetrics
Component
Graphics
Object Color
Canvas
Button
TextComponent
Label
List
CheckBoxGroup
CheckBox
Choice
Container Panel Applet
Frame
Dialog FileDialog
Window
TextField
TextArea
MenuComponent MenuItem
MenuBar
Menu
Scrollbar
LayoutManager
Jerarquía de clases para las GUI: AWT
4. P.O.O Tema 6 – Interfaces gráficas de usuario - 12
Jerarquía de componentes (repaso)
Graphics (java.awt)
Component (funcionalidad básica de componentes gráficos)
Button, Canvas, CheckBox, Choice, Label, List, ScrollBar
TextComponent
TextField, TextArea
Container (permite agrupar, añadir y eliminar componentes)
(también definir diseño o disposición (layout managers))
ScrollPane
Panel
Applet (java.applet)
JApplet (javax.swing)
Window
Frame
JFrame (javax.swing)
Dialog
FileDialog
JDialog (javax.swing)
JWindow (javax.swing)
JComponent (javax.swing)
P.O.O Tema 6 – Interfaces gráficas de usuario - 13
Contenedores
Contenedores de alto nivel:
JFrame
Habitualmente la clase JFrame se emplea para crear
la ventana principal de una aplicación en Swing.
JDialog
Ventanas de interacción con el usuario.
Contenedores intermedios:
JPanel
Agrupa a otros componentes.
JScrollPanel
Incluye barras de desplazamiento.
P.O.O Tema 6 – Interfaces gráficas de usuario - 14
Contenedores
P.O.O Tema 6 – Interfaces gráficas de usuario - 15
Jerarquía
5. P.O.O Tema 6 – Interfaces gráficas de usuario - 16
Esquema de aplicación en Swing
import javax.swing.*;
public class Gui00 extends JFrame {
// Constantes y componentes (objetos)
public Gui00(){
super("Ejemplo 00");
// Configurar Componentes ;
// Configurar Manejadores Eventos ;
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
} // Terminar la aplicación al cerrar la ventana.
public static void main(String args[]){
Gui00 aplicacion = new Gui00();
}
}
Método main()
GUI00.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 17
Esquema de aplicación en Swing sin herencia
import javax.swing.*;
public class Gui00 {
// Constantes y componentes (objetos)
public Gui00(){
Jframe frame = new Jframe(“Ejemplo 00”);
// Configurar componentes
// y añadirlos al panel del frame
. . .
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
}
public static void main(String args[]){
Gui00 aplicacion = new Gui00();
}
} GUI00.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 18
Modo 1:
1. Obtenemos el panel de contenido del frame:
Container panel = this.getContentPane();
2. Añadimos componentes a dicho panel:
panel.add(unComponente);
Modo 2:
A partir de 1.5 también se puede hacer directamente sobre el Jframe
add(unComponente);
JFrame : añadir elementos
P.O.O Tema 6 – Interfaces gráficas de usuario - 19
1. Con herencia de JFrame utilizando Container
import javax.swing.*;
import java.awt.*;
public class Gui01 extends JFrame {
private Container panel;
private JButton miboton;
public Gui01() {
super("Ejemplo 01 con botón");
// Configurar componentes ;
miboton = new JButton("Aceptar");
panel = getContentPane();
panel.add(miboton);
. . .
setSize(200,100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}}
Gui01.java
6. P.O.O Tema 6 – Interfaces gráficas de usuario - 20
2. Con herencia de JFrame sin Container
import javax.swing.*;
import java.awt.*;
public class Gui01 extends JFrame {
private JButton miboton;
public Gui01() {
super("Ejemplo 01 con botón");
. . .
miboton = new JButton("Aceptar");
add(miboton);
. . .
setSize(200,100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}
Gui01.java
Es el
método
utilizado en
los ejemplos
P.O.O Tema 6 – Interfaces gráficas de usuario - 21
3. Ejemplo sin herencia con Container
public class Gui01 {
private JButton miboton;
private Container panel;
public Gui01() {
Jframe frame = new JFrame(“Ejemplo 01”);
panel = frame.getContentPane();
. . .
miboton = new JButton("Aceptar");
panel.add(miboton);
//se añade al contentPane del frame
. . .
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}
Gui01.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 22
4. Ejemplo sin herencia sin Container
public class Gui01 {
private JButton miboton;
public Gui01() {
Jframe frame = new JFrame(“Ejemplo 01”);
. . .
miboton = new JButton("Aceptar");
frame.add(miboton); //se añade al frame
. . .
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui01 aplicacion = new Gui01();
}
}
Gui01.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 23
Administradores de disposición
Los componentes se agregan al contenedor con el método add().
JButton unBoton = new JButton("Texto del botón");
panel.add(unBoton);
El efecto de add() depende del esquema de colocación o
disposición (layout) del contenedor que se use.
Existen diversos esquemas de disposición: FlowLayout,
BorderLayout, GridLayout, ...
Los objetos contenedores se apoyan en objetos LayoutManager
(administradores de disposición).
Clases más usadas que implementa la interfaz LayoutManager:
FlowLayout: un componente tras otro de izquierda a derecha.
BorderLayout: 5 regiones en el contenedor (North, South, ...).
GridLayout: contenedor en filas y columnas.
7. P.O.O Tema 6 – Interfaces gráficas de usuario - 24
Para organizar el contenedor se utiliza el método setLayout():
public void setLayout(LayoutManager mgr)
setLayout(new BorderLayout());
setLayout(new FlowLayout());
setLayout(new GridLayout(3,4));
El layout manager elige la mejor posición y tamaño de cada
componente de acuerdo al espacio disponible.
Crea una disposición para
el contenedor actual
Tipo de disposición
(BorderLayout, ...)
Administradores de disposición
P.O.O Tema 6 – Interfaces gráficas de usuario - 25
Organización de contenedores
BorderLayout organiza
el contenedor en 5 zonas:
FlowLayout coloca los
componentes de izquierda a
derecha y de arriba hacia
abajo:
Para distribuciones más complejas podemos insertar paneles
(JPanel) en los contenedores y obtener el tamaño de un
componente con el método getSize().
P.O.O Tema 6 – Interfaces gráficas de usuario - 26
FlowLayout
import javax.swing.*;
import java.awt.*;
public class Gui02 extends JFrame {
public Gui02() {
super("Ejemplo de Layout");
// Configurar componentes ;
// Configurar layout ;
setLayout(new FlowLayout(FlowLayout.LEFT, 10, 20));
for(int i = 1; i <= 10; i++)
add(new JButton("Componente " + i));
setSize(200,200);//pack();
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui02 aplicacion = new Gui02();
}
}
Gui02.java
Cambiando el tamaño
se redistribuyen los componentes
P.O.O Tema 6 – Interfaces gráficas de usuario - 27
BorderLayout
import javax.swing.*;
import java.awt.*;
public class Gui03 extends JFrame {
public Gui03() {
super("Ejemplo de Layout");
// BorderLayout
setLayout(new BorderLayout(5, 10));
add(new JButton("1"), BorderLayout.EAST);
add(new JButton("2"), BorderLayout.SOUTH);
add(new JButton("3"), BorderLayout.WEST);
add(new JButton("4"), BorderLayout.NORTH);
add(new JButton("5"), BorderLayout.CENTER);
setSize(200,200); //pack();
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
... Gui03.java
8. P.O.O Tema 6 – Interfaces gráficas de usuario - 28
setLayout(new GridLayout(filas, columnas))
Crea una zona de filas x columnas componentes y éstos
se van acomodando de izquierda a derecha y de arriba a abajo.
GridLayout tiene otro constructor que permite establecer
la separación (en pixels) ente los componentes,
que es cero con el primer constructor.
Así, por ejemplo:
new GridLayout(3, 4, 2, 2)
crea una organización de 3 filas y 4 columnas donde los
componentes quedan a dos pixels de separación.
Ejemplo:
setLayout(new GridLayout(3, 4, 2, 2);
for(int i = 0; i < 3 * 4; i++) {
add(new JButton(Integer.toString(i + 1)));
}
GridLayout
P.O.O Tema 6 – Interfaces gráficas de usuario - 29
import javax.swing.*;
import java.awt.*;
public class Gui03b extends JFrame {
public Gui03b() {
super("Ejemplo de Layout");
setLayout(new GridLayout(4, 3, 5, 5));
for(int i = 1; i <= 10; i++)
add(new JButton(Integer.toString(i)));
setSize(200,200);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
...
GridLayout
Gui03b.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 30
Paneles como contenedores
Los paneles actúan como pequeños contenedores para agrupar
componentes. Colocamos los componentes en paneles y
los paneles en el frame o incluso en otros paneles.
boton
textfield
12
botones
frame
p2
p1
P.O.O Tema 6 – Interfaces gráficas de usuario - 31
// Extraído de "Introduction to Java Programming"
// de Y. Daniel Lang (Prentice Hall, 2001)
import java.awt.*;
import javax.swing.*;
public class Gui04 extends JFrame {
public Gui04() {
setTitle("Horno microondas");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
// Create panel p1 for the buttons and set GridLayout
JPanel p1 = new JPanel();
p1.setLayout(new GridLayout(4, 3));
// Add buttons to the panel
for(int i = 1; i <= 9; i++) {
p1.add(new JButton("" + i));
}
p1.add(new JButton("" + 0));
p1.add(new JButton("Start"));
p1.add(new JButton("Stop"));
boton
textfield
12
botones
frame
p2
p1
...
Paneles como contenedores
9. P.O.O Tema 6 – Interfaces gráficas de usuario - 32
// Create panel p2 to hold a text field and p1
JPanel p2 = new JPanel();
p2.setLayout(new BorderLayout());
p2.add(new JTextField("Aquí el tiempo"),
BorderLayout.NORTH);
p2.add(p1, BorderLayout.CENTER);
// Add p2 and a button to the frame
add(p2, BorderLayout.EAST);
add(new Button("Aquí la comida"),
BorderLayout.CENTER);
setSize(400, 250);
setVisible(true);
}
/** Main method */
public static void main(String[] args) {
Gui04 frame = new Gui04();
}
}
Gui04.java
Paneles como contenedores
P.O.O Tema 6 – Interfaces gráficas de usuario - 33
Dibujo de gráficos en paneles
JPanel se puede usar para dibujar.
Para dibujar en un panel se crea una clase derivada de JPanel
y se redefine el método paintComponent() que le indica al panel
como dibujar.
La clase Graphics es una clase abstracta para todos
los contextos gráficos.
Una vez obtenido el contexto gráfico podemos llamar desde este
objeto a las funciones gráficas definidas en la clase Graphics.
Graphics contiene información acerca de la zona que necesita
ser redibujada: el objeto donde dibujar, un origen de traslación,
el color actual, la fuente actual, etcétera.
P.O.O Tema 6 – Interfaces gráficas de usuario - 34
Ejemplo de dibujo
import javax.swing.*;
import java.awt.*;
class MiPanel extends JPanel {
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawString("Interfaz gráfica", 40, 40);
}
}
public class Gui05 extends JFrame {
public Gui05() {
super("Ejemplo de dibujo");
add(new MiPanel());
setSize(200, 100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
...
Método a redefinir
Gui05.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 35
Cuando utilizamos el método paintComponent() para dibujar
en un contexto gráfico g, ese contexto es un ejemplar de
una subclase concreta de la clase Graphics para la plataforma
específica.
El método paintComponent() es llamado la primera vez y
cada vez que es necesario redibujar el componente.
Al hacer super.paintComponent(g) nos aseguramos de que
el área visualizada se limpia antes de volver a dibujar.
class MiPanel extends JPanel {
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawString("Interfaz gráfica", 40, 40);
}
}
Dibujo de gráficos en paneles
10. P.O.O Tema 6 – Interfaces gráficas de usuario - 36
import javax.swing.*;
import java.awt.*;
class MiPanel extends JPanel {
public void paintComponent(Graphics g) {
Color c = new Color(180, 10, 120);
g.setColor(c);
g.drawString("Dibujar en el panel", 90, 90);
g.fillOval(1, 1, 90, 90);
}
}
public class Gui06 extends JFrame {
public Gui06(){
super("Ejemplo de dibujo");
add(new MiPanel());
setSize(300, 200);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
...
Creación de un color RGB
Gui06.java
Ejemplo de dibujo
P.O.O Tema 6 – Interfaces gráficas de usuario - 37
Algunos métodos de Graphics
Graphics g;
...
g.setColor(Color.blue);
g.setBackground(Color.red);
g.drawLine(int x1, int y1, int x2, int y2);
g.drawRect(int x, int y, int ancho, int alto);
g.drawRoundedRect(int x, int y, int ancho, int alto,
int arcWidth, int arcHeight);
g.fillRect(int x, int y, int ancho, int alto);
g.fillRoundedRect(int x, int y, int ancho, int alto,
int arcWidth, int arcHeight);
g.drawOval(int x, int y, int ancho, int alto);
g.fillOval(int x, int y, int ancho, int alto);
g.drawArc(int x, int y, int ancho, int alto, int ang1,
int ang2);
g.drwaString(String cadena, int x, int y);
g.setFont(Font f);
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 38
Interacción con el usuario
Al interactuar con la aplicación, el usuario:
Acciona componentes (ActionEvent).
El usuario pulsa un botón.
El usuario termina de introducir un texto en un campo y
presiona Intro.
El usuario selecciona un elemento de una lista pulsando el
preferido (o de un menú).
Pulsa o suelta botones del ratón (MouseEvent).
Minimiza, cierra o manipula una ventana (WindowEvent).
Escribe con el teclado (KeyEvent).
Descubre porciones de ventanas (PaintEvent).
P.O.O Tema 6 – Interfaces gráficas de usuario - 39
Interacción con el usuario
Cuando el usuario de un programa o applet mueve el ratón,
presiona un pulsador o pulsa una tecla, genera un evento
(actionEvent).
Los eventos son objetos de ciertas clases. Normalmente
un objeto de alguna subclase de EventObject que indica:
El elemento que accionó el usuario.
La identificación del evento que indica la naturaleza
del evento.
La posición del ratón en el momento de la interacción.
Teclas adicionales pulsadas por el usuario, como la tecla
Control, la tecla de Cambio a mayúsculas, etcétera.
11. P.O.O Tema 6 – Interfaces gráficas de usuario - 40
Acciones del usuario
Acción Objeto origen Tipo de evento
Pulsar un botón JButton ActionEvent
Cambio del texto JTextComponent TextEvent
Pulsar Intro en un campo de texto JTextField ActionEvent
Selección de un nuevo elemento JCombobox ItemEvent
ActionEvent
Selección de elemento(s) JList ListSelection-
Event
Pulsar una casilla de verificación JCheckBox ItemEvent
ActionEvent
Pulsar un botón de radio JRadioButton ItemEvent
ActionEvent
Selección de una opción de menú JMenuItem ActionEvent
Mover la barra de desplazamiento JScrollBar AdjustmentEvent
Abrir, cerrar, minimizar,
maximizar o cerrar la ventana JWindow WindowEvent
. . .
P.O.O Tema 6 – Interfaces gráficas de usuario - 41
Ejemplo
Al pulsar el botón Copiar, se debe copiar el valor del cuadro "valor"
en el cuadro "Copia".
Origen del evento:
Botón Copiar
Objeto evento:
ActionEvent e
Objeto oyente:
La ventana
P.O.O Tema 6 – Interfaces gráficas de usuario - 42
Modelo para responder a eventos
Creamos un manejador de eventos en dos pasos:
Definimos una clase específica que haga de oyente de eventos
y que implemente el método actionPerformed().
class MiOyente implements ActionListener {
public void actionPerformed() {
// Aquí se responde el evento
Registramos un ejemplar como oyente de componentes:
componente.addActionListener(ejemplar_de_MiOyente);
P.O.O Tema 6 – Interfaces gráficas de usuario - 43
class MiGui extends JFrame {
...
public void MiGui() {
// Registro los componentes interesados
// en responder a eventos ...
componente.addActionListener(new MiOyente());
}
...
class MiOyente implements ActionListener {
public actionPerformed(ActionEvent e) {
... // Aqui se responde el evento
}
}
Se añade el oyente especificado (ejemplar de MiOyente)
a la lista de oyentes para recibir eventos de acción
(ActionEvent) desde ese componente.
Modelo para responder a eventos
12. P.O.O Tema 6 – Interfaces gráficas de usuario - 44
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Gui09 extends JFrame {
JButton boton;
public Gui09() {
boton = new JButton("Pulsa!");
add(boton);
boton.addActionListener(new OyenteBoton());
setSize(100, 100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
...
}
class OyenteBoton implements ActionListener {
public void actionPerformed(ActionEvent e) {
Toolkit.getDefaultToolkit().beep();
}
}
Una clase
de oyente
específica
Gui09.java
Ejemplo: botón con pitido
P.O.O Tema 6 – Interfaces gráficas de usuario - 45
Ejemplo: reproducir un valor
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Gui10 extends JFrame {
JButton botonCopiar;
JTextField campoValor, resultado;
public Gui10() {
setLayout(new FlowLayout());
add(new JLabel("Valor "));
campoValor = new JTextField(5);
add(campoValor);
botonCopiar = new JButton("Copiar");
add(botonCopiar);
botonCopiar.addActionListener(new OyenteBoton());
add(new JLabel(" Copia "));
resultado = new JTextField(6); ...
P.O.O Tema 6 – Interfaces gráficas de usuario - 46
Ejemplo: reproducir un valor
setSize(400, 100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String args[]) {
Gui10 ventana = new Gui10();
}
class OyenteBoton implements ActionListener {
public void actionPerformed(ActionEvent e){
String valor = campoValor.getText();
resultado.setText(valor);
}
}
}
Gui10.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 47
Ejemplo: contador de pulsaciones
public class Gui11 extends JFrame {
...
public Gui11() {
boton1 = new JButton("PULSA");
label1 = new JLabel("Pulsaciones: 0");
add(boton1);
add(label1);
setLayout(new FlowLayout());
boton1.addActionListener(new OyenteBotonPulsaciones());
...
}
...
class OyenteBotonPulsaciones implements ActionListener {
public void actionPerformed(ActionEvent e){
contador++;
label1.setText("Pulsaciones: " + contador);
} ...
Gui11.java
13. P.O.O Tema 6 – Interfaces gráficas de usuario - 48
Ejemplo: cambio de color
...
import javax.swing.*;
import java.awt.*;import java.awt.event.*;
public class Gui12 extends JFrame {
JButton rojo = new JButton("Rojo");
JButton azul = new JButton("Azul");
Container p;
public Gui12() {
super("Color de fondo");
p = this.getContentPane();
setLayout(new FlowLayout());
add(rojo);
add(azul);
rojo.addActionListener(new OyenteRojo());
azul.addActionListener(new OyenteAzul());
setSize(200, 200);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
P.O.O Tema 6 – Interfaces gráficas de usuario - 49
Ejemplo: cambio de color
public static void main(String args[]) {
Gui12 ventana = new Gui12();
}
class OyenteRojo implements ActionListener {
public void actionPerformed(ActionEvent evento) {
p.setBackground(Color.red);
}
}
class OyenteAzul implements ActionListener {
public void actionPerformed(ActionEvent evento) {
p.setBackground(Color.green);
}
}
}
Gui12.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 50
ActionEvent
El objeto ActionEvent ofrece un método getActionCommand()
que devuelve un objeto con la información sobre el origen
del evento (el botón en nuestro caso).
Con un botón, devuelve la etiqueta del botón.
Para identificar botones individuales:
public void actionPerformed(ActionEvent e) {
String s = (String)e.getActionCommand();
if(s.equals("Aceptar")) {
// Tratamiento del botón Aceptar
}
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 51
El método getSource() indica el objeto en el que se ha
originado el evento:
public void actionPerformed(ActionEvent e) {
if(e.getSource() == lista) {
campo1.setText("En la lista.");
}
else if(e.getSource() == texto) {
campo2.setText("En el campo de texto.");
}
else if(e.getSource() == boton) {
campo3.setText("En el botón.");
}
}
ActionEvent
14. P.O.O Tema 6 – Interfaces gráficas de usuario - 52
Un conversor Euros-Pesetas
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Gui13 extends JFrame {
private JTextField cantidad;
private boton1, boton2;
public Gui13(){
super("Conversor Euros-Pesetas");
boton1 = new JButton("A euros");
boton2 = new JButton("A pesetas");
cantidad = new TextField(10);
JLabel eti2 = new JLabel(new ImageIcon("logo.gif"));
add(eti2); add(cantidad);
add(boton1); add(boton2);
setLayout(new FlowLayout());
boton1.addActionListener(new OyenteBoton());
boton2.addActionListener(new OyenteBoton());
setSize(300, 250);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 53
Un conversor Euros-Pesetas
public static void main(String args[]) {
Gui13 ventana = new Gui13();
}
class OyenteBoton implements ActionListener {
public void actionPerformed(ActionEvent ae) {
Float f = new Float(cantidad.getText());
float valor = f.floatValue();
String s = (String)ae.getActionCommand();
if(s.equals("A euros")) {
valor = (float) (valor / 166.321);
}
else if(s.equals("A pesetas")) {
valor = (float) (valor * 166.321);
}
cantidad.setText(Float.toString(valor));
}
}
}
Gui13.java
La clase OyenteBoton es interna y
tiene acceso a los elementos de la
clase Contenedora
P.O.O Tema 6 – Interfaces gráficas de usuario - 54
Interfaces para procesar eventos
Para facilitar la tarea del programador se han creado una serie de
interfaces que deben implementarse cuando se quieren procesar
algunos de estos eventos. Algunas interfaces y sus métodos son:
ActionListener
Escucha eventos de tipo ActionEvent
actionPerformed(ActionEvent)
KeyListener
Escucha eventos de teclado
keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
MouseListener
Escucha eventos de acción del ratón
(botones)
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
MouseMotionListener
Escucha eventos de movimiento del ratón
mouseDragged(MouseEvent)
mouseMoved(MouseEvent)
P.O.O Tema 6 – Interfaces gráficas de usuario - 55
Componentes: botones
JButton: Botón aislado. Puede pulsarse, pero su estado no cambia
JToggleButton : Botón seleccionable. Cuando se pulsa el botón, su
estado pasa a seleccionado, hasta que se pulsa de nuevo (entonces se
deselecciona)
isSelected() permite chequear su estado
JCheckBox : Especialización de JToggleButton que implementa una
casilla de verificación. Botón con estado interno, que cambia de
apariencia de forma adecuada según si está o no está seleccionado
JRadioButton: Especialización de JToggleButton que tiene sentido
dentro de un mismo grupo de botones (ButtonGroup) que controla
que sólamente uno de ellos está seleccionado
15. P.O.O Tema 6 – Interfaces gráficas de usuario - 56
Componentes : JButton
Constructores:
JButton(String text)
JButton(String text, Icon icon)
JButton(Icon icon)
Respuesta a botones:
Implementar la interfaz ActionListener
Implementar el método actionPerformed(ActionEvent e)
public void actionPerformed(ActionEvent e) {
// Obtenemos la etiqueta
String actionCommand = e.getActionCommand();
if(e.getSource() instanceof JButton)
if("Aceptar".equals(actionCommand))
System.out.println("Pulsó Aceptar");
}
P.O.O Tema 6 – Interfaces gráficas de usuario - 57
Ejemplos
boton1 = new JButton("A Euros ");
boton1.setIcon(new ImageIcon("flag1.gif"));
boton2 = new JButton(new ImageIcon("flag2.gif"));
boton3 = new JButton("Botón",new ImageIcon("flag8.gif"));
P.O.O Tema 6 – Interfaces gráficas de usuario - 58
Para texto, una imagen o ambos:
JLabel(String text,
int horizontalAlignment)
JLabel(String text)
JLabel(Icon icon)
JLabel(Icon icon,
int horizontalAlignment)
eti1 = new JLabel("Etiqueta de texto...");
eti2 = new JLabel(new ImageIcon("flag8.gif"));
Gui14.java
Componentes : JLabel
P.O.O Tema 6 – Interfaces gráficas de usuario - 59
Campos de texto para introducir caracteres:
JTextField(int columns)
JTextField(String text)
JTextField(String text, int columns)
JTextField text1 = new JTextField("hola", 10);
Poner texto: text1.setText("Adios");
Obtener texto: String str = text1.getText();
Agregar al Panel: p1.add(text1);
Componentes : JTextField
16. P.O.O Tema 6 – Interfaces gráficas de usuario - 60
Listas de elementos para seleccionar un solo valor:
Creación: JComboBox ch1 = new JComboBox();
Agregar opciones: ch1.addItem(Object elemento);
Registrar Evento: ch1.addItemListener( objeto);
Obtener selección: val = ch1.getSelectedIndex();
ch1.getItem()
Implementar la interfaz ItemListener
Implementar el método itemStateChanged(ItemEvent e)
ch1.addItemListener(new OyenteItem());
. . .
class OyenteItem implements ItemListener {
public void itemStateChanged(ItemEvent e) {
...
}}
Componentes : JComboBox
P.O.O Tema 6 – Interfaces gráficas de usuario - 61
Listas de elementos para seleccionar uno o varios valores:
JList l1 = new JList();
JList l2 = new JList(Object[] elements);
String[] cosas = {"Opción 1", "Opción 2", "Opción 3"};
Jlist l2 = new Jlist(cosas);
Registrar evento: l2.addListSelectionListener(oyente);
Obtener selección:
int[] indices = l2.getSelectedIndices();
Componentes : JList
P.O.O Tema 6 – Interfaces gráficas de usuario - 62
Implementar la interfaz ListSelectionListenner
Implementar el método valueChanged(ListSelectionEvent e)
l.addListSelectionListener(new OyenteLista());
...
class OyenteLista implements ListSelectionListener {
public void valueChanged(ListSelectionEvent e) {
int[] indices = l.getSelectedIndices();
int i;
for(i = 0; i < indices.length; i++) {
...
}
}
}
Componentes : JList
P.O.O Tema 6 – Interfaces gráficas de usuario - 63
Creación:
bar1 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,100);
Registrar evento:
bar1.addAdjustmentListener(oyente);
Implementar la interfaz AdjustmentListener
Implementar el método
adjustmentValueChanged(AdjustmentEvent e)
bar1.addAdjustmentListener(new OyenteBarra());
...
class OyenteBarra implements AdjustmentListener {
public void adjustmentValueChanged(AdjustmentEvent e) {
... }
}
Obtener valor:
int val = bar1.getValue(); // val entre 0 y 100
Componentes : JScrollBar
17. P.O.O Tema 6 – Interfaces gráficas de usuario - 64
public class Gui15 extends JFrame {
Container panel;
JPanel p1, p2;
JLabel l1, msg;
JComboBox ch1;
String[] lista = {"Opción 1", "Opción 2", "Opción 3"};
JScrollBar bar1;
public Gui15() {
super("Controles");
setLayout(new BorderLayout());
p1 = new JPanel(new GridLayout(1, 3, 10, 10));
p1.setBackground(Color.lightGray);
l1 = new JLabel("Elegir:", Label.RIGHT);
l1.setBackground(Color.yellow);
p1.add(l1);
ch1 = new JComboBox();
for(int i = 0; i < lista.length; i++)
ch1.addItem(lista[i]);
Componentes: JScrollBar y JComboBox
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 65
ch1.addItemListener(new OyenteCombo());
p1.add(ch1);
bar1 = new JScrollBar(Scrollbar.HORIZONTAL, 0, 0, 0, 100);
/* scroll de 0 a 100*/
bar1.addAdjustmentListener(new OyenteBarra());
p1.add(bar1);
p2 = new JPanel(new BorderLayout());
p2.setBackground(Color.lightGray);
msg = new JLabel("Msg:", Label.LEFT);
msg.setForeground(Color.blue);
p2.add("North", msg);
add(p1, "North");
add(p2, "South");
setSize(300, 100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
Componentes: JScrollBar y JComboBox
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 66
public static void main(String args[]) {
Gui15 ventana = new Gui15();
}
class OyenteCombo implements ItemListener {
public void itemStateChanged(ItemEvent e) {
int ind = ch1.getSelectedIndex();
msg.setText((String)ch1.getSelectedItem());
}
}
class OyenteBarra implements AdjustmentListener {
public void adjustmentValueChanged(AdjustmentEvent e) {
int valor = bar1.getValue();
String cad = "Valor : " + valor;
msg.setText(cad);
}
}
}
Componentes: JScrollBar y JComboBox
Gui15.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 67
Movimientos de ratón
public class Gui17 extends JFrame {
JButton boton;
List lista;
Container panel;
public Gui17() {
...
this.addMouseMotionListener(new OyenteMover());
...
}
...
} class OyenteMover implements MouseMotionListener {
public void mouseDragged(MouseEvent e) {
lista.add("arrastrando..");
}
public void mouseMoved(MouseEvent e) {
lista.add("moviendo..");
}
}
Gui17.java
18. P.O.O Tema 6 – Interfaces gráficas de usuario - 68
Pulsaciones de ratón
class OyenteRaton implements MouseListener {
public void mouseClicked(MouseEvent e) {
lista.add("click..");
}
public void mouseEntered(MouseEvent e) {
lista.add("enter.."); }
public void mouseExited(MouseEvent e) {
lista.add("exit.."); }
public void mousePressed(MouseEvent e) {
lista.add("pulsar.."); }
public void mouseReleased(MouseEvent e) {
lista.add("soltar..");
}
}
P.O.O Tema 6 – Interfaces gráficas de usuario - 69
Interacción modal
P.O.O Tema 6 – Interfaces gráficas de usuario - 70
Interacción modal
P.O.O Tema 6 – Interfaces gráficas de usuario - 71
Interacción modal
19. P.O.O Tema 6 – Interfaces gráficas de usuario - 72
Ejemplo de cuadro de mensaje
public class Gui18 extends JFrame {
public Gui18() {
super("Título de la ventana");
setLayout(new FlowLayout());
setSize(200, 100); // pack();
setVisible(true); // show();
setDefaultCloseOperation(EXIT_ON_CLOSE);
// if ocurre algo
JOptionPane.showMessageDialog(null,
"Debe introducir datos en todos los campos",
"Error de entrada ",
JOptionPane.ERROR_MESSAGE);
}
public static void main(String[] args) {
Gui18 f = new Gui18();
}
}
Gui18.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 73
Ejemplo de cuadro de opciones
public class Gui19 extends JFrame {
public Gui19() {
super("Título de la ventana");
p = getContentPane();
setLayout(new FlowLayout());
setSize(200, 100);
setVisible(true);
setDefaultCloseOperation(EXIT_ON_CLOSE);
Object[] textoOpciones={"Si adelante","Ahora no","No
sé"};
int opcion = JOptionPane.showOptionDialog(null,
"¿Desea continuar?", "mensaje",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE, null, textoOpciones,
textoOpciones[0]);
}
...
Gui19.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 74
Ejemplo de cuadro de entrada de datos
class PanelDatos extends JPanel {
public PanelDatos() {
setLayout(new GridLayout(4, 2));
JLabel etiquetaNombre = new JLabel("Nombre: ", JLabel.RIGHT);
JTextField campoNombre = new JTextField();
add(etiquetaNombre);
add(campoNombre);
JLabel etiquetaApellidos = new JLabel("Apellidos:", JLabel.RIGHT);
JTextField campoApellidos = new JTextField();
add(etiquetaApellidos);
add(campoApellidos);
JLabel etiquetaNP = new JLabel("Número Personal:", JLabel.RIGHT);
JTextField campoNP = new JTextField();
add(etiquetaNP);
add(campoNP);
ButtonGroup grupoBotones = new ButtonGroup();
JRadioButton mañana = new JRadioButton("Grupo Mañana", true);
JRadioButton tarde = new JRadioButton("Grupo Tarde");
grupoBotones.add(mañana);
grupoBotones.add(tarde);
add(mañana);
add(tarde);
}
}
P.O.O Tema 6 – Interfaces gráficas de usuario - 75
Ejemplo de cuadro de entrada de datos
public class Gui20 extends JFrame {
public Gui20() {
super("Título de la ventana");
setLayout(new FlowLayout());
// Cuando necesitamos el cuadro de diálogo...
PanelDatos pd = new PanelDatos();
if(JOptionPane.showConfirmDialog(this, pd,
"Introduzca datos",
JOptionPane.OK_CANCEL_OPTION,
JOptionPane.PLAIN_MESSAGE)
== JOptionPane.OK_OPTION) {
// ... tratamiento
}
}
public static void main(String[] args) {
Gui20 f = new Gui20();
}} Gui20.java
20. P.O.O Tema 6 – Interfaces gráficas de usuario - 76
Menús
Java ofrece varias clases para poner menús en una ventana:
JMenuBar
JMenu
JMenuItem
JCheckBoxMenuItem
JRadioButtonMenuItem
Un JFrame o JApplet puede guardar un barra de menú donde
se cuelgan menús desplegables.
Los menús tienen elementos de menú que puede seleccionar
el usuario.
Las barras de menús se pueden contemplar como una estructura
que soporta menús.
P.O.O Tema 6 – Interfaces gráficas de usuario - 77
Menús
Una ventana (frame) sólo puede tener una barra de menús
(objeto MenuBar), que se sitúa en la parte de arriba del mismo.
Los submenús son botones JMenu.
Los elementos de los menús son botones JMenuItem.
Cuando se activa un menú se despliegan automáticamente
las opciones del menú.
P.O.O Tema 6 – Interfaces gráficas de usuario - 78
Menús
P.O.O Tema 6 – Interfaces gráficas de usuario - 79
Ejemplo de menú
21. P.O.O Tema 6 – Interfaces gráficas de usuario - 80
Ejemplo de menú
JMenuBar barraMenu = new JMenuBar();
setJMenuBar(barraMenu); // La barra de menús de este frame
// El menú:
JMenu menuOpciones = new JMenu("Menú de opciones");
barraMenu.add(menuOpciones); // Añadimos el menú a la barra
// Un elemento de menú:
JMenuItem listar = new JMenuItem("Listar los alumnos");
menuOpciones.add(listar); // Añadimos el elemento al menú
// Inserción de una línea separadora en el menú:
menuOpciones.add(new JSeparator());
// Un menú que será un submenú del anterior:
JMenu subMenu = new JMenu("Submenú");
// Un elemento de menú para el submenú:
JMenuItem opcionSubmenu = new JMenuItem("Opción de submenú");
subMenu.add(opcionSubmenu); // La añadimos al submenú
// Añadimos el submenú como elemento del menú:
menuOpciones.add(subMenu);
P.O.O Tema 6 – Interfaces gráficas de usuario - 81
Ejemplo de menú
// Establecemos oyentes para las opciones elegibles:
listar.addActionListener(new OyenteMenu());
opcionSubmenu.addActionListener(new OyenteMenu());
...
class OyenteMenu implements ActionListener {
public void actionPerformed(ActionEvent e) {
String actionCommand = e.getActionCommand();
if(e.getSource() instanceof JMenuItem) {
if("Listar los alumnos".equals(actionCommand)) {
texto.setText("Listar los alumnos");
}
if("Opción de submenú".equals(actionCommand)) {
texto.setText("Opción de submenú");
}
}
}
}
Gui21.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 82
Otro ejemplo
Aplicación que permite realizar operaciones aritméticas.
La interfaz contiene etiquetas y campos de texto para los
operandos y el resultado. La operación se selecciona en el menú:
P.O.O Tema 6 – Interfaces gráficas de usuario - 83
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Gui22 extends JFrame {
Container panel;
JTextField jtfNum1, jtfNum2, jtfResult;
JMenuItem jmiSuma, jmiResta, jmiMul, jmiDiv, jmiCerrar;
public Gui22() {
super("Menús");
JMenuBar jmb = new JMenuBar();
setJMenuBar(jmb);
JMenu operationMenu = new JMenu("Operación");
operationMenu.setMnemonic('O'); // Letra distinguida
jmb.add(operationMenu);
operationMenu.add(jmiSuma = new JMenuItem("Suma", 'S'));
operationMenu.add(jmiResta = new JMenuItem("Resta", 'R'));
operationMenu.add(jmiMul = new JMenuItem("Multiplica",'M'));
operationMenu.add(jmiDiv = new JMenuItem("Divide", 'D'));
Otro ejemplo
...
22. P.O.O Tema 6 – Interfaces gráficas de usuario - 84
JMenu exitMenu = new JMenu("Salir");
jmb.add(exitMenu);
exitMenu.add(jmiCerrar = new JMenuItem("Cerrar", 'C'));
JPanel p1 = new JPanel();
p1.setLayout(new FlowLayout());
p1.add(new JLabel("Número 1"));
p1.add(jtfNum1 = new JTextField(3));
p1.add(new JLabel("Número 2"));
p1.add(jtfNum2 = new JTextField(3));
p1.add(new JLabel("Resultado"));
p1.add(jtfResult = new JTextField(4));
jtfResult.setEditable(false);
getContentPane().setLayout(new BorderLayout());
getContentPane().add(p1, BorderLayout.CENTER);
// Registramos oyentes
jmiSuma.addActionListener(new OyenteMenu());
jmiResta.addActionListener(new OyenteMenu());
jmiMul.addActionListener(new OyenteMenu());
jmiDiv.addActionListener(new OyenteMenu());
jmiCerrar.addActionListener(new OyenteMenu());
}
Otro ejemplo
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 85
public static void main(String args[]) {
Gui22 ventana = new Gui22();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.pack();
ventana.setVisible(true);
}
private void calculate(char operator) {
int num1 = (Integer.parseInt(jtfNum1.getText().trim()));
int num2 = (Integer.parseInt(jtfNum2.getText().trim()));
int result = 0;
switch (operator) {
case '+': result = num1 + num2; break;
case '-': result = num1 - num2; break;
case '*': result = num1 * num2; break;
case '/': result = num1 / num2;
}
jtfResult.setText(String.valueOf(result));
}
Otro ejemplo
...
P.O.O Tema 6 – Interfaces gráficas de usuario - 86
class OyenteMenu implements ActionListener {
public void actionPerformed(ActionEvent e) {
String actionCommand = e.getActionCommand();
if(e.getSource() instanceof JMenuItem) {
if("Suma".equals(actionCommand)) calculate('+');
else if("Resta".equals(actionCommand)) calculate('-');
else
if("Multiplica".equals(actionCommand)) calculate('*');
else if("Divide".equals(actionCommand)) calculate('/');
else if("Cerrar".equals(actionCommand)) System.exit(0);
}
}
}
}
Otro ejemplo
Gui22.java
P.O.O Tema 6 – Interfaces gráficas de usuario - 87
Clases adaptadoras
class OyenteRaton implements MouseListener {
public void mouseClicked(MouseEvent e) {
lista.add("click..");
}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
}
¡ Poco eficiente, sólo implementamos un método !
23. P.O.O Tema 6 – Interfaces gráficas de usuario - 88
Clases adaptadoras
class OyenteRatonconAdap extends MouseAdapter {
// La clase adaptadora MouseAdapter
// se encargan de implementar todos los métodos
// de la clase de escucha. Sólo necesitaremos
// redefinir aquellos métodos que nos van a ser útiles
// para gestionar eventos , sin preocuparnos del resto
public void mouseClicked(MouseEvent e) {
//redefinido
lista.add("click..");
}
}
P.O.O Tema 6 – Interfaces gráficas de usuario - 89
Clases adaptadoras
Si por ejemplo una de nuestras clases implementa la interfaz
WindowListener, deberá implementar todos los métodos asociados,
aún cuando sólo utilicemos uno de ellos.
Las clases adaptadoras se encargan de implementar todos los
métodos del la clase de escucha. Así sólo necesitaremos redefinir
aquellos métodos que nos van a ser útiles para gestionar eventos , sin
preocuparnos del resto.
Para ello dedemos indicar que nuestra clase es una subclase del
adaptador:
class UnaClase extends Adaptador{ ... }
P.O.O Tema 6 – Interfaces gráficas de usuario - 90
Clases adaptadoras
class MiAdaptador extends WindowAdapter {
public void windowClosing(windowEvent e) {
System.exit(0);
}
}
. . .
this.addWindowListener(new MiAdaptador());
. . .
P.O.O Tema 6 – Interfaces gráficas de usuario - 91
Clases adaptadoras
Sólo las clases que poseen más de un método tienen adaptador , y
son las siguientes:
ComponentListener posee ComponentAdapter
ContainerListener posee ContainerAdapter
FocusListener posee FocusAdapter
KeyListener posee KeyAdapter
MouseListener posee MouseAdapter
MouseMotionListener posee MouseMotionAdapter
WindowListener posee WindowAdapter
24. P.O.O Tema 6 – Interfaces gráficas de usuario - 92
Ejemplo
public class Gui17b extends JFrame {
JButton boton; List lista; Container panel;
public Gui17b(){
panel =this.getContentPane();
panel=getContentPane();
panel.setLayout(new FlowLayout());
lista = new List(8,false );
lista.setBounds(100,50,150,150);
add(lista );
this.addMouseListener(new OyenteAdaptador());
setSize(100,100);setVisible(true);
}
class OyenteAdaptador extends MouseAdapter {
public void mouseClicked(MouseEvent e) {
lista.add("click..");
}} . . .
P.O.O Tema 6 – Interfaces gráficas de usuario - 93
Arquitectura MVC (Modelo-Vista-Controlador)
La arquitectura MVC es una arquitectura típica de diseño de GUI.
El modelo representa la estructura lógica de la GUI,
independientemente de su representación visual.
La vista constituye la representación visual de la GUI.
El controlador constituye la lógica de interacción con el usuario.
El mejor modelo separa en las tres partes:
public static void main(String args[]) {
Modelo modelo = new Modelo();
Controlador controlador = new Controlador(modelo);
GUI gui = new GUI(controlador); }
Applet mínimo con Swing (JApplet)
//MiApplet.java
import java.swing.*;
class MiApplet extends JApplet { }
//MiApplet.html
<HTML>
<HEAD><TITLE>Applet mínima</TITLE> </HEAD>
<BODY>
<APPLET CODE="MiApplet.class" WIDTH=100 HEIGHT=50>
</APPLET>
</BODY>
</HTML>
AppletViewer Navegador
Anchura y altura
en píxeles
Tema 6 – Interfaces gráficas de usuario - 94P.O.O
Esquema de applet con swing
import javax.swing.*
import java.awt;
public class Applet0 extends JApplet {
// constantes y componentes (atributos)
public void init() {
// configurar componentes
// configurar layout;
// configurar Manejadores Eventos;
}
}
Tema 6 – Interfaces gráficas de usuario - 95P.O.O
25. Ejemplo
import javax.swing.*;
import java.awt.*;
public class Applet01 extends JApplet
{
JLabel etiqueta;
public void init(){
// configurar componentes;
etiqueta = new JLabel("Mi primer Applet Swing");
add(etiqueta);
// configurar layout;
FlowLayout milayout = new FlowLayout();
setLayout(milayout);
...
}
}
Tema 6 – Interfaces gráficas de usuario - 96P.O.O