Programación bit a bit: Hello World!

Hello world, hello OpenWebinars.net!

Hablando en informática, "¡Hola Mundo!" suele ser un primer programa como toma de contacto con la programación. Es un programa muy sencillo donde se muestra por pantalla el mensaje "Hello World!". A pesar de ser un programa simple, permite desde el punto de vista didáctico explicar muchos aspectos básicos de un programa. Sé que habrán cosas que explicaré hoy y serán demasiado contenido nuevo de golpe, pero no se preocupen ya que poco a poco en otros artículos quedarán más claro. Dicho esto, un ¡Hola Mundo! de ejemplo es el siguiente fichero HelloWorld.java :

/**
* Clase HelloWorld
*
* Programa a modo de ilustración
* del típico programa HelloWorld
*/

package net.openwebinars;

public class HelloWorld {

  /* Main principal
     para el programa "HelloWorld"
  */

  /**
  * Método main.
  *
  * @param args como argumento
  */
  public static void main(String[] args) {
    // Imprimimos por consola el mensaje
    System.out.println("Hello World, hello OpenWebinars.net!");
  }

}

A continuación iré explicando los elementos del código:

Comentarios

Un comentario es texto escrito por el propio programador a modo de información. Nunca se ejecutará el texto dentro de comentarios, por tanto es una buena forma de apuntar aquellas secciones de código que necesitan una explicación o simplemente alguna nota del autor. En la mayoría de lenguajes hay dos tipos de comentarios principales:

• Comentarios de una línea
• Comentarios de más de una línea

En el primer caso se escriben poniendo // al comienzo de la línea. Así por ejemplo

// Imprimimos por consola el mensaje

es un comentario de una sola línea. Si queremos añadir más líneas, en cada una de ellas tendríamos que poner // al comienzo de cada una. Para evitar escribir tantas veces // en comentarios de muchas líneas, tenemos el segundo caso. Para ello basta con escribir /* al principio de la primera línea y */ al final de la última línea. De esta forma,

/* Main principal
   para el programa "HelloWorld"
*/

sería un comentario multi-línea. La ubicación de los símbolos /* y */ no tiene por qué ser estricta. Por ejemplo yo dije que tenía que ir el símbolo */ al final y en el ejemplo lo puse en otra línea. No hay problema con ello, siempre y cuando se respete que después de un símbolo /* nunca se puede encontrar el mismo símbolo. Decir que un comentario de varias líneas también se puede escribir como si se comentarios de una sola línea se tratase. A modo de ejemplo, el comentario de antes es equivalente al siguiente:

// Main principal
// para el programa "HelloWorld"
//

Existe un tercer tipo de comentarios en Java llamados Javadoc los cuales se usan posteriormente para generar documentación de las clases en formato html. Son comentarios multi-línea y se escriben usando en lugar del símbolo /*, se usa /** . En el fichero de ejemplo tenemos el siguiente comentario

/**
  * Método main.
  *
  * @param args como argumento
  */

Los comentarios Javadoc tienen sus propios campos que usará el programa generador de la documentación para darles un formato especial. En este caso, @param es un campo para los parámetros de un método (no te preocupes si no entiendes qué es un parámetro y un método ya que dentro de poco lo veremos). Si tienes curiosidad por ver cómo queda la documentación Javadoc en formato html, puedes ver el siguiente enlace de la clase ArrayList de Java. Nota: De ahora en adelante pondré sólo los comentarios que considere necesarios. Aún así si algo no lo entienden no duden en preguntar.

Paquete

Cuando programemos en Java tendremos que especificar la carpeta o carpetas (partiendo del directorio raíz del proyecto) donde se encuentra el fichero. Para ello usamos la sentencia package seguida de dicha ruta separada por puntos y ; al final. En este caso

package net.openwebinars;

estamos indicando que el fichero está dentro de la carpeta openwebinars la cual se encuentra dentro de la carpeta net . Nota: Más de uno se preguntará por qué puse la carpeta openwebinars dentro de la carpeta net en lugar de cambiarlo para que fuera de la siguiente forma:

package openwebinars.net;

La respuesta es muy sencilla; cuestión de buena práctica. Cuando vayamos a definir una estructura de directorios se recomienda que la escribamos desde el nombre del dominio (.net, .com, etc) hacia atrás. Sencillamente es por eso.

public class HelloWorld

En cada uno de nuestros ficheros tenemos que definir un bloque de la forma

public class NombreFichero {
  // Código
}

donde NombreFichero será el nombre del fichero en el cual estamos trabajando. En este caso sería HelloWorld. Un bloque es un fragmento de código que viene delimitado por dos elementos específicos del lenguaje. En Java dichos elementos son { y } . Todo lo que se escriba dentro pertenecerá a ese bloque y no se podrá sacar de ahí ningún tipo de información (más adelante veremos que esto no es totalmente cierto, pero por no complicar más las cosas vamos a dejarlo así por ahora). No entraré mucho más en detalle con lo que significa "public class" ya que lo veremos cuando escriba el artículo sobre clases , pero si alguien tiene curiosidad significa que estamos declarando una clase de acceso público.

public static void main(String[] args)

Todos los programas en Java requieren que al menos uno de los ficheros que conforman nuestro programa tenga declarado este bloque de código. Dicho código propio de casi todos los lenguajes llamado Main o Principal es llamado a la hora de ejecutar nuestro programa para ejecutar todo el código que se encuentre dentro de él. En este caso sólo tenemos una línea de código y por tanto sólo ejecutará dicha línea.

System.out.println

Con esta sentencia estamos indicando que queremos que se muestre por pantalla (o mejor dicho por consola) el mensaje "Hello World, hello OpenWebinars.net!" . A todo conjunto de texto delimitado por comillas dobles o " se le llama cadena o String y cada símbolo en su interior se le llama carácter o Char . En este caso, nuestra cadena tiene un total de 36 caracteres (sí, los espacios en blanco también son caracteres). Volviendo a la sentencia principal, System.out.println es una sentencia propia de Java la cual imprime un mensaje por pantalla y posteriormente introduce un salto de línea o retorno de carro . Si no queremos que introduzca el salto de línea, en lugar de esa sentencia deberíamos de usar la sentencia System.out.print . No obstante, existe una diferencia notable entre las dos sentencias además del salto de línea: La sentencia System.out.println permite cadenas vacías o sin caracteres mientras que la sentencia System.out.print no lo permite. Esta es una forma muy usada para poner más o menos espacios en consola entre un texto y otro. Puesto que es una cadena vacía, se representa de la forma "" y, por tanto, la sentencia quedaría así:

System.out.println("");

Notar que cada línea en blanco que queramos requerirá de una sentencia System.out.println(""); por cada una de ellas. Tras explicar el código de HolaMundo, explicaré cómo compilarlo y, lo más importante, cómo ejecutarlo.

Compilación del código

Nuestro proyecto sigue la siguiente estructura de directorios:

/ProgramacionBitaBit  
  /src
    /net
      /openwebinars
          /HelloWorld.java

Compilar nuestro código equivale a generar un fichero ejecutable ( .class ) partiendo de un fichero con el código de nuestro programa ( .java ). En este caso, esta es la estructura definida con Eclipse; cada uno tendrá su propia estructura de directorios. Mi recomendación es que sigan la siguiente estructura genérica:

/NombreProyecto  
  /src
    /dominio
      /subdominio
          /Fichero.java

Para aquellos que usen editores como Eclipse (y no sé si NetBeans también lo hace) no es necesario que compilemos nuestro programa ya que cuando vamos a ejecutarlo con el propio editor él se encarga de compilarlo. Si por el contrario quieres compilar desde consola, deberás ubicarte en cualquier directorio del proyecto (no importa en cuál) y hacer lo siguiente:

javac ruta/Fichero.java

En el caso de este HolaMundo, estando dentro de la carpeta src, tendríamos que hacer:

javac net/openwebinars/HelloWorld.java

