Comienza a programar en Java

¿Qué es Java?

Breve historia de Java

¿Cómo empiezo a programar en Java?

Nociones básicas

Prepararse para usar el JDK

El primer proyecto

¿Qué es Java?

Java es un lenguaje de programación de alto nivel de propósito general, multiplataforma, semicompilado, orientado a objetos y multihilo.

¿Qué quiere decir multiplataforma y semicompilado?

Un programa es un conjunto de órdenes que ejecuta un procesador; estas órdenes dependen de cada procesador, por tanto un programa hecho para un procesador no será entendido por otro procesador; del mismo modo un programa hecho para un Sistema Operativo no se ejecutará en una máquina con otro Sistema Operativo ya que los programas a menudo hacen llamadas al Sistema Operativo para, por ejemplo saber los archivos de un directorio, realizar una conexión TCP/IP, utilizar la pantalla, ... Java es independiente de la máquina y del Sistema Operativo lo que permite ejecutar un programa hecho en Java en, por ejemplo, un ordenador con Linux o Windows, en un PDA, en un teléfono móvil, ...

Para conseguir esto el código fuente se compila a un lenguaje que no es específico de la plataforma, sino que es un código intermedio denominado "bytecode". Este código no es ejecutado directamente, ya que no es comprendido por la máquina, sino que es interpretado por un programa denominado Máquina Virtual o más específicamente JVM (Máquina Virtual de Java). La JVM es específica de la plataforma. De esta forma para ejecutar un programa Java sólo necesitamos la máquina virtual de la plataforma que estemos usando. Así por ejemplo existen máquinas virtuales para Sistemas Operativos Windows, Linux, Apple y Solaris. Seguramente en tu ordenador tendrás instalada una máquina virtual y ni si quiera te has dado cuenta: la mayor parte de los navegadores o browsers web tienen una instalada para poder visualizar los applets, que son pequeñas aplicaciones Java que se incrustan en las páginas web.

La WWW (World Wide Web) es una inmensa red de ordenadores de todo tipo y dado que Java es un lenguaje multiplataforma se hace ideal para superar los problemas de incompatibilidad.

Un lenguaje interprteado es siempre lento, pero las actuales JVM utilizan un JIT (Just in Time). El JIT se encarga de compilar el código aún más para reducirlo, reduciendo también de este modo el tiempo de ejecución. Estos JIT en determinadas ocasiones pueden hacer que el código no sea correctamente

ejecutado. Si quieres ver tus applets tal cual los has programado puedes usar el browser que proporciona Sun Microsystems: Hot Java.

¿Qué quiere decir de propósito general?

Es un lenguaje de propósito general ya que con él se pueden hacer multitud de cosas: crear tanto programas simples de consola hasta grandes programas en entorno gráfico, hacer los bonitos applets que lucen en las páginas web, los servlets (programas cliente-servidor más potentes que los clásicos CGI), las JSP (Java Server Pages, similares a las páginas PHP o ASP), los sockets (programas para redes de ordenadores)...

¿Qué quiere decir orientado a objetos?

Algunos lo califican de lenguaje de objetos ya que no es un lenguaje adaptado como C++ que desciende de C, sino es un lenguaje que desde el principio ha sido de objetos: (casi) todo en él son objetos.Anteriormente al crear programas grandes en C éstos se hacían inmanejables ya que unas líneas de código afectaban al resultado de otras y era muy difícil su actualización y posterior reutilizacón del código. Cuando nació C++, para crear una ventana bastaba una línea de código en la que se expecifica el tamaño, el texto de título, etc.., en cambio en C eran necesarias 5 páginas de código. Lo que se hace en la orientación de objetos es meter todas esas líneas de código en un archivo aparte y nos olvidamos de él. Posteriormente podremos reutilizar ese código vínculándolo a nuestro programa, e incluso crear un tipo de ventanas nuevas por medio de la herencia, así podremos hacer ventanas que no puedan ser redimensionadas, como los cuadros de diálogo. De esta forma los programas son más estructurados y reutilizables.

Pero, ¿qué es un objeto?

Básicamente un objeto es un conjunto de variables y funciones interrelacinados. En un objeto las variables que guardan los valores de sus características se llaman propiedades y las funciones se llaman métodos. Los lenguajes orientados a objetos son más fáciles de programar ya que se acercan más a nuestra forma de pensar, así si creamos un objeto 'vehículo terrestre', una de sus propiedades sería su color, su número de ruedas, su velocidad,... Y un método sería acelerar, frenar, que cambiarían las propiedades del objeto: en estos dos casos la velocidad. Además gracias a la 'herencia' podríamos crear un nuevo tipo de vehículos que podríamos clasificar en coches, camiones, motos,... que poseerían las mismas propiedades y los mismos métodos que un 'vehículo terrestre' más algunos característicos de ese tipo de 'vehículo terrestre', como por ejemplo un método 'descargar' en el caso de los camiones, y un número de ruedas diferentes.

