Download Compilando y ejecutando programas en java

Contenido
Introducción................................................................................................................................... 1
¿Qué es Java?................................................................................................................................. 1
Compilando a Bytecode ................................................................................................................. 1
Usando jGRASP Para Hacer el Trabajo Sucio ................................................................................. 5
El Entorno de jGRASP ................................................................................................................. 5
Introducción
Es tiempo de hablar en detalle de lo que significa escribir, compilar y ejecutar un programa en
Java. Ya casi llegamos al punto en el que todas nuestras clases, serán principalmente en el
laboratorio y es fundamental que todos nos desenvolvamos con facilidad en el entorno de
programación de Java.
¿Qué es Java?
Según Wikipedia “Java es un lenguaje de programación orientado a objetos desarrollado por
Sun Microsystems a principios de los años 90. El lenguaje en sí mismo toma mucha de su
sintaxis de C y C++, pero tiene un modelo de objetos más simple y elimina herramientas de
bajo nivel, que suelen inducir a muchos errores, como la manipulación directa de punteros o
memoria.”
De esta definición debemos destacar:
·
·
·
Java es un lenguaje de programación orientado a objetos (se programa todo dentro de
clases).
Su modelo de objetos es más sencillo que el de otros lenguajes.
Se encarga de cosas como el manejo de la memoria y su manipulación dentro de los
programas de tal forma que el programador solo debe preocuparse (al menos la mayor
parte del tiempo), por crear buenos algoritmos.
Compilando a Bytecode
Tal como escribimos nuestros programas, en uno o varios archivos de texto plano, no es
posible ejecutarlos en el computador. Es necesario que estos archivos, llamados archivos de
código fuente, sean procesados por un programa llamado compilador, que revisa su sintaxis y
busca errores que pueda detectar en tiempo de compilación, para generar uno o más archivos
de salida que pueden ser ejecutados por la JVM o Java Virtual Machine.
Página 1
El compilador de Java llamado javac (the Java Compiler), toma los archivos fuente que se le
pasan (estos archivos tienen extensión .java) y los convierte a bytecode que se guarda en
archivos con extensión .class.
El bytecode es un tipo de código binario que contiene el programa ejecutable en Java. Un
archivo .class (de bytecode), no se puede ejecutar directamente sino que requiere de una JVM
(Java Virtual Machine), que lee dicho código, lo interpreta y lo ejecuta para que nuestros
programas en Java hagan lo que se supone que deben hacer.
¿Por qué hacer las cosas tan complicadas? Porque una de las ventajas de Java es que puede
compilarse una vez (en teoría), y correr en cualquier sistema operativo o plataforma que tenga
una JVM instalada. En otras palabras, mi programa se ejecutará en Mac OS, Linux, Windows,
FreeBSD, etc., sin necesidad de preocuparme por las particularidades de cada plataforma. Para
poder hacer esto se requiere de un programa o máquina virtual (la JVM o Java Virtual
Machine), cuya misión consiste en ocultar las particularidades de cada plataforma a los
programas que se ejecutan en ella. Además el compilar el código fuente cumple las siguientes
misiones:
·
·
·
·
Busca errores de sintaxis en nuestros archivos fuente.
Busca distintos tipos de errores, que pueden ser detectados sin necesidad de correr
nuestro programa y que en última instancia, si no se corrigen a tiempo producirán
programas o salidas defectuosas (errores como usar una variable sin haberla declarado
o usar un método que no existe o que escribimos mal).
Crea código que es más rápido de ejecutar, que si nuestro programa se interpretara
línea por línea desde el código fuente.
Crea archivos que podemos empaquetar y vender si el temor de que otros sepan
fácilmente cómo es que hacemos para resolver el problema que nos hará millonarios.
En Java se pueden crear programas tanto para el escritorio (con o sin ventanas gráficas), como
lo hemos estado haciendo o podemos crear programas que se ejecutan dentro de un
navegador.
Veamos un ejemplo de una aplicación en Java, llamada Applet que se ejecuta dentro de un
navegador:
// Hola.java APPLET - SE EJECUTA EN UN NAVEGADOR
import java.applet.Applet;
import java.awt.Graphics;
public class Hola extends Applet {
public void paint(Graphics gc) {
gc.drawString("Hola, mundo!", 65, 95);
}
}
El archivo .class generado a partir de este código debe estar dentro del código de una página
HTML:
Página 2
<!-- Hola.html -->
<html>
<head>
<title>Applet Hola Mundo</title>
</head>
<body>
<applet code="Hola.class" width="200" height="200">
</applet>
</body>
</html>
Después de compilar nuestro código en Java y de tener en el mismo directorio el archivo
Hola.class y el archivo hola.html (o como sea que queramos llamarlo, porque su nombre es
independiente del nombre de nuestro .class), al abrir este último en un navegador (Internet
Explorer, Firefox, Opera), obtenemos lo siguiente:
Hemos así creado nuestro primer Applet.
Como somos programadores tal vez nos parezca engorroso tener que abrir un navegador para
ejecutar nuestro Applet. Java viene al rescate proporcionándonos el programa appletviewer
que nos permite ejecutar nuestro programa directamente desde una consola de comandos:
Página 3
Ahora veamos la misma aplicación pero para el escritorio:
// Hola.java
public class Hola
{
public static void main(String[] args){
System.out.println("¡Hola, mundo!");
}
}
En las dos capturas de pantalla anteriores, se muestran también los comandos involucrados en
la compilación y ejecución de nuestro programa en Java.
Este ejemplo necesita de una breve explicación.
·
·
·
·
·
·
·
·
·
Todo en Java está dentro de una clase, incluyendo programas autónomos.
El código fuente se guarda en archivos con el mismo nombre que la clase que
contienen y con extensión “.java”. Una clase (class) declarada pública (public)
debe seguir este convenio. En el ejemplo anterior, la clase es Hola, por lo que el código
fuente debe guardarse en el archivo “Hola.java”
El compilador genera un archivo de clase (con extensión “.class”) por cada una de las
clases definidas en el archivo fuente.
Los programas que se ejecutan de forma independiente y autónoma, deben contener
el método main ().
La palabra reservada void indica que el método main no devuelve nada.
El método main debe aceptar un arreglo de objetos tipo String. Por acuerdo se
referencia como args, aunque puede emplearse cualquier otro identificador.
La palabra reservada static indica que el método es un método de clase, asociado a
la clase en vez de una instancia de la misma. El método main debe ser estático o “de
clase’’.
La palabra reservada public significa que un método puede ser llamado desde otras
clases, o que la clase puede ser usada por clases fuera de la jerarquía de la propia
clase. Otros tipos de acceso son private y protected.
La utilidad de impresión forma parte de la biblioteca estándar de Java. la clase
System define un campo público estático llamado out. El objeto out es una
instancia de “PrintStream”, que ofrece el método println("String”), para volcar
los datos en la pantalla (la salida estándar).
Página 4
·
Las aplicaciones autónomas se ejecutan dando al entorno de ejecución de Java el
nombre de la clase cuyo método main debe invocarse. Por ejemplo, una línea de
comando (en Unix o Windows) de la forma java Hola ejecutará el programa del
ejemplo (previamente compilando el archivo fuente y generado el archivo de
bytecode Hola.class).
Resumiendo la parte de comandos necesitamos conocer y manejar son los siguientes:
·
·
·
javac: el compilador de java el cual recibe como parámetros nuestros archivos fuente.
java: nuestro entorno de ejecución java, al cual debemos pasarle el nombre de la clase
que contiene el método main en nuestras aplicaciones autónomas.
appletviewer: el cual ejecuta nuestros applets de java, para lo cual debemos pasarle
como parámetro el nombre del archivo HTML que contiene nuestra clase.
Usando jGRASP Para Hacer el Trabajo Sucio
Existen probablemente cientos de IDE o entornos de desarrollo integrado para Java. Para este
curso se recomienda usar jGRASP (www.jgrasp.org/) dado que este nos proporciona ayudas
visuales, diagramas de clases y CSD; todo en un entorno ligero y mucho más rápido que otros
IDE como Eclipse o NetBeans. La buena noticia es que si no les gusta jGRASP, pueden usar
cualquier editor de texto plano (notepad, kwrite, kate, vim, gedit, etc.), y compilar y ejecutar
sus programas desde la consola de comandos como vimos en la sección anterior o usar otro
IDE. Al fin y al cabo, su programa en Java hará siempre lo mismo si está bien construido.
El Entorno de jGRASP
Página 5
jGrasp nos proporciona un área de trabajo limpia, con botones que ejecutan los comandos y
procesos más relevantes al momento de crear programas en Java. Los botones para compilar y
ejecutar se encargan de llamar con sus parámetros correspondientes a javac y a java
mostrando en la parte inferior de la ventana los mensajes del compilador o el I/O del programa
cuando este se ejecuta (si el I/O no es gráfico). Hasta aquí jGRASP no hace nada distinto de
otro IDE para Java. Su principal distintivo es que genera ayudas gráficas llamadas CSD sobre
nuestro código fuente que representan cada una de las estructuras de programación que se
usan en el lenguaje. Al generar el CSD, jGRASP detecta errores de sintaxis en nuestro código lo
que finalmente nos hace más felices al facilitarnos la vida. Un ejemplo de un CSD sobre un
archivo fuente es el siguiente:
Esta clase de ayudas gráficas se agradecen después de unas cuantas horas de estar
programando o de crear un archivo cuyo código ocupe más espacio que lo que podemos ver
en pantalla. Un dato adicional acerca de los CSD es que al hacer doble clic sobre ellos ocultan
las secciones del código que corresponden a esa estructura de programación lo que nos
permite concentrarnos en verificar la lógica de nuestros programas.
Página 6