Haciendo eso se nos generará un fichero .class el cual no es más que nuestro código compilado en instrucciones de la máquina de Java (también llamado bytecode ).

Ejecución del código

En el caso de Eclipse y otros editores similares el propio programa tiene algún botón o pestaña la cual nos ejecuta el código. Si usan Eclipse, dentro de la pestaña Run la primera opción con el mismo nombre nos ejecutará el programa. Si por el contrario lo hacemos desde consola hay que tener muy en cuenta los paquetes definidos en el programa. Me explico con nuestro ejemplo de HolaMundo. En él definimos el paquete como "net.openwebinars" en la línea donde usamos package . Teniendo esto en cuenta, para ejecutar el programa debemos ubicarnos en la raíz del paquete , es decir, dentro de la carpeta src de nuestro proyecto. Para ejecutarlo bastará con escribir:

java net/openwebinars/HelloWorld

Si se fijan no escribí la extensión .class ya que no es necesaria. Es muy importante situarse en la ruta raíz del paquete ya que si no nos dará un error similar a este:

Exception in thread "main" java.lang.NoClassDefFoundError: src/net/openwebinars/
HelloWorld (wrong name: net/openwebinars/HelloWorld)
        at java.lang.ClassLoader.defineClass1(Native Method)
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$100(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

En este caso yo estaba situado en la carpeta ProgramacionBitaBit y se produjo dicha excepción. Por ello insisto de nuevo que es muy importante tener en cuenta la posición actual en consola.

Ficheros JAR

Un fichero JAR es un archivo en el cual se comprimen los ficheros .class de nuestro proyecto. Además, si se configura correctamente, es un fichero ejecutable de los byetcodes que tenga dentro. De nuevo, los editores como Eclipse pueden generarte automáticamente los ficheros .jar. Para ello basta con hacer click con el botón derecho sobre el nombre de nuestro proyecto, darle a exportar y seguir las indicaciones para generar un fichero Jar ejecutable. En el caso de hacerlo desde consola, la ubicación donde estemos ha de ser la misma que sucedía en el caso de ejecutar, es decir, la raíz del paquete. Antes de generar el Jar, debemos crear un segundo fichero de texto el cual usará el Jar para buscar el bytecode con el Main del programa. Dicho fichero tiene el nombre de Manifiest o manifiesto. Su estructura es la siguiente:

Manifest-Version: 1.0
Class-Path: .
Main-Class: net.openwebinars.HelloWorld

• Manifest-Version indica la versión de nuestro programa
• Class-Path indica la raíz del proyecto
• Main-Class indica el bytecode del proyecto con el Main

Importante: al final del fichero Manifiest.txt hay que dejar una línea en blanco, de lo contrario no funcionará. Tras crear nuestro fichero Manifiest.txt, situándonos en la ruta raíz del paquete, para generar el fichero Jar bastará con hacer lo siguiente:

jar cvfm NombreFicheroJar.jar Manifiest.txt dominio/subdominio/*.class

siendo en el caso del HolaMundo

jar cvfm HelloWorld.jar Manifiest.txt net/openwebinars/*.class

Y, finalmente, para ejecutar el fichero Jar bastará con escribir en consola:

java -jar ruta/FicheroJar.jar

El fichero Jar se puede ejecutar desde cualquier directorio sin ser la raíz del paquete, por eso indiqué el campo ruta/ para que indicasen la ruta relativa desde donde están al fichero Jar o la ruta absoluta si lo prefieren. Nota: También es posible ejecutar el fichero Jar haciendo doble click en él. No obstante, como no tenemos una interfaz gráfica en nuestros programa en la mayoría de casos se abrirá la consola de comandos y se cerrará en cuestión de milisegundos (depende de programa claro) y no tendremos tiempo de ver los mensajes que se impriman. Hasta aquí el artículo de hoy. En el siguiente artículo veremos algo muy variable . ¡Hasta la próxima!

Listado de capítulos

En esta sección se listan todos los capítulos de este pequeño curso:

1. Introducción