Programação em Java com Áudio

Vista previa del material en texto

Programación 
en Java desde 
la perspectiva 
del audio 
2 
 
PROGRAMACIÓN EN JAVA 
DESDE LA PERSPECTIVA DEL AUDIO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
JUAN DAVID LOPERA RIBERO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
PONTIFICIA UNIVERSIDAD JAVERIANA 
FACULTAD DE ARTES 
 CARRERA DE ESTUDIOS MUSICALES - INGENIERÍA DE SONIDO 
BOGOTÁ 
2010
i 
 
TABLA DE CONTENIDOS 
Preliminar 
 
Introducción ........................................................................................................................................ 1 
Antes de empezar ............................................................................................................................... 7 
NetBeans IDE .................................................................................................................................... 18 
Bases del lenguaje 
 
Anatomía de Java ............................................................................................................................. 24 
Variables ........................................................................................................................................... 30 
Comentarios ...................................................................................................................................... 35 
Tipos de Variables............................................................................................................................. 37 
Arreglos ............................................................................................................................................. 42 
Matemáticas ..................................................................................................................................... 45 
Sentencias de prueba 'if' .................................................................................................................. 51 
Ciclos ................................................................................................................................................. 57 
Métodos ............................................................................................................................................ 63 
Ámbitos locales ................................................................................................................................. 71 
Conversión de tipos .......................................................................................................................... 74 
Los Objetos 
 
¿Qué son los objetos? ...................................................................................................................... 78 
Encapsulación ................................................................................................................................... 84 
Herencia ............................................................................................................................................ 93 
ii 
 
Polimorfismo .................................................................................................................................. 101 
Clases externas ............................................................................................................................... 105 
Más allá de las bases 
 
Excepciones ..................................................................................................................................... 111 
Multihilos ........................................................................................................................................ 116 
Estáticos .......................................................................................................................................... 119 
¿Qué es un API? .............................................................................................................................. 122 
GUI .................................................................................................................................................. 127 
Eventos ............................................................................................................................................ 146 
MIDI API 
 
Números binarios, decimales y Qué es MIDI ................................................................................. 152 
La comunicación MIDI .................................................................................................................... 157 
La información MIDI ....................................................................................................................... 170 
Bancos de sonidos .......................................................................................................................... 183 
Archivos MIDI ................................................................................................................................. 189 
Edición de secuencias ..................................................................................................................... 192 
Sampled API 
 
Teoría de audio digital .................................................................................................................... 195 
Explorando los recursos del sistema .............................................................................................. 207 
Capturar, grabar y reproducir ........................................................................................................ 219 
iii 
 
Programación de un metrónomo 
 
Una aplicación real ......................................................................................................................... 226 
Planeación ....................................................................................................................................... 228 
Programando .................................................................................................................................. 232 
Resultado y código completo ......................................................................................................... 249 
Final 
 
Conclusiones ................................................................................................................................... 268 
Bibliografía ...................................................................................................................................... 273
1 
 
Introducción 
 
Como ingeniero de sonido me he encontrado en situaciones en las que pienso que 
sería muy útil un software que cumpliera cierta función para alguna necesidad 
particular. Como músico me ha pasado muchas veces también. Más importante 
todavía, he visto que estos pensamientos les ocurren a la mayoría de ingenieros 
de sonido. Buscar un programador que realice exactamente lo que necesitamos 
no es fácil y además es muy costoso. Aunque sé que programar y diseñar un 
software no es para todo el mundo, si creo que todo ingeniero, no sólo los de 
sonido, deben al menos tener bases sólidas en programación ya que esto permite 
desarrollar una forma de pensamiento diferente y permite crear por uno mismo 
soluciones a necesidades diarias que explotan nuevas formas de negocio. 
 
Hoy día es necesario demostrar que no todo músico tiene que ser pobre, debemos 
derrumbar la idea que solo se puede triunfar en el escenario o que para sobrevivir 
como músico e ingeniero de sonido la única posibilidad que tenemos es ser 
profesores. Es necesario encontrar nuevos nichos de mercado y esto sólo se 
puede lograr con creatividad y nuevos conocimientos. Aunque este escrito no 
pretende enseñar ni demostrar cómo hacerse rico con la programación de 
aplicaciones en Java, si quiero aclarar que me siento orgulloso de poder presentar 
de una forma clara y ordenada una introducción a lo que creo que es el futuro para 
muchos ingenieros de sonido que son capaces de crear sus propias herramientasde trabajo y contribuyen en nuestro mundo con soluciones creativas. 
 
Quiero contar cómo terminé involucrado en el mundo de la programación, esto 
para explicar por qué enfoco este proyecto de grado en la programación en Java y 
no en otro lenguaje de programación. A comienzos de 2008 me interesé por 
encontrar nuevos sitios de trabajo y terminé ocupado en la producción de audio 
para páginas web. 
 
2 
 
