RESUMIENDO JAVA

1
 Qué necesitamos
• LA PÁGINA DE SUN
• En http://www.java.sun.com tenemos todo
lo necesario para bajarnos java y empezar
a trabajar con él.

2
 Ediciones de Java
• Lo primero que tenemos que decidir es qué "edición" de
java necesitamos. Hay tres disponibles: J2ME, J2SE y
J2EE
• J2ME es la versión "Micro". Es una versión "reducida" de
java para aparatos pequeños. Los más típicos son los
teléfonos móviles. Si no queremos desarrollar un juego
para uno de estos diabólicos inventos, esta no es nuestra
versión.
• J2SE es la versión "Standard". Esta es la versión para las
aplicaciones normales que pueden correr en un PC.
Normalmente, esta es la versión que debemos descargar.
• J2EE es la versión "Enterprise". Esta versión es para el
desarrollo de aplicaciones web. Es útil para gente que
programa en servidores web y hacen páginas web
complejas, con accesos a bases de datos, etc, etc.
3
• Suponemos que nos hemos decidido por el J2SE. Dentro tenemos
varias opciones para descargarnos. Vamos a verlas:
• JRE es el entorno de ejecución. Sirve para poder ejecutar
programas java que ya estén hechos, pero no para desarrollar
nuestros propios programas. Esta opción es la adecuada para
aquellos que quieren navegar por internet y que les funcionen los
applets (programitas java) incluidos en algunas páginas web o los
chats realizados en java.
• SDK es el entorno de desarrollo. Aquí está incluido el compilador
de java, el debugger y otras herramientas. Esta es la opción
adecuada para los que quieren programar en java sus propias
aplicaciones.
• SDK + netbeans es lo mismo de antes, pero incluye netbeans, un
entorno visual de desarrollo.

4
 UN ENTORNO VISUAL DE
DESARROLLO

• El SDK nos proporciona las herramientas

necesarias para hacer nuestros programas, pero
todas estas herramientas son a base de
comandos. Esto quiere decir que nuestro
programa java debemos escribirlo con un editor
de nuestro sistema operativo (el notepad, por
ejemplo, en windows o el vi en linux). Luego,
desde una ventana de ms-dos o shell de linux,
compilamos el programa por medio del
comando javac. Finalmente, desde la misma
ventana, lo ejecutamos con el comando java.
5
 Sesión típica
• La siguiente podría ser una sesión típica en linux una
vez instalado el SDK
 
• -- Editamos el fichero java, lo escribimos y lo salvamos
$ vi HolaMundo.java

-- Lo compilamos
$ javac HolaMundo.java

-- Lo ejecutamos
$ java HolaMundo
¡Hola Mundo!

6
• El netbeans es un entorno visual de desarrollo. Cuando
arrancamos netbeans, nos aparece un árbol con todas las clases
de nuestra aplcación o proyecto (por supuesto, la primera vez que
lo arranquemos saldrá vacío), un editor en el que podemos escribir
nuestro programa, con opciones para ejecutar, para depurar, etc,
etc. Para los conocedores de otros lenguajes, algo similar al Visual
C++, Visual Basic o C++ Builder.
• El desarrollo siempre es más fácil con una herramienta de este tipo,
sin embargo su gran ventaja es también su gran inconveniente: Nos
solucionan automáticamente muchos de los trabajos que haríamos
a mano de no tenerla. Esto hace que haya cosas que no
aprendamos. Es bastante habitual que programadores
acostumbrados a estas herramientas no sepan luego compilar o
incluso ejecutar un programa java fuera de ella.

7
• Netbeans tiene su propia página http://
www.netbeans.org en la que puedes
descargarte el mismo netbeans (es
gratuito) y módulos adicionales para el
mismo (unos son gratuitos y otros no).

8
• Hay otros entornos de desarrollo visuales
gratuitos, como eclipse, que puedes
descargarte de http://www.eclipse.org.
• Y además están los de pago, como
JBuilder (de Borland) o IntelliJ Idea.

9
 LA API DE JAVA

• Además de los tutoriales o libros de java que podamos

conseguir para aprender, es muy útil la API de java. La
API son un montón de páginas web en las que están
todas las clases standard de java, explicadas y con
enlaces a ejemplos y tutoriales. Están comentados todos
los métodos de todas las clases disponibles.
• La API está en la página de sun y es conveniente
tenerla siempre a mano, ya que es la referencia más
completa que podremos encontrar en cuanto a clases y
métodos se refiere.

10
 RESUMIENDO

• Para un programador que quiera empezar a hacer sus