La orientación a objetos y la máquina virtual de Java

Gracias a la orientación a objetos y la máquina virtual de Java es posible descargar un programa de la red en pocos segundos ya que los programas que creamos, en general, se basan todos ellos en las clases que incorpora la máquina virtual de Java (algo así como los archivos de librerías). Es decir, todos los archivos necesarios para que el programa funcione ya los incorpora la máquina de destino, los posee la JVM. De esta forma los programas en Java son robustos y potentes.

La seguridad en Java

Puede suponer que un applet es un programa que se incluye en una página web, y un virus también es un programa, y por tanto Java pueda ser el lenguaje perfecto para los creadores de virus. Pues no, una de las características principales de Java es su seguridad. Cierto que se pueden incluir programas en una página web y que un virus es un programa, pero la JVM le informará cuando el programa intente hacer algo dudoso, como puede ser la utilización de archivos de nuestro disco duro.

Breve historia de Java

Java nació como iniciativa de Sun de crear un lenguaje para electrodomésticos. Para ello tenía que crear un lenguaje independiente de la plataforma, ya que el chip de una calculadora no es el mismo que el de un televisor, por ejemplo. Este se llamó OAK, pero la idea no resultó y casi cuando se iba a rechazar el proyecto un programador tuvo la brillante idea de crear un navegador web que soportara incrustar aplicaciones Java denominadas applets. Desde el primer momento se puede apreciar la capacidad de este lenguaje: el navegador estaba hecho en Java. Sun Microsystems le cambió el nombre porque "OAK" ya estaba registrado y eligió Java, que es como se llamaba el Café en el que se reunían los progrmadores de esta empresa. La idea de incrustar pequeñas aplicaciones en las páginas webs tuvo una tremenda aceptación, lo que impulsó y popularizó a este lenguaje. Hay que tener en cuenta que aunque Java debe su popularidad a Internet y está enormemente vinculado a ella, la WWW no es su único lugar ni su única capacidad, ni mucho menos.

¿Cómo empiezo a programar en Java?

Es imprescindible bajarse un compilador. Recomiendo el Java 2 Standard Development Kit de Sun Microsystems, disponible para Windows, Linux y Solaris. Contiene lo necesario para empezar a programar en Java y es gratis, aunque la licendia impide su redistribución. Contiene un compilador, un visualizador de Applets, un debugger, un decompilador,... hasta 15 programas. Todos los programas que incorpora se deben ejecutar en la consola ya que no tienen interfaz gráfica, lo que resulta un tanto engorroso, y no contiene un editor, por tanto deberéis escribir vuestros proyectos con un editor de texto convencional, como por ejemplo el Bloc de Notas, aunque tambi&eeacute;n existen programas que resaltan con colores las palabras reservadas del lenguaje, los comentarios,... que hacen un poco más agradable la tarea de programar. Aunque la programación sin un entorno de desarrollo que nos permita hacer muchas cosas con unos simples clicks de ratón es muy pesada, es como realmente se aprende.

Actualmente se distribuye el J2SDK junto con el JRE y se van añadiendo API's que antes se distribuían por separado. El JRE es también un conjunto de aplicaciones, en este caso estas aplicaciones son exclusivamente para ejecutar los programas. El JRE está destinado al usuario final de la aplicación. La licencia permite su redistribució así es una buena idea empaquetarlo junto con nuestras aplicaciones.

Para aquellos que vayan a programar en Windows Me se preguntarán ¿cómo voy a programar si necesito MS-DOS? La respuesta es fácil. Windows Me sigue teniendo MS-DOS pero está "oculto". Para ejecutar comandos deberemos crear un

archivo de texto normal (con el Bloc de Notas por ejemplo) escribir los comandos a ejecutar y guardarlo con extensión ".bat". Para editar estos archivos basta con hacer click derecho y elegir en el menú contextual la opción "Edición".

Nociones básicas Prepararse para usar el JDK

Lo primero que debemos hacer, claro está es descargarse el Java 2 Standard Development Kit desde la página de Sun. Es opcional pero tremendamente recomendado bajarse la documentación que está en Inglés. En él se incluye también un archivo de texto: README que recopila la información de instalación y uso, y que está en inglés. Posteriormente procederemos a instalarlo; este proceso es sencillo, basta con indicar lo que se quiere instalar y dónde. Para incluir la documentación (opcinal), una vez la hallamos descargado, se deberá extraer la carpeta 'docs' y pegarla en el directorio donde se instaló el J2SDK.

¿Qué es el path y el classpath?

