Operadores y expresiones aritméticas

El lenguaje de programación Java incorpora una serie de operadores que permiten realizar cálculos y escribir expresiones que realicen una serie de operaciones sobre los datos.

• + (suma)
• - (resta)
• * (multiplicación)
• / (división entera o con decimales según operandos)
• % (resto de la división)

Todos estos operadores aritméticos deben utilizarse con dos operandos, situados delante y detrás de los operadores, pudiéndose encadenar las operaciones. Se pueden incluir espacios para aclarar más el código.

Los datos usados como operandos deben ser de alguno de los tipos de datos numéricos (byte, short, int, long, float o double). Ejemplos:

• 4 + 3
• 8 - 5 + 2
• 6 * 2 / 3
• 8.5 - 3 + 4.3
  

El resultado de la división tendrá decimales o no según el tipo de operandos que se utilice. Si los dos son enteros, el resultado no tendrá decimales, pero si al menos uno de los operandos es de tipo  numérico real (float o double) el resultado será de ese tipo. Ejemplos:

• 8 / 2 resulta 4
• 7 / 2 resulta 3
• 7.0 / 2 resulta 3.5
• 7 / 2.0 resulta 3.5
• 7.4 / 2 resulta 3.7
• 8 / 2.5 resulta 3.2
• 8.5 / 2.5 resulta 3.4

Es posible modificar el tipo de dato de cualquier operando indicando delante el nuevo tipo de dato entre paréntesis. Así se hace una conversión de tipo:

• (double)7 / 2 resulta 3.5
• 7 / (float)2 resulta 3.5

El operador resto se debe utilizar con tipos de datos numéricos enteros. El resultado será el resto de la división entre los dos operandos. Ejemplos:

• 7 % 2 resulta 1
• 8 % 3 resulta 2

El resultado de cualquier operación aritmética será del tipo de dato más grande que se utilice en los operandos. Por ejemplo, si se hace una operación entre dos números enteros (int) el resultado será del mismo tipo, pero si se hace entre un int y un long es resultado es de tipo long. Ejemplos:

• 2147483647 * 2 resulta un dato incorrecto, en concreto -2, porque se están multiplicando dos int y el resultado sobrepasa el límite de los enteros.
• 2147483647L * 2 resulta 4294967294 porque el primer operando es de tipo long (se ha indicado L al final).

Al igual que en las expresiones matemáticas habituales, los operadores aritméticos y en general todos los operadores, tienen un orden de precedencia:

1. Multiplicación (*), División (/) y Resto (%)
2. Suma (+) y Resta (-)

Dentro del mismo orden de precedencia, las operaciones se realizarán en orden de izquierda a derecha. Si es necesario cambiar el orden de precedencia, se deben utilizar paréntesis de la forma habitual. Ejemplos:

• 4 + 3 * 2 resulta 10 (4+6)
  
• (4 + 3) * 2  resulta 14 (7*2)
• 4 / 2 * 3 resulta 6

Utilizando la sentencia System.out.println(); se muestra, por salida estándar, el resultado de cualquier expresión aritmética o de cualquier otro tipo. Ejemplos:

• System.out.println((4 + 3) * 2);
  Muestra 14
• System.out.println("(4 + 3) * 2");
  Muestra (4 + 3) * 2 ya que lo considera una cadena de caracteres
  

Los caracteres pueden ser utilizados para realizar cálculos aritméticos. En caso de que aparezca algún carácter en una expresión aritmética, se toma el valor numérico que le corresponde a cada carácter en la tabla de codificación Unicode. Ejemplos:

• 'A' + 1 resulta 66, ya que el carácter 'A' tiene el código 65.
• (char)('A' + 1) resulta 'B' ya que se ha hecho una conversión de tipos del resultado, convirtiendo el valor 66 a su correspondiente carácter.
  

Inserción de comentarios en el código fuente

En el código fuente de un programa Java es posible escribir texto de forma libre, es decir, sin tener que seguir las normas del lenguaje Java, con el fin de indicar comentarios sobre las sentencias del programa. El texto escrito como comentario no es tenido en cuenta por el compilador.

Es recomendable escribir este tipo de comentarios ya que facilita la compresión del programa cuando es leído por otra persona o por el mismo creador, especialmente cuando ha pasado algún tiempo desde que fue escrito el código.

Para escribir un comentario, éste puede ir precedido por dos barras //, o bien, encerrado entre los caracteres /* y */. Si se utilizan las dos barras, el comentario sólo se puede escribir en una línea, a partir de esos caracteres. En caso de que el comentario vaya a ocupar más de una línea se debe utilizar el segundo método: /* comentario */.

Ejemplo:

// Esta línea es un comentario

System.out.println("Saludo"); // Comentario detrás

// Esta es la forma de comentar más de una línea utilizando
// las dos barras. Se incluyen dos barras al comienzo
// de cada línea

