- Crear los componentes que se muestran en dicha ventana.

Transcripción

1 1. Pasos básicos para la creación de un entorno gráfico Una vez que hemos visto el conjunto de componentes que Swing nos proporciona, vamos a ver como se construye un interfaz de usuario sencillo. Vamos a mostrar como construir los elementos gráficos y dejamos para el siguiente apartado la gestión de eventos. El interfaz gráfico a construir estará formado por una ventana, y dentro de ésta van a aparecer un botón, una etiqueta y un cuadro de texto. Los pasos a seguir son los siguientes: - Crear una ventana de aplicación. - Crear los componentes que se muestran en dicha ventana. - Crear un contenedor. - Asociar los componentes al contenedor para que, al hacerse visible, muestre en su interior dichos componentes. - Asociar el contenedor a la ventana de aplicación para que, al hacerse visible, muestre en su interior el contenedor y, por tanto, los componentes asociados. La jerarquía de contenedores de nuestro sencillo interfaz gráfico sería: Ventana de Aplicación Contenedor Botón Etiqueta Campo de texto Figura 2 NOTA: Cuando en un gráfico vayamos a indicar que un componente se va a pintar dentro de un determinado contenedor, usaremos una línea terminada en un círculo del contenedor al componente Crear la ventana de aplicación Para crear una ventana de aplicación hay que instanciar un objeto de la clase JFrame. Algunos métodos de esta clase relacionados con el aspecto gráfico de la ventana son: public JFrame() Construye una ventana inicialmente invisible.

2 public JFrame(String titulo) Construye una ventana inicialmente invisible con el título indicado. public void settitle(string titulo) Establece el título de la ventana. public void setsize(int width, int height) Establece el tamaño en píxeles de la ventana. public void setdefaultcloseoperation(int operation) Establece la operación que se ha de hacer cuando el usuario cierra la ventana. Los valores permitidos vienen determinados por las siguientes constantes: Javax.swing.JFrame.EXIT_ON_CLOSE - Salir del programa. Javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE - No hacer nada. Javax.swing.WindowConstants.HIDE_ON_CLOSE - Ocultar la ventana (por defecto). Javax.swing.WindowConstants.DISPOSE_ON_CLOSE Liberar los recursos de la ventana, pero no salir del programa. public void setresizable(boolean resizable) Establece si el usuario puede cambiar el tamaño de la ventana. Por defecto es true. public void setextendedstate(int state) Establece el estado de la ventana. Puede no funcionar en algunas plataformás. Los valores permitidos vienen dados por las constantes: Java.awt.Frame.NORMAL No se encuentra ni minimizada ni maximizada. Java.awt.Frame.ICONIFIED Minimizada. Java.awt.Frame.MAXIMIZED_BOTH - Maximizada. Java.awt.Frame.MAXIMIZED_HORIZ Maximizada horizontalmente. Java.awt.Frame.MAXIMIZED_VERT Maximizada verticalmente. public void setlocation(int x, int y) Establece la posición de la esquina superior izquierda de la ventana. public void setvisible(boolean visible) Muestra u oculta la ventana Crear los componentes Para crear un componente, basta crear una instancia de la clase determinada y configurar ese objeto para que se adapte a nuestras necesidades. Vamos a ver algunos métodos de los aspectos gráficos de algunos de los componentes más usados: JButton public JButton(String texto) - Crea un botón con el texto indicado. JLabel public JLabel(String texto) - Crea una etiqueta con el texto indicado. public String gettext() - Devuelve el texto de la etiqueta. public void settext(string texto) - Pone el texto indicado en la etiqueta. JTextField public JTextField(int columnas) - Crea un Campo de Texto sencillo con el número de columnas especificado. public String gettext() - Devuelve el texto del campo de texto. A medida que vayamos avanzando en el curso iremos viendo los componentes más importantes y los métodos que permiten configurar su aspecto gráfico.

