Beruflich Dokumente
Kultur Dokumente
Ingeniería en Mecatrónica
9° Sem. “A”
Programación Avanzada
Investigación tema 5 y 6
Integrantes:
Contreras Peruyero Sergio Arturo 140I0381
1
Índice
Introducción .................................................................................................................................................. 3
Contenido ...................................................................................................................................................... 4
Tema 5 Programación Visual ..................................................................................................................... 4
5.2 Objetos Controles y componentes .................................................................................................. 4
5.3 Tecnología .NET ............................................................................................................................. 14
5.4 Entorno integrado de desarrollo ................................................................................................... 17
5.5 Tipos de proyectos ........................................................................................................................ 18
Tema 6 Formas, controles y eventos ...................................................................................................... 20
6.1 Controles estándar ........................................................................................................................ 20
5.2 Eventos y propiedades del formulario. ......................................................................................... 22
6.3 Tipos de Formulario....................................................................................................................... 24
6.4 Control de Eventos. ....................................................................................................................... 26
6.5 Cajas de Dialogo ............................................................................................................................ 29
Conclusiones................................................................................................................................................ 34
Fuentes consultadas .................................................................................................................................... 35
2
Introducción
Una interfaz gráfica de usuario (GUI) presenta un mecanismo amigable al usuario para interactuar
con una aplicación. Una GUI proporciona una “apariencia visual” única. Al proporcionar distintas
aplicaciones en las que los componentes de la interfaz de usuario sean consistentes e intuitivos,
los usuarios pueden familiarizarse en cierto modo con una aplicación, de manera que pueden
aprender a utilizarla en menor tiempo y con mayor productividad.
3
Contenido
Debajo de los botones hay un cuadro combinado; donde el usuario puede escribir el nombre de
un sitio Web a visitar, o hacer clic en la Flecha hacia abajo, que se encuentra del lado derecho,
para ver una lista de los sitios visitados previamente. Los menús, botones y el cuadro combinado
son parte de la GUI de Internet Explorer. Éstos le permiten interactuar con el navegador Web.
Las GUIs se crean a partir de componentes de la GUI. A éstos se les conoce también como
controles o widgets (accesorios de ventana) en otros lenguajes. Un componente de la GUI es
4
un objeto con el cual interactúa el usuario mediante el ratón, el teclado u otra forma de entrada,
como el reconocimiento de voz.
5
JList Proporciona una lista de elementos a partir de los cuales el usuario puede
realizar una selección, haciendo clic en cualquier elemento en la lista. Pueden
seleccionarse varios elementos.
JPanel Proporciona un área en la que pueden colocarse y organizarse los
componentes. También puede utilizarse como un área de dibujo para gráficos
Tabla 5. 1
Object
Component
Container
JComponent
La clase Component (java.awt) es una subclase de Object que declara muchos de los atributos y
comportamientos comunes para los componentes de GUI en los paquetes java.awt y java.swing.
La mayoría de los componentes GUI extienden la clase Component de manera directa o indirecta.
La clase Container (paquete java.awt) es una subclase Component. Los objetos Component se
adjuntan a objetos Container (como las ventanas), de manera que los objetos component se
pueden organizar y mostrar en la pantalla. Cualquier objeto que sea un Container se puede utilizar
para organizar u otros objetos Container para ayudar a organizar una GUI.
6
import javax.swing.SwingConstants; // constantes comunes utilizadas con Swing
import javax.swing.Icon; // interfaz utilizada para manipular imágenes
import javax.swing.ImageIcon; // carga las imágenes
Prueba de LabelFrame
// PruebaLabel.java
// Prueba de LabelFrame.
import javax.swing.JFrame;
7
Componentes de GUI básicos
Constante Descripción
Constantes de posición horizontal
SwingConstantes.LEFT Coloca el texto a la izquierda
SwingConstantes.CENTER Coloca el texto en el centro
SwingConstantes.RIGHT Coloca el texto a la derecha
// CampoTextoMarco.java
// Demostración de la clase JTextField.
import java.awt.FlowLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.JPasswordField;
import javax.swing.JOptionPane;
8
// El constructor de CampoTextoMarco agrega objetos JTextField a JFrame
public CampoTextoMarco()
{
super( "Prueba de JTextField y JPasswordField" );
setLayout( new FlowLayout() ); // establece el esquema del marco
9
cadena = String.format( "campoContrasenia: %s",
new String( campoContrasenia.getPassword() ) );
Prueba de CampoTextoMarco
// PruebaCampoTexto.java
// Prueba de CampoTextoMarco.
import javax.swing.JFrame;
Invocación del manejador de eventos. Cada tipo de evento tiene uno o más interfaces de escucha
de eventos de interfaces de escucha de eventos correspondientes. Por ejemplo, los eventos tipo
ActionEvent son manejados por objetos MouseListener y MouseMotionListener, y los eventos tipo
KeyEvent son manejados por objetos MouseListener y MouseMotionListener, y los eventos
KeyEvent son manejados por objetos KeyListener.
10
Figura 5. 2
11
// crea nuevo ManejadorBoton para manejar los eventos de botón
ManejadorBoton manejador = new ManejadorBoton();
botonJButtonElegante.addActionListener( manejador );
botonJButtonSimple.addActionListener( manejador );
} // fin del constructor de MarcoBoton
12
// El constructor de MarcoCasillaVerificacion agrega objetos JCheckBox a
JFrame
public MarcoCasillaVerificacion()
{
super( "Prueba de JCheckBox" );
setLayout( new FlowLayout() ); // establece el esquema del marco
13
Prueba de MarcoCasillaVerificación
// PruebaCasillaVerificacion.java
// Prueba de MarcoCasillaVerificacion.
import javax.swing.JFrame;
Evolución de .NET
La informática se inició con programas monousuarios implantados en grandes ordenadores.
Posteriormente estas primeras aplicaciones alcanzaron la capacidad de atender a diferentes
usuarios. Pasaron los años y llegó la arquitectura cliente-servidor, que, gracias a este modelo de
desarrollo, la aplicación se dividía en una parte que interaccionaba con el usuario y otra parte
destinada al procesamiento de información. Esto consiguió que cada una de las partes que
constituían la aplicación pudiera residir en computadoras distintas.
14
A mediado de la década de los 90 y con la aparición de Internet y su posterior masificación a
niveles jamás pensados, ha existido siempre la necesidad e inquietud por parte de las empresas
desarrolladoras de software de buscar o contar con la manera de lograr la integración entre
sistemas heterogéneos, tanto de software como de hardware. Para tal efecto mucha s compañías
fueron creando de forma individual la mejor manera de lograr esta integración. Muchas empresas
comenzaron una loca carrera para generar la mejor tecnología integradora de sistemas, pero a
medida que la competencia se hacía más fuerte, la integración se hacía cada vez más difícil.
Así que las empresas decidieron atacar el problema de raíz. Para ello en lugar de crear la mejor
plataforma integradora, mejor sería buscar un lenguaje común de intercambio de información
aprovechando los estándares existentes en el mercado.
Consiente de todo este hecho, Microsoft quiso aprovechar la oportunidad para desarrollar una
tecnología llamada Microsoft .NET para generar un marco de trabajo en el que está inundado por
la palabra "Servicios" y .NET es: ofrecer servicios informáticos a través de redes TCP/IP y Web,
pero que fuera aprovechado por cualquier lenguaje de programación que se ciñera a sus
estándares.
15
lenguaje de programación de su elección con funcionalidad completa y habilidad de interaccionar
entre componentes y servicios creados con un alto nivel de encapsulación e independencia entre
aplicaciones.
El resultado es el .NET Framework que es un conjunto de clases expuestas para que, quien
requiera, haga uso de funcionalidad. Este cúmulo de clases conforma un estándar abierto que
puede integrarse a cualquier plataforma que no solo incluye los lenguajes de Visual Sttudio.NET,
sino que hay mas de 20 lenguajes de otros fabricantes que pueden funcionar en él, como Pascal
.NET, Cobol .NET, y muchos otros, convirtiendo a .NET en una de las plataformas mas poderosas
para el desarrollo de aplicaciones distribuidas del Web. Cuyo principio básico, es el de ofrecer a
través de internet no solo datos, sino también software y servicios que son fácilmente accesibles
por PC’s, teléfonos móviles, asistentes personales digitales y al mismo tiempo facilitan la
comunicación entre ellos y búsqueda e integración de información en la Web, en cualquier
momento y desde cualquier dispositivo.
Finalidades de .NET
.NET representa la visión de Microsoft, del software como un servicio, habiendo sido diseñada con
Internet en mente, cubre todas las capas del desarrollo de software, existiendo una alta integración
entre las tecnologías de presentación, de componentes y de acceso a datos.
16
.NET intenta poner un cierto orden sobre el caos existente al interior de la plataforma para el
desarrollo de aplicaciones distribuidas, denominada Windows DNA (Distributed Network
Applications - Aplicación de Redes Distribuidas), la cual se basa en un modelo de tres capas, con
ASP en la capa de presentación, COM en la capa de objetos de negocio y ADO en la capa de
datos; dicha plataforma tenía como problema que el desarrollo con COM era complejo y poseía
una integración con ASP un tanto artificiosa. Microsoft con .Net a creado un entorno de desarrollo
que permita entender y mejorar estos problemas. Por ello es importante comprender cuales son
las finalidades de la plataforma y estas son:
➢ Mantener estándares abiertos de Internet con XML, HTTP, SOAP, UDDI. El reto de
Microsoft es proporcionar la mejor implementación en el mercado para estos estándares
con sus productos y herramientas.
➢ Servicios Web XML mediante componentes de software, que puedan accederse de
manera programática a través del Web, logrando potencializar las aplicaciones.
➢ Proporcionar mecanismos de integración para que una empresa pueda ofrecer
servicios a otras empresas o clientes de una forma sencilla y rápida, ya sea de manera
interna o expuesta a través de Internet. XML y SOAP son tecnologías que permiten esta
integración.
➢ Modelo de programación simple y consistente permitiendo a desarrolladores centrarse
en la lógica de la aplicación, ofreciendo herramientas y tecnologías mediante el soporte
de estándares sobre los cuales se basan los servicios Web.
➢ Liberar al programador de las cuestiones de infraestructura es decir de los aspectos
no funcionales.
➢ Proporcionar soporte para arquitecturas fuertemente acopladas y débilmente
acopladas. Para conseguir un buen rendimiento, escalabilidad y confiabilidad con
grandes sistemas distribuidos.
17
Un IDE es un entorno de programación que ha sido empaquetado como un programa de
aplicación; es decir, consiste en un editor de código, un compilador, un depurador y un constructor
de interfaz gráfica (GUI). Los IDEs pueden ser aplicaciones por sí solas o pueden ser parte de
aplicaciones existentes.
Los IDE proveen un marco de trabajo amigable para la mayoría de los lenguajes de programación
tales como C++, PHP, Python, Java,C#, Delphi, Visual Basic, etc. En algunos lenguajes, un IDE
puede funcionar como un sistema en tiempo de ejecución, en donde se permite utilizar el lenguaje
de programación en forma interactiva, sin necesidad de trabajo orientado a archivos de texto,
como es el caso de Smalltalk u Objective-C.
18
Proyectos apoyados por pequeñas subvenciones. Las ayudas económicas provienen del equipo de
investigación y el gobierno. Los funcionarios del gobierno intervienen para que las actividades se
cumplan y a si vez opinan sobre cómo se debe administrar el proyecto. Se emplean algunos
elementos del proyecto central.
Proyectos apoyados exclusivamente por el gobierno. El apoyo económico solo proviene del estado
pero incluye algunos elementos del proyecto central. La comunidad igualmente presta ayuda en
la ejecución de las actividades.
Proyectos de investigación
Tiene relaciones con la teoría existente en el tema y a su vez con el mundo empírico, de esta
forma se planea lo que se pretende investigar. Sus partes son: planteamiento o formulación del
problema, antecedentes, importancia o justificación del estudio, elementos teóricos que
fundamenten la investigación, objetivos (generales y específicos), metodología, esquema o plan
de trabajo, cronograma y referencias.
Proyectos de inversión
Están relacionadas con la empresa y la parte comercial los hay de varias clases: Inversión
privada: consiste en crear un plan que permita obtener una rentabilidad económica a partir de la
inversión de un capital. Inversión pública: El estado invierte recursos para lograr el bienestar
social de una comunidad a la vez que beneficio económico.
Inversión social: Se busca invertir bienes en el desarrollo exclusivamente social sin esperar
remuneración económica, sino que los beneficios permanezcan después de acabado el proyecto.
Proyectos de infraestructura
Se invierte en obras civiles, se construye infraestructura que aporte beneficios económicos o
sociales.
Proyectos sociales
Su único fin es mejorar la calidad de vida de una comunidad en sus necesidades básicas como
salud, educación, empleo y vivienda. El proyecto pronostica y orienta una serie de actividades
para conseguir unos determinados objetivos. Debe contener una descripción de lo que quiere
conseguir, debe ser adaptado al entorno en que se piensa desarrollar, los recursos necesarios
para desarrollarlo y el cronograma en el que se establece el plazo de su ejecución.
19
Proyectos de desarrollo sostenible
Es un proyecto social y económico de una comunidad que incluye ecología o del medio ambiente
como un elemento importante tanto para mejorar la economía como para ser protegido durante
un largo periodo. Este tipo de proyectos surgió en torno al deterioro en el medio ambiente y la
intención de que la producción humana no lo impacte de forma negativa. También busca la
participación equitativa de la sociedad en estos procesos.
20
Figura 6. 2 Componentes estándar GUI en NetBeans JAVA
Los componentes ligeros de Swing no están enlazados a los componentes actuales de GUI que
soporte la plataforma subyacente en la que se ejecuta una aplicación. Varios componentes de
Swing son componentes pesados, que requieren una interacción directa con el sistema de
ventanas local, lo cual puede restringir su apariencia y funcionalidad.
21
Mostrar texto e imágenes en una ventana
La mayoría de las ventanas son instancias de la clase JFrame o una subclase de JFrame. JFrame
proporciona los atributos y comportamientos básicos de una ventana. Un objeto JLabel muestra
una sola línea de texto de sólo lectura, una imagen, o texto y una imagen. Por lo general, el texto
en un objeto JLabel usa la capitalización estilo oración. Al crear una GUI, cada componente de
ésta debe adjuntarse a un contenedor, como una ventana creada con un objeto JFrame.
Muchos IDEs proporcionan herramientas de diseño de GUIs, en las cuales podemos especificar
el tamaño y la ubicación exactos de un componente mediante el uso del ratón, y después el IDE
genera el código de la GUI por nosotros.
El método getClass (de la clase Object) obtiene una referencia al objeto Class que representa la
declaración de la clase para el objeto en el que se hace la llamada al método. El método
getResource de Class devuelve la ubicación de su argumento en forma de URL. El método
getResource usa el cargador de clases del objeto Class para determinar la ubicación del recurso.
La interfaz SwingConstants (paquete javax.swing) declara un conjunto de constantes enteras
comunes que se utilizan con muchos componentes de Swing.
Las alineaciones horizontal y vertical de un objeto JLabel se pueden establecer mediante los
métodos setHorizontalAlignment y setVerticalAlignment, respectivamente. El método setText de
JLabel establece el texto a mostrar en una etiqueta. El correspondiente método getText obtiene
el texto actual que se muestra en una etiqueta.
22
nuevos conceptos de la GUI y una clase de aplicación, en la que main crea y muestra la ventana
principal de la aplicación.
Una GUI típica consiste en muchos componentes. En una GUI extensa, puede ser difícil identificar
el propósito de cada componente, a menos que el diseñador de la GUI proporcione instrucciones
de texto o información que indique el propósito de cada componente. Dicho texto se conoce como
etiqueta y se crea con la clase JLabel; una subclase de JComponent. Un objeto JLabel muestra
una sola línea de texto de sólo lectura, una imagen, o texto y una imagen. Raras veces las
aplicaciones modifican el contenido de una etiqueta, después de crearla.
Por lo general, un usuario interactúa con la GUI de una aplicación para indicar las tareas que ésta
debe realizar. Por ejemplo, cuando usted escribe un mensaje en una aplicación de correo
electrónico, al hacer clic en el botón Enviar le indica a la aplicación que envíe el correo electrónico
a las direcciones especificadas. Las GUIs son controladas por eventos. Cuando el usuario
interactúa con un componente de la GUI, la interacción (conocida como un evento) controla el
programa para que realice una tarea. Algunos eventos (interacciones del usuario) comunes que
podrían hacer que una aplicación realizara una tarea incluyen el hacer clic en un botón, escribir
en un campo de texto, seleccionar un elemento de un menú, cerrar una ventana y mover el ratón.
El código que realiza una tarea en respuesta a un evento se llama manejador de eventos y al
proceso en general de responder a los eventos se le conoce como manejo de eventos.
Las GUIs se controlan por eventos; cuando el usuario interactúa con un componente de GUI, los
eventos controlan al programa para realizar las tareas. El código que realiza una tarea en
respuesta a un evento se llama manejador de eventos, y el proceso general de responder a los
eventos se conoce como manejo de eventos.
23
El método setEditable de JTextComponent puede usarse para hacer que un campo de texto no
pueda editarse. Antes de que una aplicación pueda responder a un evento para un componente
específico de la GUI, debemos realizar varios pasos de codificación: 1) Crear una clase que
represente al manejador de eventos. 2) Implementar una interfaz apropiada, conocida como
interfaz de escucha de eventos, en la clase del paso 1. 3) Indicar que se debe notificar a un objeto
de la clase de los pasos 1 y 2 cuando ocurra el evento. A esto se le conoce como registrar el
manejador de eventos.
Las clases anidadas pueden ser static o no static. Las clases anidadas no static se llaman clases
internas, y se utilizan con frecuencia para el manejo de eventos. Antes de poder crear un objeto
de una clase interna, debe haber primero un objeto de la clase de nivel superior, que contenga a
la clase interna, ya que un objeto de la clase interna tiene de manera implícita una referencia a
un objeto de su clase de nivel superior.
Un objeto de la clase interna puede acceder directamente a todas las variables de instancia y
métodos de su clase de nivel superior. Una clase anidada que sea static no requiere un objeto de
su clase de nivel superior, y no tiene de manera implícita una referencia a un objeto de la clase
de nivel superior. Cuando el usuario oprime Intro en un objeto JTextField o JPasswordField, el
componente de la GUI genera un evento ActionEvent (paquete java.awt.event). Dicho evento se
procesa mediante un objeto que implementa a la interfaz ActionListener (paquete java.awt.event).
El método addActionListener de JTextField registra el manejador de eventos para un campo de
texto de un componente. Este método recibe como argumento un objeto ActionListener.
El componente de GUI con el que interactúa el usuario es el origen del evento. Un objeto
ActionEvent contiene información acerca del evento que acaba de ocurrir, como el origen del
evento y el texto en el campo de texto. El método getSource de ActionEvent devuelve una
referencia al origen del evento. El método getActionCommand de ActionEvent devuelve el texto
que escribió el usuario en un campo de texto o en la etiqueta de un objeto JButton. El método
getPassword de JPasswordField devuelve la contraseña que escribió el usuario.
24
JFrame y JDialog
Los dos tipos de ventanas principales que tenemos en java son JFrame y JDialog. Hay varias
diferencias entre ellas y en función de estas diferencias vamos a ver para qué sirven: Si
instanciamos un JFrame, en la barra de abajo de windows (creo que se llama "barra de
herramientas") nos aparece un nuevo "botoncito" correspondiente a nuestra aplicación. Si
instanciamos un JDialog, no aparece nada. Un JFrame tiene un método setIconImage() para
cambiar el icono por defecto de la taza de café. JDialog no tiene este método. Un JDialog admite
otra ventana (JFrame o JDialog) como padre en el constructor. JFrame no admite padres. Un
JDialog puede ser modal, un JFrame no.
Otra ventaja de admitir un padre es que heredan el icono de él. Si hemos cambiado el icono del
JFrame con el método setIconImage(), entonces todos los JDialog que hagamos como hijos de
este JFrame heredarán el icono. Todas las ventanas de nuestra aplicación tendrán el mismo
icono en lugar de la taza de café por defecto.
25
JOptionPane
Para hacer ventanas sencillas que avisen de un error al usuario y tengan un botón de "Cerrar", o
que le pidan una confirmación para hacer algo (como borrar un fichero) y tengan dos botones de
"Si" y "No", o para pedirle que elija una opción entre varias disponibles ... tenemos suerte. No hay
que construir la ventana.
Ahora viene el dato importante. Esta ventana es modal y admite un padre. Si ya hay una ventana
modal visible en pantalla, deberías pasar esa ventana como padre de esta para no tener
problemas.
JInternalFrame
El JInternalFrame es una ventana especial que ni es ventana ni es nada. De hecho, no hereda
de Window. En realidad, es un componente java que se dibuja dentro de otro componente, pero
adornado con la barra de título de una ventana y sus botones de maximizar, minimizar y cerrar.
Puede incluso arrastrarse y modificarse de tamaño siempre que se mete dentro del componente
adecuado.
El sitio bueno para meter los JInternalFrame es el JDesktopPane. Este panel admite
JInternalFrame y sabe manejarlos. En este código el JInternalFrame se comportará como una
ventana, pero que no puede salirse del JDesktop que la contiene.
26
Figura 6. 3 Clases de Eventos del paquete java.awt.event.
Todo objeto JComponent tiene una variable de instancia llamada listenerList, la cual hace
referencia a un objeto de la clase EventListenerList (paquete javax.swing.event). Cada objeto de
una subclase de JComponent mantiene las referencias a todos sus componentes de escucha
registrados en la variable listenerList.
27
Todo componente de la GUI soporta varios tipos de eventos, incluyendo los eventos de ratón, de
teclado y otros. Cuando ocurre un evento, éste se despacha sólo a los componentes de escucha
de eventos del tipo apropiado.
Registro de eventos
Todo JComponent tiene una variable de instancia llamada listenerList, que hace referencia a un
objeto de la clase EventListenerList (paquete javax.swing.event). Cada objeto de una subclase
de JComponent mantiene referencias a todos sus componentes de escucha registrados en
listenerList.
Cada tipo de evento tiene uno o más interfaces de escucha de eventos correspondientes. Por
ejemplo, los eventos tipo ActionEvent son manejados por objetos ActionListener, los eventos tipo
MouseEvent son manejados por objetos MouseListener y MouseMotionListener, y los eventos
tipo KeyEvent son manejados por objetos KeyListener. Cuando ocurre un evento, el componente
de la GUI recibe (de la JVM) un ID de evento único, el cual especifica el tipo de evento. El
componente de la GUI utiliza el ID de evento para decidir a cuál tipo de componente de escucha
debe despacharse el evento, y para decidir cuál método llamar en cada objeto de escucha. Para
un ActionEvent, el evento se despacha al método actionPerformed de todos los objetos
ActionListener registrados (el único método en la interfaz ActionListener). En el caso de un
MouseEvent, el evento se despacha a todos los objetos MouseListener o MouseMotionListener
registrados, dependiendo del evento de ratón que ocurra. El ID de evento del objeto
28
MouseListener determina cuáles de los varios métodos manejadores de eventos de ratón son
llamados.
Hay que distinguir los cuadros modales de los no modales, siendo los primeros los que necesitan
que el usuario responda antes de continuar el programa, y los segundos los que permanecen en
la pantalla y están disponibles para ser utilizados, aunque permiten que el usuario siga trabajando
con el programa.
29
Para crear cuadros de diálogo utilizamos el objeto JOptionPane, y en función del método
a elegir, mostrará un tipo u otro.
showMessageDialog
para probar esté método, lo único que haremos será crear una clase con un método main,
vamos a suponer que la clase se llama, MessageDialog:
Tenemos que importar la clase JOptionPane, aunque normalmente netbeans lo hace por
nosotros. Una vez importado lo único que tenemos que hacer es teclear el nombre de la
clase más el método que queremos utilizar, teniendo en cuenta una cosa, el método
showMessageDialog tiene 3 sobrecargas del método, uno que recibe 2 parámetros, otro
de 4, y otro de 5, vamos a ver uno por uno para observar cómo vamos personalizando
cada vez más nuestro mensaje, el primero que veremos es el de dos parametros:
30
Figura 6. 8 Mensaje mostrado
showInputDialog
Bien, para trabajar con el showInputDialog, vamos a crear nuevamente una clase a la
cual le llame InputDialog nuevamente con un método main:
El inputDialog contiene varias sobrecargas del método, los cuales tienen los siguientes
parametros y TODOS (Con excepción del ultimo) devuelven un String:
Figura 6. 10 inputDialog
31
showConfirmDialog
Una vez que hemos dominado los métodos anteriores, utilizar un showConfirmDialog es
sencillo, cuenta con cuatro sobrecargas del método, y los veremos de manera rápida,
para esto se hará una clase con cualquier nombre (en este caso showConfirmDialog).
Figura 6. 12 ShowConfirmDialog
showOptionDialog
El método anterior, nos enseñó una manera de darle a escoger al usuario más de una
opción en una ventana de dialogo, como una manera más personalizada de hacer esto,
podemos utilizar el método showOptionDialog que nos proporciona JOptionPane, este
método no tiene sobrecarga y cuenta con los siguientes parámetros.
Figura 6. 14 ShowOptionDialog
Los únicos que hay que dejar en claro después son el tipo de selección, que utilizamos
un tipo de selección como el del showConfirmDialog, el tipo de mensaje que ya sabemos
32
cuál es, y las opciones que es un arreglo con las opciones que se le mostraran al usuario
y, por último, el valor por default, cabe destacar que este método devuelve un valor en int
del valor que haya seleccionado el usuario, por ejemplo:
33
Conclusiones
Una interfaz gráfica de usuario (GUI) presenta un mecanismo amigable al usuario para interactuar
con una aplicación. Una GUI proporciona a una aplicación una “apariencia visual” única. Al
proporcionar distintas aplicaciones en las que los componentes de la interfaz de usuario sean
consistentes e intuitivos, los usuarios pueden familiarizarse en cierto modo con una aplicación,
de manera que pueden aprender a utilizarla en menor tiempo y con mayor productividad. Las
GUIs se crean a partir de componentes de GUI; a éstos se les conoce algunas veces como
controles o “widgets”.
Es indispensable conocer todas las herramientas que nos proporciona una IDE de programación,
para lograr programar de la mejor manera y más eficiente, ahorrando tiempo y espacio en
memoria a la hora de programar.
Las GUIs proporcionan una manera fácil de hacer aplicaciones visuales para los usuarios, y
tengan un entorno más amigable a la hora de interactuar con estas aplicaciones, un programador
experimentado podría interactuar a través de la consola o cmd de una computadora como si nada,
pero un usuario normal sin conocimientos, se le dificultaría mucho por no decir que no lo podría
hacer, para eso entran las GUIs, para que los usuarios puedan interactuar con el programa de
forma amigable y rápida.
34
Fuentes consultadas
DEITEL, P. J. (2008). Java como programar. Septima Edición. Mexico: PEARS ON EDUCACIÓN.
35