Introducción a Java.
¿Qué es Java?
Java es un lenguaje de programación de ordenadores, diseñado como una mejora de C++, y desarrollado por Sun Microsystems. (Nota: Para más información sobre Sun, puede consultar su página Web: www.sun.com)
Hay varias hipótesis sobre su origen, aunque la más difundida dice que se creó para ser utilizado en la programación de aparatos electrodomésticos (desde microondas hasta televisores interactivos). De ahí evolucionó (parece ser que porque el proyecto inicial no acabó de funcionar) hasta convertirse en un lenguaje orientado a Internet.
Pero su campo de aplicación no es exclusivamente Internet: una de las grandes ventajas de Java es que se procura que sea totalmente independiente del hardware: existe una “máquina virtual Java” para varios tipos de ordenadores. Un programa en Java podrá funcionar en cualquier ordenador para el que exista dicha “máquina virtual Java” (hoy en día es el caso de los ordenadores equipados con los sistemas operativos Windows, Linux, Solaris y algún otro). A cambio, la existencia de ese paso intermedio hace que los programas Java no sean tan rápidos como puede ser un programa realizado en C, C++ o Pascal y optimizado para una cierta máquina en concreto.
Tiene varias características que pueden sonar interesantes a quien ya es programador, y que ya irá conociendo poco a poco quien no lo sea: La sintaxis del lenguaje es muy parecida a la de C++ y, al igual que éste último, es un lenguaje orientado a objetos. Java soporta el manejo de threads, excepciones, está preparado para la realización de aplicaciones cliente/servidor, es independiente de la máquina, es más fiable y seguro que C++ (no existen los punteros) y cada vez incorpora más facilidades para la creación y manipulación de gráficos, para el acceso a bases de datos, etc. Buena parte de estas posibilidades las iremos tratando más adelante, cuando hayamos visto las más básicas.
¿Qué hace falta para usar un programa creado en Java?
Normalmente, la forma en que más frecuentemente encontramos programas creados en lenguaje Java será dentro de páginas Web.
Estas aplicaciones Java incluidas en una página Web reciben el nombre de “Applets”, y para utilizarlos normalmente no hará falta nada especial. Si nuestro Navegador Web reconoce el lenguaje Java (es lo habitual hoy en día, y es el caso de Internet Explorer de Microsoft y de Netscape Communicator, los más extendidos), estos Applets funcionarán perfectamente sin necesidad de ningún software adicional.
Las aplicaciones que deban funcionar “por sí solas” necesitarán que en el ordenador de destino exista algún intérprete de Java. Esto ya no es tan frecuente, pero tampoco es problemático: basta con instalar en el ordenador de destino el “Java Runtime Enviroment” (JRE), que se puede descargar desde la página web de Sun.
¿Qué hace falta para crear un programa en Java?
Existen diversas herramientas que nos permitirán crear programas en Java. La más habitual (y la más recomendable) es la propia que suministra Sun, y que se conoce como JDK (Java Development Kit). Es de libre distribución y se puede conseguir en la propia página Web de Sun.
El inconveniente del JDK es que puede resultar incómodo de manejar para quien esté acostumbrado a otros entornos integrados, como los que incorporan Delphi o Visual Basic.
En ese caso, es fácil encontrar por un precio casi simbólico editores que hagan más fácil nuestro trabajo, o incluso sistemas de desarrollo completos (como el JBuilder de Borland), si bien estos sistemas de desarrollo suelen tener un precio más elevado.
Nota: Para más
información sobre Borland (ahora Inprise),
puede consultar su página Web:
www.borland.com www.inprise.com
Los
programas que crearemos estarán probados con la versión 1.2.2 del JDK (que
soporta la versión del lenguaje conocida como “Java 2”), salvo que se indique
lo contrario.
Instalación del
JDK bajo Windows.
Vamos a ver el caso más habitual: que trabajemos con Windows 95 (o superior) y que no dispongamos de mucho dinero para gastar. Entonces nos interesará conseguir gratuitamente el JDK e instalarlo en nuestro ordenador.
¿Dónde se puede conseguir el JDK?
El sitio más fiable es la propia página Web de Sun:
http://java.sun.com
Allí encontraremos enlaces para descargar (download) la última versión disponible. Bastará con que leamos y aceptemos las condiciones de la licencia, y entonces empezaremos a recibir un único fichero de gran tamaño (20 Mb para la versión 1.2.2 para Windows; también existe la opción de descargar varios ficheros de aproximadamente 1.4Mb de tamaño)
¿Cómo instalo el JDK?
Bastará hacer doble clic sobre el fichero recibido. Por ejemplo, para la versión 1.2.2 del JDK para Windows (95 o superiores y NT o superiores), este fichero tenía el nombre jdk1_2_2-001-win.exe
Al hacer doble clic sobre este fichero, aparecerán varios mensajes de que está comenzando a “descomprimir” datos temporales, y finalmente una pantalla de bienvenida:
Si pulsamos el botón “Next” para proseguir con la instalación, se nos mostrará la licencia de uso.
Si aceptamos estas condiciones (pulsando “Yes”), aparecerá otra ventana, en la que se nos pregunta en qué carpeta (o directorio) queremos instalar el JDK:
Podríamos cambiar el directorio de destino paseando por nuestro disco duro con el botón “Browse” o bien aceptar el directorio que se nos propone y pulsar el botón “Next” para continuar.
A continuación se nos pide que escojamos las partes del JDK que deseamos instalar. Ante la duda, es preferible dejar todas las opciones marcadas:
Después pasamos a la instalación del Java Runtime Environment (JRE), que es la "máquina virtual Java" que permitirá que podamos utilizar en un cierto ordenador los programas creados en Java.
Si se tratase de otro ordenador distinto del nuestro, en el que quisiéramos instalar nuestros programas creados en Java, pero no necesitásemos desarrollar programas desde dicho ordenador, no necesitaríamos instalar el JDK completo, sino sólo el JRE, de modo que podríamos descargar sólo éste desde el sitio Web de Sun.
En cualquiera de ambos casos, deberemos comenzar por aceptar las condiciones de licencia.
Después, al igual que ocurría con el JDK, se nos preguntará en qué directorio (carpeta) deseamos hacer la instalación.
Se nos propone un directorio dentro de “Archivos de programa”. En mi caso, al instalarlo en mi propio ordenador, prefiero cambiarlo para que quede dentro del directorio en el que ha quedado el JDK:
Al final de la instalación se nos recomienda reiniciar nuestro ordenador, y el proceso queda terminado:
¿Hay que hacer algo más para que funcione el JDK?
Sí. Ya está la información dentro de nuestro ordenador, pero tenemos que acceder a ella. Hay dos opciones:
- La opción “mala” es usar el JDK tal cual ha quedado instalado. Esto supone que los fuentes (nuestros programas Java “originales”) deberán estar en el directorio “BIN” de nuestra instalación “JDK”. Es decir, deberíamos entrar al directorio C:\JDK122\BIN (o el que corresponda en nuestro caso, si hemos empleado otro distinto), teclear allí nuestros fuentes, y ponerlos en funcionamiento desde allí.
Nota sobre
Windows: Se puede modificar
el Autoexec.bat de varias formas. Una puede
ser pulsar Inicio/Ejecutar y teclear:
notepad c:\autoexec.bat
- La opción “buena” es que nuestros fuentes puedan estar en cualquier sitio. Para eso, debemos modificar el “AUTOEXEC.BAT” de nuestro ordenador, añadiendo al final del mismo la línea
path=%path%;c:\jdk122\bin
Creando una
primera aplicación.
Escribiendo “Hola Mundo”
Comenzaremos por crear una aplicación (programa) en modo texto. Esta aplicación hará lo que se suele usar como primer ejemplo en todos los lenguaje de programación: escribir un texto en la pantalla.
Quien ya conozca otros lenguajes, verá que conseguirlo en Java parece más complicado. Por ejemplo, en Basic bastaría con escribir PRINT “HOLA MUNDO!”. Pero esta mayor complejidad inicial es debida al “cambio de mentalidad” que tendremos que hacer, y dará lugar a otras ventajas más adelante.
A quien no conozca ningún lenguaje de
programación todo le sonará extraño, pero dentro de muy poco (apenas veamos que
nuestro programa funciona) volveremos atrás para ver paso a paso qué hace cada
una de las líneas que habremos tecleado.
Vamos allá...
- Lo primero que haremos será crear una carpeta en la que guardaremos nuestros fuentes (o al menos éste).
Nota sobre Windows: Se puede crear una carpeta
desde el Explorador de Windows: entramos a la
carpeta dentro de la que queremos situarla, pulsamos
el botón derecho del ratón y escogemos la opción
Nuevo / Carpeta
- Una vez que tenemos un “sitio” donde guardar nuestros programas, tenemos que teclearlos. Lo haremos con cualquier editor de texto. En un principio, puede servirnos el Bloc de Notas que incorpora Windows. (Nota: No deberemos emplear Word ni ningún otro procesador de textos que permita distintos tipos de letra, cursivas, negritas y otros cambios de apariencia, salvo que seamos usuarios avanzados y sepamos cómo guardar como “Sólo texto”).
- En nuestro caso, no usaremos el Bloc de Notas, porque tiene una característica peligrosa: suele añadir las letras “txt” al final de los archivos, y eso haría que Java no los reconociera como programas. Haremos todo desde el “modo MsDos” de Windows 95 y superiores.
- Para entrar al “modo MsDos” de Windows, entramos al menú “Inicio”, submenú “Programas”, hacemos clic en la opción “MS-DOS”. Aparecerá la ventana negra típica de MsDos y del “interfaz de comandos” de Windows NT:
Nota sobre Windows:
Puede que la ventana negra anterior
realmente esté ocupando toda la pantalla; podemos
cambiar entre la visualización en pantalla completa y en
ventana pulsando simultáneamente
Alt y Return (o Enter, o la tecla de avance de línea)
- Ahora deberemos desplazarnos hasta la carpeta que hemos creado, o bien crearla en este momento. Por ejemplo, en mi caso, he creado una carpeta JAVA01 dentro de la carpeta NPROGS, que es parte de mi disco C, de modo que teclearía CD \NPROGS\JAVA01 para entrar a esa carpeta.
- Una vez
dentro de esta carpeta, podríamos crear un fichero llamado “hola.java”.
que será nuestro primer fuente en Java. Lo haremos empleando el Editor de
texto de MsDos, llamado EDIT. De modo que teclearemos
edit hola.java
Debería aparecer la pantalla vacía del editor de
MsDos:
Nota: El uso de
mayúsculas y minúsculas es irrelevante
para MsDos y para Wndows, pero no para
Java (ni para otros sistemas, como Unix).
Por eso, deberemos respetar las mayúsculas
y minúsculas tal y como aparezcan en los ejemplos.
Ya dentro de este editor, teclearemos lo siguiente:
//
// Aplicación HolaMundo de ejemplo
//
class HolaMundo {
public static
void main( String args[] ) {
System.out.println( "Hola Mundo!" );
}
}
- Una vez que hemos tecleado todo esto, salimos del Editor, entrando al menú Archivo (con el ratón o pulsando Alt+A) y escogiendo la opción Salir. El editor se dará cuenta de que hemos escrito algo y nos preguntará si queremos guardar los cambios (deberemos decirle que Sí):
- Deberíamos volver la ventana negra de MsDos, pero ahora ya hemos avanzado un poco: tenemos nuestro programa escrito.
- El siguiente paso es “compilarlo”, es decir, convertirlo en algo que pueda entender cualquier ordenador para el que exista la “máquina virtual Java”. Para conseguirlo, escribimos:
javac hola.java
- Si no aparece ningún mensaje de error, quiere decir que todo ha ido bien. Para comprobarlo, podemos teclear la orden “dir” de MsDos (sin las comillas), que nos muestra el contenido de ese directorio en el que estamos trabajando. Debería aparecer algo parecido a:
- Vemos que hay algo que “no hemos puesto nosotros”: hay un fichero llamado “HolaMundo.class”. En efecto, es la “clase HolaMundo” que habíamos definido en nuestro fuente. Un poco más adelante hablaremos de clases y veremos detalles sobre qué hemos escrito en nuestro fuente y por qué, pero de momento ya notamos que “algo ha ocurrido” a pesar de que nuestro ordenador no hubiera respondido con ningún mensaje.
- Si hubiésemos tecleado algo mal, sí que obtendríamos algún mensaje de error como respuesta. Por ejemplo, si hubiéramos escrito “clas” en vez de “class”, en la línea 5 de nuestro programa, obtendríamos como respuesta:
hola.java:5: Class or interface declaration expected.
clas
HolaMundo {
^
1 error
- Pues vamos a ver funcionar nuestro programa: tecleamos “java HolaMundo” (sin comillas, como siempre) para que nuestro ordenador siga los pasos que le hemos detallado en “HolaMundo.class”, y debería aparecer escrito en pantalla “Hola Mundo!”:
Este es nuestro primer programa. Es poco
útil, pero al menos funciona. Ahora veremos qué hemos hecho en este programa, y
comentaremos algunas de las órdenes que permite Java, de modo que podamos
pronto crear algo “más práctico”.
¿Siempre es tan incómodo programar en Java?
No necesariamente:
Hay otros editores más cómodos, que realzan en colores la sintaxis de lo que hemos escrito, para ayudarnos a detectar errores (por ejemplo, la siguiente imagen muestra el editor de "CodeWarrior").
Incluso hay entornos integrados que nos ayudan a teclear nuestro programa y probarlo desde un mismo sitio, sin tener que conocer órdenes de MsDos (es el caso de Ibm Visual Age for Java, al que corresponden las dos próximas pantallas, y también es el caso de Borland JBuilder).
Muchos de estos entornos integrados nos ayudarán a diseñar de forma “visual” las pantallas que conformarán la parte visible de nuestros programas, de un modo similar al que emplear otras herramientas como Delphi (para lenguaje Pascal), Visual Basic (para Basic) o C++ Builder (para C++).
Pero, como ya habíamos anticipado, no comenzaremos por lo más fácil, sino por lo más “barato”, que no suponga ningún desembolso de dinero adicional. Por ello, de momento continuaremos tecleando los programas con el Editor de MsDos, y compilándolos y probándolos con las herramientas del JDK. Más adelante veremos el manejo básico de alguno de los entornos integrados que se distribuyen gratuitamente.
Entendiendo esta primera aplicación.
Vayamos línea por línea para ver qué hemos tecleado y por
qué:
El comienzo del programa: un comentario.
Las tres primeras líneas son:
//
// Aplicación HolaMundo de ejemplo
//
Estas líneas, que comienzan con una doble barra inclinada (//) son comentarios. Nos sirven a nosotros de aclaración, pero nuestro ordenador las ignora, como si no hubiésemos escrito nada.
Continuamos definiendo una clase.
Después aparece un bloque de varias órdenes; vamos a eliminar las líneas del centro y conservar solamente las que nos interesarán en primer lugar:
class HolaMundo {
[... aquí faltan más cosas ...]
}
Esto es la definición de la “clase” llamada
“HolaMundo”, que nos indica que Java es un lenguaje orientado a objetos...
Nociones básicas de programación orientada a objetos.
En Java no debemos pensar simplemente en líneas de programa, sino que antes debemos plantearnos el diseño de nuestro programa como algo mucho más general: deberemos haber descompuesto el problema en una serie de objetos que se relacionan entre sí.
Para entender esta idea, vamos llevarlo a una situación cotidiana:
Imaginemos una persona (a la que llamaremos Eva), que todas las mañanas va a trabajar con su coche (por ejemplo, un Seat Ibiza). En algo tan habitual como esto, aparecen muchas de los conceptos que nosotros emplearemos. Tenemos dos “objetos” (Eva y su Seat), pero no son objetos “aislados”: Eva es una persona, y su Seat es un coche, es decir cada uno pertenece a un grupo de objetos que comparten una serie de características comunes (lo que llamaremos una “clase”). Existe una interacción entre ellos: Eva puede avisar a su Seat de que desea circular más deprisa, pisando el pedal del acelerador (es lo que llamaremos “mandar un mensaje”), pero también el coche puede avisar a Eva, por ejemplo encendiendo una luz cuando le queda poco combustible (también le estaría enviando un mensaje).
Estos objetos interaccionando se pueden expresar gráficamente, en forma de diagrama (lo que nos ayuda a diseñar nuestros "sistemas"), y se pueden simular con una cierta facilidad mediante un ordenador si se emplean lenguajes o herramientas orientados a objetos. De hecho, existen utilidades que nos permiten “dibujar” en nuestro ordenador los diagramas que muestran los objetos y las relaciones existentes entre ellos, y son capaces de crear el “esqueleto” de nuestro programa, en el que nosotros deberemos ir rellenando “los huecos” con los detalles necesarios.
En nuestro caso, apenas tenemos un par de objetos: nuestra aplicación y la pantalla de nuestro ordenador. Y también se "mandarán mensajes" entre ellos: nuestra aplicación pedirá a la pantalla que muestre un cierto mensaje.
Pero en la Programación Orientada a Objetos existen algunos otros
conceptos importantes, y que emplearemos más adelante. Vamos a comentar ya
alguno de ellos:
- Hablaremos de atributos (o variables miembro), que son las “características” de un determinado objeto (o de toda su clase), como el peso de una persona, su estatura o su color de ojos.
- También hablaremos de métodos (o funciones miembro), que son las cosas que un objeto (o su clase) es capaz de hacer. Por ejemplo, un coche puede acelerar, frenar, cambiar de dirección, etc.
- Se habla mucho de herencia. La herencia es el hecho de que no siempre haga falta definir las cosas “desde cero”, sino que podremos apoyarnos en lo que ya conocemos. Por ejemplo, el día que Eva necesita conducir otro coche distinto del suyo, no es una tarea difícil, porque ambos son coches y apenas existirán unas pocas diferencias entre ambos, de manera que tendrá pocas cosas nuevas que aprender. De igual modo, nosotros podremos definir unos objetos a partir de otros ya existentes (porque ya estén creados en Java, o porque los hayamos creado nosotros mismos -u otra persona-), lo que nos puede ahorrar mucho trabajo.
- También puede aparecer la palabra “polimorfismo”, que se refiere a que una misma palabra se puede aplicar en sitios relativamente distintos. Por ejemplo, igual que hablamos de “conducir” un coche y de “conducir” una motocicleta, aunque ambas formas de conducir se parezcan poco, también en nuestros programas podremos hablar de “dibujar” figuras geométricas muy distintas, cada una de las cuales requerirá una serie de pasos específicos.
- Otra de las cararacterísticas de la programación orientada a objetos es la ocultación de los detalles. Por ejemplo: Eva no necesita saber casi nada de mecánica para conducir su Seat Ibiza, y si el día de mañana la casa Seat decide cambiar los motores en los nuevos Seat Ibiza, Eva podría conducir otro Seat nuevo sin necesidad de aprender nada nuevo. De igual modo, nuestros programas deberían ser lo suficientemente flexibles como para que una parte del programa no necesite saber detalles internos de otra, y podamos permitirnos mejorar internamente una parte del programa sin que ello suponga modificar el resto.
Todos estos conceptos los iremos aplicando a medida que vayamos avanzando.
¿Qué hace nuestra clase?
Como ya hemos comentado, hará poco más que pedir a la pantalla que muestre un cierto mensaje. Los detalles concretos de lo que debe hacer nuestra clase los indicamos entre llaves ( { y } ), así:
class HolaMundo {
[... aquí faltan más cosas ...]
}
Estas llaves serán frecuentes en Java, porque las usaremos para delimitar cualquier bloque de programa (y normalmente habrá bastantes...)
Java es un lenguaje de formato libre, de modo que podemos dejar más o menos espacios en blanco entre los distintas palabras y símbolos, así que la primera línea de la definición de nuestra clase se podría haber escrito más espaciada
class
HolaMundo {
o bien así (formato que prefieren algunos autores, para que las llaves de principio queden justo encima de las de final)
class HolaMundo
{
o incluso cualquier otra “menos legible”:
class
HolaMundo
{
Nuestra clase de objetos “Hola Mundo” sólo hace una cosa: englobar al cuerpo del programa, de modo que en su interior sólo existe una función, llamada “main”, que representa al cuerpo de la aplicación.
public static void main( String args[] ) {
[... aquí faltan más cosas ...]
}
Nota para C y C++:
La función “main”
es, al igual que en C y C++, la que
indicará el cuerpo de un programa,
pero en Java el programa en sí debe
ser también un objeto, de modo que
“main” debe estar dentro de la
declaración de una clase.
Pero vemos que hay muchas “cosas” rodeando a “main”. Estas “cosas” deberán estar siempre, y más adelante volveremos a ellas según las vayamos necesitando, pero vamos a comentar brevemente cada una de ellas:
- public: indica que esta función estará accesible para cualquier otro objeto (ya veremos más adelante los distintos especificadores de acceso que permite Java).
- static: indica que esta función en un “método estático” o “método de clase”, al que se podrá acceder sin necesidad de haber declarado ningún objeto concreto perteneciente a esa clase.
- void: indica que esta función no va a devolver ningún valor (por ejemplo, una función que calculase la raíz cuadrada de un número sí debería devolver el valor que ha obtenido).
- String args[] nos permitiría leer los “argumentos” que se indicasen en nuestro programa (por ejemplo, cuando escribíamos “edit hola.java”, la aplicación que estamos utilizando es “edit”, y el argumento -los detalles concretos sobre qué queremos editar- es “hola.java”). También veremos más adelante cómo utilizarlos.
Al igual que decíamos de la clase, todo el bloque de cosas que va a hacer esta
función “main” se engloba entre llaves:
public static void main( String args[] ) {
[... aquí faltan más cosas ...]
}
En concreto, nuestra clase de objetos “Hola Mundo” interacciona únicamente con la salida en pantalla de nuestro sistema (System.out), para enviarle el mensaje de que escriba un cierto texto en pantalla (println):
System.out.println( "Hola Mundo!" );
Como se ve en el ejemplo, el texto que queremos escribir en pantalla se debe indicar entre comillas.
También es importante el punto y coma que aparece al final de esa línea: cada orden en Java deberá terminar con punto y coma (nuestro programa ocupa varias líneas pero sólo tiene una órden, que es “println”).
Ahora ya podemos volver a leer todo nuestro programa, con la esperanza de entenderlo un poco más...
//
// Aplicación HolaMundo de ejemplo
//