Este paso es opcional pero muy útil.Para una cómoda utilización de los programas del kit se puede cambiar la variable de entorno 'path' y otra variable: el 'classpath'. La primera de ellas contiene la ruta de acceso de los programas que con más frecuencia uses, de modo que para ejecutar un programa bastará con escribir su nombre y Windows lo buscará, de este modo nos ahorramos tener que escribir toda la ruta de directorios hasta llegar a &eeacute;l. La segunda indica al JDK dónde debe buscar los archivos a compilar o ejecutar, sin tener que escribir en cada ejecución la ruta completa.

Así se ejecutaría el compilador de java sin haber cambiado las variables, en MS-Dos y con el JDK instalado en el directorio C:\jdk1.3 y la clase a compilar de nombre 'miclase.java' en C:\proyectosJava:

C:\>C:\jdk1.3\bin\javac C:\proyectosJava\miclase.java

Así se escribiría si se cambian adecuadamente las variables:

C:\>javac miclase.java

Es decir, no sería necesario incluir la ruta de acceso del programa ni del archivo a compilar.

Cambiar el path

Para saber que valores contiene la variable path escribiremos lo siguiente:

C:\>path

Y se listarán los valores que actualmente posee separados por ';'. Normalmente serán: 'C:\Windows' y 'C:\Windows\COMMAND'. Para añadirle el directorio que contiene los programas del JDK ('C:\jdk1.3\bin' por defecto) lo más cómodo y

sencillo es editar con un procesador de textos (por ejemplo el Bloc de Notas o el WordPad) el archivo 'C:\Autoexec.bat'. En él aparecerán los valores anteriores separados por ';'. Bastará con añadir el nuestro ('C:\jdk1.3\bin') separado por un ';', y guardarlo. Es recomendable poner nuestro directorio al principio en lugar de añadirlo al final, ya que si queremos ejecutar el programa javaw.exe del JDK el intérprete de comandos buscará el programa en los directorios definidos en la variable de entorno PATH y encontrará un programa de mismo nombre en el directorio C:\Windows que no es el que nosotros queremos ejecutar.

Para terminar habrá que reiniciar el ordenador. Con esto lo que conseguimos es definir la variable path cada vez que se ejecuta el archivo Autoexec.bat, es decir cada vez que se inicia Windows.

Cambiar el classpath

Para saber qué valores contiene el CLASSPATH (no contiene ninguno por defecto) bastará con teclear

C:\>set

y aparecerá la lista de variables de entorno con sus correspondientes valores. Si no aparece la variable CLASSPATH quiere decir que ésta no contiene ningún valor. Entre ellas se encuentra también la variable de entorno path.

Para asignarle un valor teclearemos lo siguiente en una ventana de MS-DOS:

C:\>set CLASSPATH=C:\MisClasesDeJava

Siendo MisClasesDeJava el directorio donde tenemos nuestras clases de Java.Para introducir varios directorios los separaremos por punto y coma:

C:\>set CLASSPATH=C:\MisClasesDeJava;C:\MisOtrasClasesDeJava

Finalmente si la variable CLASSPATH ya contiene valores y queremos añadir más tendremos que hacerlo del siguiente modo:

C:\>set CLASSPATH=C:\MisClasesDeJava;%CLASSPATH%

Otra cosa a tener en cuenta es que normalmente desearemos apuntar a una clase que se encuentra en el mismo directorio; si en la variable classpath no está incluido específicamente ese directorio el programa no la encontrará aunque como se ha dicho el archivo esté en el mismo directorio. Esto se puede remediar incluyendo el directorio acutal de forma relativa, es decir el intérprete de comandos, tanto en MS-DOS como en Unix, utiliza "." como forma de apuntar al directorio actual así como ".." para indicar el directorio inmediatamente superior. (Así con el comando "cd" cambiamos de directorio, y al hacer cd .. cambiamos al directorio superior). La forma de cambiar la variable CLASSPATH con los valores que ya contiene, el directorio actual y el directorio C:\MisClasesDeJava sería así:

C:\>set CLASSPATH=.;C:\MisClasesDeJava;%CLASSPATH%

Si queremos definir la variable CLASSPATH cada vez que iniciemos Windows basta con añadir el comando set, con los valores adecuados como se ha visto, al archivo C:\Autoexec.bat como se indicaba con la variable PATH.

El primer proyecto

El código fuente se debe escribir en un archivo de texto plano, es decir sin formato, para lo que recomiendo usar el Bloc de Notas o WordPad en caso de Windows. Éste debe ser guardado en un archivo, de nombre el de la clase que estemos creando, y de extensión '.java'.