3 1.3. Crear un contenedor Como hemos visto, en Swing existen muchos tipos de contenedores, dependiendo de la forma que manejen los componentes que tienen dentro. Por ejemplo, existe un contenedor con pestañas y en cada pestaña va un componente, es el JTabbedPane. También existe otro contenedor dividido en dos partes para dos componentes, y la separación puede cambiar de posición, es el JSplitPane. El que nosotros vamos a usar, para construir nuestro sencillo interfaz, es el JPanel, el más sencillo de todos, que muestra todos los componentes a la vez distribuidos en su interior. Más adelante veremos como podemos configurar la forma de distribuir los componentes. El método constructor de la clase JPanel es: public JPanel() Crea un contenedor simple 1.4. Asociar los componentes al contenedor para que los muestre al hacerse visible Para asociar componentes a un contenedor, de forma que se muestren dentro cuando el contenedor se muestre por pantalla, usamos el siguiente método de la clase JPanel: public void add( JComponent componente ) Asocia el componente al contenedor, de forma que se muestre el componente al mostrarse el contenedor. NOTA: Por motivos de compatibilidad la cabecera real del método es public void add(component comp). Puesto que vamos a trabajar con Swing podemos considerar que la cabecera es la indicada Asociar el contenedor a la ventana para que le muestre al hacerse visible Para asociar un contenedor a la ventana de aplicación, de forma que se muestre dentro cuando la ventana se muestre por pantalla, usaremos el siguiente método de la clase JFrame: public void setcontentpane(jcomponent paneldecontenido) Establece el componente pasado como parámetro como contenido de la ventana. NOTA: Por motivos de compatibilidad la cabecera real del método es public void setcontentpane(container contentpane). Puesto que vamos a trabajar con Swing podemos considerar que la cabecera es la indicada.

4 El código para construir nuestra interfaz sería (una posible solución):... // Crear la ventana de la aplicacion JFrame ventana = new JFrame("Titulo de la ventana"); ventana.setsize(300, 200); ventana.setdefaultcloseoperation(jframe.exit_on_close); // Crear los componentes JLabel etiqueta1 = new JLabel("Texto etiqueta"); JTextField campodetexto = new JTextField(20); JButton boton = new JButton("Botón"); // Crear un contenedor JPanel paneldecontenido = new JPanel(); // Asociar los componentes al contenedor para // que los muestre en su interior paneldecontenido.add(etiqueta1); paneldecontenido.add(campodetexto); paneldecontenido.add(boton); // Asociar el contenedor a la ventana para // que le muestre en su interior ventana.setcontentpane(paneldecontenido); Eventos en Java Cuando construimos una aplicación con un interfaz gráfico de usuario, la forma de programar varía con respecto a una aplicación de consola. En una aplicación con interfaz gráfico, se asocia código a diferentes eventos que puede producir el usuario, de forma que cuando se genera dicho evento, por ejemplo, pulsar un botón, pulsar una tecla del teclado, pasar el ratón sobre una imagen, etc., se ejecuta el código asociado. Cuando finaliza la ejecución de ese código asociado, la aplicación espera nuevos eventos por parte del usuario. En este apartado veremos qué eventos pueden producir cada uno de los componentes debido a la interacción del usuario y cómo construir un determinado código para que esté asociado a dichos eventos Tipos de eventos Los eventos se dividen en dos grandes grupos: - Eventos de bajo nivel Representan de forma directa las acciones simples del usuario. Los eventos de este tipo son la pulsación de teclas y los movimientos del ratón que corresponden directamente con lo que el usuario hace.