pinitos en java, hay que irse a la página de sun
www.java.sun.com, bajarse dentro del J2SE el SDK e
instalarlo. Conviene hacer unos cuantos programas sin
entorno visual para aprender lo máximo posible.
• Conviene bajarse también la API, de forma que la
tengamos siempre a mano para consulta
• Luego, por comodidad (o si tenemos prisa por ponernos
a programar) podemos bajarnos un entorno visual de
desarrollo como netbeans de www.netbeans.org  o
eclipse de www.eclipse.org.

11
 CREAMOS EL PROGRAMA
• Lo mejor es empezar los primeros
programas con un editor de textos
normalito (notepad, vi, xemcas, etc).
• No usamos Word, WordPad, StarOffice o
cualquier otro procesador de textos en
condiciones, ya que los ficheros que
almacenan no los entiende nadie, salvo
ellos mismos. Por supuesto, mucho
menos el compilador de java.

12
• También es bueno para empezar compilar y ejecutar a
mano, desde línea de comandos.
• Es mejor no usar un IDE (estilo eclipse, netbeans,
jbuilder, etc) al principio.
• El IDE hace muchas cosas él sólo o con un simple click
de ratón, por ejemplo, compilar y ejecutar.
• La consecuencia de esto es que tú no aprendes a
hacerlas y luego, sin el IDE o con otro IDE distinto, estás
perdido. También es bastante normal que los IDE
añadan cosas propias de su cosecha, especialmente
JBuilder, que no son estandard de java. Si las usas sin
querer, estarás aprendiendo algo que no es java, sino
propio del IDE.

13
• En windows nos vale el notepad, en linux podemos usar
el vi. Atención a las mayúsculas y minúsculas en el
nombre del fichero y el nombre de la clase.

• $ vi HolaMundo.java
• c:\> notepad HolaMundo.java
• Ahora escribimos nuestro programa
• public class HolaMundo
{
    public static void main (String [ ] args)
    {
        System.out.println ("Hola mundo");
     }
}
14
• Guardamos el programa y salimos del
editor.
• Si más adelante queremos escribir en la
misma línea, debemos usar print().
• El código dentro del main será entonces
• System.out.println ("Hola Mundo");

15
 COMPILAMOS EL PROGRAMA

• Para compilar usamos el programa javac.

• Dicho programa está en el subdirectorio bin de donde hayamos
instalado java. Es importante para que todo vaya bien que ese
directorio bin esté en el path de busqueda de ejecutables.
• Para comprobar si está, probamos a ejecutarlo
• $ javac
• c:\> javac
• Si obtenemos un error del estilo "comando no se reconoce" o
"command not found" o similar, es que javac no está en la variable
de entorno PATH y debemos ponerlo.

16
• $ PATH=$PATH:/directorio_java/bin
• C:\> set PATH=%PATH
%;directorio_java\bin
• Si la ejecutar javac obtenemos un
mensaje de "Usage: javac" y la lista de
opciones, es que todo está correcto y
podemos compilar nuestro programa.

17
• Para compilar el programa, estando en el mismo
directorio en el que está el fichero
HolaMundo.java escribimos
• javac HolaMundo.java

• Si todo va bien, no obtendremos ninguna salida

de error y habrá aparecido un fichero
HolaMundo.class. Este fichero es nuestro
programa compilado y lo que se puede ejecutar.

18
 EJECUTAR EL PROGRAMA

• Una vez que tenemos HolaMundo.class, podemos

ejecutarlo y ver el resultado. Para ejecutar este
HolaMunod.class necesitamos un programa llamado
java que está también en el bin de donde tengamos
instalado java. Si hemos conseguido compilarlo, es que
este directorio está en el PATH y no deberíamos tener
problemas.

• $ java HolaMundo
Hola Mundo
• C:\> java HolaMundo
Hola Mundo

19
• El comando java admite como parámetro
el nombre de la clase, no el del fichero. La
clase se llama HolaMundo, el fichero se
llama HolaMundo.class. Por eso NO
HAY QUE PONER .class AL EJECUTAR.
Este despiste suele ser habitual en la
gente que empieza y llega a dar bastantes
quebraderos de cabeza hasta que se cae
en la cuenta.
20
 LA CLASE HolaMundo
• Hemos hecho una clase que hemos llamado
HolaMundo.
• En java es habitual meter cada clase en un fichero
distinto. Es obligatorio que la clase se llame igual que el
fichero. Importan las mayúsculas y las minúsculas, así
que no es lo mismo HolaMundo que holaMundo ni que
Holamundo. Como nuestra clase se llama HolaMundo,
debemos llamar a nuestro fichero HolaMundo.java.
• Si hubiera varias clases en el mismo fichero, java sólo
permite que se pueda usar una de ellas desde código
que esté fuera del fichero. Esa clase que se puede ver
desde todos lados debe llevar el modificador public.
Además, la clase public debe ser obligatoriamente la
que se lllama igual que el fichero.

