investigacion programacion visual

Instituto Instit uto Tecnol Tecnológi ógico co Superior de Ma Martínez de la Torr Torr e

Ingeniería en en Mecatr Mecatrón ónic ica a

9° Sem. “A”

Progr ro gra amación Ava Av anzada nzada Investigación tema 5 y 6

Programa rog ramación ción Visua isu al y Form as Controles Contro les y Eventos. Integrantes: Contreras Peruyero Sergio Arturo 140I0381

M.R.Y.S.I. Ángel Salas Martínez

Martínez de la Torre, Ver (01/12/2017)

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. La programación visual brinda los conocimientos necesarios para diseñar y desarrollar aplicaciones con un entorno visual amigable y fáciles de utilizar por el usuario. Los lenguajes de programación visual, como Visual Java, hacen sencilla la tarea de los programadores porque antes constituía una gran demora tiempo en el diseño de ventanas o formularios.

3

Contenido Tema 5 Programaci ón Visual 5.2 Objetos Controles y componentes

Como ejemplo de una GUI, en la Figura 5.1 se muestra una ventana del navegador Web Microsoft Internet Explorer, con algunos componentes de la GUI etiquetados. En la parte superior hay una barra de título que contiene el título de la ventana. Debajo de la barra de título hay una barra de menús que contiene menús (Archivo, Edición, Ver, etcétera). Debajo de la barra de menús hay un conjunto de botones que el usuario puede oprimir para realizar tareas en Internet Explorer. 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.

Figura 5. 1 Ventana de Microsoft Internet Explorer con sus componentes de la GUI.

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. ClaseJOptionPanedeJava(paquetejavax.swing).

Proporciona cuadros de diálogo preempaquetados para entrada y salida. Estos diálogos se muestran mediante la invocación de los métodos static de JOptionPane. Ejm. // Suma.java // Programa de suma que utiliza a JOptionPane para entrada y salida. import javax.swing.JOptionPane; // el programa usa JOptionPane public class Suma { public static void main( String args[] ) { // obtiene la entrada del usuario de los diálogos de entrada de JOptionPane String primerNumero = JOptionPane.showInputDialog( "Introduzca el primer entero" ); String segundoNumero = JOptionPane.showInputDialog( "Introduzca el segundo entero" ); // convierte las entradas String en valores int para usarlos en un cálculo int numero1 = Integer.parseInt( primerNumero ); int numero2 = Integer.parseInt( segundoNumero ); int suma = numero1 + numero2; // suma números // muestra los resultados en un diálogo de mensajes de JOptionPane JOptionPane.showMessageDialog( null, "La suma es " + suma, "Suma de dos enteros", JOptionPane.PLAIN_MESSAGE ); } // fin del método main } // fin de la clase Suma

ComponentesbásicosdeGUI

JLabel

Muestra texto que no puede editarse, o iconos

JTextField

Permite al usuario introducir datos mediante el teclado. También se puede utilizar para mostrar texto que puede o no editarse

JButton

Activa un evento cuando se oprime mediante el ratón

JCheckBox

Especifica una opción que puede seleccionarse o no

JComboBox Proporciona una lista desplegable de elementos, a partir de los cuales el usuario puede realizar una selección, haciendo clic en un elemento o posiblemente escribiendo e el cuadro.

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

SuperclasesdeloscomponentesdeGUI.

El siguiente diagrama de clases UML, muestra una jerarquía de herencia que contiene clases a partir de las cuales los componentes Swing 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. La clase JComponent (javax.swing) es una subclase de Container. JComponent es la superclase de todos los componentes ligeros de Swing, y declara los atributos y comportamientos comunes. Debido a que jComponent es una subclase de Container, todos los componentes ligeros de Swing son también objetos Container. Demostración de la clase JLabel // LabelFrame.java // Demostración de la clase JLabel. import java.awt.FlowLayout; // especifica cómo se van a ordenar los componentes import javax.swing.JFrame; // proporciona las características básicas de una ventana import javax.swing.JLabel; // muestra texto e imágenes 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 public class LabelFrame extends { private JLabel etiqueta1; // private JLabel etiqueta2; // private JLabel etiqueta3; //