5 - Eventos de alto nivel o semánticos Representan acciones más complejas. Por ejemplo, seleccionar un elemento en una lista desplegable, arrastrar un elemento o pulsar un hiperenlace. Cada componente del interfaz de usuario puede generar eventos diferentes, agrupados por tipos. Por ejemplo, un componente de árbol (JTree) genera eventos cuando seleccionan alguno de sus componentes y también genera eventos cuando se va a expandir o colapsar una rama. Además de los eventos específicos de cada componente, hay que tener en cuenta que mediante herencia, los eventos generados por objetos de la clase padre también son generados por los objetos de las clases hijas. Debido a esto, como todos los componentes heredan de Component, y los objetos de esta clase generan eventos de bajo nivel (teclado y ratón), todos los componentes generan eventos de bajo nivel. Una tabla con los distintos eventos que generan los componentes: Clase Tipos de eventos que genera Evento concreto Component Eventos del Foco (Focus) Foco obtenido (focusgained) Foco perdido (focuslost) Eventos de entrada de teclado (Key) AbstractButton JComboBox Window Tecla presionada (keypressed) Tecla soltada (keyreleased) Tecla presionada y soltada (keytyped) Eventos de ratón (Mouse) Tecla del ratón presionada y soltada (mouseclicked) El ratón entra en un componente (mouseentered) El ratón sale de un componente (mouseexited) Tecla del ratón presionada (mousepressed) Tecla del ratón soltada (mousereleased) Eventos de movimiento del ratón (MouseMotion) El ratón se ha movido y una tecla está pulsada. El componente está siendo arrastrado. (mousedragged) El ratón se ha movido y no se está pulsando ninguna tecla. (mousemoved) Eventos de la rueda del ratón La rueda ha rotado. (mousewheelmoved) (MouseWheel) Eventos de acción (Action) Se ha hecho clic en el botón (actionperformed) Eventos de cambio (Change) El estado del botón ha cambiado (statechanged) Eventos de selección de un item (Item) Eventos de acción (Action) Eventos de selección de un item (Item) Eventos de foco en la ventana (WindowFocus) Ha cambiado el estado de selección del botón (itemstatechanged) Se ha seleccionado un elemento. Si se puede escribir en el combo box indica que se ha finalizado la edición. (actionperformed) Ha cambiado la selección del combo box (itemstatechanged) Foco obtenido por la ventana (windowgainedfocus) Foco perdido por la ventana (windowlostfocus)

6 JTextComponent Eventos del ciclo de vida de la ventana (Window) Eventos de estado de la ventana (WindowState) Eventos de entrada de texto (InputMethod) 3º Ingeniería Informática Ventana activada (windowactivated) La ventana ha sido cerrada como resultado de llamar al método dispose (windowclosed) El usuario ha pulsado el botón de cierre de la ventana (windowclosing) La ventana ya no es la ventana activa (windowdeactivated) La ventana ha pasado de minimizada a normal (windowdeiconified) La ventana se ha minimizado (windowiconified) La ventana se ha hecho visible por primera vez (windowopened) La ventana ha cambiado de estado en cuanto a minimizada, maximizada, restaurada, etc... El cursor ha cambiado de posición (caretpositionchanged) El texto introducido por teclado ha cambiado (inputmethodtextchanged) Eventos de cursor (Caret) El cursor ha cambiado de posición (caretupdate) JEditorPane Eventos de hiperenlaces (Hyperlink) El link ha sido seleccionado (hyperlinkupdate) JTextField Eventos de acción (Action) El usuario ha pulsado la tecla enter en el cuadro de texto (actionperformed) JInternalFrame Eventos de ciclo de vida de la ventana interna (InternalFrame) Ventana activada (internalframeactivated) La ventana ha sido cerrada como resultado de llamar al método dispose (internalframeclosed) El usuario ha pulsado el botón de cierre de la ventana (internalframeclosing) La ventana ya no es la ventana activa (internalframedeactivated) La ventana ha pasado de minimizada a normal (internalframedeiconified) La ventana se ha minimizado (internalframeiconified) La ventana se ha hecho visible por primera vez (internalframeopened) JList Eventos de selección (ListSelection) La selección ha cambiado (valuechanged) JMenu Eventos del menú (Menu) El menú ha sido cancelado (menucanceled) El menú ha sido deseleccionado (menudeselected) El menú ha sido seleccionado (menuselected) JMenuItem Eventos de arrastrar con el ratón en un item de menú (MenuDragMouse) Eventos de entrada de teclado en los menús (menukey) En el item se está arrastrando el ratón (menudragmousedragged) En el item ha entrado el ratón con una tecla pulsada, ha entrado arrastrando (menudragmouseentered) Ha salido del item un ratón con una tecla pulsada, ha salido arrastrando (menudragmouseexited) Un ratón que se estaba moviendo con una tecla pulsada, ha soltado la tecla dentro del item (menudragmousereleased) Tecla presionada (menukeypressed) Tecla soltada (menukeyreleased) Tecla presionada y soltada (menukeytyped) JPopupMenu (PopupMenu) Menú cancelado (popupmenucanceled) Menú se va a hacer invisible (popupmenuwillbecomeinvisible)