21
• En resumen, si hacemos un fichero HolaMundo.java,
debemos meter dentro obligatoriamente y para que todo
vaya bien una clase pública que se llame HolaMundo.
Eso es lo que tenemos en la primera línea.
• public class HolaMundo
• ¿Desde dónde hasta dónde va la clase?. En java lo
marcamos con una llaves. Inmediatamente después del
nombre de la clase, abrimos unas llaves. Luego
hacemos el código de nuestra clase y finalmente la
cerramos.
• public class HolaMundo
{
...
}
22
 EL MÉTODO MAIN
• Dentro de la clase podemos poner código de muchas maneras distintas.
• Una forma habitual es hacer "métodos". Un método es un trozo de código al que
damos un nombre para poder identificarlo y llamarlo desde cualquier sitio.
• En java hay un nombre especial de método que es main. Cuando a java le decimos
que debe ejecutar el código de una clase, busca en dicha clase el método con
nombre main y es el método que ejecuta.
• Para que java entienda el método main, este debe estar declarado de una forma
muy concreta, que es la siguiente
• public static void main (String [ ] args)
{
...
}
• Debe ser public. Eso quiere decir que se le puede llamar desde cualquier lado.
• Debe ser static.  Esto quiere decir que se le puede llamar sin necesidad de
instanciar la clase
• Es void. Eso quiere decir que ese método no devuelve ningún resultado.
• El parámetro del método, que va entre paréntesis detrás de él, es un array de String
(cadenas de texto

23
 SACAR TEXTO POR LA
PANTALLA
• En java tenemos disponible la clase System que está accesible
directamente en cualquier sitio, es decir, podemos usarla sin hacer
nada especial siempre que queramos. Esta clase contiene cosas
relacionadas con nuestro sistema, con nuestro ordenador. Dentro,
entre otras cosas, tiene un atributo out que es público. Al ser
público podemos acceder a él libremente. Para acceder a este
atributo debemos indicar que está dentro de System. Eso se hace
poniendo System.out.
• Este atributo System.out esta ligado a la pantalla y es otra clase
que a su vez tiene métodos. Tiene método para poder enviarle
cadenas de caracteres que saldrán en pantalla. Los dos métodos
más usados son print() y println(). Ambos sacan el texto que
pongamos entre los paréntesis por pantalla, sólo que el segundo
añade además un "nueva línea

24
 CLASSPATH
• java busca los ficheros .class en determinados sitios.
Las versiones más antiguas de java los buscan en el
directorio en el que está instalado java. Las versiones
más modernas los buscan en los mismos directorios y
en el directorio actual. Si estás con un java moderno,
java encontrará tu fichero HolaMundo.class y no
tendrás problemas. Si estás con un java antiguo,
entonces no lo encontrará y te dará el error de que no
encuentra la clase HolaMundo.
• Afortunadamente, java se puede configurar para que
busque clases en otros directorios de los de defecto.
Hay dos formas de hacerlo.

25
 VARIABLE DE ENTORNO
CLASSPATH
• Una es por medio por la variable de entorno CLASSPATH. Simplemente debemos definir la
variable diciéndole en qué directorios están los ficheros .class. En windows estos directorios van
separados por punto y coma. En unix van separados por dos puntos.
• Podemos dar este path relativo o absoluto.

• $ CLASSPATH=.
$ CLASSPATH=/home/usuario/mi_proyecto_HolaMundo
$ export CLASSPATH

• C:\> set CLASSAPTH=.

C:\> set CLASSPATH="C:\Dcouments and Settings\usuario\mi_proyecto_HolaMundo"

• En unix suele ser necesario poner "export CLASSPATH" después de definir la variable.  En
unix, cuando se define una variable nueva por primera vez, si queremos que los demás procesos
(por ejemplo java cuando lo ejecutemos) la vean, es necesario ejecutar un export.
• En cuanto a windows, que tiene la costumbre de poner espacios en los nombres de directorio y
ficheros, suele ser necesario meterlo todo entre comillas, para que sepa que el comando no
termina en el espacio.
• Una vez hecho esto, deberíamos poder ejecutar el programa HolaMundo sin problemas.

26
 OPCION DEL COMANDO JAVA
• La otra opción para definir el CLASSPATH es hacerlo
como opción en la linea de comandos de java. Se haría
así
• $ java -cp . HolaMundo
$ java -cp /home/usuario/mi_proyecto_HolaMundo
HolaMundo
• C:\> java -cp . HolaMundo
C:\> java -cp "C:\Documents and
Settings\usuario\mi_proyecto_HolaMundo" HolaMundo

• Si usas esta opción, se ignora el valor de la variable

CLASSPATH, así que por norma general y para evitar
errores, elige qué forma te gusta más y usa sólo esa.

27
 QUÉ SON PAQUETES EN JAVA
• Cuando hacemos programas más grandes, es normal que el
número de clases vaya creciendo. Cada vez tenemos más y más
clases. Meterlas todas en el mismo directorio no suele ser lógico.
• Es mejor hacer grupos de clases, de forma que todas las clases
que traten de un determinado tema o estén relacionadas entre sí
vayan juntas.
• Por ejemplo, si hacemos un programa de una agenda de teléfonos
que los guarde en una base de datos, podemos meter todas las
clases que tratan con la base de datos en un paquete (grupo),
todas las de ventanas en otro, las de imprimir en otro, etc, etc.
• Un paquete de clases es un grupo de clases que agrupamos juntas
porque consideramos que están relacionadas entre sí o tratan de
un tema común.

28
 LA CLASE HOLA MUNDO EN UN
PAQUETE
• Java nos ayuda a organizar las clases en paquetes.
• En cada fichero .java que hagamos, al principio, podemos indicar a qué paquete pertenece la
clase que hagamos en ese fichero.
• Por ejemplo, si decidimos agrupar nuestros programas de pruebas, incluido el Hola Mundo, en
un paquete "prueba", pondríamos esto en nuestro fichero HolaMundo.java

• package prueba;
public class HolaMundo
{
    public static void main (String [ ] args)
    {
        System.out.println ("Hola mundo");
     }
}

• El código es exactamente igual al de nuestro Hola Mundo original, pero hemos añadido la línea
"package prueba;" al principio.
• Hasta aquí todo correcto. Sin embargo, al hacer esto, para que todo funcione bien, java nos
obliga a organizar los directorios, compilar y ejecutar de cierta forma.

29
ESTRUCTURA DE DIRECTORIOS
ASOCIADA
• Si hacemos que HolaMundo.java  pertenezca al paquete
prueba, java nos obliga a crear un subdirectorio "prueba" y
meter el HolaMundo.java ahí.
• Es decir, debemos tener esto así (unix y windows)
• /
<directorio_usuario>/mi_proyecto_HolaMundo/prueba/Hola
Mundo.java
• C:\<directorio_usuario>\mi_proyecto_HolaMundo\prueba\Ho
laMundo.java
• Nuevamente, las mayúsculas y minúsculas son importantes.
Tal cual lo pongamos en "package", debemos poner el
nombre del subdirectorio.
30
 COMPILAR UNA CLASE QUE
ESTÁ EN UN PAQUETE
• Para compilar la clase que está en el paquete debemos
situarnos en el directorio padre del paquete y compilar
desde ahí
• $ cd /<directorio_usuario>/mi_proyecto_HolaMundo
$ javac prueba/HolaMundo.java
• C:\> cd C:\<directorio_usuario>\mi_proyecto_HolaMundo
C:\> javac prueba\HolaMundo.java
• Si todo va bien, en el directorio "prueba" se nos creará
un HolaMundo.class

31
 EJECUTAR UNA CLASE QUE
ESTÁ EN UN PAQUETE
• Una vez generado el HolaMundo.class en el directorio prueba, para
ejecutarlo debemos estar situados en el directorio padre de
"prueba".
• El nombre "completo" de la clase es "paquete.clase", es decir
"prueba.HolaMundo". Por ello, para ejecutar, debemos hacerlo así

• $ cd /<directorio_usuario>/mi_proyecto_HolaMundo
$ java prueba.HolaMundo
Hola Mundo
• C:\> cd C:\<directorio_usuario>\mi_proyecto_HolaMundo
C:\> java prueba.HolaMundo
Hola Mundo

• Si todo va como debe, debería salir "Hola Mundo" en la pantalla

32
 EL CLASSPATH CUANDO LAS
CLASES ESTÁN EN PAQUETES
• Cuando las clases están en paquetes, la variable CLASSPATH debe
ponerse de tal forma que encuentre el paquete, NO la clase. Es decir, en
nuestro ejemplo
• $ CLASSPATH=/<directorio_usuario>/mi_proyecto_HolaMundo
$ export CLASSPATH
$ java prueba.HolaMundo
Hola Mundo
• C:\> set CLASSPATH="C:\<directorio_usuario>\mi_proyecto_HolaMundo"
C:\> java prueba.HolaMundo
Hola Mundo

• o bien, si usamos la opción -cp en la línea de comandos

• $ java -cp /<directorio_usuario>/mi_proyecto_HolaMundo
prueba.HolaMundo
Hola Mundo
• C:\> java -cp "C:\<directorio_usuario>\mi_proyecto_HolaMundo"
prueba.HolaMundo
Hola Mundo

33
 PAQUETES ANIDADOS
• Para poder organizar mejor las cosas, java permite hacer subpaquetes de
los paquetes y subpaquetes de los subpaquetes y así sucesivamente. Por
ejemplo, si quiero partir mis clases de prueba en pruebas básicas y pruebas
avanzadas, puedo poner más niveles de paquetes separando por puntos

• package prueba.basicas;
...
package prueba.avanzadas;
...
• A nivel de subdirectorios tendría que crear los subdirectorios "basicas" y
"avanzadas" debajo de "prueba" y meter ahí las clases que correspondan.
• Para compilar, en el directorio del proyecto habria que compilar poniendo
todo el path hasta llegar a la clase. Idem para el CLASSPATH. Para
ejecutar, el nombre de la clase va con todos los paquetes separados por
puntos, es decir "prueba.basicas.HolaMundo" y
"prueba.avanzadas.HolaMundoRemoto".

34
• Es decir:
• /
<directorio_usuario>/mi_proyecto_HolaMundo/prueba/basicas/Hola
Mundo.java
$ cd /<directorio_usuario>/mi_proyecto_HolaMundo
$ javac prueba/basicas/HolaMundo.java
$ java -cp /<directorio_usuario>/mi_proyecto_HolaMundo
prueba.basicas.HolaMundo
Hola Mundo
• C:\<directorio_usuario>\mi_proyecto_HolaMundo\prueba\basicas\H
olaMundo.java
C:\> cd C:\<directorio_usuario>\mi_proyecto_HolaMundo
C:\> javac prueba\basicas\HolaMundo.java
C:\> java -cp C:\<directorio_usuario>\mi_proyecto_HolaMundo
prueba.basicas.HolaMundo
Hola Mundo

35
• Cuando tenemos un programa grande, con varios
paquetes y clases, ya sabemos cómo organizarlo,
compilarlo y ejecutarlo.
• Sin embargo, para pasárselo a otros usuarios o
instalarlo en otro ordenador es un poco rollo. Tenemos
que llevarnos directorios enteros, con los ficheros que
hay dentro y demás.
• Lo ideal es meter todos estos ficheros y directorios en
un único fichero comprimido.
• Java, con su comando jar, que está en el directorio bin
de donde tengamos java,  nos permite hacer esto.
Empaqueta todo lo que le digamos (directorios, clases,
ficheros de imagen o lo que queramos) en un único
fichero de extensión .jar.
36
• Un fichero de extensión .jar es similar a los .zip
de Winzip, a los .rar de Winrar o a los ficheros
.tar del tar de unix. De hecho, con Winzip o
Winrar se puede ver y desempaquetar el
contenido de un fichero .jar
• Java nos da además otra opción, podemos
ejecutar las clases del fichero .jar sin tener
que desempaquetarlo. Simplemente podemos
darle a nuestro usuario el fichero .jar con todo
dentro y ya está listo para ejecutar.
37
• Para crear un fichero jar, en primer lugar tenemos que tener todo
ya perfectamente preparado y compilado, funcionando.
• Si las clases de nuestro programa no pertenecen a paquetes,
simplemente debemos meter las clases en el fichero .jar Para ello,
vamos al directorio donde estén los ficheros .class y ejecutamos el
siguiente comando
• $ cd directorio_con_los_class
$ jar -cf fichero.jar fichero1.class fichero2.class fichero3.class
• La opción "c" indica que queremos crear un fichero.jar nuevo. Si ya
existía, se machacará, así que hay que tener cuidado. La opción "f"
sirve para indicar el nombre del fichero, que va inmediatamente
detrás. En nuestro caso, fichero.jar. Finalmente se pone una lista
de ficheros .class (o de cualquier otro tipo) que queramos meter en
nuestro jar. Se pueden usar comodines, estilo *.class para meter
todos los .class de ese directorio.

38
• Si las clases de nuestro porograma pertenecen a
paquetes, debemos meter en nuestro jar la estructura de
directorios equivalente a los paquetes entera.
• Para ello, nos vamos al directorio padre de donde
empiece nuestra estructura de paquetes. En el caso de
nuestro HolaMundo con paquete, debemo meter el
directorio prueba completo. El comando a ejecutar es
este.
• $ cd directorio_padre_de_prueba
$ jar -cf fichero.jar prueba
• Las opciones son las mismas, pero al final en vez de las
clases, hemos puesto el nombre del directorio. Esto
meterá dentro del jar el directorio y todo lo que hay
debajo.
39
• Otra opción sería meter los .class, pero
indicando el camino relativo para llegar e
ellos
• $ cd directorio_padre_de_prueba
$ jar -cf fichero.jar
prueba/HolaMundo.class
• En windows la barra va al revés...

40
VER QUÉ HAY DENTRO DE UN JAR

• Para comprobar si nuestro jar está bien hecho,

podemos ver su contenido. El comando es este
• $ jar tf fichero.jar
• La opción "t" indica que queremos un listado del
fichero.jar. La opción "f" es igual que antes. Esto
nos dará un listado de los class (y demás
ficheros) que hay dentro, indicando en que
directorio están. Deberíamos comprobar en ese
listado que están todas las clases que
necesitamos y la estructura de directorios
concuerda con la de paquetes.
41
 MODIFICAR UN JAR

• Para cambiar un fichero dentro de un jar o

añadirle uno nuevo, la opción del comando jar
es "u". Si el fichero existe dentro del jar, lo
reemplaza. Si no existe, lo añade.
• Por ejemplo, si hacemos un cambio en nuestro
HolaMundo.class con paquete y lo
recompilamos, podemos reemplazarlo así en el
jar
• $ jar uf fichero.jar prueba/HolaMundo.class

42
 CÓMO EJECUTAR UN JAR
• Para ejecutar un jar, símplemente debemos poner el fichero jar en el
CLASSPATH.
• Ojo, hay que poner el fichero.jar, NO el directorio en el que está el fichero.jar.
• Este suele ser un error habitual al empezar, pensar que basta con poner el
directorio donde está el jar.
• Para los .class, basta poner el directorio, para los .jar hay que poner el
fichero.jar
• El path para indicar la ubicación del fichero puede ser absoluto o relativo al
directorio en el que ejecutemos el comando java. El comando para ejecutar una
clase dentro de un jar, en nuestro caso del HolaMundo con paquete,
suponiendo que estamos en el directorio en el que está el fichero.jar, sería este
• $ java -cp ./fichero.jar prueba.HolaMundo
Hola Mundo
• Simplemente, en la opción -cp del CLASSPATH hemos puesto el fichero.jar con
su PATH relativo.
• Detrás hemos puesto el nombre de la clase, completo, con su paquete deltante.
Nuevamente, en windows la barra de directorio va al revés.

43
EL FICHERO DE MANIFIESTO
• Ejecutar así tiene una pega. Además de acordarse de poner la opción -cp,
hay que saber el nombre de la clase que contiene el método main().
Además, si nuestro programa es muy grande, tendremos varios jar, tanto
nuestros como otros que nos bajemos de internet o de donde sea. La
opción -cp también puede ser pesadita de poner en ocasiones.
• Una opción rápida que a todos se nos ocurre es crearse  un pequeño
fichero de script/comandos en el que se ponga esta orden. Puede ser un
fichero .bat de windows o un script de unix. Este fichero debe acompañar al
fichero.jar y suponiendo que estén en el mismo directorio, su contenido
puede ser este
• java -cp ./fichero.jar prueba.HolaMundo
• Para ejecutarlo, se ejecuta como un fichero normal de comandos/script. Si
el fichero se llama ejecuta.sh o ejecuta.bat, según sea unix o windows:
• $ ./ejecuta.sh
Hola Mundo
• C:\> ejecuta.bat
Hola Mundo

44
• Sin embargo, java nos ofrece otra posibilidad de forma que no tengamos
que hacer este fichero. Simplemente, en un fichero de texto metemos una
línea en la que se ponga cual es la clase principal. Este fichero se conoce
como fichero de manifiesto y su contenido puede ser este
• Main-Class: prueba.HolaMundo
• Cuando contruimos el jar, debemos incluir este fichero de una forma
especial. Por ejemplo, si el fichero lo llamamos manifiesto.txt y lo ponemos
en el directorio donde vamos a construir el jar, el comando para hacerlo
sería este
• $ jar cmf manifiesto.txt fichero.jar prueba/HolaMundo.class
• En windows, nuevamente, la barra al revés. Al comando de crear jar le
hemos añadido la opción "m" para indicar que vamos a añadir un fichero de
manifiesto. Hemos añadido además el fichero manifiesto.txt. El orden de las
opciones "mf" es importante. El fichero de manifiesto y el fichero.jar se
esperan en el mismo orden que pongamos las opciones. En el ejemplo,
como hemos puesto primero la ocpión "m", debemos poner manifiesto.txt
delante de fichero.jar. El resto de ficheros son los que queremos
empaquetar.

45
• Una vez construido, se ejecuta fácilmente. Basta con
poner
• $ java -jar fichero.jar
• La opción "-jar" indica que se va a ejecutar el fichero.jar
que se ponga a continuación haciendo caso de su
fichero de manifiesto. Como este fichero de manfiesto
dice que la clase principal es prueba.HolaMundo, será
esta la que se ejecute.
• De esta forma nos basta con entregar el jar y listo. El
comando para arrancarlo es sencillo.
• Es más, en windows, si lo configuramos para que los
ficheros jar se abran con java y la opción -jar, bastará
con hacer doble click sobre ellos para que se ejecuten.

46
 Teclado en Java
• LOS InputStream: EL OBJETO System.in
• Al igual que Java nos ofrece System.out para escribir
en pantalla, tenemos System.in para leer de ella.
System.in es un objeto de una clase de java que se
llama InputStream.
• Para java, un InputStream es cualquier cosa de la que
se leen bytes. Puede ser el teclado, un fichero, un
socket, o cualquier otro dispositivo de entrada. Esto, por
un lado es una ventaja. Si todas esas cosas son
InputStream, podemos hacer código que lea de ellas
sin saber qué estamos leyendo.

47
• Por otro lado, es un problema. Como un
InputStream es para leer bytes, sólo tiene
métodos para leer bytes. Nosotros
queremos leer palabras o números del
teclado, no bytes. Si escribimos en el
teclado una A mayúscula y la leemos con
System.in, obtendremos un entero de
valor 65, que es el valor del byte
correspondiente a la A.
48
 LOS Reader
• Para java, una clase Reader es una clase
que lee caracteres. Esto se parece más a
lo que queremos. Un Reader tiene
métodos para leer caracteres. Con esta
clase ya podriamos trabajar.
• La pena es que seguimos teniendo
System.in, que es un InputStream y no
un Reader.

49
 ¿Cómo convertimos el System.in
en Reader?
• Hay una clase en java, la
InputStreamReader, que nos hace esta
conversión.
• Para obtener un Reader, únicamente
tenemos que instanciar un
InputStreamReader pasándole en el
constructor un InputStream.

50
• El código es el siguiente
• InputStreamReader isr = new
InputStreamReader(System.in);
• Estamos declarando una variable "isr" de tipo
InputStreamReader. Creamos un objeto de
esta clase haciendo new
InputStreamReader(...).
• Entre paréntesis le pasamos el InputStream
que queremos convertir a Reader, en este caso,
el System.in

51
• Ya tenemos el Reader. ¿Cómo funciona exactamente?
• InputStreamReader es un Reader. Se comporta igual
que in Reader y se puede poner en cualquier sitio que
admita un Reader. Es decir, podemos leer de él
caracteres.
• Al constuirlo le hemos pasado un InputStream, en
concreto, System.in. InputStreamReader de alguna
forma se lo guarda dentro.
• Cuando a InputStreamReader le pedimos caracteres, él
le pide al InputStream que tiene guardado dentro los
bytes, los convierte a caracteres y nos los devuelve.

52
 LA CLASE BufferedReader

• Con la clase InputStreamReader podríamos servirnos.

• El problema es que nos da los caracteres sueltos. Si estamos
leyendo de teclado, el que usa el programa puede escribir 10
caracteres o 20 o 13. Si usamos InputStreamReader, como lee
caracteres sueltos, tenemos que decirle cuántos queremos (que no
lo sabemos), o bien ir pidiendo de uno en uno hasta que no haya
más.
Esto es un poco lioso y si sólo tuvieramos la clase
InputStreamReader sería un trozo de código que tendriamos que
repetir por muchos lados. Para el caso concreto de leer de teclado,
sería ideal si hubiese una clase en java que nos lea de golpe todo
lo que ha escrito el usuario de nuestro programa y nos lo diera de
un golpe.

53
• Se llama BufferedReader.
• El mecanismo para obtener un
BufferedReader a partir de otro Reader
cualquiera (por ejemplo el
InputStreamReader), es similar al que
usamos antes. Lo instanciamos pasándole
en el construtor el Reader.

54
• El código es
• BufferedReader br = new BufferedReader (isr);
• El funcionamiento de esta clase es igual que el
InputStreamReader. Cuando le pedimos una línea completa de
caracteres (un String), ella se lo pide al Reader que tenga dentro,
los convierte en String y nos lo devuelve.
• Para pedirle un String, se usa el método readLine(). Este método
lee todos los caracteres tecleados (recibidos si fuera otro dispositivo
de entrada) hasta que encuentra la pulsación de la tecla <INTRO>,
<RETURN> o como quieras llamarla.
• String texto = br.readLine();
• Esto lee del teclado un String completo y lo guarda en una variable
"texto".

55
 CONVERTIR LA CADENA String
EN UN ENTERO int
• Si queremos leer un número del teclado, el
usuario escribe por ejemplo 123, con la clase
BufferedReader obtendremos un String que
contiene "123", es decir, tres caracteres. Eso no
se parece en nada a un número 123.
• Para convertir el String en un número entero
(sin decimales), podemos usar otra clase de
Java. La clase Integer vale para muchas cosas,
pero entre otras es capaz de convertir un String
a int. Siempre que sea posible. Por ejemplo
"abc" no se puede convertir a número de
ninguna manera.

56
• La clase Integer es muy estricta.
• Para convertir el String a int necesita que
el String sea exactamente un int.
Cualquier caracter o letra que tenga el
String y no valga, hará que la conversión
falle.
• Por ejemplo, "123a" da fallo por culpa de
la "a" del final. Del mismo modo "12 3" da
fallo por el espacio entre el "12" y el "3".
57
• La conversión se realiza así
• int valor = Integer.parseInt(texto);
• Esto intenta convertir texto en un int y si
no hay problemas, guarda el resultado en
una variable int llamada valor.

58
 EXCEPCIONES Exception Y try-
catch
• Cuando en java puede fallar algo, por ejemplo, la conversión de la
cadena en int, suele avisarnos.
• Esto lo hace "lanzando excepciones".
• Una excepción es algo que lanza Java para avisarnos que ha
habido un problema.
• En nuestro código podemos "capturar" esas excepciones y hacer
algo para tratar de arreglaro. Por ejemplo, si le pedimos al usuario
que meta un número, el usuario escribe "abc", lo leemos e
intentamos convertirlo a int, nos salta una excepción. Si capturamos
esa excepción, en el código que hagamos para tratarla, podemos
avisar al usuario que se ha equivocado un poco al teclear, que lo
intente de nuevo y volver a pedirle el número.

59
• Para capturar una excepción, tenemos que
hacer el código así
• try
{
    // Aquí el código que puede fallar
}
 catch (Exception e)
{
    System.out.println(e);
    e.printStackTrace();
    // Aquí el código para tratar el fallo
}

60
• Lo habitual, al menos mientras estamos haciendo
nuestro programa, es sacar por pantalla el error, para
tener una pista de qué ha fallado. Eso se puede
coneiguir de las dos formas:
• Por un lado, de la forma que ya conocemos, con
System.out.println(e); Esto nos saca una línea de texto
con el error correspondiente en inglés del bueno.
• Por otro lado, llamando al método printStackTrace() de
la excepción que se ha provocado. Esta llamada escribe
la misma línea de texto de error, pero además nos dice
exactamente en qué línea de código se produce el error.
Esta información es muy útil si nuestro programa todavía
está a medias y no acaba de hacer lo que queremos.
61
 UN EJEMPLO: SUMAR DOS
NÚMEROS
• Como ejemplo, vamos a ver un programa
completo que pide dos números al
usuario, los suma y saca el resultado.

62
• import java.io.*;
public class suma
{
    public static void main (String [] args)
    {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader (isr);
        try
        {
            System.out.print("Sumando 1 : ");
            int s1 = Integer.parseInt(br.readLine());
            System.out.print("Sumando 2 : ");
            int s2 = Integer.parseInt(br.readLine());
            int suma=s1+s2;
            System.out.println ("La suma es " + s1 + "+" + s2 +"="+ suma);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

63
• Cuando vimos el tema de paquetes, vimos que
las clases se pueden agrupar en paquetes.
• Todas las clases que hemos visto aquí de java
relativas a Streams y Readers, están en el
paquete java.io.
• En la primera linea de código, con el import,
estamos avisando a java que vamos a usar
clases de ese paquete.
• Es necesario poner esta linea, decirle a java en
qué paquetes están las clases, porque en otros
paquetes puede haber clases con el mismo
nombre, para distinguir unas de otras.
64
• Luego lo compilas y lo puedes ejecutar
• $ javac suma.java
$ java suma
Sumando 1 : 2
Sumando 2 : 4
La suma es 2+4=6

65
• Si fallamos, tendremos esto
• $ javac suma.java
$ java suma
Sumando 1 : 2
Sumando 2 : asd
java.lang.NumberFormatException: For input string: "asd"
        at java.lang.NumberFormatException.forInputString(Unknown Source)
        at java.lang.Integer.parseInt(Unknown Source)
        at java.lang.Integer.parseInt(Unknown Source)
        at suma.main(suma.java:14)

• Obtenemos una excepción "NumberFormatException" para la cadena

"asd", es decir, que no puede obtener el número a partir de "asd". En la
última línea, vemos que el error se produce en la línea 14 del fichero
suma.java, en el método main(). Es decir, si contamos líneas en el código,
en la línea
• int s2 = Integer.parseInt(br.readLine());
• Las otras tres líneas son en las clases de java que se ha producido el error.

66