JFrame JLabel sólo con texto JLabel construida con texto y un icono JLabel con texto adicional e icono

// El constructor de LabelFrame agrega objetos JLabel a JFrame public LabelFrame() { super( "Prueba de JLabel" ); setLayout( new FlowLayout() ); // establece el esquema del marco // Constructor de JLabel con un argumento String etiqueta1 = new JLabel( "Etiqueta con texto" ); etiqueta1.setToolTipText( "Esta es etiqueta1" ); add( etiqueta1 ); // agrega etiqueta1 a JFrame // Constructor de JLabel con argumentos de cadena, Icono y alineación Icon insecto = new ImageIcon( getClass().getResource( "insecto1.gif" ) ); etiqueta2 = new JLabel( "Etiqueta con texto e icono", insecto, SwingConstants.LEFT ); etiqueta2.setToolTipText( "Esta es etiqueta2" ); add( etiqueta2 ); // agrega etiqueta2 a JFrame etiqueta3 = new JLabel(); // Constructor de JLabel sin argumentos etiqueta3.setText( "Etiqueta con icono y texto en la parte inferior" ); etiqueta3.setIcon( insecto ); // agrega icono a JLabel etiqueta3.setHorizontalTextPosition( SwingConstants.CENTER ); etiqueta3.setVerticalTextPosition( SwingConstants.BOTTOM ); etiqueta3.setToolTipText( "Esta es etiqueta3" ); add( etiqueta3 ); // agrega etiqueta3 a JFrame } // fin del constructor de LabelFrame } // fin de la clase LabelFrame

Prueba de LabelFrame // PruebaLabel.java // Prueba de LabelFrame. import javax.swing.JFrame; public class PruebaLabel { public static void main( String args[] ) { LabelFrame marcoEtiqueta = new LabelFrame(); // crea objeto LabelFrame marcoEtiqueta.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); marcoEtiqueta.setSize( 275, 180 ); // establece el tamaño del marco marcoEtiqueta.setVisible( true ); // muestra el marco } // fin de main } // fin de la clase PruebaLabel

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

Constantes de posición vertical

SwingConstantes.TOP

Coloca el texto en la parte superior

SwingConstantes.CENTER

Coloca el texto en el centro

SwingConstantes.BOTTOM

Coloca el texto en la parte inferior

Tabla 5. 2

Camposdetextoymanejodeeventosconclasesanidadas.

Las GUIs son controladas por eventos. Cuando el usuario interactúa con un componente de la GUI, la interacción controla el programa para que realice una tarea. El código que realiza una tarea en respuesta a un evento. La clase JTextField extiende a la clase JTextComponent, que proporciona características comunes para los componentes de Swing basados en texto. La clase JPasswordField extiende JTextField y agrega varios métodos específicos para el procesamiento de contraseñas. Cada uno de estos componentes es un área de una sola línea, en el cual el usuario puede introducir texto mediante teclado.

DemostracióndelaclaseJTextField // 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; public class CampoTextoMarco extends JFrame { private JTextField campoTexto1; // campo private JTextField campoTexto2; // campo private JTextField campoTexto3; // campo private JPasswordField campoContrasenia;

8

de de de //

texto texto texto campo

con tamaño fijo construido con texto con texto y tamaño de contraseña con texto