/* Esta segunda forma es mucho más cómoda para comentar
un número elevado de líneas ya que sólo requiere modificar
el comienzo y el final. */

Java incluye una utilidad llamada javadoc, que permite generar de forma automática alguna documentación de las aplicaciones. Para darle determinados datos a esa utilidad, se utiliza otro tipo de comentarios que comienzan con /** y terminan con */. Por ejemplo:

    /**
     * @param args the command line arguments
     */

Valores literales

Un valor literal es la representación de un valor fijo en el código fuente de un programa.

Los valores correspondientes a los tipos de datos numéricos enteros (byte, short, int y long) se pueden expresar usando el sistema numérico decimal, octal o hexadecimal. Los números en sistema decimal se expresan de la manera habitual, simplemente escribiendo su valor con los dígitos numéricos, por ejemplo, 284. No se pueden emplear separadores de millares, por lo que para indicar el valor 1.000.000 (un millón) se debe escribir como 1000000. Para representar valores negativos se añade el carácter "-" (guión) delante del número, como es habitual es la escritura normal, por ejemplo, -387.

Para representar un valor numérico entero en sistema octal, debe ir precedido del carácter 0 (cero), por ejemplo, el valor 284 se representa en octal como 0434. Así mismo, para representar un valor en el sistema hexadecimal, se debe emplear el prefijo 0x, por lo que el valor 284 se representa en hexadecimal como 0x11C.

Por defecto, los valores literales numéricos enteros se almacenan en memoria con el formato del tipo de dato "int". Si se desea almacenar como "long", con el fin de poder obtener resultados con valores muy altos en los cálculos, se debe emplear el sufijo L en mayúscula o minúscula (sería recomendable utilizar la L mayúscula por el parecido de la letra minúscula con el valor 1). Por ejemplo, el valor 284L correspondería al valor entero 284 utilizando 64 bits (tipo long) para almacenarlo en memoria.

Para representar valores literales de los tipos de datos numéricos reales (float y double) se puede emplear el sistema decimal o la notación científica. En el sistema decimal se expresan los números con parte decimal de la forma usual, utilizando el punto como separador de la parte entera y decimal. En este caso tampoco se puede emplear los separadores de millares. Así, por ejemplo, el valor 21.843,83 se debe expresar como 21843.83 en el código fuente.

Los números reales expresados en notación científica deben emplear la letra "E" o "e" para  separar la parte correspondiente al exponente. El valor 7,433·10⁶ se debe expresar como 7.433e6 en el código fuente. Si el exponente es negativo se escribe el guión detrás de la letra E, por ejemplo, 7,433·10^-6 se expresa como 7.433e-6, y si el valor es negativo se indica el guión al principio, por ejemplo, -7,433·10⁶ se expresa como -7.433e6.

Por defecto, los valores literales numéricos reales se almacenan en memoria con el formato del tipo de dato "double". Si se desea almacenar como "float", con el fin de emplear menos espacio de memoria y necesitar menos precisión en los resultados de los cálculos, se debe emplear el sufijo F en mayúscula o minúscula. Por ejemplo, el valor 21843.83F correspondería al valor entero 21843.83 utilizando 32 bits (tipo float) para almacenarlo en memoria, en vez de 64 bits.

Los valores literales de los tipos char (carácter) y String (cadena de caracteres), pueden contener cualquier carácter Unicode. Los valores de tipo char se debe expresar encerrados entre comillas simples (en los teclados españoles habituales se encuentra junto a la tecla del cero), por ejemplo, la letra A se debe expresar como 'A'. Por otro lado, las cadenas de caracteres (tipo String) se expresan entre comillas dobles (en la tecla del 2), por ejemplo, el texto Saludos a todos, se debe escribir como "Saludos a todos".

En caso de que se necesite escribir un carácter de la tabla de caracteres Unicode que no se encuentre en el teclado, se puede hacer indicando el código hexadecimal correspondiente a dicho carácter precedido del modificador \u (utilizando la barra invertida situada en la tecla junto al 1). En todo caso se debe encerrar entre comillas simples o dobles según se vaya a tratar como carácter o dentro de una cadena de caracteres. Por ejemplo, para escribir la letra griega beta (ß) se puede emplear '\u00DF', o para escribir la palabra España es posible utilizar "Espa\u00F1a".

El lenguaje de programación Java también soporta un pequeño conjunto de caracteres especiales que se pueden utilizar en los valores literales char y String:

\b (retroceso), \t (tabulador), \n (nueva línea), \f (salto de página), \r (retorno de carro), \" (comilla doble), \' (comilla simple), \\ (barra invertida).

Por ejemplo, la cadena de caracteres "La palabra "hola" es un saludo" se tiene que escribir en el código fuente como: "La palabra \"hola\" es un saludo", para que no confunda las comillas dobles de inicio y fin de la cadena de caracteres.
El carácter especial '\n' permite introducir un salto de línea dentro de una cadena de caracteres. Por ejemplo, "Primera línea\nSegunda línea" mostraría ese texto separado en dos líneas.