Al estar en este mundo terminé por conocer al amigo número uno del audio en el 
mundo web, estoy hablando de Adobe Flash. Hoy día el 95% de los computadores 
en el mundo tienen instalado Flash Player (http://riastats.com/, 2010) que es el 
componente necesario en un navegador para ver contenido creado en Adobe 
Flash. Este programa se ha hecho muy popular gracias a las facilidades que 
brinda a los diseñadores para crear contenidos ricos visualmente, permite crear 
animaciones fácilmente, agrega nuevas formas de interacción con el usuario, 
permite crear juegos y además agregar audio es muy fácil. En la gran mayoría de 
sitos web a los que entramos que manejan audio, este proceso está siendo 
posible gracias a Flash. 
 
A finales de 2008 descubrí que a la gente le gusta aprender sin salir de casa, no 
sólo hablo del profesor a domicilio sino de las comodidades que tiene aprender en 
internet. Decidí crear una academia de música online que enseña con videos, 
juegos y foros. La mejor forma para poder crear esta página1 era usar Flash de 
Adobe para manejar los videos, para crear los juegos y para incrustar el audio en 
los botones. Para empezar a desarrollar los juegos aprendí que Flash usa un 
lenguaje llamado ActionScript 3.0 que es el lenguaje que nos permite agregar 
interacción a las aplicaciones. Después de lanzar www.ladomicilio.com en 2009, 
decidí que quería hacer un metrónomo que la gente pudiera usar en mi página sin 
necesidad de descargarlo. Empecé a desarrollarlo y en medio del proceso me di 
cuenta que mi metrónomo no era preciso en el tiempo, nada más frustrante y más 
dañino que una página que enseña música con un metrónomo que funciona mal. 
Al comienzo pensé que era culpa de mi inexperiencia programando, pero después 
de aprender más, preguntar a expertos y ver otros metrónomos online, entendí 
que Flash NO ES preciso en el tiempo. Entre mis planes de trabajo también quería 
agregar un juego que permitiera al usuario tocar un ritmo con el teclado del 
computador y el programa detectaría las imprecisiones rítmicas del usuario. Como 
Flash no puede cumplir estas tareas, me vi en la obligación de buscar otros 
medios. 
 
1
 La.Do.Mi.Cilio es el nombre de la empresa creada a partir de esta idea. www.ladomicilio.com 
3 
 
 
Debo aclarar que Flash es un excelente programa con muchas posibilidades. Si 
hoy me piden crear un juego o una aplicación con música que no requiera 
precisión exacta en el tiempo como un reproductor, un juego de seleccionar la 
respuesta correcta o cualquier otro parecido, no dudo en usar Flash y ActionScript 
3.0. Pero cuando la situación se vuelve un poco más exigente como un 
metrónomo y un juego de precisión rítmica, debo encontrar otra solución. 
Desafortunadamente después de esto descubrí que había muchas otras tareas 
que Flash no podía hacer para nosotros los músicos e ingenieros de sonido. Por 
ejemplo no podemos manipular los archivos de audio de forma extensiva, no 
podemos trabajar con MIDI, Flash no soporta ningún archivo de audio en WAVE o 
AIFF, solamente mp3 y AAC. 
 
Investigando aprendí que el lenguaje de programación que era capaz de resolver 
todos mis problemas y necesidades era Java. Debo aclarar que aunque Java está 
presente en el 70% de los computadores según las estadísticas de 
http://riastats.com/ y Flash Player está instalado casi en el 95% de los 
computadores, esta desventaja no es un problema grande, sólo hay que tenerla en 
cuenta y saber que instalar Java es extremadamente fácil y es gratis, además 
estas estadísticas no incluyen la cantidad de dispositivos móviles como celulares 
que permiten compatibilidad con Java. 
 
Hoy día es casi imposible pensar que se está haciendo un trabajo único. Somos 
en el mundo más de seis mil millones de personas y aunque los medios nos 
permiten conocer gran cantidad de eventos que están ocurriendo a medio planeta 
de distancia, es muy difícil saber exactamente cuántos trabajos de este mismo tipo 
se están desarrollando a esta misma hora o incluso cuántos ya salieron a la luz 
pública pero no han tenido la suerte de dar con los efectos de la globalización. 
 
Publicaciones, trabajos, monografías, libros, revistas y páginas en internet sobre 
Java hay cantidades inimaginables, pero estos mismos tipos de trabajo que hablen 
4 
 
claro sobre Java y su relación con el audio son muy pocos. Muchos de estos 
textos no solo son aburridos sino que son muy difíciles de entender ya que dan por 
entendido que uno tiene alguna experiencia en programación. Una vez 
aprendemos a programar o tenemos algún tipo de experiencia en un lenguaje, es 
más fácil aprender otro ya que la idea básica es muy parecida de un lenguaje a 
otro y lo que termina cambiando es la sintaxis. En este proyecto de grado pretendo 
enseñar a usar Java para que la persona que lea este trabajo esté en la capacidad 
de crear aplicaciones básicas de audio. 
 
Me basaré principalmente en un libro llamado Head First Java segunda edición de 
la editorial O'Reilly Media que leí de comienzo a final y que a pesar de sus 722 
páginas, es muy agradable de leer y además es un libro que entiende la 
importancia de enseñar de forma divertida y diferente. Además de lo anterior, tiene 
un capítulo dedicado a MIDI. Recomiendo este libro para todo el que quiera 
entender Java. Aclaro que hay que tener un mínimo de experiencia en 
programación para leerlo. 
 
Un lenguaje de programación como Java nos permite crear casi cualquier 
aplicación que imaginemos, esto significa que no pretendo ni puedo enseñarles a 
diseñar todo lo que se puede hacer en audio con Java. Por ejemplo pensemos en 
un editor de audio como Pro Tools, Logic, Sonar o alguno semejante. Un software 
como estos puede ser creado en Java2 pero imaginen todo el equipo de 
producción que puede requerir crear tal software. Por lo tanto está fuera de los 
límites profundizar a semejante nivel en un proyecto de grado, pero si es posible 
obtener unas bases sólidas para empezar a programar en Java que le permitan a 
la persona que lea este escrito profundizar en el tema que más le interese y 
gracias a estas bases estoy seguro que podrá entender un texto avanzado de 
Java fácilmente. 
 
2
 Aunque un editor de audio tan complejo como los que existen hoy día puede ser creado en Java, no es 
buena idea usar este lenguaje de programación para programas tan complejos ya que como veremos más 
adelante, Java es un lenguaje que debe ser interpretado por nuestro computador y esto lo hace un poco 
más lento para aplicaciones tan demandantes. 
5 
 
 
Personalmente tengo experiencia programando en php3, ActionScript 3.0 y 
JavaScript4 que aunque no son lenguajes para lograr lo que queremos en audio si 
me permiten tener la experiencia para explicarles de forma clara y tratar de 
evitarles todos los errores que cometí cuando empecé a programar. Yo sé lo difícil 
y tedioso que puede llegar a ser aprender un lenguaje de programación cuando ni 
siquiera entendemos bien qué es un lenguaje de programación, y esta es por lo 
general la realidad de los Ingenieros de sonido. Así que los ayudaré a entender sin 
necesidad de saber nada. No sólo pretendo que el lector pueda entender y 
divertirse en el proceso, pretendo crear conciencia sobre la necesidad de explotar 
otras formas de negocio que son tan necesarias hoy día en cualquier carrera. 
 
Durante la carrera, unagran mayoría de conocimientos adquiridos en materias 
como audio digital y audio analógico, entre otras, fueron vistos de manera teórica 
únicamente, sin poder entender una verdadera aplicación de los mismos. Más de 
100 páginas de este proyecto de grado están enfocadas en aplicaciones reales del 
mundo de la programación, que permitirán entender de forma práctica muchos de 
estos conocimientos que a veces creemos que no tienen ningún fundamento o no 
sirven para nada. 
 
Al finalizar este texto, el lector tendrá la habilidad de entender el lenguaje Java de 
forma básica pero robusta, entendiendo la importancia de la programación 
orientada a objetos. También podrá entender de manera general las facilidades 
que nos brinda este lenguaje en el mundo del audio. De forma práctica, el lector 
podrá crear un metrónomo completo que le permitirá entender el uso de Java en 
esta aplicación de la vida real. 
 
3
 php es un lenguaje muy importante y popular en las páginas de internet. Aunque no permite trabajar con 
audio es casi siempre el elegido para trabajar con bases de datos. Páginas como facebook existen gracias a la 
programación en php. 
4
 JavaScript es un lenguaje que está presente en la gran mayoría de páginas de internet. No se puede 
confundir con Java ya que son lenguajes completamente diferentes. Gracias a este lenguaje apareció una 
forma de programación muy popular llamada AJAX que ha permitido crear páginas que parecen más un 
software que una página en sí. Gracias a AJAX podemos usar páginas como http://maps.google.com/ 
6 
 
 
A lo largo de este texto, evitaré el uso de tercera persona, típico de escritos 
formales, para acercarme al lector de una manera más personal, que permite 
desde el punto de vista pedagógico, entender más fácilmente temas que puedan 
llegar a ser complejos. 
 
Si bien varios de los programas que sugeriré para el desarrollo de Java podrían 
venir en un anexo digital a este proyecto de grado, es importante entender que 
nuevas versiones actualizadas y gratis pueden descargarse desde internet. Es por 
esta razón que en vez de agregar los programas que en cualquier momento 
quedarán obsoletos, escribiré las páginas desde las cuáles se pueden bajar todas 
las herramientas necesarias para seguir este escrito. Debido a que el metrónomo 
que se creará hacia el final del texto es de uso comercial privado, éste tampoco 
puede ser anexado al trabajo y es tomado únicamente como referencia de cómo 
programar una aplicación en el mundo productivo. 
 
Si por una razón Java sobresale entre tantos lenguajes de programación es por 
todo su poder de control y por su slogan "write once, run everywhere", esto 
significa que escribimos el código una vez y el mismo resultado nos funciona en 
MAC, PC, dispositivos móviles e internet. Esta flexibilidad y robustez no se 
encuentra en ningún otro lenguaje de programación famoso. Estamos a punto de 
aprender un lenguaje tan poderoso que es usado para crear los menús y permitir 
la reproducción de Blu-Ray, se ha usado en el Robot que la NASA envió a Marte y 
también es usado en el famoso Kindle. 
 
Usaremos Java 1.6 SE. Quiero recomendarle a todo el que vaya a leer de aquí en 
adelante, que tenga en cuanto sea posible un computador y ya empezaremos a 
hablar de cómo instalar y qué necesitamos para empezar a programar. La gran 
mayoría si no todos los programas que usamos aquí son gratis para descargar, así 
que empecemos a programar en Java desde la perspectiva del audio. 
 
7 
 
Antes de empezar 
 
Para todos los que nunca han programado, debo pedirles que preparen su cuerpo 
a nuevas formas de pensamiento. Tal vez la forma de pensar más parecida a la 
programación es la que usamos en las matemáticas, pero el proceso de 
aprendizaje se parece mucho más a aprender un nuevo idioma ya que implica 
asimilar nuevas palabras y entender una nueva sintaxis, esto es la forma en que 
se combinan esas nuevas palabras creando significados específicos. Una vez 
entendemos el idioma debemos hablar y oír mucho en el mismo para poder 
manejarlo. Lo mismo ocurre con los lenguajes de programación. 
 
A los programadores les encanta usar siglas y acrónimos para nombrar cualquier 
cosa que inventan, así que estén listos para aprenderlos todos. Empecemos por 
dos muy importantes: JRE y JDK. El primero significa 'Java Runtime Environment' 
que es el software necesario para correr aplicaciones creadas en Java. El 
segundo significa 'Java Development Kit' que es el software que nos permite 
desarrollar y crear aplicaciones que luego podremos ver usando el JRE. Entonces 
para crear aplicaciones necesitamos el JDK y para verlas necesitamos el JRE. 
 
Java viene en dos presentaciones: Java SE 'Standard Edition' y Java EE 
'Enterprise Edition'. En la edición EE hay funciones extra con respecto a la edición 
SE que por ahora no necesitamos y se salen de los límites de este escrito. 
 
Estamos a punto de empezar a descargar el software necesario. Antes debo 
aclarar que hay varios caminos que podemos tomar para desarrollar aplicaciones 
en Java. Primero vamos a ver un camino largo y tedioso y después vamos a ver el 
camino corto y agradable. ¿Por qué ver el camino largo y tedioso? Porque esta es 
la forma básica de programar en Java y debemos conocerla para poder entender 
procesos que están ocurriendo a escondidas en el camino corto y agradable. Sin 
mostrarles el camino largo no podríamos entender las bases que gobiernan la 
programación. Además en el camino corto usaremos un software muy particular y 
8 
 
no me parece buena idea que dependan de éste para programar en Java. Si por 
ejemplo un día este programa que nos permite ir por el camino corto dejara de 
existir, aunque es poco probable, igual tenemos los conocimientos para hacerlo de 
la forma básica. 
 
Con esto claro, aprendamos el camino largo y aburrido para empezar a divertirnos 
con el camino corto más rápidamente. Lo primero es ir a http://www.java.com/es/ y 
bajar el JRE, esto es todo lo que necesitarás para correr aplicaciones creadas en 
Java. Si por ejemplo has terminado una aplicación y se la quieres mostrar a 
alguien, esa persona lo único que necesitará es el JRE y es probable que ya lo 
tenga instalado. Para nosotros los que vamos a programar necesitamos también el 
JDK que trae incluido el JRE al descargarlo. Para descargarlo vamos a 
http://www.oracle.com/technetwork/java/javase/downloads/index.html y una vez allí 
buscamos el JDK para Java. Para la fecha actual de este escrito, el JDK está en 
su versión 6 en la actualización 19. Es probable que para cuando tú lo bajes haya 
una versión más nueva y eso no es ningún problema porque afortunadamente 
Java siempre es compatible con sus versiones anteriores. 
 
La descarga e instalación del JDK y el JRE es bastante sencilla. Debes tener en 
cuenta en qué parte de tu computador quedan guardados. Si encuentras 
problemas en el camino busca los manuales de instalación en las mismas páginas 
que te mencioné antes. 
 
Además del JDK necesitamos un editor de texto. Programas como Microsoft Word 
no sirven porque cada vez que escribimos, el software está guardando información 
adicional y cierto tipo de meta datos que no vemos y que no van a permitir que 
nuestro programa funcione correctamente o simplemente no funcione, porque 
además le agregan a todo lo que escribimos una extensión propia del editor, en el 
caso de Word agrega '.doc' o '.docx' y para Java necesitamos crear archivos con 
extensiones '.java' en primer lugar. Podemos usar programas como NotePad, 
aunque existen cientos de editores especializados para Java que corrigen 
9 
 
nuestros errores gramaticales y tienen otras herramientas que nos pueden ser 
muy útiles, pero veremos sobre estos más adelante. 
 
Veamos como es el proceso de creación de una aplicación cualquiera usando el 
JDK y NotePad.Con nuestro JDK instalado vamos a usar NotePad para escribir 
nuestro primer código Java. Normalmente, cuando estamos desarrollando una 
aplicación, debemos ir probando partes del código para saber si funciona y para 
esto necesitamos compilar. Para saber qué es compilar debemos tener claro que 
el código que escribimos está hecho para que nosotros los humanos lo 
entendamos más fácilmente, pero este tipo de lenguaje es muy abstracto para las 
máquinas y aunque lo pueden entender, deben primero ser traducidos a lenguajes 
que las máquinas puedan descifrar más rápido y así nuestra aplicación corra 
rápidamente. Si nuestro computador usara nuestro código fuente5 cada vez que 
corre el programa, el resultado serían aplicaciones lentas. Entonces al compilar, lo 
que está ocurriendo es que nuestro código se está traduciendo a otro código que 
nosotros no entendemos pero que la máquina si entiende mucho más fácilmente. 
 
El lenguaje que mejor entiende cada computadora es el código máquina, éste es 
el ideal en cuanto a velocidad para los programas. El problema con el código 
máquina es que depende del sistema operativo y del procesador, esto quiere decir 
que necesitamos diferentes códigos máquinas para diferentes lugares donde 
queramos probar nuestras aplicaciones. Cuando compilamos en Java no 
obtenemos un código máquina como si ocurre con otros lenguajes famosos. Lo 
que obtenemos al compilar en Java es un código llamado bytecode. Este código 
es muy cercano al código máquina y esto es lo que le permite ser tan rápido. Lo 
bueno que tiene el bytecode es que para todos los sistemas operativos es el 
mismo. De cualquier forma Java necesita alguien que traduzca el bytecode a 
código máquina y para esto usa la máquina virtual JVM que significa 'Java Virtual 
Machine'. JVM es un software que se instala con el JRE y que corre 
 
5
 Código fuente es el código que nosotros mismos escribimos en un lenguaje de programación particular, en 
este caso Java. Por cuestiones de derechos de autor por lo general no queremos que este código lo vea 
nadie. 
10 
 
automáticamente cada vez que abrimos una aplicación Java. Sin JVM no podrían 
los sistemas interpretar el bytecode, y sin bytecode no podría Java tener la 
portabilidad que tiene y no podría tener su lema "Write once, run everywhere". 
 
Resumiendo un poco, nosotros creamos un código Java que es traducido a 
bytecode cuando compilamos. El bytecode es interpretado por la máquina virtual 
Java o JVM que viene con el JRE. 
 
Ya entendiendo qué es compilar, podemos seguir viendo cómo es el proceso 
general al crear una aplicación. Suponiendo que ya tenemos nuestro código en 
Java listo para probarlo, para compilar debemos usar la línea de comandos en 
Windows o la Terminal en Mac. Yo estoy trabajando en Windows 7, 64 bits en 
inglés y encuentro la línea de comandos en Start > All Programs > Accessories > 
Command Prompt. Dependiendo de tu sistema operativo esto puede cambiar pero 
no debe ser difícil, si no encuentras tu línea de comandos simplemente busca en 
Google cómo abrirla para tu sistema operativo. Para Mac tengo entendido que se 
encuentra en la carpeta Utilities > Applications > Terminal. 
 
Les voy a dar un código en Java que en realidad no hace mucho pero va a ser 
muy útil para que sigan los pasos conmigo y así aprendan cómo se compila y 
cómo se corre el programa que hemos creado en Java. Por ahora no importa que 
no entiendan nada del siguiente código, más adelante veremos lo que significa y 
qué hace exactamente cada parte. 
 
Con el JDK ya instalado, escribe el siguiente código en NotePad respetando las 
mayúsculas y minúsculas, ten cuidado también con el tipo de paréntesis que usas 
ya que deben ser exactamente los mismos que usamos aquí. Debemos diferenciar 
entre paréntesis (), corchetes [ ] y llaves { }. La cantidad de espacio en blanco no 
es significante si es por fuera de las comillas. Para Java es igual un espacio que 
cinco espacios si estamos fuera de unas comillas. 
 
11 
 
public class MiPrimerPrograma { 
 public static void main (String[ ] args) { 
 System.out.print("No soy un programa de audio pero pronto lo seré."); 
 } 
} 
 
Usa un procesador de texto básico como NotePad en el que puedas escribir la 
extensión .java y nombra este archivo MiPrimerPrograma.java y debes estar muy 
pendiente del sitio dónde lo guardas. Java diferencia entre mayúsculas y 
minúsculas así que debes escribir el nombre exactamente como te lo indico. 
 
Para compilar este código necesitamos saber dos ubicaciones: 
 
1. Necesitas saber dónde quedó instalado el JDK de Java y la carpeta llamada 
'bin'. Esto depende de lo que hayas seleccionado durante la instalación y los 
números dependen de la versión que hayas instalado en tu sistema. En mi equipo 
está en: 
 
C:Program Files\Java\jdk.1.6.0_19\bin 
 
2. Necesitas saber dónde está guardado el archivo MiPrimerPrograma.java. En mi 
computador está en: 
 
D:ESTUDIO\PROYECTO_DE_GRADO\programas\intro\MiPrimerPrograma.java 
 
Recomiendo que los nombres de las carpetas no tengan espacios, excepto los 
que no podemos cambiar como 'Program Files'. Ahora vamos a la línea de 
comandos de nuestro sistema operativo. Ya abierta, en mi caso, al abrirla veo que 
está por defecto en la ubicación C:\users\Juan como muestra la imagen 1. 
 
12 
 
 
1. Imagen inicial de mi Línea de comandos. 
 
Debemos cambiar esta ubicación por la de la carpeta 'bin' del JDK. Para 
devolvernos hasta C: desde cualquier ubicación dentro de C: escribimos cd\ en la 
línea de comandos y hacemos enter para quedar en la imagen 2. 
 
 
2. Nos ubicamos en C: 
 
Ahora para movernos hasta nuestra carpeta deseada escribimos cd más la ruta de 
la carpeta sin escribir C: porque ya estamos allí, en mi caso sería así: 
 
cd Program Files\Java\jdk1.6.0_19\bin 
 
El comando cd significa 'change directory'. Al hacer enter ya debemos estar en 
nuestra carpeta bin. Como muestra la imagen 3. 
13 
 
 
3. Ubicados en la carpeta bin. 
 
Desde allí vamos a escribir javac que es la señal que le enviamos a Java para que 
compile nuestro código, seguida de la ruta donde está el código fuente, en mi caso 
sería así: 
 
javac D:ESTUDIO\PROYECTO_DE_GRADO\programas\intro\MiPrimerPrograma.java 
 
Al hacer enter, si escribimos todo correctamente, volvemos a ver la ruta de nuestra 
carpeta 'bin'. Sin ningún mensaje. 
 
 
4. Con nuestro archivo ya compilado. 
 
Hasta aquí nos vamos dando cuenta que es un proceso tedioso y debe haber 
formas más fáciles de hacerlo, pero quiero tocar puntos importantes con este 
14 
 
proceso así que sigamos. Con todos los pasos anteriores ya debemos tener 
nuestro programa compilado. Para saber cuál es el resultado, en nuestra carpeta 
donde pusimos nuestro código fuente, ahora debemos ver un archivo que se llama 
MiPrimerPrograma.class. Este es el resultado después de haber compilado, este 
archivo está en bytecode. 
 
Pero ahora para correr nuestro primer programa debemos volver a la línea de 
comandos y movernos hasta la carpeta donde tenemos nuestro archivo resultante 
de la compilación. Como el archivo resultante está en otro disco duro en mi caso, 
primero debemos escribir d: y luego hacer enter en nuestra línea de comandos. 
Siempre que queramos cambiar la raíz del directorio simplemente escribimos su 
letra seguida de dos puntos y hacemos enter sin importar donde estemos. Ya en 
este punto estamos parados en D:, lo que tenemos que hacer es movernos hasta 
la carpeta de nuestro archivo MiPrimerPrograma.class, que en mi caso sería así: 
 
cd ESTUDIO\PROYECTO_DE_GRADO\programas\intro 
 
 
5. Ubicados en la carpeta del archivo compilado. 
 
Una vez en la dirección correcta simplemente escribimos lo siguiente para ver qué 
hace nuestro programa: 
 
java MiPrimerPrograma 
15 
 
 
No le agregamos la extensión ni naday ahora debemos ver lo siguiente en nuestra 
línea de comandos: 
 
 
6. Este es el resultado de nuestro primer programa. 
 
El programa dice: 
No soy un programa de audio pero pronto lo seré 
Seguido de la ruta donde está nuestro programa como muestra la imagen 6. 
 
Hasta aquí nos queda claro que nuestro primer programa no hace mucho, 
simplemente es un programa que dice algo en la línea de comandos, pero nos 
acaba de enseñar muchas cosas. Primero aprendimos que este proceso es muy 
aburridor y ni yo mismo quiero volver a hacerlo, pero también aprendimos que 
compilar es el proceso que nos convierte nuestro código en un archivo .java a 
bytecode en un archivo .class que puede ser usado por la máquina virtual de Java. 
También aprendimos que podemos usar la línea de comandos para compilar 
programas desde la carpeta 'bin' usando la palabra clave javac seguida de la 
ubicación del archivo que queremos compilar. También podemos ejecutar el 
código ya compilado desde la ubicación de nuestro archivo .class con la palabra 
clave java seguida del nombre de nuestro programa sin extensión. 
 
16 
 
Es bueno saber que la línea de comandos sirve para algo ¿no? En la vida real 
cuando estamos creando aplicaciones de verdad y que son mucho más útiles que 
esta primera aplicación, debemos estar compilando y probando muy seguido para 
averiguar si tenemos errores en nuestro código. ¿No sería un sueño que 
tuviéramos un ayudante que compilara y corriera el código por nosotros? 
 
Debido a que este proceso que hemos hecho hasta aquí nadie se lo aguanta, 
aparecieron ciertos programas llamados IDE que significan 'Integrated 
Development Environment'. Estos programas son software que nos permiten 
escribir nuestro código, avisarnos de errores mientras escribimos, compilar 
nuestro código, comprobar más errores y correr la aplicación. Todo en un solo 
programa. Este es el camino fácil y agradable y es el que usaremos de aquí en 
adelante. 
 
Uno de los IDE más famosos para Java, que además es gratis, es NetBeans. Lo 
podemos descargar para los sistemas operativos Mac, Linux, Windows y Solaris 
desde http://www.netbeans.org. Si bien yo recomiendo y uso este editor para crear 
aplicaciones en Java hay muchos otros gratis y otros que podemos obtener 
pagando y seguramente la mayoría son muy buenos. Lo mejor de todo es que al 
descargar NetBeans no tenemos que descargar ni siquiera el JDK ya que viene 
incorporado con el programa. Este software es muy completo y no pretendo que 
aprendan a manejarlo todo aquí, en la página antes mencionada podemos 
encontrar buenos tutoriales sobre cómo usarlo. Sin embargo les enseñaré 
cuestiones básicas en el siguiente capítulo, de tal forma que cada vez que 
tengamos un código completo sepamos que para probarlo, primero debemos 
compilarlo y luego ejecutar el programa. Compilar y ejecutar en NetBeans se hace 
con un solo clic en un botón. 
 
En este punto quiero hacer un rápido resumen de lo que no deben olvidar para 
que podamos empezar a ver NetBeans y el lenguaje en sí. 
 
17 
 
Cuando vamos a crear un programa en Java necesitamos un IDE 'Integrated 
Development Environment' que es un software que nos permite crear mucho más 
fácilmente nuestras aplicaciones y probarlas de manera agradable. También 
necesitamos un JDK 'Java Development Kit' que nos permite desarrollar 
aplicaciones y que contiene un JRE 'Java Runtime Environment' que nos permite 
ver las aplicaciones y que contiene un JVM 'Java Virtual Machine' que sirve para 
ejecutar el bytecode que es un lenguaje muy cercano al código máquina. 
Afortunadamente el JDK viene con nuestro IDE NetBeans. Hay diferentes IDE 
dependiendo del lenguaje que vamos a usar, en este caso NetBeans es 
especializado en Java pero también sirve para C, Ruby, JavaFX y php que son 
otros lenguajes famosos. 
 
Si le queremos mostrar a nuestros amigos y familiares nuestras creaciones en 
Java, ellos solo necesitan un JRE. Más adelante veremos cómo hacer para 
entregarles un archivo al que puedan hacer simplemente doble clic para abrir, 
mientras aprendemos eso, ellos tendrían que usar la línea de comandos para 
poder abrirlo. En todo caso el archivo que podríamos entregar mientras tanto es el 
.class y no el .java. Recordemos que el archivo con extensión .java es nuestro 
código fuente y no queremos que nadie lo vea. 
 
Aunque todavía no hemos visto nada de Java en sí, ya entendemos que los 
lenguajes de programación se hicieron pensando en que los seres humanos 
pudieran crear programas partiendo de códigos que pudieran entenderse. Estos 
lenguajes de programación deben ser traducidos para que las máquinas los 
entiendan más fácilmente. El proceso de traducir estos lenguajes se llama 
compilar. Para compilar en Java necesitamos un JDK. Al compilar un archivo .java 
obtenemos un archivo .class que está en bytecode. Este código es leído por la 
máquina virtual Java o JVM que viene cuando tenemos un JRE. Para facilitarnos 
la vida usaremos un IDE llamado NetBeans que nos permite escribir y compilar 
nuestros programas de manera sencilla sin tener que usar la línea de comandos. 
 
18 
 
NetBeans IDE 
 
Como todos queremos aprender Java rápido y el tema es largo, no pretendo 
profundizar sobre NetBeans. No hablaré de la historia ni de cuestiones particulares 
sobre este software. Lo que me interesa en este capítulo es que puedan usar 
NetBeans para empezar a explorar Java, después por su cuenta pueden aprender 
más al respecto. 
 
Como lo mencioné en el capítulo anterior, NetBeans es un IDE, siglas que 
significan 'Integrated Development Environment' y esto quiere decir que es un 
entorno en el que podemos desarrollar programas más fácilmente. En el capítulo 
anterior vimos lo tedioso que puede ser crear programas en Java cuando no 
tenemos un IDE. Gracias a este software podremos encontrar errores en nuestro 
código rápidamente y podremos estar viendo y oyendo los resultados que 
producen nuestros códigos muy fácilmente. 
 
Descargar NetBeans es muy fácil. Lo podemos hacer desde la siguiente dirección: 
http://netbeans.org/downloads/index.html donde podremos escoger la versión que 
queremos descargar. No puedo asegurar cómo se verá la página para el momento 
que ustedes la visiten, pero actualmente me deja escoger si quiero que me sirva 
para JavaFX, Java EE, php, C, C++ y hasta trae servidores para descargar. Como 
vamos a crear programas usando Java SE, esta sería la opción que debemos 
escoger, aunque la versión completa también funciona, solo que trae muchas más 
tecnologías para desarrollar. En la página puedo ver que hay enlaces para bajar 
NetBeans con el JDK directamente o si lo prefiero puedo bajarlos aparte. Lo 
importante es que al final del proceso tengamos el JDK y NetBeans. Cada proceso 
de instalación puede variar dependiendo del sistema operativo así que en este 
punto deben referirse al manual de instalación que pueden encontrar en la página 
de NetBeans. Normalmente es un proceso que debe ser muy sencillo. Yo usaré la 
versión 6.9.1 que funciona solamente para desarrollar aplicaciones en Java SE. 
19 
 
Previamente ya tenía instalado el JDK y ustedes también si siguieron conmigo los 
pasos del capítulo anterior. Cuando instalé NetBeans, el programa me preguntó en 
qué carpeta estaba mi JDK que encontró automáticamente. 
 
Vamos a crear el mismo proyecto que hicimos por el camino difícil con la línea de 
comandos pero ahora lo haremos en NetBeans. Los pasos son muy sencillos y 
van a ser los mismos cada vez que hagamos un nuevo proyecto. 
 
1. Abrir NetBeans. Lo primero que veremos es la presentación del programa que 
tiene unos enlaces a la página donde podemos aprender más sobre el software y 
otra información adicional. 
 
2. Empezar un nuevo proyecto. Mi NetBeans está en Inglés así que primero 
buscamos en el menú y hacemos clic en File y luego New Project. 
 
3. En las categoríasescogemos Java, en proyectos escogemos Java Applications 
y luego hacemos clic en Next. 
 
 
20 
 
4. Nombramos el proyecto MiSegundoPrograma y seleccionamos la carpeta en la 
que queremos nuestro proyecto. Seleccionamos la caja que dice 'Create Main 
Class' y la nombramos MiSegundoPrograma también. Seleccionamos la caja 'Set 
as Main Project'. Por último hacemos clic en Finish. 
 
 
 
Aunque crear el proyecto nos toma más tiempo ahora, las ventajas las veremos al 
compilar y ejecutar nuestro programa. No olvidemos que crear un nuevo proyecto 
solo lo haremos cada vez que queramos crear una nueva aplicación y esto no 
ocurre muy seguido, en cambio compilar y correr aplicaciones lo hacemos miles 
de veces mientras probamos nuestro código. 
 
5. Escribimos el código. Vemos un código que se generó automáticamente pero 
por ahora lo vamos a borrar todo y lo vamos a reemplazar por el siguiente: 
 
 
21 
 
public class MiSegundoPrograma { 
 public static void main (String[ ] args) { 
 System.out.print("No soy un programa de audio pero pronto lo seré."); 
 } 
} 
 
6. Compilamos y corremos nuestro código con el botón que tiene una flecha verde 
como vemos en la siguiente imagen: 
 
 
7. Vemos el resultado en la ventana Output 
 
Aquí vemos el resultado que antes teníamos en la línea de comandos. Esto quiere 
decir que la ventana Output hace las veces de una línea de comandos. 
 
Como podemos ver necesitamos 7 pasos para crear un nuevo proyecto en Java 
usando NetBeans. Este proyecto ya está guardado y al abrir NetBeans 
nuevamente ya lo tendremos a nuestra disposición. Lo más interesante es que si 
tenemos errores en nuestro código, NetBeans nos dirá señalándonos la línea del 
código con problemas. El paso 6 es el que más haremos cada vez que 
modifiquemos algo en nuestro código y ahora es muy fácil de realizar. 
22 
 
 
 
En esta imagen vemos las tres ventanas principales de NetBeans: 
 
En la ventana 1, debemos asegurarnos que estemos en la pestaña Projects o en 
Files, es donde encontraremos algunos de nuestros proyectos ya abiertos con el 
programa. Es poco lo que haremos en esta ventana pero nos sirve para ver la 
organización interna de nuestros proyectos y se vuelve muy útil cuando tenemos 
muchos archivos en proyectos grandes. 
 
En la ventana 2 es donde escribimos todo nuestro código Java. Debemos tener 
cuidado porque dependiendo de la pestaña superior podemos estar en diferentes 
archivos .java y podríamos terminar modificando uno no deseado. En la ventana 2 
vemos a la izquierda de nuestro código unos números que son los encargados de 
numerar las líneas. Esto es muy importante ya que cuando tenemos un error en el 
código, NetBeans mostrará una alerta o un símbolo rojo sobre la línea con 
problemas. 
 
Por último en la ventana 3 veremos los resultados. En realidad esta es una 
ventana de prueba porque las aplicaciones queremos verlas con interfaces 
gráficas agradables para el usuario por lo que la ventana tres termina siendo útil 
para probar ciertos resultados antes de mostrarlos al usuario en su interfaz gráfica. 
23 
 
Muchas veces nos puede pasar que hacemos un mal movimiento dentro del 
programa y se nos desaparece alguna de nuestras ventanas principales. Si se nos 
cerró un archivo en el que estábamos editando lo buscamos nuevamente en la 
ventana Projects o en Files. Si la ventana Projects, Files o Output se nos ha 
cerrado, podemos volver a abrirlas desde el menú en la barra superior, en el ítem 
Window. 
 
Como vimos en el capítulo anterior, después de compilar terminamos con un 
archivo .class que no es fácil de abrir ya que necesitamos usar la línea de 
comandos que no es tan agradable. La solución a esto es crear un archivo JAR 
que significa Java ARchive. Este es un tipo de archivo al que solo tenemos que 
darle doble clic para poder abrirlo y así nuestro programa se ejecutará. Un archivo 
.jar se comporta muy parecido a un .rar o un .zip ya que su función es guardar 
varios archivos dentro de un solo .jar. 
 
Aunque podemos crear archivos JAR desde la línea de comandos, les voy a 
enseñar cómo hacerlo directamente desde NetBeans que es mucho más fácil y así 
no tenemos que entrar a entender procesos que van a dañar nuestra curva de 
aprendizaje. Para crear un archivo .jar de nuestra aplicación simplemente 
hacemos clic en el botón que se llama 'Clean and Build Main Project'. que es el 
que muestra la siguiente imagen: 
 
Al presionarlo podemos ver en nuestra ventana Files una carpeta llamada dist que 
contiene un archivo llamado MiSegundoPrograma.jar. Si lo buscamos en nuestro 
computador y hacemos doble clic sobre él, nada va a ocurrir. No pasa nada 
porque recordemos que nuestro programa solamente decía algo en la línea de 
comandos o en el Output de NetBeans y recordemos que tanto la línea de 
comandos como la ventana Output son de prueba, por lo que el usuario final no 
verá lo que sale allí. Para que el usuario final vea algo en pantalla tenemos que 
crear interfaces gráficas y más adelante veremos cómo hacerlas. 
24 
 
Anatomía de Java 
 
A partir de este punto empezaremos a aprender el lenguaje en sí. Entiendo que 
los procesos anteriores pueden llevar a muchas preguntas y pueden tener asuntos 
no tan agradables, pero una vez hecho todo lo anterior estamos con nuestro 
computador listo para crear los primeros códigos en Java los cuales si vamos a 
entender cómo funcionan. 
 
Al comienzo veremos códigos completos que puedes ir y copiar exactamente 
iguales en NetBeans para probarlos y entenderlos al modificarlos a tu gusto. 
Cuando estemos un poco más adelantados ya no es práctico que yo escriba todo 
el código completo porque terminaríamos con muchas páginas de códigos, así que 
puedo empezar a escribir partes de códigos que por sí solos no funcionan, pero 
para entonces ya tendrás los conocimientos necesarios para descifrar qué es lo 
que hace falta para que funcionen al compilar. 
 
Existen ciertos errores en programación que NetBeans puede detectar antes de 
compilar, pero hay otros errores que no saldrán hasta el momento de compilar o 
incluso aparecerán mientras corre nuestra aplicación. Debemos estar muy 
pendientes de la lógica de nuestros códigos, de palabras mal escritas, tener 
cuidado con mayúsculas y minúsculas y no debemos preocuparnos ni 
desesperarnos porque los errores en el código son parte de la vida diaria de hasta 
el mejor programador del mundo. 
 
Empecemos por entender el código más básico que se puede hacer en Java: 
 
public class NombreDeLaClase{ 
 public static void main (String[ ] args) { 
 System.out.print("Esto saldrá en la ventana Output"); 
 } 
} 
25 
 
En este punto ya hemos visto un par de códigos muy parecidos a este. Este 
código tiene exactamente la misma estructura y forma que MiPrimerPrograma.java 
y MiSegundoPrograma.java. Además producen el mismo resultado que es escribir 
algo en la ventana de salida o Output. Aunque este programa no hace nada 
excepcional, es la estructura más básica que se puede crear en Java para que 
funcione. Vamos a descifrar qué es lo que está ocurriendo línea por línea. 
 
public class NombreDeLaClase{ 
 
La anterior es nuestra primera línea. La primera palabra que vemos es public y 
hace parte de algo llamado modificador de acceso. Por ahora no voy a complicar 
más la situación, con que sepamos que public es un modificador de acceso es 
suficiente, más adelante profundizaremos en el asunto. Toda aplicación en Java 
debe estar contenida en una clase, como las llamamos en español, que en java y 
en inglés se escribe class. Una clase es un contenedor para nuestro código. En 
nuestros dos primeros programas y en este, tenemos una sola clase que hemos 
nombrado con la palabra que escribimos después de class ya sea 
MiPrimerPrograma, MiSegundoPrograma o NombreDeLaClase. En realidad 
podemos poner el nombre que queramos pero dicho nombreno puede tener 
espacios, no puede tener signos de puntuación ni caracteres raros y por 
convención deben empezar siempre con mayúscula. 
 
Para facilitar la lectura de estos nombres de clases, que por lo general están 
creados a partir de varias palabras para ser más descriptivos, debemos usar algo 
llamado CamelCase. Esto es cuando escribimos palabras unidas, pero para 
facilitar la lectura ponemos en mayúscula la primera letra de cada nueva palabra. 
EsMasFácilLeerEsto que tenerqueleeresto. 
 
Después del nombre de nuestra clase viene una llave de apertura { que funciona 
para determinar que de ahí en adelante se escribirá el código perteneciente a la 
clase hasta que encontremos su respectiva llave de cierre } que es la que aparece 
26 
 
en la última línea o línea 5. Estas llaves determinan el comienzo y final de una 
porción de código que llamaremos bloque. Cada vez que tengamos código dentro 
de unas llaves tenemos un bloque de código. Toda llave, corchete, paréntesis y 
paréntesis angular que se abra {, [, ( y < debe cerrarse con su correspondiente }, ], 
) y > sino el código no compilará. En definitiva las clases se usan para encerrar 
porciones de códigos por razones que veremos claramente más adelante. 
 
Por ahora imaginemos que estamos diseñando un reproductor de audio. Una 
buena idea sería usar una clase para contener todo el código que permite 
funcionar al reproductor, este sería el código encargado de cargar las canciones, 
encargado de hacer pausar la canción cuando el usuario lo desea, subir y bajar el 
volumen, etc. Otra clase podría tener todo el código correspondiente a la parte 
visual del reproductor, lo que se denomina interfaz gráfica, como los botones, el 
contenedor que muestra la carátula del álbum, los colores de fondo, etc. 
 
Un programa en Java puede tener varias clases y éstas pueden comunicarse 
entre sí como lo veremos más adelante. En nuestro ejemplo del reproductor de 
audio es necesario que ambas clases se comuniquen entre sí, ya que la parte 
visual seguramente dependerá de la canción que esté sonando. Por esta razón es 
que existen los modificadores de acceso como public. Imaginemos que tenemos 
una clase llena de código al cual no queremos que ninguna otra clase pueda 
acceder por seguridad, en ese caso usamos los modificadores de acceso para 
proteger nuestra clase del resto escribiendo por ejemplo private en vez de public. 
 
Ahora pasemos a la segunda línea de código: 
 
public static void main (String[ ] args) { 
 
Si miramos en el código original esta línea, veremos que está tabulada. Como ya 
se dijo antes, la cantidad de espacio en blanco no determina que esté bien o mal 
escrito el código, de hecho podríamos escribir todo el código en una misma línea, 
27 
 
pero hacerlo así no facilita su lectura. Al tabular estamos dando a entender 
visualmente que la segunda línea está contenida en la clase. Es una ayuda visual. 
 
Como podemos ver esta segunda línea también empieza con un modificador de 
acceso public. En esta segunda línea estamos creando un método. Tanto los 
métodos como las clases tienen modificadores de acceso para proteger su 
información. Los métodos van dentro de las clases y son como clases en cuanto 
que guardan porciones de información más específica en bloques. Volvamos al 
ejemplo del reproductor de audio. Si estamos escribiendo el código para un 
reproductor de audio, es probable que necesitemos separar pedazos de código 
dentro de su clase. Supongamos que estamos haciendo nuestra clase que se 
encarga de la funcionalidad del reproductor, es probable que queramos separar el 
código que se encarga de pausar la canción, del código que hace subir el 
volumen, ya que no queremos que cuando el usuario vaya a hacer pausa se suba 
el volumen, ¡sería un DESASTRE! 
 
Entonces por lo anterior es que existen los métodos y eso es lo que se está 
creando en esta segunda línea de código. Después de public vemos las palabras 
static void main (String[ ] args) { de las cuales les puedo decir que ya mismo no 
nos interesa saber exactamente qué es todo eso, más bien aprendamos que todo 
eso crea un método muy importante que es el método llamado main como indica 
la cuarta palabra en esta segunda línea. Toda aplicación en Java debe tener un 
método main que es el que va a correr automáticamente cada vez que ejecutemos 
nuestro programa. Pensemos en el caso del reproductor de audio, no queremos 
que todos los métodos se ejecuten cuando iniciamos el reproductor porque sería 
caótico. En cambio solo un método corre automáticamente cuando empieza 
nuestra aplicación y ese es el método main. Una aplicación puede tener muchas 
clases y muchos métodos pero sólo un método main. Una clase puede no tener un 
método main. El resto de métodos se pueden disparar desde este principal o 
cuando ocurre un evento que es cuando el usuario hace clic sobre un botón o algo 
parecido. 
28 
 
 
Aunque más adelante veremos los métodos detenidamente, veamos que en la 
segunda línea aparecen unos paréntesis, y así como aprendimos antes aparece el 
paréntesis que abre ( y luego cierra ). Lo mismo ocurre dentro de los paréntesis 
con unos corchetes [ ] que más adelante veremos lo que significan. Al final de la 
línea dos, vemos una llave de apertura que indica que a partir de ahí empieza todo 
el código que hace parte de este método main y que se acaba con la llave de 
cierre } en la línea 4. Por último tenemos la línea tres con el siguiente código: 
 
System.out.print("Esto saldrá en la ventana Output"); 
 
Sin profundizar mucho, este código es el encargado de escribir algo en la ventana 
Output o en la línea de comandos. ¿Qué escribe? Lo que sea que pongamos 
dentro de las comillas. Como ya se mencionó antes, escribir en la ventana de 
salida se usa para cuestiones de pruebas y por agilidad. Nada de lo que 
escribamos en este código podrá ser visto fuera de la línea de comandos, esto 
quiere decir que una persona que hace doble clic sobre un archivo JAR no puede 
ver esta información a menos que ejecute el JAR desde la línea de comandos, 
cosa que es poco probable. 
 
Este código lo terminaremos aprendiendo así no queramos de tanto que se usa 
cuando creamos una aplicación. Mientras estamos en el proceso de desarrollo, 
casi todos los programadores usan en varios puntos este código para saber qué 
está ocurriendo con x porción de código. Por más que estos resultados no los vea 
el usuario final, siempre se borran y solo se usan para probar nuestro código como 
ya veremos más adelante. En muchas de las aplicaciones usaremos la ventana de 
salida para aprender a usar Java, así que veremos mucho este código. 
 
Repasando un poco veamos en colores el código para entenderlo de forma 
general un poco mejor y le vamos a agregar una línea de código extra: 
 
29 
 
 
public class NombreDeLaClase{ 
 public static void main (String[ ] args) { 
 System.out.print("Esto saldrá en la ventana Output"); 
 System.out.println("Esto también saldrá en la ventana Output"); 
 } 
} 
 
La línea 1 y 5 están en rojo por ser el comienzo y el final de la clase que 
nombramos NombreDeLaClase. El nombre de toda clase que contiene al método 
main debe ser igual al nombre del archivo .java en el computador que lo contiene. 
En este caso el código debe ir en un archivo llamado NombreDeLaClase.java. 
Veamos que cada vez que estamos escribiendo dentro de llaves usamos 
tabulación para ordenar visualmente los contenidos. Dentro de la clase 
encontramos el método main que está en azul. Dentro de main tenemos en verde 
el código que se ejecuta automáticamente cuando se carga la aplicación. Este 
código es el encargado de imprimir algo en la ventana Output y le hemos 
agregado una línea muy parecida debajo que imprime otra oración. 
 
Cada sentencia en el código verde termina en punto y coma. Todo código que 
haga algo específico por pequeño que sea se le ponepunto y coma para separarlo 
del resto, esto es una forma de decir fin de la sentencia. Cuando veamos más 
código más complejo en Java empezarás a entender qué lleva punto y coma y qué 
no. Por ahora piensa que toda sentencia que escriba en la ventana Output termina 
con punto y coma. Mira que el código verde tiene otra diferencia y es que uno dice 
System.out.print y el otro dice System.out.println. El primero imprime en la misma línea 
y el segundo hace un salto de línea, como cuando hacemos enter en Microsoft 
Word. Escribe este código en NetBeans y juega con las impresiones en Output 
agregando los que quieras, para que compruebes por ti mismo cómo funciona. 
Como conclusión Java usa clases, dentro de las clases van métodos y dentro de 
los métodos van sentencias que terminan en punto y coma. 
30 
 
Variables 
 
En el capítulo anterior aprendimos que para empezar a crear una aplicación en 
Java primero creamos una clase y la nombramos empezando en mayúscula y 
usando CamelCase. Dentro de esa clase va un método main que se ejecuta 
automáticamente cuando la aplicación carga. Dentro de este método principal 
pondremos nuestro código para empezar la aplicación. Más adelante veremos 
cómo crear varios métodos dentro de una misma clase. También veremos cómo 
crear más clases que podemos usar en una misma aplicación. 
 
Ya sabiendo la anatomía básica que usa Java, debemos preocuparnos un poco 
más por el código que podemos escribir dentro de los métodos. Aprender algunas 
cuestiones básicas de Java y seguir aprendiendo más sobre la anatomía nos 
tomará algunos capítulos, pero con un poco de paciencia vamos a poder aplicar 
todos estos conocimientos para hacer casi cualquier aplicación de audio que se 
nos ocurra. Sin embargo enfocaré en cuanto más pueda los ejemplos a códigos 
que pudieran darse en aplicaciones de audio. 
 
Como dije antes, usar un lenguaje de programación requiere un pensamiento 
matemático. En ecuaciones de matemáticas existen las variables. Recordemos 
que una variable es simplemente un contenedor que puede almacenar múltiples 
valores. Por lo general en matemáticas se usan las variables para nombrar una 
porción de la ecuación que desconocemos en dicho punto. De la misma forma en 
Java existen las variables pero tienen un uso mucho más allá de los números. 
 
Existen varios tipos de variables en Java. Pensemos que no es saludable para 
nuestro programa que una variable que está pensada para contener solo números 
de pronto se llenara con texto que no tiene nada que ver con números. Sería tan 
problemático como tener una ecuación matemática en la que de pronto apareciera 
una palabra. Por lo anterior, en Java debemos especificar el tipo de variable que 
estamos creando. Existen variables solo para números enteros, otras para 
31 
 
almacenar texto entre comillas que los lenguajes denominan cadenas o String, y 
otros tipos de variables que veremos más adelante. Imaginemos que estamos 
creando un reproductor de música en Java, en algún punto sería buena idea crear 
una variable que cargara el nombre de la canción que está sonando. Veamos el 
siguiente código: 
 
public class Canciones{ 
 public static void main (String[ ] args) { 
 String cancion; 
 cancion = "Airplane"; 
 System.out.println(cancion); 
 cancion = "The show must go on"; 
 System.out.println(cancion); 
 cancion = "Billionaire"; 
 } 
} 
 
No podemos olvidar que este código debe ir en un archivo que debe llamarse igual 
a la clase que contiene el método main. Escribe el código anterior en NetBeans, 
crea un proyecto llamado 'Canciones' y en el campo que dice 'Create Main Class' 
escribe 'Canciones' para que NetBeans te cree un archivo llamado Canciones.java 
dentro del proyecto Canciones. NetBeans crea por nosotros la estructura básica 
que es la clase y el método main. Además vemos en gris otro tipo de código que 
en realidad son comentarios pero no es código. En el siguiente capítulo veremos 
qué son los comentarios en el código y para qué sirven, por ahora puedes borrar 
todo y escribir el código anterior. Cabe notar que pudimos nombrar el proyecto 
cualquier otra cosa, por ejemplo 'variables', y en 'Create Main Class' si debemos 
escribir 'Canciones' para que nos cree el archivo correcto. 
 
Las dos primeras líneas de código ya deben ser familiares para nosotros, aunque 
hay detalles de la creación del método que veremos más adelante. Todo método 
32 
 
main empieza como empieza nuestra segunda línea de código. En la tercera línea 
de código tenemos lo siguiente: 
 
String cancion; 
 
Esta tercera línea es la forma como inicializamos una variable. Toda variable se 
inicializa declarando el tipo y el nombre. En este caso estamos creando una 
variable de tipo String y con nombre 'cancion', sin tilde. Cada vez que inicialicemos 
o hagamos algo con una variable tenemos una sentencia, esto quiere decir que 
debe terminar con punto y coma. 
 
El tipo String es el necesario para indicar que una variable va a contener texto. 
Siempre que vamos a crear una variable, lo primero que escribimos es el tipo de 
contenido que va dentro de dicha variable. Para la variable que contiene el nombre 
de las canciones de nuestro reproductor, necesitamos que sea de tipo String. 
Incluso si tenemos una canción que se llama "4'33", de todas formas podemos 
poner números dentro de la cadena o String ya que estos son tratados como texto. 
 
Después del tipo, escribimos el nombre que le vamos a dar a nuestra variable. 
Este nombre debe usar CamelCase pero se diferencia del nombre de una clase 
porque empieza en minúscula. El nombre de la variable no puede empezar con 
números aunque puede contenerlos, no puede tener espacios y no se deben usar 
signos raros ni tildes. Esto es todo lo que necesitamos para crear una variable así 
que como ya terminamos ponemos punto y coma. Hasta aquí hemos creado una 
variable pero no le hemos asignado un contenido. En la siguiente línea tenemos: 
 
cancion = "Airplane"; 
 
Ya en esta línea estamos asignando un texto a la variable 'cancion'. Para asignarle 
un contenido a una variable simplemente escribimos un igual después del nombre 
y después ponemos el contenido seguido de punto y coma para finalizar la 
33 
 
sentencia. Como en este caso es un String debe ir entre comillas, si el contenido 
fuera de números no lo pondríamos entre comillas. Solo los textos los ponemos 
entre comillas. También podemos inicializar una variable y poner su contenido 
inmediatamente, en este caso no lo hice para mostrar que podemos crear primero 
la variable y asignar su contenido luego. Si hubiera querido crear la variable e 
inicializarla inmediatamente, las dos líneas se hubieran resumido a una así: 
 
String cancion = "Airplane"; 
 
Aunque este código sea más corto, existen muchas ocasiones en las que no 
queremos asignar un contenido a una variable hasta más adelante en el código, 
pero si queremos crear la variable. Estos casos los veremos más adelante en el 
capítulo llamado 'Ámbitos locales'. 
 
Antes usamos System.out.print(); para decir algo que escribíamos en comillas 
dentro del paréntesis. También podemos poner dentro del paréntesis el nombre de 
la variable y es el contenido en ese punto de la misma, el que va a salir en la 
ventana Output. Es precisamente eso lo que hacemos en la siguiente línea: 
 
System.out.println(cancion); 
 
El resultado en la ventana Output es 'Airplane' ya que este es el contenido que 
tenemos asociado a la variable cancion en este punto. Después podemos 
modificar el contenido de la variable, al fin y al cabo es para esto que sirven las 
variables y es para poder cambiar su contenido a lo largo del código. 
 
cancion = "The show must go on"; 
System.out.println(cancion); 
 
Como podemos ver, el código anterior cambia el contenido de la variable a 'The 
show must go on' y luego imprime nuevamente la misma variable. Observemos34 
 
que tenemos dos líneas en el código que se ven exactamente iguales, estas dos 
son la líneas son las que usan System.out.println(); y aunque se vean iguales 
podemos ver que no generan el mismo contenido como resultado en la ventana de 
salida. Esto es demasiado importante y es el primer paso para entender la 
programación, una misma línea de código puede producir resultados muy 
diferentes. Incluso más adelante veremos que cuando tenemos código que se 
repite podemos condensarlo en uno solo para que nuestro programa sea más ágil, 
entre menos código tengamos que escribir para producir diferentes resultados 
pues mejor. 
 
En la última línea cambiamos nuevamente el contenido de la variable pero esta 
vez no hacemos nada con ella. con esto quiero demostrar algo que puede parecer 
obvio pero a veces nos puede llevar a errores cuando tenemos códigos largos y 
complejos. El código se ejecuta de arriba hacia abajo y de izquierda a derecha. Es 
por eso que podemos poner dos veces el código System.out.println(); pero éste 
produce resultados diferentes. No es necesariamente un error que cambiemos la 
variable y al final no hagamos nada con ella, puede ser que el usuario seleccione 
una nueva canción, y esto haga que la variable se llene con el nombre, pero nunca 
la haga sonar y por lo tanto la variable nunca cumpla su función. Lo importante es 
que debemos tener cuidado de cómo se encuentran en dicho momento las 
variables, debemos estar pendientes si en el punto que queremos la variable está 
llena con la información que queremos, siempre teniendo en cuenta que el código 
se ejecuta de izquierda a derecha y de arriba hacia abajo. Podemos crear muchas 
variables, y si lo queremos, una variable puede ser igual a otra variable y obtendrá 
el valor de esa segunda variable que tenga asignado en ese momento. Una 
variable también puede ser igual a otra variable más una operación matemática. 
 
Te recomiendo que vayas y modifiques este código a tu gusto para que pruebes 
diferentes resultados, no hay mejor forma de aprender a programar que 
programando. 
 
35 
 
Comentarios 
 
Aunque en el capítulo anterior hablamos de variables y en el siguiente 
continuaremos el tema, me pareció pertinente por razones pedagógicas, darle un 
descanso al cerebro aprendiendo sobre los comentarios en Java que es un tema 
muy sencillo pero muy útil. Imaginemos que escribimos nuestro reproductor de 
música, lo terminamos, se lo mostramos a todo el mundo y después de un tiempo 
nos damos cuenta que queremos modificar algunos comportamientos y agregar 
nuevas funciones. En este caso volveremos a nuestro código que puede tener 
hasta 1000 líneas o más y obviamente nos va a costar mucho encontrar porciones 
específicas del código. Lo más probable es que nos encontremos con porciones 
de código que aunque fueron escritas por nosotros, no nos acordemos qué hacen. 
Para eso existen los comentarios en Java, son porciones de texto que no hacen 
nada útil para la aplicación en sí, pero allí podemos escribir cualquier cosa que 
queramos para recordarnos a nosotros mismos qué hace cierto código. 
 
De hecho los comentarios se hicieron no sólo para que nosotros mismos nos 
escribiéramos mensajes a nuestro yo del futuro, en muchas aplicaciones es 
probable que trabajemos en equipo con otros programadores, o que en el futuro 
otros programadores continúen nuestro trabajo, la mejor práctica en cualquier 
caso es escribir los comentarios suficientes para hacer el código lo más claro 
posible. Esto no significa llenar cada línea con comentarios, simplemente significa 
que por cada porción de código que haga algo específico, por ejemplo mostrar un 
playlist en nuestro reproductor, podemos poner comentarios cortos y claros como 
"muestra el playlist en el reproductor" o simplemente "muestra el playlist". Si 
creemos que hay procedimientos complejos ocurriendo, también podemos hacer 
anotaciones más específicas en el código. 
 
Hay dos tipos de comentarios que usaremos en Java en este proyecto de grado. 
Podemos hacer comentarios de una línea o comentarios de varias líneas. No 
existe ninguna diferencia entre los dos tipos de comentario, simplemente se 
36 
 
diferencian por el largo en líneas del mismo. Si queremos hacer un comentario 
corto de una línea procedemos así: 
 
// Con dos slash empezamos los comentarios de una línea 
 
 Cada vez que el compilador encuentra dos forward-slash ignora todo texto que 
haya en esa línea. Debemos tener cuidado porque deben ser dos de estos // y no 
dos back-slash como estos \\. Si queremos hacer comentarios más largos usamos 
los comentarios de varias líneas: 
 
/* 
Este es un comentario de varias líneas, 
podemos hacer enter y todo este texto será ignorado por el compilador. 
Para terminar un comentario de varias líneas usamos: 
*/ 
 
Para empezar un comentario de varias líneas escribimos /* y para terminarlo 
usamos el inverso que es */. Los comentarios también se usan para no dejar que 
un código funcione pero que no queremos borrar para futuras referencias. Por 
ejemplo imaginemos que escribimos un código que muestra todas las canciones 
que tenemos en una carpeta. Después de terminar dicho código, se nos ocurre 
una forma más fácil y más corta de realizar exactamente lo mismo pero no 
estamos seguros si va a funcionar. Lo mejor que podemos hacer es comentar el 
código anterior y empezar el nuevo, si después de probar nuestro nuevo código 
todavía decidimos devolvernos al código anterior, simplemente le quitamos los 
signos de comentario y así no lo perdemos. Incluso podemos comentar uno de los 
dos códigos para comparar si se comportan igual o no. 
 
 
 
 
37 
 
Tipos de Variables 
 
Las variables en Java pueden tener varios tipos de contenido. En el capítulo de 
variables vimos como podíamos almacenar texto en comillas dentro de una 
variable de tipo String. Existen otro tipo de variables llamadas primitivas que 
contienen otro tipo de información. Existen 8 tipos de variables primitivas, veamos 
el siguiente código: 
 
public class Primitivos{ 
 public static void main (String[ ] args) { 
 boolean esVerdad = true; 
 char c = 64; 
 byte b = 100; 
 short s = 10000; 
 int i = 1000000000; 
 long l = 100000000000L; 
 double d = 123456.123; 
 float f = 0.5F; 
 // Podemos ver todos los resultados con un solo System.out.println() 
 System.out.println(esVerdad + "\n" + c + "\n" + b + "\n" + s + "\n" + i + "\n" + l + 
"\n" + d + "\n" + f); 
 } 
} 
 
Este código a primera vista puede asustar un poco más, pero en realidad lo que 
está ocurriendo es muy sencillo. En general lo que tenemos son los 8 tipos de 
variables primitivas, un comentario y un solo System.out.println() que nos va a 
mostrar el contenido de nuestras 8 variables usando +. Veamos paso por paso lo 
que está ocurriendo. 
 
Como siempre empezamos declarando nuestra clase y luego nuestro método 
main(). Dentro de éste último ponemos todo nuestro código por ahora. El primer 
38 
 
tipo de variable primitiva que usamos es boolean. Este tipo de primitivos solo 
pueden tener dos estados: true y false. En nuestro ejemplo del reproductor de 
música podemos usar este tipo de variables para saber el estado de una función 
específica que tenga solamente dos estados. Por ejemplo si tenemos un botón 
que nos permite silenciar el sonido, este botón puede estar asociado a una 
variable booleana llamada silencio, o cualquiera sea el nombre que escojamos, y 
su valor puede ser false cuando queremos que nuestra aplicación suene y true 
cuando queremos que nada suene. Cuando creamos una variable de este tipo 
pero no le asignamos un valor inmediatamente, por defecto su valor es false. Más 
adelante veremos que este tipo de variables son muy utilizadas y muy útiles así 
que no debemos olvidarlas. 
 
El segundo tipo de variable es char, que es la abreviación de character. Este tipo 
de variablesirve para almacenar un solo carácter. No se puede confundir con 
String ya que char no nos permite almacenar texto, solo nos permite almacenar 
una letra o signo de cualquier idioma. Este tipo de variable primitiva usa Unicode 
que es un tipo de codificación estándar que guarda todos los signos y letras 
usados en las diferentes lenguas de la humanidad y las asocia a un número entre 
0 y 65.536. Esto quiere decir que dentro de una variable de tipo char podemos 
almacenar tanto un número como un signo o letra. En nuestro código usamos el 
número 64 que es el equivalente al signo arroba. También pudimos haber escrito 
en vez del número, el signo dentro de comillas sencillas así: '@'. Notemos que en 
los teclados existen tanto las comillas dobles " " como las comillas sencillas ' '. 
Para las variables de tipo char debemos usar comillas sencillas. En realidad es 
raro que en un programa de audio nos encontremos con este tipo de variables. 
 
Las variables de tipo byte tienen una capacidad de 8 bits. Esto significa que se 
usan para almacenar números enteros entre -128 y 127. Son muy útiles cuando 
hacemos aplicaciones de audio ya que por lo general cuando vamos a manipular, 
crear o analizar la información en la que está guardada el audio, debemos usar 
este tipo de variables para almacenar nuestra información de audio y así poder 
39 
 
hacer algo con ella. Lo mismo ocurre cuando estamos trabajando con MIDI, la 
información que se envía y se recibe está expresada en bloques de a 8 bits, así 
que cuando queremos crear mensajes MIDI, la mejor opción es usar este tipo de 
variables. 
 
En la siguiente variable encontramos el tipo short que usa 16 bits. Esto quiere 
decir que permite almacenar números enteros entre -32.768 y 32.767. Pensemos 
que cuando tenemos la calidad de CD, se usa una profundidad de 16 bits en el 
audio. Esto quiere decir que tenemos toda esta cantidad de valores para 
almacenar una exacta amplitud de onda en un determinado momento y así y todo 
muchas personas creen que no es suficiente y deciden irse por usar calidad de 
audio de hasta 24 bits. No pienso entrar en esta discusión sobre calidad de audio 
digital, más adelante hablaremos un poco más sobre procesamiento de audio 
digital. Por ahora simplemente pensemos que con 16 bits o en un tipo short, 
podemos poner una muestra de audio que use esta profundidad de bits. 
 
En la siguiente variable encontramos el tipo int que es la abreviación de integer. 
Este tipo de variable almacena 32 bits. y se pueden poner valores entre 
2.147.483.648 y 2.147.483.647. Estos números son lo suficientemente elevados 
para casi cualquier aplicación, tal vez tendríamos problemas si estamos creando 
una calculadora en Java pero de resto casi siempre una variable de tipo int es más 
que suficiente. Son muchas las ocasiones en las que podemos usar un variable de 
este tipo en audio. Pensemos nuevamente en nuestro ejemplo de un reproductor 
de audio, si por ejemplo queremos que nuestra aplicación cuente la cantidad de 
canciones que tiene el usuario, es probable que debamos usar una variable int. 
 
La variable de tipo long usa 64 bits y como te imaginarás las cantidades son 
demasiado grandes como para mencionarlas. Son números enteros que ni sé 
cómo leer así que con que sepas que cuando un int se te quede corto puedes usar 
long. La verdad es que son cantidades tan grandes y usa tantos bits que es raro 
ver este tipo de variables en una aplicación. Como podemos ver en nuestro 
40 
 
ejemplo, al final del número debemos agregar una L, esto es debido a que Java 
trata todos los números grandes como int para proteger el sistema de usar 
demasiados recursos. Cuando usamos un long, Java nos pide que agreguemos 
una L al final del número para que estemos seguros que queremos usar un long y 
no un int. 
 
Por último tenemos dos tipos de variables primitivas que son las que nos permiten 
almacenar números decimales, esto son double y float. La diferencia principal es 
que double usa 64 bits y float usa 32 bits. Java trata todos los decimales como 
float así que cuando queremos usar un float, debemos asegurarnos de agregar 
una F al final del número. Aunque double usa 64 bits, que es una cantidad grande, 
esto es necesario porque las posibilidades al usar decimales son muchas. Por lo 
general el volumen en una aplicación de audio, es manejado por un slider que da 
números decimales donde 1 es el volumen máximo y 0 es silencio total. 
 
Las variables de tipo byte, short, int, long, float y double están hechas para 
almacenar números. Aunque char puede almacenar números, este no es su fin 
sino asociar dichos números con letras. Es probable que te estés preguntando 
¿Por qué usar 6 tipos diferentes de variables para almacenar números? La 
respuesta es que debemos pensar en crear aplicaciones rápidas. Pensemos que 
una variable tipo long usa 64 bits para almacenar números, a diferencia de una 
variable de tipo byte que usa solo 8 bits, si estamos creando una variable de la 
cual sabemos que su contenido nunca va a llegar a más de 127, para qué vamos 
a sobrecargar nuestra aplicación haciéndola usar más bits de los necesarios, en 
este caso escogemos byte y no long. Siempre que creemos una variable y en 
general siempre que estemos programando, debemos pensar en la velocidad de 
nuestras aplicaciones y su óptimo rendimiento. De cualquier forma debemos tener 
mucho cuidado porque si tratamos de almacenar un número que excede la 
capacidad del tipo de su variable, el código no compilará en el mejor de los casos, 
en el peor de los casos el código compilará y habrán errores en el transcurso de 
41 
 
nuestra aplicación que pueden terminar causando errores graves o trabando 
nuestra aplicación. 
 
Al final de nuestro método main() tenemos un System.out.print() que imprime 
todas nuestras variables. Podemos agregar un + para concatenar resultados. 
Concatenar es el término que se usa en programación para decir que se 
encadenan o unen resultados. Debemos tener cuidado porque con el signo + 
podemos sumar dos números o simplemente visualizar el resultado de los dos por 
aparte. Supongamos que tenemos dos variables que contienen números, si 
escribimos System.out.print(variable1 + variable2) el resultado será la suma de los 
dos números. Si lo que queremos es ver ambos resultados por aparte sin que se 
sumen, lo que podemos hacer es poner en la mitad un String que recordemos que 
es texto entre comillas así System.out.print(variable1 + " " + variable2). En el caso 
anterior estamos agregando un texto que no es más que un espacio, éste va a 
permitir que se muestren los resultados separados por un espacio y no se sumen. 
Entonces en nuestro código original estamos uniendo resultados con el texto "\n" 
que lo que hace es simular un salto de línea, esto es como cuando hacemos enter 
en un procesador de texto. siempre que queramos hacer un salto de línea usamos 
dentro de un String el código \n. Como puedes ver, en el código original hice enter 
en medio del código que imprime el resultado porque no cabía el texto y terminé 
en la siguiente línea, esto no es problema ya que Java ignora la cantidad de 
espacio en blanco. Esto se puede hacer siempre que estemos fuera de comillas. 
 
Aquí hemos visto las variables primitivas, pero notemos que dentro de éstas no 
está la variables de tipo String que también es un tipo de variable válido. Lo que 
pasa es que String no es un tipo primitivo sino es un objeto. Por ahora no pretendo 
complicar el asunto, lo importante es que entiendas que existen los objetos y que 
los diferenciamos porque empiezan en mayúscula, más adelante veremos qué son 
los objetos. Observa que ninguno de los tipos primitivos empieza en mayúscula. 
Entonces las variables también pueden ser del tipo de objetos que son muchos y 
hasta tú puedes crearlos, pero esto lo veremos más adelante. 
42 
 
Arreglos 
 
Imaginemos que necesitamos