Habrá que tener en cuenta al escribir el código que Java es sensible a las mayúsculas y minúsculas, lo que quiere decir que 'Hola' no es lo mismo que 'hola'. Al escribir código es muy conveniente comentarlo, sobre todo si vamos a compartirlo con otros desarrolladores o para futuras actualizaciones.

Comentar y documentar el código

En Java existen tres tipos de comentarios: los que soportan sus antecesores C y C++ y uno muy importante y novedoso: el cometario de documentación.

"//" Es el comentario de C. Indica que todo lo que viene a continuación de la línea es un comentario."/*" y "*/" Es el comentario de C++. Indica que todo lo comprendido entre estos dos signos es un comentario. Puede ser multilínea, no así el anterior.

Aquí hay un ejemplo en el que se usan estos dos tipos de comentarios:

// este es un comentario de C. El compilador omitirá lo que aparezca a su derecha

/*este es un comentario de varias líneasde esta forma omitirá también esta líneay esta*/

Se pueden usar combinaciones de comentarios, pero no se admiten comentarios anidados como este:

//Esta línea será omitida por el compilador así que saltará directamente a la siguiente. /*Así que esta cabecera de comentario no la veráy se creerá que esta línea es códigoy esta también*/

Existe un tipo de comentario muy, muy útil que es introducido por Java: se trata del comentrio de documentación que usa el programa javadoc para crear documentación en formato HTML. De esta forma podremos documentar elegante y rápidamente nuestras clases.

Un comentario de documentación comienza con "/**" y termina con "*/" y cada línea debe comenzar con "*".En un comentario de este tipo podremos insertar etiquetas HTML aunque esto no sea necesario, ya que el programa javadoc crea documentos muy vistosos.Para indicarle al programa sobre qué estamos escribiendo existen las "etiquetas de documentación" que son básicamente las siguientes:

Etiqueta Explicación Sintaxis

@version Indica la versión del código que estamos escribiendo.

@version Datos de la versión

@authorIndica el autor del código. Podemos poner varios autores de la siguiente forma:

@author datos del autor@author datos de otro autor que haya intervenido

@param Indica que a continuación se explica el valor de un parámetro.

@param parametro1linea 1(...)linea n@param parmetro2linea1(...)linea n

@return Indica que a continuación se explica el valor de retorno de un método.

@return parametro1linea 1(...)linea n

@exception Indica las excepciones que la clase puede manejar.

@exception Nombre de la clase y decripcion

@throws Es sinónimo de la etiqueta anterior.

@throws Nombre de la clase y decripcion

@see Sirve para hacer referencia a otras clases.

@see nombre de clase@see nombre de clase completo@see nombre de clase completo#nombre de metodo

Ejemplo de comentario de documentación:

/***@version Version 1.0 de mi primera clase*@author Yo pr supuesto*<a href="mailto:yo@micompania.com">Mi e-mail</a>*(...)*/

Visualizar applets

Para ejecutar un applet debemos crear una página web en la que poder visualizarlo. La etiqueta para introducir un applet es la siguiente:(las etiquetas entre corchetes pueden ser omitidas)

<applet [propiedades]>[parametros][Texto que se visualizara en caso de que el browser no soporte los

applets] </applet>

Dónde propiedades son:

Propiedad

Explicación

code Indica el archivo en el cual reside el bytecode a ejecutar. Los archivos .class

codebase Indica el directorio donde se encuentra el archivo de bytecode

height Indica la altura del applet

width Indica la anchura del applet

altTexto que se visualizará en la zona del applet en caso de que el browser soporte los applets, pero no pueda cargarlo por alguna razón.

name Nombre del applet. Sirve para hacer llamadas entre applets.

align Especifica la posición del applet (Left, right, top, bottom, middle, baseline, textop, absmiddle, absbottom).

vspace Márgen por encima del applet.

hspace Márgen a los lados del applet.

Las propiedades realmente importantes son: code, height y width. Las demás pueden ser omitidas. codebase es realmente importante pero si el archivo está en el mismo directorio se omite.

Los parámetros son valores que se pasan al applet y tienen la siguiente sintáxis:

<param name="nombre_del_valor" value="valor_del_parametro">

Existe un truco al visualizar los applets. Sería muy costoso crear una página web para cada applet y poder así verlos en el navegador o en el appletviewer, así que incluiremos en el archivo de código (.java) las etiquetas HTML pero dentro de un comentario, de este modo el comilador las ignorará pero el appletviewer podrá

encontrarlas.

Este sería un ejemplo:

Este sería el código del archivo miclase.java:

import java.awt.*;import java.awt.applet.*;...

/*<applet code="miclase.class" width="300" height="300"></applet>*/

public class miclase extends Applet ...{

      ...

}

Este sería el comando a ejecutar en la ventana de MS-DOS:

C:\>appletviewer miclase.java