// 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 // construye campo de texto con 10 columnas campoTexto1 = new JTextField( 10 ); add( campoTexto1 ); // agrega campoTexto1 a JFrame // construye campo de texto con texto predeterminado campoTexto2 = new JTextField( "Escriba el texto aqui" ); add( campoTexto2 ); // agrega campoTexto2 a JFrame // construye campo de texto con texto predeterminado y 21 columnas campoTexto3 = new JTextField( "Campo de texto no editable", 21 ); campoTexto3.setEditable( false ); // deshabilita la edición add( campoTexto3 ); // agrega campoTexto3 a JFrame // construye campo de contraseña con texto predeterminado campoContrasenia = new JPasswordField( "Texto oculto" ); add( campoContrasenia ); // agrega campoContrasenia a JFrame // registra los manejadores de eventos ManejadorCampoTexto manejador = new ManejadorCampoTexto(); campoTexto1.addActionListener( manejador ); campoTexto2.addActionListener( manejador ); campoTexto3.addActionListener( manejador ); campoContrasenia.addActionListener( manejador ); } // fin del constructor de CampoTextoMarco // clase interna privada para el manejo de eventos private class ManejadorCampoTexto implements ActionListener { // procesa los eventos de campo de texto public void actionPerformed( ActionEvent evento ) { String cadena = ""; // declara la cadena a mostrar // el usuario oprimió Intro en el objeto JTextField campoTexto1 if ( evento.getSource() == campoTexto1 ) cadena = String.format( "campoTexto1: %s", evento.getActionCommand() ); // el usuario oprimió Intro en el objeto JTextField campoTexto2 else if ( evento.getSource() == campoTexto2 ) cadena = String.format( "campoTexto2: %s", evento.getActionCommand() ); // el usuario oprimió Intro en el objeto JTextField campoTexto3 else if ( evento.getSource() == campoTexto3 ) cadena = String.format( "campoTexto3: %s", evento.getActionCommand() ); // el usuario oprimió Intro en el objeto JTextField campoContrasenia else if ( evento.getSource() == campoContrasenia )

9

cadena = String.format( "campoContrasenia: %s", new String( campoContrasenia.getPassword() ) ); // muestra el contenido del objeto JTextField JOptionPane.showMessageDialog( null, cadena ); } // fin del método actionPerformed } // fin de la clase interna privada ManejadorCampoTexto } // fin de la clase CampoTextoMarco

Prueba de CampoTextoMarco // PruebaCampoTexto.java // Prueba de CampoTextoMarco. import javax.swing.JFrame; public class PruebaCampoTexto { public static void main( String args[] ) { CampoTextoMarco campoTextoMarco = new CampoTextoMarco(); campoTextoMarco.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); campoTextoMarco.setSize( 350, 100 ); // establece el tamaño del marco campoTextoMarco.setVisible( true ); // muestra el marco } // fin de main } // fin de la clase PruebaCampoTexto

Cómofuncionaelmanejo

Registro de Eventos. Todo JComponent tiene una variable de instancia llamada listenerList, que hace referencia a un objeto de la clase EventListenerList (javax.swing.event). Cada objeto de una subclase de JComponent mantiene referencias a todos sus componentes de escucha registrados en listenerList. 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

Botones de Comando y eventos de acción // MarcoBoton.java // Creación de objetos JButton. import java.awt.FlowLayout; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import javax.swing.JFrame; import javax.swing.JButton; import javax.swing.Icon; import javax.swing.ImageIcon; import javax.swing.JOptionPane; public class MarcoBoton extends JFrame { private JButton botonJButtonSimple; // botón con texto solamente private JButton botonJButtonElegante; // botón con iconos // MarcoBoton agrega objetos JButton a JFrame public MarcoBoton() { super( "Prueba de botones" ); setLayout( new FlowLayout() ); // establece el esquema del marco botonJButtonSimple = new JButton( "Boton simple" ); // botón con texto add( botonJButtonSimple ); // agrega botonJButtonSimple a JFrame Icon insecto1 = new ImageIcon( getClass().getResource( "insecto1.gif" ) ); Icon insecto2 = new ImageIcon( getClass().getResource( "insecto2.gif" ) ); botonJButtonElegante = new JButton( "Boton elegante", insecto1 ); // establece la imagen botonJButtonElegante.setRolloverIcon( insecto2 ); // establece la imagen de sustitución add( botonJButtonElegante ); // agrega botonJButtonElegante a JFrame

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 // clase interna para manejar eventos de botón private class ManejadorBoton implements ActionListener { // maneja evento de botón public void actionPerformed( ActionEvent evento ) { JOptionPane.showMessageDialog( MarcoBoton.this, String.format( "Usted oprimio: %s", evento.getActionCommand() ) ); } // fin del método actionPerformed } // fin de la clase interna privada ManejadorBoton } // fin de la clase MarcoBoton