Los valores literales para el tipo de dato boolean sólo pueden ser true o false, que corresponden a los valores Verdadero y Falso. Hay que observar que se deben indicar sin comillas de ningún tipo, ya que no son cadenas de caracteres.

En un programa, es posible mostrar cualquiera de estos valores literales a través de la salida estándar (terminal, ventana de salida, etc) utilizando la siguiente sentencia:

System.out.println(valorLiteral);

o bien:

System.out.print(valorLiteral);

Donde valorLiteral debe ser el valor que se desea mostrar manteniendo las normas comentadas anteriormente.

Ambas sentencias se diferencian en que la primera (println) tras mostrar el valor realiza un salto de línea (como una pulsación de Intro), mientras que la segunda (print) no introduce el salto de línea por lo que si se muestra otro dato con otra sentencia print o println se mostrará justo a continuación.

Algunos ejemplos:

//Mostrar un valor numérico entero
System.out.print("Número entero: ");
System.out.println(284);

//Mostrar un valor numérico real
System.out.print("Número real: ");
System.out.println(21843.83);

//Mostrar un carácter
System.out.print("Carácter: ");
System.out.println('A');

//Mostrar una cadena de caracteres
System.out.print("Cadena de caracteres: ");
System.out.println("Saludos a todos");

//Mostrar un valor lógico
System.out.print("Valor lógico: ");
System.out.println(true);

Tipos de datos básicos

El lenguaje de programación Java permite la utilización de los siguientes tipos de datos básicos:

• Números enteros: Representan a los números enteros (sin parte decimal) con signo (pueden ser positivos o negativos). Se dispone de varios tipos de datos, ocupando cada uno de ellos un espacio distinto en memoria. Cuanta más capacidad de almacenamiento, más grande es el rango de valores permitidos, aunque ocupará más espacio de memoria principal. Se dispone de los siguientes tipos:
  
• byte: Ocupan 8 bits (1 byte), permitiendo almacenar valores entre -128 y 127.
• short: Ocupan 16 bits (2 bytes), permitiendo almacenar valores entre -32.768 y 32.767.
• int: Ocupan 32 bits (4 bytes), permitiendo almacenar valores entre -2.147.483.648 y 2.147.483.647. Es el tipo de datos por defecto para los valores numéricos enteros. Este tipo de datos es lo suficientemente grande para almacenar los valores numéricos que vayan a usar tus programas. Sólo se suelen usar los tipos anteriores si se pueden producir problemas con el espacio de memoria.
  
• long: Ocupan 64 bits (8 bytes), permitiendo almacenar valores entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807.

• Números reales: Representan a los números reales con parte decimal y signo positivo o negativo. Hay dos tipos de datos numéricos reales que permiten obtener mayor o menor precisión. Utilizan un método para almacenar los datos que puede ocasionar que el valor original varíe levemente del valor almacenado realmente. Cuanta más precisión se utilice, habrá menor variación.
  
• float: Ocupan 32 bits (4 bytes). Se le denomina de simple precisión.
  
• double: Ocupan 64 bits (8 bytes). Se le denomina de doble precisión. Es el tipo de datos por defecto para los valores numéricos reales.

• Valores lógicos: Representan dos únicos posibles valores: verdadero y falso.
• boolean: Ocupan 1 bit, pudiendo almacenar los valores true (verdadero) y false (falso).

• Caracteres: Representan las letras, dígitos numéricos y símbolos contenidos en la tabla de caracteres Unicode.
• char: Ocupan 16 bits (2 bytes). Permite representar un único carácter, por ejemplo la letra 'A'.
  
• String: Realmente no es un tipo de dato básico de Java, pero por su interés se incluye aquí. Permite representar un conjunto de caracteres, por ejemplo: "Saludos para todos".

Proyectos y clases Java con NetBeans

Las aplicaciones Java creadas con NetBeans se organizan como proyectos. Cada proyecto además está dividido en:

• Paquetes de fuentes
• Paquetes de prueba
• Bibliotecas
• Bibliotecas de pruebas

El código que se escriba, y las ventanas que se diseñen para la aplicación, se almacenarán en la sección "Paquetes de fuentes". En esa sección se crea por defecto un paquete con el mismo nombre que el proyecto.

Dentro de los paquetes de fuentes se pueden crear distintos tipos de archivos. Por ejemplo, se pueden crear Clases Java, que contendrán únicamente código en Java para realizar una determinada tarea. Se pueden crear también Formularios que serán las típicas ventanas de las aplicaciones con entornos gráficos. Los formularios para aplicaciones de escritorio se denominan Formularios JFrame.

Para crear un nuevo archivo dentro de un paquete de fuentes se puede utilizar el menú "Archivo > Archivo nuevo ..." o bien usar el menú contextual del paquete de fuentes.