7 ... 3º Ingeniería Informática Menú se va a hacer visible (popupmenuwillbecomevisible) JProgressBar Eventos de cambio (Change) El estado de la barra de progreso ha cambiado (statechanged) JSlider Eventos de cambio (Change) El estado de la barra de deslizamiento ha cambiado (statechanged) JSpinner Eventos de cambio (Change) El estado del selector ha cambiado (statechanged) JTabbedPane Eventos de cambio (Change) El estado del panel con pestañas ha cambiado (statechanged) JTree Eventos de expansión en el árbol (TreeExpansion) Eventos de futuras expansiones en el árbol (TreeWillExpand) Eventos de selección de los items del árbol (TreeSelection) JTable No genera eventos directamente. Debido al patrón MVC, que veremos posteriormente en este tutorial, los eventos son generados por atributos de esta clase. Un item del árbol ha sido colapsado (treecollapsed) Un item del árbol ha sido expandido (treeexpanded) Un item del árbol será colapsado (treewillcollapse) Un item del árbol será expandido (treewillexpand) La selección en el árbol ha cambiado (valuechanged) Como hemos dicho, se puede asociar un código a cada uno de los eventos que genera un componente. Es importante tener en cuenta que Swing nos permite asociar varios códigos distintos al mismo evento del mismo componente: Código 1 Botón... Código N NOTA: Utilizaremos la flecha punteada cuando queramos indicar que al producirse un evento en un componente, el código apuntado será ejecutado. También está permitido asociar un mismo código a varios componentes distintos, de forma que, un mismo código será ejecutado cuando se genere un evento en cualquiera de los componentes a los que está asociado. Botón 1 Código Botón N

8 1.7. Implementación de los eventos Una vez vistos qué eventos genera cada uno de los componentes del interfaz de usuario, vamos a ver cómo construir el código de gestión de eventos y cómo asociar ese código a los eventos que nos interesen. En Swing se utiliza el modelo de eventos de JavaBeans 1. Para construir un código y asociarlo a un evento en un componente tenemos que seguir los siguientes pasos: 1. Hacer que una clase implemente el interfaz XXListener, siendo XX el tipo de evento (en la tabla anterior los nombres que aparecen entre paréntesis). En la tabla A se muestran las clases XXListener que existen para los eventos de los componentes. Cada uno de estos interfaces define un método para cada uno de los eventos que pertenecen a ese tipo. En el método correspondiente al evento elegido, hay que escribir el código que se ejecutará cuando se produzca dicho evento y el resto de los métodos del interfaz se dejarán vacíos. Cada uno de los métodos de los interfaces XXListener recibe un parámetro de la clase XXEvent. Con el objeto recibido como parámetro, podemos obtener información sobre el evento producido. 2. Asociar dicho código al componente o componentes. Esto se consigue usando el método void addxxlistener(xxlistener listener) que tiene cada clase para cada tipo de evento que genera. Tabla A - Clases XXListener correspondientes a cada uno de los eventos. java.util.eventlistener java.awt.event.actionlistener java.awt.event.focuslistener java.awt.event.inputmethodlistener java.awt.event.itemlistener java.awt.event.keylistener java.awt.event.mouselistener java.awt.event.mousemotionlistener java.awt.event.mousewheellistener java.awt.event.textlistener java.awt.event.windowfocuslistener java.awt.event.windowlistener java.awt.event.windowstatelistener javax.swing.event.caretlistener javax.swing.event.changelistener javax.swing.event.hyperlinklistener javax.swing.event.internalframelistener javax.swing.event.listselectionlistener javax.swing.event.menudragmouselistener javax.swing.event.menukeylistener javax.swing.event.menulistener javax.swing.event.popupmenulistener 1

