Programación Orientada a Eventos Java

0

MORELIA, MICHOACÁN 20/06/09

INSTITUTO TECNOLÓGICO DE MORELIA

DIVISIÓN DE ESTUDIOS PROFESIONALES DEPARTAMENTO DE SISTEMAS

COMPUTACIONALES

LIBROS DE TEXTO O PROTOTIPOS DIDÁCTICO

PROGRAMACIÓN II

QUE PARA OBTENER EL TÍTULO DE:

INGENIERO EN SISTEMAS COMPUTACIONALES

PRESENTA:

SAÚL CHÁVEZ VELÁZQUEZ

ASESOR:

RAYMUNDO GUZMÁN MARINES

SUBSECRETARÍA DE EDUCACIÓN SUPERIOR DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA

INSTITUTO TECNOLÓGICO DE MORELIA

Agradecimientos

Agradezco todo el apoyo de mi Asesor Raymundo Guzmán Marines sin el cual no habría sido posible la culminación de este trabajo. Gracias por todo su tiempo, su comprensión, sus consejos y su trabajo…

A mis padres, por todo su apoyo, sin él no podría haber llegado a este punto… Y a quienes debo lo bueno que haya en mi.

A Verónica, por su ayuda, por el soporte que siempre me ha brindado, siempre puedo contar con ella. ¡Gracias por todo!

A mi abuelita Angelina, quien siempre me ha servido como ejemplo de trabajo y esfuerzo. Una persona admirable, si todos tuviéramos la mitad de su energía, entusiasmo y amor por hacer las cosas bien seguramente el mundo estaría lleno de gente exitosa.

Al Tecnológico de Morelia y a todos mis profesores, realmente me siento orgulloso de ser egresado de esta institución, gracias a ellos aprendí algo que considero muy importante, “siempre estar aprendiendo cosas nuevas y por uno mismo”, “siempre dar más de lo necesario”, aunque en su momento no “agradecía” precisamente las noches de desvelo trabajando para esos “proyectos semestrales” ahora que formo parte de productiva de la sociedad agradezco mucho todo lo que aprendí tanto en las aulas, como en las incontables horas de trabajo fuera de la institución.

Dedico este trabajo a mi familia.

i

INTRODUCCIÓN

En el siguiente material se estudian los temas de la asignatura de Programación II del plan 2004 de la licenciatura en Informática. Todos los temas se desarrollan utilizando el lenguaje de programación Java; pero, debido a la temática que se debe contemplar para respetar el programa, algunos de los temas deben explicarse con otras herramientas como Visual Basic. Sin embargo se hace una pequeña comparación entre lo que pide el programa y el equivalente en lenguaje java. El material comienza desde lo más básico del lenguaje: comentarios, declaraciones, sintaxis, etc. Y avanza hasta el punto de almacenamiento en bases de datos. El flujo de trabajo es el siguiente: se comienza a trabajar en modo consola, con algoritmos sencillos y almacenamiento en memoria, a partir del final de la primera unidad se comienzan a analizar objetos gráficos y en la segunda unidad se trabaja absolutamente en ambiente gráfico, aún utilizando como modo de almacenamiento la memoria de la PC. Después, a partir de la tercera unidad, el modo de almacenamiento cambia a “Archivos” y se pide al estudiante, programe aplicaciones gráficas almacenando y extrayendo información de archivos de texto plano. Finalmente, el modo de almacenamiento cambia a “Bases de Datos” y se analizan ejemplos sencillos con bases de datos muy simples. Al final del material y a modo de información extra se analiza cómo crear tus propios controles ActiveX con Visual Basic. Los ejercicios propuestos para cada unidad pretenden reforzar los temas vistos en cada una de las mismas y están diseñados de tal manera que el alumno siga la línea de aprendizaje descrita en el párrafo anterior procurando siempre que inculcar en el alumno la necesidad de investigar más y profundizar más en los temas que se analizan. Los ejemplos siguen la misma línea de aprendizaje, todos los ejemplos están relacionados con una aplicación y situación inicial a la cual se le va agregando funcionalidad de acuerdo al avance en el temario de la materia.

Finalmente, se incluye un glosario de términos que ayude al estudiante a disipar dudas sobre tecnicismos que desconozca y se provee de una completa bibliografía, describiendo en las ligas de internet el tipo de material que se puede localizar en cada una. Cabe mencionar que dicha bibliografía se revisó recientemente para confirmar la existencia actual de las mismas.

ITM INDICE GENERAL

Instituto Tecnológico de Morelia. Página i

INDICE INTRODUCCION . . . . . . . . . . . . . . . . . i UNIDAD I. “FUNDAMENTOS DEL LENGUAJE”

1.1 Programación orientada a eventos. . . . . . . . . . . 2 1.1.1 Objetos. . . . . . . . . . . . . . . . 2 1.1.2 Eventos. . . . . . . . . . . . . . . . 6 1.1.3 Métodos. . . . . . . . . . . . . . . . 10 1.1.4 Propiedades. . . . . . . . . . . . . . . 13

1.2 Entorno integrado de desarrollo. . . . . . . . . . . . 15 1.3 Ventanas (proyecto, propiedades, ayuda). . . . . . . . . 18 1.4 Tipos de proyectos. . . . . . . . . . . . . . . 23

1.4.1 Configuración. . . . . . . . . . . . . . . 23 1.5 Comentarios. . . . . . . . . . . . . . . . . 24 1.6 Constantes. . . . . . . . . . . . . . . . . 25 1.7 Tipos de datos. . . . . . . . . . . . . . . . . 26 1.8 Variables. . . . . . . . . . . . . . . . . . 32 1.9 Operadores. . . . . . . . . . . . . . . . . 36 1.10 Sentencias. . . . . . . . . . . . . . . . . 45 1.11 Matrices. . . . . . . . . . . . . . . . . . 46 1.12 Procedimientos y funciones. . . . . . . . . . . . . 49 1.13 Estructuras de control. . . . . . . . . . . . . . 55 1.14 Controles básicos y sus propiedades. . . . . . . . . 64 Ejercicios Propuestos. . . . . . . . . . . . . . . 72 Proyectos integrales. . . . . . . . . . . . . . . . 75

UNIDAD 2. “CONTROLES, EVENTOS, MÉTODOS Y COMPONENTES” 2.1 Controles estándar. . . . . . . . . . . . . . . 77 2.2 Eventos del formulario. . . . . . . . . . . . . . .

87 2.3 Cajas de diálogo. . . . . . . . . . . . . . . 93

2.3.1 Modales y no modales. . . . . . . . . . . 94 2.3.2 Predefinidas. . . . . . . . . . . . . . . 97

2.4 Componentes estándar. . . . . . . . . . . . . . 101 Ejercicios Propuestos. . . . . . . . . . . . . . . . 105 Proyecto integral . . . . . . . . . . . . . . . . 107

UNIDAD 3. “SISTEMAS DE ARCHIVOS” 3.1 Acceso secuencial. . . . . . . . . . . . . . . 111 3.2 Acceso directo. . . . . . . . . . . . . . . . . 115 3.3 Manejo de archivos. . . . . . . . . . . . . . . 122 3.4 Controlar errores en tiempo de ejecución. . . . . . . . . 130 Ejercicios Propuestos. . . . . . . . . . . . . . . . 133

ITM INDICE GENERAL

Instituto Tecnológico de Morelia. Página ii

Proyecto integral . . . . . . . . . . . . . . . . 135

UNIDAD 4. “ACCESO A DATOS” 4.1 Introducción. . . . . . . . . . . . . . . . . 138 4.2 Control de datos ADO. . . . . . . . . . . . . . . 154 4.3 Objetos ADO. . . . . . . . . . . . . . . . . 156 4.4 Herramientas de acceso a datos. . . . . . . . . . . 164 4.4.1 ADO.NET . . . . . . . . . . . . 165 4.4.2 JDBC . . . . . . . . . . . . . . 165 4.4.3 ODBC . . . . . . . . . . . . . . 165 4.4.2 DAO . . . . . . . . . . . . . . 166 Ejercicios Propuestos. . . . . . . . . . . . . . . 172 Proyecto integral . . . . . . . . . . . . . . . . 173

UNIDAD 5. “COMPONENTES Y CONTROLES DEFINIDOS POR EL USUARIO” 5.1 Modelo de componentes. . . . . . . . . . . . . 175 5.2 Crear un componente Active X. . . . . . . . . . . . 175 5.3 Crear un Control Active X. . . . . . . . . . . . . 177 Ejercicios Propuestos. . . . . . . . . . . . . . . 187 Proyecto integral . . . . . . . . . . . . . . . . 187

Apéndice 1 Instalación de Net Beans. . . . . . . . . . . . . 187 Apéndice 2 Introducción a MySQL. . . . . . . . . . . . . . 191 Conclusiones. . . . . . . . . . . . . . . . . . . . 202 Bibliografía. . . . . . . . . . . . . . . . . . . . . 204

Glosario de Términos. . . . . . . . . . . . . . . . . . 209

ITM INDICE GENERAL

Instituto Tecnológico de Morelia. Página iii

INDICE DE FIGURAS

UNIDAD I. “FUNDAMENTOS DEL LENGUAJE” 1.1 Ejemplo de cómo identificar Objetos. . . . . . . 3 1.2 Ejemplo de cómo identificar Objetos, Misma Clase. . . . . . 3 1.3 Ejemplo utilizando JOptionPane. . . . . . . . . . . 9 1.4 Ejemplo usando ventanas para entrada de datos. . . . . . . 9 1.5 Objeto en NetBeans. . . . . . . . . . . . . . . 13 1.6 Botón con texto editado. . . . . . . . . . . . . . 14 1.7 Pantalla principal de NetBeans 6.0. . . . . . . . . . . 16 1.8 Ventana de Proyectos.. . . . . . . . . . . . . . 18 1.9 Ventana elegir nombre y ubicación. . . . . . . . . . . 19 1.10 Hola Mundo en Java. . . . . . . . . . . . . . 20 1.11 Ventana Propiedades. . . . . . . . . . . . . 21 1.12 Ventana Help. . . . . . . . . . . . . . . . 21 1.13 Búsqueda en Ayuda. . . . . . . . . . . . . . 22 1.14 Ventana Proyectos. . . . . . . . . . . . . . . 24 1.15 Ejemplo de una etiqueta. . . . . . . . . . . . . 65 1.16 Ejemplo de ScrollBar no a la vista. . . . . . . . . . 70 1.17 Ejemplo de ScrollBar a la vista. . . . . . . . . . . 71

UNIDAD 2. “CONTROLES, EVENTOS, MÉTODOS Y COMPONENTES”

2.1 Ventana “Nuevo Proyecto”. . . . . . . . . . . . . 77 2.2 Ventana de configuración de proyecto. . . . . . . . . 78 2.3 Área de trabajo de NetBeans. . . . . . . . . . . 78 2.4 Aplicación de escritorio vacía. . . . . . . . . . . 79 2.5 Paleta de controles. . . . . . . . . . . . . . . 79 2.6 Programa en ejecución con botones de ejemplo. . . . . . . 80 2.7 Ventana Propiedades. . . . . . . . . . . . . . . 81 2.8 Cambio de propiedades de un objeto. . . . . . . . . . 82 2.9 Cambio de propiedad “name”. . . . . . . . . . . . 83 2.10 Programa en ejecución con caja de texto. . . . . . . 83 2.11 Cambio de Propiedades de un objeto Textfield. . . . . . . 84 2.12 Cambio de Propiedades de objetos CheckBox. . . . . . . 85 2.13 Aplicación con botones de opción. . . . . . . . . 87 2.14 Lista de eventos. . . . . . . . . . . . . . . . 88 2.15 Ejemplo en ejecución. . . . . . . . . . . . . . 89 2.16 Programa en ejecución. . . . . . . . . . . . . 90 2.17 Aplicación en ejecución. . . . . . . . . . . . . 92 2.18 Aplicación en ejecución. . . . . . . . . . . . . 93 2.19 Ventana “New File” crear caja de diálogo. . . . . . . . 95 2.20 Nuevo formulario para caja de diálogo vacio. . . . . . . 95

ITM INDICE GENERAL

Instituto Tecnológico de Morelia. Página iv

2.21 Aplicación en ejecución. . . . . . . . . . . . . 96 2.22 Cómo ver la lista de cuadros de diálogo predefinidos. . . . 98 2.23 Error por no importar librería. . . . . . . . . . . . 98 2.24 Herramienta útil para corregir errores sencillos. . . . . . . 99 2.25 Programa en ejecución. . . . . . . . . . . . . 100 2.26 Programa en ejecución. . . . . . . . . . . . . 101 2.27 Componentes Swing y AWT. . . . . . . . . . . . 102

UNIDAD 3. “SISTEMAS DE ARCHIVOS”

3.1 Programa en ejecución. . . . . . . . . . . . . . 113 3.2 Programa en ejecución. . . . . . . . . . . . . . 115 3.3 Ejemplo con RandomAccessFile. . . . . . . . . . . 119 3.4 Ejemplo usando JFileChooser. . . . . . . . . . . . 123 3.5 Selector de apertura. . . . . . . . . . . . . . . 123 3.6 Selector personalizado. . . . . . . . . . . . . . 125

UNIDAD 4. “ACCESO A DATOS”

4.1 Ventana: elegir nombre de página y puerto . . . . . . . . 140 4.2 Ventana: configuración de MySQL. . . . . . . . . . . 140 4.3 Iniciar ambos servidores. . . . . . . . . . . . . . 141 4.4 Pantalla principal del servidor Apache. . . . . . . . . 141 4.5 Pantalla principal de phpMyAdmin. . . . . . . . . . . 142 4.6 ¿Cómo acceder a la tabla de Usuarios?. . . . . . . . . 143 4.7 Consulta de la tabla “user” de MySQL. . . . . . . . . . 143 4.8 Datos a llenar para dar de alta otro usuario. . . . . . . . .

144 4.9 ¿Cómo agregar el driver para conectar…?. . . . . . . . .

145 4.10 Ventana: agregar driver JDBC. . . . . . . . . . . . 145 4.11 Opción para conectar la base de datos. . . . . . . . . 146 4.12 Agregar los datos a la Base de datos. . . . . . . . . 146 4.13 Conectar NetBeans con MySQL. . . . . . . . . . . 147 4.14 Ventana: Conexión establecida. . . . . . . . . . . 147 4.15 Ejemplo de botó que invoca una conexión. . . . . . . 149 4.16 Opción necesaria para crear una Base de Datos. . . . . . 150 4.17 Crear tablas de la base de datos. . . . . . . . . . . 151 4.18 Ingresar datos de la tabla. . . . . . . . . . . . . 151 4.19 Ingresar datos de cada campo de la tabla. . . . . . . . .

152 4.20 Vista de las tablas de nuestra nueva base de datos. . . . . 152 4.21 Programa en ejecución. . . . . . . . . . . . . 154 4.22 Contenido de la base de datos. . . . . . . . . . . 154

UNIDAD 5. “COMPONENTES Y CONTROLES DEFINIDOS POR EL USUARIO”

5.1 Tipos de proyectos en Visual Basic. . . . . . . . . . . 178 5.2 Propiedades del Proyecto. . . . . . . . . . . . . 179

ITM INDICE GENERAL

Instituto Tecnológico de Morelia. Página v

5.3 Evento “resize” del control ActiveX. . . . . . . . . . . 180 5.4 Ventana para activar el asistente de configuración. . . . . . 180 5.5 Ventana: Seleccionar miembros de la interfaz. . . . . . . 181 5.6 Ventana: Agregar miembros personalizados. . . . . . . . 181 5.7 Ventana crear miembros personalizados de la interfaz. . . . . 182 5.8 Ventana: establecer atributos de los miembros. . . . . . . 182 5.9 Utilización de nuestro control.. . . . . . . . . . . . 184 5.10 Objeto Active X. . . . . . . . . . . . . . . . 186

Unidad 1. Fundamentos del Lenguaje.

Conceptos básicos.

ITM Unidad I Fundamentos del Lenguaje

Instituto Tecnológico de Morelia. Página 2

1.1 Programación Orientada A Eventos

1.1.1 Objetos Un objeto es una entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o funcionalidad (métodos). Corresponden a los objetos reales del mundo que nos rodea, o a objetos internos del sistema (del programa). Es una instancia de una clase. Los objetos son entidades que combinan estado, comportamiento e identidad. El estado está compuesto de datos, y el comportamiento por procedimientos o métodos. La identidad es una propiedad de un objeto que lo diferencia del resto. La programación orientada a objetos expresa un programa como un conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y módulos más fáciles de escribir, mantener y reutilizar. De esta forma, un objeto contiene toda la información que permite definirlo e identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen de mecanismos de interacción llamados métodos que favorecen la comunicación entre ellos. Esta comunicación favorece a su vez el cambio de estado en los propios objetos. Esta característica lleva a tratarlos como unidades indivisibles, en las que no se separan ni deben separarse el estado y el comportamiento. Identificando objetos

• Los objetos pueden ser físicos o conceptuales.

� Una cuenta de cliente es un ejemplo de un objeto conceptual

porque no se puede tocar físicamente. Un cajero automático es

algo que mucha gente toca todos los días y es un ejemplo de un

objeto físico.

• Los objetos tienen atributos (características).

� Tal como tamaño, nombre, color, forma, etc. Los valores de los

atributos son referidos como el estado actual del objeto. Por

ejemplo, un objeto puede tener un atributo color con el valor de

rojo.

• Los objetos tienen operaciones (las cosas que pueden hacer).



� Tal como asignar un valor, desplegar una pantalla, o incrementar

rapidez. Las operaciones usualmente afectan los atributos de los

objetos.

Figura 1.1: Ejemplo de cómo Identificar Objetos.

Otro ejemplo seria una puerta… Sus atributos serian el color, tamaño, material, etc. Sus operaciones o métodos serian cerrar_puerta(), abrir_puerta(). El identificar objetos ayuda a diseñar las clases (o plantillas) para cada tipo de objetos en un sistema. En la Programación Orientada a Objetos (POO) cada objeto de una clase es llamada una instancia de clase y tiene valores distintos en sus atributos, pero son los mismos atributos y las mismas operaciones.

Figura 1.2: Ejemplo Diferentes Objetos, Misma Clase.

Para declarar un objeto, primero debemos declarar la clase, la sintaxis en Java es la siguiente: Declaración de clases: En Java la declaración de clases toma la siguiente forma:

<modificador>* class <nombre_clase> { <declarer_atributos>* <declarar_constructor>* <declarar_métodos>*



} Ejemplo: En el archivo MiClase.class

package javaApplication1; public class MiClase{ String mensaje; }

Declaración de objetos: Para declarar un objeto se sigue la siguiente sintaxis:

<nombre_clase> <nombre_objeto> = new <nombre_clase>(); Ejemplo: En el archivo Main.class package javaApplication1; public class Main { public static void main(String[] args) { //variable usada para explicar la herencia. int i=0; //Aquí se crea el objeto MiClase imprimir=new MiClase(); imprimir.mensaje=”Hola a todos”; System.out.println("El mensaje es: " + imprimir.mensaje); } }

Si corremos el archivo MiClase.class, la salida será: “El mensaje es: Hola a todos”. Ambos archivos deberán contenerse en una aplicación creada dentro de NetBeans, este proceso se explicara con detalle posteriormente. A grandes rasgos, deberá ir al menú “file”, seleccionar “New Project” aparecerá la ventana de las diferentes categorías, seleccionamos la categoría “Java” y dentro de ella la opción “Java Application” el nombre del archivo Main.class dentro del proyecto. Una vez que tenemos nuestro proyecto, iremos al menú “file”, seleccionamos la opción “New File”, en el campo “Categories” seleccionamos “Java” y en el campo “File Types” seleccionamos “Java Class” en el caso del ejemplo la clase se llama MiClase, debido a ello así se llama el archivo. Con esto tendremos nuestros dos archivos creados y listos para introducir nuestro código. Proyecto: Durante el desarrollo de esta unidad se irán planteando ejercicios, todos los ejercicios serán parte de un proyecto en el cual se tendrá como resultado el uso de todas las herramientas que se analizarán durante el desarrollo de la Unidad I.



Ejercicio 1.1: Inicie un proyecto en NetBeans, una aplicación normal (No de escritorio) Esto creará a su clase principal. Ahora declare una clase, esta clase será nuestra clase base en el proyecto y se llamará “Operaciones”, si lo desea puede poner el nombre que desee pero posteriormente estaremos referencia a esta clase con el nombre aquí propuesto, la clase Operaciones deberá contener una variable para almacenar los resultados de las operaciones. Herencia La herencia es uno de los aspectos de la programación orientada a objetos que se ha definido formalmente. Utilizando la herencia, se puede derivar una nueva clase a partir de una antigua. La clase nueva se llama clase derivada y la clase original, clase base. La idea es añadir lo que se quiera a la nueva clase para darle más funcionalidad a la clase base. La herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave.

class Pato extends Ave { int numero_de_patas; }

La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Un Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato. Además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave. La sintaxis para declarar una clase derivada es similar a la de una clase normal, únicamente debemos agregar la palabra reservada extends seguida del nombre de la clase base.

<modificador>* class <nombre_clase> extends <nombre_clase_base>{ <declarer_atributos>* <declarar_constructor>* <declarar_métodos>* }

Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro el ejemplo de MiClase, aquí hay un ejemplo de una clase derivada aumentando a la función Suma_a_i():



import MiClase; public class MiNuevaClase extends MiClase { public void Suma_a_i( int j ) { i = i + ( j/2 ); } }

Ahora cuando se crea una instancia de MiNuevaClase, esta contendrá todas las características de la clase MiClase y además podrá utilizar el método Suma_a_i(), de ahí que podamos utilizar la variable “i” sin haberla declarado aquí. Debido a que se esta heredando de MiClase, MiNuevaClase puede hacer uso de ella. En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (animal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces. Ejercicio 1.2: Defina cuatro clases que hereden las características de la clase Operaciones. Las nuevas clases serán Suma, Resta, Multiplica y Divide. Hasta este momento ninguna de nuestras clases posee métodos o propiedades. 1.1.2 Eventos Un evento es un suceso en el sistema (tal como una interacción del usuario con la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje adecuado al objeto pertinente. También se puede definir como evento, a la reacción que puede desencadenar un objeto, es decir, la acción que genera. Los lenguajes visuales orientados a eventos y con manejo de componentes dan al usuario que no cuenta con mucha experiencia en desarrollo, la posibilidad de construir sus propias aplicaciones utilizando interfaces gráficas sobre la base de ocurrencia de eventos. Para soportar este tipo de desarrollo interactúan dos tipos de herramientas, una que permite realizar diseños gráficos (En nuestro caso NetBeans) y, un lenguaje de alto nivel que permite codificar los eventos (Java). Con dichas herramientas es posible desarrollar cualquier tipo de aplicaciones basadas en el entorno. Java es uno de los lenguajes de programación que más entusiasmo despiertan entre los programadores, tanto expertos como novatos. En el caso de los programadores expertos por la facilidad con la que desarrollan aplicaciones



complejas en poquísimo tiempo. En el caso de los programadores novatos por el hecho de ver de lo que son capaces a los pocos minutos de empezar su aprendizaje. Java es también un lenguaje orientado a objetos. La diferencia con un lenguaje no orientado a objetos y uno basado en objetos es que el segundo utiliza objetos con propiedades y métodos, pero carece de los mecanismos de herencia y polimorfismo propios de los verdaderos lenguajes orientados a objetos como Java. Existen distintos tipos de programas. Al inicio de la historia de la programación los programas eran de tipo secuencial (también llamados tipo batch). Un programa secuencial es un programa que se arranca, lee los datos que necesita, realiza los cálculos e imprime o guarda en el disco los resultados. Mientras un programa secuencial está ejecutándose no necesita ninguna intervención del usuario. A este tipo de programas se les llama también programas basados u orientados a procedimientos o a algoritmos (procedural languages). Este tipo de programas siguen utilizándose ampliamente en la actualidad, pero la difusión de las PC’s ha puesto de actualidad otros tipos de programación. Los programas interactivos exigen la intervención del usuario en tiempo de ejecución, ya sea para suministrar datos, o bien para indicar al programa lo que debe hacer por medio de menús. Los programas interactivos limitan y orientan la acción del usuario. Por su parte los programas orientados a eventos son los programas típicos de Windows, tales como Netscape, Word, Excel, PowerPoint y otros. Cuando uno de estos programas ha arrancado, lo único que hace es quedarse a la espera de las acciones del usuario, que en este caso son llamadas eventos. El usuario dice si quiere abrir y modificar un archivo existente, o bien comenzar a crear un archivo desde el principio. Estos programas pasan la mayor parte de su tiempo esperando las acciones del usuario (eventos) y respondiendo a ellas. Las acciones que el usuario puede realizar en un momento determinado son variadísimas, y exigen un tipo especial de programación: la programación orientada a eventos. Este tipo de programación es sensiblemente más complicada que la secuencial y la interactiva, pero con los lenguajes visuales de hoy, se hace sencilla y agradable. Ya se ha dicho que las acciones del usuario sobre el programa se llaman eventos. Son eventos típicos el clic sobre un botón, el hacer doble clic sobre el nombre de un archivo para abrirlo, el arrastrar un icono, el pulsar una tecla o combinación de teclas, el elegir una opción de un menú, el escribir en una caja de texto, o simplemente mover el ratón. Cada vez que se produce un evento sobre un determinado tipo de control, NetBeans arranca una determinada función o procedimiento que realiza la acción programada por el usuario para ese evento concreto. Estos



procedimientos se llaman con un nombre que se forma a partir del nombre del objeto y el nombre del evento como se muestra a continuación:

private void botonAbrirMouseClicked

(java.awt.event.MouseEvent evt) {

// TODO add your handling code here:

}

Como se puede observar, el evento que se programará es el clic sobre el objeto botonAbrir, cabe mencionar que al utilizar NetBeans, todo este código se generará automáticamente. Lo único que tendremos que hacer será seleccionar el objeto que deseamos, seleccionar un evento de la pestaña de eventos y dar doble clic. El programa incluso coloca comentarios en el código para guiarnos. Por ejemplo en el evento anterior, se nos indica donde podemos colocar nuestro código. Este proceso se explica con mayor detalle adelante. Para comprender más sobre los eventos tenemos el siguiente ejemplo. Solo se muestra un mensaje de confirmación. Para ello se utiliza la clase JOptionPane, esta clase se analiza a fondo en la unidad II. Ejemplo: Hacer un pequeño ejemplo en el cual se muestre un pequeño mensaje de bienvenida. El código es el siguiente: package proyecto; import javax.swing.JOptionPane; /** * * @author saul.chavez */ public class Main { /** * @param args the command line arguments */ public static void main(String[] args) { JOptionPane.showMessageDialog(null, "Bienvenido al lenguaje Java");

System.Out.Println(Bienvenido al lenguaje Java”

} } El código anterior es tal cual un nuevo proyecto en NetBeans. Para el ejemplo anterior no se tuvo más que crear nuevo proyecto y agregar las líneas en negrita que se encarga de mostrar el mensaje deseado, que es todo lo que hace el programa. Con JOptionPane se crea una ventana como la que se



muestra en la Figura 1.3. Con System.Out.Println(); el mensaje se muestra en modo texto.

Figura 1.3 Ejemplo utilizando JOptionPane.

Hay otro tipo de ventana de diálogo predefinida que necesitaremos conocer en este momento para los ejercicios propuestos. Esta ventana nos servirá para introducir datos gráficamente y se utiliza de la siguiente manera: package proyecto; import javax.swing.JOptionPane; public static void main(String[] args) { JOptionPane.showMessageDialog(null, "Bienvenido al lenguaje Java"); int Valor = Integer.parseInt (JOptionPane.showInputDialog(null, "Introduce un valor"));

} } Lo que se está haciendo en la línea en negritas es declarar una variable entera, mostrar una venta de diálogo que pide un valor y asignarlo a la variable. La instrucción sola que muestra la ventana deseada es:

JOptionPane.showInputDialog(null, "Introduce un valor") Pero esto nos regresa una cadena, no un entero. Por ello utilizamos el método Integer.ParseInt(); que transforma la cadena que reciba en un valor entero. Si se recibe como parámetro una cadena que no representa a un valor entero (como “hola” en lugar de “200”) se producirá un error en al método ParseInt().

Figura 1.4 Ejemplo usando ventanas de diálogo para entrada de datos.

1.1.3 Métodos



Los métodos son funciones de una clase. Generalmente los métodos se dividen en aquellos que se usan internamente en la clase, llamados métodos privados (private), los que se usan fuera de la clase, llamados métodos públicos (public) y los que son usados por la clase y sus derivadas, llamados métodos protegidos (protected). Los métodos privados son generalmente llamados en el interior del objeto por otras partes del mismo. Una vez que se tiene un objeto que soporta métodos, se pueden usar los métodos de esos objetos. En el ejemplo siguiente se usa el método calcular para trabajar con los valores de operando1 y operando2 y almacenar el resultado en la variable resultado. //Suponiendo que ya creamos esta clase

Calculadora objeto = new Calculadora();

double resultado = objeto.calcular(operando1, operando2);

//Suponiendo que el método calcular también fue

programado.

Java soporta dos tipos de métodos: métodos de clase y métodos de instancia. Los métodos de instancia, como en el ejemplo “calcular”, son invocados en objetos (es decir, los objetos son instancias de una clase). Los métodos de clase, por otro lado, son invocados en una clase. Por ejemplo, la clase java.lang.Math tiene un método de clase llamado sqrt que calcula una raíz cuadrada y se puede usar como sigue (no es necesario un objeto): public class MiClase{ public static void main (String [] args) double valor = 4, raiz; raiz = Math.sqrt(valor); System.out.println(“La raíz cuadrada de “ + valor + “ = “ + sqrt); } } La salida de este código es: La raíz cuadrada de 4.0 = 2.0 Ejercicio 1.3: Defina en cada una de las clases de su proyecto, un método que realice la operación a la que su nombre hace referencia (Ej. En la clase Suma un método que sume). Cada método trabajará únicamente con dos operadores, los cuales se recibirán como parámetros cuando una instancia de la clase los



requiera. Utilice la clase JOptionPane ejemplificada anteriormente para obtener los valores. Método main Es un método especial que java reconoce como el punto inicial para que un programa se ejecute desde la línea de comando. Su sintaxis es:

public static void main (String args[]){ //Código}

Siempre debe tener dos modificadores de acceso: public y static. El método main no regresa ningún valor. Acepta cero o más objetos de tipo String. Accesando miembros del objeto

� El operador punto (.) permite accesar a atributos y métodos no privados

de una clase como se muestra en los ejemplos anteriores.

� Dentro de un método no se necesita usar esta notación para accesar

miembros locales del método.

� Generalmente se crean métodos set() y get() para accesar a miembros

de un objeto que no es local.

Polimorfismo El polimorfismo se logra mediante la sobrecarga de métodos. Consiste en crear métodos que se comporten de manera distinta dependiendo de los parámetros con los que trabaje. Por ejemplo, si usted crea una clase cualquiera y en ella define el método “Suma”, el cual realiza la suma de dos operadores, pero usted tiene la necesidad de sumar ahora tres operadores… No necesita crear un nuevo método para realizar dicha acción, para eso sirve la sobrecarga de métodos. La sobrecarga de métodos permite definir diferentes versiones de un método, todos con el mismo nombre pero con diferentes listas de parámetros. Cuando se utiliza un método sobrecargado, el compilador de java sabe cual se desea utilizar por el número y/o tipo de parámetros que se le pasen. Para sobrecargar un método, sólo hay que definirlo más de una vez, especificando una nueva lista de parámetros en cada una de ellas. Cada lista de parámetros debe ser diferente de cualquier otra de alguna forma, el número de parámetros o el tipo de uno o más de ellos. Ejemplo: Sobrecargaremos el método Suma de la clase Calculadora



//Clase original sin sobrecarga. class Calculadora { int Suma(int op1, int op2) { return op1 + op2; } }

Para utilizar la clase anterior el código es el siguiente. public class MiClase{ public static void main(String [] args){ Calculadora calc = new Calculadora(); System.out.println(“Suma 2 más 2 = “ + calc.Suma(2,2)); System.out.println(“Suma 2 más 2 más 2 = “ + calc.Suma(2,2,2)); } }

Como puede ver, la sobrecarga proporciona una técnica potente, con ella podemos evitar problemas clásicos de desorden de código como la declaración de varios métodos con nombres como: “Suma2”, “Suma3” o “SumaDosOp”, “SumaTresOp”, etc. Ejercicio 1.4: Sobrecargue cada uno de los métodos que contienen las clases Suma, Resta, Multiplica y Divide para que trabajen con tres operadores de la siguiente manera: *Suma: Se sumarán los tres operadores. *Resta: el tercer parámetro indicara cuantas veces se desea que se reste el segundo parámetro al primero.

class Calculadora { //método Suma que trabaja con dos operadores

int Suma(int op1, int op2) { return op1 + op2; }

//método Suma que trabaja con tres operadores int Suma(int op1, int op2, int op3)

{ return op1 + op2 + op3; } }



*Multiplica: Se multiplicarán los tres parámetros entre sí. *Divide: El tercer parámetro indicará cuantas veces se desea que se divida el primer parámetro entre el segundo. Los resultados de las operaciones deberán ser manipulados o almacenados en la variable que contiene la clase Operaciones para que la herencia tenga algún sentido y mostrados al usuario por medio de ventanas de diálogo (Utilice la clase JOptionPane para esto). 1.1.4 Propiedades Una propiedad es una asignación que describe algo sobre un objeto como un formulario, un botón, una lista, etc. Dependiendo de la propiedad, se le puede asignar en tiempo de diseño usando la ventana Propiedades y/o en tiempo de ejecución al programar. Los objetos que ya existen en NetBeans como los botones, listas, formularios, etc. Tienen propiedades definidas ya en el lenguaje, por ejemplo:

Figura 1.5 Objeto en NetBeans

Un botón en NetBeans como este posee propiedades como: Font: describe el tipo de letra que contiene el botón. Background: indica el color del fondo del botón. Name: nombre del objeto asignado por el usuario. Como estas propiedades, cada objeto en NetBeans posee sus propiedades específicas, estas propiedades pueden ser modificadas dentro del ambiente grafico de NetBeans en la ventana de propiedades (Los aspectos relacionados con el funcionamiento gráfico serán analizados a profundidad posteriormente) o en el código escribiendo el nombre del objeto seguido de un punto. (<Nombre_objeto>.<Propiedad>), al escribir el punto (.) NetBeans nos mostrará una lista de las propiedades y los métodos del objeto. Ejemplo: si queremos cambiar el texto jButton1 que se encuentra en el botón, utilizamos el método “setText(“String”).

jButton1.setText(“Hola”);

Figura 1.6 Botón con texto editado.

En caso de que se trate de objetos creados por nosotros mismos como se mostró en la parte “1.1.1 Objetos” de este libro, las propiedades son descritas



por los atributos. En Java, los atributos son representados usando variables (estas a su vez son el mecanismo para guardar datos) Declaración de atributos

<modificador>* <tipo> <nombre> [=<valor_inicial>]; Ejemplo:

public class MiClase{ int x; private float y = 10000.0F; public String name = “Saúl Chávez”; …

La palabra private indica que el atributo solo es accesible por los métodos dentro de la clase. El tipo puede ser primitivo o de cualquier clase. Por último, al igual que para los atributos de los objetos de NetBeans, para accesar a las propiedades de un objeto se utiliza el operador punto (.). Ejemplo: MiClase objeto1 = new MiClase(); //Declaramos el objeto

objeto1.x=30; //asignamos un valor al atributo x del objeto Modificadores de acceso Los modificadores de acceso permiten al diseñador de una clase determinar quien accede a los datos y métodos miembros de una clase. Los modificadores de acceso preceden a la declaración de un elemento de la clase (ya sea dato o método), de la siguiente forma:

[modificadores] tipo_variable nombre; [modificadores] tipo_devuelto nombre_Metodo ( lista_Argumentos );

Existen los siguientes modificadores de acceso:

• public - Todo el mundo puede acceder al elemento. Si es un dato, todo

el mundo puede ver el elemento, es decir, usarlo y asignarlo. Si es un

método todo el mundo puede invocarlo.

• private - Sólo se puede acceder al elemento desde métodos de la clase,

o sólo puede invocarse el método desde otro método de la clase.



• protected – Es más accesible que prívate debido a que permite el uso a

todos los elementos de la clase o clases derivadas. Se explicará mas a

detalle en el tema de la herencia.

• sin modificador - Se puede acceder al elemento desde cualquier clase

del package donde se define la clase.

Pueden utilizarse estos modificadores para cualquier tipo de miembros de la clase, incluidos los constructores (con lo que se puede limitar quien puede crear instancias de la clase). 1.2 Entorno Integrado De Desarrollo Un entorno de desarrollo integrado o en inglés Integrated Development Environment (IDE1) es un programa compuesto por un conjunto de herramientas para un programador. Puede dedicarse en exclusiva a un sólo lenguaje de programación o bien, poder utilizarse para varios. 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 GUI2. Los IDEs pueden ser aplicaciones por si solas o pueden ser parte de aplicaciones existentes. El lenguaje Visual Basic por ejemplo puede ser usado dentro de las aplicaciones de Microsoft Office, lo que hace posible escribir sentencias Visual Basic en forma de macros para Microsoft Word. Los IDEs proveen un marco de trabajo amigable para la mayoría de los lenguajes de programación tales como C++, Java, C#, Delphi, Visual Basic, etc. Es posible que un mismo IDE pueda funcionar con varios lenguajes de programación. Para conocer el proceso de instalación de NetBeans (que es el IDE que se utilizará en esta obra) y algunos otros IDE´s consulte el Anexo 1. NetBeans

1 Entorno Integrado de Desarrollo. Programa como NetBeans que proporciona herramientas que facilitan la programación. 2 Graphical User Interface. Interfaz Gráfica de Usuario. (Lo vemos al momento de diseñar gráficamente nuestras aplicaciones gráficas arrastrando botones o cambiando tamaño de los elementos con jalar una esquina, etc.)



Figura 1.7 Pantalla principal de NetBeans

NetBeans se refiere a una plataforma para el desarrollo de aplicaciones de escritorio usando Java y a un entorno de desarrollo integrado (IDE) desarrollado usando la Plataforma NetBeans. La plataforma NetBeans permite que las aplicaciones sean desarrolladas a partir de un conjunto de componentes de software llamados módulos. Un módulo es un archivo Java que contiene clases de java escritas para interactuar con las APIs de NetBeans y un archivo especial (manifest file) que lo identifica como módulo. Las aplicaciones construidas a partir de módulos pueden ser extendidas agregándole nuevos módulos. Debido a que los módulos pueden ser desarrollados independientemente, las aplicaciones basadas en la plataforma NetBeans pueden ser extendidas fácilmente por otros desarrolladores de software. NetBeans es un proyecto de código abierto de gran éxito con una gran base de usuarios, una comunidad en constante crecimiento. Sun MicroSystems3 fundó el proyecto de código abierto NetBeans en junio 2000 y continúa siendo el patrocinador principal de los proyectos.

La Plataforma NetBeans es una base modular y extensible usada como una estructura de integración para crear aplicaciones de escritorio grandes. Empresas independientes asociadas, especializadas en desarrollo de software, proporcionan extensiones adicionales que se integran fácilmente en la plataforma y que pueden también utilizarse para desarrollar sus propias herramientas y soluciones.

3 Sun Microsystems es una empresa informática de Silicon Valley, fabricante de semiconductores y software.



La plataforma ofrece servicios comunes a las aplicaciones de escritorio, permitiéndole al desarrollador enfocarse en la lógica específica de su aplicación. Entre las características de la plataforma están:

• Administración de las interfaces de usuario (ej. menús y barras de

herramientas).

• Administración de las configuraciones del usuario.

• Administración del almacenamiento (guardando y cargando cualquier

tipo de dato).

• Administración de ventanas.

• Framework basado en asistentes (diálogo paso a paso).

Está escrito en Java y existe además un número importante de módulos para extender el IDE NetBeans. El IDE NetBeans es un producto libre y gratuito sin restricciones de uso. Paquetes adicionales de NetBeans. Pack de Movilidad de NetBeans El Pack de Movilidad de NetBeans es una herramienta para desarrollar aplicaciones que se ejecutan en teléfonos móviles. El Pack de Movilidad puede ser usado para escribir, probar, y depurar aplicaciones para la plataforma Java ME4, tecnología existente en dispositivos móviles. Profiler de NetBeans El Profiler de NetBeans es una herramienta para la optimización de aplicaciones Java: Ayuda a encontrar cuellos de botella en la memoria y a optimizar la velocidad de las aplicaciones. El C/C++ Native Development Module Soporta proyectos de C/C++. Más información: http://www.netbeans.org/kb/55/1/cnd-index.html

4 Java ME: Java Micro Edition Herramienta para crear programas para celulares y otras tecnologías moviles.



1.3 Ventanas (proyecto, propiedades, ayuda). Ventana de proyectos

Figura 1.8 Ventana de Proyectos

Esta es la ventana de proyectos de NetBeans, para accesar a ella deberá dar clic sobre el menú File (Archivo) y a continuación en New Project (Nuevo Proyecto). Podrá seleccionar entre los distintos tipos de proyectos, desde aplicaciones de consola, pasando por aplicaciones de escritorio, hasta aplicaciones para celulares o páginas web. Los tipos de proyectos serán analizados en el siguiente tema. (1.4 Tipos de proyectos), por ahora solo se analizan los componentes de las ventanas en cuestión. Como puede observar, esta ventana es muy sencilla, únicamente debe seleccionar la categoría del proyecto que quiere crear y el tipo de proyecto dentro de la categoría que eligió. Si no está seguro que tipo de proyecto debe crear, esta ventana muestra una breve explicación de lo que hará en cada caso en el campo “Description”, bastará con que usted seleccione una categoría y un tipo de proyecto para que se muestre la descripción del mismo en dicho campo. Por ejemplo, podemos ver que se encuentra seleccionada la categoría “Java” y el tipo de proyecto “Java Desktop Application” y debajo nos dice: Crea un esqueleto de una aplicación de escritorio basada en la Swing Application Framework. Este template provee infraestructura básica para aplicaciones como barras de menú, persistencia de estado de ventana, y barras de estado. Con este template, puedes además generar código para



crear una interfaz GUI (Interfaz Gráfica de Usuario) para una tabla de base de datos. Ejemplo: Crearemos un “Hola Mundo” en una aplicación Java. (Java Application).

1. Seleccione la categoría “Java” y el proyecto “Java Application”.

2. De clic sobre el botón “Next”

3. Nos aparece la ventana de Nombre y Localización, esto se refiere

al nombre que tendrá nuestra aplicación y el lugar donde serán

guardados los archivos que se generen.

Figura 1.9 Ventana elegir nombre u ubicación.

4. Especificamos un nombre, en este caso HolaMundo. Este será el

nombre de nuestra clase principal y el archivo. Como se explicó

anteriormente, dentro de nuestro programa debe existir el método

main. NetBeans lo generará automáticamente.

5. Damos clic en “Finish”.

6. Como puede observar, se creó el método Main automáticamente,

incluso tenemos comentarios importantes acerca del código.

Habrá ocasiones en la que no podrá modificar el código generado

automáticamente debido a puede provocar un mal

funcionamiento. Bueno, pasamos a nuestro método main y



escribimos System.out.println("Hola Mundo"); donde se indica

que debemos colocar nuestro código.

7. Damos clic sobre el botón de correr proyecto o presionamos f6 y

veremos que sucede.

Figura 1.10 Hola Mundo en java.

Como puede ver, tenemos una pequeña ventana con el nombre de “Projects”, esta nos muestra el proyecto en el que estamos trabajando y los archivos que necesitamos. Entre esos archivos se encuentran las librerías que incluimos. Ventana Propiedades Para abrir la ventana de propiedades, damos clic sobre el menú “Window” y a continuación en “Properties”. Con esto se mostrará la ventana de propiedades de nuestra aplicación. NetBeans lo conoce como Main.java aunque si lo buscamos en el directorio que se creo, la clase principal se llamará HolaMundo.class. En esta ventana podemos observar información como el nombre, el directorio donde se encuentran los archivos, la hora a la que se modificaron y el directorio donde se crean los archivos de clases que conforman a nuestro proyecto. Por ejemplo el archivo HolaMundo.class.

Aquí ponemos el código

Aquí se muestra la salida

Botón para correr el proyecto



Figura 1.11 Ventana propiedades.

Ventana de Ayuda

Para abrir la ventana de ayuda debe dar clic sobre el menú “Help” y a continuación en “Help Contents”.

Figura 1.12 Ventana Help



En esta ventana, podremos buscar información relacionada con temas específicos listados del lado izquierdo en la ventana de contenido “Contents” o buscar información dentro del contenido mediante algún criterio de búsqueda en la pestaña de “Search” (esta es la más recomendada). No hay ningún grado de dificultad en el uso de esta ventana. Si desea ver la información de los temas listados, únicamente de clic sobre el tema que le interesa, o si le interesa saber algo de algún tema especifico y no sabe en qué tema pueda encontrarlo, utilice la búsqueda. Para ello únicamente debe ingresar una palabra o palabras relacionadas con la información que usted necesita y a continuación se le mostrará un listado de archivos en los que se localizó el criterio de búsqueda. Por ejemplo, buscaremos la información relacionada con un botón. Cabe mencionar que NetBeans le permite ingresar su criterio de búsqueda en el idioma requerido o no obtendrá resultados. Buscar: Button

Figura 1.13 Búsqueda en Ayuda.

En la figura 1.13 se muestra el resultado de la búsqueda.

1.4 Tipos De Proyectos. 1.4.1 Configuración



Como ya se mencionó, Se pueden crear muchos tipos de proyectos de cada categoría en NetBeans, de entre los cuales: Categoría Java Java Application: crea una aplicación en un proyecto estándar de la IDE. Puede generarse la clase main en el proyecto. El proyecto que creamos en esta primera unidad es de este tipo. Java Desktop Application: crea un esqueleto de una aplicación de escritorio basada en la Swing Application Framework (JSR 296). Este template provee infraestructura básica para aplicaciones como barras de menú, persistencia de estado de ventana, y barras de estado. Con este template, puedes además generar código para crear una interfaz GUI (Interfaz Gráfica de Usuario) para una tabla de base de datos. Java Class Library: Crea una librería Java SE (Standard Edition) en un proyecto estándar IDE (Entorno Integrado de Desarrollo). No contiene clase main. Java Project with Existing Sources: importa una aplicación existente de java para crear un proyecto estándar IDE. La aplicación de java se puede importar de múltiples folders. Categoría Web Web Application: Crea una aplicación web vacía en un proyecto IDE estándar. Web Application with Existing Sources: importa una aplicación web existente para crear un proyecto IDE estándar. Como existen muchos proyectos posibles, no se explicará cada uno pero en la ventana de nuevo proyecto existe una pequeña parte, en la cual se describe qué clase de proyecto se creará de acuerdo a la opción y la categoría seleccionadas.



Figura 1.14 Ventana de Proyectos.

1.5 Comentarios En muchas ocasiones, es necesario incluir notas en el código para documentar

un poco y recordar posteriormente para que se utiliza una función u alguna línea de código, para poder hacer esto existen los comentarios:

• Comentarios de una sola línea.

• Comentarios de una o más líneas.

Ejemplos: // Comentarios para una sola línea (doble diagonal).

/* Comentarios de una o más líneas, (diagonal-asterisco

para iniciar le comentario, asterisco-diagonal para

terminarlo.*/

/** Comentario de documentación, de una o más líneas,

(diagonal-asterisco-asterisco para iniciarlo, asterisco-

diagonal para terminarlo. */

Los dos primeros tipos de comentarios son los que todo programador conoce y se utilizan del mismo modo. Los comentarios de documentación, colocados



inmediatamente antes de una declaración (de variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera automáticamente cuando se utiliza la herramienta de Java, javadoc. Dichos comentarios sirven como descripción del elemento declarado permitiendo generar una documentación de nuestras clases escrita al mismo tiempo que se genera el código. Convenciones de nombres SUN recomienda un estilo de codificación que es seguido en el API5 de Java y en este material que consiste en:

• Utilizar nombres descriptivos para las clases, evitando los nombres muy

largos.

• Para los nombres de clases poner la primera letra en mayúsculas y las

demás en minúsculas. Por ejemplo: Empleado o MiClase.

• Si el nombre tiene varias palabras ponerlas todas juntas (sin separar con

- o _) y poner la primera letra de cada palabra en mayúsculas. Por

ejemplo: InstrumentoMusical.

• Para los nombres de miembros (datos y métodos) seguir la misma

norma, pero con la primera letra de la primera palabra en minúsculas.

Por ejemplo: registrarOyente.

• Para las constantes (datos con el modificador final) usar nombres en

mayúsculas, separando las palabras con _

1.6 Constantes En Java, se utiliza la palabra clave final para indicar que una variable debe comportarse como si fuese constante, significando con esto que no se permite su modificación una vez que haya sido declarada e inicializada. Como es una constante, se le ha de proporcionar un valor en el momento en que se declare, por ejemplo:

5 (del inglés Application Programming Interface - Interfaz de Programación de Aplicaciones) es el conjunto de funciones y procedimientos



class Elipse { final float PI = 3.14159; . . . }

Si se intenta modificar el valor de una variable final desde el código de la aplicación, se generará un error de compilación. Si se usa la palabra clave final con una variable o clase estática, se pueden crear constantes de clase, haciendo un uso altamente eficiente de la memoria, porque no se necesitarían múltiples copias de las constantes. La palabra clave final también se puede aplicar a métodos, significando en este caso que los métodos no pueden ser sobrescritos.

1.7 Tipos De Datos Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos. Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de punto flotante, booleanos y de carácter. Los tipos compuestos se basan en los tipos simples, e incluyen las cadenas, las matrices, etc. Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados, para darles valor. En este apartado se explican los tipos de datos simples (o primitivos) que presenta Java, así como los literales que soporta (sintaxis de los valores que se les puede asignar). Tipos de datos simples Es uno de los conceptos fundamentales de cualquier lenguaje de programación. Estos definen los métodos de almacenamiento disponibles para representar información, junto con la manera en que dicha información ha de ser interpretada. Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su identificador. Sintaxis: para la declaración de variables de tipo de dato simple.

Tipo nombre [ = valor] [, nombre [ = valor]…]; Tipos de datos enteros Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y long.

Tipo Tamaño

byte 1Byte (8 bits)



short 2 Bytes (16 bits)

int 4 Bytes (32 bits)

long 8 Bytes (64 bits)

Tabla 1.2 Tipos de datos enteros Literales enteros Son básicos en la programación en Java y presentan tres formatos:

• Decimal: Los literales decimales aparecen como números ordinarios sin

ninguna notación especial.

• Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x ó 0X

inicial, notación similar a la utilizada en C y C++.

• Octal: Los octales aparecen con un 0 inicial delante de los dígitos.

Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12 en decimal, como 0xC en hexadecimal y como 014 en octal. Los literales enteros se almacenan por defecto en el tipo int, (4 bytes con signo), o si se trabaja con números muy grandes, con el tipo long, (8 bytes con signo), añadiendo una L ó l al final del número. La declaración de variables enteras es muy sencilla. Un ejemplo de ello sería:

long numeroLargo = 0xC; // Por defecto vale 12

Tipos de datos en punto flotante Se usan para representar números con partes fraccionarias (o con decimales como los conocemos normalmente). Hay dos tipos de punto flotante: float y double. El primero reserva almacenamiento para un número de precisión simple de 4 bytes y el segundo lo hace para un número de precisión doble de 8 bytes.

Tipo Tamaño

float 4 Bytes (32 bits)

double 8 Bytes (64 bits) Tabla 1.3 Tipos de datos numéricos en punto flotante



Literales en punto flotante Representan números decimales con partes fraccionarias. Pueden representarse con notación estándar (563.84) o científica (5.6384e2). De forma predeterminada son del tipo double (8 bytes). Existe la opción de usar un tipo más corto (el tipo float de 4 bytes), especificándolo con una F ó f al final del número. La declaración de variables de punto flotante es muy similar a la de las variables enteras. Por ejemplo: declaración de variables punto flotante.

double valorDePi = 314.16e-2 ;

float temperatura = (float)36.6

Se realiza un enmascaramiento a temperatura, porque todos los literales con decimales por defecto se consideran double. Tipo de datos boolean Se usa para almacenar variables que presenten dos estados, que serán representados por los valores true y false. Normalmente estamos acostumbrados a utilizar variables enteras como banderas en el código, desperdiciando así mucha memoria, este desperdicio crece conforme vamos creando banderas sobre la marcha, este vicio de programación se arrastra debido a que la mayoría de los programadores aprendieron a programar en lenguajes como C, en cuya estructura no existe un tipo de dato lógico y se tenía que recurrir a los datos tipo entero. Aquí hay una buena opción para disminuir drásticamente este desperdicio. Literales Booleanos Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de falso se representa por un 0 numérico, y verdadero cualquier número que no fuese el 0. Sintaxis: para declarar un dato del tipo booleano se utiliza la palabra reservada boolean.

boolean reciboPagado = false;

Tipo de datos carácter



Se usa para almacenar caracteres Unicode simples. Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas. Literales carácter Representan un único carácter (de la tabla de caracteres Unicode 1.1) y aparecen dentro de un par de comillas simples. De forma similar que en C/C++. Los caracteres especiales (de control y no imprimibles) se representan con una barra invertida ('\') seguida del código carácter.

Descripción Representación Valor Unicode

Caracter Unicode \udddd

Numero octal \ddd

Barra invertida \\ \u005C

Continuación \ \

Retroceso \b \u0008

Retorno de carro \r \u000D

Alimentación de formularios

\f \u000C

Tabulación horizontal \t \u0009

Línea nueva \n \u000A

Comillas simples \’ \u0027

Comillas dobles \" \u0022

Números arábigos ASCII 0-9 \u0030 a \u0039

Alfabeto ASCII en mayúsculas

A.-Z \u0041 a \u005A

Alfabeto ASCII en minúsculas

a.-z \u0061 a \u007A

Tabla1.4: Caracteres especiales Java Sintaxis: Las variables de tipo char se declaran de la siguiente forma

char letraMayuscula = 'A';

// Observe la necesidad de los ' '

char letraV = '\u0056'; // Letra 'V' La clase String



En java las cadenas se gestionan como si fueran objetos. De ahí que String no es un tipo de dato. Se trata de una clase, una de las ventajas de esto es que un objeto de tipo String tiene gran variedad de métodos que se pueden usar. En muchos lenguajes, las cadenas de texto son tipos de datos fundamentales inherentes al lenguaje, pero en java, las cadenas son gestionadas con la clase String. El siguiente es un ejemplo en el que se crea una cadena y se visualiza (observe cómo este código hace la clase String como si fuera otro tipo de dato sencillo).

Public class MiClase{ Public static void main (String [] args){ String cadena1= “¡¡Hola Mundo!!”; System.out.println(cadena1); } }

La clase String es muy ponderosa, pues con los métodos que proporciona permite convertir la cadena en un arreglo de caracteres, convertir números en cadenas, buscar cadenas, crear sub-cadenas, cambiar la cadena de mayúsculas a minúsculas o viceversa, obtener la longitud de la cadena, comparar cadenas y mucho mas. Algunos de los métodos de la clase String son los siguientes:

int lastIndexOf (int ch) Devuelve el índice, dentro de la cadena, de la última ocurrencia del carácter especificado.

int lastIndexOf (int ch, int fromIndex)

Produce el índice, dentro de la cadena de la última ocurrencia del carácter dado, buscando hacia atrás desde el índice especificado.

int lastIndexOf (String str) Devuelve el índice, dentro de la cadena, de la ocurrencia del String dado.

int lastIndexOf (String str, int fromIndex) Produce el índice dentro de la cadena de la última ocurrencia del carácter dado.

int length() Devuelve la longitud de la cadena

String replace (char oldChar, char newChar)

Produce una nueva cadena substituyendo todas las ocurrencias de oldChar con newChar

boolean startsWith (String prefix) Chequea si la cadena empieza con el prefijo dado.

boolean startsWith (String prefix, int offset)

Chequea si la cadena empieza con el prefijo dado, empezando en el índice dado.



char[] to CharArray () Convierte una cadena en un arreglo de caracteres.

String toLowerCase () Cambia todos los caracteres de la cadena a su equivalente en minúsculas.

String to UpperCase() Cambia los caracteres de una cadena a su equivalente en mayúsculas.

String trim()

Elimina los espacios en blanco que encuentre iniciando la búsqueda desde ambos extremos de la cadena.

Static String valueOf (boolean b) Produce la representación de la cadena del argumento booleano.

Static String valueOf (char b) Produce la representación de la cadena del argumento char

Static String valueOf (char [] data) Produce la representación de la cadena del arreglo de caracteres.

Static String valueOf(char[] data, offset, int count)

Produce la representación de la cadena de un sub arreglo específico del argumento char array de enteros.

Static String valueOf (doubleb) Produce la representación String de un double.

Static String valueOf (float b) Produce la representación String de un float.

Static String valueOf (int b) Produce la representación String de un int.

char charAt (int index) Proporciona el carácter del índice especificado.

int compareTo (Object o) Compara este objeto String con otro.

int compareToIgnoreCase(String otraCadena)

Compara dos cadenas ignorando diferencias entre mayúsculas y minúsculas.

int compareTo (String otraCadena) Compara que dos cadenas sean exactamente iguales.

String concat(String str) Concatena la cadena dada al final de la cadena.

Boolean endsWith (String sufijo) Verdadero si la cadena termina con el sufijo dado.

Tabla 1.5 Métodos de la clase String. Conversión de tipos de datos En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. Este proceso se denomina "conversión", “cast”, “enmascaramiento”, "moldeado" o "tipado". La conversión se lleva a cabo colocando el tipo destino entre paréntesis, a la izquierda del valor que queremos convertir de la forma siguiente:

char c = (char)System.in.read();



La función read devuelve un valor int, que se convierte en un char debido a la conversión (char), y el valor resultante se almacena en la variable de tipo carácter c. El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del int, con lo que si contienen información útil, esta se perderá. Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente":

Tipo Origen Tipo Destino

byte double, float, long, int, char, short

short double, float, long, int

char double, float, long, int

int double, float, long

long double, float

float Double Tabla 1.6 Conversiones sin pérdidas de información

1.8 Variables Las variables pueden ser de diferentes tipos y actúan como gestores de memoria de datos. Los diferentes tipos tienen que ver con el formato de los datos que almacenan en ellas, así como con la memoria que es necesaria para gestionar ese dato. Por ejemplo, la variable de tipo entero (int), es de 4 bytes (o 32 bits) y se utiliza para almacenar valores enteros. Esto hace que un dato de tipo int pueda tomar un rango de valores que van desde -2,147,483,648 hasta 2,147,483,647. Antes de usar una variable en java, debe declararse especificando su tipo. Sintaxis: como declarar una variable en Java.

Tipo nombre [ = valor] [, nombre [ = valor]…]; Ejemplo: declaración de una variable tipo int.



public class MiClase{ public static void main (String[] args){ int dias; dias = 365; System.out.println("Número de días = " + dias); } }

En este código se reservan 32 bits de memoria y se etiqueta esa ubicación de forma que el compilador entienda la variable dias, luego recibe el valor 365 y por último, se visualiza en pantalla. Esta es la salida que se muestra en pantalla:

Número de días = 365; Como puede ver, hemos creado una variable para almacenar un valor y luego visualizarlo. Una variable puede ser inicializada en el momento de declararla, por ejemplo:

public class MiClase{ public static void main (String[] args){ int días = 365; System.out.println("Número de días = " + dias); } }

Los tipos primitivos para la declaración de variables son:

• Enteros: Estos tipos son byte, short, int y long, que guardan el signo y el

valor.

• Números en punto flotante: Estos tipos son float y double; almacenan

números flotantes con signo.

• Caracteres: char, en estas se guardan caracteres tanto alfabéticos como

numéricos.

• Booleano: en este tipo se guardan únicamente dos valores: verdadero

(true) o falso (false).

Tipo de Variable Almacenamiento en

bytes Rango de Valores

boolean 1 Verdadero, Falso byte 1 -128 a 127 char 2 N/A

double 8 -1.79769313486232E308 a -94065645841247E-324



para valores negativos y 4.94065645841247E-324 a

1.79769313486232E308 para valores positivos.

Float 4

-3.402823E38 a -1.401298E-45 para valores negativos y 1.401298E-45

a 3.402823E38 para valores positivos.

int 4 -2,147,483,648 a 2,147,483,647

Long 8

-9,223,372,036,854,775,808

a 9,223,372,036,854,775,807

Short 2 -32,768 a 32,767 Tabla1.7 Tipos de variables.

La tabla 1.7 muestra los tipos de variables. Strings Como se mencionó anteriormente, no existe un tipo de dato String, se trata de una clase con métodos y constructores. Entonces, la declaración de una variable String dependerá del constructor que se desea utilizar. La manera más sencilla es String nombre; y posteriormente asignas cualquier valor que queramos. Sin embargo si usted tiene la necesidad de crearlas de una manera distinta, aquí se muestran algunos de sus constructores.

Constructor Descripción

String () Inicializa un nuevo objeto String para gestionar una secuencia de caracteres vecía.

String (byte[] bytes)

Construye un nuevo objeto String convirtiendo el arreglo de bytes mediante la codificación de caracteres que tiene la plataforma por defecto.

String (byte[] bytes, int offset, int length)

Construye un nuevo objeto String convirtiendo el subarreglo de bytes usando la codificación de caracteres por defecto.

String (byte[] bytes bytes, int offset, enc)

Construye un Nuevo objeto String convirtiendo el entero length y el subarreglo de caracteres utilizando la codificación de caracteres especificada.

String (byte[] bytes, String enc) Construye un nuevo objeto String convirtiendo el arreglo de bytes mediante la codificación de caracteres



que se especifica.

String (char[] value) Aloca un nuevo objeto String para representar la secuencia de caracteres.

Tabla 1.8 Constructores de la clase String. La tabla 1.8 muestra la lista de constructores. Ejemplos: Distintas formas de crear e inicializar cadenas.

Esta forma ya la hemos visto. public class MiClase{ public static void main (String [] args){ String s1 = “Hola Mundo!”;

. . . } }

Declaramos una cadena y la inicializamos posteriormente.

public class MiClase{ public static void main (String [] args){ String s1 = “Hola Mundo!”; String s2; s2 = “Hola!”;

. . } }

Creamos una cadena vacía y luego le asignamos datos.


string s3 = new String();

s3 = “Hola de nuevo!”;

. } }

Utilizamos uno de los constructores de la clase String.




string s3 = new String(); s3 = “Hola de nuevo!”; String s4 = new String(“Usamos

Constructor!”);

.

. . } }

1.9 Operadores Los operadores son un tipo de tokens que indican una evaluación o computación para ser realizada en objetos o datos, y en definitiva sobre identificadores o constantes. Además de realizar la operación, un operador devuelve un valor, ya que son parte fundamental de las expresiones. El valor y tipo que devuelve depende del operador y del tipo de sus operandos. Por ejemplo, los operadores aritméticos devuelven un número como resultado de su operación. Los operadores realizan alguna función sobre uno, dos o tres operandos. Los operadores que requieren un operando son llamados operadores unarios. Por ejemplo, el operador "++" es un operador unario que incrementa el valor de su operando en una unidad. Los operadores unarios en Java pueden utilizar tanto la notación prefija como la posfija. La notación prefija indica que el operador aparece antes que su operando. ++contador; // Notación prefija, se evalúa a: contador+1

La notación posfija indica que el operador aparece después de su operando: contador++ // Notación posfija, se evalúa a: contador

Los operadores que requieren dos operandos se llaman operadores binarios. Por ejemplo el operador "=" es un operador binario que asigna el valor del operando del lado derecho al operando del lado izquierdo.



Todos los operadores binarios en Java utilizan notación infija, lo cual indica que el operador aparece entre sus operandos.

operando1 <operador> operando2 Por último, los operadores ternarios son aquellos que requieren tres operandos. El lenguaje Java tiene el operador ternario, "?", que es una sentencia similar a la if-else. Este operador ternario usa notación infija; y cada parte del operador aparece entre operandos:

expresión ? operación1 : operación2 Los operadores de Java se pueden dividir en las siguientes cuatro categorías:

• Aritméticos.

• De comparación y condicionales.

• A nivel de bits y lógicos.

• De asignación.

Operadores aritméticos El lenguaje Java soporta varios operadores aritméticos para los números enteros y en punto flotante. Se incluye + (suma), - (resta), * (multiplicación), / (división), y % (módulo, es decir, resto de una división entera). La tabla 1.9 muestra los operadores aritméticos. Por ejemplo: sumaEste + aEste; //Suma los dos enteros divideEste % entreEste; //Calcula el resto de dividir 2 enteros

Operador Uso Descripción

+ op1 + op2 Suma op1 y op2

- op1 - op2 Resta op2 de op1

* op1 * op2 Multiplica op1 por op2 / op1 / op2 Divide op1 entre op2

% op1 % op2 Calcula el resto de dividir op1 entre op2

Tabla1.9 Operadores aritméticos binarios de Java



El tipo de los datos devueltos por una operación aritmética depende del tipo de sus operandos; si se suman dos enteros, se obtiene un entero. Estos operadores se deben utilizar con operandos del mismo tipo, o si no realizar una conversión de tipos de uno de los dos operandos al tipo del otro. El lenguaje Java sobrecarga la definición del operador “+” para incluir la concatenación de cadenas. El siguiente ejemplo utiliza “+” para concatenar la cadena "Contados ", con el valor de la variable contador y la cadena " caracteres.": System.out.print("Contados" + contador + "caracteres.");

Esta operación automáticamente convierte el valor entero de contador a una cadena de caracteres. Los operadores + y - tienen versiones unarias que realizan las siguientes operaciones:


+ +op Convierte op a entero si es un byte, short o char

- -op Niega aritméticamente op Tabla 1.10 Versiones unarias de los operadores "+" y "-"

El operador - realiza una negación del número en complemento a 2, es decir, cambiando de valor todos sus bits y sumando 1 al resultado final:

42 -> 00101010 -42 -> 11010110

Existen dos operadores aritméticos que funcionan como atajo de la combinación de otros: ++ que incrementa su operando en 1, y -- que decrementa su operando en 1. Ambos operadores tienen una versión prefija, y otra posfija. La utilización correcta es crítica en situaciones donde el valor de la sentencia es utilizado en mitad de un cálculo más complejo, por ejemplo para control de flujos.


++ op++ Incrementa op en 1; se evalúa con valor anterior al incremento

++ ++op Incrementa op en 1; se evalúa con valor posterior al incremento

-- op-- Decrementa op en 1; se evalúa con valor anterior al incremento

-- --op Decrementa op en 1; se evalúa con valor posterior al



incremento Tabla 1.11 Operaciones con "++" y "--"

Operadores de comparación y condicionales Un operador de comparación compara dos valores y determina la relación existente entre ambos. Por ejemplo, el operador “!=” devuelve verdadero (true) si los dos operandos son distintos. La siguiente tabla resume los operadores de comparación de Java:

Operador Uso Devuelve verdadero si

> op1 > op2 op1 es mayor que op2

>= op1 >= op2 op1 es mayor o igual que op2

< op1 < op2 op1 es menor que op2

<= op1 <= op2 op1 es menor o igual que op2

== op1 == op2 op1 y op2 son iguales

!= op1 != op2 op1 y op2 son distintos Tabla: Operadores de comparación

Los operadores de comparación suelen ser usados con los operadores condicionales para construir expresiones complejas que sirvan para la toma de decisiones. Un operador de este tipo es “&&”, el cual realiza la operación booleana and. Por ejemplo, se pueden utilizar dos operaciones diferentes de comparación con “&&” para determinar si ambas relaciones son ciertas. La siguiente línea de código utiliza esta técnica para determinar si la variable index de una matriz se encuentra entre dos límites (mayor que cero y menor que la constante NUMERO_ENTRADAS):

( 0 < index ) && ( index < NUMERO_ENTRADAS ) Se debe tener en cuenta que en algunos casos, el segundo operando de un operador condicional puede no ser evaluado. En caso de que el primer operando del operador && sea falso, Java no evaluará el operando de la derecha:

(contador < NUMERO_ENTRADAS) && ( in.read() != -1 ) Si contador es mayor o igual que NUMERO_ENTRADAS, el valor de retorno de && puede ser determinado sin evaluar el operando de la parte derecha. En este caso in.read no será llamado y un carácter de la entrada estándar no será leído. Si el programador quiere que se evalúe la parte derecha, deberá utilizar el operador & en lugar de &&. De la misma manera se relacionan los operadores || y | para la exclusión lógica (OR).



Java soporta cinco operadores condicionales, mostrados en la siguiente tabla:

Operador Uso Devuelve verdadero si...

&& op1 && op2 op1 y op2 son ambos verdaderos, condicionalmente evalúa op2

& op1 & op2 op1 y op2 son ambos verdaderos, siempre evalúa op1 y op2

|| op1 || op2 op1 o op2 son verdaderos, condicionalmente evalúa op2

| op1 | op2 op1 o op2 son verdaderos, siempre evalúa op1 y op2

! ! op op es falso Tabla 1.12 Operadores condicionales

Además Java soporta un operador ternario, el “?:”, que se comporta como una versión reducida de la sentencia if-else:

expresion ? <operacion1> : operacion2 El operador ?: evalúa la expresion y devuelve operación1 si es cierta, o devuelve operación2 si expresion es falsa. Operadores de bit Un operador de bit permite realizar operaciones de bit sobre los datos. Existen dos tipos: los que desplazan (mueven) bits, y operadores lógicos de bit. Operadores de desplazamiento de bits

Operador Uso Operación

>> op1 >> op2 Desplaza los bits de op1 a la derecha op2 veces

<< op1 << op2 Desplaza los bits de op1 a la izquierda op2 veces

>>> op1 >>> op2 Desplaza los bits de op1 a la derecha op2 veces (sin signo)

Tabla 1.13 Operadores de desplazamiento de bits Los tres operadores de desplazamiento simplemente desplazan los bits del operando de la parte izquierda el número de veces indicado por el operando de la parte derecha. El desplazamiento ocurre en la dirección indicada por el operador. Por ejemplo, la siguiente sentencia, desplaza los bits del entero 13 a la derecha una posición:

13 >> 1; La representación en binario del número 13 es 1101. El resultado de la operación de desplazamiento una posición a la derecha es 110 o 6 en decimal. Se debe tener en cuenta que el bit más a la derecha se pierde en este caso.



Un desplazamiento a la derecha una posición es equivalente a dividir el operando del lado izquierdo por 2, mientras que un desplazamiento a la izquierda de una posición equivale a multiplicar por 2, pero un desplazamiento es más eficiente computacionalmente hablando, que una división o multiplicación. El desplazamiento sin signo >>> funciona de la siguiente manera:

• Si se desplaza con signo el número -1 (1111), seguirá valiendo -1, dado

que la extensión de signo sigue introduciendo unos en los bits más

significativos.

• Con el desplazamiento sin signo se consigue introducir ceros por la

izquierda, obteniendo el número 7 (0111).

Operadores de lógica a nivel de bits La lógica de bits (lógica de Bool) se utiliza para modelar condiciones biestado y trabajar con ellas (cierto/falso, true/false, 1/0). En Java hay cuatro operadores de lógica de bits:

Operador Uso Operación

& op1 & op2 AND

| op1 | op2 OR ^ op1 ^ op2 OR Exclusivo

~ ~op2 Complemento Tabla 1.14 Operadores de lógica a nivel de bits

El operador & realiza la operación AND de bit. Aplica la función AND sobre cada par de bits de igual peso de cada operando. La función AND es evaluada a cierto si ambos operandos son ciertos. Por ejemplo vamos a aplicar la operación AND a los valores 12 y 13:

12 & 13 El resultado de esta operación es 12. ¿Por qué?. La representación en binario de 12 es 1100, y de 13 es 1101. La función AND pone el bit de resultado a uno si los dos bits de los operandos son 1, sino, el bit de resultado es 0: 1100 & 1101 ----------- 1100



El operador | realiza la operación OR de bit. Aplica la función OR sobre cada par de bits de igual peso de cada operando. La función OR es evaluada a cierto si alguno de los operandos es cierto. Entonces 12 | 13 genera el resultado 13. El operador ^ realiza la operación OR exclusivo de bit (XOR). Aplica la función XOR sobre cada par de bits de igual peso de cada operando. La función XOR es evaluada a cierto si alguno de los operandos es cierto, pero no los dos. Entonces 12 ^ 13 genera el resultado 1. Para finalizar, el operador de complemento invierte el valor de cada bit del operando. Convierte el falso en cierto, y el cierto en falso. Entre otras cosas, la manipulación bit es útil para gestionar indicadores booleanos (banderas). Supongamos, por ejemplo, que se tienen varios indicadores booleanos en nuestro programa, los cuales muestran el estado de varios componentes del programa: esVisible, esArrastrable, etc... En lugar de definir una variable booleana para cada indicador, se puede definir una única variable para todos ellos. Cada bit de dicha variable representará el estado vigente de uno de los indicadores. Se deberán utilizar entonces manipulaciones de bit para establecer y leer cada indicador. Primero, se deben preparar las constantes de cada indicador. Esos indicadores deben ser diferentes unos de otros (en sus bits) para asegurar que el bit de activación no se solape con otro indicador. Después se debe definir la variable de banderas, cuyos bits deben de poder ser configurados según el estado vigente en cada indicador. El siguiente ejemplo inicia la variable de banderas flags a 0, lo que significa que todos los indicadores están desactivados (ninguno de los bits es 1):

final int VISIBLE = 1;

final int ARRASTRABLE = 2;

final int SELECCIONABLE = 4;

final int MODIFICABLE = 8;

int flags = 0;

Para activar el indicador VISIBLE, se deberá usar la sentencia:

flags = flags | VISIBLE; Para comprobar la visibilidad se deberá usar la sentencia:

if ( (flags & VISIBLE) == 1 )

Operadores de asignación



El operador de asignación básico es el =, que se utiliza para asignar un valor a otro. Por ejemplo:

int contador = 0; //Inicia la variable contador con 0.

Java además proporciona varios operadores de asignación que permiten realizar un atajo en la escritura de código. Permiten realizar operaciones aritméticas, lógicas, de bit y de asignación con un único operador. Supongamos que necesitamos sumar un número a una variable y almacenar el resultado en la misma variable, como a continuación:

i = i + 2; Se puede abreviar esta sentencia con el operador de atajo +=, de la siguiente manera:

i += 2; La siguiente tabla muestra algunos de los operadores de atajo de asignación y sus equivalentes largos:

Operador Uso Equivalente a

+= op1 += op2 op1 = op1 + op2 -= op1 -= op2 op1 = op1 - op2

*= op1 *= op2 op1 = op1 * op2

/= op1 /= op2 op1 = op1 / op2

%= op1 %= op2 op1 = op1 % op2

&= op1 &= op2 op1 = op1 & op2 Tabla 1.15 Operadores de atajo de asignación

Precedencia de operadores Cuando en una sentencia aparecen varios operadores el compilador deberá de elegir en qué orden aplica los operadores. A esto se le llama precedencia. Los operadores con mayor precedencia son evaluados antes que los operadores con una precedencia menor. Cuando en una sentencia aparecen operadores con la misma precedencia:

• Los operadores de asignación son evaluados de derecha a izquierda.

• Los operadores binarios, (menos los de asignación) son evaluados de

izquierda a derecha.



Se puede indicar explícitamente al compilador de Java cómo se desea que se evalúe la expresión con paréntesis balanceados ( ). Para hacer que el código sea más fácil de leer y mantener, es preferible ser explícito e indicar con paréntesis que operadores deben ser evaluados primero. La siguiente tabla muestra la precedencia asignada a los operadores de Java. Los operadores de la tabla están listados en orden de precedencia: cuanto más arriba aparezca un operador, mayor es su precedencia. Los operadores en la misma línea tienen la misma precedencia:

Tipo de operadores Operadores de este tipo

Operadores posfijos [ ] . (parametros) expr++ expr--

Operadores unarios ++expr --expr +expr -expr ~ !

Creación o conversión new (tipo) expr

Multiplicación * / %

Suma + -

Desplazamiento << >> >>>

Comparación < > <= >= instanceof

Igualdad == !=

AND a nivel de bit &

OR a nivel de bit ^

XOR a nivel de bit |

AND lógico &&

OR lógico ||

Condicional ? :

Asignación = += -= *= /= %= &= ^= |= <<= >>= >>>= Tabla1.16 Precedencia de operadores

Por ejemplo, la siguiente expresión produce un resultado diferente dependiendo de si se realiza la suma o división en primer lugar:

x + y / 100 Si no se indica explícitamente al compilador el orden en que se quiere que se realicen las operaciones, entonces el compilador decide basándose en la precedencia asignada a los operadores. Como el operador de división tiene mayor precedencia que el operador de suma el compilador evaluará y/100 primero. Así:

x + y / 100 Es equivalente a:

x + (y / 100)



1.10 Sentencias La unidad básica de ejecución es una sentencia, Java determina el fin de una sentencia mediante el “;”. Un bloque es un conjunto de sentencias comprendidas entre dos llaves ({ }). Es importante remarcar que los bloques definen el alcance de las variables y que los bloques pueden anidarse. Como la mayoría de los lenguajes de programación Java tiene sentencias condicionales y de ciclo (ciclo). A continuación se presentan breves ejemplos, cada sentencia se explica con gran detalle en el punto 1.13 Estructuras de control.

Condicionales

if(<condición>){ <sentencia>* }

if(<condición>){ <sentencia>* }else{ <sentencia>* }

switch(<variable>){ case<valor>: <sentencia>* break; case<valor>: <sentencia>* break; default: <sentencia>* break; }

Ciclos o Ciclos

for(<valor_inicial>;<condición>;<incremento>){ <sentencia>* }

while(<condición>){ <sentencia>* }

do{ <sentencia>* } while(<condición>);

Tabla 1.17 Sentencias condicionales y de ciclo. Como los bloques se pueden anidar no hay problemas por definir una sentencia de control dentro de otra:



Las condiciones deben ser sentencias que forzosamente devuelven un booleano (un valor cierto o falso), por lo tanto una asignación i=34 no es una condición válida, ni el 0 es equivalente a false o el 1 a true. break: La palabra reservada break puede utilizarse para romper la secuencia de ejecución dentro de los ciclos. continue: La palabra reservada continue funciona de forma similar a break con la diferencia que no rompe el ciclo, sino que simplemente se salta una iteración. 1.11 Matrices Se define como un conjunto de datos del mismo tipo organizados en dos o más columnas y uno o más renglones, es decir es un arreglo bidimensional o una tabla. Los arreglos con dos dimensiones se utilizan a menudo para representar tablas de valores, que constan de información ordenada en filas y columnas. Para identificar un elemento especifico de una tabla, se deben especificar los índices. Por convención, el primer índice indica la fila del elemento y el segundo, su columna. En Java los arreglos bidimensionales son arreglos de arreglos. Como era de esperarse, se parecen y actúan como los arreglos multidimensionales. Las matrices se derivan de los arreglos (arrays), de hecho son arreglos multidimensionales, debido a ello daré una breve explicación sobre ellos. Inicialización de arreglos Para inicializar los arreglos unidimensionales, únicamente hay que poner los valores entre llaves, un valor detrás de otro, separados por comas, empezando con el primer valor del arreglo. Ejemplo: Declaración e inicialización de un arreglo. public class MiClase{ public static void main (String [] args){ double cuentas[] = {345.6, 999.0, 0, 1000.5}; cuantas[3] = 1000.5; System.out.println("La cuenta 3 debe $" + cuentas[3]); } }

Declaración de matrices Se pueden declarar matrices de una manera muy similar a como se declaran los arreglos, solo se incluyen un par de corchetes adicionales. Serian arreglos multidimensionales. De hecho, se agrega un par de corchetes adicionales por



cada dimensión, por ejemplo, para un arreglo, que es de una dimensión, se incluye un par de corchetes, para uno bidimensional, se incluirán dos pares.

Tipo nombre [][]….; Sintaxis: Declaración y creación de una matriz de dos filas y 100 columnas

tipo nombreMatriz [][] = new tipo [filas][columnas]; tipo [][] nombreMatriz = new tipo [filas][columnas];

Ejemplo:

double accounts [][] = new double [2][100]; Podría incluso declarar arreglos de mas dimensiones. Ejemplo: Declaración de un arreglo de cuatro dimensiones. double cuentas [][][][] = new double [2] [3] [4] [5];

Usted podría declarar únicamente una matriz y crearla posteriormente. Ejemplo: public class MiClase{ public static void main (String [] args){ double cuentas[][]; //declaración de la matriz //demás sentencias cuentas = new double[2][4];//creación de la matriz cuentas[0][0] = 1000.5; System.out.println("Valor en cuentas [0][0]"+ cuentas[0][0]); } } Inicialización de matrices Las matrices se pueden inicializar cuando se les declara, de la misma forma que inicializaron lo arreglos; basta con poner un par de corchetes para cada dimensión y poner los valores con los que se quiere inicializar el arreglo dentro de los mismos. Ejemplo: public class MiClase{ public static void main (String [] args){



double cuentas[][] = {{10.1, 14.4, 5067.88, 7.7}, {345.67, 67.8, 678.890, 43.0}};

System.out.println("Valor en cuentas [0][3]"+ cuentas[0][3]); } }

Creación de matrices

Como en otros lenguajes de programación, en Java, las matrices, son arreglos de arreglos. Esto quiere decir que se pueden construir arreglos como se quiera; como en el ejemplo siguiente, en el que cada fila de un arreglo de dos dimensiones tiene un diferente número de elementos.

Ejemplo:

public class MiClase{ public static void main (String [] args){

double matriz[][] = new double [5][]; matriz[0] = new double [500]; matriz[1] = new double [400]; matriz[2] = new double [300]; matriz[3] = new double [50]; matriz[4] = new double [5]; matriz[0][3] = 4567.886;

System.out.println("En matriz [0][3] "+ cuentas[0][3]); } }

Mostrar una matriz Mostrar una matriz en la pantalla de texto es difícil, ya que Java no dispone de una función que sitúe el cursor de texto en una posición de la pantalla, como lo hace la función gotoxy disponible en los lenguajes C/C++. La única alternativa que queda es mostrar los elementos de una fila unos a continuación de los otros separados por un tabulador, después otra fila y así hasta mostrar todos los elementos de la matriz. En el siguiente ejemplo se muestra en pantalla una matriz de 2 x 3; primero se inicializa la matriz en la línea int [][]a ={{1,2,3},{10,20,30}};. Se separan los elementos de una fila mediante el carácter tabulador '\t', Cuando se acaba una fila se inserta un retorno de carro '\n' y se continua con la siguiente fila, y así sucesivamente.



public class MiClase{ public static void main (String [] args){ int[][] matriz = {{1,2,3},{10,20,30}}; for (int fila=0; fila<2; fila++){ for(int columna=0; columna<3; columna++){ System.out.println( matriz[fila][columna] +"\t"); } System.out.println("\n"); } } }

Como inicializamos la matriz con dos grupos de números, estos representarán dos columnas, y como cada grupo de números contiene tres números, cada uno de ellos es una fila, recomiendo que si es confuso identificar el número de filas y de columnas al inicializar una matriz al momento de su declaración, créela de alguna de las otras maneras explicada anteriormente.

La salida es:

1 2 3 10 20 30

1.12 Procedimientos y funciones Funciones Supongamos que queremos depositar todo nuestro dinero ganado como programadores. Hay dos bancos en los que podemos llevar a cabo un depósito y ganar algunos intereses. El primero, lo llamamos "Banco A", nos ofrecen un interés con una tasa mensual del 1 % mas una bonificación final del 5%. El segundo, el "Banco B", nos ofrece una tasa del 1.5 %. Realizamos un algoritmo para obtener el mayor beneficio. El programa calculará el monto obtenido en un período de 12 meses con un cálculo de interés compuesto. Para darnos una mejor idea de lo que tenemos que hacer elaboramos el algoritmo principal.

double monto = 10000; double meses = 12; for ( int n = 1; n <= meses; n++){ monto = monto + monto * interés / 100; }

Al monto inicial le sumamos las sucesivas capitalizaciones que ganamos mes a mes, hasta llegar a un período de 12 meses.



Con este algoritmo probado, codificamos el programa: public class ShowMeTheMoney{ public static void main(String args[]){ int meses = 12; float interesBanco1 = 1f; float bonificBanco1 = 5f; float interesBanco2 = 1.5f; double monto = 10000; double montoBanco1 = monto; double montoBanco2 = monto; for ( int n = 1; n <= meses; n++){ montoBanco1+=montoBanco1 * interesBanco1 / 100; } montoBanco1 += montoBanco1 * bonificBanco1 /100; for ( int n = 1; n <= meses; n++){ montoBanco2+=montoBanco2 * interesBanco2 / 100; } System.out.println("Importe final del banco1 : " + montoBanco1); System.out.println("Importe final del banco2 : " + montoBanco2); } }

Esto ocurrirá cada vez que tengamos que realizar un cálculo de intereses. Si la elección se extendiera a, por ejemplo, cinco bancos, tendríamos que copiar el algoritmo para cada uno de ellos. Para no tener que repetir una y otra vez lo mismo, podemos recurrir a una técnica muy utilizada en programación: dividir el código en funciones. Una función es un conjunto de instrucciones que ejecutan una rutina y devuelven un resultado. El resultado puede depender de parámetros de entrada. Una función se construye de la siguiente manera:

tipo_resultado nombre_función (tipo_parámetro nombre_parámetro, ... ) { sentencia1; sentencia2; ... sentenciaN; return unValor; }

Se debe definir el tipo de dato del resultado y el nombre que identifica a la función. Además, opcionalmente se pueden definir parámetros de entrada con el tipo de dato y su nombre. Una función permite que reutilicemos un algoritmo. En el caso de nuestro problema bancario, podemos reutilizar el cálculo de interés aplicándolo a cada banco. Veamos cómo se construye esta función:



double interesCompuesto(double monto, float tasa, int períodos){ for(int n = 1; n <= períodos; n++ ){ monto += monto * tasa / 100; } return monto; }

Necesitamos definir ciertos datos de entrada para ejecutar el algoritmo. Vamos a necesitar el monto inicial, la tasa de interés y el período. A su vez definimos el tipo de datos del resultado. La función nos devuelve el monto final, entonces el tipo de dato es double. Para identificar a la función le hemos puesto el nombre de interesCompuesto. Para utilizar la función en el programa la llamamos por su nombre. Como la función devuelve un resultado, tendremos que almacenarlo en una variable que tenga un tipo de dato compatible con el resultado.

double montoBanco2 = interesCompuesto(10000 , interesBanco2, meses); Debemos pasar los parámetros como se han definido, en el mismo orden y con el mismo tipo de dato. Conociendo como se arma y se invoca una función, estamos listos para utilizarla en nuestro programa. public class ShowMeTheMoney2{ static double interesCompuesto(double monto, float tasa, int períodos){ for(int n = 1; n <= períodos; n++ ){ monto += monto * tasa / 100; } return monto; } public static void main(String args[]){ int meses = 12; float interesBanco1 = 1f; float bonificBanco1 = 5f; float interesBanco2 = 1.5f; double monto = 10000; double montoBanco1 = monto; double montoBanco2 = monto; montoBanco1 = interesCompuesto( montoBanco1, interesBanco1, meses ); montoBanco1 += montoBanco1 * bonificBanco1 /100; montoBanco2 = interesCompuesto( montoBanco2, interesBanco2, meses ); System.out.println("Importe final del banco1 : " + montoBanco1); System.out.println("Importe final del banco2 : " +



montoBanco2); } } Ejercicio 1.5: Cree una función que muestre un menú que le permita decidir qué operación realizar. Esto de acuerdo al proyecto que se ha venido desarrollando. De acuerdo a cada opción, el usuario deberá ingresar un número o una letra que identifique cada opción. Procedimientos Los procedimientos son también funciones programadas por el usuario. Son muy parecidos a los métodos, de hecho muchas personas que publican tutoriales o guías en la red, se refieren a los procedimientos como métodos. Los procedimientos son invocados escribiendo el nombre del objeto, seguido del operador punto (.), y después el nombre del procedimiento que ofrece la clase y que describe sus atributos y comportamientos. Como cualquier rutina los métodos pueden incorporar argumentos. Declaración de procedimientos

Sintaxis. <modificador>*<tipo_regresado><nombre>(<argumentos>*){ <cuerpo>* }

• Los modificadores pueden ser: public, protected , prívate.

• El modificador de acceso público indica que el procedimiento puede ser

llamado desde otro código.

• Un procedimiento privado indica que solo puede ser llamado por otros

métodos dentro de la clase.

• Se pueden sobrecargar los procedimientos. (Procedimientos con el

mismo nombre pero que funcionan diferente de acuerdo a los

parámetros que reciben.)

Ejemplo: crear el procedimiento setPeso, esta función nos servirá para asignar un valor a este atributo del objeto y otro procedimiento que nos regrese dicho valor. (getPeso)



public class Perro{ private int peso; public int getPeso(){ return peso; } public void setPeso(int nuevoPeso){ if(nuevoPeso > 0){ peso = nuevoPeso; } }

}

Para sobrecargar un procedimiento utilizaremos lo que se conoce como polimorfismo. Esta función ya fue analizada y ejemplificada en la parte 1.1.1 Objetos, de cualquier forma he aquí una breve explicación. Para sobrecargar un procedimiento, sólo hay que definirlo más de una vez, especificando una nueva lista de parámetros en cada una de ellas. Cada lista de parámetros debe ser diferente de cualquier otra de alguna forma, el número de parámetros o el tipo de uno o más de ellos. Ejemplo: Sobrecargaremos el método setPeso del ejemplo anterior.

public class Perro{ private int peso; public int getPeso(){ return peso; } public void setPeso(int nuevoPeso){ if(nuevoPeso > 0){ peso = nuevoPeso; } } public void setPeso(int nuevoPeso, int viejoPeso){ if(nuevoPeso > 0 && viejoPeso<100){

peso = nuevoPeso;

}

} } La referencia this En ocasiones es conveniente disponer de una referencia que apunte al propio objeto que se está manipulando. Esto se consigue con la palabra reservada this. this es una referencia implícita que tienen todos los objetos y que apunta a sí mismo. Por ejemplo:



//Se ejemplifica el uso de this public class Perro{ private int peso; public void setPeso(int peso){ this.peso = peso; } public Perro elPesoMayor(Perro nuevo){ if( peso > nuevo.peso) return this; else return nuevo;

} } /*En este ejemplo se compara el valor de la variable peso de dos objetos, lo que se regresa es el objeto cuyo valor en peso sea mayor.*/

El método elPesoMayor devuelve una referencia al perro que tiene mayor peso, comparando los pesos del Perro nuevo que se recibe como argumento y el propio. En caso de que el propio resulte mayor el método debe devolver una referencia a sí mismo. Esto se consigue con la expresión return this. Al ir avanzando conocerá métodos en los cuales se debe enviar o recibir como parámetro un objeto, en todos esos casos será de mucha utilidad la referencia this. Ejercicio 1.6: Realice los cambios necesarios (diseñar clase, procedimientos o funciones) para agregar funcionalidad a nuestra aplicación. Agregue por lo menos 3 habilidades nuevas a nuestra calculadora. Por ejemplo: sacar la raíz cuadrada, elevar un número a una potencia, etc. Obviamente estas nuevas opciones deberán aparecer en nuestro menú por lo que deberá modificar algunas de sus funciones. 1.13 Estructuras de control Durante un programa existen acciones que se han de repetir un número determinado de veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in se codificaría:

in.read();

in.read();

in.read();

Este código además de poco elegante sería inviable para una repetición de 3000 lecturas. Por eso aparecen las estructuras de control, que facilitan que determinadas acciones se realicen varias veces, mientras que una condición se



cumpla, y en definitiva, tomar decisiones de qué hacer en función de las condiciones que se den en el programa en un momento dado de su ejecución. Ejemplo:

int contador=0; for ( contador=0 ; contador < 3 ; contador++ ) in.read();

Donde bastaría cambiar el 3 por cualquier otro número para que la lectura se repitiese ese número de veces. El lenguaje Java soporta las siguientes estructuras de control:

Sentencia Clave

Toma de decisión if-else, switch-case

Ciclo for, while, do-while

Diversas break, continue, label:, return Tabla1.18 Estructuras de control

Las sentencias condicionales: if y switch La sentencia if - else La sentencia if-else de Java dota a los programas de la habilidad de ejecutar distintos conjuntos de sentencias según algún criterio. Sintaxis: La sintaxis de la sentencia if-else es:

if ( condición ){ // Código a ejecutar si la condición es cierta } else{ //Código a ejecutar si la condición es falsa }

La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia vacía; para representar que en ese caso no se ha de ejecutar nada. Supongamos que un programa debe realizar diferentes acciones dependiendo de si el valor de una variable es mayor o igual a cero, este valor lo escribimos nosotros en un campo de texto que se llama “campoDeTexto”. Nuestro programa puede realizar esto usando la sentencia if - else:



int variable=Integer.parseInt(campoDeTexto.getText()); if (variable >= 0) { //que hacer si es mayor o igual a cero System.out.println( "Entró a >= 0 " ); } else { //que hacer si no es mayor o igual que cero System.out.println( "Entró a <0 " ); }

Se pueden anidar expresiones if-else, para poder implementar aquellos casos con múltiples acciones. Esto es lo que se suele denominar como sentencias else if. Por ejemplo, supongamos que se desea escribir un programa que clasifique según el contenido de una variable valor, asigne una letra a una variable clasificación. A para un valor del 91-100, B de 81-90, C para 71-80 y F (Método de calificar de EUA) si no es ninguno de los anteriores:

int valor; //leer valor char clasificacion; if (valor > 90){ clasificacion='A'; } else if (valor > 80){ clasificacion='B'; } else if (valor > 70){ clasificacion='C'; } else{ clasificacion='F'; }

Se pueden escribir los if en las mismas líneas que los else. Este sistema de programación (else if) no es demasiado recomendable cuando crece la cantidad de condiciones, por ello el lenguaje Java incluye la sentencia switch, que veremos a continuación, para dirigir el flujo de control de variables con múltiples valores.



La sentencia switch Mediante la sentencia switch se puede seleccionar entre varias sentencias según el valor de cierta expresión. Sintaxis: La forma general de switch es la siguiente

switch ( <expresionMultivalor> ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3: conjuntoDeSentencias; break; default: conjuntoDeSentencias; break; }

La sentencia switch evalúa la expresiónMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la cláusula case cuyo valor corresponda con el de la expresiónMultivalor. Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el devuelto por la expresiónMultivalor de la sentencia switch. Las sentencias break que aparecen después del conjuntoDeSentencias provocan que el control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habrá que eliminar algunos break. Finalmente, se puede usar la sentencia default para manejar los valores que no son explícitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado. Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operación: int mes; //asignar un valor a mes switch ( mes ){ case 1: System.out.println( "Enero" ); break; case 2: System.out.println( "Febrero" ); break; case 3: System.out.println( "Marzo" ); break; //Demás meses



case 12: System.out.println( "Diciembre" ); break; default: System.out.println( "Mes no valido" ); break; } El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede decidir cuál usar basándonos en la legibilidad, aunque se recomienda utilizar switch para sentencias con más de tres o cuatro posibilidades. Ejercicio 1.7: Utilice las herramientas anteriores para crear dos maneras distintas de mostrar el menú de nuestra aplicación. Al inicio, el usuario deberá elegir uno de los dos (Uno que use if else y el otro switch) Sentencias de iteración o ciclos: for, do, while Ciclo while El ciclo while es el ciclo básico de iteración. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición. La forma general del ciclo while es la siguiente:

while ( expresiónBooleana ) { sentencias; };

Las sentencias se ejecutan mientras la expresiónBooleana tenga un valor de verdadero. Se utiliza, por ejemplo para estar en un ciclo del que no hay que salir mientras que no se cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que sea mayor que 100:

int i = 1; while ( i <= 100 ) { i = i * 2; }

Ciclo do-while El ciclo do-while es similar al ciclo while, pero en el ciclo while la expresión se evalúa al principio del ciclo y en el ciclo do-while la evaluación se realiza al final, es decir hasta que se cumpla una determinada condición. La forma general del ciclo do-while es la siguiente:



do { sentencias; } while ( expresiónBooleana );

La sentencia do-while debe utilizarse cuando el ciclo deba ser ejecutado por lo menos una vez. Por ejemplo, cuando se lee información de un archivo, se sabe que siempre se debe leer por lo menos un carácter:

int c; do { c = System.in.read( ); // Sentencias para tratar el carácter c } while ( c != -1 ); // No se puede leer más (Fin del archivo)

Ciclo for La forma general de la sentencia for es la siguiente:

for ( iniciación ; terminación ; incremento ){

sentencias; }

La iniciación es una sentencia que se ejecuta una vez antes de entrar en el ciclo. La terminación es una expresión que determina cuándo se debe terminar el ciclo. Esta expresión se evalúa al final de cada iteración del ciclo. Cuando la expresión se evalúa a falso, el ciclo termina. El incremento es una expresión que es invocada en cada iteración del ciclo. En realidad puede ser una acción cualquiera, aunque se suele utilizar para incrementar una variable contador:

for ( i = 0 ; i < 10 ; i++ ) Algunos (o todos) estos componentes pueden omitirse, pero los puntos y coma siempre deben aparecer (aunque sea sin nada entre sí). Se debe utilizar el ciclo for cuando se conozcan las restricciones del ciclo (su instrucción de iniciación, criterio de terminación e instrucción de incremento). Por ejemplo, los ciclos for son utilizados comúnmente para iterar sobre los elementos de una matriz, o los caracteres de una cadena:



// cad es una cadena (String) for ( int i = 0; i < cad.length() ; i++){ // hacer algo con el elemento i-ésimo de cad }

Un ciclo for, normalmente involucra a tres acciones en su ejecución:

o Inicialización de la variable de control (clausula inicio)

o Comprobación del valor de la variable de control en una expresión

condicional (clausula test)

o Actualización de la variable de control (clausula incremento)

La cláusula de inicio y la cláusula de incremento pueden estar compuestas por varias expresiones separadas mediante el operador coma (,).

for ( a=0,b=0; a < 7; a++,b+=2 ) El operador coma garantiza que el operando de su izquierda se ejecutará antes que el operando de su derecha. Las expresiones de la cláusula de inicio se ejecutan una sola vez, cuando arranca el ciclo. Cualquier expresión legal se puede emplear en esta cláusula, aunque generalmente se utiliza para inicialización. Las variables se pueden declarar e inicializar al mismo tiempo en esta sentencia:

for( int cnt=0; cnt < 2; cnt++ ) La segunda cláusula, consiste en una expresión que debe evaluarse a false para que el ciclo concluya. En Java, esta segunda expresión debe ser de tipo booleano, de tal modo que se pueden utilizar únicamente expresiones relacionales o expresiones relacionales y condicionales. El valor de esta segunda cláusula es comprobado cuando la sentencia comienza la ejecución y en cada una de las iteraciones posteriores. Sentencias de salto: break, continue y return Sentencia break La sentencia break provoca que el flujo de control salte a la sentencia inmediatamente posterior al bloque en curso. Ya se ha visto anteriormente la sentencia break dentro de la sentencia switch. Se puede etiquetar una sentencia poniendo un identificador Java válido seguido por dos puntos antes de la sentencia:

nombreSentencia: sentenciaEtiquetada



La sentencia break se utiliza para salir de una sentencia etiquetada, llevando el flujo del programa al final de la sentencia de programa que indique:

break nombreSentencia2; Un ejemplo de esto sería el programa:

void gotoBreak() { System.out.println("Ejemplo de break como 'goto' "); a: for ( int contadorUno=1; contadorUno <10; contadorUno++ ){

System.out.print("contadorUno ="+ contadorUno); for( int contadorDos =1; contadorDos <10; contadorDos++ ){

if (contadorDos ==5 ) break a; //Sale de los dos ciclos!!!

System.out.print("contadorDos ="+ contadorDos);

} System.out.print("No llega aquí"); } }

Al interpretar break a, no solo se rompe la ejecución del ciclo interior (el de contadorDos), sino que se salta al final del ciclo contadorUno, obteniéndose: contadorUno = 1 contadorDos = 1 contadorDos = 2 ontadorDos = 3 contadorDos = 4 No se aconseja esta forma de programación, basada en goto, y con saltos de flujo “no controlados”. Sentencia continue Del mismo modo que en un ciclo se puede desear romper la iteración, también se puede desear continuar con el ciclo, pero dejando pasar una determinada iteración. Se puede usar la sentencia continue dentro de los ciclos para saltar a otra sentencia, aunque no puede ser llamada fuera de un ciclo o ciclo. Tras la invocación a una sentencia continue se transfiere el control a la condición de terminación del ciclo, que vuelve a ser evaluada en ese momento, y el ciclo continúa o no dependiendo del resultado de la evaluación. En los ciclos for además en ese momento se ejecuta la cláusula de incremento (antes de la evaluación). Por ejemplo el siguiente fragmento de código imprime los números del 0 al 9 no divisibles entre 3:



for (int cont = 0 ; cont < 10 ; cont++) {

if ( ( cont % 3 ) == 0 ) continue; System.out.print( " " + cont ); }

Del mismo modo que break, en las sentencias continue se puede indicar una etiqueta de bloque al que hace referencia. Con ello podemos referirnos a un bloque superior, si estamos en ciclos anidados. Si dicha etiqueta no es indicada, se presupone que nos referimos al ciclo en el que la sentencia continue aparece. Por ejemplo, el siguiente fragmento de código:

void gotoContinue( ) { f: for ( int cont1=1; cont1 <5; cont1 ++ ) { for ( int cont2 =1; cont2 <5; cont2 ++ ) { if (cont2 > cont1 ) { System.out.println(" "); continue f; } System.out.print( " " + (cont1 * cont2) ); } } }

En este código la sentencia continue termina el ciclo de cont2 y continúa el flujo en la siguiente iteración de cont1. La salida es: 1 2 4 3 6 9 4 8 12 16 No se aconseja esta forma de programación, basada en goto, y con saltos de flujo “no controlados”. Sentencia return La última de las sentencias de salto es la sentencia return, que puede usar para salir de la función, procedimiento o método en curso y retornar a la sentencia que realizó la llamada. Para devolver un valor, simplemente se debe poner el valor (o una expresión que calcule el valor) a continuación de la palabra return. El valor devuelto por return debe coincidir con el tipo declarado como valor de retorno del método.



Cuando un método se declara como void se debe usar la forma de return sin indicarle ningún valor. Ejemplo:

int contador; boolean condicion; int devuelveContadorIncrementado(){ return ++contador; } void metodoReturn(){ //Sentencias if ( condicion == true ) return; //Más sentencias a ejecutar si condición ¡= true }

Ejercicio 1.8: Hasta el momento, las herramientas que hemos utilizado permiten que nuestra aplicación se utilice una vez, eligiendo una de las opciones y termine su ejecución. Utilice ciclos (ciclos) para lograr que la aplicación se ejecute de manera indefinida hasta que se le presente la opción salir. Agregue la opción salir. 1.14 Controles básicos y sus propiedades. Una Interfaz gráfica de Usuario (GUI) presenta un mecanismo amigable al usuario para interactuar con un programa. Las GUI se crean a partir de componentes de la GUI (también conocidos como controles [accesorios de ventana]). Un componente de la GUI es un objeto con el cual interactúa el usuario mediante el ratón, el teclado u otra forma de entrada. Los componentes de la GUI en Java se encuentran en java.awt o en javax.swing (existe una diferencia entre los .swing y los .awt pero se analizará a profundidad posteriormente). Los componentes de GUI son parte de la JFC6 (Java Foundation Classes), las bibliotecas de Java para el desarrollo de GUI´s para múltiples plataformas. El Swing es una extensión de AWT así que a los métodos o clases se les antepuso la ‘J’ para saber que era de Swing AWT SWING

Button JButton Label JLabel

A continuación, presentaré por medio de ejemplos la manera como se crean aplicaciones con controladores básicos. Cabe mencionar que lo que está a

6 Java Foundation Classes; Clases de la fundación java.



punto de aprender, es hecho por NetBeans automáticamente, de cualquier manera, usted puede necesitar modificar el código por lo que será mejor conocer su estructura básica. Etiquetas // Nombre del archivo: PruebaEtiqueta.java // Demostración de la clase JLabel. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class PruebaEtiqueta extends JFrame { private JLabel etiqueta1; // crearemos la etiqueta en el constructor public PruebaEtiqueta() { super( "Prueba de JLabel" ); //este texto sale en la ventana //Así se crea la ventana. Container contenedor = getContentPane(); //Línea anterior: Se crea el contenedor contenedor.setLayout( new FlowLayout() ); //Línea anterior: Forma de organizar los elementos. // constructor de JLabel con un argumento cadena etiqueta1 = new JLabel( "Etiqueta con texto" ); //este es el texto de la etiqueta etiqueta1.setToolTipText( "Esta es la etiqueta1" ); //esto sale si dejas el cursor sobre ella. contenedor.add( etiqueta1 ); //le agregamos al contenedor la etiqueta y ya está. setSize( 275, 170 ); setVisible( true ); } // fin del constructor public static void main( String args[] ) { PruebaEtiqueta aplicacion = new PruebaEtiqueta(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }



} // fin de la clase PruebaEtiqueta La salida se muestra en la figura 1.15:

Figura 1.15 Ejemplo de una etiqueta.

Como se puede observar, el código en si es muy autodocumentado, de ahí los estándares en los nombres de variables y clases. Con los comentarios la comprensión del código se incrementa aún más aunque no se recomienda inundar tanto el código con comentarios. Campos de texto En el ejemplo siguiente, se crean varios tipos de campos de texto, normales, para passwords, editables, no editables, etc. // Nombre del Archivo: PruebaCampoTexto.java // Demostración de la clase JTextField. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class PruebaCampoTexto extends JFrame { private JTextField campoTexto1, campoTexto2; private JPasswordField campoContrasenia; // configurar GUI public PruebaCampoTexto() { super( "Prueba de JTextField y JPasswordField" ); Container contenedor = getContentPane(); contenedor.setLayout( new FlowLayout() ); // crear campo de texto con tamaño predeterminado campoTexto1 = new JTextField( 10 ); contenedor.add( campoTexto1 ); // crear campo de texto con texto predeterminado campoTexto2 = new JTextField( "Escriba el texto aquí" ); contenedor.add( campoTexto2 ); // crear campo de contraseña con texto // predeterminado, se verán asteriscos campoContrasenia = new JPasswordField( "Texto oculto" );



contenedor.add( campoContrasenia ); // registrar manejadores de eventos ManejadorCampoTexto manejador = new ManejadorCampoTexto(); campoTexto1.addActionListener( manejador ); campoTexto2.addActionListener( manejador ); campoContrasenia.addActionListener( manejador ); setSize( 325, 100 ); setVisible( true ); } // fin del constructor de PruebaCampoTexto public static void main( String args[] ) { PruebaCampoTexto aplicacion = new PruebaCampoTexto(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); } //clase interna privada para el manejo de eventos, //en este caso se usa para escuchar al teclado. //Para que lo que escribamos se muestre en ese campo. private class ManejadorCampoTexto implements ActionListener { // procesar eventos de campo de texto public void actionPerformed( ActionEvent evento ) { String cadena = ""; // el usuario oprimió Intro en objeto JTextField campoTexto1 if ( evento.getSource() == campoTexto1 ) cadena = "campoTexto1: " + evento.getActionCommand(); // el usuario oprimió Intro en objeto JTextField campoTexto2 else if ( evento.getSource() == campoTexto2 ) cadena = "campoTexto2: " + evento.getActionCommand(); // el usuario oprimió Intro en objeto JTextField campoContrasenia else if ( evento.getSource() == campoContrasenia ) { cadena = "campoContrasenia: " + new String( campoContrasenia.getPassword() ); } JOptionPane.showMessageDialog( null, cadena ); } // fin del método actionPerformed } // fin de la clase interna privada ManejadorCampoTexto



} // fin de la clase PruebaCampoTexto

Debido al tamaño que tiene el código de este ejemplo por sí solo, se omitieron comentarios de instrucciones que ya fueron explicadas anteriormente. JTextArea En el siguiente ejemplo, se utilizan objetos JTextArea. El ejemplo consiste enmostrar como copiar texto seleccionado de un área de texto a otra, usando métodos de la clase JTextArea. package jtextarea_ej; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Main extends JFrame { private JTextArea areaTexto1, areaTexto2; private JButton botonCopiar; // configurar Interfaz grafica public Main() { super( "Ejemplo del uso de JTextArea" ); Box cuadro = Box.createHorizontalBox(); //Creamos la ventana String cadena = "Ésta es una cadena de"+ "\ndemostración para\nilustrar cómo copiar"+ "texto\nde un área de texto a \n" + "otra, utilizando un\nevento externo"; // establecer areaTexto1 areaTexto1 = new JTextArea( cadena, 10, 15 ); cuadro.add( new JScrollPane( areaTexto1 ) ); // Creamos el botón Copiar y le asignamos el // ActionListener para el evento. botonCopiar = new JButton( "Copiar" ); //Lo creamos cuadro.add( botonCopiar ); //Le ponemos texto botonCopiar.addActionListener( new ActionListener() { // clase interna anónima // Creamos un método que copie el texto seleccionado // de un campo a otro //cuando detecte el evento sobre el botón.



public void actionPerformed( ActionEvent evento ){ areaTexto2.append( areaTexto1.getSelectedText() ); } } // fin de la clase interna anónima ); // fin de la llamada a addActionListener // establecer areaTexto2 areaTexto2 = new JTextArea( 10, 15 ); areaTexto2.setEditable( false ); cuadro.add( new JScrollPane( areaTexto2 ) ); // agregar cuadro al panel de contenido Container contenedor = getContentPane(); contenedor.add( cuadro ); // colocar en in BorderLayout.CENTER setSize( 425, 200 ); setVisible( true ); } // fin del constructor de Main (no se onfunda por el public static void main( String args[] ){ Main aplicacion = new Main(); aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); } } // fin de la clase

JScrollPane Esto es un ejemplo de cómo usar el JScrollPane. Para ello vamos a poner una imagen dentro de un JLabel y esta a su vez dentro de un JScrollPane. Todo ello dentro de un JFrame para visualizarlo. El JFrame saldrá con el tamaño necesario para ver la imagen completa (la línea que dice ventana.pack() hace eso). Para que aparezcan las barras de scroll hay que redimensionar la ventana, haciéndola más pequeña que la imagen. También, en el código, se podría usar el método: setVerticalScrollBarPolicy (JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

De JScrollPane para obligar a que salga siempre la barra vertical. Hay un método similar para la horizontal. package pruebajscrollpane; import javax.swing.*; public class PruebaJScrollPane {



/** Crea una instancia de PruebaJScrollPane */ public PruebaJScrollPane() { // La ventana JFrame ventana = new JFrame("Imagen"); // El panel de scroll JScrollPane scroll = new JScrollPane(); // La etiqueta. JLabel etiqueta = new JLabel(); // Se carga la imagen, con path absoluto para evitar // problemas y debe ser un gif. Icon imagen = new ImageIcon ("E:/ angelodemonio.gif); // Se mete la imagen en el label etiqueta.setIcon (imagen); // Se mete el scroll en la ventana ventana.getContentPane().add(scroll); // Se mete el label en el scroll scroll.setViewportView(etiqueta); // Y se visualiza todo. ventana.pack(); ventana.setVisible(true); } /** * Programa principal. Instancia un PruebaJScrollPane */ public static void main(String[] args) { new PruebaJScrollPane(); } }



Figura 1.16 Ejemplo de ScrollBar no a la vista.

Si la imagen no es .gif, no funciona. Para que aparezcan los scrolls debe hacer la ventana más pequeña que la imagen, como se muestra a continuación. Si desea que aparezcan sin tener que modificar la imagen utilice el método que se mencionó anteriormente.

Figura 1.17 Ejemplo de ScrollBar a la vista.



EJERCICIO PROPUESTOS

1.1 ¿En qué consiste la programación orientada a eventos?

1.2 Defina que es un objeto, un evento, un método y sus propiedades.

1.3 ¿Qué es un entorno integrado de desarrollo?

1.4 ¿Para qué sirven los comentarios dentro del código de una aplicación?

1.5 ¿Qué tipos de comentarios existen?

1.6 ¿Qué es una estructura de control?

1.7 Investigar la clase Exception de Java. Mencione sus métodos más

importantes.

1.8 Diseñe las clases que serían necesarias para crear un sistema de

inventarios para una tienda de ropa. A la tienda le interesa llevar un control

sobre sus empleados, sus productos, sus clientes y las ventas realizadas para

llevar un control contable, no es necesario programarlas.

1.9 Diseñe una clase llamada Factorial, su finalidad será calcular el factorial de

un número, este número deberá ser solicitado por el programa y el resultado

deberá ser comunicado al usuario. Utilice una función recursiva para lograrlo.

Ejemplo:

public class RecursivaApp{ public static void main(String[] args){ System.out.println("Factorial de 5 "+factorial(5)); } static long factorial(int n){ //función recursiva //... } }

Variaciones:



� Posteriormente utilice la herencia para crear una clase que calcule el

factorial de 2 números dados (obviamente por separado).

� Utilice también el polimorfismo para que dependiendo de si se le envía 1

o 2 parámetros realice los cálculos de cada uno.

1.10 Crear una clase en java que permita resolver ecuaciones de segundo

grado (forma: ax2 + bx + c = 0). Si en los resultados de una ecuación dada

existe una raíz compleja (raíz de número negativo) deberá mostrarse la

expresión que la represente.

1.11 Crear una clase que contenga un arreglo de números enteros y cuyas

funciones miembro realicen las siguientes funciones:

� Encontrar el valor mayor. � Encontrar el valor más pequeño del arreglo. � Calcular un promedio de los valores. � Ordenar los numero del arreglo de mayor a menor. Los resultados deberán ser mostrados al usuario.

Variaciones:

� Crear una clase que pida n valores enteros para llenar un arreglo.

Posteriormente crear 4 clases que hereden de la anterior para utilizar su

método de creación del arreglo y realicen las 4 operaciones descritas.

1.12 Crear una clase que contenga las siguientes funciones:

� Calcular y mostrar el valor absoluto de un número entero. � Determinar si un número dado por el usuario es primo o no.

Variación:

� Utilizar el polimorfismo para lograr que una función realice las operaciones anteriores dependiendo de si recibe un número entero (calcular valor absoluto) o un numero entero y un carácter (determinar si el valor dado es primo)

1.13 Llenar un arreglo de caracteres de n elementos y determinar:

� Cuántas letras mayúsculas existen. � Cuántas letras minúsculas existen. � Cuántas vocales.



Los caracteres que no entren en ninguna de estas clasificaciones deberán

ser ignoradas y llenar el arreglo únicamente con letras mayúsculas y

minúsculas.

1.14 Crear una clase que contenga un método que liste los divisores de un

número dado.

1.15 Dada las siguientes variables:

int a = 8 , b = 3;

double suma = 10.241;

char letra = ‘R’;

Indique los resultados que imprimen las siguientes instrucciones:

� System.out.println(“Este es el resultado de ”+ a*a); � System.out.println(a+“ + 3 vale ”+ (a+3) ); � System.out.println(“Creo que voy a ”+ letra+”eprobar esta materia =(

!!!”); � System.out.println(letra); � System.out.println(“Este es el resultado de ”+ a/suma); � System.out.println(“Este es el resultado de ”+ b*suma); � System.out.println(“Este es el resultado de ”+ b-suma);

1.16 Diseñar una clase que pida un número n al usuario y muestre los primeros

n números de la serie fibonacci (Investigue como se calcula la serie fibonacci).



PROYECTOS INTEGRÁLES.

Crear un proyecto en NetBeans como el que se desarrollo a lo largo de la Unidad I. La funcionalidad será la siguiente:

Proyecto 1:

• Calcular las áreas de distintas figuras geométricas. Por ejemplo:

triángulos, rectángulos, etc.

• Diseñe las clases necesarias, implemente herencia y polimorfismo.

• Programe lo necesario para crear un menú con las opciones

correspondientes.

• Utilice objetos gráficos como JOptionPane para ingresar los datos con

los que desea trabajar.

Proyecto 2:

• Crear una agenda en memoria manejando arreglos para almacenar la

información. (Nombre, Teléfono, Mail, Dirección)

• Crear un menú para la aplicación que permita agregar a una nueva

persona, después de ello, guardar su información personal. Utilice al

manejo de arreglos para almacenar la información como usted desee.

(Si conoce el manejo de listas de objetos será más eficiente).

• El sistema deberá ser capaz de realizar altas, bajas, modificaciones y

consultas de la información que se haya almacenado en dichos arreglos

o listas. Y el menú obviamente deberá contener dichas opciones.

Proyecto 3:

• Desarrolle una aplicación que realice operaciones con matrices

cuadradas.

• Suma, resta y multiplicación, serán las operaciones que se realicen. El

usuario deberá especificar el tamaño de las matrices. Posteriormente se



llenarán con valores aleatorios de 1 a 9 y se presentaran en consola al

usuario.

• Deberá existir la opción de generar matrices nuevas.

• Por último, el usuario especificará que operación desea realizar con

ellas. Y se le presentarán los resultados.

• Utilice arreglos bidimensionales, herencia, polimorfismo.

Unidad 2. Controles, Eventos, Métodos y Componentes.

Aplicaciones gráficas.

ITM Unidad II Controles, Eventos, Métodos y Componentes


2.1 Controles Estándar. Al hablar de controles estándar en NetBeans, hacemos referencia a los botones, campos de texto, etiquetas y todas esas herramientas que más comúnmente utilizamos en nuestras aplicaciones. A continuación se describe el proceso mediante el cual se crean o se modifican dichos controles. Para ejemplificar todo el proceso, iremos desarrollando una aplicación de escritorio en la cual incorporaremos los controles estándar y daremos alguna funcionalidad para conocer mejor su funcionamiento. Primero crearemos una aplicación de escritorio, para ello hay que crear un proyecto en NetBeans de tipo Java Desktop Application. La manera de crear un proyecto ya se explicó anteriormente, debemos ir al menú File (Archivo) y a continuación en New Project (Nuevo Proyecto). Podrá seleccionar entre los distintos tipos de proyectos, desde aplicaciones de consola, pasando por aplicaciones de escritorio, hasta aplicaciones para celulares o páginas web, en este caso debemos seleccionar la categoría “Java” y el tipo de proyecto mencionado y presionar “Next”.

Figura 2.1 Ventana “Nuevo Proyecto”

Aparece la ventana de Nombre y Localización, esto se refiere al nombre que tendrá nuestra aplicación y el lugar donde serán guardados los archivos que se generen.



Figura 2.2 Ventana de configuracion de proyecto.

Especificamos un nombre, en este caso AplicacionDeEscritorio. Este será el nombre de nuestra clase principal. Como se explicó anteriormente, dentro de nuestro programa debe existir el método main. NetBeans lo generará automáticamente. Damos clic en “Finish” para que se cree el proyecto y a continuación podremos ver nuestra área de trabajo con todas las herramientas necesarias.

Figura 2.3 Área de trabajo de NetBeans

Habrá ocasiones en la que no podrá modificar el código generado automáticamente debido a puede provocar un mal funcionamiento. Damos clic sobre el botón de correr proyecto o presionamos f6 y veremos que sucede.



Figura 2.4 Aplicación de escritorio vacía. (Esto es lo que se muestra.)

Como puede observar, por default tenemos ya una pestaña de Archivo “File” y una de ayuda “Help”, esto es debido a que es el template o esqueleto de aplicación de escritorio por default de NetBeans, también se tienen los íconos para ampliar la ventana, minimizarla o cerrarla. Si lo deseamos podremos remover o cambiar lo que sea. Una vez que tenemos nuestra aplicación de escritorio podremos crear controles y agregarlos a la misma de una manera tan sencilla como arrastrarlos al lugar donde los necesitemos. Para eso, tenemos la ventana del lado derecho de la pantalla con la leyenda “Palette”, en ella podremos localizar los componentes comunes que encontramos en una aplicación.

Figura 2.5 Paleta de controles.

Botones. Los botones proporcionan al usuario una forma rápida de iniciar alguna acción. Hay que hacer clic sobre ellos. A los botones se les puede dar una inscripción,



como “¡Presióneme!”. Cuando el usuario hace clic sobre un botón, el código recibe una notificación. Hay dos tipos de botones entre los cuales seleccionar. El primero es el “Button”, este tipo de botón no permanece presionado, posee dos estados:

• Presionado: el momento en que se da clic al botón.

• No presionado: el estado normal del botón.

A diferencia del “Toggle Button” que cambia de estado al ser presionado. También posee dos estados pero los maneja de una manera distinta al anterior.

• Presionado: al dar clic sobre el botón, queda presionado, no regresa a

su estado anterior como el tipo de botón anterior.

• No presionado: estado inicial del botón, para cambiar de un estado a

otro debemos dar clics.

Para crear un botón, únicamente tenemos que arrastrarlo de la Paleta de componentes a nuestra ventana de aplicación y ubicarlo en el lugar que queramos. Presione f6 para observar que sucede.

Figura 2.6 Programa en ejecución con dos botones de ejemplo.

En este momento los botones no tienen función alguna, el cómo agregar función a estos elementos se analizará en el apartado siguiente 2.2 Eventos del formulario. Recuerde que java es un lenguaje orientado a eventos y con ellos se dará funcionalidad a los controles del formulario. Modificar propiedades.



Como puede observar, los botones tienen texto predeterminado, este texto se almacena en una de las muchas propiedades de los objetos, veamos como modificar algunas de estas propiedades. Para modificar las propiedades de los objetos, basta con seleccionar la propiedad deseada en la ventana de propiedades que se encuentra en la parte derecha de la pantalla.

Figura 2.7 Ventana propiedades.

Puede cambiar el texto del botón, la fuente, el color de la letra, el color del botón, el tamaño, el nombre del botón, etc. Algunas de las propiedades son las siguientes: background: color del fondo del botón. font: tipo de letra. text: texto que se muestra sobre el botón. enabled: propiedad que indica si el botón esta activado o no en el formulario. margin: margen del texto del botón. name: nombre del botón, con el hará referencia al objeto para utilizarlo en el código. La propiedad nombre se modifica de manera distinta a las demás. Posteriormente se explicará este proceso. Ejemplo: Cambiar el texto de los botones del ejemplo a “¡Hola Mundo!” y “¡Hola Java!”. Para ello:

1. Seleccionamos la propiedad “text”.

2. Cambiamos el texto predeterminado por el texto deseado.



3. Presione Enter.

4. Pruebe el resultado corriendo el programa con f6.

Figura 2.8 Cambio de Propiedades de un objeto.

Para cambiar la propiedad “name” se describe a continuación.

1. En la ventana de propiedades, seleccione la pestaña “Code”.

2. Seleccione la propiedad “Variable Name”.

3. Escriba el nombre con el cual desee referirse al objeto.

4. Presione “Enter”, automáticamente verá el cambio en la propiedad

“name”

Es conveniente que asigne un nombre a cada componente que crea para facilitarle la programación.

Ventana de propiedades

Aquí selecciona la propiedad

Corrida del programa.



Figura 2.9 Cambio de la propiedad “name”

Campos de Texto. Los cuadros de texto son componentes que soportan texto. Estos componentes gestionan cadenas de texto de una dimensión; permiten visualizar el texto que el usuario escribe, poner máscaras de texto cuando se introduce una clave secreta, leer texto que el usuario ha incluido y mucho mas. Para crear un campo de texto, llevamos a cabo el mismo proceso que en los botones. Únicamente tenemos que arrastrarlo de la Paleta de componentes a nuestra ventana de aplicación y ubicarlo en el lugar que queramos. Presione f6 para observar que sucede.

Figura 2.10 Programa en ejecución con caja de texto de ejemplo.

En este momento la caja de texto no tienen función alguna (podemos editarlo pero no tiene función alguna). Se preguntará, ¿Qué funcionalidad?, pues que



se lleve a cabo alguna acción cuando escriba algo, seleccionar la caja de texto, etc. Modificar propiedades. Al igual que los botones tienen texto predeterminado, lo tiene la caja de texto, este texto se almacena en una de las muchas propiedades de los objetos, estas propiedades se modifican de la misma manera que se describió anteriormente. Puede cambiar el texto, la fuente, el color de la letra, el color del fondo, el tamaño, el nombre del objeto, cambiarlo de habilitado a deshabilitado, ocultar el texto que se escribe, etc. Ejemplo: Cambiar el texto predeterminado de la caja de texto y deshabilitarla. Para ello:

1. Seleccionamos la propiedad “text” de la primera caja.

2. Cambiamos el texto predeterminado por el texto deseado.

3. Presione Enter.

4. Seleccione la propiedad “editable” de la segunda caja y

desactívela.

5. Pruebe el resultado corriendo el programa con f6.



Figura 2.11 Cambio de Propiedades de un objeto TextField.

Casillas de activación (Check Box) Las casillas de activación son como botones, salvo que tienen un doble estado, es decir, pueden estar seleccionadas o no. Cuando se seleccionan, aparecen con algún tipo de marca, como puede ser una marca de activación o una X (el tipo de indicación visual depende del sistema operativo en que se haya programado, que es una de las razones por la que Sun introdujo Swing, que puede visualizar componentes con la misma forma independientemente del sistema operativo). El usuario puede marcar una casilla de activación para seleccionar un tipo de opción. Se usan las casillas de activación para permitir al usuario opciones de selección no exclusivas. Ejemplo: Programa que tiene dos campos de texto, uno editable y otro no editable. Agregar dos casillas de activación al programa, cambie el texto predeterminado de las casillas para describir lo que hará cada una, en este caso, una que diga mayúsculas y otra que copie el texto de una casilla a la otra. Para ello:

1. Coloque las dos casillas de activación, arrastrándola de la paleta de

componentes, asignándoles un nombre en función de su propósito,

por ejemplo jCBcopiar (jCheckBoxcopiar).

2. Seleccione la propiedad “text” de ambas casillas y cámbielas por

“Mayúsculas” y “Copiar”.


En una cambiamos la propiedad editable y en la otra la propiedad text.




Figura 2.12 Cambio de Propiedades de objetos CheckBox.

Botones de opción (Radio Button) y Grupos de Botones (Button Group) Los botones de opción son un tipo especial de casilla de activación, y se usan en grupos. Sólo un botón de opción de un grupo puede ser seleccionado a la vez; cuando el usuario selecciona un botón de opción de un grupo, el resto del grupo es automáticamente desactivado. Estas herramientas se utilizan cuando desea ejecutar acciones mutuamente excluyentes. Para crear un grupo de botones de opción siga los siguientes pasos:

1. Arrastre los objetos “Radio Button” de la paleta de objetos que

necesite y colóquelos en el formulario en el sitio que guste. Para el

ejemplo siguiente se colocarán dos opciones distintas.

2. Una vez que ordenó los botones de opción, arrastre un grupo de

botones (Button Group) al formulario. Como puede observar, este

objeto no se muestra en el formulario pero si se agrega a la lista de





objetos en el inspector del formulario (lado izquierdo inferior de la

pantalla, pestaña “Inspector”).

3. Ahora seleccione los botones de opción (Radio Button) y busque la

propiedad “buttonGroup” en la lista de propiedades como lo ha hecho

hasta ahora. Modifique esta propiedad seleccionando el grupo de

botones de opción que creamos en el punto anterior. Por default tiene

de nombre “ButtonGroup1”. Con ello logramos que al seleccionar una

de las opciones se deseleccionen las otras.

NOTA: Si no agrega los botones de opción a un grupo, estos funcionarán de manera independiente. Y si selecciona alguno, los otros no se deseleccionarán. Es decir, la propiedad primordial de estos objetos se desperdicia. En ese caso será mejor utilizar “Check Box”. Ejemplo: Agregar dos botones de opción al formulario y organizarlos en un grupo de opción. (Recuerde asignar un nombre a los componentes al momento de crearlos)

Figura 2.13 Aplicación con botones de opción.

2.2 Eventos del formulario. Ya se ha dicho que las acciones del usuario sobre el programa se llaman eventos. Son eventos típicos el clic sobre un botón, el hacer doble clic sobre el nombre de un archivo para abrirlo, el arrastrar un icono, el pulsar una tecla o combinación de teclas, el elegir una opción de un menú, el escribir en una caja

Aquí selecciona el grupo al que desea que pertenezcan los botones de opción.



de texto, o simplemente mover el ratón. Cada vez que se produce un evento sobre un determinado tipo de control, Java arranca una determinada función o procedimiento que realiza la acción programada por el usuario para ese evento concreto. Estos procedimientos se llaman con un nombre que se forma a partir del nombre del objeto y el nombre del evento, separados por el carácter (_), por ejemplo: private void Boton1MouseClicked(java.awt.event.MouseEvent evt) { // TODO add your handling code here: }

Para ejemplificar como se programan los eventos en un formulario, ahora haremos que nuestra aplicación tenga funcionalidad. Analizaremos diferentes eventos con los objetos del formulario. Para crear un evento sobre algún objeto del formulario, seleccione el objeto que desee y a continuación busque el evento deseado en la pestaña “Events” que se encuentra junto a la pestaña de propiedades.

Figura 2.14 Lista de eventos.

Campo de texto (Text Field). Crearemos un evento sobre el campo de texto habilitado del ejemplo “campoTexto1”, el evento que crearemos se llama “KeyTyped”, es decir, al presionar una tecla se llevará a cabo alguna acción. Los pasos para crear dicho evento son los siguientes:

1. Seleccione el campo de texto y después busque el evento

“KeyTyped” en la lista de eventos de la pestaña “Events” y presione

enter.



2. Con esto, se crea el esqueleto del evento en la parte correspondiente

del código. Por si solo, este código no realiza función alguna.

Debemos echar mano de los métodos del objeto “campoTexo1”.

3. En este caso, haremos que se copie el texto que tecleemos en la

segunda ventana de texto (la que se encuentra deshabilitada,

(“jTextField2”). El código está adelante.

4. campoTexto2.setText(), es un método que sirve para asignar un valor

al campo de texto. campoTexto2.getText(), por el contrario, devuelve

el texto de un campo.

private void campoTexto1KeyTyped(java.awt.event.KeyEvent evt) { // TODO add your handling code here: campoTexto2.setText(campoTexto1.getText()); //Aquí se toma el texto del campo1 y se copia en el //campo2. }

2.15 Ejemplo en ejecución.

NOTA IMPORTANTE: Para facilitar la programación, NetBeans posee una herramienta muy importante. Si no recuerda como se llaman sus objetos o desconoce los métodos de un objeto, basta con escribir la primera letra del nombre del objeto y luego presionar la combinación de teclas “Ctrl+espacio” para listar las posibles opciones, con ello, únicamente tendrá que seleccionar el nombre que desea. Aplica lo mismo para los métodos.



Para agregar más funcionalidad debemos utilizar los métodos de los objetos, a continuación se listan algunos de los métodos de un campo de texto y su funcionalidad.

Método Descripción Dimension getMinimumSize() Obtiene las dimensiones mínimas

para el cuadro de texto int getColumns() Obtiene el número de columnas del

cuadro de texto. Protected String paramString() Obtiene la representación en cadena

del estado del cuadro de texto. void removeActionListener(Action Listener)

Elimina el action listener indicado, para que no reciba eventos.

void setText(String) Asigna una cadena al objeto. String getString () Devuelve en una cadena el contenido

de una caja de texto. Tabla 2.1 Métodos de algunos objetos.

Cabe mencionar que NetBeans proporciona una lista y una breve descripción del funcionamiento de cada método. Basta con utilizar la herramienta de NetBeans mencionada anteriormente.(Ctrl+Space) Botones Ahora crearemos un evento sobre el botón de nuestro ejemplo. Utilizaremos el evento “mouseClicked”, es decir, algunas funciones se desencadenarán al dar clic sobre nuestro botón. Los pasos para crear el evento son los mismos, únicamente debe seleccionar el evento indicado. Seleccione el botón y busque el evento apropiado en la pestaña de eventos. “mouseClicked” para el ejemplo, además es lo más común con un botón. Ejemplo: Programe el evento “mouseClicked” en el botón del ejemplo. Haga que al dar clic sobre el mismo, se muestre cualquier frase en el campo de texto deshabilitado. El código es el siguiente:

private void Boton1MouseClicked(java.awt.event.MouseEvent evt) { campoTexto1.setText("Programaste el evento clic"); //Entre comillas se pone lo que deseas que se //muestre en la caja de texto }



Figura 2.16 Programa en ejecución

Casillas de activación (check box) A continuación trabajaremos con los check box, programaremos también el evento mouseClicked. Ejemplo: Programar el evento mouseClicked de las casillas de activación (debe hacerse en ambas). Al dar clic sobre una, deberá revisar si se está activando o desactivando, para llevar a cabo la acción específica.

1. La primera casilla deberá cambiar el texto del campo de texto habilitado

a mayúsculas al ser activada, y a minúsculas al ser desactivada.

2. La segunda deberá copiar el texto de la primera caja de texto a la

segunda al ser activada y quitar cualquier texto de dicha caja al ser

desactivada.

3. Busque el evento en cada una de las check box y programe lo anterior.

El código es el siguiente:

Para el check_box 1

private void checkMayusculasMouseClicked(java.awt.event. MouseEvent evt) { if (checkMayusculas.isSelected() == true){ campoTexto1.setText(campoTexto1.getText(). toUpperCase()); } else{ campoTexto1.setText(campoTexto1.getText(). toLowerCase()); }



}

Para el check_box 2

private void checkCopiarMouseClicked(java.awt.event.MouseEvent evt) { if (campoTexto2.isSelected()==true){ campoTexto2.setText(campoTexto1.getText()); } else{ campoTexto2.setText(""); } }

Como puede observar, la programación cada vez involucra más herramientas. En este caso ya utilizamos el condicional if else, además los métodos toLowerCase() y toUpperCase() que cambian una cadena de mayúsculas a minúsculas. Estos y más métodos ya se analizaron en la primera unidad 1.7 Tipos De Datos, en la clase String. También hay métodos como campoTexto2.isSelected(), este nos regresa “true” si la casilla de activación esta activada, valga la redundancia, o “false” si esta desactivada. A continuación, se presentan algunos métodos relacionados con las check box que pueden facilitar la programación:

Método Descripción boolean isBackgroundSet() Regresa “true” si el color de fondo del

componente se ha especificado, “false” si no.

boolean isBorderPainted() Regresa “true” si el borde del objeto está pintado, regresa “false” de lo contrario.

boolean isEnabled() Regresa “true” si el componente está habilitado o “false” si no.

boolean isSelected() Regresa “true” si el componente está seleccionado o “false” si no.

void setText (String text) text – Es una cadena que se pondrá como texto.

void setVisible (boolean aFlag) aFlag – bandera “true” para hacer que este



componente sea visible, bandera “false” para que no sea visible.

void setEnabled (boolean b) “false” para deshabilitar el componente, “true” para habilitarlo.

Tabla 2.2 Métodos de una check box.

Figura 2.17 Aplicación en ejecución.

Botones de Opción (Radio Button).

Ahora crearemos un evento sobre los botones de opción de la aplicación. Ejemplo: Para los botones de opción programe el evento “StateChanged” para lograr que al seleccionar uno, se coloque una frase en el campo de texto habilitado y con el otro botón una frase distinta.

1. Seleccione cada uno de los botones de opción e identifique el evento

“StateChanged”, pulse enter para crear el código correspondiente.

El código es el siguiente: Código para el botón de opción 1: private void opcion1StateChanged(javax.swing.event.ChangeEvent evt) { if(opcion1.isSelected()==true){ campoTexto1.setText("Eligió la opción 1"); } }

Código para el botón de opción 2:



private void opcion2StateChanged(javax.swing.event.ChangeEvent evt) { if (opcion2.isSelected()==true){ campoTexto.setText("Eligió la opción 2"); } }

Como puede observar, estamos utilizando el método “isSelected()”, es el mismo que utilizamos en los check box. Esto se debe a que muchos de los métodos disponibles para los componentes estándar son iguales.


2.3 Cajas de diálogo. Los programas de ventanas utilizan, con frecuencia, cuadros de diálogo para que el usuario introduzca datos, como el nombre de un archivo que se desea abrir, una clave o un color que se selecciona entre muchos otros. Al igual que otros elementos visuales, los cuadros de diálogo son familiares para los usuarios GUI (interfaz Grafica de Usuario). Se usan cuando se quiere que el usuario introduzca información, pero no quiere usar un control dedicado, como un cuadro de texto, todas la veces en la ventana principal. Es decir, los cuadros de diálogo son ventanas temporales que se pueden llenar con controles para la entrada de datos del usuario. 2.3.1 Modales y no modales. Los formularios y los cuadros de diálogo pueden ser modales o no modales. Un formulario o cuadro de diálogo modal debe cerrarse u ocultarse para que el usuario pueda continuar trabajando con el resto de la aplicación.



Es conveniente que los cuadros de diálogo que muestran mensajes importantes sean siempre modales. El cuadro de diálogo Acerca de es un ejemplo de un cuadro de diálogo modal. Los formularios no modales permiten alternar el foco entre dos formularios sin necesidad de cerrar el formulario inicial. El usuario puede continuar trabajando en otro lugar, en cualquier aplicación, mientras se muestra el formulario. Los formularios no modales son más difíciles de programar, porque el acceso por parte de los usuarios se produce en un orden impredecible. Se ha de mantener la aplicación en un estado coherente con independencia de lo que haga el usuario. Con frecuencia, las ventanas de herramientas se muestran de forma no modal. El cuadro de diálogo Buscar, disponible en muchas aplicaciones, es un ejemplo de cuadro de diálogo no modal. Utilice formularios no modales para mostrar comandos o información utilizados con frecuencia. Para crear una caja de dialogo en java, usted debe crear una clase desde cero, heredar de clases predefinidas y crear por medio de texto puro cada elemento del nuevo formulario. NetBeans provee herramientas que permiten la creación de cajas de dialogo de la misma manera que hemos creado nuestro formulario hasta ahora. Para crear una caja de dialogo siga los pasos siguientes:

1. Vaya al menú “File” (archivo) y seleccione “New File”.

2. Elija la categoría “Swing GUI Forms”

3. Seleccione el tipo de archivo “JDialog Form” y presione “Next”.



Figura 2.19 Ventana “New File” crear caja de diálogo.

4. Ahora debemos elegir el nombre de la clase de nuestro nuevo

formulario. Debe quedar claro, que este será el nombre de la clase, mas

no del formulario. Por último presione “Finish”

5. Como puede ver, se crea un nuevo formulario, usted puede arrastrar

componentes de la paleta de componentes y darle la forma que usted

quiera. Estos procesos se explicaron con detalle en el apartado anterior.

El nombre de la clase de nuestro nuevo cuadro de diálogo es

“NewJDialog”.

Figura 2.20 Nuevo formulario para caja de dialogo vacio.

Ejemplo: Ponga un par de botones y una caja de texto al cuadro de diálogo. Y programa los eventos clic de cada botón para mostrar algún mensaje en la caja de texto.



Para el ejemplo anterior muestre el texto “Hola a mi” y “Hola a Todos” al presionar el botón correspondiente a la frase. Hasta este momento no puede ejecutar este cuadro de diálogo. Para ello debe crear una instancia de su clase en nuestro formulario principal. Para llamar el cuadro de diálogo que diseñamos anteriormente en el formulario principal, haga lo siguiente: 1. Para el ejemplo, llamaremos el cuadro de diálogo al dar clic sobre el

botón de nuestra aplicación principal.

2. Una vez que nos ubicamos en el código del evento correspondiente,

procedemos a declarar una instancia de la clase “NewJDialog” y la

mostramos. El código es el siguiente:

private void Boton1MouseClicked(java.awt.event.MouseEvent evt) { campoTexto2.setText("Programaste el evento clic"); //Creamos el objeto. NewJDialog cuadroDialogo = new NewJDialog(getFrame(), false); //Luego lo mostramos cuadroDialogo.show(); }

Como puede observar, al declarar el objeto de tipo “NewJDialog” se llamará a su constructor, el cual requiere como parámetros: el formulario padre, es decir, el que lo invoca y una bandera en la que se especificará si la caja de diálogo será modal o no modal. NewJDialog cuadroDialogo = new NewJDialog(getFrame(), false); //Es en este momento que se decide si la caja de diálogo será

modal o no modal




TIP: Si en determinado método no esta seguro de los parámetros, presione “Ctrl + space” para que NetBeans le ofrezca posibles valores. 2.3.2 Predefinidas En el apartado anterior, 3.1 Modales y no modales, analizamos como crear cajas de diálogo pero; existen cajas de dialogo predefinidas, crearlas es muy sencillo y el proceso necesario se describe a continuación. La clase que se utiliza para este fin se llama “JOptionPane” Los tipos de cajas de texto predefinidas son:

1. Confirmación (ConfirmDialog).

2. Entrada de datos (InputDialog).

3. Confirmación Interna (InternalConfirmDialog)

4. Entrada interna de datos (InternalInputDialog)

5. Mensaje Interno (InternalMessageDialog)

6. Mensaje (MessageDialog)

7. Opción (OptionDialog)



Cada uno de los tipos de cajas de dialogo predefinidas mencionadas anteriormente tienen varios constructores dependiendo de sus parámetros, a continuación se explicará el proceso de creación y utilización de algunas de estas cajas de diálogo mediante el uso de herramientas de NetBeans que facilitan la programación. Por ejemplo: Crearemos una caja de diálogo de confirmación en el objeto “checkMayusculas1” de nuestra aplicación, este es el que nos da la opción de poner nuestro texto en mayúsculas. Para ello realice lo siguiente.

1. Localice el código de evento que ya habíamos programado para este

objeto, si no ha seguido el ejemplo hasta este punto, cree una checkbox,

localice el evento mouseclicked y escriba “JOptionPane.”. Al escribir él

“.” (punto) NetBeans intentará complementar su código dándole

opciones posibles. Si no ocurre lo anterior presione Ctrl + space para

que lo haga.

Figura 2.22 Cómo ver la lista de cuadros de diálogo predefinidos

Como puede Observar es muy sencillo, solo debe seleccionar el tipo de caja de diálogo que desea utilizar. Si no está seguro de para qué sirve cada una, en la parte inferior se muestra una explicación de para qué sirve, que es lo que muestra, etc. En el listado de los métodos puede observar que parámetros se necesitan y que devuelve la función. En fin entre las dos ventana automáticamente desplegadas por NetBeans se muestra todo lo que debe saber del método que crea una caja de diálogo.



2. Una vez que identifica el método que necesita, selecciónelo y presione

“enter”, automáticamente se muestra otra ventana de ayuda para

completar el código con los parámetros correspondientes.

Figura 2.23 Error por no importar librería.

Los parámetros para la caja de diálogo que estamos creando son el formulario que la esta invocando y el mensaje que deseamos se muestre. Recuerde que se puede ayudar de Ctrl+space para completar los parámetros si desconoce que debe poner. En este caso, el formulario que llamará al cuadro de diálogo es el formulario principal cuyo nombre es “mainPanel” y el mensaje que queremos mostrar es: “Está completamente seguro??”. Observe que tenemos un error, es debido a que no hemos importado la clase “JOptionPane” pero; otra de las herramientas poderosas de NetBeans es solucionar con facilidad errores de los cuales conoce su solución. Por ejemplo para que se solucione ese error, basta con dar un clic sobre el foco amarillo para que nos diga de qué error se trata y a continuación seleccionar una de las posibles soluciones. Siempre que se muestra un foco en un mensaje de error, es porque NetBeans puede solucionarlo, De lo contrario solo se muestra el error que se localiza.

Figura 2.24 Herramienta útil para corregir errores sencillos.

Puede ser que le muestre otro error debido a que no está asignando el valor de vuelta a ninguna variable. Ese error también se puede solucionar fácilmente. Aunque… de hecho esto no es un error, sería el equivalente a un warning en el lenguaje C.



Como vemos el método devuelve un entero que nos permitirá captar cual es la opción elegida por el usuario. Los valores serán 0 para Si, 1 para No, 2 para Cancelar y -1 para el cierre de la ventana. Así podremos preguntar cuál es el valor devuelto y realizar la acción que deseamos. 3. Ahora utilicemos los valores de retorno para condicionar el

comportamiento. De lo contrario se mostrará la ventana pero no tendrá

función alguna.

4. Haremos que si se presiona “Si”, la casilla se seleccione y cambie el

texto del cuadro de texto a mayúsculas, si se presiona “No” No se

activará la casilla, y en caso de que se presione “Cancelar” o se cierre la

ventana, Tampoco se activará la casilla.

5. El código en el evento clic del checkbox es el siguiente.

private void checkMayusculasMouseClicked(java.awt.event.MouseEvent evt) { //necesitamos una variable entera en la cual almacenar el valor de retorno. int showConfirmDialog = JOptionPane.showConfirmDialog(mainPanel, "Está Completamente seguro??"); if(showConfirmDialog == 0){ checkMayusculas.setSelected(true); } else{ checkMayusculas.setSelected(false); } //Como puede ver se realiza una acción si se selecciona la //casilla. if (checkMayusculas.isSelected() == true){ ampoTexto1.setText(campoTexto1.getText().toUpperCase()); } else{ campoTexto1.setText(campoTexto1.getText().toLowerCase()); } }

Con esto, estamos condicionando a que se confirme la acción que antes siempre se ejecutaba al dar clic sobre ese objeto.



Figura 2.25 Programa en ejecución.

Ahora, supongamos que usted no necesita preguntar nada al usuario, que solo quiere mostrar un mensaje al realizar cierta acción, ya sea una confirmación o un mensaje de que ocurrió cierto error. Para eso utilicemos un mensaje simple, ahora lo pondremos en el botón de la aplicación. Ejemplo: Agregar al código del evento “mouseclicked” del Botón con la leyenda “Hola Java” de nuestra aplicación el código que muestre una mensaje que indique que la acción se llevó a cabo correctamente. Anteriormente habíamos mostrado una caja de dialogo en ese código. Modifíquelo si es necesario. El código es el siguiente: private void Boton1MouseClicked(java.awt.event.MouseEvent evt) { campoTexto2.setText("Programaste el evento clic"); JOptionPane.showMessageDialog(mainPanel, "La acción se realizó correctamente"); }

La creación de cuadros de diálogo pre diseñados es una de las tareas más sencillas. Utilice cajas de diálogo prediseñanadas en lugar de cajas diseñadas por usted mismo si es posible. Se ahorrará mucho tiempo en la programación y además tendrá muchas opciones pre programadas en las mismas.




2.4 Componentes estándar. Cuando desarrolla una aplicación en java, es apropiado elegir los componentes de interfaz gráfica de usuario (GUI) adecuados. En NetBeans se pueden crear componentes Swing7 o AWT8 (Abstract Window Toolkit), ambos forman parte de la Java Foundation Classes (JFC). Para crear componentes de los distintos estándares, debe seleccionar la categoría correspondiente en la paleta de componentes. Ambos tienen ventajas y desventajas, las cuales se mencionarán posteriormente. Hasta el momento hemos trabajado únicamente con controles swing.

7 Swing es una biblioteca gráfica para Java. Contiene botones, cajas de texto, etc. 8 La Abstract Window Toolkit (AWT, en español Kit de Herramientas de Ventana Abstracta) es un kit de herramientas de gráficos, e interfaz de usuario.



Figura 2.27 Componentes Swing y AWT.

Las Internet Foundation Classes (IFC9) era una biblioteca gráfica para el lenguaje de programación Java desarrollada originalmente por Netscape10. Desde sus inicios el entorno Java ya contaba con una biblioteca de componentes gráficos conocida como AWT. Esta biblioteca estaba concebida como una API estandarizada que permitía utilizar los componentes nativos de cada sistema operativo. Entonces una aplicación Java corriendo en determinado sistema operativo, usaría componentes estándar del sistema. En la práctica esta tecnología no funcionó:

• Al depender fuertemente de los componentes nativos del sistema

operativo el programador AWT estaba confinado a un mínimo

denominador común entre ellos. Es decir que sólo se disponen en AWT

de las funcionalidades comunes en todos los sistemas operativos.

• El comportamiento de los controles varía mucho de sistema a sistema y

se vuelve muy difícil construir aplicaciones portables. Fue por esto que el

eslogan de Java "Escríbalo una vez, ejecútelo en todos lados" fue

parodiado como "Escríbalo una vez, pruébelo en todos lados".

9 Internet Foundation Classes era una biblioteca gráfica para el lenguaje de programación Java 10 Es una empresa de software famosa por ser la creadora del navegador web Netscape Navigator.



En cambio, los componentes de IFC eran mostrados y controlados directamente por código Java independiente de la plataforma. Swing se desarrolla a partir de AWT con el objetivo de mejorar a las tecnologías existentes y lograr lo que AWT no pudo. Swing introdujo un mecanismo que le permite que el aspecto de cada componente de una aplicación pudiera cambiar sin introducir cambios sustanciales en el código de la aplicación. Swing emula la apariencia de los componentes nativos manteniendo las ventajas de la independencia de la plataforma. También contiene un conjunto de herramientas que nos permiten crear un interfaz atractivo para los usuarios. Pudo haber notado que en NetBeans se pueden crear controles Swing y controles AWT. La explicación anterior es para comprender por qué durante el desarrollo de este libro, se utilizaron únicamente componentes Swing. De cualquier modo, la creación y manipulación de ambos es la misma, esta decisión se basó en las ventajas que ofrece una nueva tecnología (“Swing”) sobre (“AWT”). AWT vs Swing Hay por supuesto pros y contras de ambos componentes de la JFC, a continuación se listan algunos.

AWT: Pros

• Velocidad: el uso de componentes nativos aumenta la velocidad de

ejecución y el desempeño.

• Portabilidad Web: La mayoría de los navegadores de internet soportan

AWT por lo que no es necesario algún plugin adicional.

• Apariencia: Los componentes AWT lucen más como los componentes

nativos del sistema Operativo.

Contras • Portabilidad: El uso de componentes nativos atenta contra la portabilidad

de la aplicación a otra plataforma.

• Mayorías: La mayor parte de las compañías importantes de Software

basan sus tecnologías sobre swing.

• Funciones adicionales: los componentes AWT no soportan cosas como

iconos y otras herramientas adicionales.



Swing: Pros

• Portabilidad: El diseño de éstos componentes provén mayor portabilidad.

• Comportamiento: Estos componentes provén de mayor funcionalidad ya

que no están atados a funciones de un solo sistema.

• Funciones: Swing soporta muchas más funciones como los iconos, los

pop-up, etc.

• Actualmente: El desarrollo de Swing es más activo, sun continúa dando

mantenimiento a estas librerías y mejorándolas.

• Apariencia: Aunque estos componentes imitan a los nativos de los

sistemas operativos, la verdad es que no hay diferencia notable en la

actualidad. Sobre todo para plataformas como (Microsoft Windows,

Solaris, Macintosh, etc.)

Contras

• Portabilidad Web: La mayoría de los navegadores de internet no

contienen la librería swing por lo que debe agregarse un plug-in. (Si la

tendencia hacia swing continúa, esto ya no será necesario).

• Desempeño: Los componentes swing son mucho más lentos y contienen

más bugs que los AWT.

• Apariencia: Aunque los componentes Swing están hechos para lucir

como los propios del sistema operativo, pueden no verse como ellos.



EJERCICIOS PROPUESTOS. 2.1 Desarrolle una aplicación de escritorio, adapte las clases creadas en el proyecto de la Unidad I, en el proyecto de la calculadora. Para funcionar gráficamente, agregue los botones necesarios para las funciones adicionales que realice su aplicación. Ej. De la interfaz que deberá crear y programar.

2.2 Diseñe una aplicación gráfica para manipular la información de una Agenda electrónica. Utilice los controles swing disponibles para poder agregar, modificar, eliminar o consultar la información de 20 personas diferentes. La información se almacenará en memoria. Utilice arreglos de tipo que considere necesarios. 2.3 Programe una aplicación en ambiente gráfico que le permita tener una lista de alumnos y sus calificaciones. Utilice un objeto JList para almacenar dicha lista y utilice JOptionPane o JTextField para ingresar la información. Luego coloque los botones necesarios para ordenar dicha lista ya sea por nombre o por la calificación. 2.4 Memorama. Desarrolle una aplicación que funcione como un memorama. Un memorama cociste en un conjunto de “n“cartas con n/2 imágenes distintas. El objetivo es poner las cartas hacia abajo y tratar de localizar el mayor número de parejas posible. Elija que objetos utilizar (botones, labels, etc.) y programe un evento sobre ellos para que al seleccionar uno nos muestre que imagen o texto oculta (puede utilizar texto en lugar de imágenes). La aplicación deberá llevar el control de puntaje y turno de 2 jugadores. Utilice como mínimo 16 objetos que representarán las cartas. 2.6 Diseñe un programa en ambiente gráfico que le ayude a aprender inglés. Deberá crear de manera automática (con valores fijos) o pidiendo los valores al usuario para llenar un arreglo de palabras en inglés. Deberá guardar en otro su equivalente en español. El programa mostrará de manera aleatoria una palabra del arreglo de palabras en inglés. Usted deberá ingresar la palabra en español



y presionar enter para revisar si fue correcta o incorrecta su respuesta. El programa mostrará de manera infinita y aleatoria las palabras que contiene. 2.7 Programe una aplicación que realice una conversión de temperaturas entre Fahrenheit y Centígrados. Deberá ser capaz de que a que escala convertir, es decir, de centígrados a Fahrenheit o viceversa. 2.8 Desarrolle una aplicación que le permita transformar cantidades entre varias tipos de monedas. Por ejemplo: De euros a pesos, a libras esterlinas, a dólares, etc. Contemple todas las conversiones posibles entre al menos esas cuatro monedas. 2.9 Diseñe una aplicación que le permita resolver ecuaciones algebraicas de primer grado. Ejemplo: x + 3 = 2x – 2 y segundo grado. Ejemplo: x2 − 16 = 0. 1.10 Programe el juego del gato. Utilice una matriz de 9 elementos para llevar un control de las posiciones. Utilice el objeto que considere conveniente para representar de manera gráfica al gato. El programa debe llevar el control de turno de dos jugadores y decir cuando gana alguno. Utilice botones o un menú para crear opciones como nuevo juego o lo que necesite.



PROYECTO INTEGRAL. Sudoku. (En japonés: 数独, sūdoku) es un pasatiempo (como los crucigramas en México), muy popular en Japón. El objetivo es rellenar una cuadrícula de 9×9 celdas (81 casillas) dividida en subcuadrículas de 3×3 (también llamadas "regiones") con los números del 1 al 9 partiendo de algunos números ya dispuestos en algunas de las celdas. Aunque se podrían usar colores, letras, figuras, conviene en usar números para mayor claridad. Lo que importa, en todo caso, es que sean nueve elementos diferenciados. No se debe repetir ninguna cifra en una misma fila, columna o región. Un sudoku está bien planteado si la solución es única. La resolución del problema requiere paciencia y ciertas dotes lógicas.

Diseñe una aplicación gráfica que cree tablas de sudoku y usted pueda resolverlas. El programa deberá ser capaz de revisar la solución que demos y decir si es correcta o incorrecta. Existen algoritmos que describen también como solucionarlos, de la opción al usuario para resolver un sudoku si es que se rindió o no puede resolverlo.

Unidad 3. Sistemas de Archivos.

Utilización de archivos como método de almacenamiento de información.

ITM Unidad III Sistemas de Archivos


INTRODUCCION. Antes de comenzar con el contenido de esta unidad, considero conveniente explicar un poco el manejo de archivos en el lenguaje Java. Esto con el fin de que comprendan mejor los ejemplos y explicaciones presentes en la Unidad. Definición de archivos de texto y archivos binarios Archivos de texto: Es una estructura de datos permanente no estructurada formada por una secuencia de caracteres ASCII. Los archivos de texto son aquellos que están compuestos únicamente por texto sin formato, sólo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Algunos de los sistemas de codificación más usados son: ASCII, Latín-1, Unicode, etc. Se les conoce también como archivos de texto plano por carecer de información destinada a generar formatos y tipos de letra (por ejemplo, tipo de letra: Arial, Times, Courier; formato: negritas, subrayado, cursivas; tamaño, etc.). La costumbre ha hecho que se nombren con la extensión de archivo .TXT aunque pueden tener cualquier otra, a capricho del usuario (son válidas y habituales .INF .80 .DAT .TMP .PRV .HLP etc.). Los archivos .BAT, .HTML y muchos otros son también archivos de texto, que tienen funciones especiales. Archivos binarios: Los archivos binarios son archivos electrónicos que han sido guardados utilizando el código básico de las computadoras: una sucesión de ceros y unos. Constituyen, en última instancia, la forma en la cual almacenan la información, aunque su interacción con los usuarios requiere de lenguajes auxiliares que resulten más inteligibles al ser humano. Operaciones Básicas en Archivos. Crear Para crear un archivo la sintaxis es: FileWriter nombre_variable = new FileWriter(“Nombre del archivo incluyendo ruta”); Por ejemplo:

FileWriter archivo = new FileWriter("c:/prueba.txt");

En el ejemplo anterior se crea un archivo de nombre prueba.txt ubicado en la ruta “c:”, pero en NetBeans marcará un error si no se coloca esta línea dentro de un control de excepciones try y catch. El código funcional es el siguiente:



try{ FileWriter archivo = new FileWriter ("C:/prueba.txt"); } catch (Exception e){ System.out.print("Error al crear el archivo"); }

Si quiere añadir al final de un archivo ya existente, simplemente se debe poner una bandera (flag) en true como segundo parámetro del constructor de FileWriter FileWriter archivo = new FileWriter("c:/prueba.txt",true);

En este ejemplo se añadirán líneas al final del archivo prueba.txt Abrir La apertura de un archivo se hace con la siguiente sintaxis: FileReader nombre_variable = new FileReader(“Nombre del archivo incluyendo ruta”); Por ejemplo:

FileReader fr2 = new FileReader("archivo.txt"); Esto es equivalente a:

File archi = new File("archivo.txt"); FileReader fr2 = new FileReader(archi);

Si a la hora de la apertura no se encuentra el archivo indicado, los constructores de FileReader y FileInputStream lanzan la excepción java.io.FileNotFoundException. Cerrar Para cerrar un archivo, ya sea de lectura o escritura, utilice el método close(). Sintaxis: Nombre_variable.close(); Este método debe invocarse para liberar los recursos11. Una vez que el archivo ha sido cerrado, las operaciones posteriores sobre él producirán una excepción IOException (Excepciones de entrada y salida de datos). Cerrar un archivo previamente cerrado no tiene ningún efecto. Para probar las operaciones anteriores el código es el siguiente:

11 Como los descriptores de archivos.



try{ FileWriter archivoEsc = new FileWriter ("C:/prueba.txt"); FileReader archivoLee = new FileReader ("C:/prueba.txt"); archivoEsc.close(); archivoLee.close(); } catch (Exception e){ System.out.print("Error en el archivo"); }

Aunque con lo anterior se logra el objetivo de lectura en los archivos, la clase FileReader tiene pocos métodos que faciliten la lectura en archivos de texto. Para ello existe la clase BufferReader. El código para crear un objeto de este tipo es el siguiente: FileReader archivoLee = new FileReader ("C:/prueba.txt"); BufferedReader leerArch = new BufferedReader(archivoLee);

3.1 Acceso secuencial. En este caso los datos son leídos secuencialmente, desde el comienzo del archivo hasta el final. Entrada y salida secuencial en Java La interfaz básica de entrada y salida secuencial se define a través de las clases InputStream y OutputStream, su interfaz permite la lectura y escritura de bytes, el tipo de dato más pequeño disponible en Java e históricamente el tamaño mínimo de almacenamiento de datos en las computadoras. Entrada Como se dijo, la clase base para los distintos tipos de entrada secuencial es InputStream. Existen varias subclases que implementan distintos tipos de fuentes de datos secuenciales, algunas de las más usadas son:

• FileInputStream: Permite leer datos desde un archivo.

• ByteArrayInputStream: Permite leer datos desde un bloque de memoria

dado por un arreglo de tipo byte.

• StringBufferInputStream: Lee caracteres desde una cadena de texto.

La interfaz de InputStream provee un acceso muy crudo a los datos, siempre en forma de bytes. Cuando se habla de E/S, es deseable tener formas para:



• Leer distintos tipos de datos además de bytes (por ejemplo: double, int,

boolean, etc.)

• Hacer más eficiente el acceso a los datos mediante la lectura en ráfagas

hacia buffers.

• Volver hacia atrás en la lectura de un archivo.

En Java se define una subclase abstracta de InputStream, LineNumberInputStream. Esta clase contiene métodos que nos permiten realizar funciones con las que estamos más familiarizados y consideramos más accesibles como .read() que nos permiten leer líneas en un archivo. Vemos un pequeño ejemplo: Agregue un botón al ejemplo que hemos utilizado hasta el momento, su objetivo será abrir un archivo de texto creado, leer cada línea que contenga e imprimirla y al final indicar cuantas líneas fueron leídas en el archivo. Cree el archivo en el directorio que desee. private void leerArchivoMouseClicked(java.awt.event.MouseEvent evt) { try { File f = new File("C:/prueba.txt"); LineNumberInputStream lin = new LineNumberInputStream(new FileInputStream(f)); int contador; do { contador = lin.read(); if (contador >= 0) { System.out.print((char) contador); } } while (contador >= 0); System.out.println("\nSe leyeron " + lin.getLineNumber()+1+ " lineas de texto."); lin.close(); } catch (IOException ex) { System.out.println("Error al leer o crear archivo"); }

En el caso anterior la clase LineNumberInputStream es una clase que provee métodos adicionales para llevar la cuenta del número de líneas leídas desde el flujo entrante (en este caso proveniente de un archivo). Observe que para crear un objeto de la clase LineNumberInputStream se necesita un objeto de la clase FileInputStream quien a su vez necesita un objeto de tipo File. Las líneas donde se crean estos objetos es la siguiente:



File f = new File("C:/prueba.txt"); LineNumberInputStream lin = new LineNumberInputStream(new FileInputStream(f)); Observe que en el ejemplo, todas las líneas que involucran al archivo (creación, lectura, etc.) se encuentran dentro de un control de excepciones try, catch. Si no fuera así, el intérprete nos marcaría un error. Observe además, que dentro del catch nos dice “IOException ex”. IOException nos indica que será una excepción de entrada o salida (In, Out) y ex es el nombre con que conoceremos dicha excepción. Usted puede poner el nombre que desee a una excepción. También, en lugar de poner IOException, podría poner simplemente Ecxeption. Para que cualquier tipo de excepción que ocurra se controle por medio de ese catch. Recuerde, dentro del catch usted pondrá lo que desea que el programa haga si ocurre un error de algún tipo. De salida en caso de IOException o cualquier error en caso de Exception. En este caso queremos que nos muestre un mensaje explicándonos que tipo de error ocurrió, por eso ponemos la línea:

System.out.println("Error al leer o crear archivo");


Otras clases (más útiles que esta) existentes son:

• BufferedInputStream: Agiliza (y mucho) el acceso a flujos mediante la

lectura de los datos en ráfagas. Los datos, en lugar de ser leídos de a

uno a medida que se invoca al método read(), son leídos de a muchos y

almacenados en una memoria intermedia de contención (buffer).



• DataInputStream: Permite leer datos de tipo primitivo desde el flujo en

lugar de sólo enteros de 8 bits (bytes), por ejemplo double, float, int,

long, etc.

Salida La familia de flujos de salida es análoga a la de entrada, teniéndose subclases de OutputStream que permiten escribir en distintos medios:

• FileOutputStream: hacia un archivo.

• ByteArrayOutputStream: hacia un bloque de memoria o bien

decoradores, heredados de FilterOutputStream.

• BufferedOutputStream: escritura en ráfagas.

• DataOutputStream: escritura de datos de otros tipos primitivos además

de byte.

• PrintSteam: permite escribir texto de a líneas (System.out es un ejemplo

de PrintStream).

Ejemplo: Modifique el ejemplo, coloque un nuevo botón para crear un archivo de texto que pueda utilizar para leerlo y contar la líneas que se escribieron en el. Justo lo que se hizo en el ejemplo anterior. private void crearArchivo1MouseClicked(java.awt.event.MouseEvent evt) { try{ FileWriter archivoEsc = new FileWriter ("C:/prueba.txt"); PrintWriter escribirArch = new PrintWriter(archivoEsc); int lineas = Integer.parseInt(JOptionPane.showInputDialog (campoTexto1, "¿Cuantas Lineas desea ingresar?")); for(int contador=1; contador<=lineas; contador++ ){ escribirArch.println(JOptionPane.showInputDialog (campoTexto1, "Escriba la linea "+contador)); } archivoEsc.close(); } catch (Exception e){ System.out.print("Error al crear el archivo"); } }



En el ejemplo anterior, se crea el archivo y se presenta una caja de dialogo preguntando cuantas líneas desea ingresar al archivo y posteriormente se crea un ciclo en el cual se pide una por una las líneas que se indicaron en la primera y se escriben en el archivo.


3.2 Acceso directo. Las clases que hemos analizado hasta ahora, son clases de acceso secuencial, clases cuyo contenido debe ser leído o escrito secuencialmente. Esto es increíblemente útil, los archivos de acceso secuencial son consecuencia de un medio secuencial cómo una cinta magnética. Por otro lado, los archivos de acceso aleatorio, permiten un acceso no secuencial, o aleatorio al contenido de un archivo. Veamos por qué podríamos necesitar archivos de acceso aleatorio. Consideremos el formato de archivo conocido como "zip". Los archivos Zip contienen archivos que normalmente están comprimidos para ahorrar espacio. Estos archivos también contienen una "entrada de directorio" que indica donde comienzan los distintos archivos contenidos dentro de la carpeta Zip: Ahora supongamos que queremos extraer un archivo específico de un archivo Zip. Si utilizáramos una clase de acceso secuencial, tendría que hacer lo siguiente:

• Abrir el archivo Zip.

• Buscar a través del archivo Zip hasta que se localice el archivo que

quiere extraer.

• Extraer el Archivo.

• Cerrar el archivo Zip.



Como mínimo, utilizando este argumento, habremos tenido que leer medio archivo Zip antes de encontrar el archivo que quiere extraer. Se puede extraer el mismo archivo de un archivo Zip de una forma más eficiente utilizando la característica de búsqueda de un archivo de acceso aleatorio:

• Abrir el archivo Zip.

• Buscar en la entrada de directorio y localizar la posición para el archivo

que quiere extraer.

• Buscar (hacia atrás o adelante) dentro del archivo Zip hasta la posición

del archivo a extraer.

• Extraer el archivo.

• Cerrar el archivo Zip.

Este algoritmo es mucho más eficiente porque sólo lee la entrada de directorio y el archivo que se quiere extraer. (Los archivos .zip que contiene varios archivos dentro, contienen una breve descripción de las posiciones que ocupa cada archivo dentro de este. Eso es lo que se lee para saber dónde está el archivo y extraerlo). La clase RandomAccessFile del paquete java.io implementa un archivo de acceso aleatorio. Utilizar Archivos de Acceso Aleatorio Al contrario que las clases de acceso secuencial, RandomAccessFile se utiliza tanto para leer como para escribir archivos. Se puede crear el RandomAccessFile con diferentes argumentos dependiendo de lo que se intente hacer, leer o escribir. La clase RandomAccessFile implementa las interfaces DataInput y DataOutput y por lo tanto puede utilizarse tanto para leer como para escribir. RandomAccessFile es similar a FileInputStream y FileOutputStream en que se especifica un archivo del sistema de archivos nativo para abrirlo cuando se crea. Se puede hacer esto con un nombre de archivo o un objeto File. Cuando se crea un RandomAccessFile, se debe indicar si sólo se va a leer el archivo o también se va a escribir en él. La siguiente línea de código java crea un RandomAccessFile para leer el archivo llamado prueba.txt:

new RandomAccessFile("prueba.txt", "r"); Y esta otra abre el mismo archivo para leer y escribir:



new RandomAccessFile("prueba.txt", "rw"); Después de haber abierto el archivo, se pueden utilizar los métodos comunes read() o write() para realizar la I/O sobre el archivo. En la siguiente tabla se muestran algunos de los métodos para leer o escribir que posee esta clase.

Método Función read() Lee un byte de información del archivo. write() Escribe un byte específico en el archivo.

readLine() Lee la siguiente Línea de texto del archivo. writeLong() Escribe un dato tipo long en el archivo. readShort() Lee un número con signo de 16 bits del archivo. readLong() Lee un dato tipo long del archivo.

readInt() Lee un dato tipo Int del archivo. Tabla 3.1 Métodos de la clase RandomAccessFile.

Esta clase posee métodos suficientes para leer cualquier tipo de dato nativo de java, líneas en un archivo, escribir cualquier tipo de dato nativo de java e incluso métodos para moverse a determinada posición. RandomAccessFile soporta la noción de puntero de archivo. El puntero de archivo indica la posición actual dentro del archivo. Cuando el archivo se crea por primera vez, el puntero de archivo es cero, indicando el principio del archivo. Las llamadas a los métodos readTipoDeDato() y writeTipoDeDato() ajustan el puntero de archivo el número de bytes leídos o escritos. Además de los métodos normales de E/S (Entrada / Salida) que mueven implícitamente el puntero del archivo cuando ocurre una operación, RandomAccessFile contiene tres métodos que manipulan explícitamente el puntero de archivo. skipBytes() : Mueve el puntero de archivo hacia adelante el número de bytes especificado. void seek() : Coloca el puntero del archivo en una posición determinada. La posición se da como un desplazamiento en bytes desde el comienzo del archivo. La posición 0 marca el comienzo de ese archivo. long getFilePointer() : Devuelve la posición actual del puntero de archivo. long length() : Devuelve la longitud del archivo. La posición length() marca el final de ese archivo. Creación de un Archivo de Acceso Aleatorio Hay dos posibilidades para abrir un archivo de acceso aleatorio: Con el nombre del archivo: miRAFile = new RandomAccessFile( String nombre,String modo );



Con un objeto File: miRAFile = new RandomAccessFile( File archivo, String modo );

El argumento modo determina si se tiene acceso de sólo lectura (“r”) o de lectura/escritura (“r/w”). Por ejemplo, se puede abrir un archivo de una base de datos para actualización:

RandomAccessFile miRAFile; miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );

Actualización de Información Se pueden utilizar archivos de acceso aleatorio para añadir información a archivos existentes: Ejemplo: Agregar un botón a la aplicación de escritorio que cree un archivo de acceso aleatorio, se mueva al final del archivo y agregue algunas líneas de información. private void crearRAFMouseClicked(java.awt.event.MouseEvent evt) { try { //Cada vez que demos clic sobre este botón, //se incorporara una nueva //línea al archivo de log que se crea //la primera vez que se ejecuta RandomAccessFile miRAFile; String s = "Informacion a incorporar"; // Abrimos el archivo de acceso aleatorio miRAFile = new RandomAccessFile("C:/prueba.txt", "rw"); // Nos vamos al final del archivo miRAFile.seek(miRAFile.length()); miRAFile.writeBytes(s); miRAFile.close(); } catch (IOException ex) { System.out.println("Error al Abrir el archivo"); } }



Figura 3.3 Ejemplo con RandomAccessFile.

Como puede observar la información se escribe de manera consecutiva, en la misma línea. Este tipo de archivo es muy útil cuando se conoce la estructura exacta de algún archivo y se desea introducir información en determinado lugar o después de determinada cantidad de bytes. Observe que debido a sus características, usted es capaz de regresar a cierta posición en el archivo o ir de nuevo al inicio si así lo requiere para alguna aplicación. Leer y Escribir objetos (Serialización). La serialización es una característica de objetos (cuya clase implementa la interfaz Serializable) que les permite convertirse en una secuencia de bytes que pueden ser posteriormente leídos para restaurar al objeto original. Esta característica se mantiene incluso al mandar la información por alguna red sin importar si quiera si se envía de un sistema operativo a otro distinto. Para hacer una clase serializable, esta debe implementar la interfaz Serializable por ejemplo:

public class MiClase implements java.io.Serializable{ private int[] x; private int n; //otros miembros... }

Hay dos clases que se especializan en la lectura y escritura de objetos. Estas clases con: ObjectInputStream y ObjectOutputStream. Estas clases ayudan en la lectura y escritura de clases que implementan serialización, como la del ejemplo anterior. Para escribir objetos siga los siguientes pasos:

1. Creamos un objeto de la clase “MiClase” o cualquiera que implemente serialización.

MiClase objetoAEscribir = new MiClase(new [] {1,2,3,4,5});

Estamos creando un arreglo de enteros para que el objeto tenga algo de información.



2. Creamos un flujo de salida. O sea un objeto FileOutputStream, le pasamos el nombre del archivo en el que queremos escribir o el objeto file que contenga dicha información (Estos métodos se analizaron anteriormente).

FileOutputStream fileOut=new FileOutputStream("prueba.obj");

3. Ya creamos un flujo de salida a un archive, sin embargo, necesitamos relacionar el objeto que acabamos de crear con uno de la clase ObjectOutputStream que es el que procesa los datos.

ObjectOutputStream flujoSalida=new ObjectOutputStream(fileOut);

O puede unir los dos pasos anteriores con la siguiente línea:

ObjectOutputStream flujoSalida=new ObjectOutputStream(new FileOutputStream("prueba.obj"));

4. El objeto flujoSalida puede utilizar ahora al método writeObject para escribir los objetos en un archivo en el disco duro. Por ejemplo, para escribir un objeto de la clase MiClase y un String el código es el siguiente:

flujoSalida.writeObject("Esta String se guardará\n"); flujoSalida.writeObject(onjetoAEscribir); 5. Por último, se cierran los flujos de salida.

flujoSalida.close(); El código completo se vería de la siguiente manera: MiClase objetoAEscribir= new MiClase(new int[]{12, 15, 11, 4, 32}); FileOutputStream fileOut=new FileOutputStream("prueba.obj"); ObjectOutputStream flujoSalida=new ObjectOutputStream(fileOut); flujoSalida.writeObject("guardar este string y un objeto\n"); flujoSalida.writeObject(lista1); flujoSalida.close(); Para leer objetos siga los siguientes pasos:



1. Creamos un objeto de la clase FileInputStream, éste será nuestro flujo de entrada al archivo. Le pasamos el nombre y directorio del archivo que deseamos utilizar o un objeto file que contenga el dato.

FileInputStream fileIn=new FileInputStream("media.obj");

2. El flujo de entrada ObjectInputStream es el que procesa los datos, se debe vincular al objeto de la clase FileInputStream que creamos.

ObjectInputStream flujoEntrada=new ObjectInputStream(fileIn);

3. El objeto flujoEntrada posee ahora los métodos necesarios para leer objetos que se encuentren en un archivo. El método que llama readObject se encarga de leer objetos del flujo de entrada, o sea, el archivo. Por ejemplo, para leer un objeto String y un objeto de MiClase las líneas son las siguientes:

String str=(String)flujoEntrada.readObject(); MiClase obj=(MiClase)flujoEntrada.readObject();

4 Utilice los objetos recuperados. Una vez que llega a este punto, puede disponer de los objetos como le plazca, puede utilizar sus métodos o propiedades para lo que sea que los haya recuperado de la misma manera que lo hace habitualmente. Por ejemplo, imprimiremos un dato del objeto obj y al objeto str. System.out.println("Valor de n "+obj1.n); System.out.println(“El objeto String contiene ”+str); 5. Y por último, al igual que al escribir objetos, se cierran los flujos.

flujoEntrada.close(); Modificador transient El escribir objetos muchas veces se utiliza para mandarlos por medio de archivos a través de internet, esto podría ser un problema si usted transporta información importante o secreta. Por ello existe el modificador transient, este modificador protege los datos de un objeto cuando lo escribimos en un archivo. Este modificador se utiliza de la siguiente manera: public class MiClase implements java.io.Serializable{ private int[] x; private transient int n; //otros miembros... }



Como puede ver, únicamente debe colocar la palabra transient antes del tipo de dato. Para escribir un objeto que contenga este tipo de protección, el proceso es el mismo.

3.3 Manejo de archivos. El manejo de archivos en java es el conjunto de operaciones que se pueden realizar con ellos en sus respectivos tipos. A lo largo de esta unidad estos procesos fueron ya explicados para que se comprendiera mejor la explicación de cada tema por lo que en este apartado se explicarán algunas otras herramientas útiles para el manejo de archivos en java que no se mencionaron anteriormente. Clase JFileChooser La clase JFileChooser proporciona una interfaz al usuario para elegir un archivo de una lista. Un selector de archivos es un componente que podemos situar en cualquier lugar del GUI (interfaz Gráfica de Usuario) de nuestro programa. Sin embargo, normalmente los programas los muestran en diálogos modales porque las operaciones con archivos son sensibles a los cambios dentro del programa (Recuerde, un cuadro de diálogo modal no permite que el programa siga interactuando con el usuario hasta que se cierre). La clase JFileChooser hace sencillo traer un diálogo modal que contiene un selector de archivos. Los selectores de archivos se utilizan comúnmente para dos propósitos.

• Para presentar una lista de archivos que pueden ser abiertos por la

aplicación.

• Para permitir que el usuario seleccione o introduzca el nombre de un

archivo a grabar.

Recuerde que hasta ahora, en todos los ejemplos relacionados con archivos, debemos introducir el directorio y nombre del archivo que queremos abrir, con esta clase, podremos elegir el archivo que deseemos abrir o guardar con el nombre que queramos sin tener que predefinir nada en el código con relación a estos nombres. Es conveniente aclarar que el selector de archivos ni abre ni graba archivos. Presenta una GUI para elegir un archivo de una lista. El programa es responsable de hacer algo con el archivo, como abrirlo o grabarlo. Como la mayoría de los programadores sólo quieren un selector para abrir o para grabar archivos, la clase JFileChooser proporciona los métodos convenientes para mostrar estos tipos de selectores de archivos en un diálogo. Nuestro primer ejemplo ilustra estos usos.



Ejemplo: Agregue dos botones a una aplicación de escritorio y programe los eventos correspondientes para que uno permita abrir un archivo de una lista y el otro permita guardar un archivo con un nombre cualquiera.

Figura 3.4 Ejemplo usando la clase JFileChooser.

Cuando se pulsa el botón “Abrir Archivo” el programa trae un open file chooser. Cuando se pulsa el botón “Guardar Archivo” el programa trae un save file chooser. Aquí podemos ver una imagen de un selector de apertura de archivos.

Figura 3.5 Selector de apertura

El código que crea y muestra el selector de apertura de archivos es el siguiente.



private void abrirArchivoMouseClicked(java.awt.event.MouseEvent evt) { JFileChooser fileChooser = new JFileChooser(); int valor = fileChooser.showOpenDialog(fileChooser); //Guardamos el valor de retorno para saber si se abrió //o no un archivo, Otras utilidades se explicarán //adelante. }

Por defecto, un selector de archivos que no haya sido mostrado anteriormente muestra todos los archivos en el directorio del usuario. Podemos especificarle un directorio inicial utilizando uno de los otros constructores de JFileChooser, o podemos seleccionar el directorio directamente con el método setCurrentDirectory. El programa de ejemplo utiliza el mismo ejemplar de JFileChooser para mostrar el selector de grabar archivos. El código es el siguiente: private void guardarArchivoMouseClicked(java.awt.event.MouseEvent evt) { JFileChooser fileChooser = new JFileChooser(); int valor = fileChooser.showSaveDialog(fileChooser); } Utilizando el mismo selector de archivos para abrir y grabar archivos, el programa consigue estos beneficios.

• El selector recuerda el directorio actual entre usos, por eso los diálogos

de abrir y grabar comparten el mismo directorio actual.

• Sólo tenemos que personalizar un selector de archivos, y nuestra

personalización se aplicará a las dos versiones, la de apertura y la de

grabación.

Cómo hemos podido ver en los fragmentos de código anteriores, los métodos showOpenDialog() y showSaveDialog() devuelven un entero que indica si el usuario ha seleccionado un archivo. Podemos utilizar el valor de retorno para determinar si realizar o no la operación requerida. Si el usuario elige un archivo, el código llama a getSelectedFile (del objeto fileChooser) sobre el selector de archivos para obtener un ejemplar de File, que representa el archivo elegido. Podemos utilizar otros métodos del objeto File, como getPath o isDirectory, para obtener información sobre él. También podemos llamar a otros métodos como delete y rename para cambiar el archivo



de alguna forma. Por supuesto, podríamos leer o grabar el archivo utilizando una de las clases lectoras o escritoras proporcionadas Anteriormente abríamos un archivo indicando la ruta y nombre del mismo, con los métodos de fileChooser como getPath podemos hacer lo mismo que antes pero sin especificar solo un archivo. Si quieres crear un selector de archivos para una tarea distinta de abrir o grabar, o si quieres personalizar el selector de archivos, sigue leyendo. Selectores de Archivos Personalizados Como hemos visto, JFileChooser proporciona un método para mostrar un selector de apertura de archivos y otro método para mostrar un selector para grabar archivos. En aspecto y comportamiento, la única diferencia entre estos dos selectores es el título de la ventana del diálogo y la etiqueta del botón "accept". La clase tiene un tercer método, showDialog, para mostrar un selector de archivos para una tarea personalizada. Aquí podemos ver el código que muestra el diálogo selector de archivos para la tarea Enviar.

private void abrirArchivoMouseClicked(java.awt.event.MouseEvent evt) { JFileChooser fileChooser = new JFileChooser(); int valor = fileChooser.showDialog(fileChooser, "Enviar"); }

Figura 3.6 Selector personalizado.

El primer argumento del método showDialog es el componente padre para el diálogo. El segundo argumento es un String que proporciona tanto el título de la ventana de diálogo como la etiqueta del botón "accept".



De nuevo, el selector de archivos no hace nada con el archivo seleccionado. El programa es responsable de implementar la tarea personalizada para la que se creó el selector de archivos. Filtrar la lista de archivos Por defecto, un selector de archivos muestra todos los archivos y directorios que detecta. Un programa puede aplicar uno o más filtros de archivos a un selector de archivos para que el selector sólo muestre algunos de ellos. El selector de archivos llama al método accept del filtro con cada archivo para determinar si debería ser mostrado. Un filtro de archivos acepta o rechaza un archivo basándose en algún criterio como el tipo, el tamaño, el propietario, etc. JFileChooser soporta tres clases de filtrado. Los filtros se checan en el orden aquí listado. Por eso un filtro del segundo tipo solo puede filtrar aquellos archivos aceptados por el primero, etc. Filtrado interno: El filtrado se configura a través de llamadas a métodos específicos de un selector de archivos. Actualmente el único filtro interno disponible es para los archivos ocultos. Se llama a setFileHidingEnabled(true) y sirve para desactivar la selección de archivos ocultos (como aquellos que empiezan con '.' en sistemas UNIX). Filtrado controlado por la aplicación: La aplicación determina los archivos a mostrar. Se crea una subclase de FileFilter, y se utiliza como un argumento para setFileFilter. El selector de archivos sólo mostrará los archivos que acepte el filtro. Filtrado seleccionable por el usuario: La GUI selector de archivos proporciona una lista de filtros de la que el usuario puede elegir uno. Cuando el usuario elige un filtro, el selector de archivos muestra sólo aquellos archivos que acepte el filtro. En el siguiente ejemplo se añade un filtro de archivos personalizado a su lista de filtros seleccionables del selector de archivos. Ejemplo: Cree un botón en nuestra aplicación o edite uno ya existente para que al dar clic, muestre un selector de archivos personalizado. Crear un filtro personalizado para que el selector de archivos muestre únicamente los archivos cuya extensión pertenezca a una imagen. Para ello deberá crear una clase separada que herede las propiedades de la clase FileFilter. El código del botón es:

private void abrirArchivoMouseClicked(java.awt.event.MouseEvent evt) { JFileChooser fileChooser = new JFileChooser(); int valor = fileChooser.showDialog(fileChooser, "Abrir Imagen"); Filtro imagenes = new Filtro(); fileChooser.addChoosableFileFilter(imagenes); }



Lo que se hace es lo siguiente:

a. Creamos un objeto FileChooser, este nos ayuda a mostrar los

selectores de archivos.

b. Guardamos el valor de retorno que nos indica que botón del

selector se presionó para realizar lo que deseemos. Al mismo

tiempo, se está personalizando la ventana para mostrar un texto

diferente en el botón “accept”, “Abrir Imagen” en este caso.

c. Creamos una instancia de la clase que representa al filtro.

Filtro.java que hicimos. Esta se muestra a continuación.

d. Agregamos el filtro a nuestro FileChooser. Este método, recibe

como parámetro un objeto FileFilter. Debido a esto, la clase que

nosotros diseñamos (Filtro.java) debe heredar las características

de FileFilter.

El filtro personalizado se implementa en Filtro.java, como una subclase de FileFilter. La clase Filtro implementa el método getDescription() para devolver un string y ponerlo en la lista de filtros seleccionables. Como muestra en el código de la clase Filtro, se implementa el método accept para aceptar todos los directorios y cualquier archivo que tenga las extensiones ".jpg", ".jpeg", ".gif", ".tif", or ".tiff". El código de la clase que representa al filtro es el siguiente: El nombre de la clase en Filtro.java

package aplicaciondeescritorio; import java.io.File; import javax.swing.*; import javax.swing.filechooser.*; //debe heredar de FileFilter para que se pueda usar la //clase en el método que la utiliza. public class Filtro extends FileFilter{ final static String jpeg = "jpeg"; final static String jpg = "jpg"; final static String gif = "gif"; final static String tiff = "tiff"; final static String tif = "tif";



// Acepta todos los directorios y los archivos gif, jpg, //o tiff. public boolean accept(File f) { if (f.isDirectory()) { return true;

} String s = f.getName(); int i = s.lastIndexOf('.'); //Buscamos después del punto en cada archivo para saber su //ext. if (i > 0 && i < s.length() - 1) { String extension = s.substring(i+1).toLowerCase(); if (tiff.equals(extension) || tif.equals(extension) || gif.equals(extension) || jpeg.equals(extension) || jpg.equals(extension)) { return true; } else { return false; } } return false; } // Método que nos muetra la descripcion del filtro public String getDescription() { return "Solo Imagenes"; } }

Como al principio se indica que esta clase pertenece al mismo paquete de nuestra aplicación (package aplicaciondeescritorio;), no es necesario importarla en ella para instanciar. Aceptando todos los directorios, este filtro permite al usuario navegar a través del sistema de archivos. Si se omitieran las líneas en negrita de este método, el usuario se vería limitado al directorio en que se inicializó el selector de archivos. A continuación, los métodos relacionados con lo aprendido y una breve descripción de su funcionamiento. Crear y Mostrar un Selector de Archivos

Método Propósito



JFileChooser() JFileChooser(File, FileSystemView) JFileChooser(File) JFileChooser(FileSystemView) JFileChooser(String, FileSystemView) JFileChooser(String)

Crea un ejemplar de JFileChooser.

int showOpenDialog(Component) int showSaveDialog(Component) int showDialog(Component, String)

Muestra un diálogo modal conteniendo el selector de archivos.

Tabla 3.2 Métodos para crear y mostrar un selector de archivos. Navegar por la Lista del Selector de Archivos

Método Propósito void ensureFileIsVisible(File) Fuerza el archivo indicado a ser

visible en la lista de archivos. void setCurrentDirectory(File) File getCurrentDirectory

Selecciona u obtiene el directorio cuyos archivos se están mostrando en el selector de archivos.

void changeToParentDirectory() Cambia la lista para mostrar el directorio padre del directorio actual.

void rescanCurrentDirectory() Comprueba el sistema de archivos y actualiza la lista del selector.

Personalizar el Selector de Archivos

Método Propósito JComponent getAccessory() void setAccessory(JComponent)

Selecciona u obtiene el accesorio del selector de archivos.

void setFileFilter(FileFilter) FileFilter getFileFilter()

Selecciona u obtiene el filtro primario del selector de archivos.

void setFileView(FileView) FileView getFileView()

Selecciona u obtiene el visor de archivos del selector.

FileFilter[] getChoosableFileFilters() void setChoosableFileFilters (FileFilter[]) void addChoosableFileFilter(FileFilter) boolean removeChoosableFileFilter (FileFilter) void resetChoosable(FileFilter) FileFilter getAcceptAllFileFilter()

Selecciona, obtiene o modifica la lista de filtros seleccionables.

void setFileHidingEnabled(boolean) boolean isFileHidingEnabled()

Selecciona u obtiene si se muestran los archivos ocultos.

Tabla 3.3 Métodos para personalizar el selector de archivos. Seleccionar Archivos y Directorios

Método Propósito void setFileSelectionMode(int) Selecciona el modo de selección de



int getFileSelectionMode() boolean isDirectorySelectionEnabled() boolean isFileSelectionEnabled()

archivos. Los valores aceptables son FILES_ONLY, DIRECTORIES_ONLY, y FILES_AND_DIRECTORIES.

void setMultiSelectionEnabled (boolean) boolean isMultiSelectionEnabled()

Selecciona u obtiene si se pueden seleccionar varios archivos a la vez.

void setSelectedFile(File) File getSelectedFile()

Selecciona u obtiene el archivo actualmente seleccionado.

void setSelectedFiles(File[]) File[] getSelectedFiles()

Selecciona u obtiene los archivos actualmente seleccionados.

Tabla 3.4 Métodos para seleccionar archivos y directorios.

3.4 Controlar errores en tiempo de ejecución. En todo programa existen errores inesperados en tiempo de ejecución, y también errores que no consideramos debido a nuestra propia inexperiencia como programadores. Algunos de estos errores ocurren por ejemplo, al intentar acceder a un elemento del arreglo que está fuera del límite de nuestro arreglo, o cuando intentamos acceder a un archivo inexistente, entre otros. Normalmente estos errores interrumpen el flujo de ejecución de nuestros programas, hasta el extremo de provocar la terminación del programa en forma inmediata. Java hace uso de las excepciones12 para poder controlar los errores en tiempo de ejecución. En Java, casi todos los tipos de errores que puedan surgir en tiempo de ejecución lanzan excepciones, es decir, cuando ocurre un error dentro de un método de Java, este método crea un objeto Exception, dicho objeto contiene información sobre la excepción, que incluye su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para manejar el error. El manejo de excepciones en Java sigue una estructura como esta:

try { //Codigo donde puede ocurrir un error } catch (ExcepcionA ex) { // Que se va a hacer en caso que se lance una Excepcion A } ... catch (ExcepcionZ ex) { // Que se va a hacer en caso que se lanze una Excepcion Z }

Por ejemplo: el siguiente es el código de un botón de nuestro ejemplo que se encarga de crear un archivo de acceso aleatorio, se ubica al final del archivo y agrega algo de información.

12 Una excepción es un evento que ocurre durante la ejecución del programa, de forma que interrumpe el flujo normal de las sentencias.



private void crearRAFMouseClicked(java.awt.event.MouseEvent evt) { try { // Cada vez que demos clic sobre este botón, se //incorporara una nueva línea al archivo de // log que se crea la primera vez que se ejecuta RandomAccessFile miRAFile; String s = "Informacion a incorporar"; // Abrimos el archivo de acceso aleatorio miRAFile = new RandomAccessFile("C:/prueba.txt", "rw"); // Nos vamos al final del archivo miRAFile.seek(miRAFile.length()); miRAFile.writeBytes(s); miRAFile.close(); } catch (IOException ex) { System.out.println("Error al Abrir el archivo"); } }

Dentro del bloque try { } viene encerrada la parte del programa que se desea manejar sus excepciones. El código dentro de algún catch (TipoDeExcepcion e) se ejecuta en caso de que se lance una excepción TipoDeExcepcion o que pertenezca al grupo TipoDeExcepcion. El sistema de ejecución Java busca rar el método que esté interesado en manejar una excepción particular. Es decir si se lanza una excepción en el método A, pero si A no está interesado en manejar dicha excepción, entonces el sistema de ejecución Java ve quién llamó a A (supongamos que si existe, y es el método B), entonces se regresa a B y ve si está interesado en dicha excepción, y así consecutivamente hasta llegar al método principal de nuestra aplicación. En caso de no encontrar alguien que quiera manejarlo, comúnmente Java manda una lista de mensajes en nuestra ventana de consola, y en muchos casos se termina la ejecución de nuestro programa. Cuando manejamos excepciones, podemos manejar excepciones en forma específica (por ejemplo, usar un índice que está fuera de los límites de nuestro arreglo), o manejar una excepción de cierta categoría (por ejemplo, una excepción lanzada por mal uso de un arreglo de datos), o manejar todas las excepciones en su conjunto. Para el primer caso, es necesario este código:

catch(ArrayIndexOutOfBoundsException e){ } Para el segundo:

catch (ArrayException e){} Y para el último

catch (Exception e){ }



En la práctica no es recomendable hacer uso de manejadores de excepciones demasiado generales, como la del último caso. Las excepciones son parte de Java, y es muy común usarlos en las operaciones E/S, ya que es donde más probabilidad hay de que se lance una. El uso de try y catch se abordo a fondo en la primera unidad de este libro.



EJERCICIOS PROPUESTOS. 3.1 Para continuar con nuestro proyecto de la calculadora, ahora implementaremos archivos en ella. Deberá crear un archivo en donde contenga una lista de nombres, nombres de usuario y contraseñas, estructure el archivo como crea que le convenga, ya sea separando el nombre y la contraseña por un carácter o simplemente basándose en las posiciones. El objetivo será que el programa pida un nombre de usuario y una contraseña, revisará que se el usuario este registrado en el archivo de texto y dará o no acceso a la aplicación. El programa utilizara las columnas de nombre y contraseña para validar el acceso a nuestra calculadora y el campo de nombre para mostrarlo en alguna parte de la calculadora con la leyenda “Usuario: nombre_del_usuario. “ Después, tendrá que agregar un menú que le permita agregar, eliminar, modificar o consultar usuarios. Agregue los objetos que considere necesarios. NOTA: Puede leer y manipular la información en arreglos y almacenar en archivo solo al momento de entrar o salir de la aplicación. Ejemplos del archivo de texto:

3.2 Programe una pequeña función que le permita leer un archivo de entrada y le diga cuantas palabras encontró en el mismo. 3.3 Diseñe un programa que le permita leer un archivo en su totalidad y que le diga cuantas veces encontró cierta palabra en él. El usuario deberá especificar que palabra desea buscar y elegir el archivo de entrada. 3.4 Programe una aplicación que le permita consultar el contenido de un archivo de texto, se le proporcionaran dos datos al programa, una palabra que se desea buscar y otra palabra con la que se desea sustituir la anterior. El



programa buscará la primera palabra y la sustituirá por la segunda y al final creará un nuevo archivo. 3.5. Implemente la utilización de archivos para manipular la información de una agenda electrónica. Este programa le permitirá crear, borrar, modificar o consultar de uno o varios archivos la información de sus amigos, familiares y conocidos. Utilice la clase JOptionPane para permitir que el usuario seleccione el archivo con el que se desea trabajar en lugar de especificar un directorio fijo. Lea la información de un(os) archivo(s) con una estructura especifica, manipule la información en arreglos y almacene la información al salir de la aplicación. La información almacenada es el nombre y su número telefónico únicamente. 3.6 Diseñe y programe las clases necesarias para crear una aplicación que le permita manipular una lista de alumnos y sus calificaciones almacenada en un archivo de texto. Deberá ser capaz de ordenar a los alumnos por su nombre o por sus calificaciones. Además, deberá ser capaz de agregar nuevos alumnos a su lista o eliminar registros existentes. Luego de tener una lista en orden, deberá ser capaz de guardar dicha lista ordenada en un archivo distinto al archivo de origen. 3.7 Crear un programa traductor del idioma inglés. Para ello, introduzca un archivo que contenga las palabras que pueden ser traducidas, cuando el usuario escriba una palabra en ingles, el programa leerá el archivo y buscará el significado para mostrarlo en la pantalla. 3.8 Desarrolle una aplicación que lea un archivo que contiene una lista de nombres con diferentes longitudes. El programa deberá comprobar que todos los nombres midan menos de 20 caracteres, de lo contrario deberá ajustarlo a este tamaño, elimine espacios en blanco que se encuentren en los extremos (si es que los hay) antes de comprobar el tamaño. Cree un nuevo archivo con los nombres filtrados y haga que el programa le diga cuantos registros fueron modificados para que su tamaño correspondiera. 3.9 Programe lo necesario para crear una aplicación que le permita leer de un archivo una lista de personas, su dirección y su teléfono. Las columnas deberán medir: nombre, 20 caracteres, dirección 60 caracteres y teléfono 20 caracteres. El programa deberá rellenar con espacios en blanco lo necesario para que haya 3 columnas con los datos exactamente en ese formato. El archivo de entrada puede tener algún formato en específico pero el de salida deberá tener la estructura mencionada. 3.10 Diseñe un programa que lea de un archivo una lista de valores numéricos (teléfonos) y busque si hay alguno repetido. El programa le notificará que número y cuantas veces esta repetido.



PROYECTO INTEGRAL El siguiente es un proyecto relativamente sencillo que se desarrolló en la empresa Konexo de grupo posadas (Morelia) para facilitar un proceso de filtrado de información para ciertas aplicaciones que trabajan utilizando archivos de texto con formato de posiciones. El programa consiste en tomar como entrada un archivo de Excel o pasar la información que contenga dicho archivo separada por algún carácter a otro archivo de texto para que la información se pueda separa en columnas (Las columnas dentro de un archivo de texto plano se identifican por los caracteres de separación como “#”, “’”, “|”, etc.). Las columnas más comunes son: Nombre, apellido paterno, apellido materno, dirección, ciudad y número telefónico.

El objetivo es obtener como salida un archivo de texto plano con la siguiente estructura:

ESTRUCTURA DEL ARCHIVO DE SALIDA.

ID Descripción del campo Tipo de dato Longitud Pos Inicial Pos Final Comentarios 2 Tipo de producto Numérico 6 1 6 1 AFORE 3 Tipo de solicitud Numérico 6 7 12 1 Afiliación 2 Traspaso 7 NSS Numerico 11 13 23 número de seguro social 8 CURP CHAR 18 24 41 Clave CURP 9 Ap. Paterno CHAR 40 42 81 Apellido Paterno 10 Ap. Materno CHAR 40 82 121 Apellido Materno 11 Nombres CHAR 40 122 161 Nombres 12 Telefono casa CHAR 20 162 181 Teléfono del domicilio del trabajador 13 Telefono oficina CHAR 20 182 201 Teléfono de la oficina del trabajador 12 Telefono celular CHAR 20 202 221 Teléfono celular del trabajador 12 Telefono patrón CHAR 20 222 241 Teléfono del jefe el trabajador 14 Extension oficina CHAR 6 242 247 Extensión de oficina del trabajador 13 Extension patron CHAR 6 248 253 Extensión del oficina del jefe Los campos de tipo de producto y tipo de solicitud se rellenan con: 000001 en cada registro y los datos que no existen en nuestro archivo de entrada como Teléfono del patrón, teléfono celular y demás. Se rellenan con espacios en



blanco. El único campo que no se deberá quedar en blanco es el NSS, pero como no lo tenemos llenamos los campos con 00000000001, 00000000002 y así sucesivamente para cada registro. Un ejemplo del archivo final es:

Las validaciones son las siguientes:

• Se necesitan por lo menos 10 dígitos en el número telefónico (solo

números). Los registros que no cumplan con esto se eliminan junto

con los datos que los acompañan. (No deben tener espacios,

diagonales, paréntesis, menos de 10 dígitos, guiones medios, letras,

etc.).

• Rellenar con espacios en blanco cada campo para que se completen

un número determinado de caracteres por línea.

En resumen, debe leer del archivo de Excel las diferentes columnas o extraer la información a un archivo de texto que le permita realizar las validaciones necesarias a los registros. La aplicación real obedece más validaciones y reglas pero para nuestro proyecto creo que con esto será suficiente.

Unidad 4. Acceso a Datos

Bases de Datos.

ITM Unidad IV Acceso a Datos


4.1 Introducción. En esta unidad trabajaremos sobre bases de datos, sin embargo, no es objetivo de esta unidad profundizar demasiado en el tema, mas bien, el dar al estudiante una idea del funcionamiento y los beneficios de utilizar una base de datos y también presentarle superficialmente algunas nuevas tecnologías diseñadas para trabajar con ellas que además de proporcionar un mejor diseño a la estructura de una aplicación, ayudan muchísimo a un funcionamiento mucho más eficiente. Como podrá recordar, el desarrollo de este material se basa en el lenguaje java, sin embargo, adicionalmente a los temas que se deben desarrollar de acuerdo al temario, explicaré y ejemplificare el uso de tecnologías importantísimas relacionadas con el lenguaje java, que además son equivalentes a las que se piden en el temario pero que son basadas en otros lenguajes como Visual Basic. Es necesario mencionar que debido a que las bases de datos son objeto de estudio en materias posteriores, aquí solo daré una breve introducción. Dando así al estudiante los conocimientos necesarios para facilitar el aprendizaje futuro. Para ello utilizaremos la herramienta de java JDBC13. Como manejador de bases de datos utilizaremos MySQL. JDBC fue diseñado para mantener sencillas las cosas sencillas. Esto significa que el API14 JDBC hace muy sencillas las tareas diarias de una base de datos, como una simple sentencia SELECT. Esta sección nos llevará a través de ejemplos que utilizan el JDBC para ejecutar sentencias SQL15 comunes, para que podamos ver lo sencilla que es la utilización del API JDBC básico. Al final de esta primera sección, sabremos cómo utilizar el API básico del JDBC para crear tablas, insertar valores en ellas, pedir tablas, recuperar los resultados de las peticiones y actualizar las tablas. En este proceso, aprenderemos como utilizar las sentencias sencillas y veremos un ejemplo de un procedimiento almacenado. También aprenderemos como realizar transacciones y como capturar excepciones y avisos. Instalar Componentes Necesarios. Para crear una aplicación que utiliza una base de datos debemos conectar nuestro programa hecho en con el lenguaje java en NetBeans con el manejador de la base de datos MySQL. Lo primero que debemos hacer antes de conectar Java con MySQL en NetBeans es instalar ambos. En la primera unidad vimos como instalar NetBeans. Para MySQL, no solo instalaremos MySQL, instalaremos un paquete llamado Appserv16.

13 Java Database Connectivity, es un API que permite ejecutar operaciones sobre una base de datos. 14 Del inglés Application Programming Interface – Interfaz de Programación de Aplicaciones. 15 Structured Query Language – Lenguaje estructurado para consultas en una base de datos. 16 Es un paquete que instalará en la PC Apache, PHP, MySQL y phpMyAdmin, dejando las aplicaciones configuradas para su funcionamiento.



Appserv es una herramienta OpenSource para Windows que facilita la instalación de Apache, MySQL y PHP en una sola herramienta, esta característica facilita la tarea al usuario ya que se configuran las aplicaciones de forma automática y quedan listas y funcionando. AppServ incluye:

• Apache 2.2.8: servidor HTTP multiplataforma.

• PHP 5.2.6: lenguaje de programación dinámico que utilizan la mayoría

de gestores de contenidos más populares. Se integra a la perfección con

MySQL y Apache.

• MySQL 5.0.51b: gestor de bases de datos, rápido y seguro.

• phpMyAdmin 2.10.3: interfaz gráfica de administración para MySQL.

Una vez instalado AppServ, dispondremos de un servidor web y otro de base de datos propio, configurado de manera local, y que nos permitirá realizar todas las pruebas necesarias en nuestra aplicación. La instalación de este paquete es conveniente para explicar de manera más adecuada y comprensible lo relacionado con la base de datos. Para ello se necesita phpMyAdmin. phpMyAdmin es una herramienta escrita en PHP con la intención de manejar la administración de MySQL a través de páginas web, utilizando Internet. Actualmente puede crear y eliminar Bases de Datos, crear, eliminar y alterar tablas, borrar, editar y añadir campos, ejecutar cualquier sentencia SQL, administrar claves en campos, administrar privilegios, exportar datos en varios formatos y está disponible en 50 idiomas. Se encuentra disponible bajo la licencia GPL (General Public License – O sea open source). Instalación de AppServ. Para instalar AppServ siga los siguientes pasos:

1. Baje la versión que desee del sitio oficial de AppServ, en este caso se

utilizará la versión (2.5.10), el link de la página oficial es el siguiente:

http://www.appservnetwork.com/

2. De doble clic al archivo y presione siguiente, acepte los términos de uso

y seleccione los elementos que desea instalar. Cabe mencionar que se



necesita apache server para que phpMyAdmin funcione. En nuestro

caso, instalaremos el paquete completo.

Figura 4.1 Ventana: Elegir nombre de pagina y puerto.

En este punto deberá elegir el nombre de su página de internet y dar un mail. Esto es para el servidor web apache. Por lo que si decidió no instalar este componente no verá esta pantalla. También deberá especificar porque puerto desea que trabaje el servidor. El valor predefinido es el 80.

3. Posteriormente, deberá elegir la configuración de MySQL.

Figura 4.2 Ventana: configuración de MySQL.



Esta parte es de suma importancia ya que debe elegir una contraseña para manejar las bases de datos, esta contraseña se requerirá al momento de conectar NetBeans con MySQL. “No la olvide”

4. Por último nos pregunta si debemos iniciar el servidor apache y MySQL.

Para probar que la instalación funciona debemos iniciar ambos servidores, para hacer esto vaya a inicio y busque AppServ, luego Control Server by Service y ahí seleccione Apache start y MySQL start. Puede ser que necesite en determinado momento detener o reiniciar el servidor apache, para que no tenga que venir a este punto en todo momento, puede utilizar Apache Monitor, al ejecutar esto, aparecerá un pequeño icono en la esquina inferior derecha con el cual tendrá acceso a estos comandos.

Figura 4.3 Iniciar ambos servidores.

Una vez que ambos servidores están funcionando habrá algún navegador de internet y escriba “localhost” en el apartado de la página. Lo que se muestra es la página de inicio de nuestro servidor apache. Si no se muestra la siguiente pantalla, puede ser que se haya instalado mal o que no hayamos iniciado los servidores. Nota: “localhost” funciona únicamente si usted dejo el puerto 80 al momento de instalar el servidor apache, si por algún motivo usted cambio ese número, deberá escribir “localhost:xxxx” (Ej. Localhost:8080).



Figura 4.4 Pantalla principal del servidor Apache.

Una vez que tenemos esta página vamos a entrar a phpMyadmin para administrar nuestras bases de datos. Para ello pulse donde dice phpMyadmin Database Manager. Para tener acceso deberemos ingresar nuestro nombre de usuario y contraseña; pero, hasta este momento únicamente existe el usuario “root”, para el cual especificamos una contraseña al momento de instalar. Escriba “root” en el nombre de usuario y la contraseña que eligió para poder entrar.

Figura 4.5 Pantalla principal de phpMyAdmin.

Esta es la interfaz de phpMyadmin que nos ayudará a administrar nuestra base de datos. Por último veamos la tabla de MySQL donde se guardan los usuarios que tienen acceso para ver qué usuarios tiene acceso.

NOTA: La utilización de phpMyadmin es muy sencilla pero debido a la gran cantidad de funciones y a la gran extensión de la misma, no se explicará a fondo su manejo en este apartado. Sin embargo, procesos como la creación de una base de datos, sus tablas y algunas otras acciones se explicarán a detalle más adelante.



Para ver la tabla donde se guardan los usuarios que tiene acceso demos click en “Bases de Datos” y seleccione la tabla de MySQL.

Figura 4.6 Como acceder a la tabla de usuarios

Como puede observar, se muestra un listado de las tablas que contiene esa base de datos. Seleccione la tabla “user” que está en lo más bajo. Hay dos opciones: Si da clic sobre la palabra “user” se mostraran los campos de la tabla, y su descripción. Esto es lo mismo que seleccionar la tabla y luego dar clic en la pestaña “Estructura”. Si da clic sobre la pequeña imagen de la tabla, se mostrará el contenido de la tabla, es decir los registros que se encuentran almacenados. Esto equivale a seleccionar una tabla y dar clic en la pestaña “Examinar” (Esta opción es la que nos interesa en este momento.)

Figura 4.7 Consulta de la tabla user de mySQL.



Como puede observar, se nos muestra la sintaxis de la consulta SQL que nos mostraría el contenido de esta tabla en la sección “consulta SQL” y en la parte inferior nos lista los resultados de la consulta. Esta herramienta le puede ser de gran utilidad si no está seguro de la sintaxis de alguna acción sobre una tabla al momento de programar y necesite saber cómo hacer algo sobre alguna tabla… todo lo que usted haga aquí de manera gráfica, se mostrara en consulta SQL. Vea que el único registro de la tabla es el usuario “root” y en el campo Password aparecen muchos caracteres. Esto es debido a que no es conveniente tener almacenada este tipo de información sin codificar. (Al momento de instalar, usted debió elegir algún método de codificación, si no se otorga uno por default). Si desea agregar un nuevo registro a esa tabla, haga click en la pestaña Insertar y llene los campos correspondientes.

Figura 4.8 Datos a llenar para dar de alta otro usuario.

Como puede ver, será capaz de crear nuevos usuarios con diferentes privilegios sobre las tablas o las cosas que puede hacer o no. Conectar Java con MySql en NetBeans. El proceso para conectar Java con MySQL es diferente en las diferentes versiones de NetBeans debido a que algunas versiones ya tienen incluidos los drivers necesarios y en otras se deben agregar manualmente. Conexión en versiones sin drivers. Lo primero es descargar el conector de la página oficial. El enlace es el siguiente: http://www.mysql.com/products/connector/j/ Para conectar una base de datos con java, abrimos NetBeans y creamos un proyecto, hacemos clic en la pestaña "Runtime" (En la versión que estamos utilizando la pestaña dice “Services”) y buscamos la opción "Databases",



hacemos doble clic sobre ella. Nos mostrará una carpeta con el nombre Driver, a esta le daremos clic con el botón derecho del mouse y seleccionamos Add Driver.

Figura 4.9 ¿Cómo agregar el driver para conectar la base de datos?

Nos mostrará un cuadro de dialogo en el cual debemos agregar el driver que descargamos anteriormente. Esto se hace oprimiendo el botón Add, deberemos buscar el archivo mysql-connector-java-5.1.6-bin.jar. En la opción Driver Class debemos seleccionar "com.mysql.jdbc.Driver".

Figura 4.10 Ventana: Agregar driver JDBC

Ahora, veremos que en la carpeta "Driver" nos aparecerá una opción llamada com.mysql.jdbc.Driver, la seleccionamos con el botón derecho del mouse y seleccionamos "Connect Using"



Figura 4.11 Opción para conectar la base de datos.

Ahora, se nos pide los datos de la base de datos, en la opción "Database URL" debemos ingresar la dirección de la base de datos, empezando con el prefijo "jdbc:mysql:://host/bd, ingresamos nuestro nombre de usuario y contraseña.

Figura 4.12 Agregar los datos de la base de datos.

Nos deberá salir un mensaje diciendo "Connection established", si es así, la conexión se completó sin problemas. De lo contrario, algún dato está mal o el servidor de MySQL no está activo. Establecer Conexión en NetBeans 6.0 En esta versión de NetBeans, el conector viene incluido por lo que establecer la conexión es más sencillo. Abra su aplicación, localice la pestaña “Services” y dentro de doble clic en Databases. Por último abra la carpeta Drivers. Como puede ver, ya se encuentran incluidos varios drivers, incluido el de MySQL. Lo seleccionamos con el botón derecho del mouse y seleccionamos "Connect Using". Ahora, se nos pide los datos de la base de datos (igual que antes), en la opción "Database URL" debemos ingresar la dirección de la base de datos, empezando con el prefijo "jdbc:mysql:://host/bd, ingresamos nuestro nombre de usuario y contraseña.



Figura 4.13 Conectar NetBeans con MySQL.

Una vez que ingresa los datos correctos, la conexión se establece.

Figura 4.14 Ventana: Conexión establecida.

La manera de conectarse con la base de datos anterior, puede ser útil para realizar pruebas con los usuarios que se hayan creado o para otros fines pero la manera importante de establecer la conexión es mediante código, dentro de alguna función. Ejemplo: Modificar nuestra aplicación para conectarse con una Base de Datos. Cree una función que pueda llamar desde cualquier lugar para conectarse mediante líneas de código con una base de datos.



A continuación, se muestra la clase “ConectarBD”, la cual nos servirá para conectarnos con una base de datos específica. package aplicaciondeescritorio; //Importamos las bibliotecas necesarias. import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; /** * @author Saùl */ public class ConectarBD { //Accesaremos a la base de datos de prueba que viene en el Appserv. public static String bd = "test"; //Nombre de la BD public static String login = "root"; //usuario public static String password = "entrar"; //Contraseña public static String url = "jdbc:mysql://localhost/"+bd; public static void conectar() { Connection conn = null; //Creamos un objeto Connection try { Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection(url, login, password); if (conn != null) { System.out.println("Conexión a base de datos "+ url+" … Ok"); //Este mensaje se mostrará si la conexión se estableció. conn.close(); //La instrucción anterior termina la conexión. } } catch(SQLException ex) { System.out.println("Hubo un problema al intentar"+ " conectarse con la base de datos "+url); } catch(ClassNotFoundException ex) { System.out.println(ex); //Se muestra un error si no se localiza una clase. } } }

Si no sabe que bibliotecas necesitará, no se preocupe, NetBeans le indicará al momento de detectar el error qué biblioteca necesita. Primero indicamos el driver que vamos a utilizar para establecer la conexión. Los drivers se bajan de internet como se indicó anteriormente. La manera de hacerlo es mediante la instrucción:

Class.forName("com.mysql.jdbc.Driver");

El método forName recibe como parámetro el nombre del driver. Este lo debimos haber agregado como se indicó anteriormente.



Las instrucciones que utilizamos para establecer la conexión deben estar dentro de un try {}, de lo contrarió NetBeans no nos permitirá avanzar. Los objetos necesarios para establecer una conexión vienen de la clase Connection. Una vez que creamos uno, hay que mandarle como parámetro la url (Direccion de la base de datos), el nombre de usuario y la contraseña de nuestro manejador de bases de datos. Ahora llamaremos esta función desde un botón nuevo en nuestra aplicación. (Se eliminaron los elementos de los ejemplos anteriores ya que no se necesitaban más.)

Figura 4.15 Ejemplo de botón que invoca una conexión con la base de datos.

El código del botón ConectarBD es el siguiente:

private void conectarBDMouseClicked(java.awt.event.MouseEvent evt) { ConectarBD.conectar(); }

Vea que ni siquiera es necesario declarar un objeto de la clase ConectarBD debido a que su único método (conectar()) es público. Aplicación con Bases de Datos. Para conocer la importancia de manejar las bases de datos hagamos el siguiente ejemplo. Siga los pasos cuidadosamente. Dado que no se pretende profundizar en el lenguaje de mySQL en el programa de esta materia, este no se analizará con profundidad, sin embargo se realizara un pequeño ejemplo en el cual se utilizara una base de datos con la ayuda de



phpMyadmin, se recomienda revisar el “Apendice 2” para conocer más a profundidad el lenguaje de mySQL. Cabe mencionar que al llevar a cabo este procedimiento en phpMyadmin, usted podrá “visualizar los comandos que tendría que llevar a cabo en línea de comandos”. Crear una base de datos.

La base de datos se llamará Negocio. Contendrá las tablas Clientes, Productos y Empleados. Los campos serán: para Clientes (Id, nombre, dirección), para Productos (Id, nombre y precio) y para empleados (Id, nombre, salario).

Primero entramos a nuestro navegador y luego a phpMyAdmin. Para crear ahí de manera gráfica nuestra base de datos. Seleccionamos la opción “Bases de Datos”.

Figura 4.16 Opción necesaria para crear una Base de Datos.

Ingresamos el nombre de nuestra base de datos y damos click en crear.



Figura 4.17 Crear tablas de la base de datos.

Creamos cada una de nuestras tablas. El proceso es muy intuitivo, escriba el nombre de la tabla y el número de campos, luego de clic en Continuar.

Figura 4.18 Ingresar datos de la tabla.

Ahora hay que definir que tamaño y tipo serán nuestros campos. Para el ejemplo manejaremos el campo Id como numérico y los demás serán caracteres. El campo Id, será la llave de cada una de las tablas. De clic en Guardar cuando termine con cada tabla.



Figura 4.19 Ingresar datos de cada campo de la tabla.

En la figura anterior se muestra que nuestro Id será un tipo de dato INT, no nulo, se autoincrementará y es además la llave de nuestra tabla. No se preocupe por cometer errores, puede modificar las tablas y sus campos posteriormente si lo desea. Haga lo mismo con las demás tablas. Una vez que creamos nuestras tablas podremos seleccionar nuestra nueva base de datos en el menú de bases de datos y ver cómo está conformada.

Figura 4.20 Vista de las tablas de nuestra base de datos.

Ahora vamos a nuestro ejemplo a crear registros en las tablas. Hasta este punto, nos conectamos con nuestra base de datos al dar clic en un botón. Obviamente no debe ser así, una aplicación de este tipo debería conectarse sin necesidad de tener que indicárselo. En el ejemplo donde se conecta con la base de datos usando un botón estamos terminando la conexión inmediatamente después de establecerla. Para este ejemplo hay que quitar esa línea y modificar los datos para conectarnos a la base de datos que acabamos de crear. La clase queda de la siguiente manera. package aplicaciondeescritorio; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ConectarBD { public static String bd = "negocio"; //Nombre de la BD public static String login = "root"; //usuario public static String password = "entrar"; //Contraseña public static String url = "jdbc:mysql://localhost/"+bd; public static Connection conectar() {



Connection conn = null; try { Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection(url, login, password); if (conn != null){ System.out.println("Conexión a base de datos "+url+" … Ok"); //conn.close(); se quita para permanecer conectados } } catch(SQLException ex) { System.out.println("Hubo un problema al intentar "+ "conectarse con la base de datos "+url); } catch(ClassNotFoundException ex) { System.out.println(ex); } return conn; } }

En el ejemplo anterior nos conectamos con una base de datos vacía que se llama test, ahora nos conectamos con la base de datos que creamos. Solo hay que cambiar el nombre de la base a la que nos conectamos y quitar la instrucción que nos desconectaba. También modificamos un poco la función para que nos regrese el objeto que representa nuestra conexión. Lo necesitaremos para los accesos a la base de datos. Ahora crearemos un botón que de de alta productos en nuestra base de datos, quitaremos el botón de “Conectar” ya que eso lo haremos aquí antes de dar de alta un registro. Nos pedirá por medio de cajas de diálogo los datos y los almacenará en la base de datos. El código del botón es el siguiente: private void altaProductoMouseClicked(java.awt.event.MouseEvent evt) { try { java.sql.Connection cone = ConectarBD.conectar(); String Id = JOptionPane.showInputDialog(menuBar, "Id :"); String nombre = JOptionPane.showInputDialog(menuBar, "Nombre :"); String precio = JOptionPane.showInputDialog(menuBar, "Precio :"); java.sql.Statement st = cone.createStatement(); st.execute("INSERT INTO `negocio`.`productos` (`Id` ,`nombre` ,`precio`) VALUES ('"+Id+"', '"+nombre+"', '"+precio+"');"); } catch (SQLException ex) { Logger.getLogger(AplicacionDeEscritorioView.class.getName()). log(Level.SEVERE, null, ex); } }



Primero se está estableciendo la conexión, luego se piden los tres valores que se almacenarán en la tabla. Por último se crea un objeto de la clase Statement que nos permitirá ejecutar sentencias SQL que enviemos en forma de cadenas.

Figura 4.21. Programa en ejecución.

Si entramos a phpMyadmin a ver los registros en esta tabla podremos ver lo siguiente.

Figura 4.22 Contenido de la base de datos.

Ejercicio: Realice modificaciones a la aplicación para realizar las cuatro operaciones básicas (Altas, Bajas, Modificaciones y Consultas) en las 3 tablas del ejemplo.

4.2 Control de datos ADO. ActiveX Data Objects (ADO) es uno de los mecanismos que usan los programas para comunicarse con las bases de datos, darles órdenes y obtener resultados de ellas. Con ADO, un programa puede leer, insertar, editar o borrar, la información contenida en diferentes áreas de almacenamiento dentro de la base de datos llamadas tablas.



Además, se puede manipular la propia base de datos para crear nuevas áreas para el almacenamiento de información (tablas), como también alterar o eliminar las ya existentes, entre otras cosas. Fue desarrollado por Microsoft y es usado en ambientes Windows por lenguajes de programación como Visual Basic y en la Web mediante el uso de Active Server Pages (ASP) y el lenguaje VBScript. ADO substituyó tanto a DAO (Data Access Object), que eran los sistemas previos que se usaban para acceder a las bases de datos y bases de datos remotas. Es sencillo de usar, de entender y por lo tanto fácil y menos engorroso de programar. La última versión de ADO, creada por Microsoft, se llama ADO.NET, y se usa en los entornos de programación de la plataforma .NET, de Microsoft, para manejar bases de datos tanto en Windows como en la Web mediante ASP.NET, que es la nueva versión del ASP para la plataforma .NET. ADO.NET es mucho más poderoso que ADO pero también es muy diferente, por lo que es necesario rediseñar los programas hechos con ADO, para que funcionen en él.

DAO RDO ADO

ADO.NET ADO.NET 2 (2006)

Funcionamiento ADO es un intermediario entre el programa y la base de datos. El programa no ve la base de datos directamente, sino que hace todo el trabajo a través de ADO. Usando ADO, el programa se comunica con la base de datos, consulta, edita, inserta, borra registros, añade tablas, etc. ADO a su vez se comunica con la base de datos a través de un "proveedor de datos". El programa usa ADO para hacer una solicitud a la base de datos: "Dame el nombre y apellido de todos los clientes que vivan en México"

Programa ---> ADO ---> Proveedor de datos ---> Base de datos En la dirección contraria, la base de datos responde, comunicándose con el proveedor de datos, éste con ADO, y al final, la información llega al programa. La base de datos responde:

Programa <--- ADO <--- Proveedor de datos <--- Base de datos



Una vez que el programa tiene la información proveniente de la base de datos, puede hacer con ella lo que considere, como por ejemplo, puede desplegarla en una página Web. Importancia de esta tecnología. Para comprender la importancia de esta tecnología, imaginemos que hicimos una aplicación de gestión para una empresa. Utilizando como motor de base de datos Oracle. Pero no tenemos dividida la capa de lógica (esta se representa con las líneas de programación que dicen qué hace el programa o que información necesita manipular de la base de datos) de la de persistencia (la capa de persistencia seria la que manipula las consultas directamente sobre la base de datos). Por lo que la interacción con la base de datos se hace directamente desde la capa de lógica de negocio. Tal y como lo hicimos en el apartado anterior. Nuestra aplicación consiste en muchísimas clases, y gran parte de ellas interactúan con la base de datos (conectándose a la base de datos, guardando y recuperando datos, etc.). Nuestra aplicación va de maravilla, cuando de pronto, se acerca nuestro cliente y nos comenta que por X, Y y Z razones se va a cambiar el motor de la base de datos a MySQL. En ese momento se nos viene el mundo encima pues tendremos que hacer prácticamente todo de nuevo. Todas las clases que interactúan directamente con la base de datos deben ser rediseñadas. Si hubiéramos tenido por separado la capa de lógica de negocio de la de persistencia, habría sido suficiente con modificar la capa de persistencia para que la aplicación pudiera utilizar el nuevo motor de base de datos, sin tener que modificar nada de la capa de lógica de negocio. Pero como en el ejemplo anterior NO usamos una capa de persistencia, sino que interactuamos con la base de datos directamente desde la capa de lógica de negocio, entonces vamos a tener que modificar todas las clases, cambiando todas las consultas SQL, la manera de acceder a la base de datos, etc. para adecuarse al nuevo motor de la base de datos.

4.3 Objetos ADO. (ActiveX Data Object) Los objetos ADO, se utilizan comúnmente con la tecnología ASP17. Una de las características más interesantes de ASP es su facilidad para el manejo de bases de Datos que residen en el servidor, obviamente mediante el uso de ADO (ActiveX Data Object) de una forma fácil, rápida y con un mínimo consumo de recursos del sistema. ADO usa ODBC (Open Database Connectivity)18 para el acceso a bases de datos. Lo que nos independiza de la tecnología de las misma; esto implica que podemos cambiar la tecnología de la base de datos y si mantenemos la misma

17 Active Server Pages, tecnología de Microsoft del tipo “lado servidor” para páginas web dinámicas. 18 Estándar para manejo de bases de datos creado por Microsoft.



estructura de datos, nuestras aplicaciones desarrolladas con ADO pueden seguir funcionando sin cambiar ni una sola línea de código. ADO está formado por varios objetos organizados de forma jerárquica (cada uno de ellos con sus métodos y propiedades específicos) de los cuales vamos a estudiar los que considero más interesantes. Connection Nos proporciona una conexión a una base de datos ODBC desde una página ASP. Esta conexión nos permitirá efectuar las operaciones que deseemos sobre la base de datos. Es el objeto primario de ADO, ninguno de los otros objetos puede existir si este no es declarado de forma explícita o implícita (en algunos de los ejemplos veremos que no existe una declaración del objeto Connection, pero debemos de tener en cuenta que siempre existe, si es necesario ADO lo declarará por sí mismo). La conexión terminará cuando nosotros la cerremos explícitamente con el método close o bien cuando termine la ejecución de la página ASP. Error Es una colección en la que se almacenarán los posibles errores del objeto. Command Representa un comando SQL que se ejecuta contra la base de datos declarada en el objeto Connection. Si el resultado de ese comando es un conjunto de datos, estos se almacenaran en un objeto de tipo Recordset. Recordset Representa una tabla o el resultado de una consulta ejecutada contra la base de datos. Va a ser nuestra interface natural contra la base de datos. Como en todo modelo relacional, los datos se nos presentaran en filas y columnas. Field El objeto Field representa la información relativa a un campo de un Recordset. Contiene la colección Fields que representa todos los campos de la tabla, cada miembro de esa colección es un objeto de tipo Field. Objeto Connection (propiedades y métodos) Hemos comentado que el objeto Connection nos proporciona una conexión a una base de datos desde una página ASP; ahora vamos a ver como se usa, así como sus propiedades y métodos. Para establecer la conexión lo primero que hacemos es crear el Objeto Connetion por medio de la propiedad CreateObject de objeto Server:



<% Set conexión=Server.CreateObject("ADODB.Connection")%>

Una vez establecida la instancia del objeto pasamos a configurarlo mediante sus distintas propiedades y métodos. Propiedades: ConnectionString Especifica la referencia a la base de datos con la cual queremos conectar, conteniendo en una cadena de texto la información necesaria para efectuar esa conexión mediante parejas de valores separadas por ";". Los valores que podemos asignar son: Data Source:

DSN=Nombre ODBC de la Base de Datos Usuario:

User=Nombre de Usuario Password:

Password=Password del usuario para la base de datos Ejemplo:

<% conexion.ConnectionString="DSN=MIOdbc;User=pepe;Password=1234" %>

Mode Especifica los permisos de la conexión. Algunos de los valores más habituales que podemos asignar son: 1 Establece permiso solo de Lectura 2 Establece permiso solo de Escritura 3 Establece permiso de Lectura/Escritura Ejemplo:

<% conexion.Mode=3 %> Métodos: BeginTrans Abre una transacción; todas las operaciones que realicemos a partir de ese momento no serán efectivas hasta que no cerremos la transacción. Ejemplo:



<% conexion.BeginTrans %> Close Cierra el objeto. Ejemplo:

<% conexion.close %>

CommitTrans Cierra una transacción haciendo efectivos los cambios efectuados dentro de ella. Ejemplo:

<% conexion.CommitBeginTrans %> Execute Ejecuta una sentencia SQL contra la base de datos. Ejemplo: <% Set resultado=conexion.execute (Select * from amigos) %> Open Abre la conexión con los parámetros especificados en las propiedades. Ejemplo:

<% conexion.open %> RollBackTrans Deshace todos los cambios efectuados en la base de datos desde el inicio de la transacción. Ejemplo:

<% conexion.RollBackTrans %> Objeto Error (propiedades y métodos) El objeto Error contiene la colección Errores, que es la encargada de almacenar los errores que se pudieran producir durante la ejecución de operaciones contra Bases de Datos.



Propiedades: Description Descripción del error. Number El numero de error. SQLState Código de error SQL. Métodos: Clear Elimina los datos del objeto Error. Ejemplo: Examinando los posibles datos de la colección Errors. Se crea un ciclo y se imprimen los posibles errores. ....... ....... Miconexion.open If Miconexion.Errors.Count > 0 then For each error in Miconexion.errors then Response.write Error.Number & " = "& Error.Description next End if

Nota: Count es una propiedad de la colección Errors. Objeto RecordSet El objeto Recordset es la interface entre los datos obtenidos de nuestras consultas sobre las tablas y nuestras páginas ASP. Representa una tabla organizada en filas (registros) y columnas (campos). La propiedades y métodos de Recordset son muchos, en esta unidad vamos a ver las más interesantes, para hacerlo un poco más sencillo de entender vamos a verlos agrupados por la funcionalidad que nos ofrecen. Definición del tipo de Cursor Entendemos como cursor el puntero que nos permite desplazarnos por los registros del recordset. Dependiendo del tipo elegido determinaremos los



desplazamientos y cambios realizables en los datos. El tipo de cursor lo definiremos mediante la propiedad CursorType, los posibles valores son:

Denominación valor Características

adOpenForwardOnly 0

Es el cursor por defecto, solo nos permite recorrer la tabla de forma secuencial (no se puede volver hacia atrás) y no permite modificaciones en los registros. No vemos los cambios realizados en la tabla por otro recordset.

adOpenKeyset

1

Nos permite movernos en los dos sentidos, si permite modificaciones en los registros. Vemos los cambios realizados en la tabla por otro recordset a excepción de las nuevas altas.

adOpenDynamic

2

Nos permite movernos en los dos sentidos, si permite modificaciones en los registros. Vemos todos los cambios realizados en la tabla por otro recordset.

adOpenStatic

3

Nos permite movernos en los dos sentidos, no permite modificaciones en los registros. No vemos los cambios realizados en la tabla por otro recordset.

Tabla 4.1 Tipos de cursores Definición del tipo de Cerrojo Entendemos como cerrojo el tipo de bloqueo que efectuaremos en la base de datos cuando modifiquemos un recordset, a fin de evitar que dos o más usuarios accedan a modificar un mismo registro a la vez. El tipo de cerrojo lo definiremos mediante la propiedad LockType, los posibles valores son:

Denominación valor Características

adLockReadOnly 1 Es el que está por defecto; no permite al usuario modificar los datos de la tabla.

dLockPessimistic 2 Cuando se abra la tabla nadie más podrá hacerlo, este modo nos asegura la plena integridad de los datos.

adLockOptimistic 3

Cierra la tabla a los demás usuarios cuando se invoque al método Update del objeto recordset; de este modo la Base de datos quedará bloqueada menos tiempo que con el método anterior.

Tabla 4.2 Tipos de Cerrojo.



Ejemplo: Definición de un recordset para actualizar datos:

Const adOpenForwardOnly = 0 Const adOpenKeyset = 1 Const adOpenDynamic = 2 Const adOpenStatic = 3 Const adLockReadOnly = 1 Const adLockPessimistic = 2 Const adLockOptimistic = 3%> set rs=createobject("ADODB.Recordset") rs.CursorType = adOpenKeyset rs.LockType = adLockOptimistic

Moviéndose por los datos del RecordSet Métodos usados para moverse en un RecordSet:

Método Características

Move Num_registros Mueve el cursor Num_registros hacia abajo si es positivo y hacia arriba si es negativo.

MoveFirst Mueve el cursor al primer registro del Recordset.

MoveLast Mueve el cursor al último registro del Recordset.

MoveNext Mueve el cursor un registro hacia adelante. MovePrevious Mueve el cursor un registro hacia atrás.

Tabla 4.3 Métodos pa moverse en un Recorset Propiedades usadas:

Propiedades Caracteristicas

PageSize (Ej. rs.Pagesize=10)

Establece el número de registros por página del Recordset.

AbsolutePage (Ej. rs.AbsolutePage=2)

Mueve el cursor al primer registro de dicha página (es necesario definir anteriormente el pageSize).

PageCount (Ej. xx=rs.PageCount)

Contiene el número de páginas del recordset, tomando como base PageSize.

Absoluteposition (Ej.

rs.Absoluteposition=17)

Mueve el cursor al num_registro especificado.

RecordCount (Ej. xx=rs.recordcount)

Contiene el número de registros del recordset; Nota: No funciona con el cursor adOpenForwardOnly

BOF Toma el valor True cuando estamos en el primer registro del recordset

EOF Toma el valor True cuando estamos en el ultimo registro del recordset



Tabla 4.4 Propiedades de un Recordset. Modificando los datos Métodos usados:

Metodo Caracteristicas AddNew

EJ.

rs.Addnew rs("codigo")=1234 rs("titulo")="Todo sobre ASP" rs.Update

Abre un nuevo registro en el recordset para introducir datos

Delete Elimina el registro actual Update

EJ:

rs("titulo")="Como hacerse rico en 10 minutos" rs.Update

Actualiza un registro del recordset tras haberlo modificado

Tabla 4.5 Métodos usados para modificar datos de un RecordSet. Abriendo y cerrando el recordset Métodos usados:

Método Caracteristicas Open Sql, conexion EJ. set rs=createobject("ADODB.Recordset") rs.CursorType = 1 rs.LockType = 3 Sqltxt="SELECT * FROM libros" rs.open Sqltxt, "DSN=Biblioteca"

Abre el recordset y almacena en el resultado de sql contra la conexión

Close Cierra el recordset Tabla 4.6 Métodos usados para abrir y cerrar un Recordset.

Ejemplo de listado de un Recordset: Suponga que tiene una BD, en ella la tabla almacén y en esa tabla los campos Id_Producto, Producto, Cantidad y Precio para el ejemplo. Nombre del archivo: Listado.asp



<%SQLtxt = "SELECT Producto, Cantidad, Precio FROM almacen set rs = CreateObject("ADODB.Recordset") rs.Open SQLtxt, "DSN=Mibase"%> <table> <% Do While NOT rs.EOF%> <tr> <td><%= rs("Producto")%></td> <td><%= rs("Cantidad")%></td> <td align="right"><% = FormatCurrency(rs("Precio"))%></td> </tr> <% rs.MoveNext Loop rs.Close </table> %>

4.4 Herramientas de acceso a datos. En el apartado anterior, analizamos una de las tecnologías más novedosas para el acceso eficiente a los datos. Sin embargo, existen muchas más herramientas que podríamos utilizar con el mismo fin. A continuación mencionaré de manera general algunas de las más comunes. 4.4.1 ADO.NET El ADO.NET es un conjunto de componentes del software que pueden ser usados por los programadores para acceder a datos y a servicios de datos. Es una parte de la biblioteca de clases base que están incluidas en el Microsoft .NET Framework. Es comúnmente usado por los programadores para acceder y para modificar los datos almacenados en un Sistema Gestor de Bases de Datos Relacionales, aunque también puede ser usado para acceder a datos en fuentes no relacionales. ADO.NET es a veces considerado como una evolución de la tecnología ActiveX Data Objects (ADO), pero fue cambiado tan extensivamente que puede ser concebido como un producto enteramente nuevo. 4.4.2 JDBC JDBC es el acrónimo de Java Database Connectivity, un API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se accede utilizando el dialecto SQL del modelo de base de datos que se utilice. El API JDBC se presenta como una colección de interfaces Java y métodos de gestión de manejadores de conexión hacia cada modelo específico de base de datos. Un manejador de conexiones hacia un modelo de base de datos en



particular es un conjunto de clases que implementan las interfaces Java y que utilizan los métodos de registro para declarar los tipos de localizadores a base de datos (URL) que pueden manejar. Para utilizar una base de datos particular, el usuario ejecuta su programa junto con la librería de conexión apropiada al modelo de su base de datos, y accede a ella estableciendo una conexión, para ello provee el localizador a la base de datos y los parámetros de conexión específicos. A partir de allí puede realizar con cualquier tipo de tareas con la base de datos a las que tenga permiso: consulta, actualización, creación, modificación y borrado de tablas, ejecución de procedimientos almacenados en la base de datos, etc. 4.4.3 ODBC Open Database Connectivity (ODBC) es un estándar de acceso a Bases de Datos desarrollado por Microsoft Corporation, el objetivo de ODBC es hacer posible el acceder a cualquier dato desde cualquier aplicación, sin importar qué Sistema Gestor de Bases de Datos (DBMS por sus siglas en inglés) almacene los datos, ODBC logra esto al insertar una capa intermedia llamada manejador de Bases de Datos, entre la aplicación y el DBMS, el propósito de esta capa es traducir las consultas de datos de la aplicación en comandos que el DBMS entienda. Para que esto funcione tanto la aplicación como el DBMS deben ser compatibles con ODBC, esto es que la aplicación debe ser capaz de producir comandos ODBC y el DBMS debe ser capaz de responder a ellos. Desde la versión 2.0 el estándar soporta SAG y SQL. Para conectarse a la Base de Datos se crea una DSN dentro del ODBC que define los parámetros, ruta y características de la conexión según los datos que solicite el fabricante. 4.4.4 DAO Como mencioné al inicio de esta unidad, este material se orienta a la programación en java en la medida de lo posible. Sin embargo, se analizan herramientas que no necesariamente trabajan con java. La tecnología ADO (De Microsoft, se maneja con Visual Basic o tecnologías propias hasta este momento), como pudo observar, es una tecnología importantísima en cuanto al manejo de bases de datos, es por esto que analizaré más a detalle el tema de los objetos DAO. Estos objetos se considera una herramienta vieja en comparación a ADO, sin embargo está comprobado que se utiliza de manera más amplia debido a que se maneja con el lenguaje java y su potencia es equiparable. Un Data Access Object (DAO, Objeto de Acceso a Datos) es un componente de software que suministra una interfaz común entre la aplicación y uno o más dispositivos de almacenamiento de datos, tales como una Base de datos o un archivo. Al igual que los objetos ADO, los objetos DAO conforman una capa que separa las capas de lógica y de programación de nuestras aplicaciones. El beneficio principal, como se ejemplificó anteriormente, es que si tuviéramos una tecnología de BD y cambiáramos a otra, no tendríamos que reprogramar nuestras clases. La capa formada por los objetos DAO se llama capa de Persistencia de Datos.



Como ya mencionamos, DAO encapsula el acceso a la base de datos. Por lo que cuando la capa de lógica de negocio necesite interactuar con la base de datos, va a hacerlo a través de la API que le ofrece DAO. Generalmente esta API consiste en métodos CRUD (Create, Read, Update y Delete). Entonces por ejemplo cuando la capa de lógica necesite guardar un dato en la base de datos, va a llamar a un método create(). Lo que haga este método, es problema de DAO y depende de cómo DAO implemente el método create(), puede que lo implemente de manera que los datos se almacenen en una base de datos o que los datos se almacenen en un archivos de texto. Lo importante es que la capa de lógica no tiene porque saberlo, lo único que sabe es que el método create() va a guardar los datos, así como el método delete() va a eliminarlos, el método update() actualizarlos, etc. Pero no tiene idea de cómo interactúa DAO con la base de datos. En una aplicación, hay tantos DAOs como modelos. Es decir, en una base de datos relacional, por cada tabla, habría un DAO. DAO consiste básicamente en una clase que es la que interactúa con la base de datos. Los métodos de esta clase dependen de la aplicación y de lo que queramos hacer. Pero generalmente se implementan los métodos CRUD para realizar las "4 operaciones básicas" de una base de datos. Por último, debemos mencionar a los objetos DTO y podremos analizar código. Los DTO (Data Transfer Object) o también denominados VO (Value Object). Son utilizados por DAO para transportar los datos desde la base de datos hacia la capa de lógica y viceversa. Por ejemplo, cuando la capa de lógica llama al método create(), ¿qué es lo que hace DAO? inserta un nuevo dato... ¿pero qué dato? el que la capa de lógica le pase como parámetro... ¿y cómo se lo pasa este dato?, a través de un DTO. Podría decirse que un DTO es un objeto común y corriente, que tiene como atributos los datos del modelo, con sus correspondientes accesos (getters y setters). Por ejemplo, si tuviéramos una base de datos relacional con una tabla Almacen, con los campos id, producto y cantidad. Entonces tendríamos que crear una clase AlmacenDTO, con los atributos id, producto y cantidad, que van a utilizar la capa de lógica y de persistencia para transportar los datos entre las dos capas. Entonces cuando la capa de lógica quiera guardar un dato en la base de datos, va a crear un objeto AlmacenDTO, a través de los accessors (métodos utilizados para accesar a la base) va a modificar los atributos, y después se lo va a pasar al método create() de DAO. Entonces DAO va a leer los datos del DTO, y los va a guardar en la base de datos. Lo mismo pasaría para eliminar datos. Y para actualizarlos además se le pasaría el ID, para saber que dato actualizar. Para buscar datos, sería parecido, ya que se le pasa al método read() el DTO para usarlo como patrón de búsqueda, pero con la diferencia de



que este método tiene valor de retorno, ya que devuelve otro DTO con los datos del resultado de la búsqueda. Ejemplo usando DAO Imaginemos una aplicación realizada en Java, utilizada para gestionar los datos de una empresa (Almacen, clientes, empleados, etc.). Nosotros somos los encargados de crear la capa de persistencia de la aplicación, y decidimos utilizar el patrón de diseño DAO. Primero debemos saber ¿Qué vamos a guardar en la base de datos?. Los datos de los empleados, los datos de los clientes y los datos de los productos. Son tres modelos:

• El modelo Empleado: que almacena los datos de los empleados (el ID,

el nombre y el sueldo).

• El modelo Cliente: que almacena los datos de los clientes (el ID, el

nombre y la dirección).

• El modelo Producto: que almacena los datos de los productos (el ID, el

nombre y el precio).

Lo primero que debemos hacer es crear los DTO, uno para cada modelo: Archivo Empleado.class:



class EmpleadoDTO { //Necesitamos una variable por cada dato de la tabla private int id; private String nombre; private double salario; //Ahora un método que nos regrese cualquiera de los //valores de la tabla que declaramos antes. public int getId() {return id;} public String getNombre() {return nombre;} public double getSalario() {return salario;} //Por ultimo un método que podamos usar para //establecer o dar un valor a cada elemento. public void setId(int id) {this.id = id} public void setNombre(String nom) {this.nombre = nom} public void setSalario(double sal) {this.salario = sal} }

Archivo Clientes.class: class ClienteDTO { //Campos de la tabla private int id; private String nombre; private String direccion; //Métodos para leer datos public int getId() {return id;} public String getNombre() {return nombre;} public String getDireccion() {return direccion;} //Métodos para establecer datos public void setId(int id) {this.id = id} public void setNombre(String nom) {this.nombre = nom} public void setDireccion(String dir) {this.direccion = dir} }

Archivo Producto.class:



class ProductoDTO { //Campos de la tabla private int id; private String nombre; private double precio; //Métodos para leer datos public int getId() {return id;} public String getNombre() {return nombre;} public double getPrecio() {return precio;} //Métodos para establecer datos public void setId(int id) {this.id = id} public void setNombre(String nom) {this.nombre = nom} public void setPrecio(double precio) {this.precio = precio} }

Ahora, vamos a crear los DAO, uno para cada modelo también: Archivo EmpleadoDAO.class:

class EmpleadoDAO { public void create(EmpleadoDTO dto) { /* Implementación del método create() */ } public EmpleadoDTO read(EmpleadoDTO dto) { /* Implementación del método read() */ } public void update(EmpleadoDTO dto, int id) { /* Implementación del método update() */ } public void delete(EmpleadoDTO dto) { /* Implementación del método delete() */ } }

Archivo ClienteDAO.class:

class ClienteDAO { public void create(ClienteDAO dto) { /* Implementación del método create() */ } public ClienteDAO read(ClienteDAO dto) { /* Implementación del método read() */ }



public void update(ClienteDAO dto, int id) { /* Implementación del método update() */ } public void delete(ClienteDAO dto) { /* Implementación del método delete() */ } }

Archivo Producto.class:

class ProductoDAO { public void create(ProductoDTO dto) { /* Implementación del método create() */ } public ProductoDTO read(ProductoDTO dto) { /* Implementación del método read() */ } public void update(ProductoDTO dto, int id) { /* Implementación del método update() */ } public void delete(ProductoDTO dto) { /* Implementación del método delete() */ } }

Obviamente en lugar de los comentarios van las implementaciones. Como estamos utilizando mySQL, el método create() , por ejemplo, de ClienteDAO hará una consulta SQL insertando un nuevo registro con los datos pasados por el DTO como parámetro en la tabla clientes. Si por algún motivo tuviéramos que cambiar de manejadores de bases de datos, es en este punto donde deberemos modificar líneas de código. Sin embargo, será mucho más sencillo ya que tendremos perfectamente ubicados los archivos que interactúan con la base de datos y las demás clases seguirán funcionando exactamente igual. Bien, ya estaría la capa de persistencia creada. Ahora ya podríamos utilizarla desde la capa de lógica: Aplicación. Archivo principal Programa.class: public static void main(String[] args) { /* Creamos el DAO */ EmpleadoDAO dao = new EmpleadoDAO(); /* Creamos un DTO */



EmpleadoDTO dto = new EmpleadoDTO(); /* Le asignamos los datos */ dto.setNombre("Saúl Chávez"); dto.setSalario(7500); /* Llamamos al método create() del DAO que se encarga de

guardarlo en la base de datos */ dao.create(dto); } Como pueden ver, lo único que hace la capa de lógica es llamar al método create() de EmpleadoDAO, pasándole como parámetro un EmpleadoDTO, después lo que haga el método create() es asunto de EmpleadoDAO.



EJERCICIO PROPUESTOS. 4.1 ¿Qué y para qué es el lenguaje SQL? Investigue acerca de este lenguaje con mucho detalle. Sobre todo la sintaxis de sus consultas. 4.2 ¿Cuál es la sintaxis para dar de alta un registro, modificarlo, consultarlo o eliminarlo? Ejemplifique diversas posibilidades. 4.3 Instale el paquete AppServ y de de alta un nuevo usuario con todos los accesos y permisos sobre las bases de datos de MySQL. 4.4 Crear una base de datos con ayuda de phpMyAdmin, deberá contener al menos 2 tablas, utilice el ambiente gráfico para ingresar 5 registros en cada una y luego experimente como modificar o eliminar los registros creados. Ej.

Clientes

Productos

ID ID Nombre Nombre AP Precio AM Existencia

4.5 Programe una función que le permita leer registro a registro el contenido de las tablas de una base de datos. Impleméntela en una aplicación gráfica que tenga los botones y campos de texto necesarios para ello. El usuario deberá elegir que tabla desea consultar, en caso de que la base de datos contenga varias. 4.6 Ejercicio de continuación del proyecto general. Cree una base de datos con el nombre que guste que contenga una tabla que se llame “usuarios” esta tabla deberá contener los campos: ID, usuario, password, nombre. Luego, haga que la calculadora que ha desarrollado durante todo el material utilice esta base de datos para el control de acceso, al igual que en la unidad anterior, donde se utilizó un archivo estructurado. 4.7 Desarrolle una aplicación gráfica que implemente bases de datos para almacenar palabras en ingles y sus equivalentes en español. Deberá crear la base de datos necesaria y permitir al usuario consultar el significado de una palabra en ingles. O sea, un traductor implementando bases de datos. 4.8 Explique con sus propias palabras la importancia de la capa de persistencia de datos en una aplicación. ¿Para qué sirve? Y ¿Qué herramientas puede utilizar para crearla? 4.9 ¿Cuáles son algunos de los objetos ADO Principales? ¿Para qué sirve cada uno? 4.10 Haga un programa sencillo en el que implemente algún objeto DAO para una consulta de datos. Realice la misma función sin utilizar el objeto y analice



cuales son las ventajas y desventajas de usarlo, no solo para su aplicación sino para proyectos empresariales. Investigue en internet que tanto se utiliza esta tecnología en comparación a los objetos ADO de Microsoft. PROYECTO INTEGRAL Existen muchos negocios en crecimiento que se interesan más y mas en poseer un sistema que les ayude a controlar la mercancía que tienen a la venta. La falta de un sistema de este tipo impide llevar un control exacto de las ganancias, las ventas y la existencia en bodega de sus productos. Además de que es menos posible detectar robos de esta manera. Desarrolle una aplicación de escritorio que implemente el uso de bases de datos. Consistirá en controlar los inventarios de la tienda de abarrotes “Doña Lupe”, como se trata de un negocio pequeño, solo les interesa saber que productos tienen, cuantos tienen, cuánto valen y quieren tener un sistema que les permita consultar la existencia de cierto producto para saber si necesitan comprar más o no, o si hay producto que está desapareciendo misteriosamente de la tienda y cual. Debe crear la base de datos que necesite y una interfaz que permita introducir nuevos productos al inventario, eliminar productos que ya no se tienen o realizar las consultas que el cliente necesita y se mencionaron anteriormente.

Unidad 5. Componentes y Controles Definidos por el

Usuario.

ITM Unidad V Componentes y Controles Definidos por el Usuario


5.1 Modelo de componentes. Un componente es un modulo de software independiente, que puede ser reemplazado y es una parte de un sistema de software dentro de una arquitectura bien definida. Un componente se ensambla a una arquitectura debido a que realiza o implanta un conjunto de interfaces. El modelo de componentes es una arquitectura y un API (del inglés Application Programming Interface - Interfaz de Programación de Aplicaciones) que permite a los desarrolladores definir segmentos reutilizables de código y que pueden ser reutilizados para crear programas. ActiveX Es un término que hace referencia a un conjunto de tecnologías independientes del lenguaje, que permiten que los componentes de software escritos en diferentes lenguajes funcionen juntos en entornos de red. Los componentes desarrollados bajo esta tecnología se denominan ActiveX. Su fundamento es tratar de hacer que estos componentes sean reutilizables. Cada componente (objeto) se caracteriza por un comportamiento, que se puede alterar a través de sus métodos, propiedades o la interacción con otros objetos.

5.2 Crear un componente Active X. Los controles ActiveX son pequeñas aplicaciones capaces de interactuar con el usuario, realizar cálculos o representar datos, y que se insertan en páginas web a través de las etiquetas <OBJECT> y <PARAM>, que se corresponden a las operaciones de inserción del componente y paso de sus parámetros de ejecución. Diferencia entre controles y componentes ActiveX Los elementos desarrollados con esta tecnología pueden aplicarse tanto en el lado cliente como en el lado servidor. Esta es la diferencia fundamental entre un control ActiveX, que se ejecuta localmente en nuestra aplicación, de un objeto ActiveX, que utiliza un "automation interface" (o interfaz automatizada) para que otras aplicaciones o herramientas de programación puedan utilizarlo. Se denomina formalmente componente al objeto ActiveX y no al control. Un componente tiene la ventaja de que se trata de un estándar prácticamente universal, multiplataforma y, por tanto, independiente de las aplicaciones y sus lenguajes. Los controles se encuentran en clara desventaja frente a las posibilidades que nos ofrecen los objetos de servidor (componentes), al poder combinarse, a través de ASP, con scripts y páginas HTML para poder crear webs profesionales. Su funcionamiento precisa la instalación del objeto en la máquina sobre la que se ejecute, y suele encontrarse bajo archivos de extensión OCX o DLL.



Para poder utilizar un componente, deberá enlazarlo con su página web a través de programación en un lenguaje de script, directamente, o a través del uso de ASP (Active Server Pages). En cualquiera de los casos, deberá introducir cierto código para poder usar el componente, una vez instalado en el servidor sobre el que vaya a ejecutarse. Se trata, principalmente de una línea en la que crea una "instancia" del objeto (componente) que va a usar, y el resto de código que utiliza los métodos y propiedades de la instancia que acaba de crear. Por ejemplo, si escribimos en una página ASP, el código debe quedar de la forma:

<% Set OBJETO = Server.CreateObject(IDENTIFICADOR) OBJETO.Metodo(Argumentos) ....... %>

El parámetro "IDENTIFICADOR" es un identificador único del componente. Los valores "OBJETO.Metodo(Argumentos)" referencian a las funciones, y parámetros que necesitan las mismas para su llamada, que incorpora el componente que estamos usando. Por ejemplo, el componente Acceso a bases de datos utiliza objetos de datos de ActiveX (ADO) para proporcionar un fácil acceso a la información almacenada en una base de datos (o en otra estructura de datos en forma de tabla), que cumpla con el estándar ODBC (Open DataBase Connectivity). A continuación se muestra el código que tendría que colocar en su página ASP para poder usar este objeto: <% 'Aquí creamos la instancia del objeto Set miconexion = Server.CreateObject("ADODB.Connection") 'Ahora usamos la instancia y sus propiedades para nuestros fines 'Indicamos al objeto la cadena de conexión miconexion.ConnectionString = "DSN=midsn" 'Se abre la base de datos miconexion.Open ' ....... '........ 'Se cierra la base de datos miconexion.Close %> Crear un componente



Si tiene algo de experiencia en programación de aplicaciones, puede que le resulte interesante desarrollar sus propios objetos para temas específicos. Los componentes ActiveX pueden ser creados con las herramientas tradicionales de desarrollo (que soporten automatización). Entre las más conocidas están el Visual C++ (en particular MFC ActiveX ControlWizard) y Borland C++ respectivamente. Sin embargo, tal vez le resulte más sencillo el uso de otros como Visual Basic o Delphi. El enlace natural de estos componentes con las páginas HTML se realiza mediante scripts. Por ello, una vez creado el componente, podrá enlazarlo en su web directamente a través de scripts o con el uso de páginas ASP. Dado que la diferencia entre un control y un componente ActiveX radica en qué lugar se ejecuta (Cliente o servidor) ejemplificaré la creación de un objeto de este tipo en el apartado siguiente. Encontrar Componentes ActiveX Si busca por Internet encontrará numerosos componentes para muchisimas utilidades. Aunque no todos los encontrará de manera gratuita (algunos son comerciales), podrá obtener versiones de prueba con las que podrá decidir si le interesa o no adquirir una licencia para su uso. Puede visitar el siguiente sitio web donde encontrará información y algunos componentes: http://www.activex.org/

5.3 Crear un Control Active X. ActiveX está compuesto por dos tipos de objetos: controles Activos (Active controls) y documentos Activos (Active documents). Estos últimos permiten insertar documentos con formato PDF, DOC, etc. Cada objeto tiene suficiente información para ejecutarse él mismo sin ayuda de ninguna aplicación. Podemos crear nuestros propios controles o usar los creados por otros programadores que nos los venden o distribuyen gratuitamente. Si optamos por programarlos nosotros mismos existen herramientas que lo convierten prácticamente en un juego de niños, entre ellas destaca las creadas para este fin por Microsoft y que distribuye a través de su Web (www.microsoft.com/ie/). Hoy por hoy el único inconveniente de la tecnología ActiveX consiste en que sólo puede ser visto desde el sistema operativo Windows y con el Navegador Internet Explorer, aunque afortunadamente parece que esto cambiará pronto. Creando un control ActiveX (OCX)19

19 OCX hace referencia a módulos que publican controles y funciones para ser utilizados en programas para Windows, incluyendo especialmente el navegador.



Se pueden crear distintos tipos de controles activeX, lo único que requiere, es decidir si quiere hacer un control como el de un formulario, un ejecutable, algo que pueda cargar en una página web, etc. Al crear un proyecto nuevo en Visual Basic tendrá que elegir cual desea desarrollar. Para el siguiente ejemplo, y con el fin de que no se piense que los controles ActiveX son solo para temas relacionados con el internet, haremos un ejecutable que se encargue de apagar nuestra computadora.

Figura 5.1 Tipos de proyectos en Visual Basic.

Para crear un control OCX, siga los siguientes pasos en el Visual Basic. NOTA IMPORTANTE: En esta ocasión no se señalará punto a punto y por medio de imágenes dónde se localiza cada opción dentro de la interfaz gráfica de Visual Basic, solo las que podría tener dificultad en localizar. Sin embargo, está en muy intuitiva y no tendrá problema en seguir el procedimiento que se describe a continuación. 1. Abrir Visual Basic y crear un proyecto "EXE Estándar" (Standard EXE) y le vamos a agregar otro proyecto de tipo "Control ActiveX". De tal forma que nos queden los dos proyectos como si fuera uno. El control que crearemos será uno que nos permita apagar Windows, reiniciarlo, etc. 2. Seleccionamos la propiedad "InvisibleAtRunTime" y la ponemos en true, ya que nuestro control no será visible durante la ejecución del proyecto en el que se encuentre.



Figura 5.2 Propiedades del proyecto.

Como puede observar, nuestro control es como un form normal, pero sin bordes, ahora inserte un objeto image (Image1, se encuentran del lado izquierdo de la pantalla, pase el puntero por encima para que se muestre el nombre de cada objeto) y ponga como picture un icono que te parezca representativo de lo que va a hacer nuestro control. O alguna imagen que tenga a la mano para realizar la prueba. 3. En el evento "Resize" del UserControl pon lo siguiente... (Para ver los eventos debe dar doble clic sobre el objeto que desee y a continuación seleccionar el evento de una lista disponible).

Private Sub UserControl_Resize() Image1.Top = 0 Image1.Left = 0 UserControl.Height = Image1.Height UserControl.Width = Image1.Width End Sub

Esto hará que el control se vea en el formulario como si fuera solo el icono de la imagen.



Figura 5.3 Evento Resize del control ActiveX.

4. Ahora debemos crear los Métodos del control, para eso vaya al menú "Complementos" (Add-Ins), de ahí a "Administrador de Complementos" (Add-In Manager) y haga doble clic sobre "Asistente para interfaz de controles ActiveX de VB" (VB 6 ActiveX Ctrl Interface Wizard) seleccione la casilla “Cargado/No Cargado” (Loaded/Unloaded) y pulse "Aceptar".

Figura 5.4 Ventana para activar el asistente de configuración de controles ActiveX.

El "Asistente para interfaz de controles ActiveX de VB" es un asistente que nos guiará paso a paso en la asignación de métodos para nuestro control. Otra vez vaya a "Complementos", allí aparecerá una nueva opción, que es el asistente. Ábralo y pulse "Siguiente". En el cuadro "Nombres Disponibles" (Available



names) tiene todos los métodos más comunes que puede insertar, en "Nombres Seleccionados" (Selected names) no deje nada y pulse "Siguiente". En esta nueva ventana podemos definir métodos personalizados.

Figura 5.5 Ventana: Seleccionar miembros de la interfaz.

De clic en "Nuevo" y crea estos métodos...

1. "Mensaje_Apagar"

2. "Cerrar_Sesion"

3. "Apagar_Sistema"

4. "Reiniciar_Sistema"

5. "Forzar_Apagado"

Figura 5.6 Ventana: Agregar miembros personalizados.



No olvide de poner a cada uno como "Método" (Method) en el cuadro "Tipo" (Type). De Clic a "Siguiente", en el cuadro siguiente no hacemos nada, así que "Siguiente" de nuevo.

Figura 5.7 Ventana Crear miembros personalizaos de la interfaz.

El cuadro que nos salteamos nos permite decir a cuál de los componentes insertados en nuestro control corresponden los métodos que tengamos puestos (de los que aparecían en "Nombres Disponibles") ya que hay métodos que lo tienen más de uno de los controles insertados y esto se presta a confusiones. En la ventana actual, podemos agregar una descripción a cada cosa y designar que valor retorna una función. Ponga una descripción a cada método lo desea, aunque los nombres son bastante descriptivos. No cambien nada en lo de "Tipo Devuelto". Denle a "Siguiente" y a "Finalizar".

Figura 5.8 Ventana Establecer atributos de los miembros.



5. Vamos al código de control. Tenemos que declarar las APIs20 que realizaran las operaciones necesarias: (si no está familiarizado con la interfaz puede perderse en este punto, el código siguiente debe ser insertado en la parte de las declaraciones del código de nuestro control.) Con esto se nos permitirá mostrar el dialogo de "Apagar el Sistema": Private Declare Function SHShutDownDialog Lib "shell32" Alias "#60" (ByVal YourGuess As Long) As Long

Con el siguiente código se ejecutaran las demás operaciones: Private Declare Function ExitWindowsEx Lib "user32" (ByVal uFlags As Long, ByVal dwReserved As Long) As Long Const EWX_LOGOFF = 0 Const EWX_SHUTDOWN = 1 Const EWX_REBOOT = 2 Const EWX_FORCE = 4

Una vez que tenemos las declaraciones, tenemos las siguientes funciones (Se pueden ver en la parte baja del código): Public Function Dialogo_Apagar() As Variant End Function Y así para las demás funciones. Ahora debemos poner las llamadas a las APIs dentro de cada función... Public Function Dialogo_Apagar() As Variant SHShutDownDialog 0 End Function Public Function Cerrar_Sesion() As Variant ExitWindowsEx EWX_LOGOFF, 0 End Function Public Function Apagar_Sistema() As Variant ExitWindowsEx EWX_SHUTDOWN, 0 End Function

20 Del inglés Application Programming Interface - Interfaz de Programación de Aplicaciones



Public Function Reiniciar_Sistema() As Variant ExitWindowsEx EWX_REBOOT, 0 End Function Public Function Forzar_Apagado() As Variant ExitWindowsEx EWX_FORCE, 0 End Function No elimine los comentarios ni el resto del código que haya generado automáticamente Visual Basic. Casi hemos terminado. De clic a guardar y pase al formulario del proyecto ejecutable… (O sea, el otro, que no hemos tocado, pulse CTRL+F4 para cerrar la ventana del formulario del control ActiveX). El último icono que aparece en la barra de la izquierda es el de nuestro control, dibújelo en el formulario de nuestro proyecto ejecutable (aparecerá el ícono que le asignamos”) y vaya a la ventana de código del formulario (En este punto, nuestro control apareció en el panel izquierdo, con el nombre de “UserControl1”, es decir, hemos creado un control personalizado ActiveX, a partir de este punto se pretende implementarlo). Escriba "UserControl11" y ponga un punto para ver los métodos del control, aparecen los nuestros mas algunos que VB pone por defecto.

Figura 5.9 Utilización de nuestro control.

Control

Nuevo

Objeto insertado al formulario

(Elija una imagen pequeña) Esa

imagen es de la empresa en la que

laboro y es marca registrada Así que

cuidado con eso =)

Ventana del código del

formulario y métodos de

nuestro control.



Por último, ponga la propiedad "CanGetFocus" a False (nuestro control no obtiene el foco porque es invisible). En Paint u otro programa para manejo de imágenes cree un BMP de 16 x 15 pixeles. Coloque esa imagen en "ToolBoxBitmap", ese es el icono que aparecerá en la barra de la izquierda (la barra de herramientas), en lugar del icono por defecto. Asigne un nombre en la propiedad "Nombre", de modo que cuando dibuje su control en un formulario, el nombre por default del objeto será “nombre_objeto_1”, “nombre_objeto_2”, etc. Ejercicio: Vaya al Form1, borre el que control que pusimos anteriormente y el código que en el que creamos el objeto (si escribió algo) e inserte uno nuevo. Ponga en el form varios botones (uno que llame a cada función del control). Guarde todo y pruébelo (recuerde que apagara su computadora así que tenga cuidado). Compile el control, elija el proyecto y vaya al menú "Archivo" y a "Generar Nombre_quepuso.OCX". Elija donde desea guardarlo, asigne un nombre (Si se llama Apagar_Equipo, puede ponerle Apagar_Equipo.OCX). Vaya a "Opciones" y agregue la información que desee. Esto último es solo con el fin de poner su nombre o lo que guste a su control... no afecta su funcionamiento.) Inserción de un control ActiveX El código HTML que se necesita para insertar un control o documento ActiveX en una página Web fue desarrollado por Microsoft, con lo que se acordó el uso del estándar OBJECT. A continuación veremos un sencillo ejemplo que no requiere ningún archivo especial, el único requisito para poder visualizarlo consistirá en tener instalado el navegador Internet Explorer 3.0 o superior, en este caso se utilizó Internet Explorer 7.0. El código usado para insertar el control ActiveX será: <OBJECT WIDTH=250 HEIGHT=340 CLASSID="clsid:99B42120-6EC7-11CF-A6C7-00AA00A47DD2"> <PARAM NAME="alignment" VALUE="2"> <PARAM NAME="BackStyle" VALUE="3"> <PARAM NAME="caption" VALUE="Programación II"> <PARAM NAME="FontName" VALUE="Arial"> <PARAM NAME="FontSize" VALUE="30"> <PARAM NAME="FontBold" VALUE="1"> <PARAM NAME="Backcolor" VALUE="#006600"> <PARAM NAME="Forecolor" VALUE="#FFFFFF"> Para visualizar el control ActiveX necesita Explorer 3.0 o posterior. </OBJECT>

En la figura 5.1 podemos ver el resultado obtenido tal y como se ve con Internet Explorer 7.0. Pasemos a explicar el este código: El valor del atributo CLASSID es el que identifica el tipo de control ActiveX que estamos insertando. Este código es complejo y se sale de los objetivos de esta obra.



Figura 5.10 Objeto ActiveX

Usando este control ActiveX podemos crear efectos variados con texto… Entre los principales parámetros usados en la inserción de este control ActiveX encontramos: Caption: Es el texto que debe insertarse con las características que se indican con el resto de parámetros. Angle: Es el ángulo del texto con la horizontal en grados. Si le damos el valor 90 el control mostrará el texto en vertical. FontSize: Es el tamaño del texto. FontName: Es el tipo de letra. Backcolor y Forecolor: Son el color del fondo y el color del texto respectivamente. Ejercicio: Hacer pruebas modificando los valores de estos y el resto de los atributos para adaptarlo a nuestras necesidades y poder incorporarlo en sus propias páginas. EJERCICIOS PROPUESTOS



5.1 ¿Qué es un control modelo de componentes? 5.2 ¿Qué es un control ActiveX? ¿Para qué sirve? 5.3 ¿Qué es un componente ActiveX? ¿Para qué sirven? 5.4 ¿Cuál es la diferencia entre un control y un componente? 5.5 ¿Qué herramientas se pueden utilizar para crear componentes y controles ActiveX? ¿Por qué? 5.6 ¿Cuáles son las ventajas y desventajas principales de los componentes ActiveX? 5.7 ¿Qué herramientas existen para crear elementos equivalentes a los controles y componentes ActiveX? 5.8 Realice una investigación para determinar cuál es la tecnología equivalente a los controles y componentes ActiveX para el lenguaje Java. 5.9 Investigue qué tipos de controles y componentes ActiveX pueden ser programados en Visual Basic. 5.10 ¿Por qué a pesar de ser una herramienta tan útil, ActiveX es una herramienta que se utiliza poco a comparación de otras herramientas disponibles? PROYECTO INTEGRAL. Proyecto 1: Crear tu propio componente o control ActiveX. No importa que funcionalidad le de. Utilice Visual Basic para crear un objeto personalizado y posteriormente utilícelo en alguna aplicación de escritorio o Web. Recuerde: Visual Basic es una de las herramientas que permiten crear este tipo de objetos de una manera sencilla. Después de crearlo, deberá probarlo y utilizarlo. Proyecto 2: Desarrolle una investigación detallada acerca de Java Beans y desarrolle un ejemplo sencillo que realice cualquier función equivalente a la de los controles ActiveX.

ITM Apéndice 1 “Instalación de NetBeans”


Apéndice 1 Instalación de NetBeans A continuación se darán las instrucciones de como instalar NetBeans IDE en cada una de las plataformas soportadas. Recuerde que el JDK21 de java ya debe estar instalado en el sistema. Hay dos versiones de NetBeans, una normal y una que incluye ya los paquetes, sin embargo la instalación no tiene dificultad alguna. (Es del tipo accept, next, next, finish.) Instalación en Windows XP o Vista

1. Bajar e instalar el JDK de internet, una de las paginas que lo tiene es: http://java.sun.com/javase/downloads/index.jsp

2. Después de haber bajado el instalador, dar doble clic sobre el icono para iniciar el instalador.

3. Después aparecerá el Acuerdo de Licenciamiento (License Agreement), acéptelo y de clic en Siguiente (Next).

4. Especificar un directorio vacío donde instalar Netbeans IDE. Dar clic en Siguiente (Next).

5. Selecciones el JDK que se quiere usar junto con el NetBeans IDE de la lista de selección si hay más de uno. Dar clic en Siguiente (Next). (si ya tiene instalada una versión no le pregunta)

6. Verifique que el directorio de instalación es el correcto y que se cuenta con espacio suficiente en el sistema para la instalación.

7. De clic en Siguiente (Next) para iniciar la instalación.

Instalación en Linux (Este proceso se probó en Ubuntu 8.1 Intrepid Ibex)

1. Abrir una consola de comandos y ejecutar el comando “sudo su”, después de ingresar la contraseña adecuada podrá ejecutar el siguiente comando.

2. $sudo apt-get install netbeans. Con esto se nos listas los paquetes que se instalarán, el espacio requerido, etc. Y al final se nos preguntará si se desea proceder.

3. ¿Desea continuar [S/n]? 4. Una vez que selecciona continuar, la instalación se crea sin ningún

problema y la aplicación se agrega a la lista de aplicaciones de Ubuntu. Nota: Los pasos pueden ser diferentes dependiendo de la distribución que tenga. Ejecutar NetBeans IDE A continuación se explicará la forma de ejecutar NetBeans IDE en los diferentes sistemas operativos. Ejecutar en Windows XP o Vista 21 Java Development Kit. Kit de desarrollo de Java. Necesario para trabajar con dicho lenguaje.



Para ejecutar el IDE en Máquinas con Microsoft Windows hacer lo siguiente:

• Dar Doble clic en el icono de NetBeans IDE en el escritorio. • Desde el Menú Inicio, seleccionar NetBeans IDE > NetBeans IDE

Ejecutar en Linux (Ubuntu 8.1 Intrepid Ibex)

• Dar Doble clic en el icono de NetBeans IDE en el escritorio. • Buscar el ícono de la aplicación en el listado de aplicaciones y dar clic

sobre el mismo. Desinstalar NetBeans IDE A continuación se mostrará como desinstalar NetBeans IDE en los diferentes sistemas operativos. Desinstalar en Windows XP o Vista

1. Desde el Menú Inicio, escoger Panel de Control. 2. Dar doble clic en el icono de “Agregar o Quitar Programas”. 3. Seleccionar NetBeans IDE de la lista y dar clic en “Remover”.

Desinstalar en Linux (Ubuntu 8.1 Intrepid Ibex)

1. Entre a una consola de comandos y ejecute el comando sudo para poder ejecutar algunos comandos con permisos de root.

2. Ejecute $sudo apt-get remove netbeans.

Instalación de Eclipse en (Ubuntu 8.1 Intrepid Ibex)

1. Abrir una consola de comandos y ejecutar el comando “sudo su”, después de ingresar la contraseña adecuada podrá ejecutar el siguiente comando.

2. $sudo apt-get install eclipse. Con esto se nos listas los paquetes que se instalarán, el espacio requerido, etc. Y al final se nos preguntará si se desea proceder.

3. ¿Desea continuar [S/n]? 4. Una vez que selecciona continuar, la instalación se crea sin ningún

problema y la aplicación se agrega a la lista de aplicaciones de Ubuntu. 5. Para ejecutar la aplicación o desinstalarla siga la misma lógica que se

aplicó al instalar NetBeans.

Instalación de JCreator en Windows XP o Vista



1. La instalación es muy sencilla independientemente de la versión, sobre todo hablando de instalar aplicaciones en Windows. Primero localice el archivo instalador y de doble clic. Presione “Next” y luego acepte la licencia y presione “Next” nuevamente

2. Seleccione el directorio donde desea que se instale la aplicación y presione “Next”.

3. Seleccione sonde desea que se coloquen accesos directos y presione “Next”.

4. Finalmente presione “Install” y termine la instalación con “Finish”

ITM Apéndice 2 “Introducción a MySQL”


Apéndice 2

Introducción a MySQL

MySQL es un gestor de base de datos sencillo de usar, es uno de los motores de base de datos más usados en Internet, la principal razón de esto es que es Open Source.

En este apéndice se pretende mostrar el uso del programa cliente mysql para crear y usar una sencilla base de datos, se analizara solo lo necesario para llevar a cabo un ejercicio como el que se presenta en el material.

Mysql es un programa interactivo que permite conectarnos a un servidor MySQL, ejecutar algunas consultas, y ver los resultados.

Supongamos que mysql está instalado en alguna máquina y que disponemos de un servidor MySQL al cual podemos conectarnos (Tal como lo deja AppServ). Para ver la lista de opciones proporcionadas por mysql, lo invocamos con la opción --help:

> mysql --help

A continuación se describe el proceso completo de creación y uso de una base de datos en MySQL. Puesto que es imposible que se describan a detalle muchos de los temas relacionados con la funcionalidad total de MySQL, se recomienda que se consulte el manual de MySQL para obtener más información al respecto.

Conectar al servidor MySQL

Para conectarse al servidor, usualmente necesitamos de un nombre de usuario (login) y de una contraseña (password), y si el servidor al que nos deseamos conectar está en una máquina diferente de la nuestra, también necesitamos indicar el nombre o la dirección IP de dicho servidor. Una vez que conocemos estos tres valores, podemos conectarnos de la siguiente manera:

> mysql -h NombreDelServidor -u NombreDeUsuario -p

Cuando ejecutamos este comando, se nos pedirá que proporcionemos también la contraseña para el nombre de usuario que estamos usando.

Si la conexión al servidor MySQL se pudo establecer de manera satisfactoria, recibiremos el mensaje de bienvenida y estaremos en el prompt de mysql:



>mysql -h root -u algo -p Enter password: ****** Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 5563 to server version: 3.23.41 Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql>

Esto nos indica que mysql está listo para recibir comandos.

Después de que nos hemos conectado de manera satisfactoria, podemos desconectarnos en cualquier momento al escribir "quit", "exit", o presionar CONTROL+D.

La mayoría de los ejemplos siguientes asume que estamos conectados al servidor, lo cual se indica con mysql>.

Sintaxis MySQL

En este momento debimos de haber podido conectarnos ya al servidor MySQL, aún cuando no hemos seleccionado alguna base de datos para trabajar. Lo que haremos a continuación es escribir algunos comandos para irnos familiarizando con el funcionamiento de mysql.

• Un comando normalmente consiste de una sentencia SQL seguida por un punto y coma.

• Cuando emitimos un comando, mysql lo manda al servidor para que lo ejecute, nos muestra los resultados y queda listo para recibir más consultas.

• mysql muestra los resultados de la consulta como una tabla (filas y columnas). La primera fila contiene etiquetas para las columnas. Las filas siguientes muestran los resultados de la consulta. Normalmente las etiquetas de las columnas son los nombres de los campos de las tablas que estamos usando en alguna consulta.

• mysql muestra cuántas filas fueron regresadas y cuanto tiempo tardó en ejecutarse la consulta, lo cual puede darnos una idea de la eficiencia del servidor, aunque estos valores pueden ser un tanto imprecisos ya que no se muestra la hora del CPU, y porque pueden verse afectados por otros factores, tales como la carga del servidor y la velocidad de comunicación en una red.

• Las palabras clave pueden ser escritas usando mayúsculas y minúsculas.



Las siguientes consultas son equivalentes:

mysql> SELECT VERSION(), CURRENT_DATE; mysql> select version(), current_date; mysql> SeLeCt vErSiOn(), current_DATE;

Es posible escribir más de una sentencia por línea, siempre y cuando estén separadas por punto y coma:

mysql> SELECT VERSION(); SELECT NOW();

Sintaxis MySQL

Un comando no necesita ser escrito en una sola línea, así que los comandos que requieran de varias líneas no son un problema. mysql determinará en dónde finaliza la sentencia cuando encuentre el punto y coma, no cuando encuentre el fin de línea.

Aquí está un ejemplo que muestra una consulta simple escrita en varias líneas:

mysql> SELECT -> USER(), -> CURRENT_DATE; +-------------------+--------------+ | USER() | CURRENT_DATE | +-------------------+--------------+ | root@localhost | 2008-12-24 | +-------------------+--------------+ 1 row in set (0.00 sec) mysql>

En este ejemplo debe notarse como cambia el texto (de mysql> a ->, a ese texto se le conoce como propmt.) cuando se escribe una consulta en varias líneas. Esta es la manera en cómo mysql indica que está esperando a que finalice la consulta. Sin embargo si deseamos no terminar de escribir la consulta, podemos hacerlo al escribir \c como se muestra en el siguiente ejemplo:

mysql> SELECT -> USER(), -> \c mysql>



Está listo para una nueva consulta.

Los comandos multi-línea comúnmente ocurren por accidente cuando tecleamos ENTER, pero olvidamos escribir el punto y coma. En este caso mysql se queda esperando para que finalicemos la consulta:

mysql> SELECT USER() ->

Si esto llega a suceder, muy probablemente mysql estará esperando por un punto y coma, si escribimos el punto y coma podremos completar la consulta y mysql podrá ejecutarla:

mysql> SELECT USER() -> ; +----------------+ | USER() | +----------------+ | root@localhost | +----------------+ 1 row in set (0.00 sec) mysql>

Los prompts '> y "> ocurren durante la escritura de cadenas. En mysql podemos escribir cadenas utilizando comillas sencillas o comillas dobles (por ejemplo, 'hola' y "hola"), y mysql nos permite escribir cadenas que ocupen múltiples líneas. De manera que cuando veamos el prompt '> o ">, mysql nos indica que hemos empezado a escribir una cadena, pero no la hemos finalizado con la comilla correspondiente.

Aunque esto puede suceder si estamos escribiendo una cadena muy grande, es más frecuente que obtengamos alguno de estos prompts si inadvertidamente escribimos alguna de estas comillas.

Por ejemplo:

mysql> SELECT * FROM mi_tabla WHERE nombre = "Tecnológico AND edad < 30; ">

Si escribimos esta consulta SELECT y entonces presionamos ENTER para ver el resultado, no sucederá nada. En lugar de preocuparnos porque la consulta ha tomado mucho tiempo, debemos notar la pista que nos da mysql cambiando el prompt. Esto nos indica que mysql está esperando que finalicemos la cadena iniciada ("Tecnológico).



En este caso, lo más simple es cancelar la consulta. Sin embargo, no basta con escribir \c, ya que mysql interpreta esto como parte de la cadena que estamos escribiendo. En lugar de esto, debemos escribir antes la comilla correspondiente y después \c :

mysql> SELECT * FROM mi_tabla WHERE nombre = "Tecnológico AND edad < 30; "> " \c mysql>

El prompt cambiará de nuevo al ya conocido mysql>, indicándonos que mysql está listo para una nueva consulta.

Es sumamente importante conocer lo que significan los prompts '> y ">, ya que si en algún momento nos aparece alguno de ellos, todas la líneas que escribamos a continuación serán consideradas como parte de la cadena, inclusive cuando escribimos QUIT. Esto puede ser confuso, especialmente si no sabemos que es necesario escribir la comilla correspondiente para finalizar la cadena, para que podamos escribir después algún otro comando, o terminar la consulta que deseamos ejecutar.

Usar una base de datos

Ahora que conocemos como escribir y ejecutar sentencias, es tiempo de acceder a una base de datos.

Crearemos la misma base de datos y las tablas que se crean en el materia de esta materia utilizando “phpMyadmin” así podrá realizar una comparación entre utilizar la línea de comandos o alguna aplicación gráfica que le permita administrar su servidor mySQL.

La base de datos "Negocio" será muy simple (deliberadamente), pero no es difícil pensar de situaciones del mundo real en la cual una base de datos similar puede ser usada.

Primeramente usaremos la sentencia SHOW para ver cuáles son las bases de datos existentes en el servidor al que estamos conectados:

mysql> SHOW DATABASES; +----------+ | Database | +----------+ | mysql | | test | +----------+ 2 rows in set (0.00 sec) mysql>



Es probable que la lista de bases de datos que veamos sea diferente en nuestro caso, pero seguramente las bases de datos "mysql" y "test" estarán entre ellas. En particular, la base de datos "mysql" es requerida, ya que ésta tiene la información de los privilegios de los usuarios de MySQL. La base de datos "test" es creada durante la instalación de MySQL con el propósito de servir como área de trabajo para los usuarios que inician en el aprendizaje de MySQL, como puede recordar, cuando comenzamos a trabajar con phpMyadmin utilizamos la base de datos “test”.

Es posible que no veamos todas las bases de datos si no tenemos el privilegio SHOW DATABASES. Se recomienda revisar la sección del manual de MySQL dedicada a los comandos GRANT y REVOKE.

Si la base de datos "test" existe, hay que intentar accesar a ella:

mysql> USE test Database changed mysql>

Observe que USE, al igual que QUIT, no requieren el uso del punto y coma, aunque si se usa no hay ningún problema. El comando USE es especial también de otra manera: éste debe ser usado en una sola línea.

Crear una base de datos

Intentaremos acceder a la base de datos, si no ha sido creada deberemos hacerlo nosotros mismos.

mysql> USE Negocio ERROR 1049: Unknown database 'Negocio' mysql>

El mensaje anterior indica que la base de datos no ha sido creada, por lo tanto necesitamos crearla.

mysql> CREATE DATABASE Negocio; Query OK, 1 row affected (0.00 sec) mysql> USE Negocio Database changed mysql>



Al crear una base de datos no se selecciona ésta de manera automática; debemos hacerlo de manera explícita, por ello usamos el comando USE en el ejemplo anterior.

La base de datos se crea sólo una vez, pero nosotros debemos seleccionarla cada vez que iniciamos una sesión con mysql. Por ello es recomendable que se indique la base de datos sobre la que vamos a trabajar al momento de invocar al monitor de MySQL. Por ejemplo:

>mysql -h parametro1 -u usuario -p Negocio Enter password: ****** Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 17 to server version: 3.23.38-nt Type 'help;' or '\h' for help. Type '\c' to clear the buffer mysql>

Observe que "Negocio" no es la contraseña que se está proporcionando desde la línea de comandos, sino el nombre de la base de datos a la que deseamos acceder. Si deseamos proporcionar la contraseña en la línea de comandos después de la opción "-p", debemos de hacerlo sin dejar espacios (por ejemplo, -phola123, no como -p hola123). Sin embargo, escribir nuestra contraseña desde la línea de comandos no es recomendado, ya que es bastante inseguro.

Crear tabla

Crear la base de datos es la parte más fácil, pero en este momento la base de datos está vacía, como lo indica el comando SHOW TABLES:

mysql> SHOW TABLES; Empty set (0.00 sec)

La parte un tanto complicada es decidir la estructura que debe tener nuestra base de datos: qué tablas se necesitan y qué columnas estarán en cada tabla.

En principio, Contendrá las tablas Clientes, Productos y Empleados.

Los campos serán: para Clientes (Id, nombre, dirección), para Productos (Id, nombre y precio) y para empleados (Id, nombre, salario).



Usaremos la sentencia CREATE TABLE para indicar como estarán conformados los registros de nuestros clientes.

mysql> CREATE TABLE Clientes( -> id INT, nombre VARCHAR(60), -> direccion VARCHAR(120); Query OK, 0 rows affected (0.02 sec) mysql>

Lleve a cabo el mismo procedimiento para las tres tablas. Consulte el manual de MySQL para saber más acerca de los tipos de datos que se utilizan, sus longitudes y la manera adecuada de asignarlos a campos dentro de una tabla.

Ahora que hemos creado la tabla, la sentencia SHOW TABLES debe producir algo como:

mysql> SHOW TABLES; +---------------------+ | Tables_in_Negocio | +---------------------+ | clientes | | productos | empleados | +---------------------+ 3 row in set (0.00 sec) mysql>

Para verificar que la tabla fue creada como nosotros esperábamos, usaremos la sentencia DESCRIBE:

mysql> DESCRIBE clientes; +--------------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +--------------+-------------+------+-----+---------+-------+ | id | INT | NO | | NULL | | | nombre | varchar(60) |NO| | NULL | | | direccion| varchar(120)|NO| | NULL | | +--------------+-------------+------+-----+---------+-------+ 3 rows in set (0.01 sec) mysql>



Podemos hacer uso de la sentencia DESCRIBE en cualquier momento, por ejemplo, si olvidamos los nombres ó el tipo de las columnas en alguna tabla.

Cargar datos en una tabla

Después de haber creado la tabla, ahora podemos incorporar algunos datos en ella, para lo cual haremos uso de la sentencia INSERT.

En la manera más simple, debemos proporcionar un valor para cada columna en el orden en el cual fueron listados en la sentencia CREATE TABLE.

mysql> INSERT INTO clientes -> VALUES('1', 'Saul Chavez', 'Constelaciones 99');

Recuperar información de una tabla

La sentencia SELECT es usada para obtener la información guardada en una tabla. La forma general de esta sentencia es:

SELECT LaInformaciónQueDeseamos FROM DeQueTabla WHERE CondiciónASatisfacer

Aquí, LaInformaciónQueDeseamos es la información que queremos ver. Esta puede ser una lista de columnas, o un * para indicar "todas las columnas". DeQueTabla indica el nombre de la tabla de la cual vamos a obtener los datos. La clausula WHERE es opcional. Si está presente, la CondiciónASatisfacer especifica las condiciones que los registros deben satisfacer para que puedan ser mostrados.

Seleccionando todos los datos

La manera más simple de la sentencia SELECT es cuando se recuperan todos los datos de una tabla:

mysql> SELECT * FROM clientes; +---+-----------------+--------------------------+ | id | nombre | dirección | +---+-----------------+--------------------------+ | 1 | Saul Chavez | Constelaciones 99 | +---+------------------+-------------------------+ 1 rows in set (0.00 sec)

Esta forma del SELECT es útil si deseamos ver los datos completos de la tabla.

Para eliminar “todos” los datos de una tabla usamos la sentencia DELETE.

mysql> DELETE FROM clientes;



Para llevar a cabo una modificación, utilizamos una sentencia UPDATE:

mysql> UPDATE clientes SET nombre="Saul Hernandez de caifanes" WHERE nombre="Saul Chavez";

Como se mostró anteriormente, es muy fácil recuperar los datos de una tabla completa. Pero típicamente no deseamos hacer esto, particularmente cuando las tablas son demasiado grandes..

Seleccionar registros particulares

Podemos seleccionar sólo registros particulares de una tabla. Por ejemplo, si deseamos verificar el cambio que hicimos al nombre de Saul Chavez, seleccionamos sólo el registro de Saul Hernandez de caifanes de la siguiente manera:

mysql> SELECT * FROM clientes WHERE id="1"; +---+-----------------+--------------------------+ | id | nombre | dirección | +---+-----------------+--------------------------+ | 1 | Saul Hernandez de caifanes | Constelaciones 99| +---+------------------+-------------------------+

1 rows in set (0.00 sec)

La salida mostrada confirma que el nombre ha sido modificado de Saul Chavez a Saul Hernandez de caifanes.

La comparación de cadenas es normalmente no sensitiva, así que podemos especificar el nombre como "Saul Chavez", "saul chavez", etc. El resultado de la consulta será el mismo.

Podemos además especificar condiciones sobre cualquier columna, no sólo el "id", como el nombre o la dirección. O incluso utilizar el operador lógico AND u OR para especificar más condiciones:

mysql> SELECT * FROM clientes WHERE id = "1" OR Nombre = "Saul Chavez";

Si tenemos una mayor cantidad de operadores AND u OR y queremos determinar el orden en que se deben agrupar las condiciones, es buena idea usar paréntesis.

Seleccionar columnas particulares

Si no deseamos ver los registros completos de una tabla, entonces tenemos que usar los nombres de las columnas en las que estamos interesados separándolas por coma.



Por ejemplo, si deseamos conocer solo la dirección, debemos seleccionar la columna "direccion" únicamente:

mysql> SELECT direccion FROM clientes; +-------------------------+ | dirección | +-------------------------+ | Constelaciones 99| +-------------------------+ 1 rows in set (0.00 sec)

La extracción de información de una base de datos puede ser tan específica como lo requiera el usuario y hay muchas palabras claves que facilitan el filtrado, ordenamiento u otra acción a realizar en los registros resultantes de una consulta. Para conocer a profundidad la creación de sentencias por favor consulte el manual de mySQL ya que este material es meramente introductorio.

ITM


Conclusiones

En este material se han conseguido los objetivos propuestos:

Elaborar el material didáctico para la asignatura de Programación II y proporcionar los conocimientos teórico – prácticos a los estudiantes, quienes aplicarán los conocimientos en un lenguaje de programación orientado a eventos, para resolver problemas dentro de los procesos administrativos.

Desarrollar material que lleve de la mano al alumno y sea una herramienta útil para el profesor, con explicaciones sencillas.

Respetar el temario indicado y desarrollarlo utilizando el lenguaje Java y analizar herramientas alternativas relacionadas con Java para temas que no tienen relación con dicho lenguaje.

Apoyar sustancialmente al profesor y alumno de la asignatura de Programación II, ofreciendo al alumno una buena referencia de la cual extraer información, tomar ejemplos, realizar ejercicios, etc. durante el estudio de esta asignatura. A los profesores de la misma, les podrá funcionar como apoyo y guía durante el desarrollo de los temas. Así mismo, apoya a sostener el programa de acreditación de la carrera de la Licenciatura en Informática.

Este material fue desarrollado de manera tal, que se facilite el aprendizaje y que este sea además progresivo y la dificultad vaya en aumento para así no solo guiar al alumno, sino inculcar en él la necesidad de investigar y aprender más acerca de los temas expuestos. Por ejemplo: en la unidad uno se desarrollan los temas relacionados con la “base” del lenguaje, sus estructuras, su sintaxis, su importancia, etc. Y todo se realiza desarrollando proyectos en consola, con una interfaz rudimentaria y ejemplos sencillos, de cualquier modo, los ejemplos van aumentando en su grado de complejidad, comenzando con un simple “hola mundo” hasta pequeñas aplicaciones donde se piden datos por medio de una interfaz ahora un poco mejor y se trabajan de tal manera que se obliga al alumno a practicar lo expuesto durante toda la unidad como: ciclos, estructuras, declaraciones, objetos, clases, herencia, polimorfismo, etc. etc. etc.

Siguiendo esta idea de aumento progresivo en dificultad de programación y análisis de conceptos, en la segunda unidad se introduce al alumno a un ambiente gráfico, en el cual debe implementar “todo” lo aprendido en la unidad I pero ahora utilizando elementos de un ambiente gráfico como botones, cuadros de diálogo, ventanas, áreas de texto, etc.

ITM


Posteriormente, en la unidad III, el alumno es guiado a implementar lo aprendido en las unidades anteriores y fusionarlos con la administración de archivos. Hasta el momento, todos los ejemplos y ejercicios fueron planeados de tal manera que los datos fueran almacenados y generados en memoria, en esta unidad se da otro giro implementando ahora archivos como fuente de información y lugares de almacenamiento. Es así como en esta unidad se logra desarrollar aplicaciones gráficamente amigables que implementan archivos para funcionar.

Después, en la unidad IV se sigue con la línea de aprendizaje guiando al alumno a la implementación de bases de datos como medio de almacenaje y lectura de información. Aunque no se profundiza demasiado en este tema debido a que el objetivo durante ésta materia es más introductorio. A pesar de esto, se detalla como instalar un servidor de bases de datos, como utilizarla usando el lenguaje de programación java y el ambiente gráfico de NetBeans e incluso se ejemplifican pequeñas aplicaciones con bases de datos pequeñas también. Con ello, el alumno contará con los conocimientos necesarios en relación con bases de datos para un aprendizaje futuro.

Por último, en la unidad V salimos un poco de la temática que gira alrededor de Java para analizar herramientas que trabajan con otros lenguajes como Visual Basic. El objetivo es mostrar al alumno que además de poder programar aplicaciones poderosas utilizando los componentes y controles existentes, es posible crear sus propios componentes con fines específicos. Y debido a que los temas que propone el temario están relacionados con el lenguaje Visual Basic y uno de los objetivos del libro fue desarrollar los temas utilizando el lenguaje java, se da al alumno la tarea de analizar el equivalente a la tecnología Active X de Microsoft en el lenguaje Java.

Así pues, se estructuró el contenido de este material, guiando al alumno de lo más sencillo a lo más complejo, siempre ejemplificando y proponiendo ejercicios que fuercen al alumno a ir un poco más profundo…

A pesar de que este material fue realizado en la versión más actual en cuanto a las herramientas que involucra, siempre hay herramientas nuevas que surgen incluso día con día y esto podría dejar atrás ciertos métodos analizados. Sin embargo, la esencia del funcionamiento de cualquier lenguaje orientado a eventos queda plasmada y no pasará de moda, además, analizando la evolución de los lenguajes de programación puedo predecir que este material será de utilidad durante suficiente tiempo para cumplir su misión y ayudar al alumnado y profesorado de la mejor institución educativa pública del estado a aprender y enseñar respectivamente.

ITM


Bibliografía

1. Steven Holzner - “La Biblia Del Java 2”

Ed. Coriolis.

2. Deitel – “Java How to Program”, 4th EditionMicrosoft

Ed. Prentice Hall

3. Taylor David.

Object Orient informations systems, planning and implementations.

Ed. Ed. Wiley, Canada, 1992.

4. Fco. Javier Ceballos.

Java 2 Curso de Programación.

Ed. Alfaomega.

5. Herbert Schildt.

Fundamentos de Programación en Java 2.

Ed. McGrawHil.

6. Agustín Froufe.

Java 2 Manual de usuario y tutorial.

Ed. Alfaomega.

ITM


7. Stephen R. Davis.

Aprenda Java Ya.

Ed. McGrawHill.

8. Laura Lemay, Rogers Cadenhead.

Aprendiendo JAVA 2 en 21 días.

Ed. Prentice Hall.

9. Kris Jamsa Ph D..

¡Java Ahora!

Ed. McGrawHill..

10. Philip Heller, Simon Roberts

Complete Java® 2 Certification: Study Guide

Fifth Edition

11. http://java.sun.com/

Web oficial de SUN. Puedes encontrar: información, software, etc.

Fecha de consulta: 02/ene/09

12. http://www.javaworld.com/

Documentación muy completa.


ITM


13. http://www.adictosaltrabajo.com/indexg.php?pagina=tutoriales

Tutoriales muy completos


14. http://www.developer.com/java/

Información muy actualiza respecto al mundo de java.


15. http://www.javahispano.org/canyamo.action

Uno de los sitios de java más completos que hay en español.


16. http://www.programacion.net/java/

Otro buen sitio de java en español.


17. http://www.exampledepot.com/

Aquí se puede disponer de muchos ejemplos sencillos.


18. http://www.java2s.com/

Otro excelente sitio con información confiable y ejemplos sobre java.

Fecha de consulta: 01/feb/09

19. http://www.lawebdelprogramador.com/

ITM


Información confiable, chat para resolver dudas, foros de consulta, libros incluso posee un área de ofertas de trabajo.

20. http://www.elrincondelprogramador.com/

Buena fuente de información, no solo para temas relacionados con java, sino con más lenguajes.


21. http://mindprod.com/jgloss/jgloss.html

Glosario muy completo sobre java. Aunque el diseño de la página no es el mejor.


22. http://java.dzone.com/

Pagina con foros, links e información sobre java muy confiables pero sobre temas avanzados del lenguaje.


23. http://www.javasoft.com

Fuente confiable y completa.


24. http://www.prenhall.com/deitel

Pagina con la cual se complementa la información que viene en la obra de deitel.


25. http://es.wikipedia.org/wiki/Java

ITM


La información consultada es buena.


26. http://www.java.com

Página oficial, descargas, ayuda, ¿Qué es java?


27. www.manual-java.com

Manual muy completo, sección de FAQ, Foros, Código, etc.


28. www.webtaller.com/manual-java

Manual paso a paso de Java. Muy recomendable para alguien que comienza a introducirse en el tema.


29. http://todojava.awardspace.com/manuales-java.html

Manuales de java


30. www.itapizaco.edu.mx/paginas/Javatut/froufe/introduccion/indice.html

Tutorial muy bueno para principiantes en java.

Fecha de consulta 10/feb/09

ITM


Glosario de Términos

A

abstract class (clase abstracta)

Una clase que contiene uno o más métodos abstractos, y, por tanto, nunca puede ser instanciada. Las clases se definen de manera que otras clases pueden extenderse y hacerlas concretas mediante la aplicación de los métodos abstractos.

abstract method (método abstracto)

Un método que no tiene implementación.

Abstract Window Toolkit (AWT)

Una colección de componentes de interfaz gráfica de usuario (GUI) que se crearon utilizando las plataformas-nativas de los componentes. Estos componentes proporcionan un subconjunto de la funcionalidad que es común a todas las plataformas. En gran medida suplantado por el proyecto conjunto de componentes Swing.

access control (control de acceso)

Los métodos por los cuales las interacciones con los recursos son limitados a las colecciones de los usuarios o programas con el fin de hacer cumplir la integridad, confidencialidad, disponibilidad o limitaciones.

ACID

El acrónimo de las cuatro propiedades de las transacciones garantizadas: (atomicity, consistency, isolation, and durability) atomicidad, la consistencia, aislamiento y durabilidad.

actual parameter list (lista de parámetros reales)

The arguments specified in a particular method call. Los argumentos que se especifican en una llamada de método especial.

ITM


API

(Application Programming Interface.) Interfaz de programación de aplicaciones. La especificación de cómo un programador haciendo una aplicación accede a la conducta y el estado de clases y objetos.

applet

Un componente que normalmente se ejecuta en un navegador Web, pero puede ejecutar en una variedad de otras aplicaciones o dispositivos que apoyan el modelo de programación applet.

argument (argumento)

Un elemento de datos especificados en una llamada de método. Un argumento puede ser un valor literal, una variable, o una expresión.

array (arreglo)

Una colección de datos, todos del mismo tipo, en el que cada elemento ocupa una posición única designada por un entero.

ASCII

(American Standard Code for Information Interchange) Código americano estándar para el intercambio de información. Una norma de asignación de 7-bit códigos numéricos a caracteres.

atomic (atómica)

Se refiere a una operación que nunca se interrumpe o se dejan en un estado incompleto bajo ninguna circunstancia.

B

bean

Un componente de software reutilizable que se ajuste a determinado diseño y convenciones de nombres.

Binario, sistema

ITM


Es un sistema de numeración en el que los números se representan utilizando solamente las cifras cero y uno (0 y 1).

binary operator (operador binario)

Un operador que tiene dos argumentos.

bit

La unidad más pequeña de información en una computadora, con un valor de 0 o 1.

bitwise operator (operador bitwise)

El operador que manipula los bits de uno o más de sus operandos por separado y en paralelo. Los ejemplos incluyen a los operadores binario lógicos (&, |, ^), el cambio de operadores binarios (<<,>>>>>) y el unario un complemento del operador (~).

block (bloque)

En el lenguaje de programación Java, cualquier código entre llaves. Ejemplo: {x = 1;}.

boolean

Se refiere a una expresión o variable que sólo puede tener un valor verdadero o falso. El lenguaje de programación Java proporciona el tipo booleano y los valores literales verdadero y falso.

break

Una palabra clave de Java utilizada para reanudar la ejecución del programa en la instrucción inmediatamente después de la actual declaración. Si está seguido por una etiqueta, el programa reanudará la ejecución en la etiqueta la declaración.

byte

Una secuencia de ocho bits. Java proporciona un tipo byte correspondiente.

bytecode

Código independiente máquina generado por el compilador Java y ejecutado por el intérprete de Java.

C

ITM


case

Una palabra reservada de Java que define un grupo de estados para iniciar la ejecución si un valor coincide con el valor definido.

casting (enmascaramiento)

Conversión explícita de un tipo de dato a otro.

catch

Una palabra clave de Java utilizada para declarar un bloque de código para ser ejecutado en caso de que haya una excepción de Java, o en un error en tiempo de ejecución, se produce en un bloque try anterior.

char

Una palabra clave de Java utilizada para declarar una variable de tipo carácter.

class (clase)

En el lenguaje de programación Java, un tipo que define la implementación de un tipo particular de objeto. Una definición de clase define la instancia y variables de clase y métodos, así como especificar las interfaces que la clase implementa y la inmediata superclase de la clase.

class method (método de clase)

Un método consta de una serie de instrucciones que determinan el comportamiento del de la clase. Los métodos de clase afectan a la clase en su conjunto, no una instancia de la clase

class variable (variable de clase)

Un elemento de datos asociados a una clase en su conjunto - no con casos particulares de la clase. Las variables se definen en las definiciones de clase.

Código

Conjunto de líneas de texto que son las instrucciones que debe seguir la computadora para ejecutar un programa.

comment (comentario)

ITM


En un programa, un texto explicativo que es ignorado por el compilador. En los programas escritos en el lenguaje de programación Java, los comentarios están delimitados con / / o / * ... * /.

commit (comprometerse)

El punto en una transacción cuando todas las actualizaciones a todos los recursos que participan en la transacción se hizo permanente.

compiler (compilador)

Programa informático que traduce un programa escrito en un lenguaje de programación a otro lenguaje de programación, generando un programa equivalente que la máquina será capaz de interpretar.

Componentes de Software

Todo aquel recurso desarrollado para un fin concreto y que puede formar solo o junto con otro/s, un entorno funcional requerido por cualquier proceso predefinido. Son independientes entre ellos, y tienen su propia estructura e implementación.

constructor (constructor)

Es un pseudo-método que crea un objeto. En el lenguaje de programación Java, los constructores son métodos de instancia con el mismo nombre que su clase. Los constructores se invocan utilizando la palabra reservada new.

continue (continuar)

Es una palabra clave de Java utilizados para reanudar la ejecución del programa al final del bucle de corriente.

D

declaration (declaración)

Una línea de código que establece un identificador y los atributos asociados con él, sin que necesariamente se reserve memoria (para datos).

default (predeterminado)

ITM


Palabra reservada de Java utilizado opcionalmente, después de todos los casos o condiciones. Si las condiciones no son correspondidas por el valor de la variable, las sentencias de la opción por default se llevarán a cabo.

Depurador

Programa que permite depurar o limpiar los errores de otro programa informático.

do

Palabra clave de Java utilizada para declarar un bucle que va a iterar un bloque de declaraciones. La condición de salida del bucle puede especificarse al mismo tiempo.

double

Una palabra clave de Java utilizado para definir una variable de tipo doble.

E

else

Palabra clave de Java utilizada para ejecutar un bloque de estados en el caso de que la condición de prueba con la palabra clave if evalúa a falso.

exception (excepción)

Un evento durante la ejecución del programa que evita que el programa continúe normalmente, en general, un error. El lenguaje de programación Java admite excepciones con las palabras try, catch, y throw.

exception handler (manejador de excepciones)

Bloque de código que reacciona a un tipo específico de excepción. Si la excepción es para un error del cual el programa se puede recuperar, el programa se puede reanudar después de la ejecución manejador de excepciones se ha ejecutado.

extends (se extiende o hereda)

La clase X extiende a la clase Y para añadir funcionalidad, ya sea mediante la adición de campos o métodos para la clase Y, por una o métodos de la clase Y. esta palabra reservada se utiliza en la herencia de clases.

ITM


F

final

Palabra clave de Java que se utiliza para declarar valores constantes en una aplicación.

float

Palabra reservada de Java utilizada para definir una variable en punto flotante.

for

Palabra clave de Java utilizada para declarar un bucle que reitera las declaraciones. El programador puede especificar los estados para ser ejecutado, las condiciones de salida, y variables para la inicialización del bucle.

G

garbage collection (recolección de basura)

Detección automática y liberación de memoria que ya no está en uso. El sistema ejecuta esta acción debido a que los programadores no siempre liberan la memoria que solicitan al sistema.

goto

Se trata de una palabra reservada. Sin embargo, no es utilizado por las versiones actuales del lenguaje de programación Java.

GUI

(Graphical User Interface.) Interfaz gráfica de usuario. Se refiere a las técnicas involucradas en el uso de gráficos, junto con un teclado y un ratón, para proporcionar una manera fácil de utilizar algún programa.

H

ITM


hexadecimal

El sistema de numeración que utiliza 16 como su base.

I

Identificador

Nombre de un elemento en un programa escrito en el lenguaje de programación Java.

if

Palabra clave de Java utilizada para llevar a cabo una prueba condicional y ejecutar un bloque de estados si la prueba se evalúa a verdadero.

import

Palabra reservada de Java utilizada en el comienzo de un archivo fuente que puede especificar las clases o los paquetes que se desean importar o utilizar posteriormente.

inheritance (herencia)

Concepto de clases en el que de forma automática que contienen las variables y los métodos definidos en sus superclases.

instancia

Un objeto de una clase particular. En los programas escritos en el lenguaje de programación Java, una instancia de una clase se crea usando el operador new seguido por el nombre de clase.

int

Palabra reservada de Java utilizada para definir una variable de tipo entera.

intérprete

Módulo que, alternativamente, decodifica y ejecuta todas las instrucciones en un programa. El intérprete de Java decodifica y ejecuta bytecode de la máquina virtual.

Iteración

Se refiere a la acción de repetir una serie de pasos un cierto número de veces.

ITM


J

Java

Lenguaje de programación orientado a objetos desarrollado por Sun Microsystems a principios de los años 90.

Java Database Connectivity (JDBC) Conectividad de bases de datos Java

Un estándar de la industria de base de datos independiente de la conexión entre la plataforma Java y una amplia gama de bases de datos.

Java Development Kit (JDK)

Un entorno de desarrollo de software que sirve para escribir applets y aplicaciones en el lenguaje de programación Java.

Java Foundation Classes (JFC)

Organismo encargado de crear bibliotecas adicionales al lenguaje Java como el Toolkit AWT.

Java virtual machine (Máquina virtual Java)

Software "motor de ejecución" que en condiciones de seguridad y compatibilidad ejecuta el código byte en los archivos de clase Java en un microprocesador (ya sea en una computadora o en otro dispositivo electrónico).

JavaBeans

Modelo de componente reusable e independiente de plataforma.

L

Librería

Es un conjunto de subprogramas utilizados para desarrollar software. Las librerías contienen código y datos, que proporcionan servicios a programas independientes, es

ITM


decir, pasan a formar parte de éstos. Esto permite que el código y los datos se compartan y puedan modificarse de forma modular.

M

Memoria de datos

Memoria de lectura/escritura (RAM), cuyo objetivo es permitir el almacenamiento temporal de datos o programas de aplicación. Por sus características de lectura/escritura, la información que reside en ella se puede alterar fácilmente. Esta se pierde cuando se apaga la fuente de alimentación.

N

NetBeans

Plataforma para el desarrollo de aplicaciones de escritorio usando Java y a un entorno de desarrollo integrado (IDE) desarrollado usando la Plataforma NetBeans.

new

Una palabra clave de Java utilizado para crear una instancia de una clase.

null

El tipo nulo tiene un valor, la referencia nula, representada por el literal null, el cual está formado de caracteres ASCII. Una literal es nula siempre del tipo null.

O

objeto

Instancia de clase. Elemento principal de un lenguaje orientado a objetos.

octal

ITM


El sistema de numeración que utiliza 8 como su base, utilizando los números 0-7 como sus dígitos

P

Parámetro

Es una variable que es recibida por una función, procedimiento o subrutina.

Primitivo, tipo

Tipos de datos originales de un lenguaje de programación, esto es, aquellos que nos proporciona el lenguaje y con los que podemos (en ocasiones) construir tipos de datos abstractos y estructuras de datos.

private

Palabra reservada de Java que indica si una variable puede ser accedida o utilizada únicamente por elementos de la misma clase.

propiedad

Características de un objeto que los usuarios pueden fijar, como el color de una ventana.

protected (protegidas)

Palabra reservada de Java. Significa que el método o variable sólo puede ser visitada por los elementos que residen en sus clases, subclases, clases o en el mismo paquete.

public público

Palabra reservada de Java. Significa que el método o variable puede ser visitada por los elementos que residen en otras clases.

R

return

ITM


Palabra clave de Java utilizada para terminar la ejecución de un método. Se utilize normalmente para regresar un valor en un método.

S

short

Una palabra clave de Java utilizado para definir una variable de tipo short.

SQL

Structured Query Language. Lenguaje estructurado de consultas en bases de datos.

stream corriente

Es un flujo de datos en bytes que se envían desde un emisor a un receptor.

super

Una palabra clave de Java utilizado para acceder a miembros de una clase heredada de la clase en la que aparece.

Swing

Colección de componentes de interfaz gráfica de usuario (GUI) que se ejecuta de manera uniforme a cualquier plataforma nativa que utilice la máquina virtual Java

T

Template

O plantilla es una forma de dispositivo que proporciona una separación entre la forma o estructura y el contenido. Es un medio o un instrumento que permite guiar, portar o construir un diseño o esquema predefinido.

this

ITM


Una palabra clave de Java que pueden utilizarse para representar una instancia de la clase en la que aparece. Esto puede ser usado para acceder a las variables de clase y métodos.

throw

Una palabra clave de Java que permite al usuario lanzar una excepción.

Token

O componente léxico, es una cadena de caracteres que tiene un significado coherente en cierto lenguaje de programación.

try

Palabra clave que define un bloque de estados que pueden lanzar una excepción lenguaje Java.

V

Variable

Elemento de datos nombrado con un identificador.

Programación Orientada a Eventos Java

Education

Transcript of Programación Orientada a Eventos Java