Clase de prueba de MarcoBoton // PruebaBoton.java // Prueba de MarcoBoton. import javax.swing.JFrame; public class PruebaBoton { public static void main( String args[] ) { MarcoBoton marcoBoton = new MarcoBoton(); // crea MarcoBoton marcoBoton.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); marcoBoton.setSize( 300, 110 ); // establece el tamaño del marco marcoBoton.setVisible( true ); // muestra el marco } // fin de main } // fin de la clase PruebaBoton

Botones que mantienen el estado // MarcoCasillaVerificacion.java // Creación de botones JCheckBox. import java.awt.FlowLayout; import java.awt.Font; import java.awt.event.ItemListener; import java.awt.event.ItemEvent; import javax.swing.JFrame; import javax.swing.JTextField; import javax.swing.JCheckBox; public class MarcoCasillaVerificacion extends JFrame { private JTextField campoTexto; // muestra el texto en tipos de letra cambiantes private JCheckBox negritaJCheckBox; // para seleccionar/deseleccionar negrita private JCheckBox cursivaJCheckBox; // para seleccionar/deseleccionar cursiva

12

// El constructor de MarcoCasillaVerificacion agrega objetos JCheckBox a JFrame public MarcoCasillaVerificacion() { super( "Prueba de JCheckBox" ); setLayout( new FlowLayout() ); // establece el esquema del marco // establece JTextField y su tipo de letra campoTexto = new JTextField( "Observe como cambia el estilo de tipo de letra", 28 ); campoTexto.setFont( new Font( "Serif", Font.PLAIN, 14 ) ); add( campoTexto ); // agrega campoTexto a JFrame negritaJCheckBox = new JCheckBox( "Negrita" ); // crea casilla de verificación "negrita" cursivaJCheckBox = new JCheckBox( "Cursiva" ); // crea casilla de verificación "cursiva" add( negritaJCheckBox ); // agrega casilla de verificación "negrita" a JFrame add( cursivaJCheckBox ); // agrega casilla de verificación "cursiva" a JFrame // registra componentes de escucha para objetos JCheckBox ManejadorCheckBox manejador = new ManejadorCheckBox(); negritaJCheckBox.addItemListener( manejador ); cursivaJCheckBox.addItemListener( manejador ); } // fin del constructor de MarcoCasillaVerificacion // clase interna privada para el manejo de private class ManejadorCheckBox implements { private int valNegrita = Font.PLAIN; // letra negrita private int valCursiva = Font.PLAIN; // letra cursiva

eventos ItemListener ItemListener controla el estilo de tipo de controla el estilo de tipo de

// responde a los eventos de casilla de verificación public void itemStateChanged( ItemEvent evento ) { // procesa los eventos de la casilla de verificación "negrita" if ( evento.getSource() == negritaJCheckBox ) valNegrita = negritaJCheckBox.isSelected() ? Font.BOLD : Font.PLAIN; // procesa los eventos de la casilla de verificación "cursiva" if ( evento.getSource() == cursivaJCheckBox ) valCursiva = cursivaJCheckBox.isSelected() ? Font.ITALIC : Font.PLAIN; // establece el tipo de letra del campo de texto campoTexto.setFont( new Font( "Serif", valNegrita + valCursiva, 14 ) ); } // fin del método itemStateChanged } // fin de la clase interna privada ManejadorCheckBox } // fin de la clase MarcoCasillaVerificacion

13