COMO CONECTAR JAVA Y ACCES

JDBC y ODBC

La capacidad para acceder a bases de datos desde Java la ofrece la API JDBC (Java DataBase Conectivity). JDBC es un estándar para manejar bases de datos en Java. ODBC es un estándar de Windows para manejar bases de datos, de forma que cualquier programa en Windows que desee acceder a bases de datos genéricas debe usar este estándar. La necesidad de crear un estándar propio para acceder a bases de datos desde Java se explica porque el estándar ODBC está programado en C y un programa que use este estándar, por lo tanto, depende de la plataforma.

Controladores JDBC-ODBC

Necesitamos acceder a un origren de datos ODBC pero contamos con una API que usa el estándar JDBC. Para solventar este problema las empresas realizan drivers que traducen el ODBC a JDBC. Hay varios tipos de Driver, pero para nuestro ejemplo usaremos los llamados puentes JDBC-ODBC. Estamos de suerte porque el JDK de Windows incorpora el driver necesario para conectar bases de datos Access.

Crear un nuevo DSN (Data Source Name)

Para realizar la conexión a una base de datos ODBC necesitaremos crear un perfil DSN desde el panel de control y posteriormente accederemos a la base de datos a partir del nombre del perfil. En el perfil DSN lo que se hace es indicar el driver a utilizar, así como el archivo o archivos del origen de datos. Estos son los pasos a llevar a cabo para configurar un perfil DSN.

1.- Iremos a Panel de Control. Ello se hace desde Inicio->Configuración o desde MiPC.

2.- Ahora hacemos doble-click en el icono de Fuentes de datos ODBC (32 bits).

3.- En nuestra pantalla aparecerá ahora la pestaña DSN usuario seleccionada. Para crear un nuevo perfil haremos click en Agregar...

4.- A continuación se nos pide que ingresemos el controlador que vamos a usar en el nuevo perfil. En nuestro caso será Microsoft Access Driver (*.mdb).

5.- Una vez aquí sólo nos queda dar un nombre al origen de datos y especificar el archivo .mdb de origen. Tras aceptar la ventana ya tenemos creado un perfil con lo que ya podemos comenzar a programar.

Clases, objetos y métodos básicos

Lo que necesitamos para hacer nuestro programa es la API JDBC incluida en la última versión del JDK. El paquete a utilizar y el cual deberemos importar es el paquete java.sql

Las primeras líneas de código suelen ser rutinarias ya que siempre serán muy similares.

Cargar el Driver

Lo primero es hacer una llamada al Driver JDBC-ODBC para cargarlo. Eso se consigue con las siguientes líneas de código:

try{Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); }catch(Exception e){ System.out.println("No se ha podido cargar el Driver JDBC-ODBC"); }

Con esto ya tenemos cargado el Driver. Ahora básicamente trabajaremos con tres objetos. Estos objetos son: Connection, Statement y ResultSet. El objeto Connection se obtiene al realizar la conexión a la base de datos. El objeto Statement se crea a partir del anterior y nos permite ejecutar SQL para hacer consultas o modificaciones en la base de datos. En caso de hacer una consulta (SELECT ... FROM ...) se nos devolverá un objeto que representa los datos que deseamos consultar; este objeto es un objeto ResultSet (Hoja de resultados).

El objeto Connection

Debemos realizar la conexión a nuestro origen de datos. Para ello debemos crear un objeto Connection de la siguiente forma:

Connection con = DriverManager.getConnection("jdbc:odbc:Nombre_Perfil_DSN", "Nombre_Usuario", "Contraseña");

Los dos últimos parámetros pueden ser cadenas vacías "" a no ser que la base de datos las requiera. Con esto ya hemos realizado una conexión a nuestra base de datos. Pero esto todavía no es suficiente. Ahora vamos a crear un objeto Statement con el que podremos ejecutar y hacer consultas SQL. Si hasta ahora todo ha sido rutinario a partir de ahora vamos a poder crear código más adaptado a las necesidades de nuestro programa.

El objeto Statement

Como se ha dicho, un objeto Statement se crea a partir del objeto Connection antes obtenido. También como se ha dicho un objeto Statement nos permite hacer consultas SQL que nos devuelven una hoja de resultados. Pues bien, según como deseamos que sea esa hoja de resultados (modificable, o no, sensible a las modificaciones o no,...) deberemos crear de una forma u otra el objeto Statement. Más adelante se explican las diferencias entre crearlos de una u otra forma. De momento nos limitaremos ha hacerlo de la forma más sencilla.

Statement stat = con.createStatement();

De esta forma muy simple hemos creado un objeto Statement. Ahora podemos usar este objeto Statement para hacer modificaciones en la base de datos a través del lenguaje SQL. Para realizar modificaciones, es decir, instrucciones INSERT, UPDATE o DELETE, se usa el método executeUpdate pasando como parámetro una cadena de texto String que contenga la instrucción SQL.

