Download instituto tecnológico de morelia programación ii

0
SUBSECRETARÍA DE EDUCACIÓN SUPERIOR
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR
TECNOLÓGICA
INSTITUTO TECNOLÓGICO
DE MORELIA
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
MORELIA, MICHOACÁN
20/06/09
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.
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.
i
ITM INDICE GENERAL
INDICE
INTRODUCCION
.
.
.
.
.
.
.
.
.
UNIDAD I. “FUNDAMENTOS DEL LENGUAJE”
1.1 Programación orientada a eventos. . .
1.1.1 Objetos. . . . . . . .
1.1.2 Eventos. . . . . . . .
1.1.3 Métodos. . . . . . . .
1.1.4 Propiedades. . . . . . .
1.2 Entorno integrado de desarrollo. . . .
1.3 Ventanas (proyecto, propiedades, ayuda).
1.4 Tipos de proyectos. . . . . . .
1.4.1 Configuración.
. . . .
23
1.5 Comentarios. . . . . . . . .
1.6 Constantes.
. . . . . . . .
1.7 Tipos de datos. . . . . . . . .
1.8 Variables. . . . . . . . . .
1.9 Operadores.
. . . . . . . .
1.10 Sentencias. . . . . . . . .
1.11 Matrices. . . . . . . . . .
1.12 Procedimientos y funciones.. . . .
1.13 Estructuras de control. . . . . .
1.14 Controles básicos y sus propiedades.
Ejercicios Propuestos.
. . . . . .
Proyectos integrales. . . . . . . .
.
.
.
.
.
.
.
.
i
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
6
10
13
15
18
23
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
24
25
26
32
36
45
46
49
55
64
72
75
.
.
77
. .
.
.
.
.
.
.
93
94
97
101
105
107
.
.
.
.
.
111
115
122
130
133
UNIDAD 2. “CONTROLES, EVENTOS, MÉTODOS Y COMPONENTES”
2.1 Controles estándar. . . . . . . . . . . . . .
2.2 Eventos del formulario.
. . . . . . . . . . .
87
2.3 Cajas de diálogo.
. . . . . . . . . . . . .
2.3.1 Modales y no modales.
. . . . . . . . .
2.3.2 Predefinidas. . . . . . . . . . . . . .
2.4 Componentes estándar. . . . . . . . . . . . .
Ejercicios Propuestos. . . . . . . . . . . . . . .
Proyecto integral . . . . . . . . . . . . . . .
UNIDAD 3. “SISTEMAS DE ARCHIVOS”
3.1 Acceso secuencial.
. . . . . .
3.2 Acceso directo. . . . . . . . .
3.3 Manejo de archivos. . . . . . .
3.4 Controlar errores en tiempo de ejecución.
Ejercicios Propuestos. . . . . . . .
Instituto Tecnológico de Morelia.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Página i
ITM INDICE GENERAL
Proyecto integral
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
135
UNIDAD 4. “ACCESO A DATOS”
4.1 Introducción. . . . . . .
4.2 Control de datos ADO. . . . .
4.3 Objetos ADO. . . . . . .
4.4 Herramientas de acceso a datos.
4.4.1 ADO.NET
. .
4.4.2 JDBC . . . .
4.4.3 ODBC . . . .
4.4.2 DAO . . . .
Ejercicios Propuestos.
. . . .
Proyecto integral . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
138
154
156
164
165
165
165
166
172
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. . .
Conclusiones.
Bibliografía. .
.
.
.
.
.
.
.
.
.
.
.
.
191
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
202
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
204
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
209
Glosario de Términos.
Instituto Tecnológico de Morelia.
Página ii
ITM INDICE GENERAL
INDICE DE FIGURAS
UNIDAD I. “FUNDAMENTOS DEL LENGUAJE”
1.1 Ejemplo de cómo identificar Objetos.
.
.
1.2 Ejemplo de cómo identificar Objetos, Misma Clase.
1.3 Ejemplo utilizando JOptionPane.
. . . . .
1.4 Ejemplo usando ventanas para entrada de datos. .
1.5 Objeto en NetBeans. . . . . . . . . .
1.6 Botón con texto editado. . . . . . . . .
1.7 Pantalla principal de NetBeans 6.0. . . . . .
1.8 Ventana de Proyectos.. . . . . . . . .
1.9 Ventana elegir nombre y ubicación. . . . . .
1.10 Hola Mundo en Java. . . . . . . . .
1.11 Ventana Propiedades.
. . . . . . .
1.12 Ventana Help. . . . . . . . . . .
1.13 Búsqueda en Ayuda. . . . . . . . .
1.14 Ventana Proyectos. . . . . . . . . .
1.15 Ejemplo de una etiqueta. . . . . . . .
1.16 Ejemplo de ScrollBar no a la vista. . . . .
1.17 Ejemplo de ScrollBar a la vista. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
9
9
13
14
16
18
19
20
21
21
22
24
65
70
71
UNIDAD 2. “CONTROLES, EVENTOS, MÉTODOS Y COMPONENTES”
2.1 Ventana “Nuevo Proyecto”. . . . . . . . . . . .
2.2 Ventana de configuración de proyecto.
. . . . . . .
2.3 Área de trabajo de NetBeans.
. . . . . . . . .
2.4 Aplicación de escritorio vacía.
. . . . . . . . .
2.5 Paleta de controles. . . . . . . . . . . . . .
2.6 Programa en ejecución con botones de ejemplo. . . . . .
2.7 Ventana Propiedades. . . . . . . . . . . . . .
2.8 Cambio de propiedades de un objeto. . . . . . . . .
2.9 Cambio de propiedad “name”.
. . . . . . . . . .
2.10 Programa en ejecución con caja de texto.
. . . . .
2.11 Cambio de Propiedades de un objeto Textfield. . . . . .
2.12 Cambio de Propiedades de objetos CheckBox. . . . . .
2.13 Aplicación con botones de opción.
. . . . .
. .
2.14 Lista de eventos. . . . . . . . . . . . . . .
2.15 Ejemplo en ejecución. . . . . . . . . . . . .
2.16 Programa en ejecución.
. . . . . . . . . . .
2.17 Aplicación en ejecución. . . . . . . . . . . .
2.18 Aplicación en ejecución. . . . . . . . . . . .
2.19 Ventana “New File” crear caja de diálogo.
. . .. . .
2.20 Nuevo formulario para caja de diálogo vacio. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
77
78
78
79
79
80
81
82
83
83
84
85
87
88
89
90
92
93
95
95
Instituto Tecnológico de Morelia.
.
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Página iii
ITM INDICE GENERAL
2.21
2.22
2.23
2.24
2.25
2.26
2.27
Aplicación en ejecución. . . . . . . . .
Cómo ver la lista de cuadros de diálogo predefinidos.
Error por no importar librería. . . . . . . .
Herramienta útil para corregir errores sencillos. . .
Programa en ejecución.
. . . . . . . .
Programa en ejecución.
. . . . . . . .
Componentes Swing y AWT. . . . . . . .
UNIDAD 3. “SISTEMAS DE ARCHIVOS”
3.1 Programa en ejecución. . . .
3.2 Programa en ejecución. . . .
3.3 Ejemplo con RandomAccessFile.
3.4 Ejemplo usando JFileChooser. .
3.5 Selector de apertura. . . . .
3.6 Selector personalizado. . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
UNIDAD 4. “ACCESO A DATOS”
4.1 Ventana: elegir nombre de página y puerto. . . .
4.2 Ventana: configuración de MySQL. . . . . . .
4.3 Iniciar ambos servidores. . . . . . . . . .
4.4 Pantalla principal del servidor Apache.
. . . .
4.5 Pantalla principal de phpMyAdmin. . . . . . .
4.6 ¿Cómo acceder a la tabla de Usuarios?. . . . .
4.7 Consulta de la tabla “user” de MySQL. . . . . .
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. . . . . . . .
4.11 Opción para conectar la base de datos. . . . .
4.12 Agregar los datos a la Base de datos.
. . . .
4.13 Conectar NetBeans con MySQL. . . . . . .
4.14 Ventana: Conexión establecida. . . . . . .
4.15 Ejemplo de botó que invoca una conexión.
. .
4.16 Opción necesaria para crear una Base de Datos. .
4.17 Crear tablas de la base de datos. . . . . . .
4.18 Ingresar datos de la tabla. . . . . . . . .
4.19 Ingresar datos de cada campo de la tabla.
. .
152
4.20 Vista de las tablas de nuestra nueva base de datos.
4.21 Programa en ejecución.
. . . . . . . .
4.22 Contenido de la base de datos.
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
96
98
98
99
100
101
102
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
113
115
119
123
123
125
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
140
140
141
141
142
143
143
. .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
145
146
146
147
147
149
150
151
151
. .
.
.
.
.
.
.
.
.
.
.
.
.
152
154
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
Instituto Tecnológico de Morelia.
Página iv
ITM INDICE GENERAL
5.3 Evento “resize” del control ActiveX. . . . . . .
5.4 Ventana para activar el asistente de configuración. .
5.5 Ventana: Seleccionar miembros de la interfaz. . .
5.6 Ventana: Agregar miembros personalizados. . . .
5.7 Ventana crear miembros personalizados de la interfaz.
5.8 Ventana: establecer atributos de los miembros. . .
5.9 Utilización de nuestro control.. . . . . . . .
5.10 Objeto Active X. . . . . . . . . . . .
Instituto Tecnológico de Morelia.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
180
180
181
181
182
182
184
186
Página v
Unidad 1. Fundamentos del
Lenguaje.
Conceptos básicos.
ITM Unidad I Fundamentos del Lenguaje
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).
Instituto Tecnológico de Morelia.
Página 2
ITM Unidad I Fundamentos del Lenguaje
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>*
Instituto Tecnológico de Morelia.
Página 3
ITM Unidad I Fundamentos del Lenguaje
}
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.
Instituto Tecnológico de Morelia.
Página 4
ITM Unidad I Fundamentos del Lenguaje
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():
Instituto Tecnológico de Morelia.
Página 5
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 6
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 7
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 8
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 9
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 10
ITM Unidad I Fundamentos del Lenguaje
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
//Código}
void
main
(String
args[]){
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
Instituto Tecnológico de Morelia.
Página 11
ITM Unidad I Fundamentos del Lenguaje
//Clase original sin sobrecarga.
class Calculadora
{
int Suma(int op1, int op2)
{
return op1 + op2;
}
}
class Calculadora
{
//método Suma que
int Suma(int op1,
{
return op1 +
}
//método Suma que
int Suma(int op1,
{
return op1 +
}
}
trabaja con dos operadores
int op2)
op2;
trabaja con tres operadores
int op2, int op3)
op2 + op3;
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.
Instituto Tecnológico de Morelia.
Página 12
ITM Unidad I Fundamentos del Lenguaje
*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
Instituto Tecnológico de Morelia.
Página 13
ITM Unidad I Fundamentos del Lenguaje
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]
[modificadores]
tipo_variable nombre;
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.
Instituto Tecnológico de Morelia.
Página 14
ITM Unidad I Fundamentos del Lenguaje
•
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.)
Instituto Tecnológico de Morelia.
Página 15
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 16
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 17
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 18
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 19
ITM Unidad I Fundamentos del Lenguaje
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.
Botón para correr el proyecto
Aquí ponemos el código
Aquí se muestra la salida
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.
Instituto Tecnológico de Morelia.
Página 20
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 21
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 22
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 23
ITM Unidad I Fundamentos del Lenguaje
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, asteriscodiagonal 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
Instituto Tecnológico de Morelia.
Página 24
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 25
ITM Unidad I Fundamentos del Lenguaje
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
byte
Instituto Tecnológico de Morelia.
Tamaño
1Byte (8 bits)
Página 26
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 27
ITM Unidad I Fundamentos del Lenguaje
Literales en punto flotante
Representan números decimales con partes fraccionarias.
representarse con notación estándar (563.84) o científica (5.6384e2).
Pueden
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
Instituto Tecnológico de Morelia.
Página 28
ITM Unidad I Fundamentos del Lenguaje
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
de \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
Alimentación
formularios
Alfabeto
ASCII
mayúsculas
en A.-Z
\u0041 a \u005A
Alfabeto
ASCII
minúsculas
en 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
Instituto Tecnológico de Morelia.
Página 29
ITM Unidad I Fundamentos del Lenguaje
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)
int lastIndexOf (int ch, int fromIndex)
int lastIndexOf (String str)
int lastIndexOf (String str, int fromIndex)
int length()
String replace (char oldChar, char
newChar)
boolean startsWith (String prefix)
boolean startsWith (String prefix, int
offset)
Instituto Tecnológico de Morelia.
Devuelve el índice, dentro de la
cadena, de la última ocurrencia del
carácter especificado.
Produce el índice, dentro de la
cadena de la última ocurrencia del
carácter dado, buscando hacia atrás
desde el índice especificado.
Devuelve el índice, dentro de la
cadena, de la ocurrencia del String
dado.
Produce el índice dentro de la
cadena de la última ocurrencia del
carácter dado.
Devuelve la longitud de la cadena
Produce
una
nueva
cadena
substituyendo todas las ocurrencias
de oldChar con newChar
Chequea si la cadena empieza con
el prefijo dado.
Chequea si la cadena empieza con
el prefijo dado, empezando en el
índice dado.
Página 30
ITM Unidad I Fundamentos del Lenguaje
char[] to CharArray ()
String toLowerCase ()
String to UpperCase()
String trim()
Static String valueOf (boolean b)
Static String valueOf (char b)
Static String valueOf (char [] data)
Static String valueOf(char[] data, offset,
int count)
Static String valueOf (doubleb)
Static String valueOf (float b)
Static String valueOf (int b)
char charAt (int index)
int compareTo (Object o)
int compareToIgnoreCase(String
otraCadena)
int compareTo (String otraCadena)
String concat(String str)
Boolean endsWith (String sufijo)
Convierte una cadena en un arreglo
de caracteres.
Cambia todos los caracteres de la
cadena a su equivalente en
minúsculas.
Cambia
los caracteres de una
cadena a su equivalente en
mayúsculas.
Elimina los espacios en blanco que
encuentre iniciando la búsqueda
desde ambos extremos de la
cadena.
Produce la representación de la
cadena del argumento booleano.
Produce la representación de la
cadena del argumento char
Produce la representación de la
cadena del arreglo de caracteres.
Produce la representación de la
cadena de un sub arreglo específico
del argumento char array de enteros.
Produce la representación String de
un double.
Produce la representación String de
un float.
Produce la representación String de
un int.
Proporciona el carácter del índice
especificado.
Compara este objeto String con otro.
Compara dos cadenas ignorando
diferencias entre mayúsculas y
minúsculas.
Compara que dos cadenas sean
exactamente iguales.
Concatena la cadena dada al final de
la cadena.
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();
Instituto Tecnológico de Morelia.
Página 31
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 32
ITM Unidad I Fundamentos del Lenguaje
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).
boolean
byte
char
Almacenamiento en
bytes
1
1
2
double
8
Tipo de Variable
Instituto Tecnológico de Morelia.
Rango de Valores
Verdadero, Falso
-128 a 127
N/A
-1.79769313486232E308 a
-94065645841247E-324
Página 33
ITM Unidad I Fundamentos del Lenguaje
Float
4
int
4
Long
8
Short
para valores negativos y
4.94065645841247E-324 a
1.79769313486232E308
para valores positivos.
-3.402823E38 a 1.401298E-45 para valores
negativos y 1.401298E-45
a 3.402823E38 para
valores positivos.
-2,147,483,648 a
2,147,483,647
9,223,372,036,854,775,808
a
9,223,372,036,854,775,807
-32,768 a 32,767
2
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
String ()
String (byte[] bytes)
String (byte[] bytes, int offset, int
length)
String (byte[] bytes bytes, int offset,
enc)
String (byte[] bytes, String enc)
Instituto Tecnológico de Morelia.
Descripción
Inicializa un nuevo objeto String para
gestionar una secuencia de caracteres
vecía.
Construye un nuevo objeto String
convirtiendo el arreglo de bytes
mediante la codificación de caracteres
que tiene la plataforma por defecto.
Construye un nuevo objeto String
convirtiendo el subarreglo de bytes
usando la codificación de caracteres
por defecto.
Construye un Nuevo objeto String
convirtiendo el entero length y el
subarreglo de caracteres utilizando la
codificación
de
caracteres
especificada.
Construye un nuevo objeto String
convirtiendo el arreglo de bytes
mediante la codificación de caracteres
Página 34
ITM Unidad I Fundamentos del Lenguaje
String (char[] value)
que se especifica.
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.
public class MiClase{
public static void main (String [] args){
String s1 = “Hola Mundo!”;
String s2;
s2 = “Hola!”;
string s3 = new String();
s3 = “Hola de nuevo!”;
.
}
}
Utilizamos uno de los constructores de la clase String.
Instituto Tecnológico de Morelia.
Página 35
ITM Unidad I Fundamentos del Lenguaje
public class MiClase{
public static void main (String [] args){
String s1 = “Hola Mundo!”;
String s2;
s2 = “Hola!”;
string s3 = new String();
s3 = “Hola de nuevo!”;
String
s4
Constructor!”);
.
.
.
}
=
new
String(“Usamos
}
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.
Instituto Tecnológico de Morelia.
Página 36
ITM Unidad I Fundamentos del Lenguaje
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
op1 + op2
op1 - op2
op1 * op2
op1 / op2
%
op1 % op2
Descripción
Suma op1 y op2
Resta op2 de op1
Multiplica op1 por op2
Divide op1 entre op2
Calcula el resto de dividir op1 entre
op2
Tabla1.9 Operadores aritméticos binarios de Java
Instituto Tecnológico de Morelia.
Página 37
ITM Unidad I Fundamentos del Lenguaje
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:
Operador Uso
+
+op
-
-op
Descripción
Convierte op a entero si es un byte, short o
char
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.
Operador
Uso
++
op++
++
++op
--
op--
--
--op
Descripción
Incrementa op en 1; se evalúa con valor anterior
incremento
Incrementa op en 1; se evalúa con valor posterior
incremento
Decrementa op en 1; se evalúa con valor anterior
incremento
Decrementa op en 1; se evalúa con valor posterior
Instituto Tecnológico de Morelia.
al
al
al
al
Página 38
ITM Unidad I Fundamentos del Lenguaje
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
op1 > op2
op1 >= op2
op1 < op2
op1 <= op2
op1 == op2
op1 != op2
Devuelve verdadero si
op1 es mayor que op2
op1 es mayor o igual que op2
op1 es menor que op2
op1 es menor o igual que op2
op1 y op2 son iguales
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).
Instituto Tecnológico de Morelia.
Página 39
ITM Unidad I Fundamentos del Lenguaje
Java soporta cinco operadores condicionales, mostrados en la siguiente tabla:
Operador
Uso
&&
op1 && op2
&
op1 & op2
||
op1 || op2
|
!
op1 | op2
! op
Devuelve verdadero si...
op1 y op2 son ambos verdaderos, condicionalmente
evalúa op2
op1 y op2 son ambos verdaderos, siempre evalúa op1
y op2
op1 o op2 son verdaderos, condicionalmente evalúa
op2
op1 o op2 son verdaderos, siempre evalúa op1 y op2
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
>>
op1 >> op2
<<
op1 << op2
>>>
op1 >>> op2
Operación
Desplaza los bits de op1 a la derecha op2 veces
Desplaza los bits de op1 a la izquierda op2 veces
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.
Instituto Tecnológico de Morelia.
Página 40
ITM Unidad I Fundamentos del Lenguaje
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
op1 & op2
op1 | op2
op1 ^ op2
~op2
Operación
AND
OR
OR Exclusivo
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
Instituto Tecnológico de Morelia.
Página 41
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 42
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 43
ITM Unidad I Fundamentos del Lenguaje
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 posfijos
Operadores unarios
Creación o conversión
Multiplicación
Suma
Desplazamiento
Comparación
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
Operadores de este tipo
[ ] . (parametros) expr++ expr-++expr --expr +expr -expr ~ !
new (tipo) expr
*/%
+<< >> >>>
< > <= >= instanceof
== !=
&
^
|
&&
||
?:
= += -= *= /= %= &= ^= |= <<= >>= >>>=
Tabla1.16 Precedencia de operadores
Por ejemplo, la siguiente expresión produce un resultado
dependiendo de si se realiza la suma o división en primer lugar:
diferente
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)
Instituto Tecnológico de Morelia.
Página 44
ITM Unidad I Fundamentos del Lenguaje
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:
Instituto Tecnológico de Morelia.
Página 45
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 46
ITM Unidad I Fundamentos del Lenguaje
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){
Instituto Tecnológico de Morelia.
Página 47
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 48
ITM Unidad I Fundamentos del Lenguaje
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
10
2
20
3
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.
Instituto Tecnológico de Morelia.
Página 49
ITM Unidad I Fundamentos del Lenguaje
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
nombre_parámetro, ... ) {
sentencia1;
sentencia2;
...
sentenciaN;
return unValor;
}
(tipo_parámetro
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:
Instituto Tecnológico de Morelia.
Página 50
ITM Unidad I Fundamentos del Lenguaje
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 : " +
Instituto Tecnológico de Morelia.
Página 51
ITM Unidad I Fundamentos del Lenguaje
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)
Instituto Tecnológico de Morelia.
Página 52
ITM Unidad I Fundamentos del Lenguaje
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:
Instituto Tecnológico de Morelia.
Página 53
ITM Unidad I Fundamentos del Lenguaje
//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
Instituto Tecnológico de Morelia.
Página 54
ITM Unidad I Fundamentos del Lenguaje
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
Toma de decisión
Ciclo
Diversas
Clave
if-else, switch-case
for, while, do-while
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:
Instituto Tecnológico de Morelia.
Página 55
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 56
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 57
ITM Unidad I Fundamentos del Lenguaje
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:
Instituto Tecnológico de Morelia.
Página 58
ITM Unidad I Fundamentos del Lenguaje
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:
Instituto Tecnológico de Morelia.
Página 59
ITM Unidad I Fundamentos del Lenguaje
// 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
Instituto Tecnológico de Morelia.
Página 60
ITM Unidad I Fundamentos del Lenguaje
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:
Instituto Tecnológico de Morelia.
Página 61
ITM Unidad I Fundamentos del Lenguaje
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
24
369
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.
Instituto Tecnológico de Morelia.
Página 62
ITM Unidad I Fundamentos del Lenguaje
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
Button
Label
SWING
JButton
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.
Instituto Tecnológico de Morelia.
Página 63
ITM Unidad I Fundamentos del Lenguaje
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 );
}
Instituto Tecnológico de Morelia.
Página 64
ITM Unidad I Fundamentos del Lenguaje
} // 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" );
Instituto Tecnológico de Morelia.
Página 65
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 66
ITM Unidad I Fundamentos del Lenguaje
} // 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.
Instituto Tecnológico de Morelia.
Página 67
ITM Unidad I Fundamentos del Lenguaje
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 {
Instituto Tecnológico de Morelia.
Página 68
ITM Unidad I Fundamentos del Lenguaje
/** 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();
}
}
Instituto Tecnológico de Morelia.
Página 69
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 70
ITM Unidad I Fundamentos del Lenguaje
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:
Instituto Tecnológico de Morelia.
Página 71
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 72
ITM Unidad I Fundamentos del Lenguaje
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).
Instituto Tecnológico de Morelia.
Página 73
ITM Unidad I Fundamentos del Lenguaje
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
Instituto Tecnológico de Morelia.
Página 74
ITM Unidad I Fundamentos del Lenguaje
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.
Instituto Tecnológico de Morelia.
Página 75
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.
Instituto Tecnológico de Morelia.
Página 77
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 78
ITM Unidad II Controles, Eventos, Métodos y Componentes
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,
Instituto Tecnológico de Morelia.
Página 79
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 80
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 81
ITM Unidad II Controles, Eventos, Métodos y Componentes
3. Presione Enter.
4. Pruebe el resultado corriendo el programa con f6.
Ventana de propiedades
Corrida del programa.
Aquí selecciona la propiedad
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.
Instituto Tecnológico de Morelia.
Página 82
ITM Unidad II Controles, Eventos, Métodos y Componentes
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
Instituto Tecnológico de Morelia.
Página 83
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 84
ITM Unidad II Controles, Eventos, Métodos y Componentes
Ventana de propiedades
Corrida del programa.
En una cambiamos la propiedad
editable y en la otra la propiedad
text.
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”.
Instituto Tecnológico de Morelia.
Página 85
ITM Unidad II Controles, Eventos, Métodos y Componentes
Ventana de propiedades
Corrida del programa.
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
Instituto Tecnológico de Morelia.
Página 86
ITM Unidad II Controles, Eventos, Métodos y Componentes
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)
Aquí selecciona el grupo al que desea que
pertenezcan los botones de opción.
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
Instituto Tecnológico de Morelia.
Página 87
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 88
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 89
ITM Unidad II Controles, Eventos, Métodos y Componentes
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
Dimension getMinimumSize()
int getColumns()
Protected String paramString()
void removeActionListener(Action
Listener)
void setText(String)
String getString ()
Descripción
Obtiene las dimensiones mínimas
para el cuadro de texto
Obtiene el número de columnas del
cuadro de texto.
Obtiene la representación en cadena
del estado del cuadro de texto.
Elimina el action listener indicado,
para que no reciba eventos.
Asigna una cadena al objeto.
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
evt) {
void
Boton1MouseClicked(java.awt.event.MouseEvent
campoTexto1.setText("Programaste el evento clic");
//Entre comillas se pone lo que deseas que se
//muestre en la caja de texto
}
Instituto Tecnológico de Morelia.
Página 90
ITM Unidad II Controles, Eventos, Métodos y Componentes
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());
}
Instituto Tecnológico de Morelia.
Página 91
ITM Unidad II Controles, Eventos, Métodos y Componentes
}
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
boolean isBackgroundSet()
boolean isBorderPainted()
boolean isEnabled()
boolean isSelected()
void setText (String text)
void setVisible (boolean aFlag)
Instituto Tecnológico de Morelia.
Descripción
Regresa “true” si el color de fondo del
componente se ha especificado, “false” si
no.
Regresa “true” si el borde del objeto está
pintado, regresa “false” de lo contrario.
Regresa “true” si el componente está
habilitado o “false” si no.
Regresa “true” si el componente está
seleccionado o “false” si no.
text – Es una cadena que se pondrá como
texto.
aFlag – bandera “true” para hacer que este
Página 92
ITM Unidad II Controles, Eventos, Métodos y Componentes
void setEnabled (boolean b)
componente sea visible, bandera “false”
para que no sea visible.
“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:
Instituto Tecnológico de Morelia.
Página 93
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Figura 2.18 Aplicación en ejecución.
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.
Instituto Tecnológico de Morelia.
Página 94
ITM Unidad II Controles, Eventos, Métodos y Componentes
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”.
Instituto Tecnológico de Morelia.
Página 95
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 96
ITM Unidad II Controles, Eventos, Métodos y Componentes
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
evt) {
void
Boton1MouseClicked(java.awt.event.MouseEvent
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
Instituto Tecnológico de Morelia.
Página 97
ITM Unidad II Controles, Eventos, Métodos y Componentes
Figura 2.21 Aplicación en ejecución.
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)
Instituto Tecnológico de Morelia.
Página 98
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 99
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 100
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 101
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 102
ITM Unidad II Controles, Eventos, Métodos y Componentes
Figura 2.26 Aplicación en ejecución.
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.
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.
8
Instituto Tecnológico de Morelia.
Página 103
ITM Unidad II Controles, Eventos, Métodos y Componentes
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
Es una empresa de software famosa por ser la creadora del navegador web Netscape Navigator.
10
Instituto Tecnológico de Morelia.
Página 104
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 105
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 106
ITM Unidad II Controles, Eventos, Métodos y Componentes
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
Instituto Tecnológico de Morelia.
Página 107
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 108
ITM Unidad II Controles, Eventos, Métodos y Componentes
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.
Instituto Tecnológico de Morelia.
Página 109
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:
Instituto Tecnológico de Morelia.
Página 109
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 110
ITM Unidad III Sistemas 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:
Instituto Tecnológico de Morelia.
Página 111
ITM Unidad III Sistemas de Archivos
• 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
evt) {
void
leerArchivoMouseClicked(java.awt.event.MouseEvent
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:
Instituto Tecnológico de Morelia.
Página 112
ITM Unidad III Sistemas de Archivos
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");
Figura 3.1 Programa en ejecución.
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).
Instituto Tecnológico de Morelia.
Página 113
ITM Unidad III Sistemas de Archivos
• 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");
}
}
Instituto Tecnológico de Morelia.
Página 114
ITM Unidad III Sistemas de Archivos
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.
Figura 3.2 Programa en ejecución.
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.
Instituto Tecnológico de Morelia.
Página 115
ITM Unidad III Sistemas de Archivos
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:
Instituto Tecnológico de Morelia.
Página 116
ITM Unidad III Sistemas de Archivos
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
read()
write()
readLine()
writeLong()
readShort()
readLong()
readInt()
Función
Lee un byte de información del archivo.
Escribe un byte específico en el archivo.
Lee la siguiente Línea de texto del archivo.
Escribe un dato tipo long en el archivo.
Lee un número con signo de 16 bits del archivo.
Lee un dato tipo long del archivo.
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 );
Instituto Tecnológico de Morelia.
Página 117
ITM Unidad III Sistemas de Archivos
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
archivo");
}
}
Instituto Tecnológico de Morelia.
al
Abrir
el
Página 118
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 119
ITM Unidad III Sistemas de Archivos
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:
Instituto Tecnológico de Morelia.
Página 120
ITM Unidad III Sistemas de Archivos
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...
}
Instituto Tecnológico de Morelia.
Página 121
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 122
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 123
ITM Unidad III Sistemas de Archivos
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
guardarArchivoMouseClicked(java.awt.event.MouseEvent
void
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
Instituto Tecnológico de Morelia.
Página 124
ITM Unidad III Sistemas de Archivos
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".
Instituto Tecnológico de Morelia.
Página 125
ITM Unidad III Sistemas de Archivos
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
evt) {
void
abrirArchivoMouseClicked(java.awt.event.MouseEvent
JFileChooser fileChooser = new JFileChooser();
int valor = fileChooser.showDialog(fileChooser,
"Abrir Imagen");
Filtro imagenes = new Filtro();
fileChooser.addChoosableFileFilter(imagenes);
}
Instituto Tecnológico de Morelia.
Página 126
ITM Unidad III Sistemas de Archivos
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";
Instituto Tecnológico de Morelia.
Página 127
ITM Unidad III Sistemas de Archivos
// 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
Instituto Tecnológico de Morelia.
Propósito
Página 128
ITM Unidad III Sistemas de Archivos
JFileChooser()
JFileChooser(File, FileSystemView)
JFileChooser(File)
JFileChooser(FileSystemView)
JFileChooser(String, FileSystemView)
JFileChooser(String)
int showOpenDialog(Component)
int showSaveDialog(Component)
int showDialog(Component, String)
Crea un ejemplar de JFileChooser.
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
void ensureFileIsVisible(File)
void setCurrentDirectory(File)
File getCurrentDirectory
void changeToParentDirectory()
void rescanCurrentDirectory()
Propósito
Fuerza el archivo indicado a ser
visible en la lista de archivos.
Selecciona u obtiene el directorio
cuyos archivos se están mostrando en
el selector de archivos.
Cambia la lista para mostrar el
directorio padre del directorio actual.
Comprueba el sistema de archivos y
actualiza la lista del selector.
Personalizar el Selector de Archivos
Método
JComponent getAccessory()
void setAccessory(JComponent)
void setFileFilter(FileFilter)
FileFilter getFileFilter()
void setFileView(FileView)
FileView getFileView()
FileFilter[] getChoosableFileFilters()
void setChoosableFileFilters
(FileFilter[])
void addChoosableFileFilter(FileFilter)
boolean removeChoosableFileFilter
(FileFilter)
void resetChoosable(FileFilter)
FileFilter getAcceptAllFileFilter()
void setFileHidingEnabled(boolean)
boolean isFileHidingEnabled()
Propósito
Selecciona u obtiene el accesorio del
selector de archivos.
Selecciona u obtiene el filtro primario
del selector de archivos.
Selecciona u obtiene el visor de
archivos del selector.
Selecciona, obtiene o modifica la lista
de filtros seleccionables.
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
void setFileSelectionMode(int)
Instituto Tecnológico de Morelia.
Propósito
Selecciona el modo de selección de
Página 129
ITM Unidad III Sistemas de Archivos
int getFileSelectionMode()
archivos. Los valores aceptables son
boolean isDirectorySelectionEnabled() FILES_ONLY,
DIRECTORIES_ONLY,
y
boolean isFileSelectionEnabled()
FILES_AND_DIRECTORIES.
void setMultiSelectionEnabled
Selecciona u obtiene si se pueden
(boolean)
seleccionar varios archivos a la vez.
boolean isMultiSelectionEnabled()
void setSelectedFile(File)
Selecciona u obtiene el archivo
File getSelectedFile()
actualmente seleccionado.
void setSelectedFiles(File[])
Selecciona u obtiene los archivos
File[] getSelectedFiles()
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.
Instituto Tecnológico de Morelia.
Página 130
ITM Unidad III Sistemas de Archivos
private
evt) {
void
crearRAFMouseClicked(java.awt.event.MouseEvent
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){ }
Instituto Tecnológico de Morelia.
Página 131
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 132
ITM Unidad III Sistemas de Archivos
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
Instituto Tecnológico de Morelia.
Página 133
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 134
ITM Unidad III Sistemas de Archivos
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
2
3
7
8
9
10
11
12
13
12
12
14
13
Descripción del campo
Tipo de producto
Tipo de solicitud
NSS
CURP
Ap. Paterno
Ap. Materno
Nombres
Telefono casa
Telefono oficina
Telefono celular
Telefono patrón
Extension oficina
Extension patron
Tipo de dato
Numérico
Numérico
Numerico
CHAR
CHAR
CHAR
CHAR
CHAR
CHAR
CHAR
CHAR
CHAR
CHAR
Longitud
6
6
11
18
40
40
40
20
20
20
20
6
6
Pos Inicial
1
7
13
24
42
82
122
162
182
202
222
242
248
Pos Final
6
12
23
41
81
121
161
181
201
221
241
247
253
Comentarios
1 AFORE
1 Afiliación 2 Traspaso
número de seguro social
Clave CURP
Apellido Paterno
Apellido Materno
Nombres
Teléfono del domicilio del trabajador
Teléfono de la oficina del trabajador
Teléfono celular del trabajador
Teléfono del jefe el trabajador
Extensión de oficina del trabajador
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
Instituto Tecnológico de Morelia.
Página 135
ITM Unidad III Sistemas de Archivos
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.
Instituto Tecnológico de Morelia.
Página 136
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.
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.
14
Instituto Tecnológico de Morelia.
Página 138
ITM Unidad IV Acceso a Datos
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
Instituto Tecnológico de Morelia.
Página 139
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 140
ITM Unidad IV Acceso a Datos
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).
Instituto Tecnológico de Morelia.
Página 141
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 142
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 143
ITM Unidad IV Acceso a Datos
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",
Instituto Tecnológico de Morelia.
Página 144
ITM Unidad IV Acceso a Datos
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"
Instituto Tecnológico de Morelia.
Página 145
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 146
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 147
ITM Unidad IV Acceso a 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
public
public
public
static
static
static
static
String
String
String
String
bd = "test"; //Nombre de la BD
login = "root"; //usuario
password = "entrar"; //Contraseña
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.
Instituto Tecnológico de Morelia.
Página 148
ITM Unidad IV Acceso a Datos
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
Instituto Tecnológico de Morelia.
Página 149
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 150
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 151
ITM Unidad IV Acceso a Datos
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() {
Instituto Tecnológico de Morelia.
Página 152
ITM Unidad IV Acceso a Datos
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);
}
}
Instituto Tecnológico de Morelia.
Página 153
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 154
ITM Unidad IV Acceso a Datos
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
Instituto Tecnológico de Morelia.
Página 155
ITM Unidad IV Acceso a 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
18
Active Server Pages, tecnología de Microsoft del tipo “lado servidor” para páginas web dinámicas.
Estándar para manejo de bases de datos creado por Microsoft.
Instituto Tecnológico de Morelia.
Página 156
ITM Unidad IV Acceso a Datos
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:
Instituto Tecnológico de Morelia.
Página 157
ITM Unidad IV Acceso a Datos
<% 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:
Instituto Tecnológico de Morelia.
Página 158
ITM Unidad IV Acceso a Datos
<% 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.
Instituto Tecnológico de Morelia.
Página 159
ITM Unidad IV Acceso a 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
Instituto Tecnológico de Morelia.
Página 160
ITM Unidad IV Acceso a Datos
desplazamientos y cambios realizables en los datos. El tipo de cursor lo
definiremos mediante la propiedad CursorType, los posibles valores son:
Denominación
valor
adOpenForwardOnly
0
adOpenKeyset
1
adOpenDynamic
2
adOpenStatic
3
Características
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.
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.
Nos permite movernos en los dos sentidos,
si permite modificaciones en los registros.
Vemos todos los cambios realizados en la
tabla por otro recordset.
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
adLockReadOnly
1
dLockPessimistic
2
adLockOptimistic
3
Características
Es el que está por defecto; no permite al
usuario modificar los datos de la tabla.
Cuando se abra la tabla nadie más podrá
hacerlo, este modo nos asegura la plena
integridad de los datos.
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.
Instituto Tecnológico de Morelia.
Página 161
ITM Unidad IV Acceso a Datos
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
Move Num_registros
MoveFirst
MoveLast
MoveNext
MovePrevious
Características
Mueve el cursor Num_registros hacia abajo si
es positivo y hacia arriba si es negativo.
Mueve el cursor al primer registro del
Recordset.
Mueve el cursor al último registro del
Recordset.
Mueve el cursor un registro hacia adelante.
Mueve el cursor un registro hacia atrás.
Tabla 4.3 Métodos pa moverse en un Recorset
Propiedades usadas:
Propiedades
PageSize
(Ej. rs.Pagesize=10)
AbsolutePage
(Ej. rs.AbsolutePage=2)
PageCount
(Ej. xx=rs.PageCount)
Absoluteposition
(Ej.
rs.Absoluteposition=17)
RecordCount
(Ej. xx=rs.recordcount)
BOF
EOF
Caracteristicas
Establece el número de registros por página
del
Recordset.
Mueve el cursor al primer registro de dicha
página (es necesario definir anteriormente el
pageSize).
Contiene el número de páginas del recordset,
tomando como base PageSize.
Mueve el cursor al num_registro especificado.
Contiene el número de registros del recordset;
Nota:
No
funciona
con
el
cursor
adOpenForwardOnly
Toma el valor True cuando estamos en el
primer
registro del recordset
Toma el valor True cuando estamos en el
ultimo
registro del recordset
Instituto Tecnológico de Morelia.
Página 162
ITM Unidad IV Acceso a Datos
Tabla 4.4 Propiedades de un Recordset.
Modificando los datos
Métodos usados:
Metodo
AddNew
EJ.
rs.Addnew
rs("codigo")=1234
rs("titulo")="Todo sobre ASP"
rs.Update
Delete
Update
EJ:
Caracteristicas
Abre un nuevo registro en el recordset
para introducir
datos
Elimina el registro actual
Actualiza un registro del recordset tras
haberlo
modificado
rs("titulo")="Como hacerse rico en 10
minutos"
rs.Update
Tabla 4.5 Métodos usados para modificar datos de un RecordSet.
Abriendo y cerrando el recordset
Métodos usados:
Método
Open Sql, conexion
Caracteristicas
Abre el recordset y almacena en el
resultado de sql contra la conexión
EJ.
set
rs=createobject("ADODB.Recordset")
rs.CursorType = 1
rs.LockType = 3
Sqltxt="SELECT * FROM libros"
rs.open Sqltxt, "DSN=Biblioteca"
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
Instituto Tecnológico de Morelia.
Página 163
ITM Unidad IV Acceso a Datos
<%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
Instituto Tecnológico de Morelia.
Página 164
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 165
ITM Unidad IV Acceso a 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
Instituto Tecnológico de Morelia.
Página 166
ITM Unidad IV Acceso a Datos
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:
Instituto Tecnológico de Morelia.
Página 167
ITM Unidad IV Acceso a Datos
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:
Instituto Tecnológico de Morelia.
Página 168
ITM Unidad IV Acceso a Datos
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() */
}
Instituto Tecnológico de Morelia.
Página 169
ITM Unidad IV Acceso a Datos
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 */
Instituto Tecnológico de Morelia.
Página 170
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 171
ITM Unidad IV Acceso a Datos
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
ID
Nombre
AP
AM
Productos
ID
Nombre
Precio
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
Instituto Tecnológico de Morelia.
Página 172
ITM Unidad IV Acceso a Datos
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.
Instituto Tecnológico de Morelia.
Página 173
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.
Instituto Tecnológico de Morelia.
Página 175
ITM Unidad V Componentes y Controles Definidos por el Usuario
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
nuestros fines
'Indicamos al objeto la cadena de conexión
miconexion.ConnectionString = "DSN=midsn"
para
'Se abre la base de datos
miconexion.Open
' .......
'........
'Se cierra la base de datos
miconexion.Close
%>
Crear un componente
Instituto Tecnológico de Morelia.
Página 176
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 177
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 178
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 179
ITM Unidad V Componentes y Controles Definidos por el Usuario
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
Instituto Tecnológico de Morelia.
Página 180
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 181
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 182
ITM Unidad V Componentes y Controles Definidos por el Usuario
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
Alias "#60" (ByVal YourGuess As Long) As Long
"shell32"
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
Const
Const
Const
EWX_LOGOFF = 0
EWX_SHUTDOWN = 1
EWX_REBOOT = 2
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
Instituto Tecnológico de Morelia.
Página 183
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
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 =)
Control
Nuevo
Ventana del código del
formulario y métodos de
nuestro control.
Figura 5.9 Utilización de nuestro control.
Instituto Tecnológico de Morelia.
Página 184
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 185
ITM Unidad V Componentes y Controles Definidos por el Usuario
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
Instituto Tecnológico de Morelia.
Página 186
ITM Unidad V Componentes y Controles Definidos por el Usuario
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.
Instituto Tecnológico de Morelia.
Página 187
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.
Instituto Tecnológico de Morelia.
Página 188
ITM Apéndice 1 “Instalación de NetBeans”
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
Instituto Tecnológico de Morelia.
Página 189
ITM Apéndice 1 “Instalación de NetBeans”
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”
Instituto Tecnológico de Morelia.
Página 190
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:
Instituto Tecnológico de Morelia.
Página 191
ITM Apéndice 2 “Introducción a 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.
Instituto Tecnológico de Morelia.
Página 192
ITM Apéndice 2 “Introducción a MySQL”
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>
Instituto Tecnológico de Morelia.
Página 193
ITM Apéndice 2 “Introducción a 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).
Instituto Tecnológico de Morelia.
Página 194
ITM Apéndice 2 “Introducción a MySQL”
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>
Instituto Tecnológico de Morelia.
Página 195
ITM Apéndice 2 “Introducción a 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>
Instituto Tecnológico de Morelia.
Página 196
ITM Apéndice 2 “Introducción a 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).
Instituto Tecnológico de Morelia.
Página 197
ITM Apéndice 2 “Introducción a MySQL”
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>
Instituto Tecnológico de Morelia.
Página 198
ITM Apéndice 2 “Introducción a 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
CondiciónASatisfacer
FROM
DeQueTabla
WHERE
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;
Instituto Tecnológico de Morelia.
Página 199
ITM Apéndice 2 “Introducción a MySQL”
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.
Instituto Tecnológico de Morelia.
Página 200
ITM Apéndice 2 “Introducción a MySQL”
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.
Instituto Tecnológico de Morelia.
Página 201
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.
Instituto Tecnológico de Morelia.
Página 202
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.
Instituto Tecnológico de Morelia.
Página 203
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.
Instituto Tecnológico de Morelia.
Página 204
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.
Fecha de consulta: 03/ene/09
Instituto Tecnológico de Morelia.
Página 205
ITM
13. http://www.adictosaltrabajo.com/indexg.php?pagina=tutoriales
Tutoriales muy completos
Fecha de consulta: 10/ene/09
14. http://www.developer.com/java/
Información muy actualiza respecto al mundo de java.
Fecha de consulta: 27/ene/09
15. http://www.javahispano.org/canyamo.action
Uno de los sitios de java más completos que hay en español.
Fecha de consulta: 10/ene/09
16. http://www.programacion.net/java/
Otro buen sitio de java en español.
Fecha de consulta: 15/ene/09
17. http://www.exampledepot.com/
Aquí se puede disponer de muchos ejemplos sencillos.
Fecha de consulta: 08/ene/09
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/
Instituto Tecnológico de Morelia.
Página 206
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.
Fecha de consulta: 05/feb/09
21. http://mindprod.com/jgloss/jgloss.html
Glosario muy completo sobre java. Aunque el diseño de la página no es el mejor.
Fecha de consulta: 05/ene/09
22. http://java.dzone.com/
Pagina con foros, links e información sobre java muy confiables pero sobre temas
avanzados del lenguaje.
Fecha de consulta: 17/ene/09
23. http://www.javasoft.com
Fuente confiable y completa.
Fecha de consulta: 01/feb/09
24. http://www.prenhall.com/deitel
Pagina con la cual se complementa la información que viene en la obra de deitel.
Fecha de consulta: 03/ene/09
25. http://es.wikipedia.org/wiki/Java
Instituto Tecnológico de Morelia.
Página 207
ITM
La información consultada es buena.
Fecha de consulta: 10/feb/09
26. http://www.java.com
Página oficial, descargas, ayuda, ¿Qué es java?
Fecha de consulta: 09/feb/09
27. www.manual-java.com
Manual muy completo, sección de FAQ, Foros, Código, etc.
Fecha de consulta: 10/feb/09
28. www.webtaller.com/manual-java
Manual paso a paso de Java. Muy recomendable para alguien que comienza a
introducirse en el tema.
Fecha de consulta: 10/feb/09
29. http://todojava.awardspace.com/manuales-java.html
Manuales de java
Fecha de consulta: 10/feb/09
30. www.itapizaco.edu.mx/paginas/Javatut/froufe/introduccion/indice.html
Tutorial muy bueno para principiantes en java.
Fecha de consulta 10/feb/09
Instituto Tecnológico de Morelia.
Página 208
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.
Instituto Tecnológico de Morelia.
Página 209
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
Instituto Tecnológico de Morelia.
Página 210
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
Instituto Tecnológico de Morelia.
Página 211
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)
Instituto Tecnológico de Morelia.
Página 212
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)
Instituto Tecnológico de Morelia.
Página 213
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.
Instituto Tecnológico de Morelia.
Página 214
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
Instituto Tecnológico de Morelia.
Página 215
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.
Instituto Tecnológico de Morelia.
Página 216
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
Instituto Tecnológico de Morelia.
Página 217
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
Instituto Tecnológico de Morelia.
Página 218
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
Instituto Tecnológico de Morelia.
Página 219
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
Instituto Tecnológico de Morelia.
Página 220
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.
Instituto Tecnológico de Morelia.
Página 221