Un mismo proyecto puede tener varias clases e incluso varios paquetes de fuentes como se puede ver en el siguiente ejemplo:

Pero siempre al menos una de la clases debe ser la clase principal, es decir, aquella por lo que debe empezar la ejecución de la aplicación que se está creando. La clases candidatas a ser clase principal se diferencia visualmente de las demás porque en su icono aparece un triángulo verde (en el ejemplo anterior se puede ver sobre la clase Anagrams.java). Pueden ser clases principales aquellas que contengan un método llamado "main" dentro de su código fuente.

    public static void main(String[] args)

Si se deseara establecer otra clase como principal, se puede realizar esa acción desde las propiedades del proyecto. A dichas propiedades se puede acceder desde el menú "Archivo > Project Properties" o desde el menú contextual abierto sobre el icono del proyecto. En la ventana de diálogo que aparece se debe elegir en la parte izquierda la sección "Ejecutar", y ahí aparece un campo de texto donde se puede indicar cuál será la clase principal.

Aunque un proyecto tenga varias clases definidas, en algunas ocasiones es interesante ejecutar una sola clase de manera individual para hacer algún tipo de prueba. Para ello se dispone de la opción "Ejecutar archivo" dentro del menú contextual que se puede abrir sobre el icono o el nombre de la clase que se desea ejecutar. La clase que se desee ejecutar debe tener un método "main".

Al crear un nuevo proyecto del tipo "Aplicación Java" con NetBeans, automáticamente se crea parte del código fuente del programa en una nueva "Clase Java", con la estructura básica para comenzar a escribir código en el mismo:

En caso de que al paquete de fuentes se le añada un "Formulario JFrame", es decir, una ventana, lo que se muestra es el diseño gráfico del formulario con la posibilidad de ir añadiendo componentes al formulario arrastrando los elementos deseados desde la Paleta.

Para ver el código fuente correspondiente a un formulario, se debe hacer clic en la parte superior donde se puede seleccionar entre "Fuente" y "Diseño".

Al seleccionar "Fuente" aparece en pantalla la estructura básica del código fuente del formulario.

La sentencia initComponentes(); que aparece en el código, es la que crea la ventana que se ha elaborado desde la vista "Diseño". Por tanto, cualquier modificación de la ventana o de sus elementos que se desee realizar desde código, deberá realizarse escribiendo las sentencias oportunas a continuación de esa instrucción.

En el código anterior, que ha sido generado automáticamente al crear un formulario, se puede observar que hay áreas sombreadas. Esas zonas no pueden ser modificadas por el programador desde el editor de código fuente, ya que están relacionadas con los elementos que han sido incluidos de forma gráfica en el formulario utlizando la vista "Diseño".

En NetBeans es posible tener abiertos simultáneamente varios proyectos, pero sólo uno de ellos será el "Proyecto principal". El proyecto que se encuentre seleccionado como proyecto principal será el que se ejecute cuando se lance la orden de Ejecutar desde NetBeans. El proyecto principal se diferencia visualmente de los demás porque aparece resaltado su nombre en negrita.

Es posible seleccionar otro proyecto como el principal desde el menú contextual abierto sobre el nombre del proyecto, o bien, desde el menú "Ejecutar > Establecer como proyecto principal".

En el menú contextual, y desde el menú "Archivo" se pueden "Cerrar" los proyectos que se encuentran abiertos. No confundir con "Eliminar", ya que esta operación puede borrar toda la información del proyecto almacenada en el disco duro.

Ejemplo de edición, compilación y ejecución por línea de comandos

Se va a mostrar a continuación cómo se puede crear el programa "Hola mundo" editándolo con un editor de textos, compilándolo y ejecutándolo desde la línea de comandos.

En primer lugar se escribe el código en un editor de textos sencillo, como el bloc de notas de Windows. El código del programa es el siguiente:

public class HolaMundo
{

public static void main(String args[])
{

System.out.println("Hola Mundo!");

}

}

Tras abrir el bloc de notas se copia y pega el código anterior.

El archivo se debe guardar asignándole el mismo nombre, exactamente, que el indicado tras la palabra "class". En este caso es "HolaMundo". Además, el archivo debe tener la extensión ".java", por lo que en la ventana de diálogo de Guardar se debe seleccionar el tipo "Todos los archivos" (ya que no es un archivo de texto txt), y en el cuadro de texto del nombre se debe indicar: "HolaMundo.java", comprobando que se respetan las mayúsculas y minúsculas.

Si el archivo se guarda en la carpeta "Mis documentos", al abrir el "Símbolo del sistema" se debe acceder a dicha carpeta. Por defecto se abre en la carpeta principal del usuario (C:\Documents and settings\usuario). Para ir a la carpeta "Mis documentos" se debe ejecutar el comando: "cd Mis documentos" (Si el archivo que contiene el código fuente se ha guardado en otra carpeta se debe acceder a dicha carpeta utilizando el comando CD seguido de la ruta completa hasta dicha carpeta).