Para hacer una consulta, es decir, una instrucción SELECT debemos usar otro método: el método executeQuery que como el anterior se le ha de pasar un String que contenga la instrucción. Este método nos devuelve un objeto ResultSet que contiene los datos obtenidos. Este objeto será diferente según como hayamos creado el objeto Statement. En el ejemplo anterior hemos usado un método muy simple de Connection para crear el objeto Statement, pero hay otras formas de crearlo. Estas son y estas son las características que aportan a la hoja de resultados de una consulta:

El método anteriormente utilizado es el siguiente: createStatement(), pero existe el mismo método al que le podemos pasar dos parámetros. En la documentación se expresa así: createStatement(int resultSetType, int resultSetConcurrency). Los posibles valores a pasar son campos de la clase ResultSet. Por ejemplo para el parámetro resultSetType podemos elegir que el objeto ResultSet se pueda mover (entre registros) sólo hacia delante (ResultSet.TYPE_FORWARD_ONLY), que se pueda mover pero que cuando se actualice, aunque los cambios ya hayan sido reflejados en la base de datos, el ResultSet no los 'sienta' (ResultSet.TYPE_SCROLL_INSENSITIVE) o que se pueda mover y que los cambios si que se reflejen también en él (ResultSet.TYPE_SCROLL_SENSITIVE). Para el parámetro resultSetConcurrency podemos establecer dos valores diferentes: ResultSet.CONCUR_READ_ONLY si queremos que los datos se puedan leer pero no actualizar, y ResultSet.CONCUR_UPDATABLE si queremos permitir que la base de datos sea actualizable mediante el objeto ResultSet. Si no se usa el método sin parámetros el objeto será TYPE_FORWARD_ONLY y CONCUR_READ_ONLY.

El objeto ResultSet: Hoja de resultados

Moverse por la hoja de resultados

Al hablar de posición del cursor nos referimos a la posición dentro de los datos del objeto ResultSet. Lo primero que hay que saber es que el cursor tiene tantas posiciones como filas tenga la consulta y dos más que se sitúan antes de la primera fila y después de la última. Nada más crear un objeto ResultSet, la posición del cursor es la anterior a la primera fila.

Para mover el cursor a la posición siguiente usaremos el método next() que nos devuelve una variable booleana: sí, si se ha podido mover; no, si no ha sido posible el desplazamiento. Nos devolverá false si estamos en el útimo registro (el posterior al último). Para movernos hacia atrás tenemos un método muy similar: el método previous() que al igual que el anterior nos devuelve un valor booleano que será false si estamos en el registro anterior al primero. Estos métodos nos permiten movernos de forma relativa por la hoja de resultados; si deseamos movernos a un registro determinado usaremos el método absolute(int numero_fila), que también nos devuelve un valor boolean. Además tenemos otros métodos que son: afterLast(), que mueve el cursor a la fila posterior a la última; beforeFirst() que mueve el cursor a la fila anterior a la primera; last() que mueve el cursor a la última fila; first() que mueve el cursor a la primera fila. Todos ellos devuelven un valor booleano.

Obtener datos de la hoja de resultados

Para acceder a los datos de la hoja de resultados usamos los métodos get...(int numeroColumna) o get...(String nombreColumna). Estos métodos nos devuelven el valor que indica el nombre del método (por ejemplo tenemos: getString, getInt, getDate, ...) indicando el número o el nombre de la columna. Hay que tener en cuenta que el número de columna es el número de columna en la hoja de resultados y por tanto se establece con el orden en el que se han incluido las columnas en la instrucción SELECT. Por ejemplo si hemos hecho la consulta de la siguiente forma: SELECT Nombre, Apellidos ... la columna Nombre será la primera y la columna Apellidos será la segunda independientemente de cómo estén situadas en la base de datos. Si hacemos un SELECT * FROM ..., en ese caso las columnas estarán en el orden en el que están en la base de datos.

Modificar la base de datos con el objeto ResultSet

Hemos dicho que mediante el objeto Statement podemos ejecutar sentencias SQL para modificar la base de datos y hacer consultas, por lo que podemos usar el

lenguaje SQL para hacer cualquier operación en la base de datos; pero además tenemos métodos especializados que nos permiten hacer estas mismas tareas sin usar el lenguaje SQL. Para ello se usan los métodos especializados del objeto ResultSet. Por tanto si deseamos modificar la base de datos a través de Java, sin utilizar SQL, lo primero que deberemos hacer es realizar una consulta SQL para obtener el objeto ResultSet (parece un poco paradógico). Ahora sólo nos queda usar los métodos especializados de este objeto.