Prueba de MarcoCasillaVerificación // PruebaCasillaVerificacion.java // Prueba de MarcoCasillaVerificacion. import javax.swing.JFrame; public class PruebaCasillaVerificacion { public static void main( String args[] ) { MarcoCasillaVerificacion marcoCasillaVerificacion = new MarcoCasillaVerificacion(); marcoCasillaVerificacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); marcoCasillaVerificacion.setSize( 350, 100 ); // establece el tamaño del marco marcoCasillaVerificacion.setVisible( true ); // muestra el marco } // fin de main } // fin de la clase PruebaCasillaVerificacion

5.3 Tecnología .NET

.NET es una infraestructura para desarrollar aplicaciones Windows y Web dentro de los entornos Microsoft a través de un conjunto de herramientas, superiores a las ya conocidas. Cambia el rumbo inicial de Microsoft, ya que las aplicaciones de ser centradas en el cliente ahora son centradas en el servidor, es decir, que a través de .Net se puede integrar aplicaciones. 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.

Figura 5. 3 Evoluci ón .NET

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. Microsoft entonces, diseñó un FRAMEWORK que es el corazón de .NET y es el resultado de la unión de dos proyectos uno relacionado con el desarrollo de aplicaciones Web y de aplicaciones distribuidas, mientras que el segundo proyecto, conocido como NGWS (Next Generation Windows Services - Siguiente Generación de Servicios Windows), es la creación de una plataforma para el desarrollo del software como servicio. El producto resultante de ambos proyectos mejora el despliegue y ejecución de las aplicaciones, e introduce el concepto de los SERVICIOS WEB, que permiten el desarrollo de aplicaciones débilmente acopladas basadas en componentes. Pero la idea de Servicios en el Web no es nueva, antecesores en el tema de computación distribuida han existido y funcionado: RPC [RFC1050], CORBA [RFC2714], COM, etc. Pero cada técnica es correcta en si misma ya que solo funcionan en un mismo sistema o similar a otro: MSMQ solo habla con un cliente MSMQ, DCOM con un servidor DCOM, mientras .NET es independiente del lenguaje, lo que permite que los desarrolladores elaboren aplicaciones en el

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

Figura 5. 4 Arquitectura de la plataforma .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 integr ació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 simpl e 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 infr aestruct ura  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.

5.4 Entorno integrado de desarrollo

Un entorno de desarrollo integrado, llamado también IDE (sigla en inglés de integrated development environment), es un programa informático compuesto por un conjunto de herramientas de programación. Puede dedicarse en exclusiva a un solo lenguaje de programación o bien puede utilizarse para varios.

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.

Figura 5. 5 IDE NetBeans (JAVA)

5.5 Tipos de proyectos Proyectossociales

Son proyectos para lograr alguna obra que beneficie a la comunidad, pueden ser: Con pequeña subvención. El apoyo económico es poco y proviene del mismo equipo de investigación, es manejado por la comunidad que aprenden unos de otros el manejo de grupo, la ejecución y supervisión de proyectos, se reúnen para establecer reglas, ellos mismos administran sus fondos. Los funcionarios ayudan a la comunidad en su proyecto.

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. Tema 6 Formas, controles y eventos 6.1 Controles est ándar ComparaciónentreSwingyAWT

En realidad, hay dos conjuntos de componentes de GUI en Javas. Antes de introducir a Swing en Java SE 1.2, las GUIs de Java se creaban a partir de componentes del Abstract Window Toolkit (AWT) en el paquete java.awt. Cuando una aplicación de Java con una GUI del AWT se ejecuta en distintas plataformas, los componentes de la GUI de la aplicación se muestran de manera distinta en cada plataforma. Considere una aplicación que muestra un objeto de tipo Button (paquete java.awt). En una computadora que ejecuta el sistema operativo Microsoft Windows, el objeto Button tendrá la misma apariencia que los botones en las demás aplicaciones Windows. De manera similar, en una computadora que ejecuta el sistema operativo Apple Mac OS X, el objeto Button tendrá la misma apariencia visual que los botones en las demás aplicaciones Macintosh. Algunas veces, la forma en la que un usuario puede interactuar con un componente específico del AWT difiere entre una plataforma y otra.