Una vez que estemos situados en la carpeta donde se ha almacenado el archivo java, se debe llamar al compilador Java indicándole el nombre del archivo que contiene el código fuente a compilar. En este caso se debe ejecutar: "javac HolaMundo.java".

Si el código se ha escrito correctamente, no debe aparecer ningún mensaje en pantalla. En caso de que haya algún error en el código fuente, se mostrará el error encontrado tras llamar al compilador.

Para comprobar que se ha generado el archivo compilado "HolaMundo.class" se puede utilizar el comando "dir".

Ya sólo queda ejecutar el programa compilador, utilizando el comando: "java HolaMundo". Si todo ha ido bien, aparecerá el mensaje que se había escrito en la sentencia "System.out.println", que en este caso era "Hola Mundo!".

Instalación del compilador de Java (Java Development Kit - JDK)

Desde el sitio web de java (java.sun.com) debe realizarse la descarga del compilador de Java (Java Development Kit - JDK), desde la sección descargas (Downloads).

Aparecen varias descargas posibles, por lo que hay que localizar aquella que indique algo como Java SE Development Kit (JDK).

Se debe seleccionar la plataforma (sistema operativo) en el que se desea hacer la instalación (por ejemplo, Windows), y hay que marcar la casilla "I agree to the Java SE Development Kit License Agreement" si estamos de acuerdo con la licencia de Java.

Es posible que aparezca una nueva página con una serie de posible archivos que pueden descargarse. En ese caso deberemos elegir el que haga referencia al Java SE Development Kit. Haciendo clic en el nombre del archivo (en este ejemplo es: jdk-6u16-windows-i586.exe) comenzará directamente la descarga del programa. En ese momento tenemos la opción de abrirlo directamente o guardarlo para abrirlo posteriormente teniendo así la posibilidad de dejarlo guardado para otro momento.

Una vez finalizada la descarga comienza la instalación.

Hacer clic en "Continue".

Para continuar con la instalación, se debe aceptar la licencia pulsando el botón "Accept >".

Es posible especificar exactamente qué programas o características se desean instalar. SI no se desea una instalación muy personalizada se puede dejar todo por defecto y hacer clic en "Next >" para continuar.
Conviene observar la carpeta en la que se va a realizar la instalación del compilador. En este caso se puede ver que es: "C:\Archivos de programa\Java\jdk1.6.0_16\". Según la versión descargada, variará dicha carpeta.

Al finalizar el proceso hay que hacer clic en el botón "Finish".

Ahora es el momento de comprobar si se ha realizado bien la instalación y hacer algún último ajuste.
Debemos abrir el "Símbolo del sistema" que se puede encontrar en "Inicio > Todos los programas > Accesorios > Símbolo del sistema".
La llamada al compilador de Java desde el Símbolo del sistema se hace con el comando javac.
Se puede comprobar que al escribir directamente ese comando, realmente no funciona, ya que se debería especificar en qué carpeta se encuentra instalado el compilador.

En cambio, al llamar al comando "javac" especificando delante la ruta completa donde se ha realizado la instalación, debería funcionar correctamente. Para comprobar cuál es la carpeta donde se ha hecho la instalación se puede abrir el icono "Mi PC" y buscar en la unidad C: dentro de la carpeta "Archivos de programa" y "Java". En ella aparecerá una carpeta con el nombre "jdk" seguido de los números correspondientes a la versión instalada. Dentro de esa carpeta existe otra llamada "bin" que al abrirla se debe encontrar el archivo ejecutable "javac". En la barra de direcciones se puede observar la ruta seguida hasta encontrar el compilador. En este ejemplo es "C:\Archivos de programa\Java\jdk1.6.0_16\bin".

En este caso, la llamada se hace con el comando "C:\Archivos de programa\Java\jdk1.6.0_16\bin\javac", dejando incluso las comillas para que los espacios los considere como parte de la llamada al compilador. Recuerda que dependiendo de la versión del JDK descargada, la carpeta de instalación variará.

Lo ideal para usar con comodidad el compilador es no tener que escribir continuamente la ruta completa. Para ello debemos incluir dicha ruta en la variable PATH del sistema. Eso se hace siguiendo los siguientes pasos:

Entrar en la "Propiedades" de "Mi PC", por ejemplo, haciendo clic con el botón derecho sobre el icono de "Mi PC" y seleccionar "Propiedades" en el menú contextual abierto.

Acceder a la pestaña "Opciones avanzadas" y hacer clic en el botón "Variables de entorno".

En la sección "Variables del sistema" seleccionar la variable "Path" y hacer clic en el botón "Modificar".

