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Á

i TABLA DE CONTENIDOS

Preliminar

Introducción ... 1

Antes de empezar ... 7

NetBeans IDE ... 18

Bases del lenguaje

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

Encapsulación ... 84

ii

Polimorfismo ... 101

Clases externas ... 105

Más allá de las bases

Multihilos ... 116

Estáticos ... 119

¿Qué es un API? ... 122

GUI ... 127

Eventos ... 146

MIDI API

La comunicación MIDI ... 157

La información MIDI ... 170

Bancos de sonidos ... 183

Archivos MIDI ... 189

Edición de secuencias ... 192

Sampled API

Explorando los recursos del sistema ... 207

iii

Programación de un metrónomo

Una aplicación real ... 226

Planeación ... 228

Programando ... 232

Resultado y código completo ... 249

Final

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 herramientas de trabajo y contribuyen en nuestro mundo con soluciones creativas.

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.

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.

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

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, una gran 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

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.

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.

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.

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

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.

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

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

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.

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:

15 No le agregamos la extensión ni nada y 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

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.

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.

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.

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ías escogemos Java, en proyectos escogemos Java Applications

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.

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.

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.

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

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 nombre no 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.

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) {

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

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.

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.

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.

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.

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";

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

34 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.

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.

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:

*/

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

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 variable sirve 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.

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

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.

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.

42 Arreglos

Imaginemos que necesitamos una variable que pueda albergar varios contenidos a la vez. En mi experiencia personal me he dado cuenta que casi toda aplicación necesita variables de este tipo. Por ejemplo cuando he creado juegos que enseñan música, necesito crear una variable que contenga todos los nombres de notas como Do, Re, Mi, Fa, etc. En estos casos usamos los arreglos. Veamos cómo se escribe un arreglo que contenga todos los nombres de notas sin sostenidos o bemoles:

public class Arreglos {

public static void main(String[ ] args) {

String[ ] nombresDeNotas = new String[7]; nombresDeNotas[0] = "Do";

nombresDeNotas[1] = "Re"; nombresDeNotas[2] = "Mi"; nombresDeNotas[3] = "Fa"; nombresDeNotas[4] = "Sol"; nombresDeNotas[5] = "La"; nombresDeNotas[6] = "Si";

System.out.println(nombresDeNotas[0]); }

}

Como ya debemos tener claro, primero creamos una clase y luego el método main(). En la primera línea del método principal inicializamos un nuevo arreglo así:

String[ ] nombresDeNotas = new String[7];

43 escribimos un corchete que abre y en seguida uno que cierra, esta es la indicación que le damos a Java para decirle que estamos creando un arreglo y no una variable normal. Después de los corchetes escribimos el nombre que le queremos asignar al arreglo, este nombre debe seguir los mismos parámetros que las variables. Luego ponemos un signo igual y escribimos new String[7]; que es el código necesario para declarar que el contenido de este arreglo es de 7 elementos del mismo tipo especificado anteriormente que es un String. Si el arreglo hubiese sido de tipo int entonces escribiríamos así:

int[ ] arregloDeNumeros = new int[7];

En este ejemplo creamos un arreglo de tipo int con 7 elementos de contenido pero

todavía no hemos especificado qué contenido va en cada una de esas 7 casillas. Volviendo a nuestro código original, en las siguientes líneas especificamos el contenido de cada casilla, veamos la primera:

nombresDeNotas[0] = "Do";

Con este código estamos asignando el texto "Do" a la primera de las siete casillas

de nuestro arreglo llamado nombresDeNotas. Dentro de los corchetes escribimos

la casilla en la que vamos a meter un contenido, pero debemos ser cuidadosos porque estas casillas no se nombran desde el número 1 sino desde 0. Entonces la primera casilla es 0, la segunda es 1, la tercera es 2 y así sucesivamente. Después de especificar la casilla simplemente escribimos el signo igual y luego el contenido seguido de punto y coma para aclarar que acabamos una sentencia. No olvidemos que toda sentencia lleva punto y coma, tampoco olvidemos que las clases y los métodos en sí no son sentencias y por eso no llevan punto y coma.

44

En nuestro System.out.println(nombresDeNotas[0]); estamos imprimiendo la

casilla 0, si queremos imprimir otra casilla simplemente cambiamos el número dentro de los corchetes por cualquier otro número válido de casilla.

Quiero aclarar que en la creación de los arreglos podemos poner los corchetes después del tipo o después del nombre del arreglo, ambas notaciones son válidas. También pudimos haber asignado los valores a las casillas inmediatamente en el momento de creación del arreglo de la siguiente forma:

String[ ] nombresDeNotas = {"Do", "Re", "Mi", "Fa", "Sol", "La", "Si"};

Esta línea produce exactamente el mismo resultado que nuestras primeras 8 líneas dentro del método principal. Aunque esta es mucho más corta, hay ocasiones en las que necesitamos primero crear el arreglo y más adelante en el código asignar su contenido, así que debemos aprender las dos formas. Como ya vimos antes, podemos crear arreglos de tipos primitivos y también arreglos de

objetos como String. Más adelante veremos qué son los objetos.

Si en algún momento queremos saber cuántas casillas tiene un arreglo, podemos

usar el código nombresDeNotas.length e igualarlo a una variable para guardar el

número así:

int largoDeArreglo = nombresDeNotas.length;

45 Matemáticas

Como lo he dicho antes, la programación requiere de un pensamiento muy matemático. Gracias a la matemática podemos ahorrar mucho tiempo programando nuestras aplicaciones. Cuando estemos viendo la parte de audio aplicaremos matemáticas más avanzadas como funciones seno y coseno para poder crear ondas, pero este tema es tan amplio que podríamos llegar a profundizar en temas como derivadas rápidas de Fourier para analizar nuestro audio. En este proyecto de grado pretendo hacer un primer acercamiento a las generalidades de la programación en Java, pero no olvidemos que algunos de los temas que trato aquí, son en realidad incluso maestrías completas para los programadores, así que no puedo pretender incluirlo todo. Lo importante es que al leer este capítulo de matemáticas tengas claras algunas nociones básicas para que luego vayas y aprendas más por otros medios. Veamos el siguiente código que hace las cuatro operaciones básicas en matemáticas:

public class Math {

public static void main(String[] args) { int num1 = 134;

int num2 = 60; // suma

int suma = num1 + num2; // resta

int resta = num1 - num2;

// multiplicación. Se usa el símbolo * int multi = num1 * num2;

// división usando double

double division = (double) num1 / num2;

// Imprime el resultado que quieras, en este caso división System.out.println(division);