Figura 6. 1 Componentes est ándar de GUI.

20

Figura 6. 2 Componentes est ándar GUI en NetBeans JAVA

GeneralidadesdecomponentesdeSwing

La mayoría de los componentes de GUI de Swing se encuentran en el paquete javax.swing. Forman parte de las Java Foundation Classes (JFC): las bibliotecas de Java para el desarrollo de GUIs en distintas plataformas. En conjunto, a la apariencia y la forma en la que interactúa el usuario con la aplicación se les denomina la apariencia visual. Los componentes de GUI de Swing nos permiten especificar una apariencia visual uniforme para una aplicación a través de todas las plataformas, o para usar la apariencia visual personalizada de cada plataforma. 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. La clase Component (paquete java.awt) declara muchos de los atributos y comportamientos comunes para los componentes de GUI en los paquetes java.awt y javax.swing. La clase Container (paquete java.awt) es una subclase de Component. Los objetos Component se adjuntan a los objetos Container, de manera que puedan organizarse y mostrarse en la pantalla. La clase JComponent (paquete javax.swing) es una subclase de Container. JComponent es la superclase de todos los componentes ligeros de Swing, y declara los atributos y comportamientos comunes. Algunas de las características comunes de JComponent son: una apariencia visual adaptable, teclas de método abreviado llamadas nemónicas, cuadros de información sobre herramientas, soporte para tecnologías de ayuda y soporte para la localización de la interfaz de usuario.

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 setToolTipText de JComponent  especifica la información sobre herramientas que se muestra cuando el usuario coloca el cursor del ratón sobre un componente ligero. El método add de Container adjunta un componente de GUI a un objeto Container. La clase ImageIcon  (paquete  javax.swing) soporta varios formatos de imagen, incluyendo GIF, PNG y JPEG. 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. 5.2 Eventos y propiedades del formulario.

La mayoría de las ventanas que creará son una instancia de la clase JFrame o una subclase de JFrame. JFrame proporciona los atributos y comportamientos básicos de una ventana: una barra de título en la parte superior, y botones para minimizar, maximizar y cerrar la ventana. Como la GUI de una aplicación por lo general es específica para esa aplicación, la mayoría de nuestros ejemplos consistirán en dos clases: una subclase de JFrame que nos ayuda a demostrar los 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. La clase JTextField extiende a la clase JTextComponent (paquete javax.swing.text), que proporciona muchas características comunes para los componentes de Swing basados en texto. La clase JPasswordField extiende a JTextField y agrega varios métodos específicos para el procesamiento de contraseñas. Un objeto JPasswordField muestra que se están escribiendo caracteres a medida que el usuario los introduce, pero oculta los caracteres reales con caracteres de eco. Un componente recibe el enfoque cuando el usuario hace clic sobre él.

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. 6.3 Tipos de Formulario.

Dentro de NetBeans existen diferentes tipos de formularios, El JFrame, JDialog, JOptionPane y JInternalFrame.

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. Todo esto nos indica lo siguiente: •

Un JFrame debe ser la ventana principal de nuestra aplicación y sólo debe haber una.

•

Las ventanas secundarias de nuestra aplicación deben ser JDialog.

Los motivos de esto son los siguientes. Al mostrar el JFrame un botón en la barra de herramientas de windows y tener método para cambiar el icono, es la ventana ideal como ventana principal de nuestra aplicación y sólo debe haber una. Nos permite cambiar el icono y sólo debe haber un botón en la barra de herramientas de windows para nuestra aplicación. Si usamos un JDialog como ventana principal, no tenemos botón en la barra de herramientas y no hay forma fácil de cambiarle el icono. Los JDialog son ideales para ventanas secundarias porque admiten una ventana padre. Si la VentanaA es padre del JDialogB, entonces el JDialogB siempre estará por delante de VentanaA, nunca quedará por detrás. Lo ideal es que hagamos nuestras ventanas secundarias como JDialog cuyo padre sea el JFrame principal. De esta forma los JDialogsiempre serán visibles por encima del JFrame y no se irán detrás ni quedarán ocultos por el JFrame. 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. La clase JOptionPane de java tiene