En el campo de texto "Valor de variable" se debe escribir al final del contenido que hubiera la ruta al compilador que hemos comentado anteriormente. Recuerda que se debe escribir al final de lo que hubiera utilizando como separador el signo punto y coma ";". Por ejemplo, en este caso se ha añadido al final ";C:\Archivos de programa\Java\jdk1.6.0_16\bin". No utilices espacios en la separación, sólo el punto y coma.
Haz clic en "Aceptar" para finalizar.

Ahora debería funcionar correctamente la llamada al compilador desde el "Símbolo del sistema" sólo con llamar al comando "javac".

Primer programa en Java con NetBeans

Para desarrollar un programa en Java con netBeans se debe crear un proyecto, para lo cual, tras abrir el programa se debe elegir la opción Proyecto Nuevo del menú Archivo, o bien hacer clic en el botón de la barra de herramientas similar al que aparece en dicho menú.

En función del tipo de distribución de NetBeans descargado e instalado, aparece un listado de tipos de Proyectos que se pueden crear, los cuales aparecen agrupados en Categorías.

Para crear un programa básico en Java, para ser utilizado bajo el Símbolo del sistema o el Terminal, hay que seleccionar la Categoría Java y el tipo de Proyecto debe ser Aplicación Java.

Tras hacer clic en el botón Siguiente comenzará el asistente que permite crear un proyecto del tipo seleccionado.

En primer lugar se especifica el nombre del proyecto a crear dentro del cuadro de texto Nombre del proyecto. Es lo único que debe modificarse en esta ventana de diálogo. Para este ejemplo se ha indicado el nombre HolaMundo. En este nombre se pueden utilizar espacios aunque posteriormente los archivos que se crean serán eliminados o sustituidos por el guión bajo.

Tan sólo con eso comenzará el proceso de creación del nuevo proyecto tras hacer clic en el botón Terminar. El progreso de la creación del proyecto puede observarse en la barra que aparece en la parte inferior, el cual, una vez finalizado, dará paso al entorno de desarrollo donde se deberá escribir el código del programa.

El código fuente de la aplicación debe escribirse en el editor de textos de la parte derecha donde inicialmente aparece la siguiente plantilla sobre la que se puede escribir el resto del código:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package holamundo;