9 javax.swing.event.treeexpansionlistener javax.swing.event.treeselectionlistener javax.swing.event.treewillexpandlistener Como hemos visto, lo que en un principio habíamos llamado de forma general código de manejo de eventos, vemos como se implementa como un método con una cabecera determinada en una clase que implemente el interfaz XXListener. En la cabecera de esos métodos siempre se recibe como parámetro un objeto de la clase XXEvent. En la siguiente tabla se muestran todas las clases de XXEvent que existen para los componentes del interfaz: Tabla B - Clases XXEvent pasadas como parámetro en cada uno de los métodos de XXListener class java.lang.object class java.util.eventobject class javax.swing.event.caretevent class javax.swing.event.changeevent class javax.swing.event.hyperlinkevent class javax.swing.event.listselectionevent class javax.swing.event.menuevent class javax.swing.event.popupmenuevent class javax.swing.event.treeexpansionevent class javax.swing.event.treeselectionevent class java.awt.awtevent class javax.swing.event.internalframeevent class java.awt.event.actionevent class java.awt.event.inputmethodevent class java.awt.event.itemevent class java.awt.event.textevent class java.awt.event.componentevent class java.awt.event.windowevent* class java.awt.event.focusevent class java.awt.event.inputevent class java.awt.event.keyevent class javax.swing.event.menukeyevent class java.awt.event.mouseevent** class java.awt.event.mousewheelevent class javax.swing.event.menudragmouseevent * Usado por WindowStateListener y WindowFocusListener ** Usado por MouseMotionListener Las clases XXEvent se pueden dividir en dos categorías dependiendo de la cantidad de información sobre el evento que alberguen: - Eventos ligeros Sólo albergan la referencia al componente que generó el evento. Este tipo de eventos se usan cuando podemos saber detalles sobre el evento producido, lanzando mensajes al componente en el que se originó. Para obtener una referencia al objeto que generó el evento, usaremos el método en la clase EventObject (padre de todos los eventos): public Object getsource() - Eventos informativos Además de guardar una referencia al componente que generó el evento, tienen información sobre las características del evento

10 que se ha producido. Con eventos de este tipo no suele ser necesario consultar al componente. A medida que vayamos viendo cada uno de los componentes de nuestra interfaz, iremos viendo que información se puede obtener de los eventos generados. Existen clases abstractas, llamadas XXAdapter, que implementan uno o varios interfaces XXListener, pero dejan todos sus métodos sin implementación. Son usadas para construir clases de gestión de eventos sin necesidad de implementar un interfaz XXListener y dejar vacíos los métodos que no usemos. En vez de esto, heredamos de la clase XXAdapter y redefinimos los métodos que nos interesan. La primera aplicación con interfaz gráfico. Una vez que conocemos todos los mecanismos necesarios, vamos a construir nuestro primer programa con interfaz gráfico. Las partes básicas de un programa con interfaz gráfico son: - Construcción de la interfaz: 1. Construcción de los elementos gráficos. 2. Asociación del código de manejo de eventos a los componentes. 3. Hacer visible la ventana de la aplicación. - Código de manejo de eventos: 1. Cuando se produce un evento del usuario, se ejecuta el código de manejo de eventos asociado. En este código, habitualmente, se obtienen datos del interfaz, se procesan esos datos y se modifica el interfaz en consecuencia. Existen muchas formas de construir nuestro código para cumplir estas directivas generales. Para aplicaciones pequeñas, la forma en que construyamos el código del interfaz gráfico no será relevante, pero en aplicaciones medias y grandes, la organización de este código será de vital importancia para que sea manejable, mantenible, reutilizable, etc., por este motivo, a medida que avancemos en el tutorial no sólo veremos la API, sino que nos esforzaremos en hacer que nuestro código sea de calidad. El código más sencillo para construir un interfaz gráfico se consigue siguiendo los siguientes pasos: 1. Crear una clase. 2. En el método main de esa clase se instancia un objeto de dicha clase. 3. Se ponen como atributos cada uno de los elementos del interfaz de usuario. 4. El constructor se encarga de: 1. Construir los elementos gráficos. 2. Asociar el código de manejo de eventos a los componentes.