diferentes tipos de métodos showConfirmDialog(),

showInputDialog(), showOptionDialog(), showMessageDialog(). Estos métodos mostarán una ventana modal que pide al usuario una confirmación, que le pide un dato o le muestra un mensaje. En caso de que el usuario tenga que elegir algo, el método usado devuelve el valor elegido. Por ejemplo, para mostrar un aviso de error, nos basta esta simple línea de código JOptionPane.showMessageDialog(ventanaPadre, "mensaje de error", "título de la ventana", JOptionPane.ERROR_MESSAGE) ; esto mostrará el mensaje de error y detendrá la ejecución del

código hasta que el usuario cierre 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. 6.4 Control de Eventos. TiposdeeventoscomunesdelaGUI

Para cada tipo de objeto evento hay, por lo general, una interfaz de escucha de eventos que le corresponde. Cada interfaz de escucha de eventos especifica uno o más métodos manejadores de eventos, que deben declararse en la clase que implementa a la interfaz. 26

Figura 6. 3 Clases de Eventos del paquete java.awt.event.

Comofuncionaelmanejodeeventos

Cuando ocurre un evento, el componente de la GUI con el que el usuario interactuó notifica a sus componentes de escucha registrados, llamando al método de manejo de eventos apropiado de cada componente de escucha. 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. El componente de la GUI recibe un ID de evento único, especificando el tipo de evento, el cual utiliza para decidir el tipo de componente de escucha al que debe despacharse el evento, y cuál método llamar en cada objeto componente de escucha. 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. Invocacióndelmanejadordeeventos

Todo componente de la GUI soporta varios tipos de eventos, incluyendo eventos de ratón, eventos de tecla y otros más. Cuando ocurre un evento, éste se despacha solamente a los componentes de escucha de eventos del tipo apropiado. El despachamiento (dispatching) es simplemente el proceso por el cual el componente de la GUI llama a un método manejador de eventos en cada uno de sus componentes de escucha registrados para el tipo de evento que ocurrió. 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.

Figura 6. 4 Registro de eventos para el objeto JTextField campoTexto1.

Figura 6. 5 Jerarquias de botones de Swing.

6.5 Cajas de Dialogo

Los cuadros de diálogo son una opción perfecta para enviar al usuario mensajes de todo tipo: de error, de precaución, de información, etc. Además, permiten mostrar uno o más botones, e incluso solicitar información al usuario en forma de cuadro de texto o combo. 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:

Figura 6. 6 Creaci ón de clase llamada 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:

Figura 6. 7 Como mandar un mensaje

El primer parámetro, representa el componente padre sobre el cual el mensaje se mostrará, si nosotros no le enviamos ninguno, como en este caso lo estamos haciendo, simplemente mostrará una ventana similar a la siguiente:

30

Figura 6. 8 Mensaje mostrado

Si nosotros le enviamos un componente, se colocará encima de él, sin ninguna variación en el funcionamiento, el segundo parámetro es el mensaje que queremos observar. 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:

Figura 6. 9 Clase creada llamada InputDialog

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

Como resultado obtendremos:

Figura 6. 11 Mensaje dialogo de showImputDialog

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). Este es muy sencillo, el componente padre pues como anteriormente mencionamos es aquel sobre el cual se mostrará el mensaje, y el mensaje es lo que dirá el mensaje, como es un dialogo de confirmación, este, por default mostrará las opciones si, no y cancelar, y devolverá un entero con la opción seleccionada como si estuvieramos en un vector, es decir, si seleccionamos si retornará un cero, si es no un 1 y si es cancelar un 2, por ejemplo:

Figura 6. 12 ShowConfirmDialog

Figura 6. 13 Mensaje de 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:

Figura 6. 15 Codigo para mensaje con opciones

Como resultado obtenemos:

Figura 6. 16 Mensaje de dialogo con opciones

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