/**
 *
 * @author Usuario
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println("Hola mundo");
    }

}

Las instrucciones que vayan a formar parte de la aplicación deberán escribirse sustituyendo la línea comentada en la que aparece:

// TODO code application logic here

En el primer programa que se va a desarrollar únicamente debe mostrarse en pantalla el típico mensaje "Hola mundo". Por lo que se escribirá en ese lugar la orden:

System.out.println("Hola mundo");

Ahora es el momento de compilar el código escrito, para lo que se dispone en el menú Ejecutar de las opciones Build Main Project que realiza el proceso de compilación, o de Clean and Build Main Project que además de compilar realiza previamente una limpieza de cualquier compilación anterior. Por tanto, optaremos por una de estas soluciones.

Estas herramientas pueden ser utilizadas desde los botones de la barra de herramientas donde se muestra el mismo icono que el mostrado en el menú Ejecutar.

El resultado de la compilación se puede ver en la parte inferior de la ventana. En caso de que la compilación haya sido satisfactorio aparece en la barra de estado, durante un tiempo, el mensaje "Ha terminado la generación de ...".

Pero si hay errores en el código fuente éstos se mostrarán en la ventana de Salida que se abre en la parte inferior derecha. Al detectarse los errores se abre automáticamente esa pestaña, pero se puede especificar que se muestre desde el menú Ventana > Salida > Salida. La pequeña X que aparece en el título de la pestaña Salida permite cerrarla.

Para realizar la ejecución del programa hay que seleccionar la opción Ejecutar > Run Main Project, o realizar eso mismo desde el botón de la barra de herramientas en forma de triángulo verde (como un botón Play de un reproductor).

El resultado de la ejecución aparece en la ventana Salida.

Estructura de archivos en proyectos NetBeans

En la parte izquierda de la ventana de NetBeans aparecen tres pestañas que permiten mostrar distinta información en ese panel: Proyectos, Archivos y Prestaciones.

Al seleccionar la pestaña Archivos, se muestra un árbol con las carpetas y archivos que se crean automáticamente al generar un proyecto.

Las carpetas más interesantes son las siguientes:

• La carpeta "build" contiene las clases compiladas (.class).
• En la carpeta "dist" se crea un archivo comprimido con la extensión ".jar" que contiene todos los archivos necesarios para distribuir la aplicación generada y que pueda ser ejecutada.
• La carpeta "src" almacena los archivos con el código fuente (.java) que hemos escrito o que forman parte de la aplicación.
  

Todas esas carpetas y archivos pueden encontrarse con la misma estructura dentro del disco duro en la carpeta donde se haya creado el proyecto.

Editores, compiladores y entornos de desarrollo para Java

El proceso habitual para crear una aplicación informática ese editar el código fuente (escribir el programa en el lenguaje de programación elegido), compilarlo (es decir, traducirlo al lenguaje máquina) y ejecutar la aplicación. Pero ahí no termina el proceso, porque lo más habitual es que haya se detecten errores o se necesiten mejoras del programa que requieran que se vuelva a editar, compilar y ejecutar para ver los nuevos resultados, lo cual se puede repetir numerosas veces. Esos errores se pueden detectar en el momento de la compilación, o durante la ejecución.

Para editar un programa en Java se puede utilizar desde un sencillo editor de textos como el Bloc de notas, hasta un entorno de desarrollo más completo como NetBeans, Eclipse o Jcreator. No  se puede utilizar un editor de textos que aplique formato al texto como lo hace Word u OpenOffice Writer.

Para escribir el código fuente de un programa Java desde un editor de textos, se debe escribir el código del programa y hay que guardarlo con la extensión ".java". Los entornos de desarrollo harán esto automáticamente.

Hay editores de textos con la sencillez del Bloc de notas pero que añaden otras mejoras, como el coloreo del código para facilitar su análisis, creación de macros que automaticen algunas tareas habituales, etc. Algunos ejemplos de editores gratuitos para son Notepad++ o Scite.

Para compilar un programa Java se necesita tener instalado correctamente en el ordenador el compilador Java de Sun que se puede descargar libremente desde la página Java de Sun (java.sun.com), con el nombre JDK (Java Development Kit). Existe una versión del JDK para cada perfil de Java (Java SE, EE, ME, FX, etc).

Descarga del Java SE Development Kit 6 update 16

Una vez instalado el compilador se puede compilar un programa Java desde el Símbolo del sistema o el Terminal con la orden:

rutaCompilador\javac nombreArchivo.java

donde rutaCompilador es la ruta completa a la carpeta donde se haya instalado el compilador, y nombreArchivo es el nombre del archivo que contiene el código fuente.

Al realizar la compilación del código fuente Java, y si no se han detectado errores, se crea un archivo con el mismo nombre que el archivo que contiene el código, pero con la extensión ".class". Ese es el archivo que puede ser ejecutado. Para ello, desde el Símbolo del sistema o el Terminal se debe escribir la orden:

java nombreArchivoJava

Hay que observar que en este caso no se debe escribir la extensión del archivo.

Para poder ejecutar un programa Java no es necesario disponer del archivos o los archivos que contienen el código fuente, tan sólo en necesario tener los archivos compilados. Por ello, si deseamos distribuir una aplicación que hemos creado, y no queremos que pueda ser modificado por otras personas, sólo se deben hacer públicos los archivos compilados, junto con los recursos necesarios (imágenes, sonidos, etc).

Los entornos de desarrollo integrado (IDE) son aplicaciones que permiten realizar todo el proceso de desarrollo de aplicaciones desde un mismo programa. Es decir, con uno de estos programas podemos editar, compilar, ejecutar programas en Java o en muchos otros lenguajes de programación, y todo dentro de un entorno gráfico. Además cuentan con otras herramientas de ayuda para la programación como la depuración (para la búsqueda de errores), coloreado del código fuente, plantillas predefinidas con la estructura básica de aplicaciones, etc.

Para Java, los principales entornos de desarrollo son NetBeans (que cuenta con el apoyo de Sun), Eclipse y JCreator. Los dos primeros son gratuitos, con soporte de idiomas y multiplataforma (Windows, Linux, MacOS).

Descarga de NetBeans IDE

Lenguaje de programación Java

Java es un lenguaje de programación desarrollado por Sun Microsystems a principios de los años 90. Toma mucha sintaxis de los lenguajes de programación C y C++, aunque se han eliminándose algunas herramientas de bajo nivel que inducían a errores en el desarrollo de las aplicaciones.

En 2007 se liberó la mayor parte de la tecnología Java bajo licencia GNU GPL, de tal forma que prácticamente todo el lenguaje Java de Sun es ahora software libre.

Existen varias teorías sobre el origen del nombre Java aunque la más aceptada es la del nombre de un tipo de café que se servía en una cafetería que frecuentaban sus creadores, de ahí que el icono de Java sea una taza de café.

Java es un lenguaje multiplataforma, por lo que un mismo programa escrito en Java puede ser ejecutado en distintos tipos de ordenadores o plataformas, por ejemplo, Windows, Unix, Macintosh, etc.

Para poder ejecutar un programa Java es necesario tener instalado en el equipo una máquina virtual Java. Se trata de un programa que traduce las instrucciones compiladas del programa Java al lenguaje máquina que corresponda, según la plataforma bajo la que se ejecute el programa. Sun proporciona de forma gratuita una máquina virtual Java con el nombre Java Runtime Environment (JRE) que puede descargarse desde la web de Java. buscando la versión correspondiente al sistema operativo sobre el que se desea ejecutar el programa.

Con Java se pueden desarrollar aplicaciones para diversos entornos de funcionamiento:

• Sin entorno gráfico, para el terminal.
• Con entorno gráfico de Windows, Linux o MacOS.
• Aplicaciones para páginas web.
• Aplicaciones para dispositivos móviles: Teléfonos, PDA, etc.
• Para sistemas de servidor.

Sun lanzó la primera versión pública como Java 1.0 en 1995. Con la aparición de Java 2 (lanzado inicialmente como J2SE 1.2 en 1998), las versiones nuevas tuvieron diversas configuraciones en función del tipo de plataforma a las que estaban orientadas.

• J2SE: Edición estándar de Java (Java 2 Standard Edition).
• J2ME: Desarrollo de aplicaciones para dispositivos móviles (Java 2 Mobile Edition).
• J2EE: Desarrollo de aplicaciones empresariales (Java 2 Enterprise Edition).

A partir de 2006 las nuevas versiones de Java 2 se renombraron como Java SE, Java ME y Java EE, respectivamente.
En 2009, ha aparecido JavaFX orientado al desarrollo de aplicaciones de Internet, ejecutables en distintos tipos de dispositivos, con el fin de competir con Flash de Adobe.

Historia y evolución de los lenguajes de programación

Los primeros ordenadores programables utilizaban combinaciones de interruptores y cambios en el cableado para establecer el comportamiento de la máquina. Un ejemplo es ENIAC, considerada la primera computadora electrónica de propósito general, que fue presentada en 1946. Fue utilizada para el cálculo de trayectorias de proyectiles, pudiendo resolver, por ejemplo, 5000 sumas en 1 segundo.

Otra forma de indicar las operaciones que debía realizar el ordenador, así como los datos sobre los que debía operar, era mediante tarjetas perforadas. En ellas se realizaban una serie de perforaciones que permitían codificar la información como si fuera un código binario (perforado, no perforado). Un dispositivo lector de tarjetas realiza la lectura columna a columna obteniendo la información que se encuentra codificada en la tarjeta,

Con el fin de facilitar la tarea de realizar la programación surge el lenguaje ensamblador, mediante el cual cada instrucción del lenguaje máquina se convierte en un código nemotécnico más fácil de utilizar por los programadores. Por ejemplo, para indicar al ordenador que realice una suma se debe utilizar la instrucción ADD. Este tipo de lenguaje de programación se considera de bajo nivel por su cercanía con el lenguaje máquina que utiliza internamente el procesador.

Este lenguaje tiene como inconvenientes que requiere un alto conocimiento del funcionamiento interno del ordenador, los programas no son transportables de un tipo de ordenador a otro, y resulta bastante difícil escribir los programas. Por otro lado, tiene la ventaja de que la ejecución de los programas es muy rápida.

Ejemplo de programa "Hola mundo" en lenguaje ensamblador para procesadores x86:

 .model small
 .stack
 .data
 Cadena1 DB 'Hola Mundo.$'
 .code
 programa:
    mov ax, @data
    mov ds, ax
    mov dx, offset Cadena1
    mov ah, 9
    int 21h
 end programa
 

A medida que los programas van siendo más complejos, la programación en ensamblador se va haciendo más complicada, así como la tarea de mantenimiento de la programas escritos en ese lenguaje. Por ello van apareciendo otros lenguajes llamados de alto nivel que se asemejan más al lenguaje humano.

Los programas escritos en lenguajes de alto nivel son más fáciles de escribir por los programadores y realizar su mantenimiento, pueden ser ejecutados en distintos tipos de ordenadores sin tener que modificar el código y no requieren un alto nivel de conocimiento del funcionamiento interno del ordenador. Pero las instrucciones escritas en esos lenguajes deben ser traducidas a lenguaje máquina para que puedan ser comprendidas por el procesador, por lo que es necesario utilizar programas traductores como los compiladores o intérpretes.

Uno de los primeros lenguajes de alto nivel que aparecieron, sobre el año 1955, y que tuvo una gran difusión fue Fortran. Este lenguaje se considera de propósito general, aunque estaba especialmente orientado al cálculo numérico y científico.

Ejemplo de programa "Hola mundo" escrito en Fortran:

PROGRAM HOLA
   PRINT *, '¡Hola, mundo!'
END

Otros lenguajes de propósito general que han sido amplamente utilizados: Basic (1964), Pascal (1970), C (1972), C++ (1983), Perl (1987), Java (1995), etc.

Han aparecido también lenguajes que, en vez que tener un enfoque de propósito general, están especializados en el desarrollo de aplicaciones de un determinado tipo. Por ejemplo, Cobol (1960) está orientado al sector empresarial, Prolog (1972) a la inteligencia artificial, SQL (1978) a la gestión de bases de datos, PHP (1995) al desarrollo web, etc.

Linea de tiempo de la historia de los lenguajes de programación (en inglés)