Por ejemplo podemos usar deleteRow() para borrar una fila.

Para actualizar una fila se usan los métodos update...(NombreColumna, valor) o update...(NumeroColumna, valor), así podemos encontrar updateFloat, updateString, ... Para que los cambios se reflejen en la base de datos se debe llamar al método updateRow() o cancelRowUpdates() si queremos cancelar la actualización.

resultset.updateString("Nombre", "PEPE");resultset.updateRow();

Para insertar una fila nos hemos de mover a un lugar del cursor especial con el método toInsertRow(), una vez allí usaremos los métodos update... explicados antes y para reflejar esta actualización llamar al método insertRow().

GENERAR UN ARCHVO EJECUTABLE EN JAVA

Ejecutables de la plataforma

Scripts

Archivos bat (Archivos por lotes MS-DOS)

Scripts en Unix

Ejecutar directamente desde Linux

Jar ejecutables

En Java, en principio, no se pueden crear autoejecutables ya que este es un lenguaje multiplataforma y los archivos autoejecutables son dependientes de la plataforma. Esto provoca que tengamos que usar la consola para ejecutar nuestros programas; lo que supone un gran inconveniente para usuarios sobre todo acostumbrados a los entornos gráficos.

Existen varias soluciones para este asunto. Aquí se explican tres de ellas. La primera es la de crear ejecutables dependientes de la plataforma ; la segunda permite hacer más fácil la ejecución en cada plataforma sin impedir su ejecución en otra plataforma; la tercera es válida para cualquier plataforma y aporta otras muchas posibilidades.

Crear ejecutables de la plataforma

Podemos crear un ejecutable de la plataforma de varias maneras:

Podemos usar traducir el código java a código C con Toba o J2C. De esta forma sólo nos queda compilar el código C para crear el ejecutable. Toba es un proyecto libre cuyo desarrollo ha quedado estancado cuando Java iba por la versión 1.1, pero podemos descargarlo todavía desde su página web. J2C lo puedes encontrar aquí (creo; cuando veas la página sabrás el porqué de mis dudas),

Existe un compilador que además de permitirnos, como cualquier otro compilador, crear bytecodes a partir de ficheros .java, nos da la posibilidad de compilar el fuente (archivos .java) para obtener un ejecutable de la plataforma y también permite crear un ejecutable de la plataforma a partir del bytecode. De esta forma el código obtenido es mucho más rápido. El programa se llama GJC y forma parte la familia de compiladores GCC del proyecto GNU que se desarrolla bajo la GPL (General Public License).

Si lo que queremos es crear un archivo ejecutable .exe (para plataforma Windows) y prescindir de la cualidad de multiplataforma de este lenguaje, lo que hay que hacer es conseguir un programa que realice esta tarea. Esto lo hacen algunas IDE's y el programa JtoExe. Al crear un .exe lo que hacemos es sustituir los archivos de clase de Java, al contrario que la siguiente opción que complementa y no sustituye. En particular el programa JtoExe necesita de la máquina virtual de Java para poder ejecutar el programa de modo seguiremos necesitando instalar la JVM al contrario que las dos opciones anteriores.

Crear scripts

Otra posibilidad, que nos permite mantener la multiplataforma es crear un script para cada plataforma. Esto lo que nos permite es facilitar la ejecución dentro de cada plataforma sin evitar que podamos ejecutar el programa en otra para la que no hayamos creado un script. Bueno para el que no haya entendido nada hasta aquí o no sepa lo que es un script lo voy a explicar más claramente. Un script no es

más que un archivo en el que se guardan los comandos que se teclearían en la consola (es decir, lo que teclearías en una ventana MS-DOS en caso de usar este Sistema Operativo o en una shell para los que usen Unix) para que fuera interpretados por el intérprete de comandos.

Archivos .bat

Los script de Windows/MS-DOS se llaman archivos por lotes de MS-DOS, y su extensión es .bat. De este modo solamente tenemos que crear un archivo de este tipo cuya única línea sea la siguiente:

javaw ClasePrincipal

Ya sólo nos queda ejecutarlo con un doble click en el navegador de archivos y se lanzará la aplicación por medio del programa javaw del JDK (deberá estar indicada la ruta de este programa en la variable de entorno PATH). También podríamos haber usado el programa java.exe. Esta solución tiene un inconveniente: se abre una ventana de MS-DOS muy incómoda. Si usamos el programa javaw.exe esta ventana podrá cerrarse nada más ser lanzada la aplicación y si usamos el programa java.exe sólo podrá cerrarse una vez finalizada la aplicación.

Scripts en Unix

Para los que usen Unix crear el script no debe tener mucha dificultad. Podemos crearlo desde la shell de la siguiente forma:

shell>echo 'java ClasePrincipal' > nombre_archivo_del_script

Siendo ClasePrincipal la clase que se ha de ejecutar y estando la ruta hacia el programa java en la variable de entorno PATH y la ruta hacia ClasePrincipal en la variable de entorno CLASSPATH. Y posteriormente ejecutarlo de la siguiente forma:

shell>sh nombre_archivo_del_script

Aunque también podríamos ejecutarlo, aunque para ello deberíamos darle los permisos adecuados. Una vez dados estos permisos lo podríamos ejecutar desde la shell de la siguiente forma:

shell>./nombre_archivo_del_script

O de la siguiente si en la variable de entorno PATH se ha especificado el directorio actual

shell>nombre_archivo_del_script

Ejecutar directamente desde Linux

Desde la versión del Kernel 2.2.10 existe una posibilidad a la hora de compilar el kernel que nos permite ejecutar directamente un bytecode como si se tratara de un binario para Linux. Para ello necesitaremos compilar un kernel con la opción de Misc Binaries. Tendremos que crear un scrip para lanzar las clases (esto no será necesario para los applets). De este modo bastará con cambiar los permisos del

bytecode para permitir su ejecución y ya podremos lanzar nuestro applet o aplicación como un ejecutable más. Todo ello se explica en la documentación del kernel 2.2.10.

Archivos jar

La última y más recomendada posibilidad es la de hacer un archivo jar ejecutable. Los archivos jar permiten introducir todos los archivos necesarios para ejecutar nuestra aplicación (clases, imágens, sonidos, archivos de texto, ...) en uno solo con la posibilidad de comprimirlos. Pero además ofrecen otras posibilidades, entre las que se encuentra la posibilidad de añadir información adicional: versión del programa, quién lo ha creado, ... y la que en nuestro caso nos interesa: indicar la clase principal (la que contiene el método main) para poder ejecutarla con el intérprete del JDK (el programa java). Esta información se guarda en un archivo dentro del jar, que se llama MANIFEST.MF cuya ruta dentro del archivo jar será siempre META-INF/MANIFEST.MF. Este archivo es creado por defecto siempre que se crea un archivo jar. Este archivo se puede personalizar, y ahora veremos como:

Para administrar un archivo jar se usa el programa jar del JDK.

Crear un arhchivo jar

A continuación se muestra un ejemplo de cómo crear un archivo jar con las opciones más usuales.

jar cfv MiArchivo.jar Clase1.class Clase2.class Imagen.gif Sonido.au OtrosArchivos

En esta ocasión se ha creado un archivo jar de nombre MiArchivo.jar que contendrá los archivos Clase1.class, Clase2.class, Imagen.gif y Sonido.au y el directorio OtrosArchivos. Como se puede observar en un archivo jar podemos meter cualquier tipo de archivo, incluso directorios. Si exite alguna referencia a archivos dentro de otro directorio estas se mantendrán sin producirse errores ya que la jerarquía de directorios se mantiene dentro del archivo. En el ejemplo se han empleado las opciones c, f y v de la línea de comandos. Estas opciones y otras se explican a continuación:

c .- Indica que vamos a crear un archivo.f .- Indica que la salida quieres que vaya a un fichero, y no a la salida estandar.v .- Indica que quieres obtener información durante el proceso de creación del archivo.m .- Indica al programa que queremos personalizar el archivo de manifiesto para añadir información adicional.M .- Indica que no se cree el archivo de manifiesto.0 .- Indicamos que no queremos que se comprima el contenido del archivo.

Modificar el archivo de manifiesto

Llegados a este punto tenemos que crear el archivo de manifiesto. El archivo de manifiesto es un archivo de texto plano (sin formato) por lo que podrá ser creado con cualquier editor de textos convencional. El archivo podrá tener cualquier nombre y/o extensión ya que lo que el programa jar lo que hará será mezclar el

contendio de este archivo con el que se crea por defecto.

En nuestro caso el archivo de manifiesto tendrá una sola línea en la que indicaremos la clase principal (la que contiene el método main). Esto se hace de la siguiente forma:

Main-Class: ClasePrincipal

De este modo se indica cual es la clase principal (sin .class). Ahora deberemos crear el archivo jar con esta información. A continuación se muestra un ejemplo:

jar cfm MiManifiesto.mf MiArchivo.jar ClasePrincipal.class OtraClase.class Imagen.gif

Se observa que tras las opciones, en las que está la opción m explicada anteriormente, se indica el nombre del archivo de manifiesto. Ahora solamente tendremos que indicar que los archivos .jar se abran con el programa java y con la opción -jar en la línea de comandos. Esto ya lo hace el instalador del J2SDK por lo que no será necesario hacerlo a mano.