11 3. Hacer visible la aplicación. 5. La clase implementa el interfaz XXListener e implementa el método correspondiente al evento elegido. En el cuerpo de ese método se obtienen los datos del interfaz de usuario, a través del objeto evento, a través de la fuente del evento o directamente de otros componentes del interfaz de usuario. Posteriormente, se procesan esos datos y se modifica el interfaz de usuario para mostrar los resultados. Ejemplo1 Interfaz de un Conversor de Euros a Pesetas Construir la parte de código que construye un interfaz de usuario que conste de una ventana de 300 x 400 píxeles y cuyo título sea Conversor de Euros a Pesetas. Al cerrar la ventana se finalizará la ejecución de nuestro programa. Dentro de la ventana se tiene que mostrar una etiqueta con el texto Importe en Euros y un cuadro de texto de 20 columnas de longitud. Aparecerá un botón con el texto Convertir y una etiqueta con el texto Pulse para obtener el importe en pesetas. Cuando se pulse el botón, se debe obtener el valor del campo de texto, hacer la conversión de Euros a pesetas y modificar el interfaz de usuario con el valor de la conversión. import javax.swing.*; import java.awt.event.*; public class Conversor implements ActionListener { JLabel etiqueta1; JTextField campodetexto; JButton boton; JLabel etiqueta2; public Conversor() { //********************************************* // CREACIÓN DEL INTERFAZ GRÁFICO //********************************************* // Crear la ventana de la aplicacion JFrame ventana = new JFrame("Conversor de Euros a pesetas"); ventana.setsize(300, 200); ventana.setdefaultcloseoperation(jframe.exit_on_close); // Crear los componentes etiqueta1 = new JLabel("Importe en Euros"); campodetexto = new JTextField(20); boton = new JButton("Convertir"); etiqueta2 = new JLabel("Pulse para obtener el" + "importe en pesetas"); // Crear un contenedor JPanel paneldecontenido = new JPanel(); // Configurar el contenedor para mostrar los componentes cuando // se muestre. paneldecontenido.add(etiqueta1); paneldecontenido.add(campodetexto); paneldecontenido.add(boton); paneldecontenido.add(etiqueta2);

12 // Configurar la ventana para mostrar el panel cuando se muestre ventana.setcontentpane(paneldecontenido); //************************************************** // ASOCIACIÓN DEL CÓDIGO DE MANEJO DE EVENTOS //************************************************** boton.addactionlistener(this); //************************************************** // HACER VISIBLE LA VENTANA //************************************************** ventana.setvisible(true); public static void main(string[] args) { new Conversor(); public void actionperformed(actionevent e) { //************************************************** // CÓDIGO DE MANEJO DE EVENTOS //************************************************** try { double euros = Double.parseDouble(campoDeTexto.getText()); double pesetas = euros * ; etiqueta2.settext("equivale a " + pesetas + " pesetas"); catch (NumberFormatException e2) { etiqueta2.settext("en el campo de texto no hay un número"); Como podemos observar, en una aplicación con interfaz gráfico existen cuatro tipos de relaciones entre los objetos: - Asociación/Composición - La relación habitual en cualquier programa orientado a objetos es la relación de composición/asociación, que existe cuando un objeto está enlazado a otro mediante un atributo en la clase. La representaremos como: Objeto Objeto atributo - Uso Es la relación que guarda un objeto con aquellos objetos que le llegan como parámetro o que actúan como objetos locales a un método. La representaremos como: Objeto Objeto usado

13 - Eventos Esta relación se da cuando el método de un objeto será ejecutado cuando se genere un determinado evento en un componente. La representaremos como: Componente Objeto de manejo de eventos - Pintado Esta relación se da cuando un componente se asocia a un contenedor para pintarse dentro de él. La representaremos como: Contenedor Componente Según estos cuatro tipos de relaciones, el esquema de nuestra primera aplicación sería: <<interface>> ActionListener :JFrame :Conversor :JPanel :JButton :JLabel :JLabel :JTextField

14 2. Organización del código de una aplicación gráfica Una vez que tenemos claras las partes clave de una aplicación con interfaz gráfico, vamos a construir un pequeño traductor. Iremos poco a poco añadiendo más componentes y eventos a nuestro traductor. Esto nos permitirá experimentar con la implementación de los eventos. 2.1 Estructura general. Interfaz y Datos Cuando se construye una aplicación con un entorno gráfico es habitual dividir su estructura principal en tres clases: Aplicación Interfaz Datos - La clase Aplicación Esta clase es la que tiene el método estático main. Se encarga de acceder a los datos de la aplicación y diversas tareas de inicialización. También se encarga de instanciar el interfaz de usuario y asociarle los datos. En esta clase se suelen realizar todas aquellas tareas de inicialización y mientras tanto aparecería una ventana sin marco mostrando el progreso de la carga. Cuando esta carga estuviese lista crearía el interfaz de usuario. - La clase principal de Datos Normalmente las aplicaciones sencillas suelen tener una clase que representa la forma de acceder a los datos que ésta gestiona. Dependiendo de la aplicación esta clase puede ser muy distinta, por ejemplo, puede ser un gestor de base de datos, una clase con la lógica de una calculadora, etc. - La clase principal de Interfaz La mayoría de las aplicaciones sencillas suelen tener una clase para la creación del interfaz de usuario, y cómo éste se relaciona con la clase principal de datos. Esta clase principal suele heredar de JFrame y suele tener como atributos los componentes del interfaz de usuario.

15 Ejemplo 2. Se pretende crear una aplicación de traducción, en este caso será una traducción entre dos idiomas: español e inglés. La interfaz gráfica de usuario debe estar formada por una etiqueta con el texto Pulse el botón para traducir ; por un campo de texto de 20 caracteres, que inicialmente estará vacío y un botón con el texto Traducir. La ventana de aplicación tendrá un tamaño de 300 x 200 píxeles y el título de la misma será: Traductor de Español a Inglés. La aplicación debe presentar la siguiente funcionalidad: Al cerrar la ventana de aplicación se finalizará la ejecución del programa. Cuando se pulse el botón Traducir, el contenido del campo de texto deberá ser traducido de español a inglés, y el resultado de la traducción se mostrará en la etiqueta de texto (sustituyendo, por tanto, el texto inicial que tenía dicha etiqueta). Cuando se intente traducir una palabra que no se encuentre en el diccionario del traductor, el resultado de la traducción será la cadena de caracteres X. El diccionario de palabras que utilizará la aplicación se muestra en la siguiente tabla (Tabla 1). Español Inglés Francés Largo Long Longue Barato Cheap Réduit Pan Bread Pain Petardo Bomb Bombe Moto Motorbike Moto Tabla1. Diccionario de palabras de la aplicación Para este ejemplo de aplicación se dispone una clase de datos llamada Traductor. Como la aplicación actual es un traductor, los datos a gestionar son, por ejemplo, los idiomas de origen y destino de la traducción, el diccionario de palabras, el proceso de traducción, etc. A continuación se comentan algunos detalles de esta clase de datos: Cada idioma vendrá representado por una constante: Traductor.ESPAÑOL Traductor.INGLES Traductor.FRANCES Al crearse el traductor se configura con algún idioma origen y destino por defecto. Existen métodos para actualizar y gestionar estos idiomas: public void setidiomaorigen(int idiomaorigen)

16 public void setidiomadestino(int idiomadestino) public int getidiomaorigen() public int getidiomadestino() public void invierteidioma() Para traducir se utilizan los siguientes métodos: 3º Ingeniería Informática public String traducepalabra(string palabra, int idiomaorigen, int idiomadestino) public String traducepalabra(string palabra) Se puede tener una representación textual de una constante del idioma con el siguiente método estático: public static String getcadenaidioma (int idioma) El diagrama de clases y objetos de la aplicación se muestra en la figura 2 Figura 2. Diagrama de clases y objetos de la aplicación de traducción 1.0 La interfaz de la aplicación se muestra en la figura 3.

17 Figura 3. Interfaz aplicación de traducción Se pide: implementar el resto de código fuente (AplicacionTraductor y VentanaTraductor) para terminar la aplicación que se muestra en la figura 3. utilizando la clase: Traductor.java que se lista a continuación: import java.util.stringtokenizer; public class Traductor { public static final int FRANCES = 0; public static final int ESPAÑOL = 1; public static final int INGLES = 2; public static final int NUM_IDIOMAS = 3; private int idiomaorigen; private int idiomadestino; private String[][] diccionario = { { "Longue", "Rédiut", "Pain", "Bombe", "Moto ", { "Largo", "Barato", "Pan", "Petardo", "Moto", { "Long", "Cheap", "Bread", "Bomb", "Motorbike" ; private static String[] cadena = { "Francés", "Español", "Inglés" ; public Traductor() { this.idiomaorigen = ESPAÑOL; this.idiomadestino = INGLES; public static String getcadenaidioma(int codidioma) { return cadena[codidioma]; public void setidiomaorigen(int idiomaorigen) { this.idiomaorigen = idiomaorigen; public void setidiomadestino(int idiomadestino) { this.idiomadestino = idiomadestino;

18 public int getidiomaorigen() { return idiomaorigen; public void invierteidioma() { int aux; aux = idiomaorigen; idiomaorigen = idiomadestino; idiomadestino = aux; public int getidiomadestino() { return idiomadestino; public String[] getpalabras(int codidioma) { return diccionario[codidioma]; public String traducepalabra(string palabra) { return this.traducepalabra(palabra, this.idiomaorigen, this.idiomadestino); public String traducepalabra(string palabra, int codorigen, int coddestino) { int i = 0; boolean encontrado = false; while ((i < diccionario[español].length) &&!encontrado) { if (palabra.equalsignorecase(diccionario[codorigen][i])) { encontrado = true; else { i++; if (encontrado) { return diccionario[coddestino][i]; else { return "X"; public String traducetexto(string texto) { return this.traducetexto(texto, this.idiomaorigen, this.idiomadestino); public String traducetexto(string texto, int codorigen, int coddestino) { StringBuffer traduccion = new StringBuffer(); StringTokenizer st = new StringTokenizer(texto, " \n"); while (st.hasmoretokens()) { String palabra = st.nexttoken(); traduccion.append(this.traducepalabra(palabra, codorigen, coddestino));

19 traduccion.append(" "); return traduccion.tostring(); Ejercicio 2. Se pretende organizar mejor el código de la versión 1.0 de la aplicación de traducción (Ejercicio 1); por ello, se va a modificar dicho código para que la creación y gestión de los componentes de la ventana se realice en una clase distinta a la encargada de la gestión de la propia ventana. El diagrama de clases y objetos de esta nueva aplicación se muestra en la figura 4. Figura 4. Diagrama de clases y objetos de la aplicación de traducción 2.0 La interfaz no cambia en comparación con la anterior aplicación. La clase AplicaciónTraductor que igual. La clase VentanaTraductor si cambiará y se creará una nueva, llamada PanelTraductor. Se pide: Implementar dicha clase (PanelTraductor)

20 Nota: Separar el código dependiendo de su función nos garantiza tener un código de fácil mantenimiento y reutilización, es decir, de forma general, es recomendable separar las sentencias de configuración de la ventana de las instrucciones de creación y gestión del panel de contenido. Esta separación del contenido de la ventana en una clase diferente a la de la propia ventana, permite que la funcionalidad de la aplicación pueda ser incorporada en cualquier parte de la interfaz de usuario de otra aplicación. En el ejemplo de la aplicación de traducción, al crear una clase para el contenido de la ventana se permite que el traductor se pueda incorporar, por ejemplo, en una aplicación de proceso de textos.