Introduccin

a Java
Por Nacho Cabanes,
Versin 0.40 de Julio de 2015

Este texto se puede distribuir libremente,

siempre y cuando no se modifique

ltima versin disponible en

www.nachocabanes.com/java

Tabla de contenido
1. Introduccin: por qu Java? ...................................................................................... 5
1.1. Qu es Java?.................................................................................................................. 5
1.2. Por qu usar Java? ....................................................................................................... 5
1.3. Cundo no usar Java? .................................................................................................. 5
1.4. Qu ms aporta Java?.................................................................................................. 6
1.5. Qu hace falta para usar un programa creado en Java?......................................... 6
1.6. Qu hace falta para crear un programa en Java? .................................................... 6

2. Instalacin del entorno de desarrollo ....................................................................... 8

2.1. Instalacin del JDK y NetBeans bajo Windows .......................................................... 8
2.2. Instalacin de Eclipse en Windows ........................................................................... 16
2.3. Instalacin del JDK y Eclipse bajo Linux .................................................................... 17
2.4. Instalacin de Netbeans bajo Linux .......................................................................... 19
2.5. La alternativa ligera: Geany........................................................................................ 21

3. Nuestro primer programa ........................................................................................ 22

3.1. Un programa que escribe "Hola Mundo" ................................................................. 22
3.2. Entendiendo este primer programa ......................................................................... 22

3.2.1. Escribir en pantalla ...................................................................................................23

3.2.2. Formato libre ............................................................................................................23
3.2.3. El cuerpo del programa ............................................................................................23
3.2.4. El nombre del programa ...........................................................................................24
3.2.5. Comentarios .............................................................................................................24
3.2.6. Varias rdenes ..........................................................................................................25
3.2.7. Escribir y avanzar de lnea ........................................................................................25
3.3. Compilar y lanzar el programa desde lnea de comandos..................................... 26
3.4. La alternativa bsica pero cmoda: Geany .............................................................. 27
3.5. Manejo bsico de NetBeans ...................................................................................... 29
3.6. Contacto con Eclipse ................................................................................................... 33

4. Variables y operaciones matemticas bsicas ....................................................... 38

4.1. Las variables................................................................................................................. 38
4.2. Operaciones matemticas bsicas............................................................................ 40
4.3. Operar con datos introducidos por el usuario ........................................................ 40
4.4. Incremento y asignaciones abreviadas .................................................................... 42
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 2

4.5. Otros tipos de datos numricos ................................................................................ 44

5. Comprobacin de condiciones ................................................................................ 47

5.1. if ..................................................................................................................................... 47
5.2. El caso contrario: else ................................................................................................. 48
5.3. Operadores relacionales ............................................................................................ 49
5.4. Operadores lgicos para enlazar condiciones......................................................... 50
5.5. switch ............................................................................................................................ 51
5.6. El operador condicional .............................................................................................. 54

6. Bucles: partes del programa que se repiten ........................................................... 56

6.1. while .............................................................................................................................. 56
6.2. do-while ........................................................................................................................ 57
6.3. for .................................................................................................................................. 59
6.4. break y continue .......................................................................................................... 63
6.5. Etiquetas ....................................................................................................................... 64

7. Booleanos, caracteres, cadenas de texto y arrays ................................................. 66

7.1 Datos booleanos .......................................................................................................... 66
7.2. Caracteres .................................................................................................................... 67
7.3. Las cadenas de texto .................................................................................................. 68

7.3.1. String ........................................................................................................................68

7.3.2. StringBuilder .............................................................................................................73
7.4. Los arrays. .................................................................................................................... 75

8. Las Matemticas y Java ............................................................................................. 81

9. Contacto con las funciones. ..................................................................................... 85
9.1.Descomposicin modular ........................................................................................... 85
9.2. Parmetros................................................................................................................... 88
9.3. Valor de retorno .......................................................................................................... 88

10. Clases en Java. ......................................................................................................... 91

10.2. Varias clases en Java ................................................................................................. 93
10.3. Herencia ..................................................................................................................... 98
10.4. Ocultacin de detalles ............................................................................................ 100
10.5. Sin "static" ................................................................................................................ 101
10.6. Constructores .......................................................................................................... 103

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 3

11. Ficheros .................................................................................................................. 105

11.1. Por qu usar ficheros? .......................................................................................... 105
11.2. Escribir en un fichero de texto .............................................................................. 105
11.3. Leer de un fichero de texto .................................................................................... 106
11.4. Leer de un fichero binario ...................................................................................... 108
11.5. Leer y escribir bloques en un fichero binario ...................................................... 109

Cambios en el curso .................................................................................................... 111

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 4

1. Introduccin: por qu Java?

1.1. Qu es Java?
Java es un lenguaje de programacin de ordenadores, desarrollado por Sun
Microsystems en 1995 (compaa que fue posteriormente absorbida por Oracle,
en 2010).
Hay varias hiptesis sobre su origen, aunque la ms difundida dice que se cre
para ser utilizado en la programacin de pequeos dispositivos, como aparatos
electrodomsticos (desde microondas hasta televisores interactivos). Se pretenda
crear un lenguaje con algunas de las caractersticas bsicas de C++, pero que
necesitara menos recursos y que fuera menos propenso a errores de
programacin.
De ah evolucion (hay quien dice que porque el proyecto inicial no acab de
funcionar) hasta convertirse en un lenguaje muy aplicable a Internet y
programacin de sistemas distribuidos en general.
Pero su campo de aplicacin no es exclusivamente Internet: una de las grandes
ventajas de Java es que se procura que sea totalmente independiente del
hardware: existe una "mquina virtual Java" para varios tipos de ordenadores. Un
programa en Java podr funcionar en cualquier ordenador para el que exista dicha
"mquina virtual Java" (hoy en da es el caso de los ordenadores equipados con los
sistemas operativos Windows, Mac OS X, Linux, y algn otro). Pero aun hay ms: el
sistema operativo Android para telfonos mviles propone usar Java como
lenguaje estndar para crear aplicaciones.

1.2. Por qu usar Java?

Puede interesarnos si queremos crear programas que tengan que funcionar en
distintos sistemas operativos sin ningn cambio, o programas cliente/servidor, o
aplicaciones para un Smartphone Android, entre otros casos. Tampoco es un mal
lenguaje para aprender a programar, aunque en ocasiones resulta un tanto
engorroso para un principiante.

1.3. Cundo no usar Java?

Como debe existir un paso intermedio (la "mquina virtual") para usar un
programa en Java, no podremos usar Java si queremos desarrollar programas para
un sistema concreto, para el que no exista esa mquina virtual. Y si necesitamos
que la velocidad sea la mxima posible, quiz no sea admisible lo (poco) que
ralentiza ese paso intermedio.
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 5

1.4. Qu ms aporta Java?

Tiene varias caractersticas que pueden sonar interesantes a quien ya es
programador, y que ya ir conociendo poco a poco quien no lo sea:

La sintaxis del lenguaje es muy parecida a la de C++ (y a la de C, C#, PHP y

algn otro). Eso simplifica el aprendizaje de Java si se conoce alguno de
esos lenguajes, y tambin permite aprovechar los conocimientos de Java
para aprender despus uno de estos otros lenguajes.

Es un lenguaje orientado a objetos, lo que supondr ventajas a la hora de

disear y mantener programas de gran tamao.

Permite crear programas "multitarea" (formados por varios hilos de

ejecucin), lo que ayuda a sacar mejor partido de los modernos
procesadores con mltiples ncleos.

Incluye control de excepciones, como alternativa ms sencilla para manejar

errores inesperados, como un fichero inexistente o una conexin de red
perdida.

Es ms difcil cometer errores de programacin que en otros lenguajes ms

antiguos, como C y C++ (por ejemplo, no existen los "punteros", que son
una fuente de quebraderos de cabeza en esos lenguajes).

Se pueden crear programas en modo texto, entornos "basados en

ventanas", dibujar grficos, acceder a bases de datos, etc.

1.5. Qu hace falta para usar un programa creado en Java?

Vamos a centrarnos en el caso de un "ordenador convencional", ya sea de
escritorio o porttil.
Las aplicaciones que deban funcionar "por s solas" necesitarn que en el
ordenador de destino exista algn "intrprete" de Java, eso que hemos llamado la
"mquina virtual". Esto es cada vez ms frecuente (especialmente en sistemas
como Linux), pero si no lo tuviramos (como puede ocurrir en Windows), basta con
instalar el "Java Runtime Enviroment" (JRE), que se puede descargar libremente
desde Java.com (unos 10 Mb de descarga).

1.6. Qu hace falta para crear un programa en Java?

Existen diversas herramientas que nos permitirn crear programas en Java. La
propia Oracle suministra un kit de desarrollo oficial que se conoce como JDK (Java
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 6

Development Kit). Es de libre distribucin y se puede conseguir en la propia pgina

Web de Oracle.
http://www.oracle.com/technetwork/java/javase/downloads/index.html
El inconveniente del JDK es que no incluye un editor para crear nuestros
programas, slo las herramientas para generar el programa ejecutable y para
probarlo.
Por eso, puede resultar incmodo de manejar para quien est acostumbrado a
otros entornos integrados, como los de Visual C# y Visual Basic, que incorporan
potentes editores. Pero no es un gran problema, porque es fcil encontrar
editores que hagan ms fcil nuestro trabajo, o incluso sistemas de desarrollo
completos,

como

Eclipse

(http://www.eclipse.org/downloads/)

NetBeans.

(https://netbeans.org/ downloads/index.html). Ambos son buenos y gratuitos. En

el prximo tema veremos cmo descargarlos e instalarlos, as como alguna
alternativa para ordenadores menos potentes.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 7

2. Instalacin del entorno de desarrollo

Para poder programar en Java, necesitars tanto el compilador (el llamado "Kit de
desarrollo", JDK) como algn editor. Veremos los entornos ms habituales y su
instalacin en Windows y Linux. En principio, el entorno ms recomendable para
un principiante es NetBeans, y hay alternativas an ms ligeras, como Geany, cuya
instalacin es inmediata en Linux pero ligeramente ms incmoda en Windows.

2.1. Instalacin del JDK y NetBeans bajo Windows

El JDK (Java Development Kit) es la herramienta bsica para crear programas
usando el lenguaje Java. Es gratuito y se puede descargar desde la pgina oficial de
Java, en el sitio web de Oracle (el actual propietario de esta tecnologa, tras haber
adquirido Sun, la empresa que cre Java):
www.oracle.com/technetwork/java/javase/downloads
All encontraremos enlaces para descargar (download) la ltima versin
disponible.

En primer lugar, deberemos escoger nuestro sistema operativo y (leer y) aceptar

las condiciones de la licencia:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 8

Entonces empezaremos a recibir un nico fichero de gran tamao (cerca de 70 Mb,

segn versiones):

Al tratarse de un fichero de gran tamao, la descarga puede ser lenta,

dependiendo de la velocidad de nuestra conexin a Internet (y de lo saturados que
estn los servidores de descarga):

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 9

Cuando hayamos descargado, haremos doble clic en el fichero, para comenzar la

instalacin propiamente dicha:

Podremos afinar detalles como la carpeta de instalacin, o qu partes no

queremos instalar (por ejemplo, podramos optar por no instalar los ejemplos). Si
tenemos suficiente espacio (posiblemente unos 400 Mb en total), generalmente la
opcin ms sencilla hacer una instalacin tpica, sin cambiar nada:

Ahora deberemos tener paciencia durante un rato, mientras se descomprime e

instala todo:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 10

En cierto punto se nos preguntar si queremos instalar la mquina virtual Java

(Java Runtime Environment, JRE). Lo razonable ser responder que s, para poder
probar los programas que creemos.
Igual que para el JDK, podramos cambiar la carpeta de instalacin del JRE:

Tendremos que esperar otro momento...

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 11

Y si todo ha ido bien, deberamos obtener un mensaje de confirmacin:

Y se nos propondr registrar nuestra copia de Java en la pgina de Oracle (no es

necesario):

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 12

Con eso ya tenemos instalada la herramienta bsica, el compilador que convertir

nuestros programas en Java a algo que pueda ser utilizado desde cualquier otro
equipo que tenga una mquina virtual Java.
Pero el kit de desarrollo (JDK) no incluye ningn editor con el que crear nuestros
programas. Podramos instalar un "editor genrico", porque tenemos muchos
gratuitos y de calidad, como Notepad++. Aun as, si nuestro equipo es
razonablemente moderno, puede ser preferible instalar un entorno integrado,
como NetBeans, que encontraremos en
http://netbeans.org

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 13

Si hacemos clic en "Download", se nos llevar a la pgina de descargas, en la que

tenemos varias versiones para elegir. Lo razonable "para un novato" es descargar
la versin para "Java SE" (Standard Edition; las alternativas son otros lenguajes,
como PHP o C++, versiones profesionales como Java EE -Enterprise Edition-, o una
versin que engloba todas estas posibilidades).
Es posible que tambin podamos escoger el Espaol como idioma, en vez del
ingls (slo en algunas versiones).

La instalacin no se podr completar si no hemos instalado Java antes, pero si lo

hemos hecho, debera ser simple y razonablemente rpida:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 14

Y al final quiz se nos pregunte si queremos permitir que se recopile estadsticas

sobre nuestro uso:

Todo listo. Tendremos un nuevo programa en nuestro men de Inicio. Podemos

hacer doble clic para comprobar que se ha instalado correctamente, y debera
aparecer la pantalla de carga:

Y despus de un instante, la pantalla "normal" de NetBeans:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 15

Ya estaramos listos para empezar a crear nuestro primer programa en Java, pero
eso queda para la siguiente leccin...

2.2. Instalacin de Eclipse en Windows

Eclipse es otro entorno de desarrollo para Java, alternativo a NetBeans, tambin
muy extendido, aunque algo ms pesado (ocupa ms espacio y es ms lento en
funcionamiento). Se puede descargar desde eclipse.org:

Al igual que ocurre con NetBeans, existen versiones de Eclipse para crear
programas en distintos lenguajes o incluso con diferentes versiones de Java. Lo
razonable ser usar "Eclipse for Java Developers" (no la versin de Java EE,
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 16

Enterprise Edition, que aade herramientas que un principiante no va a necesitar y

que pueden complicar el entorno).
Es habitual que se nos proponga descargar un fichero ZIP, que deberemos
descomprimir en la carpeta que nosotros escojamos y lanzar despus con un
doble clic (no se creara una opcin en el men de Inicio).

Estas mayores complicaciones en la instalacin son otro punto en su contra y a

favor de NetBeans. Aun as, si se ha instalado previamente el JDK y se ha reiniciado
el equipo antes de intentar instalar Eclipse, es esperable que funcione todo a la
primera.

2.3. Instalacin del JDK y Eclipse bajo Linux

Instalar el JDK (Java Development Kit) en Linux puede ser an ms fcil que en
Windows. En casi cualquier distribucin Linux actual bastara con entrar al " Gestor
de paquetes Synaptic" (o la herramienta que use nuestro sistema para instalar
nuevos programas), buscar "jdk" y hacer doble clic en el paquete llamado
"openjdk-6-jdk" (o similar) para marcarlo:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 17

De paso, podemos aprovechar para instalar Eclipse, que tambin se suele poder
escoger desde el gestor de paquetes de la mayora de distribuciones de Linux:

En ambos casos, se nos avisar de que esos paquetes dependen de otros que
tambin habr que instalar:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 18

Cuando hagamos clic en el botn "Aplicar", se descargarn todos los paquetes

(casi 200 Mb en total) y se instalarn (debera ocupar algo ms de 300 Mb de
disco). A partir de entonces, en nuestro men, en el apartado de Programacin (o
Desarrollo), tendremos un acceso a Eclipse. Si entramos, deberamos ver algo
parecido a esto:

(Los detalles de cmo empezar a programar con Eclipse los veremos en el prximo
tema)

2.4. Instalacin de Netbeans bajo Linux

En la mayora de distribuciones de Linux actuales, NetBeans tambin estar
disponible desde Synaptic (o el gestor de paquetes que incluya esa distribucin):
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 19

Y, al igual que hemos visto que ocurra con el JDK y con Eclipse, se nos avisar en
caso de que sea necesario instalar algn paquete extra:

Si no pudiramos instalarlo desde el gestor de paquetes, deberamos descargar

desde su pgina oficial, bien sea en su "versin para Linux" oficial, o bien a partir
una versin comprimida en fichero ZIP capaz de funcionar en cualquier sistema
operativo (para el que exista una versin de la mquina virtual Java, claro), que
deberamos descomprimir en una carpeta de nuestra eleccin.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 20

2.5. La alternativa ligera: Geany

Podemos usar otras muchas herramientas, adems de NetBeans y Eclipse. Si
nuestro ordenador no est muy sobrado de recursos, disponemos de alternativas
ms simples, editores avanzados como Geany (que podramos instalar en un par
de clics usando Synaptic o el gestor de paquetes de cualquier distribucin Linux).
Su apariencia es sta:

Tambin se puede usar Geany en otros sistemas operativos, como Windows, pero
en este caso, el manejo puede no ser tan sencillo: tendremos que instalar primero
el JDK, luego Geany, y quiz aun as no podamos compilar y lanzar directamente
los programas desde Geany, sino que obtengamos un mensaje de error que nos
diga que no encuentra Java. Para solucionarlo, habra que cambiar la configuracin
de Geany o incluir Java en el "Path" de Windows, pero son tareas que quiz no
estn al alcance de un principiante, as que las esquivaremos por ahora...

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 21

3. Nuestro primer programa

3.1. Un programa que escribe "Hola Mundo"
Comenzaremos por crear un pequeo programa en modo texto. Este primer
programa se limitar a escribir el texto "Hola Mundo!" en la pantalla. En primer
lugar, veremos cmo es este programa, luego comentaremos un poco (todava con
poco detalle) las rdenes que lo forman y finalmente veremos cmo probar ese
programa con distintos entornos.
Nuestro primer programa ser:
// HolaMundo.java
// Aplicacin HolaMundo de ejemplo
class HolaMundo {
public static void main( String args[] ) {
System.out.print( "Hola Mundo!" );
}
}

Dos detalles que hay que considerar antes de seguir adelante:

Puede parecer complicado para ser un primer programa. Es cierto, lo es. Si

Java es tu primer lenguaje de programacin, tienes que asumirlo: Java es
as, no pretende que lo simple sea simple, sino que lo complicado no sea
terrible. Por eso, los grandes proyectos sern ms fciles de mantener y
menos propensos a errores que con otros lenguajes ms antiguos como
BASIC o C, pero los programas bsicos parecern innecesariamente
complejos.

Dentro de poco veremos cmo teclearlo. Ser importante respetar las

maysculas y minsculas exactamente como estn en el ejemplo. El hecho
de escribir "system" en vez de "System" har que obtengamos un error de
compilacin.

Ejercicio propuesto 3.1.1: Crea un programa en Java que te salude en pantalla

por tu nombre (por ejemplo, "Hola, Nacho").

3.2. Entendiendo este primer programa

La nica parte del programa que necesitamos comprender por ahora es la lnea
central. Por eso, vamos a analizarlo de dentro hacia fuera, dejando todava
algunos detalles en el aire.
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 22

3.2.1. Escribir en pantalla

La orden que realmente escribe en pantalla es: System.out.print( "Hola Mundo!"
); La orden que se encarga de escribir es "print". Se trata de una orden de salida
(out) de nuestro sistema (System), y deberemos escribirla siempre usando esas
tres palabras, una tras otra y separadas por puntos: System.out.print
Lo que deseemos escribir se indicar entre parntesis. Si se trata de un texto que
deba aparecer tal cual, ir adems encerrado entre comillas.
Tambin es importante el punto y coma que aparece al final de esa lnea: cada
orden en Java deber terminar con punto y coma (nuestro programa ocupa varias
lneas pero slo tiene una orden, que es "print").
Por eso, la forma de escribir un texto ser:
System.out.print( "Hola Mundo!" );

3.2.2. Formato libre

Java es un lenguaje "de formato libre". Antes de cada orden, podemos dejar tantos
espacios o tantas lneas en blanco como nos apetezca. Por eso, es habitual escribir
un poco ms a la derecha cada vez que empecemos un nuevo bloque
(habitualmente cuatro espacios), para que el programa resulte ms legible.
Ese es el motivo de que nuestra orden "print" no estuviera pegada al margen
izquierdo, sino ms a la derecha (ocho espacios, porque est dentro de dos
bloques).
System.out.print( "Hola Mundo!" );

3.2.3. El cuerpo del programa

En todos los programas creados usando Java, debe existir un bloque llamado
"main", que representa el cuerpo del programa. Por motivos que veremos ms
adelante, este bloque siempre comenzar con las palabras "public static void" y
terminar con "(String args[])":
public static void main( String args[] )

El contenido de cada bloque del programa se debe detallar entre llaves. Por eso, la
lnea "print" aparece despus de "main" y rodeada por llaves:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 23

public static void main( String args[] ) {

System.out.print( "Hola Mundo!" );
}

Estas llaves de comienzo y de final de un bloque se podran escribir en cualquier

punto del programa antes del contenido del bloque y despus de su contenido, ya
que, como hemos dicho, Java es un lenguaje de formato libre. Aun as, pro
convenio, es habitual colocar la llave de apertura al final de la orden que abre el
bloque, y la llave de cierre justo debajo de la palabra que abre el bloque, como se
ve en el ejemplo anterior.
3.2.4. El nombre del programa
Cada programa Java debe "tener un nombre". Este nombre puede ser una nica
palabra o varias palabras unidas, e incluso contener cifras numricas, pero debe
empezar por una letra y no debe tener espacios intermedios en blanco. El nombre
se debe indicar tras la palabra "class" (ms adelante veremos a qu se debe el uso
de esa palabra) y a continuacin se abrir el bloque que delimitar todo el
programa, con llaves:
class HolaMundo {
public static void main( String args[] ) {
System.out.print( "Hola Mundo!" );
}
}

El programa se debe guardar en un fichero, cuyo nombre coincida exactamente

con lo que hemos escrito tras la palabra "class", incluso con las mismas
maysculas y minsculas. Este nombre de fichero terminar con ".java". As, para
nuestro

primer

programa

de

ejemplo,

el

fichero

debera

llamarse

"HolaMundo.java".
3.2.5. Comentarios
Las dos primeras lneas del programa son:
// HolaMundo.java
// Aplicacin HolaMundo de ejemplo

Estas lneas, que comienzan con una doble barra inclinada (//) son comentarios.
Nos sirven a nosotros de aclaracin, pero nuestro ordenador las ignora, como si
no hubisemos escrito nada.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 24

Si queremos que un comentario ocupe varias lneas, o slo un trozo de una lnea,
en vez de llegar hasta el final de la lnea, podemos preceder cada lnea con una
doble barra, como en el ejemplo anterior, o bien indicar dnde queremos empezar
con "/*" (una barra seguida de un asterisco) y dnde queremos terminar con "*/"
(un asterisco seguido de una barra), as:
/* Esta es la
Aplicacin HolaMundo
de ejemplo */

3.2.6. Varias rdenes

Si queremos "hacer varias cosas", podremos escribir varias rdenes dentro de
"main". Por ejemplo, podramos escribir primero la palabra "Hola", luego un
espacio y luego "Mundo!" usando tres rdenes "print" distintas:
// HolaMundo2.java
// Segunda aplicacin HolaMundo de ejemplo
class HolaMundo2 {
public static void main( String args[] ) {
System.out.print( "Hola" );
System.out.print( " " );
System.out.print( "Mundo!" );
}
}

Como puedes imaginar, este programa deber estar guardado en un fichero

llamado "HolaMundo2.java". Como tambin podrs intuir, el formato libre se
refiere a las rdenes del lenguaje Java, no a los mensajes en pantalla: si escribes
varios espacios con una orden "print", todos ellos sern visibles en pantalla.

3.2.7. Escribir y avanzar de lnea

En ocasiones no querremos escribir todo en la misma lnea. Para avanzar de lnea
tras escribir algo, basta con usar "println" en vez de "print":
// HolaMundo3.java
// Tercera aplicacin HolaMundo de ejemplo
class HolaMundo3 {
public static void main( String args[] ) {
System.out.println( "Hola..." );
System.out.println( "Mundo!" );

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 25

}
}

Ejercicio propuesto 3.2.1: Crea un programa en Java que te salude en pantalla

por tu nombre. En la primera lnea de pantalla aparecer la palabra "Hola" y
ser en la segunda lnea de pantalla donde aparezca tu nombre. Usa dos
rdenes "println" distintas.

3.3. Compilar y lanzar el programa desde lnea de comandos

Si quieres aprender a programar, deberas no tener miedo a la "lnea de
comandos", esa pantalla que tpicamente tiene fondo negro y letras blancas, y en
la que se teclean las rdenes en vez de hacer clic. En Linux normalmente se le
llama "Terminal" y en Windows puede aparecer como "Smbolo del sistema".
Si has instalado el JDK pero ningn entorno de desarrollo, podras abrir esa lnea
de comandos, lanzar desde ella un editor, despus compilar el programa y
finalmente, si todo ha ido bien, lanzar el programa ejecutable resultante.
En un Linux, tpicamente el primer paso ser lanzar un editor (como "gedit" en la
versiones basadas en Gnome) y decirle el nombre que queremos que tenga el
fichero que se va a crear:
gedit HolaMundo.java

El segundo paso ser lanzar el compilador, llamado "javac", indicndole el nombre

del programa que queremos analizar:
javac HolaMundo.java

Si nuestro programa contiene algn error, se nos mostrar un mensaje que dir la
lnea y columna en la que se ha detectado. Si no es as, obtendremos un fichero
ejecutable llamado "HolaMundo.class", que podremos poner en funcionamiento
tecleando:
java HolaMundo

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 26

En Windows, si todo va bien (cosa que no siempre ocurre), los pasos seran los
mismos, pero el editor que viene preinstalado es el bloc de notas (notepad), luego
comenzaramos por teclear:
notepad HolaMundo.java

Ejercicio propuesto 3.3.1: Prueba a compilar desde "lnea de comandos" el

programa que te saludaba en pantalla por tu nombre (si no lo consigues,
dentro de poco podrs hacerlo usando NetBeans).

3.4. La alternativa bsica pero cmoda: Geany

Geany es uno de los entornos ms sencillos que permite teclear nuestros
programas y tambin compilarlos y probarlos sin abandonar el editor.
Basta con escribir nuestro fuente, y guardarlo en un fichero llamado
"HolaMundo.java" (en general, el mismo nombre que la clase, respetando
maysculas y minsculas). Cuando pulsemos el botn de "compilar" el fuente, en
la parte inferior de la ventana se nos mostrar si todo ha ido bien:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 27

Si no ha habido errores, a continuacin podremos pulsar el botn de Ejecutar para

poner nuestro programa en marcha:

Y aparecer una ventana de terminal, que mostrar el resultado:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 28

En caso de existir algn error de compilacin, al volver al editor se nos mostraran

subrayadas en color rojo las lneas incorrectas.
Ejercicio propuesto 3.4.1: Crea un programa en Java, usando Geany, que te
salude en pantalla por tu nombre (por ejemplo, "Hola, Nacho").

3.5. Manejo bsico de NetBeans

Vamos a ver qu pasos dar en NetBeans para crear un programa como ese.
En primer lugar, deberemos entrar al men "Archivo" y escoger la opcin
"Proyecto Nuevo":

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 29

Se nos preguntar el tipo de proyecto. Se tratar de una "Aplicacin Java".

Deberemos indicar un nombre para el proyecto. Tenemos tambin la posibilidad

de cambiar la carpeta en que se guardar.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 30

Y entonces aparecer un esqueleto de programa que recuerda al que nosotros

queremos conseguir... salvo por un par de detalles:

Falta la orden "System.out.print"

Sobra una orden "package"

La orden "package" deberemos conservarla si usamos NetBeans, para indicar que

nuestro programa es parte de un proyecto. La orden "print" deberemos aadirla, o
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 31

de lo contrario nuestro programa no escribir nada en pantalla. Podramos borrar

los comentarios adicionales, hasta llegar a algo como esto:
// HolaMundoNetBeans.java
// Aplicacin HolaMundo de ejemplo, para compilar con NetBeans
package prueba01;
public class HolaMundoNetBeans {
public static void main( String args[] ) {
System.out.print( "Hola Mundo!" );
}
}

Si hacemos clic en el botn de Ejecutar (el que muestra una punta de flecha de
color verde), nuestro programa se pondr en marcha (si no tiene ningn error), y
su resultado se mostrar en la parte inferior derecha de la pantalla de trabajo de
NetBeans:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 32

Ejercicio propuesto 3.5.1: Crea un programa en Java, usando NetBeans, que

te salude en pantalla por tu nombre (por ejemplo, "Hola, Nacho").

3.6. Contacto con Eclipse

Personalmente, NetBeans me parece un entorno ms sencillo, ms amigable y
ms rpido que Eclipse. Aun as, por si no has conseguido hacer funcionar tu
programa con NetBeans o por si quieres conocer tambin Eclipse, vamos a ver los
pasos bsicos para probar un programa como el nuestro.
Para crear nuestro proyecto con Eclipse, deberemos entrar al men "File"
(Archivo), y en la opcin "New" (Nuevo) tendremos "Java Project":

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 33

Se nos pedir un nombre para el proyecto, y que confirmemos si se trata de un

nuevo proyecto (como es nuestro caso) o si queremos partir de otros fuentes que
ya existen (no por ahora):

Aparecer nuestro proyecto vaco:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 34

Y ahora deberemos aadir una clase a nuestro proyecto (File / New / Class):

Se nos preguntar el nombre para la clase (junto con otros datos que por ahora no
necesitamos cambiar):

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 35

Y nos aparecer un esqueleto de clase (algo ms vaco que en el caso de

NetBeans):

Sobre ese esqueleto, escribiremos (o copiaremos y pegaremos) los detalles de

nuestro fuente:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 36

Y si pulsamos el botn "Run", el programa se compilar y se pondr en marcha, y

su resultado se mostrar en la parte inferior de la pantalla, en la pestaa
"Console":

Ejercicio propuesto 3.6.1: Crea un programa en Java, usando Eclipse, que te

salude en pantalla por tu nombre (por ejemplo, "Hola, Nacho").

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 37

4. Variables y operaciones matemticas bsicas

4.1. Las variables.
En nuestro primer ejemplo escribamos un texto en pantalla, pero este texto
estaba prefijado dentro de nuestro programa.
De forma muy similar, podemos realizar operaciones matemticas si las indicamos
sin comillas. As, el ordenador sabr que no debe escribir algo "tal cual", sino que
debe intentar descubrir su significado:
// Suma1.java
// Ejemplo de suma con datos prefijados
// Introduccin a Java, Nacho Cabanes
class Suma1 {
public static void main( String args[] ) {
System.out.println(
"La suma de 56 y 23 es:" ); // Mostramos un mensaje de aviso
System.out.println(
56+23 ); // y el resultado de la operacin
}
}

Pero esto no es lo habitual: normalmente los datos que maneje nuestro programa
sern el resultado de alguna operacin matemtica o de cualquier otro tipo, a
partir de datos introducidos por el usuario, ledos de un fichero, obtenidos de
Internet... Por eso, necesitaremos un espacio en el que ir almacenando valores
temporales y resultados de las operaciones.
En casi cualquier lenguaje de programacin podremos reservar esos "espacios", y
asignarles un nombre con el que acceder a ellos. Esto es lo que se conoce como
"variables".
Por ejemplo, si queremos que el usuario introduzca dos nmeros y el ordenador
calcule la suma de ambos nmeros y la muestre en pantalla, necesitaramos el
espacio para almacenar al menos esos dos nmeros iniciales. No sera
imprescindible reservar espacio tambin para la suma, porque podemos mostrarla
en pantalla en el mismo instante en que la calculamos. Los pasos a dar seran los
siguientes:
Avisar al usuario de que deseamos que introduzca un nmero.

Almacenar ese valor que introduzca el usuario (por ejemplo, en un espacio

de memoria al que podramos asignar el nombre "primerNumero").
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 38

Pedir al usuario que introduzca otro nmero.

Almacenar el nuevo valor (por ejemplo, en otro espacio de memoria

llamado "segundoNumero").

Mostrar

en

pantalla

el

resultado

de

sumar

"primerNumero"

"segundoNumero".
Pues bien, en este programa estaramos empleando dos variables llamadas
"primerNumero" y "segundoNumero". Cada una de ellas se usara para acceder a
un espacio de memoria, que ser capaz de almacenar un nmero.
Para no desperdiciar memoria de nuestro ordenador, el espacio de memoria que
hace falta "reservar" se podr optimizar segn lo grande que pueda llegar a ser
dicho nmero (la cantidad de cifras), o segn la precisin que necesitemos para
ese nmero (cantidad de decimales). Por eso, tenemos disponibles diferentes
"tipos de variables".
Por ejemplo, si vamos a manejar nmeros sin decimales ("nmeros enteros") de
como mximo 9 cifras, nos interesara el tipo de datos llamado "int" (esa palabra
es la abreviatura de "integer", "entero" en ingls). Este tipo de datos consume un
espacio de memoria de 4 bytes. Si no necesitamos guardar datos tan grandes (por
ejemplo, si nuestros datos va a ser nmeros inferiores a 10.000), podemos
emplear el tipo de datos llamado "short" (entero "corto"), que ocupa la mitad de
espacio.
Con eso, vamos a ver un programa sume dos nmeros enteros (de no ms de 9
cifras) prefijados y muestre en pantalla el resultado:
// Suma2.java
// Ejemplo de suma con variables
// Introduccin a Java, Nacho Cabanes
class Suma2 {
public static void main( String args[] ) {
int primerNumero = 56; // Dos enteros con valores prefijados
int segundoNumero = 23;
System.out.println(
"La suma de 56 y 23 es:" ); // Muestro un mensaje de aviso
System.out.println(
primerNumero+segundoNumero ); // y el resultado de la operacin
}
}

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 39

Como se ve, la forma de "declarar" un variable es detallando primero el tipo de

datos que podr almacenar ("int", por ahora) y despus el nombre que daremos la
variable. Adems, opcionalmente se puede indicar un valor inicial.
Ejercicio propuesto 4.1.1: Crea un programa en Java que escriba en pantalla
el producto de dos nmeros prefijados (pista: el smbolo de la multiplicacin
es el asterisco, "*").

4.2. Operaciones matemticas bsicas.

Hay varias operaciones matemticas que son frecuentes. Veremos cmo
expresarlas en Java, as como otra operacin menos habitual:

Operacin matemtica Smbolo correspondiente

Suma

Resta

Multiplicacin

Divisin

Resto de la divisin

Hemos visto un ejemplo de cmo calcular la suma de dos nmeros; las otras
operaciones se emplearan de forma similar. La nica operacin "menos habitual"
es el resto de la divisin. Por ejemplo, si dividimos 14 entre 3, obtenemos 4 como
cociente y 2 como resto, de modo que el resultado de 14 % 3 sera 2.
Ejercicio propuesto 4.2.1: Crea un programa que muestre la divisin de dos
nmeros prefijados.
Ejercicio propuesto 4.2.2: Crea un programa que muestre el resto de dividir
100 entre 30.

4.3. Operar con datos introducidos por el usuario

Vamos a ver cmo hacer que sea el usuario quien introduzca valores para esas
variables, que es algo mucho ms habitual. Nuestro primer ejemplo sumar dos
nmeros, que en esta ocasin no estarn prefijados:
// Suma3.java
// Ejemplo a las variables introducidas por el usuario
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 40

// Introduccin a Java, Nacho Cabanes

import java.util.Scanner;
class Suma3 {
public static void main( String args[] ) {
Scanner teclado = new Scanner(System.in);
System.out.print( "Introduzca el primer nmero: " );
int primerNumero = teclado.nextInt();
System.out.print( "Introduzca el segundo nmero: " );
int segundoNumero = teclado.nextInt();
System.out.print( "Su suma es: " );
System.out.println( primerNumero+segundoNumero );
}
}

En este programa hay varias cosas nuevas:

Vamos a usar una caracterstica que no es algo bsico del lenguaje. Por eso
le decimos que deseamos "importar" nuevas funcionalidades. En nuestro
caso, se trata de un tal "Scanner", que nos permitir analizar textos: import
java.util.Scanner;

En concreto, nuestro scanner va a tomar datos desde la entrada del sistema

(System.in), por lo que lo declaramos con: Scanner teclado = new
Scanner(System.in); El nombre "teclado" podra ser "entrada" o cualquier
otro.

A partir de entonces, cada vez que llamemos a ".nextInt()" se leer un

nmero desde la entrada estndar del sistema (el teclado): int
primerNumero = teclado.nextInt();

Son varias novedades, pero tampoco debera resultar difcil. Este programa
escribir algo como (dependiendo de los datos que introduzca el usuario):
Introduzca el primer nmero: 34
Introduzca el segundo nmero: 56
Su suma es: 90

Es habitual declarar las variables al principio del programa, antes de que comience
la lgica real que resuelve el problema. Si varias variables van a guardar datos del
mismo tipo, se pueden declarar todas ellas a la vez, separadas por comas, como
en el siguiente ejemplo:
// Suma3b.java
// Dos variables declaradas a la vez
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 41

// Introduccin a Java, Nacho Cabanes

import java.util.Scanner;
class Suma3b {
public static void main( String args[] ) {
Scanner teclado;
int primerNumero, segundoNumero;
teclado = new Scanner(System.in);
System.out.print( "Introduzca el primer nmero: " );
primerNumero = teclado.nextInt();
System.out.print( "Introduzca el segundo nmero: " );
segundoNumero = teclado.nextInt();
System.out.print( "Su suma es: " );
System.out.println( primerNumero+segundoNumero );
}
}

Como la forma de asimilar todo esto es probndolo, aqu tienes varios ejercicios
propuestos:
Ejercicio propuesto 4.3.1: Crea un programa que calcule y muestre el
producto de dos nmeros enteros que introduzca el usuario.
Ejercicio propuesto 4.3.2: Crea un programa que calcule y muestre la divisin
de dos nmeros enteros que introduzca el usuario.
Ejercicio propuesto 4.3.3: Crea un programa que calcule y muestre el resto
de la divisin de dos nmeros enteros que introduzca el usuario.
Ejercicio propuesto 4.3.4: Crea un programa que pida al usuario una longitud
en millas (por ejemplo, 3) y calcule su equivalencia en metros (1 milla = 1609
m).
Ejercicio propuesto 4.3.5: Crea un programa que pida al usuario una
temperatura en grados centgrados y calcule (y muestre) a cuntos grados
Fahrenheit equivalen (F = 9*C/5 + 32).
Ejercicio propuesto 4.3.6: Crea un programa que pregunte al usuario la base
y la altura de un tringulo y muestre su superficie (S = B*A/2).

4.4. Incremento y asignaciones abreviadas

Hay varias operaciones muy habituales, que tienen una sintaxis abreviada en Java.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 42

Por ejemplo, para sumar 2 a una variable "a", la forma "normal" de conseguirlo
sera:
a = a + 2;

pero existe una forma abreviada en Java:

a += 2;

Al igual que tenemos el operador += para aumentar el valor de una variable,

podemos emplear -= para disminuirlo, /= para dividirla entre un cierto nmero, *=
para multiplicarla por un nmero, y as sucesivamente. Por ejemplo, para
multiplicar por 10 el valor de la variable "b" haramos
b *= 10;

Tambin podemos aumentar o disminuir en una unidad el valor de una

variable, empleando los operadores de "incremento" (++) y de "decremento" (--).
As, para sumar 1 al valor de "a", podemos emplear cualquiera de estas tres
formas:
a = a+1;
a += 1;
a++;

Los operadores de incremento y de decremento se pueden escribir antes o

despus de la variable. As, es lo mismo escribir estas dos lneas:
a++;
++a;

Pero hay una diferencia si ese valor se asigna a otra variable "al mismo tiempo"
que se incrementa/decrementa:
int c = 5;
int b = c++;

da como resultado c = 6 y b = 5, porque se asigna el valor a "b" antes de

incrementar "c", mientras que
int c = 5;
int b = ++c;

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 43

da como resultado c = 6 y b = 6 (se asigna el valor a "b" despus de incrementar

"c").
Por eso, para evitar efectos colaterales no esperados, es mejor no incrementar
una variables a la vez que se asigna su valor a otra, sino hacerlo en dos pasos.
Ejercicio propuesto 4.4.1: Calcula "a mano" el resultado de las siguientes
operaciones con nmeros enteros, y luego crea un programa que muestre el
resultado.
a = 5;
a++;
a*=2;
a-=3;
a%=5;
a=a+7;

4.5. Otros tipos de datos numricos

No slo se puede almacenar nmeros enteros de hasta 9 cifras. Java nos permite
usar tambin otros tipos de datos numricos:
Nombre

Admite
decimales?

Valor mn.

Valor mx.

Precisin Ocupa

byte

no

-128

127

short

no

-32.768

32.767

int

no

-2.147.483.648

2.147.483.647

long

no

float

double s

9.223.372.036.854.775.808

9..223.372.036.854.775.807 -

1.401298E-45

3.402823E38

4.94065645841247E-324

1.79769313486232E308

1
byte
2
bytes
4
bytes
8
bytes

6-7

cifras

bytes

14-15

cifras

bytes

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 44

Los datos de tipo byte, short, int y long sirven para almacenar nmeros enteros,
de mayor o menor tamao. Si se desborda ese tamao, el programa se
interrumpir con un error, como en este ejemplo:
// DesbordarByte.java
// Ejemplo de desbordamiento de una variable
// Introduccin a Java, Nacho Cabanes
class DesbordarByte {
public static void main( String args[] ) {
byte dato = 100;
System.out.print( "El dato inicialmente es: " );
System.out.println( dato );
dato += 100;
System.out.print( "Si sumamos 100, el dato ahora es: " );
System.out.println( dato );
}
}

Que mostrara:
El dato inicialmente es: 100
Si sumamos 100, el dato ahora es: -56

Por su parte, los datos float y double permiten almacenar nmeros reales (con
cifras decimales), que pueden almacenar los nmeros de forma incorrecta si
tienen ms cifras que la permitida por ese tipo de datos, como en este ejemplo:
// PrecisionFloat.java
// Ejemplo de lmite de precisin de un dato float
// Introduccin a Java, Nacho Cabanes
class PrecisionFloat {
public static void main( String args[] ) {
float dato = 1.23456789f;
System.out.print( "El dato inicialmente es: " );
System.out.println( dato );
dato += 1000;
System.out.print( "Si sumamos 1000, el dato ahora es: " );
System.out.println( dato );
}
}

Que escribira:
El dato inicialmente es: 1.2345679
Si sumamos 1000, el dato ahora es: 1001.23456

Para pedir datos de estos tipos, podemos usar un "Scanner" con ".nextByte",
".nextShort", ".nextLong", ".nextFloat" o ".nextDouble"
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 45

Por ejemplo, se podra sumar dos nmeros reales de forma similar a como hemos
visto para dos nmeros enteros:
// SumaFloat.java
// Sumar dos nmeros reales
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class SumaFloat {
public static void main( String args[] ) {
Scanner teclado;
float primerNumero, segundoNumero;
teclado = new Scanner(System.in);
System.out.print( "Introduzca el primer nmero real: " );
primerNumero = teclado.nextFloat();
System.out.print( "Introduzca el segundo nmero real: " );
segundoNumero = teclado.nextFloa.t();
System.out.print( "Su suma es: " );
System.out.println( primerNumero+segundoNumero );
}
}

Un ejemplo de su posible resultado (que muestra las posibles prdidas de

precisin) podra ser:
Introduzca el primer nmero real: 2,3
Introduzca el segundo nmero real: 3,56
Su suma es: 5.8599997
Ejercicio propuesto 4.5.1: Crea un programa que calcule y muestre la suma
de dos nmeros de dos cifras (de tipo byte) que introduzca el usuario.
Ejercicio propuesto 4.5.2: Crea un programa que pida al usuario su ao de
nacimiento y el ao actual (usando datos de tipo short) y halle la diferencia de
ambos para obtener su edad.
Ejercicio propuesto 4.5.3: Crea un programa que calcule y muestre la divisin
de dos nmeros reales de doble precisin introducidos por el usuario.
Ejercicio propuesto 4.5.4: Crea un programa que pida al usuario una longitud
en millas (por ejemplo, 3) y calcule su equivalencia en kilmetros, usando
datos de tipo float (1 milla = 1.609 km).

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 46

5. Comprobacin de condiciones
5.1. if
En cualquier lenguaje de programacin es habitual tener que comprobar si se
cumple una cierta condicin. La forma ms simple de conseguirlo es empleando
una construccin que recuerda a:
SI condicin ENTONCES rdenes

En Java, la forma exacta ser empleando if (si, en ingls), seguido por la condicin
entre parntesis, e indicando finalmente entre llaves los pasos que queremos dar
si se cumple la condicin, as :
if (condicin)

{ rdenes }

Por ejemplo,
// If1.java
// Comprobacin de condiciones con "if" 1: mayor que
// Introduccin a Java, Nacho Cabanes
class If1 {
public static void main( String args[] ) {
int x = 10;
if (x > 5) {
System.out.println( "x es mayor que 5" );
}
}
}

Nota: Las llaves slo sern imprescindibles cuando haya que hacer varias cosas. Si
slo queremos dar un paso en caso de que se cumpla la condicin, no es
necesario emplear llaves (aunque puede ser recomendable usar siempre las llaves,
para no olvidarlas si ms adelante ampliamos ese fragmento del programa):
// If2.java
// Comprobacin de condiciones con "if" 2: sin llaves
// Introduccin a Java, Nacho Cabanes
class If2 {
public static void main( String args[] ) {
int x = 10;

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 47

if (x > 5)
System.out.println( "x es mayor que 5" );
}
}

Ejercicio propuesto 5.1.1: Crea un programa que pida un nmero al usuario y

diga si es positivo (mayor que cero)

5.2. El caso contrario: else

Una primera mejora a la comprobacin de condiciones con "if" es indicar qu
hacer en caso de que no se cumpla la condicin. Sera algo parecido a
SI condicin
ENTONCES rdenes
EN_CASO_CONTRARIO rdenes_alternativas

que en Java escribiramos as:

if (condicin)

{ rdenes1 }

else

{ rdenes2 }

Por ejemplo,
// If3.java
// Comprobacin de condiciones con "if" 3: else
// Introduccin a Java, Nacho Cabanes
class If3 {
public static void main( String args[] ) {
int x = 10;
if (x > 5) {
System.out.println( "x es mayor que 5" );
}
else {
System.out.println( "x es menor o igual que 5" );
}
}
}

Ejercicio propuesto 5.2.1: Crea un programa que pida un nmero entero al

usuario y diga si es positivo (mayor que cero) o si, por el contrario, no lo es
(usando "else").

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 48

5.3. Operadores relacionales

La forma de comprobar si un dato es "mayor" que otro, que hemos usado en el
apartado anterior, debera resultar totalmente intuitiva. Pero tambin nos
interesar comprobar si un variable tiene exactamente un cierto valor, o si tiene
un valor distinto, o si es menor, o si es mayor o igual que otro...
Los operadores que utilizaremos para ello son:
Operacin

Smbolo

Mayor que

>

Mayor o igual que

>=

Menor que

<

Menor o igual que

<=

Igual que

== (dos smbolos de "igual")

Distinto de

!=

As, por ejemplo, para ver si el valor de una variable "b" es distinto de 5,
escribiramos:
// If4.java
// Comprobacin de condiciones con "if" 4: distinto de
// Introduccin a Java, Nacho Cabanes
class If4 {
public static void main( String args[] ) {
int x = 10;
if (x != 5) {
System.out.println( "x no vale 5" );
}
else {
System.out.println( "x vale 5" );
}
}
}

o para ver si la variable "a" vale 70, sera:

// If5.java
// Comprobacin de condiciones con "if" 5: igual a
// Introduccin a Java, Nacho Cabanes
class If5 {
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 49

public static void main( String args[] ) {

int x = 10;
if (x == 70) {
System.out.println( "x vale 70" );
}
else {
System.out.println( "x no vale 70" );
}
}
}

Es muy importante recordar esta diferencia: para asignar un valor a una variable
se emplea un nico signo de igual, mientras que para comparar si una variable es
igual a otra (o a un cierto valor) se emplean dos signos de igual.
Ejercicio propuesto 5.3.1: Crea un programa que pida al usuario que
introduzca el nmero 12. Despus debe decirle si lo ha hecho correctamente o
no.
Ejercicio propuesto 5.3.2: Crea un programa que pida un nmero entero al
usuario y diga si es positivo (mayor que cero), si es negativo (menor que cero)
o si, por el contrario, es exactamente 0 (necesitars enlazar 2 "if" uno tras
otro).
Ejercicio propuesto 5.3.3: Crea un programa que pida dos nmeros reales
(con decimales) al usuario y diga cul es el mayor de ellos.
Ejercicio propuesto 5.3.4: Crea un programa que pida al usuario y diga si ese
nmero es mltiplo de 3 (pista: puedes utilizar la operacin "mdulo", el "resto
de la divisin": %)
Ejercicio propuesto 5.3.5: Crea un programa que diga si el nmero
introducido por el usuario es impar o no lo es.

5.4. Operadores lgicos para enlazar condiciones

Podremos enlazar varias condiciones, para indicar qu hacer cuando se cumplan
ambas, o slo una de ellas, o cuando no se cumplan. Los operadores que nos
permitirn enlazar condiciones son:
Operacin Smbolo
Y

&&

||

No

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 50

Por ejemplo, la forma de decir "si a vale 3 y b es mayor que 5, o bien a vale 7 y b no
es menor que 4" sera:
// If6.java
// Comprobacin de condiciones con "if" 6: varias condiciones
// Introduccin a Java, Nacho Cabanes
class If6 {
public static void main( String args[] ) {
int a = 7;
int b = 1;
if ( ((a == 3) || ( b > 5))
|| ((a == 7) && ! (b < 4)) ) {
System.out.println( "Se cumple la condicin" );
}
else {
System.out.println( "No se cumple la condicin" );
}
}
}

Como se ve en el ejemplo anterior, la condicin general del "if" deber ir entre

parntesis, pero, por legibilidad y por evitar efectos colaterales de que alguna
condicin no se analice en el orden deseado, convendr que cada condicin
individual vaya tambin entre parntesis, y ser interesante aadir parntesis
adicionales para dejar claro cmo agruparlas.
Ejercicio propuesto 5.4.1: Crea un programa que pida al usuario dos nmeros
enteros y diga si los dos son positivos (el primero Y el segundo).
Ejercicio propuesto 5.4.2: Crea un programa que pida al usuario dos nmeros
enteros y diga si al menos uno de los dos es positivo

(el primero O el

segundo).
Ejercicio propuesto 5.4.3: Crea un programa que pida al usuario dos nmeros
enteros y cuntos de ellos son pares.
Ejercicio propuesto 5.3.5: Crea un programa que pida tres nmeros enteros
largos al usuario y diga cul es el mayor de los tres.

5.5. switch
Si queremos comprobar varios posibles valores para una misma variable,
podemos utilizar varios if - else - if - else - if encadenados, pero tenemos una
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 51

forma ms elegante de elegir entre distintos valores posibles que tome una cierta
expresin. Su formato es ste:
switch (expresion) {
case valor1: sentencias1; break;
case valor2: sentencias2; break;
case valor3: sentencias3; break;
// ... Puede haber ms valores
}

Es decir, despus de la orden switch indicamos entre parntesis la expresin que

queremos evaluar. Despus, tenemos distintos apartados, uno para cada valor
que queramos comprobar; cada uno de estos apartados se precede con la
palabra case, indica los pasos a dar si es ese valor el que tiene la variable (esta
serie de pasos no ser necesario indicarla entre llaves), y termina con break.
Un ejemplo sera:
// Switch1.java
// Comprobacin de condiciones con "switch" 1: ejemplo bsico
// Introduccin a Java, Nacho Cabanes
class Switch1 {
public static void main( String args[] ) {
int mes = 2;
switch(mes) {
case 1: System.out.println( "El mes es Enero" ); break;
case 2: System.out.println( "El mes es Febrero" ); break;
case 3: System.out.println( "El mes es Marzo" ); break;
}
}
}

Tambin podemos indicar qu queremos que ocurra en el caso de que el valor de

la expresin no sea ninguno de los que hemos detallado, usando la palabra
"default":
switch (expresion) {
case valor1: sentencias1; break;
case valor2: sentencias2; break;
case valor3: sentencias3; break;
// ... Puede haber ms valores
default: sentencias; // Opcional: valor por defecto
}

Por ejemplo, as:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 52

// Switch2.java
// Comprobacin de condiciones con "switch" 2: default
// Introduccin a Java, Nacho Cabanes
class Switch2 {
public static void main( String args[] ) {
int mes = 4;
switch(mes) {
case 1: System.out.println( "El mes
case 2: System.out.println( "El mes
case 3: System.out.println( "El mes
default: System.out.println( "No es
}

es Enero" ); break;
es Febrero" ); break;
es Marzo" ); break;
entre Enero y Marzo" ); break;

}
}

Podemos conseguir que se den los mismos pasos en varios casos, simplemente
eliminando la orden "break" de algunos de ellos. Un ejemplo podra ser:
// Switch3.java
// Comprobacin de condiciones con "switch" 3: casos en cascada
// Introduccin a Java, Nacho Cabanes
class Switch3 {
public static void main( String args[] ) {
int x = 5;
switch ( x ) {
case 1:
case 2:
case 3:
System.out.println(
break;
case 4:
case 5:
System.out.println(
break;
case 6:
System.out.println(
int valorTemporal =
System.out.println(
break;
default:
System.out.println(
break;
}

"El valor de x estaba entre 1 y 3" );

"El valor de x era 4 o 5" );

"El valor de x era 6" );

10;
"Operaciones auxiliares completadas" );

"El valor de x no estaba entre 1 y 6" );

}
}

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 53

A partir de Java 7, se puede usar la orden "switch" tambin para comprobar los
valores de cadenas de texto:
//
//
//
//

Switch4.java
Comprobacin de condiciones con "switch" 4: cadenas de texto
(Para Java 7 o superior)
Introduccin a Java, Nacho Cabanes

class Switch4 {
public static void main( String args[] ) {
String nombre = "yo";
switch(nombre) {
case "uno": System.out.println( "Hola, uno" ); break;
case "yo": System.out.println( "Hola, t" ); break;
case "otro": System.out.println( "Bienvenido, otro" ); break;
default: System.out.println( "Nombre desconocido" ); break;
}
}
}

Ejercicio propuesto 5.5.1: Crea un programa que pida al usuario el nmero

de un mes y escriba el nombre de ese mes. Por ejemplo, si el usuario
introduce 9, deber escribir "septiembre".
Ejercicio propuesto 5.5.2: Crea un programa que escriba como texto
cualquier nmero del 1 al 10 que introduzca el usuario. Por ejemplo, si el
usuario introduce 3, deber escribir "tres".

5.6. El operador condicional

Existe una construccin adicional, que permite comprobar si se cumple una
condicin y devolver un cierto valor segn si dicha condicin se cumple o no. Es lo
que se conoce como el "operador condicional (?)" u "operador ternario":
condicion ? resultado_si cierto : resultado_si_falso

Es decir, se indica la condicin seguida por una interrogacin, despus el valor que
hay que devolver si se cumple la condicin, a continuacin un smbolo de "dos
puntos" y finalmente el resultado que hay que devolver si no se cumple la
condicin.
Es frecuente emplearlo en asignaciones (aunque algunos autores desaconsejan su
uso porque puede resultar menos legible que un "if"), como en este ejemplo:
x = (a == 10) ? b*2 : a ;

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 54

En este caso, si "a" vale 10, la variable "x" tomar el valor de b*2, y en caso
contrario tomar el valor de a. Esto tambin se podra haber escrito de la siguiente
forma, ms larga pero ms legible:
if (a == 10)
x = b*2;
else
x = a;

Un ejemplo completo, que diera a la variable "par" el valor 1 si un nmero "n" es

par, o el valor 0 en caso contrario, sera:
// Condicional1.java
// Ejemplo de "operador condicional" (o ternario)
// Introduccin a Java, Nacho Cabanes
class Condicional1 {
public static void main( String args[] ) {
int n = 4;
int par;
par = n % 2 == 0 ?

1 : 0;

System.out.print( "\"par\" vale... " );

System.out.println( par );
}
}

Ejercicio propuesto 5.6.1: Crea un programa que pida un nmero entero al

usuario y d a una variable par el valor 1 si ese nmero es par o el valor 0 si no
es par. Hazlo primero con un "if" y luego con un "operador condicional".
Ejercicio propuesto 5.6.2: Crea un programa que pida dos nmeros de tipo
byte al usuario y cree a una variable "menor", que tenga el valor del menor de
esos dos nmeros. Hazlo primero con un "if" y luego con un "operador
condicional".

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 55

6. Bucles: partes del programa que se repiten

Con frecuencia tendremos que hacer que una parte de nuestro programa se
repita, bien sea mientras se cumpla una condicin o bien un cierto nmero
prefijado de veces. Es lo que llamaremos un "bucle".

6.1. while
La orden "while" hace que una parte del programa se repita mientras se cumpla
una cierta condicin. Su formato ser:
while (condicin)
sentencia;

Es decir, la sintaxis es similar a la de "if", con la diferencia de que aquella orden

realizaba la sentencia indicada una vez como mximo (si se cumpla la condicin),
pero "while" puede repetir la sentencia ms de una vez (mientras la condicin sea
cierta). Al igual que ocurra con "if", podemos realizar varias sentencias seguidas
(dar "ms de un paso") si las encerramos entre llaves:
// While1.java
// Comprobacin repetitiva de condiciones con "while"
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class While1 {
public static void main( String args[] ) {
Scanner teclado = new Scanner(System.in);
System.out.print("Introduce un cero: ");
int dato = teclado.nextInt();
while (dato != 0) {
System.out.print("No era cero. Introduce cero: ");
dato = teclado.nextInt();
}
System.out.println("Terminado!");
}
}

Estas estructuras repetitivas se pueden usar tambin para hacer "contadores". Por
ejemplo, un programa que contase del 1 al 5 (y escribiese todos esos nmeros)
podra ser:
// Contar1a5.java
// Contar del 1 al 5 con "while"
// Introduccin a Java, Nacho Cabanes

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 56

class Contar1a5 {
public static void main( String args[] ) {
int x = 1;
while (x <= 5) {
System.out.println( x );
x++;
}
}
}

Ejercicio propuesto 6.1.1: Crea un programa que muestre los nmeros del 1
al 10, usando "while"
Ejercicio propuesto 6.1.2: Crea un programa que muestre los nmeros pares
del 20 al 2, decreciendo, usando "while"
Ejercicio propuesto 6.1.3: Crea un programa que muestre la "tabla de
multiplicar del 5", usando "while"
Ejercicio propuesto 6.1.4: Crea un programa que pida al usuario un nmero
entero y muestre su cuadrado. Se repetir mientras el usuario introduzca un
nmero distinto de cero.
Ejercicio propuesto 6.1.5: Crea un programa que pida al usuario su login (un
nmero entero) y su contrasea (otro nmero entero). Se repetir mientras el
usuario introduzca un login distinto de "1809" o una contrasea distinta de
"1234".
Ejercicio propuesto 6.1.6: Crea un programa que pida al usuario su login (un
nmero entero) y su contrasea (otro nmero entero). Se repetir mientras el
usuario introduzca un login distinto de "1809" o una contrasea distinta de
"1234", hasta un mximo de tres veces. Tras tres fallos, se mostrar un
mensaje avisando al usuario de que se le deniega el acceso.
Ejercicio propuesto 6.1.7: Crea un programa que escriba en pantalla tantos
asteriscos como el usuario indique, todos ellos en la misma lnea.

6.2. do-while
Existe una variante de "while", que permite comprobar la condicin al final de la
parte repetitiva, en vez de hacerlo antes de comenzar. Es el conjunto do..while,
cuyo formato es:
do {
sentencia;
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 57

} while (condicin)

Con "while", si la condicin era falsa desde un principio, los pasos que se indicaban
a continuacin de "while" no llegaban a darse ni una sola vez; con do-while, las
"sentencias" intermedias se realizarn al menos una vez.
Un ejemplo tpico de esta construccin "do..while" es cuando queremos que el
usuario introduzca una contrasea que le permitir acceder a una cierta
informacin:
// DoWhile1.java
// Comprobacin repetitiva de condiciones con "do-while"
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class DoWhile1 {
public static void main( String args[] ) {
int password;
Scanner teclado = new Scanner(System.in);
do {
System.out.print( "Introduzca su password numrica: " );
password = teclado.nextInt();
if (password != 1234)
System.out.println( "No es vlida." );
}
while (password != 1234);
}
}

Por supuesto, tambin podemos crear un contador usando un do..while, siempre y

cuando tengamos en cuenta que la condicin se comprueba al final, lo que puede
hacer que la lgica sea un poco distinta en algunos casos:
// Contar1a5b.java
// Contador con "do-while"
// Introduccin a Java, Nacho Cabanes

import java.util.Scanner;

class Contar1a5b {

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 58

public static void main( String args[] ) {

int x = 1;

do {
System.out.println( x );
x++;
}
while (x <= 5);
}
}

Ejercicio propuesto 6.2.1: Crea un programa que muestre los nmeros del 1
al 10, usando "do-while"
Ejercicio propuesto 6.2.2: Crea un programa que muestre los nmeros pares
del 20 al 2, decreciendo, usando "do-while"
Ejercicio propuesto 6.2.3: Crea un programa que muestre la "tabla de
multiplicar del 5", usando "do-while"
Ejercicio propuesto 6.2.4: Crea un programa que pida al usuario dos nmeros
enteros y muestre su suma. Se repetir hasta que los dos sean 0. Emplea dowhile.
Ejercicio propuesto 6.2.5: Crea un programa que pida al usuario su login (un
nmero entero) y su contrasea (otro nmero entero). Se repetir hasta que el
usuario introduzca como login "1809" y como contrasea "1234". En esta
ocasin, hazlo con do-while.
Ejercicio propuesto 6.2.6: Crea un programa que pida un nmero de tipo byte
al usuario y escriba en pantalla un cuadrado formado por asteriscos, que
tendr como alto y ancho la cantidad introducida por el usuario.

6.3. for
Una tercera forma de conseguir que parte de nuestro programa se repita es
mediante la orden "for". La emplearemos sobre todo para conseguir un nmero
concreto de repeticiones. En lenguajes como BASIC su formato es muy simple:
"FOR x = 1 TO 10" ir recorriendo todos los valores de x, desde uno hasta 10. En
Java y otros lenguajes que derivan de C, su sintaxis es ms enrevesada:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 59

for ( valor_inicial ; condicion_continuacion ; incremento ) {

sentencias
}

Es decir, indicamos entre parntesis, y separadas por puntos y coma, tres

rdenes:

La primera orden dar el valor inicial a una variable que sirva de control.

La segunda orden ser la condicin que se debe cumplir mientras que se

repitan las sentencias.

La tercera orden ser la que se encargue de aumentar -o disminuir- el valor

de la variable, para que cada vez quede un paso menos por dar.

Esto se ver mejor con un ejemplo. Podramos repetir 10 veces un bloque de

rdenes haciendo:
// For1.java
// Repeticin con "for" 1: escribir 10 veces
// Introduccin a Java, Nacho Cabanes
class For1 {
public static void main( String args[] ) {
int i;
for ( i=1 ; i<=10 ; i++ ) {
System.out.print( "Hola " );
}
}
}

(inicialmente i vale 1, hay que repetir mientras sea menor o igual que 10, y en
cada paso hay que aumentar su valor una unidad),
De forma similar, podramos hacer un contador de 1 a 5, como los que hemos
creado con "while" y con "do-while":
// Contar1a5c.java
// Repeticin con "for" 2: contar de 1 a 5
// Introduccin a Java, Nacho Cabanes
class Contar1a5c {
public static void main( String args[] ) {
int x;
for ( x=1 ; x<=5 ; x++ ) {
System.out.println( x );
}
}
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 60

O bien podramos contar descendiendo desde el 10 hasta el 2, con saltos de 2

unidades en 2 unidades, as:
// Contar10a0.java
// Repeticin con "for" 3: descontar de 10 a 0, de 2 en 2
// Introduccin a Java, Nacho Cabanes
class Contar10a0 {
public static void main( String args[] ) {
int i;
for ( i=10 ; i>=0 ; i-=2 ) {
System.out.println( i );
}
}
}

Nota: se puede observar una equivalencia casi inmediata entre la orden "for" y la
orden "while". As, el ejemplo anterior se podra reescribir empleando "while", de
esta manera:
//
//
//
//

Contar10a0b.java
Repeticin con "while": descontar de 10 a 0, de 2 en 2
Programa equivalente a "For2.java"
Introduccin a Java, Nacho Cabanes

class Contar10a0b {
public static void main( String args[] ) {
int i;
i=10 ;
while ( i>=0 ) {
System.out.println( i );
i-=2;
}
}
}

No hay obligacin de declarar las variables justo al principio del programa. Es

frecuente hacerlo buscando legibilidad, pero tambin se pueden declarar en
puntos posteriores del fuente. Por eso, un sitio habitual para declarar la
variable que acta de contador de un "for" es dentro del propio "for", as:

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 61

// ForVariable.java
// Variable declarada dentro de un "for"
// Introduccin a Java, Nacho Cabanes
class ForVariable {
public static void main( String args[] ) {
for (int i=10 ; i>=0 ; i-=2 ) {
System.out.println( i );
}
}
}

Esto tiene la ventaja de que no podemos reutilizar por error esa variable "i"
despus de salir del "for", porque "se destruye" automticamente y obtendramos
un mensaje de error si tratamos de usarla. As evitamos efectos indeseados de que
cambios en una parte del programa afecten a otra parte del programa porque
estemos reusando una variable sin darnos cuenta.
Ejercicio propuesto 6.3.1: Crea un programa que muestre los nmeros del 1
al 15, usando "for"
Ejercicio propuesto 6.3.2: Crea un programa que muestre los nmeros pares
del 20 al 2, decreciendo, usando "for"
Ejercicio propuesto 6.3.3: Crea un programa que muestre la "tabla de
multiplicar del 5", usando "for"
Ejercicio propuesto 6.3.4: Crea un programa que muestre los nmeros
enteros del 0 al 100 que son mltiplos de 6 (el resto al dividir por 6 sea 0).
Ejercicio propuesto 6.3.5: Crea un programa que muestre los nmeros
enteros entre 0 y el que introduzca el usuario que sean mltiplos de 3 (el resto
al dividir por 3 es 0) y a la vez mltiplos de 7 (dem).
Ejercicio propuesto 6.3.6: Crea un programa que pida dos nmeros de tipo
byte al usuario y escriba en pantalla un rectngulo formado por asteriscos, que
tendr como alto el primer nmero y como ancho el segundo nmero.
Ejercicio propuesto 6.3.7: Crea un programa que pida un nmero de tipo byte
al usuario y escriba en pantalla un cuadrado hueco de ese ancho, que tendr
un borde formado por asteriscos y su interior sern espacios en blanco. Por
ejemplo, para un tamao de 4 sera:
****
* *
* *
****

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 62

Ejercicio propuesto 6.3.8: Crea un programa que pida al usuario un nmero

entero largo y muestre cules son sus divisores (aquellos entre los que se
puede dividir, obteniendo como resto 0).
Ejercicio propuesto 6.3.9: Crea un programa que pida al usuario un nmero
entero largo y diga si es primo (si slo es divisible entre 1 y l mismo).
Ejercicio propuesto 6.3.10: Crea un programa que pida al usuario dos
nmeros enteros largos y diga cuntos nmeros primos hay entre ellos
(ambos incluidos).

Precaucin con los bucles: Casi siempre, nos interesar que una parte de nuestro
programa se repita varias veces (o muchas veces), pero no indefinidamente. Si
planteamos mal la condicin de salida, nuestro programa se puede quedar
"colgado", repitiendo sin fin los mismos pasos (dentro de un "bucle sin fin").

6.4. break y continue

Se puede modificar un poco el comportamiento de estos bucles con las rdenes
"break" y "continue".
La sentencia "break" hace que se salten las instrucciones del bucle que quedan
por realizar, y se salga del bucle inmediatamente. Como ejemplo:
// Break1.java
// Ejemplo de uso de "break"
// Introduccin a Java, Nacho Cabanes
class Break1 {
public static void main( String args[] ) {
int i;
System.out.println( "Empezamos..." );
for ( i=1 ; i<=10 ; i++ ) {
System.out.println( "Comenzada la vuelta" );
System.out.println( i );
if (i==8)
break;
System.out.println( "Terminada esta vuelta" );
}
System.out.println( "Terminado" );
}
}

En este caso, no se mostrara el texto "Terminada esta vuelta" para la pasada con
i=8, ni se daran las pasadas de i=9 e i=10, porque ya se ha abandonado el bucle.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 63

La sentencia "continue" hace que se salten las instrucciones del bucle que quedan
por realizar, pero no se sale del bucle sino que se pasa a la siguiente iteracin (la
siguiente "vuelta" o "pasada"). Como ejemplo:
// Continue1.java
// Ejemplo de uso de "continue"
// Introduccin a Java, Nacho Cabanes
class Continue1 {
public static void main( String args[] ) {
int i;
System.out.println( "Empezamos..." );
for ( i=1 ; i<=10 ; i++ ) {
System.out.println( "Comenzada la vuelta" );
System.out.println( i );
if (i==8)
continue;
System.out.println( "Terminada esta vuelta" );
}
System.out.println( "Terminado" );
}
}

En este caso, no se mostrara el texto "Terminada esta vuelta" para la pasada con
i=8, pero s se daran la pasada de i=9 y la de i=10.
Ejercicio propuesto 6.4.1: Crea un programa que muestre los nmeros del 1
al 20, excepto el 15, usando "for" y "continue"
Ejercicio propuesto 6.4.2: Crea un programa que muestre los nmeros del 1
al 10, usando "for" que vaya del 1 al 20 y "break"

6.5. Etiquetas
Tambin existe la posibilidad de usar una "etiqueta" para indicar dnde se quiere
saltar con break o continue. Slo se debera utilizar cuando tengamos un bucle
que a su vez est dentro de otro bucle, y queramos salir de golpe de ambos. Es ese
caso (muy poco frecuente), deberemos crear una etiqueta justo antes de la orden
que queremos que se interrumpa, y luego usar "break" seguido del nombre de esa
etiqueta, as
// BreakEtiqueta.java
// Ejemplo de uso de "break" con etiqueta de salto
// Introduccin a Java, Nacho Cabanes

class BreakEtiqueta {
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 64

public static void main( String args[] ) {

int i;
bucleAInterrumpir:
for ( i=1 ; i<=10 ; i++ ) {
System.out.println( "Comenzada la vuelta" );
System.out.println( i );
if (i==8) break bucleAInterrumpir;
System.out.println( "Terminada esta vuelta" );
}
System.out.println( "Terminado" );
}
}

En este caso, a mitad de la pasada 8 se interrumpira el bloque que hemos

etiquetado como "bucleAInterrumpir" (una etiqueta se define como se ve en el
ejemplo, con su nombre terminado con el smbolo de "dos puntos").

Ejercicio propuesto 6.5.1: Crea un programa que muestre los nmeros del 1
al 10, usando "for" que vaya del 1 al 20 y un "break" con etiqueta.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 65

7. Booleanos, caracteres, cadenas de texto y arrays

Hemos visto cmo manejar datos numricos, tanto enteros como reales, y con
mayor o menor precisin, pero para muchos problemas reales necesitaremos
datos de otros tipos: textos, datos estructurados e incluso otros datos simples que
an no hemos tratado, como letras individuales y valores lgicos "verdadero" o
"falso".

7.1 Datos booleanos

Un dato "booleano" es uno que puede tener slo dos valores posibles: verdadero
(true) o falso (false), que son los dos valores existentes en la "lgica de Boole", de
la que toman su nombre.
Es habitual utilizarlos para hacer que las condiciones complicadas resulten ms
legibles. Un ejemplo de su uso podra ser:
// Booleano1.java
// Primer ejemplo de variables "bool"
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class Booleano1 {
public static void main( String args[] ) {
int dato;
boolean todoCorrecto;
Scanner teclado = new Scanner(System.in);
do
{
System.out.print("Introduce un dato del 0 al 10: ");
dato = teclado.nextInt();
todoCorrecto = true;
if (dato < 0)
todoCorrecto = false;
if (dato > 10)
todoCorrecto = false;
if ( ! todoCorrecto )
System.out.println("No es vlido!");
}
while ( ! todoCorrecto );
System.out.println("Terminado!");
}
}

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 66

No es necesario usar un "if" para darles valores, sino que se puede hacer
directamente asignndoles el valor de una condicin, as:
// Booleano2.java
// Segundo ejemplo de variables "bool"
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class Booleano2 {
public static void main( String args[] ) {
int dato;
boolean todoCorrecto;
Scanner teclado = new Scanner(System.in);
do
{
System.out.print("Introduce un dato del 0 al 10: ");
dato = teclado.nextInt();
todoCorrecto = (dato >= 0) && (dato <= 10);
if ( ! todoCorrecto )
System.out.println("No es vlido!");
}
while ( ! todoCorrecto );
System.out.println("Terminado!");
}
}
Ejercicio propuesto 7.1.1: Crea un programa que pida al usuario un nmero
entero y, si es par, d el valor "true" a una variable booleana llamada "esPar";
es caso contrario, le dar el valor "false".

7.2. Caracteres
El tipo de datos char lo usaremos para almacenar una letra del alfabeto, o un
dgito numrico, o un smbolo de puntuacin, o cualquier otro carcter. Ocupa 2
bytes. Sigue un estndar llamado Unicode (que a su vez engloba a otro estndar
anterior llamado ASCII). Sus valores se deben indicar entre comillas simples: char
inicial = 'n';
Por ejemplo, un programa que prefije dos datos de tipos "char" y los muestre sera
// Char1.java
// Segundo ejemplo de variables "bool"
// Introduccin a Java, Nacho Cabanes
class Char1 {
public static void main( String args[] ) {
char letra1, letra2;
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 67

letra1 = 'a';
letra2 = 'b';
System.out.print("La primera letra es : ");
System.out.println(letra1);
System.out.print("La segunda letra es : ");
System.out.println(letra2);
}
}

Java no permite usar un "Scanner" para leer desde teclado letra a letra, as que la
mayora de operaciones con letras las haremos dentro de poco, cuando sepamos
manejar cadenas de texto.

7.3. Las cadenas de texto

Una cadena de texto (en ingls, "string") es un conjunto de letras, que usaremos
para

poder

almacenar

palabras

frases.

Realmente

en

Java

hay dos

"variantes" de las cadenas de texto: existe un tipo de datos llamado "String" (con
la primera letra en maysculas, al contrario que los tipos de datos que habamos
visto hasta ahora) y otro tipo de datos llamado "StringBuilder". Un "String" ser
una cadena de caracteres constante, que no se podr modificar (podremos leer su
valor, extraer parte de l, etc.; pero para cualquier modificacin, deberemos volcar
los datos a una nueva cadena), mientras que un "StringBuilder" se podr
modificar "con ms facilidad" (podremos insertar letras, dar la vuelta a su
contenido, etc) a cambio de ser ligeramente menos eficiente (ms lento).
7.3.1. String
Las cadenas se declaran con la palabra "String" (cuidado: la primera letra debe
estar en maysculas) y su valor se asigna entre dobles comillas:
// String1.java
// Primer contacto con los String (cadenas de texto)
// Introduccin a Java, Nacho Cabanes
class String1 {
public static void main( String args[] ) {
String saludo = "Hola";
System.out.print( "El saludo es... " );
System.out.println( saludo );
}
}

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 68

Podemos "concatenar" cadenas (juntar dos cadenas para dar lugar a una nueva)
con el signo +, el mismo que usamos para sumar nmeros. Es frecuente utilizarlo
para escribir varias cosas en una misma frase:
// String2.java
// Primer contacto con los String: concatenacin
// Introduccin a Java, Nacho Cabanes
class String2 {
public static void main( String args[] ) {
String saludo = "Hola " + "t";
System.out.println( "El saludo es... " + saludo );
}
}

Para comprobar si una cadena de texto tiene un cierto valor o no, podemos
emplear los smbolos "==" y "!=", igual que con los nmeros:
// String3.java
// Tercer contacto con los String: comparacin
// Introduccin a Java, Nacho Cabanes
class String3 {
public static void main( String args[] ) {
String saludo = "Hola";
if (saludo == "Hola")
System.out.println( "El saludo es Hola" );
else
System.out.println( "El saludo no es Hola" );
}
}

Por otra parte, existe una serie de "operaciones con nombre" (tambin llamadas
"mtodos") que podemos aplicar a una cadena. Vamos a ver un ejemplo de
algunas de las ms frecuentes y luego detallaremos un poco:
// String4.java
// Ejemplo ms detallado de uso de String
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class String4 {
public static void main( String args[] ) {
// Forma "sencilla" de dar un valor
String texto1 = "Hola";
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 69

// Declarar y dar valor usando un "constructor"

String texto2 = new String("Prueba");
// Declarar sin dar valor
String resultado;
// Manipulaciones bsicas
System.out.print( "La primera cadena de texto es: " );
System.out.println( texto1 );
resultado = texto1 + texto2;
System.out.println( "Si concatenamos las dos: " +

resultado);

resultado = texto1 + 5 + " " + 23.5 + '.';

System.out.println( "Podemos concatenar varios: " + resultado);
System.out.println( "La longitud de la segunda es: "
+ texto2.length() );
System.out.println( "La segunda letra de texto2 es: "
+ texto2.charAt(1) );
// En general, las operaciones no modifican la cadena
texto2.toUpperCase();
System.out.println( "texto2 no ha cambiado a maysculas: " + texto2
);
resultado = texto2.toUpperCase();
System.out.println( "Ahora s: " + resultado );
// Podemos extraer fragmentos
resultado = texto2.substring(2,5);
System.out.println( "Tres letras desde la posicin 2: " + resultado
);
// Y podemos comparar cadenas
System.out.println( "Comparamos texto1 y texto2: "
+ texto1.compareTo(texto2) );
if (texto1.compareTo(texto2) < 0)
System.out.println( "Texto1 es menor que texto2" );
// Finalmente, pedimos su nombre completo al usuario
System.out.print( "Cmo te llamas? ");
Scanner teclado = new Scanner(System.in);
String nombre = teclado.nextLine();
System.out.println( "Hola, " + nombre);
// O podemos bien leer slo la primera palabra
System.out.print( "Teclea varias palabras y espacios... ");
String primeraPalabra = teclado.next();
System.out.println( "La primera es " + primeraPalabra);
}
}

Vamos a ver los detalles ms importantes:

String texto1 = "Hola"; es la forma normal de dar valor a una variable que
vaya a guardar cadenas de texto.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 70

String texto2 = new String("Prueba"); es una forma alternativa de dar el

valor inicial a una variable de tipo String. Parece una manera ms
rebuscada, pero es un tipo de construccin muy habitual en Java. Ms
adelante hablaremos de "clases" y veremos el motivo de escribir ese tipo de
rdenes.

String resultado; es la forma de crear una variable que guardar cadenas,

pero cuyo valor no se conoce an.

resultado = texto1 + texto2; Una cadena se puede crear "concatenando"

otras dos cadenas, como ya hemos visto.

resultado = texto1 + 5 + " " + 23.5 + '.'; Si uno de los datos es numrico, se
convertir a la expresin de cadena equivalente para poderlo concatenar.

texto2.length() devuelve un nmero, la cantidad de letras que hay en la

cadena de texto que se haya guardado dentro de la variable "texto2". Ser
muy habitual usar esa longitud para recorrer la cadena de texto letra a
letra.

texto2.charAt(1) permite obtener el carcter que se encuentra en una

cierta posicin, en este caso la segunda (porque la primera posicin es la
nmero cero).

texto2.toUpperCase(); crea una copia de una cadena de texto y la

convierte a maysculas, pero su valor se pierde si no se vuelca a otra
variable o se muestra directamente con una orden "print". La forma
correcta ser resultado = texto2.toUpperCase();

if (texto1.compareTo(texto2) > 0) permite ver si una cadena es "menor"

que otra, es decir, si aparecera antes en un diccionario. Si texto1 es
"menor" que texto2, se obtendra un valor negativo; por el contrario,
si texto1 es "mayor" que texto2, se obtendra un valor positivo.

String nombre = teclado.nextLine(); permite leer toda una frase desde

teclado usando un Scanner y guardarla en una cadena.

String primeraPalabra = teclado.next(); lee desde teclado pero slo hasta

encontrar un espacio en blanco (o el final de la lnea porque se pulse Intro,
lo que primero ocurra).

Una lista un poco ms detallada de los "mtodos" (operaciones con nombre) que
se pueden aplicar sobre una cadena podra ser::

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 71

Mtodo

Cometido

length()

Devuelve la longitud (nmero de caracteres) de la cadena

charAt (int pos)

Devuelve el carcter que hay en una cierta posicin

toLowerCase()

Devuelve la cadena convertida a minsculas

toUpperCase()

Devuelve la cadena convertida a maysculas

substring(int desde,

Devuelve una subcadena: varias letras a partir de una posicin

int cuantos)

dada

replace(char antiguo,
char nuevo)
trim()
startsWith(String
subcadena)
endsWith(String
subcadena)
indexOf(String
subcadena,
[int desde])

Devuelve una cadena conun carcter reemplazado por otro

Devuelve una cadena sin espacios de blanco iniciales ni finales
Indica si la cadena empieza con una cierta subcadena

Indica si la cadena termina con una cierta subcadena

Indica la posicin en que se encuentra una cierta subcadena

(buscando desde el principio, a partir de una posicin opcional)

lastIndexOf(String

Indica la posicin en que se encuentra una cierta subcadena

subcadena, [int desde])

(buscando desde el final, a partir de una posicin opcional)

valueOf( objeto )

concat(String cadena)

Devuelve un String que es la representacin como texto del

objeto que se le indique (nmero, boolean, etc.)
Devuelve la cadena con otra aadida a su final (concatenada)
Tambin se pueden concatenar cadenas con "+"

equals(String cadena)

Mira si las dos cadenas son iguales (lo mismo que "= =")

equals-IgnoreCase(

Comprueba si dos cadenas son iguales, pero despreciando

String cadena)

las diferencias entre maysculas y minsculas

compareTo(String

Compara una cadena con la otra (devuelve 0 si son iguales,

cadena2)

negativo si la cadena es "menor" que cadena2 y positivo

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 72

si es "mayor").

En ningn momento estamos modificando el String de partida. Eso s, en muchos

de los casos creamos un String modificado a partir del original.
El mtodo "compareTo" se basa en el orden lexicogrfico: una cadena que
empiece por "A" se considerar "menor" que otra que empiece por la letra "B"; si
la primera letra es igual en ambas cadenas, se pasa a comparar la segunda, y as
sucesivamente. Las maysculas y minsculas se consideran diferentes.
Ejercicio propuesto 7.3.1.1: Crea un programa que escriba un tringulo con
las letras de tu nombre, mostrando primero la primera letra, luego las dos
primeras y as sucesivamente, hasta llegar al nombre completo, como en este
ejemplo:
N
Na
Nac
Nach
Nacho
(Pista: tendrs que usar "substring" y un bucle "for")
Ejercicio propuesto 7.3.1.2: Crea un programa que pida su nombre al usuario
y lo escriba con un espacio entre cada par de letras. Por ejemplo, a partir de
"Nacho" escribira "N a c h o " (Pista: tendrs que usar "charAt" y un bucle "for")
Ejercicio propuesto 7.3.1.3: Crea un programa que pida su nombre al usuario
y lo escriba con al revs. Por ejemplo, a partir de "Nacho" escribira "ohcaN".
Ejercicio propuesto 7.3.1.4: Crea un programa que pida su nombre al usuario
y lo escriba con la primera letra en maysculas y el resto en minsculas. Por
ejemplo, a partir de "nAcho" escribir "Nacho".
Ejercicio propuesto 7.3.1.5: Crea un programa que pida su nombre al usuario
tantas veces como sea necesario, hasta que escriba "nacho" (o el nombre que
t prefijes en el programa). Deber permitir que ese nombre se introduzca
tanto en maysculas como en minsculas. Cuando introduzca el nombre
correcto, se le saludar y terminar el programa.

7.3.2. StringBuilder
Por su parte, los mtodos bsicos de un StringBuilder, que representa una
cadena de texto modificable, son:
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 73

Mtodo

Cometido

length()

Devuelve la longitud (nmero de caracteres) de la cadena

setLength()

Modifica la longitud de la cadena (la trunca si hace falta)

charAt (int pos)

Devuelve el carcter que hay en una cierta posicin

setCharAt(int pos, char

letra)

Cambia el carcter que hay en una cierta posicin

toString()

Devuelve el StringBuilder convertido en String

reverse()

Cambia el orden de los caracteres que forman la cadena

append( objeto )

Aade otra cadena, un nmero, etc. al final de la cadena

insert(int pos, objeto)

Aade otra cadena, un nmero, etc. en una cierta posicin

Un ejemplo de su uso sera:

// EjemploStringBuilder.java
// Aplicacin de ejemplo con StringBuilder
// Introduccin a Java, Nacho Cabanes
class EjemploStringBuilder {
public static void main( String args[] ) {
StringBuilder texto3 = new StringBuilder("Otra prueba");
texto3.append(" mas");
System.out.println( "Texto 3 es: " + texto3 );
texto3.insert(2, "1");
System.out.println( "Y ahora es: " + texto3 );
texto3.reverse();
System.out.println( "Y ahora: " + texto3 );
System.out.println( "En maysculas: " +
texto3.toString().toUpperCase() );
}
}

El resultado de este programa sera el siguiente:

Texto 3 es: Otra prueba mas
Y ahora es: Ot1ra prueba mas
Y ahora: sam abeurp ar1tO En mayculas: SAM ABEURP AR1TO

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 74

Ejercicio propuesto 7.3.2.1: Crea un programa que pida su nombre al usuario

y lo escriba con al revs, usando un StringBuilder. Por ejemplo, a partir de
"Nacho" escribira "ohcaN".
Ejercicio propuesto 7.3.2.2: Crea un programa que pida su nombre al usuario
y cambie la primera letra por una "A", excepto en el caso de que ya fuera una
"A", y entonces se convertira en una "B".
Ejercicio propuesto 7.3.2.3: Crea un programa que pida su nombre al usuario
y cree una nueva cadena de texto formada por "Don " seguido del nombre.
Hazlo de dos formas: primero concatenando dos cadenas y luego usando
"insert" en un StringBuilder.
Ejercicio propuesto 7.3.2.4: Crea un programa que pida su nombre al usuario
y convierta las letras impares a maysculas y las pares a minsculas. Por
ejemplo, a partir de la cadena "nAcho" se obtendra "NaChO".

7.4. Los arrays.

Imaginemos que tenemos que realizar clculos estadsticos con 10 nmeros que
introduzca el usuario. Parece evidente que tiene que haber una solucin ms
cmoda que definir 10 variables distintas y escribir 10 veces las instrucciones de
avisar al usuario, leer los datos que teclee, y almacenar esos datos. Si necesitamos
manejar 100, 1.000 o 10.000 datos, resulta todava ms claro que no es eficiente
utilizar una variable para cada uno de esos datos.
Por eso se emplean los arrays (que en ocasiones tambin se llaman "matrices" o
"vectores", por similitud con estas estructuras matemticas, y que algunos autores
traducen como "arreglos"). Un array es una variable que puede contener varios
datos del mismo tipo. Para acceder a cada uno de esos datos, indicaremos su
posicin entre corchetes. Por ejemplo, si definimos una variable llamada "m" que
contenga 10 nmeros enteros, accederemos al primero de estos nmeros como
m[0], el ltimo como m[9] y el quinto como m[4] (se empieza a numerar a desde 0
y se termina en n-1). Veamos un ejemplo que halla la media de cinco nmeros (con
decimales, "double"):
// Array1.java
// Aplicacin de ejemplo con Arrays
// Introduccin a Java, Nacho Cabanes
class Array1 {
public static void main( String args[] ) {
double[] a = { 10, 23.5, 15, 7, 8.9 };
double total = 0;
int i;
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 75

for (i=0; i<5; i++)

total += a[i];
System.out.println( "La media es:" );
System.out.println( total / 5 );
}
}

Para definir la variable podemos usar dos formatos: "double a[]" (que es la
sintaxis habitual en C y C++, no recomendada en Java) o bien "double[] a" (que es
la sintaxis recomendada en Java, y posiblemente es una forma ms "razonable" de
escribir "la variable a es un array de doubles").
Lo habitual no ser conocer los valores en el momento de teclear el programa,
como hemos hecho esta vez. Ser mucho ms frecuente que los datos los teclee el
usuario o bien que los leamos de algn fichero, los calculemos, etc. En este caso,
tendremos que reservar el espacio, y los valores los almacenaremos a medida que
vayamos conocindolos.
Para ello, primero declararamos que vamos a utilizar un array, as:
double[] datos;

y despus reservaramos espacio (por ejemplo, para 1.000 datos) con

datos = new double [1000];

Si conocemos el tamao desde el primer momento, estos dos pasos se pueden

dar en uno solo, as:
double[] datos = new double [1000];

y daramos los valores de una forma similar a la que hemos visto en el ejemplo
anterior:
datos[25] = 100 ; datos[0] = i*5 ; datos[j+1] = (j+5)*2;

Vamos a ver un ejemplo algo ms completo, con tres arrays de nmeros enteros,
llamados a, b y c. A uno de ellos (a) le daremos valores al definirlo, otro lo
definiremos en dos pasos (b) y le daremos fijos, y el otro lo definiremos en un paso
y le daremos valores calculados a partir de ciertas operaciones:
// Array2.java
// Aplicacin de ejemplo con Arrays
// Introduccin a Java, Nacho Cabanes
class Array2 {
public static void main( String args[] ) {
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 76

int i; // Para repetir con bucles "for"

// ------ Primer array de ejemplo, valores prefijados
int[] a = { 10, 12345, -15, 0, 7 };
System.out.print( "Los valores de a son: " );
for (i=0; i<5; i++)
System.out.print( a[i] + " " );
System.out.println( );
// ------ Segundo array de ejemplo, valores uno por uno
int[] b;
b = new int [3];
b[0] = 15; b[1] = 132; b[2] = -1;
System.out.print( "Los valores de b son: " );
for (i=0; i<3; i++)
System.out.print( b[i] + " " );
System.out.println( );
// ------ Tercer array de ejemplo, valores con "for"
int j = 4;
int[] c = new int[j];
for (i=0; i < j; i++)
c[i] = (i+1)*(i+1);
System.out.print( "Los valores de c son: " );
for (i=0; i < j; i++)
System.out.print( c[i] + " " );
System.out.println( );
}
}

Y si queremos que sea el usuario el que introduzca los valores y luego mostrar
esos valores, lo podramos conseguir de esta manera:
// Array3.java
// Leer de teclado y mostrar datos de un array
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class Array3 {
public static void main( String args[] ) {
Scanner teclado = new Scanner(System.in);
int[] datos = new int[5];
for (int i=0; i<5; i++)
{
System.out.print( "Deme el dato "+i+": " );
datos[i] = teclado.nextInt();
}
for (int i=4; i>=0; i--)
{
System.out.println( "El dato "+ i +" vale " + datos[i] );
}
}
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 77

Un programa no debera tener "nmeros mgicos" prefijados dentro del fuente,

como ese 5. Pueden no ser evidentes cuando se revise el programa ms adelante,
y pueden dar lugares a errores si tenemos ms adelante que modificarlos y no lo
hacemos en todos los sitios en los que aparezca. Por eso, ser preferible usar
"constantes" para esos nmeros que indican valores especiales como el tamao
del array y que no van a cambiar durante el funcionamiento del programa, as:
// Array4.java
// Leer y mostrar datos de un array, usando constantes
// Introduccin a Java, Nacho Cabanes
import java.util.Scanner;
class Array4 {
public static void main( String args[] ) {
Scanner teclado = new Scanner(System.in);
final int TAMANYO = 5;
int[] datos = new int[TAMANYO];
for (int i=0; i=0; i--)
{
System.out.println( "El dato "+ i +" vale " + datos[i] );
}
}
}

Como se ve en ese ejemplo, para indicar que un dato ser constante usaremos la
palabra

"final"

existe

el

convenio

de

usar

nombres

totalmente

en maysculas para las constantes.

Ejercicio propuesto 7.4.1: Crea un programa que pida al usuario 5 nmeros
reales, que guardar en un array. Luego calcular y mostrar su media (la
suma de todos los datos, dividida entre la cantidad de datos) y los valores que
estn por encima de la media.
Ejercicio propuesto 7.4.2: Crea un programa que pida al usuario 8 nmeros
enteros, los guarde en un array, halle y muestre el valor ms alto que contiene
(su mximo) y el valor ms bajo que contiene (su mnimo). Pista: puedes
empezar suponiendo que el primer valor es el mximo provisional; a partir de
ah, recorre todos los dems con un "for"; si alguno de los datos es mayor que
el mximo provisional, pasar a ser el nuevo mximo; el mnimo se calcular
de forma similar.
Ejercicio propuesto 7.4.3: Crea un programa que prepare un array que
contenga la cantidad de das que hay en cada mes del ao. A partir de
entonces el usuario introducir un nmero de mes (por ejemplo, 4 para abril) y
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 78

el programa le responder cuntos das tiene ese mes. Se repetir hasta que el
usuario introduzca un mes menor que 1 o mayor que 12.
Ejercicio propuesto 7.4.4: Crea un programa que prepare un array que
contenga el nombre de cada mes del ao. El usuario introducir un nmero de
mes (por ejemplo, 4 para abril) y el programa le dir el nombre de ese mes.
Ejercicio propuesto 7.4.5: Si has estudiado estadstica, crea un programa que
pida al usuario 10 nmeros reales de doble precisin, los guarde en un array y
luego muestre su media aritmtica, varianza y desviacin tpica.
Ejercicio propuesto 7.4.6: Crea un programa que pida al usuario 10 nmeros
enteros largos, los guarde en un array y despus pregunte qu nmero quiere
buscar y le contestar si ese nmero forma parte de los 10 iniciales o no.
Volver a preguntar qu nmero desea buscar, hasta que el usuario
introduzca "-1" para indicar que no quiere seguir buscando.
Ejercicio propuesto 7.4.7: Crea un programa que prepare un array de hasta
1000 nmeros enteros. El usuario podr elegir aadir un nuevo dato (tendrs
que llevar la cuenta la cantidad de datos que ya hay introducidos), buscar para
comprobar si aparece un cierto dato, o salir del programa.
Ejercicio propuesto 7.4.8: Si has estudiado lo que es un vector, crea un dos
arrays de tres elementos, cada uno de los cuales representar un vector de
tres dimensiones. Pide al usuario los datos para ambos vectores, luego
mustralos en la forma "(5, 7, -2)", despus calcula (y muestra) su producto
escalar y su producto vectorial.

Si no necesitamos una nica serie de datos sino varias, podemos usar un array
bidimensional. Por ejemplo, podramos crear un array con dos filas de dos
elementos cada una, as:
// ArrayBi.java
// Ejemplo de array bidimensional
// Introduccin a Java, Nacho Cabanes
class ArrayBi {
public static void main( String args[] ) {
int[][] datos
datos[0][0] =
datos[0][1] =
datos[1][0] =
datos[1][1] =

= new int[2][2];
5;
1;
-2;
3;

for (int i=0; i<2; i++)

for (int j=0; j<2; j++)
System.out.println( "El dato "+ i + "," + j +
" vale " + datos[i][j] );
}
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 79

}
Ejercicio propuesto 7.4.9: Si has estudiado lo que es una matriz, crea un array
de 3x3 elementos, pide al usuario los datos de esas 9 posiciones y luego
calcula el determinante de esa matriz bidimensional.
Ejercicio propuesto 7.4.10: Crea un programa que cree un array de 5x5
caracteres, lo rellene con puntos, excepto la segunda fila, que estar rellena de
letras "A" y luego muestra el contenido del array en pantalla. Deber aparecer
algo como:
.....
AAAAA
.....
.....
.....
Ejercicio propuesto 7.4.11: Crea un programa que cree un array de 5x5
caracteres, lo rellene con puntos en todas las posiciones excepto aquellas en
las que el nmero de fila es igual al nmero de columna, en las que pondr un
X. Luego muestra su contenido en pantalla, que deber ser algo como:
X....
.X...
..X..
...X.
....X

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 80

8. Las Matemticas y Java

Ya habamos visto las operaciones matemticas bsicas: suma, resta, divisin,
multiplicacin. Tambin alguna menos habitual, como el resto de una divisin.
Pero existen otras operaciones matemticas que son muy habituales: races
cuadradas, potencias, logaritmos, funciones trigonomtricas (seno, coseno,
tangente), generacin de nmeros al azar... Todas estas posibilidades estn
accesibles a travs de la clase java.lang.Math. Vamos a comentar alfabticamente
las ms importantes y luego veremos un ejemplo de su uso:
Funcin

Significado

abs()

Valor absoluto

acos()

Arcocoseno

asin()

Arcoseno

atan()

Arcotangente entre -PI/2 y PI/2

atan2( , )

Arcotangente entre -PI y PI

ceil()

Entero mayor ms cercano

cos(double)

Coseno

exp()

Exponencial

floor()

Entero menor ms cercano

log()

Logaritmo natural (base e)

max( , )

Mximo de dos valores

min( , )

Mnimo de dos valores

pow( , )

Primer nmero elevado al segundo

random()

Nmero aleatorio (al azar) entre 0.0 y 1.0

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 81

rint(double)

Entero ms prximo

round()

Entero ms cercano (redondeo de la forma

habitual)

sin(double)

sin(double)

sqrt()

Raz cuadrada

tan(double)

Tangente

toDegrees(double) Pasa de radianes a grados (a partir de Java 2)

toRadians()

Pasa de grados a radianes (a partir de Java 2)

Tambin hay disponibles dos constantes: PI (relacin entre el dimetro de una

circunferencia y su longitud) y E (base de los logaritmos naturales).
Las funciones trigonomtricas (seno, coseno, tangente, etc) miden en radianes, no
en grados, de modo que ms de una vez deberemos usar "toRadians" y
"toDegrees" si nos resulta ms cmodo pensar en grados.
Y un ejemplo, agrupando estas funciones por categoras, sera:

// Matem.java
// Ejemplo de matemticas desde Java
// Introduccin a Java, Nacho Cabanes
class Matem {
public static void main( String args[] ) {
System.out.print( "2+3 es ");
System.out.println( 2+3 );
System.out.print( "2*3 es ");
System.out.println( 2*3 );
System.out.print( "2-3 es ");
System.out.println( 2-3 );
System.out.print( "3/2 es ");
System.out.println( 3/2 );
System.out.print( "3,0/2 es ");
System.out.println( 3.0/2 );
System.out.print( "El resto de dividir 13 entre 4 es ");
System.out.println( 13%4 );
System.out.print( "Un nmero al azar entre 0 y 1: ");
System.out.println( Math.random() );
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 82

System.out.print( "Un nmero al azar entre 50 y 150: ");

System.out.println( (int)(Math.random()*100+50) );
System.out.print( "Una letra minscula al azar: ");
System.out.println( (char)(Math.random()*26+'a') );
System.out.print( "Coseno de PI radianes: ");
System.out.println( Math.cos(Math.PI) );
System.out.print( "Seno de 45 grados: ");
System.out.println( Math.sin(Math.toRadians(45)) );
System.out.print( "Arco cuya tangente es 1: ");
System.out.println( Math.toDegrees(Math.atan(1)) );
System.out.print( "Raz cuadrada de 36: ");
System.out.println( Math.sqrt(36) );
System.out.print( "Cinco elevado al cubo: ");
System.out.println( Math.pow(5.0,3.0) );
System.out.print( "Exponencial de 2: ");
System.out.println( Math.exp(2) );
System.out.print( "Logaritmo de 2,71828: ");
System.out.println( Math.log(2.71828) );
System.out.print( "Mayor valor entre 2 y 3: ");
System.out.println( Math.max(2,3) );
System.out.print( "Valor absoluto de -4,5: ");
System.out.println( Math.abs(-4.5) );
System.out.print( "Menor entero ms cercano a -4,5: ");
System.out.println( Math.floor(-4.5) );
System.out.print( "Mayor entero ms cercano a -4,5: ");
System.out.println( Math.ceil(-4.5) );
System.out.print( "Redondeando -4,5 con ROUND: ");
System.out.println( Math.round(-4.5) );
System.out.print( "Redondeando 4,5 con ROUND: ");
System.out.println( Math.round(4.5) );
System.out.print( "Redondeando -4,6 con RINT: ");
System.out.println( Math.rint(-4.6) );
System.out.print( "Redondeando -4,5 con RINT: ");
System.out.println( Math.rint(4.5) );
}
}

Su resultado es:
2+3 es 5
2*3 es 6
2-3 es -1
3/2 es 1
3,0/2 es 1.5
El resto de dividir 13 entre 4 es 1
Un nmero al azar entre 0 y 1: 0.9775498588615054
Un nmero al azar entre 50 y 150: 71
Una letra minscula al azar: u
Coseno de PI radianes: -1.0
Seno de 45 grados: 0.7071067811865475
Arco cuya tangente es 1: 45.0
Raz cuadrada de 36: 6.0
Cinco elevado al cubo: 125.0
Exponencial de 2: 7.38905609893065
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 83

Logaritmo de 2,71828: 0.999999327347282

Mayor valor entre 2 y 3: 3
Valor absoluto de -4,5: 4.5
Menor entero ms cercano a -4,5: -5.0
Mayor entero ms cercano a -4,5: -4.0
Redondeando -4,5 con ROUND: -4
Redondeando 4,5 con ROUND: 5
Redondeando -4,6 con RINT: -5.0
Redondeando -4,5 con RINT: 4.0
Ejercicio propuesto 8.1: Crea un programa que muestre en pantalla el
resultado de lanzar dos dados (dos nmeros del 1 al 6).
Ejercicio propuesto 8.2: Crea un programa que d al usuario la oportunidad
de adivinar un nmero del 1 al 100 en un mximo de 6 intentos. En cada
pasada deber avisar de si se ha pasado o se ha quedado corto. El nmero a
adivinar se debe generar al azar.
Ejercicio propuesto 8.3: Crea un programa que cree un array de 5x5
caracteres, lo rellene con puntos en todas las posiciones y luego escriba una O
en los puntos que cumplan y = x2. (Nota: puedes calcular el cuadrado usando
"pow" o simplemente con "x*x") Deber verse algo como:
..O..
.....
.....
.O...
O....

Ejercicio propuesto 8.4: Crea un programa que calcule y muestre el coseno

de los ngulos que van de 0 a 90 grados (ambos inclusive), de 5 en 5 grados.
Ejercicio propuesto 8.5: Crea un programa que pida al usuario un nmero
real "a" y un nmero entero "b". Deber calcular la raz de orden "b" del
nmero "a". Por ejemplo, si los nmeros son 3 y 4, tendrs que calcular (y
mostrar) la raz cuarta de 3. Deber repetirse hasta que el nmero "a" sea 0. Si
el nmeros "a" es negativo y "b" es par se deber mostrar un aviso "No se
puede calcular esa raz". (Pista: recuerda que para calcular la raz "b" del
nmero "a", basta con elevar "a" a "1/b".).

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 84

9. Contacto con las funciones.

9.1.Descomposicin modular
En ocasiones, nuestros programas contendrn operaciones repetitivas. Crear
funciones nos ayudar a que dichos programas sean ms fciles de crear y ms
robustos (con menos errores). Vamos a verlo con un ejemplo...
Imaginemos que queremos calcular la longitud de una circunferencia a partir de
su radio, y escribirla en pantalla con dos cifras decimales. No es difcil: por una
parte, la longitud de una circunferencia se calcula con 2 * PI * radio; por otra parte,
para conservar slo dos cifras decimales, lo podemos hacer de varias formas, una
de las cuales consiste en multiplicar por 100, quedarnos con la parte entera del
nmero y volver a dividir entre 100:
// FuncionesPrevio1.java
// Ejemplo previo 1 de la conveniencia de usar funciones
// para evitar cdigo repetitivo
import java.io.*;
class FuncionesPrevio1 {
public static void main( String args[] ) {
int radio = 4;
double longCircunf = 2 * 3.1415926535 * radio;
double longConDosDecimales =
Math.round(longCircunf * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio + " es " + longConDosDecimales);
}
}

Su resultado sera
La longitud de la circunferencia de radio 4 es 25.13

Si ahora queremos hacerlo para 5 circunferencias, podemos repetir esa misma

estructura varias veces:
// FuncionesPrevio2.java
// Ejemplo previo 2 de la conveniencia de usar funciones
// para evitar cdigo repetitivo
import java.io.*;
class FuncionesPrevio2 {
public static void main( String args[] ) {
int radio1 = 4;

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 85

double longCircunf1 = 2 * 3.1415926535 * radio1;

double longConDosDecimales1 =
Math.round(longCircunf1 * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio1 + " es " + longConDosDecimales1);
int radio2 = 6;
double longCircunf2 = 2 * 3.1415926535 * radio2;
double longConDosDecimales2 =
Math.round(longCircunf2 * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio2 + " es " + longConDosDecimales2);
int radio3 = 8;
double longCircunf3 = 2 * 3.1415926535 * radio3;
double longConDosDecimales3 =
Math.round(longCircunf3 * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio3 + " es " + longConDosDecimales3);
int radio4 = 10;
double longCircunf4 = 2 * 3.1415926535 * radio4;
double longConDosDecimales4 =
Math.round(longCircunf4 * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio4 + " es " + longConDosDecimales4);
int radio5 = 111;
double longCircunf5 = 2 * 3.1415926535 * radio5;
double longConDosDecimales5 =
Math.round(longCircunf5 * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio5 + " es " + longConDosDecimales5);
}
}

Pero un programa tan repetitivo es muy propenso a errores: tanto si escribimos

todo varias veces como si copiamos y pegamos, es fcil que nos equivoquemos en
alguna de las operaciones, usando el nombre de una variable que no es la que
debera ser. Por ejemplo, podra ocurrir que escribiramos "double longCircunf5 =
2 * 3.1415926535 * radio4;" (en el ltimo fragmento no aparece "radio5" sino
"radio4"). El programa se comportara de forma incorrecta, y este error podra ser
muy difcil de descubrir.
La alternativa es crear una "funcin": un bloque de programa que tiene un
nombre, que recibe ciertos datos, y que puede incluso devolvernos un resultado.
Por ejemplo, para el programa anterior, podramos crear una funcin llamada
"escribirLongCircunf" (escribir la longitud de la circunferencia), que recibira un
dato (el radio, que ser un nmero entero) y dar todos los pasos que daba
nuestro primer "main":
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 86

public static void escribirLongCircunf( int radio ) {

double longCircunf = 2 * 3.1415926535 * radio;
double longConDosDecimales =
Math.round(longCircunf * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio + " es " + longConDosDecimales);
}

Y desde "main" (el cuerpo del programa) usaramos esa funcin tantas veces como
quisiramos:
public static void main( String args[] ) {
escribirLongCircunf(4);
escribirLongCircunf(6);
...

De modo que el programa completo quedara:

// Funciones01.java
// Primer ejemplo de funciones
import java.io.*;
class Funciones01 {
public static void escribirLongCircunf( int radio ) {
double longCircunf = 2 * 3.1415926535 * radio;
double longConDosDecimales =
Math.round(longCircunf * 100) / 100.0;
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio + " es " + longConDosDecimales);
}
public static void main( String args[] ) {
escribirLongCircunf(4);
escribirLongCircunf(6);
escribirLongCircunf(8);
escribirLongCircunf(10);
escribirLongCircunf(111);
}
}

Por ahora, hasta que sepamos un poco ms, daremos por sentado que todas las
funciones tendrn que ser "public" y "static".
Ejercicio propuesto 9.1.1: Crea una funcin llamada "borrarPantalla", que
borre la pantalla dibujando 25 lneas en blanco. No debe devolver ningn
valor. Crea tambin un "main" que permita probarla.
Ejercicio propuesto 9.1.2: Crea una funcin llamada "dibujarCuadrado3x3",
que dibuje un cuadrado formato por 3 filas con 3 asteriscos cada una. Crea
tambin un "main" para comprobar que funciona correctamente.
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 87

9.2. Parmetros
Nuestra funcin "escribirLongCircunf" reciba un dato entre parntesis, el radio de
la circunferencia. Estos datos adicionales se llaman "parmetros", y pueden ser
varios, cada uno indicado con su tipo de datos y su nombre.
Ejercicio propuesto 9.2.1: Crea una funcin que dibuje en pantalla un
cuadrado del ancho (y alto) que se indique como parmetro. Completa el
programa con un "main" que permita probarla.
Ejercicio propuesto 9.2.2: Crea una funcin que dibuje en pantalla un
rectngulo del ancho y alto que se indiquen como parmetros. Completa el
programa con un "main" que permita probarla.

9.3. Valor de retorno

Las funciones "void", como nuestra "escribirLongCircunf" y como el propio cuerpo
del programa ("main") son funciones que dan una serie de pasos y no devuelven
ningn resultado. Este tipo de funciones se suelen llamar "procedimientos" o
"subrutinas".
public static void saludar( ) {
System.out.println( "Bienvenido");
System.out.println( "Comenzamos...");
}

Por el contrario, las funciones matemticas suelen dar una serie de pasos y
devolver un resultado, por lo que no sern "void", sino "int", "double" o del tipo
que corresponda al dato que devuelven. Por ejemplo, podramos calcular la
superficie de un crculo as:
public static double superfCirculo( int radio ) {
double superf = 3.1415926535 * radio * radio;
double superfConDosDecimales =
Math.round(superf * 100) / 100.0;
return superfConDosDecimales;
}

O descomponer la parte matemtica del ejemplo anterior (el clculo de la longitud

de la circunferencia) en una funcin independiente, as:
public static double longCircunf( int radio ) {
double longitud = 2 * 3.1415926535 * radio;
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 88

double longConDosDecimales =
Math.round(longitud * 100) / 100.0;
return longConDosDecimales;
}

Y un programa completo que usara todas esas funciones quedara:

// Funciones02.java
// Segundo ejemplo de funciones
import java.io.*;
class Funciones02 {
public static double longCircunf( int radio ) {
double longitud = 2 * 3.1415926535 * radio;
double longConDosDecimales =
Math.round(longitud * 100) / 100.0;
return longConDosDecimales;
}
public static double superfCirculo( int radio ) {
double superf = 3.1415926535 * radio * radio;
double superfConDosDecimales =
Math.round(superf * 100) / 100.0;
return superfConDosDecimales;
}
public static void saludar( ) {
System.out.println( "Bienvenido");
System.out.println( "Comenzamos...");
}
public static void escribirLongCircunf( int radio ) {
System.out.println( "La longitud de la circunferencia " +
"de radio " + radio + " es " + longCircunf( radio ));
}
public static void main( String args[] ) {
saludar();
escribirLongCircunf(4);
escribirLongCircunf(6);
escribirLongCircunf(8);
escribirLongCircunf(10);
escribirLongCircunf(111);
System.out.println( "La superficie del crculo " +
"de radio 5 es " + superfCirculo(5));
}
}

Volveremos ms adelante a las funciones, para formalizar un poco lo que hemos

aprendido, y tambin para ampliarlo, pero ya tenemos suficiente para empezar a
practicar.
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 89

Ejercicio propuesto 9.3.1: Crea una funcin que calcule el cubo de un nmero
real (float) que se indique como parmetro. El resultado deber ser otro
nmero real. Prubala para calcular el cubo de 3.2 y el de 5.
Ejercicio propuesto 9.3.2: Crea una funcin que calcule el menor de dos
nmeros enteros que recibir como parmetros. El resultado ser otro
nmero entero.
Ejercicio propuesto 9.3.3: Crea una funcin que devuelva la primera letra de
una cadena de texto. Prueba esta funcin para calcular la primera letra de la
frase "Hola".
Ejercicio propuesto 9.3.4: Crea una funcin que devuelva la ltima letra de
una cadena de texto. Prubala para calcular la ltima letra de la frase "Hola".
Ejercicio propuesto 9.3.5: Crea una funcin "esPrimo", que reciba un nmero
y devuelva el valor booleano "true" si es un nmero primo o "false" en caso
contrario.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 90

10. Clases en Java.

Cuando tenemos que realizar un proyecto grande, ser necesario descomponerlo
en varios subprogramas, de forma que podamos repartir el trabajo entre varias
personas (pero la descomposicin no debe ser arbitraria: por ejemplo, ser
deseable que cada bloque tenga unas responsabilidades claras).
La forma ms recomendable de descomponer un proyecto ser tratar de verlo
como una serie de "objetos" que colaboran entre ellos, cada uno de los cuales
tiene unas ciertas responsabilidades.
Como ejemplo, vamos a dedicar un momento a pensar qu elementos ("objetos")
hay en un juego como el clsico Space Invaders:

De la pantalla anterior, se puede observar que nosotros manejamos una "nave",

que se esconde detrs de "torres defensivas", y que nos atacan (nos disparan)
"enemigos". Adems, estos enemigos no se mueven de forma independiente, sino
como un "bloque". En concreto, hay cuatro "tipos" de enemigos, que no se
diferencian en su comportamiento, pero s en su imagen. Tambin, aunque no se
ve en la pantalla anterior, en ocasiones aparece un "OVNI" en la parte superior de
la pantalla, que nos permite obtener puntuacin extra. Tambin hay un
"marcador", que muestra la puntuacin y el record. Y antes y despus de cada

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 91

"partida", regresamos a una pantalla de "bienvenida", que muestra una animacin

que nos informa de cuntos puntos obtenemos al destruir cada tipo de enemigo.
Para disear cmo descomponer el programa, se suele usar la ayuda de
"diagramas de clases", que muestran de una manera visual qu objetos son los
que interaccionan para, entre todos ellos, formar nuestro proyecto. En el caso de
nuestro "Space Invaders", un diagrama de clases simplificado podra ser algo
como:

Algunos de los detalles que se pueden leer de ese diagrama son:

La clase principal de nuestro proyecto se llama "Juego" (el diagrama

tpicamente se leer de arriba a abajo).

El juego contiene una "Bienvenida" y una "Partida" (ese relacin de que un

objeto "contiene" a otros se indica mediante un rombo en el extremo de la
lnea que une ambas clases, junto a la clase "contenedora").

En una partida participan una "Nave", cuatro "Torres" defensivas, un

"BloqueDeEnemigos" formado por varios "Enemigos" (que, a su vez,

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 92

podran ser de tres tipos distintos, pero no afinaremos tanto por ahora) y
un "Ovni".

Tanto la "Nave" como las "Torres", los "Enemigos" y el "Ovni" son tipos
concretos de "Sprite" (esa relacin entre un objeto ms genrico y uno ms
especfico se indica con las puntas de flecha, que sealan al objeto ms
genrico).

Un "Sprite" es una figura grfica de las que aparecen en el juego. Cada

sprite tendr detalles (atributos) como una "imagen" y una posicin, dada
por sus coordenadas "x" e "y". Ser capaz de hacer operaciones (mtodos)
como "dibujarse" o "moverse" a una nueva posicin. Cuando se programa
toda esta estructura de clases, los atributos sern variables, mientras que
los "mtodos" sern funciones. Los subtipos de sprite "heredarn" las
caractersticas de esta clase. Por ejemplo, como un Sprite tiene una
coordenada X y una Y, tambin lo tendr el OVNI, que es una subclase de
Sprite.

El propio juego tambin tendr mtodos como "comprobarTeclas" (para ver

qu teclas ha pulsado el usuario), "moverElementos" (para actualizar el
movimiento de los elementos que deban moverse por ellos mismos),
"comprobarColisiones" (para ver si dos elementos chocan, como un disparo
y un enemigo, y actualizar el estado del juego segn corresponda), o
"dibujarElementos" (para mostrar en pantalla todos los elementos
actualizados).

En este punto, podramos empezar a repartir trabajo: una persona se podra

encargar de crear la pantalla de bienvenida, otra de la lgica del juego, otra del
movimiento de los enemigos, otra de las peculiaridades de cada tipo de enemigo,
otra del OVNI...
Nosotros no vamos a hacer proyectos tan grandes (al menos, no todava), pero s
empezaremos a crear proyectos sencillos en los que colaboren varias clases, que
permitan sentar las bases para proyectos ms complejos, y tambin entender
algunas peculiaridades de los temas que veremos a continuacin, como el manejo
de ficheros en Java.

10.2. Varias clases en Java

En Java podemos definir varias clases dentro de un mismo fichero, con la nica
condicin de que slo una de esas clases sea declarada como "pblica". En un caso

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 93

general, lo ms correcto ser definir cada clase en un fichero. Aun as, vamos a
ver primero un ejemplo que contenga dos clases en un solo fichero
//
//
//
//
//

DosClases.java
Primer ejemplo de una clase nuestra
que accede a otra tambin nuestra,
ambas definidas en el mismo fichero
Introduccin a Java, Nacho Cabanes

class Principal {
public static void main( String args[] ) {
Secundaria s = new Secundaria();
s.saluda(); // Saludo de "Secundaria"
saluda(); // Saludo de "Principal"
}
public static void saluda() {
System.out.println( "Saludando desde " );
}
}

// ---------------------------------------------------class Secundaria {
public void saluda() {
System.out.println( "Saludando desde " );
}
}

Como siempre, hay cosas que comentar:

En este fuente hay dos clases, una llamada "Principal" y otra llamada
"Secundaria".

La clase "Secundaria" slo tiene un mtodo, llamado "saluda", mientras

que la clase "Principal" tiene dos mtodos: "main" (el cuerpo de la
aplicacin) y otro llamado "saluda", al igual que el de "Secundaria".

Ambos mtodos "saluda" se limitan a mostrar un mensaje en pantalla, que

es distinto en cada caso.

En el mtodo "main", hacemos 3 cosas:

o

Primero definimos y creamos un objeto de la clase "Secundaria".

Esto lo podramos conseguir en dos pasos, definiendo primero el
objeto con "Secundaria s" y creando despus el objeto con "s = new
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 94

Secundaria()", o bien podemos hacer ambas cosas en un solo paso,

como ya habamos hecho con las variables sencillas.
o

Despus llamamos al mtodo "saluda" de dicho objeto, con la

expresin "s.saluda()"

Finalmente, llamamos al mtodo "saluda" de la propia clase

"Principal", escribiendo solamente "saluda()".

Para compilar este programa desde lnea de comandos, teclearamos, como

siempre:
javac DosClases.java

y entonces se crearan dos ficheros llamados

Principal.class
Secundaria.class

Podramos probar el resultado tecleando

java Principal

Y en pantalla se mostrara:
Saludando desde <Principal>
Saludando desde <Secundaria>

Si usamos Geany como editor, nos interesar que el propio programa se llame
Principal.java, igual que la que va a ser la clase que habr que ejecutar
posteriormente; de lo contrario, cuando pidamos lanzar el programa, se buscara
un fichero DosClases.class (porque nuestro fuente era DosClases.java), pero ese
fichero no existe...

Ahora vamos a ver un ejemplo en el que las dos clases estn en dos ficheros
distintos. Tendremos una clase "sumador" que sea capaz de sumar dos nmeros
(no es gran cosa, sabemos hacerlo sin necesidad de crear "clases a propsito",
pero nos servir como ejemplo) y tendremos tambin un programa principal que
la utilice.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 95

La clase "Sumador", con un nico mtodo "calcularSuma", que acepte dos

nmeros enteros y devuelva otro nmero entero, sera:
// Sumador.java
// Segundo ejemplo de una clase nuestra
//
que accede a otra tambin nuestra.
//
Esta es la clase auxiliar, llamada
//
desde "UsaSumador.java"
// Introduccin a Java, Nacho Cabanes
class Sumador {
public int calcularSuma( int a, int b ) {
return a+b;
}
}

Por otra parte, la clase "UsaSumador" empleara un objeto de la clase "Sumador",

llamado "suma", desde su mtodo "main", as:
// UsaSumador.java
// Segundo ejemplo de una clase nuestra
//

que accede a otra tambin nuestra.

//

Esta es la clase principal, que

//

accede a "Sumador.java"

// Introduccin a Java, Nacho Cabanes

class UsaSumador {

public static void main( String args[] ) {

Sumador suma = new Sumador();

System.out.println( "La suma de 30 y 55 es" );

System.out.println( suma.calcularSuma (30,55) );
}

Para compilar estos dos fuentes desde lnea de comandos, si tecleamos

directamente
javac usaSumador.java
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 96

recibiramos como respuesta un mensaje de error que nos dira que no existe la
clase Sumador:
UsaSumador.java:13: Class Sumador not found.
Sumador suma = new Sumador();
^
UsaSumador.java:13: Class Sumador not found.
Sumador suma = new Sumador();
^
2 errors

La forma correcta sera compilar primero "Sumador" y despus "UsaSumador",

para despus ya poder probar el resultado:
javac Sumador.java
javac UsaSumador.java
java UsaSumador

La respuesta, como es de esperar, sera:

La suma de 30 y 55 es
85

Si usamos como entorno NetBeans, tambin podemos crear programas

formados por varios fuentes. Los pasos seran los siguientes:

Crear un proyecto nuevo (men "Archivo", opcin "Proyecto nuevo")

Indicar que ese proyecto es una "Aplicacin Java".

Elegir un nombre para esa aplicacin (por ejemplo, "EjemploSumador"), y, si

queremos, una carpeta (se nos propondr la carpeta de proyectos de
NetBeans).

Aadir una segunda clase a nuestra aplicacin (men "Archivo", opcin

"Archivo Nuevo"). Escogeremos que ese archivo est dentro de nuestro
proyecto actual ("EjemploSumador") y que sea una "Clase Java". Despus se
nos preguntar el nombre que deseamos para la clase (por ejemplo
"Sumador").

Entonces completaremos el cdigo que corresponde a ambas clases,

preferiblemente empezando por las clases que son necesitadas por otras
(en nuestro caso, haramos "Sumador" antes que "EjemploSumador").

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 97

Finalmente, haremos clic en el botn de "Ejecutar" nuestro proyecto, para

comprobar el resultado.
Ejercicio propuesto 10.2.1: Crea una clase "LectorTeclado", para simplificar la
lectura de datos desde teclado. Esta clase tendr un mtodo "pedir", que
recibir como parmetro el texto de aviso que se debe mostrar al usuario, y
que devolver la cadena de texto introducida por el usuario. Crea tambin una
clase "PruebaTeclado", que use la anterior.

10.3. Herencia
Hemos comentado que unas clases podan "heredar" atributos y mtodos de otras
clases. Vamos a ver cmo se refleja eso en un programa. Crearemos un "escritor
de textos" y despus lo mejoraremos creando un segundo escritor que sea capaz
adems de "adornar" los textos poniendo asteriscos antes y despus de ellos.
Finalmente, crearemos un tipo de escritor que slo escriba en maysculas...
// Herencia.java
// Primer ejemplo de herencia entre clases,
//
todas definidas en el mismo fichero
// Introduccin a Java, Nacho Cabanes

class Escritor {
public static void escribe(String texto) {
System.out.println( texto );
}
}

class EscritorAmpliado extends Escritor {

public static void escribeConAsteriscos(String texto) {
escribe( "**" + texto + "**" );
}
}

class EscritorMayusculas extends Escritor {

public static void escribe(String texto) {
Escritor.escribe( texto.toUpperCase() );
}
}
// ---------------------------------------------------class Herencia {
public static void main( String args[] ) {
Escritor e = new Escritor();
EscritorAmpliado eAmp = new EscritorAmpliado();
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 98

EscritorMayusculas eMays = new EscritorMayusculas();

e.escribe("El primer escritor sabe escribir");
eAmp.escribe("El segundo escritor tambin");
eAmp.escribeConAsteriscos("y rodear con asteriscos");
eMays.escribe("El tercero slo escribe en maysculas");
}
}

Veamos qu hemos hecho:

Creamos una primera clase de objetos. La llamamos "Escritor" y slo sabe

hacer una cosa: escribir. Mostrar en pantalla el texto que le indiquemos,
usando su mtodo "escribe".

Despus creamos una clase que ampla las posibilidades de sta. Se llama
"EscritorAmpliado", y se basa (extends) en Escritor. Como "hereda" las
caractersticas de un Escritor, tambin "sabr escribir" usando el mtodo
"escribe", sin necesidad de que se lo volvamos a decir.

De hecho, tambin le hemos aadido una nueva posibilidad (la de "escribir

con asteriscos"), y al definirla podemos usar "escribe" sin ningn problema,
aprovechando que un EscritorAmpliado es un tipo de Escritor.

Despus creamos una tercera clase, que en vez de ampliar las posibilidades
de "Escritor" lo que hace es basarse (extends) en ella pero cambiando el
comportamiento (slo escribir en maysculas). En este caso, no aadimos
nada, sino que reescribimos el mtodo "escribe", para indicarle que debe
hacer cosas distintas (esto es lo que se conoce como polimorfismo: el
mismo nombre para dos elementos distintos -en este caso dos funciones-,
cuyos comportamientos no son iguales). Para rizar el rizo, en el nuevo
mtodo "escribe" no usamos el tpico "System.out.println" (lo podamos
haber hecho perfectamente), sino que nos apoyamos en el mtodo
"escribe" que acabbamos de definir para la clase "Escritor".

Finalmente, en "main", creamos un objeto de cada clase (usando la palabra

"new" y los probamos.

El resultado de este programa es el siguiente:

El primer escritor sabe escribir
El segundo escritor tambin
**y rodear con asteriscos**
EL TERCERO SLO ESCRIBE EN MAYSCULAS

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 99

Ejercicio

propuesto

10.3.1: Crea

una

nueva

clase

"EscritorMayusculasEspaciado" que se apoye en "EscritorMayusculas", pero

reemplace cada espacio en blanco por tres espacios antes de escribir en
pantalla.

10.4. Ocultacin de detalles

En general, ser deseable que los detalles internos (los "atributos", las variables)
de una clase no sean accesibles desde el exterior. En vez de hacerlos pblicos,
usaremos "mtodos" (funciones) para acceder a su valor y para cambiarlo.
Esta forma de trabajar tiene como ventaja que podremos cambiar los detalles
internos de nuestra clase (para hacerla ms rpida o que ocupe menos memoria,
por ejemplo) sin que afecte a los usuarios de nuestra clase, que la seguirn
manejando "como siempre", porque su parte visible sigue siendo la misma.
De hecho, podremos distinguir tres niveles de visibilidad:

Pblico (public), para mtodos o atributos que debern ser visibles. En

general, las funciones que se deban poder utilizar desde otras clases sern
visible, mientras que procuraremos que los estn ocultos.

Privado (private), para lo que no deba ser accesible desde otras clases,
como los atributos o algunas funciones auxiliares.

Protegido (protected), que es un caso intermedio: si declaramos un

atributo como privado, no ser accesible desde otras clases, ni siquiera las
que heredan de la clase actual. Pero generalmente ser preferible que las
clases "hijas" de la actual s puedan acceder a los atributos que estn
heredando de ella. Por eso, es habitual declarar los atributos como
"protected", que equivale a decir "ser privado para todas las dems clases,
excepto para las que hereden de m".

Un ejemplo sera
//
//
//
//
//

Getters.java
Segundo ejemplo de herencia entre clases,
todas definidas en el mismo fichero
Incluye getters y setters
Introduccin a Java, Nacho Cabanes

class Escritor {
public static void escribe(String texto) {
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 100

System.out.println( texto );
}
}

class EscritorMargen extends Escritor {

static byte margen = 0;
public static void escribe(String texto) {
for (int i=0; i < margen; i++)
System.out.print(" ");
System.out.println( texto );
}
public static int getMargen() {
return margen;
}
public static void setMargen(int nuevoMargen) {
margen = (byte) nuevoMargen;
}
}

// ---------------------------------------------------class Getters {
public static void main( String args[] ) {
Escritor e = new Escritor();
EscritorMargen e2 = new EscritorMargen();
e.escribe("El primer escritor sabe escribir");
e2.setMargen( 5 );
e2.escribe("El segundo escritor tambin, con margen");
}
}
Ejercicio propuesto 10.4.1: Crea una nueva clase "EscritorDosMargenes" que
se base en "EscritorMargen", aadindole un margen derecho. Si el texto
supera el margen derecho (suponiendo 80 columnas de anchura de pantalla),
deber continuar en la lnea siguiente.

10.5. Sin "static"

Hasta ahora, siempre hemos incluido la palabra "static" antes de cada funcin, e
incluso de los atributos. Realmente, esto no es necesario. Ahora que ya sabemos
lo que son las clases y cmo se definen los objetos que pertenecen a una cierta
clase, podemos afinar un poco ms:
La palabra "static" se usa para indicar que un mtodo o un atributo es igual para
todos los objetos de una clase. Pero esto es algo que casi no ocurre en "el mundo
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 101

real". Por ejemplo, podramos suponer que el atributo "cantidadDeRuedas" de una

clase "coche" podra ser "static", y tener el valor 4 para todos los coches... pero en
el mundo real existe algn coche de 3 ruedas, as como limusinas con ms de 4
ruedas. Por eso, habamos usado "static" cuando todava no sabamos nada sobre
clases, pero prcticamente ya no lo volveremos a usar a partir de ahora, que
crearemos objetos usando la palabra "new".
Podemos reescribir el ejemplo anterior sin usar "static", as
//
//
//
//
//
//

Getters2.java
Segundo ejemplo de herencia entre clases,
todas definidas en el mismo fichero
Incluye getters y setters
Versin sin "static"
Introduccin a Java, Nacho Cabanes

class Escritor {
public void escribe(String texto) {
System.out.println( texto );
}
}

class EscritorMargen extends Escritor {

byte margen = 0;
public void escribe(String texto) {
for (int i=0; i < margen; i++)
System.out.print(" ");
System.out.println( texto );
}
public int getMargen() {
return margen;
}
public void setMargen(int nuevoMargen) {
margen = (byte) nuevoMargen;
}
}

// ---------------------------------------------------class Getters2 {
public static void main( String args[] ) {
Escritor e = new Escritor();
EscritorMargen e2 = new EscritorMargen();
e.escribe("El primer escritor sabe escribir");
e2.setMargen( 5 );
e2.escribe("El segundo escritor tambin, con margen");
}
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 102

Ejercicio propuesto 10.5.1: Crea una versin del ejercicio 10.4.1, que no
utilice "static".

10.6. Constructores
Nos puede interesar dar valores iniciales a los atributos de una clase. Una forma
de hacerlo es crear un mtodo (una funcin) llamado "Inicializar", que sea llamado
cada vez que creamos un objeto de esa clase. Pero esto es algo tan habitual que ya
est previsto en la mayora de lenguajes de programacin actuales: podremos
crear "constructores", que se lanzarn automticamente al crear el objeto. La
forma de definirlos es con una funcin que se llamar igual que la clase, que no
tendr ningn tipo devuelto (ni siquiera "void") y que puede recibir parmetros. De
hecho, podemos incluso crear varios constructores alternativos, con distinto
nmero o tipo de parmetros:
// Constructores.java
// Ejemplo de clases con constructores
// Introduccin a Java, Nacho Cabanes
class Escritor {
protected String texto;
public Escritor(String nuevoTexto) {
texto = nuevoTexto;
}
public Escritor() {
texto = "";
}
public String getTexto() {
return texto;
}
public void setTexto(String nuevoTexto) {
texto = nuevoTexto;
}
public void escribe() {
System.out.println( texto );
}
}

class EscritorMargen extends Escritor {

byte margen = 0;

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 103

public EscritorMargen(String nuevoTexto) {

texto = nuevoTexto;
}
public void escribe() {
for (int i=0; i < margen; i++)
System.out.print(" ");
System.out.println( texto );
}
public int getMargen() {
return margen;
}
public void setMargen(int nuevoMargen) {
margen = (byte) nuevoMargen;
}
}

// ---------------------------------------------------class Constructores {
public static void main( String args[] ) {
Escritor e = new Escritor("Primer escritor");
EscritorMargen e2 =
new EscritorMargen("Segundo escritor");
e.escribe();
e2.setMargen( 5 );
e2.escribe();
}
}

Tambin existen los "destructores", que se llamaran cuando un objeto deja de

ser utilizado, y se podran aprovechar para cerrar ficheros, liberar memoria que
hubiramos reservado nosotros de forma manual, etc., pero su uso es poco
habitual para un principiante, y menos an en un lenguaje moderno como Java,
que incluye un "recolector de basura" automtico para liberar las zonas de
memoria que ya no se usan, as que no los veremos por ahora.
Ejercicio

propuesto

10.6.1: Crea

una

nueva

versin

de

la

clase

"EscritorDosMargenes" que use un constructor para indicarle el texto, el

margen izquierdo y el margen derecho.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 104

11. Ficheros
11.1. Por qu usar ficheros?
Con frecuencia tendremos que guardar los datos de nuestro programa para
poderlos recuperar ms adelante. Hay varias formas de hacerlo. Una de ellas son
los ficheros, que son relativamente sencillos. Otra forma ms eficiente cuando es
un volumen de datos muy elevado es usar una base de datos, que veremos ms
adelante.

11.2. Escribir en un fichero de texto

Un primer tipo de ficheros, que resulta sencillo de manejar, son los ficheros de
texto. Son ficheros que podremos crear desde un programa en Java y leer con
cualquier editor de textos, o bien crear con un editor de textos y leer desde un
programa en Java, o bien usar un programa tanto para leer como para escribir.
Para manipular ficheros, siempre tendremos que dar tres pasos:

Abrir el fichero

Guardar datos o leer datos

Cerrar el fichero

Hay que recordar siempre esos tres pasos: si no guardamos o leemos datos, no
hemos hecho nada til; si no abrimos fichero, obtendremos un mensaje de error
al intentar acceder a su contenido; si no cerramos el fichero (un error frecuente),
puede que realmente no se llegue a guardar ningn dato, porque no se vace el
"buffer" (la memoria intermedia en que se quedan los datos preparados hasta el
momento de volcarlos a disco).
En el caso de un fichero de texto, no escribiremos con "println", como hacamos en
pantalla, sino con "write". Cuando queramos avanzar a la lnea siguiente,
deberemos usar "newLine()":
ficheroSalida.write("Hola");
ficheroSalida.newLine();

Por otra parte, para cerrar el fichero (lo ms fcil, pero lo que ms se suele
olvidar), usaremos "close", mientras que para abrir usaremos un BufferedWriter,
que se apoya en un FileWriter, que a su vez usa un "File" al que se le indica el
nombre del fichero. Es menos complicado de lo que parece: ###
// FicheroTextoEscribir.java
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 105

// Ejemplo de escritura en un fichero de texto

// Introduccin a Java, Nacho Cabanes
import java.io.*;
class FicheroTextoEscribir
{
public static void main( String[] args )
{
System.out.println("Volcando a fichero de texto...");
try
{
BufferedWriter ficheroSalida = new BufferedWriter(
new FileWriter(new File("fichero.txt")));
ficheroSalida.write("Hola");
ficheroSalida.newLine();
ficheroSalida.write("Este es");
ficheroSalida.write(" un fichero de texto");
ficheroSalida.newLine();
ficheroSalida.close();
}
catch (IOException errorDeFichero)
{
System.out.println(
"Ha habido problemas: " +
errorDeFichero.getMessage() );
}
}
}

Como se ve en este ejemplo, todo el bloque que accede al fichero deber estar
encerrado tambin en un bloque try-catch, para interceptar errores.

Ejercicio propuesto 11.2.1: Crea un programa que pida al usuario que

introduzca frases, y guarde todas ellas en un fichero de texto. Deber terminar
cuando el usuario introduzca "fin".

11.3. Leer de un fichero de texto

Para leer de un fichero de texto usaremos "readLine()", que nos devuelve una
cadena de texto (un "string"). Si ese string es null, quiere decir que se ha acabado
el fichero y no se ha podido leer nada. Por eso, lo habitual es usar un "while" para
leer todo el contenido de un fichero.
Existe otra diferencia con la escritura, claro: no usaremos un BufferedWriter, sino
un BufferedReader, que se apoyar en un FileReader:
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 106

// FicheroTextoLeer.java
// Ejemplo de lectura desde un fichero de texto
// Introduccin a Java, Nacho Cabanes
import java.io.*;
class FicheroTextoLeer
{
public
{
//
//
//

static void main( String[] args )

Volcar a un fichero las lneas de otro (de texto)
que empiecen por "A"
Errores: slo se comprueba si no existe el de origen

if (! (new File("fichero.txt")).exists() )
{
System.out.println("No he encontrado fichero.txt");
return;
}
System.out.println("Leyendo fichero de texto...");
try
{
BufferedReader ficheroEntrada = new BufferedReader(
new FileReader(new File("fichero.txt")));
String linea=null;
while ((linea=ficheroEntrada.readLine()) != null) {
System.out.println(linea);
}
ficheroEntrada.close();
}
catch (IOException errorDeFichero)
{
System.out.println(
"Ha habido problemas: " +
errorDeFichero.getMessage() );
}
}
}

Ejercicio propuesto 11.3.1: Crea un programa que muestre el contenido de

un fichero de texto, cuyo nombre deber introducir el usuario. Debe avisar si
el fichero no existe.
Ejercicio propuesto 11.3.2: Crea un programa que lea el contenido de un
fichero de texto y lo vuelque a otro fichero de texto, pero convirtiendo cada
lnea a maysculas.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 107

Ejercicio propuesto 11.3.3: Crea un programa que pida al usuario el nombre

de un fichero y una palabra a buscar en l. Debe mostrar en pantalla todas las
lneas del fichero que contengan esa palabra.

11.4. Leer de un fichero binario

Un fichero "binario" es un fichero que contiene "cualquier cosa", no slo texto.
Podemos leer byte a byte con "read()". Si el dato lo leemos como "int", un valor de
"-1" indicar que se ha acabado el fichero.
En este caso, el tipo de fichero que usaremos ser un "FileInputStream":
// FicheroBinarioLeer.java
// Ejemplo de lectura desde un fichero de texto
// Introduccin a Java, Nacho Cabanes
import java.io.*;
class FicheroBinarioLeer
{
public static void main( String[] args )
{
// Cantidad de "a" en un fichero de cualquier tipo
// Mirando errores solo con try-catch
System.out.println("Contando \"a\"...");
int contador = 0;
try
{
FileInputStream ficheroEntrada2 =
new FileInputStream(new File("fichero.bin"));
int dato;
while ((dato = ficheroEntrada2.read()) != -1) {
if (dato == 97) // Codigo ASCII de "a"
contador++;
}
ficheroEntrada2.close();
}
catch (Exception errorDeFichero)
{
System.out.println(
"Ha habido problemas: " +
errorDeFichero.getMessage() );
}
System.out.println("Cantidad de \"a\": " + contador);
}
}

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 108

Este ejemplo cuenta la cantidad de letras "a" que contiene un fichero de cualquier
tipo, ya sea de texto, ejecutable, documento creado con un procesador de textos o
cualquier otro fichero.
Ejercicio propuesto 11.4.1: Crea un programa que lea el contenido de un
fichero binario, mostrando en pantalla todo lo que sean caracteres
imprimibles (basta con que sean desde la A hasta la Z, junto con el espacio en
blanco).
Ejercicio propuesto 11.4.2: Crea un programa que extraiga el contenido de un
fichero binario, volcando a un fichero de texto todo lo que sean caracteres
imprimibles (basta con que sean desde la A hasta la Z, junto con el espacio en
blanco).

11.5. Leer y escribir bloques en un fichero binario

Si tenemos que leer muchos datos de un fichero de cualquier tipo, acceder byte a
byte puede resultar muy lento. Una alternativa mucho ms eficiente es usar un
array de bytes. Podemos usar "read", pero indicndole en qu array queremos
guardar los datos, desde qu posicin del array (que casi siempre ser la cero) y
qu cantidad de datos:
Si no conseguimos leer tantos datos como hemos intentado, ser porque hemos
llegado al final del fichero. Por eso, un programa que duplicara ficheros, leyendo
cada vez un bloque de 512 Kb podra ser:
// FicheroBinarioEscribir.java
// Ejemplo de escritura en un fichero binario
// Introduccin a Java, Nacho Cabanes
import java.io.*;
class FicheroBinarioEscribir
{
public
{
//
//
//

static void main( String[] args )

---------------Copiar todo un fichero, con bloques de 512 Kb
Sin ninguna comprobacin de errores

System.out.println("Copiando fichero binario...");

final int BUFFER_SIZE = 512*1024;
try
{
InputStream ficheroEntrada3 = new FileInputStream(
new File("fichero.in"));
OutputStream ficheroSalida3 = new FileOutputStream(
new File("fichero2.out"));
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 109

byte[] buf = new byte[BUFFER_SIZE];

int cantidadLeida;
while ((cantidadLeida = ficheroEntrada3.read(buf, 0,
BUFFER_SIZE)) > 0)
{
ficheroSalida3.write(buf, 0, cantidadLeida);
}
ficheroEntrada3.close();
ficheroSalida3.close();
}
catch (Exception errorDeFichero)
{
System.out.println(
"Ha habido problemas: " +
errorDeFichero.getMessage() );
}
System.out.println("Terminado!");
}
}

Ejercicio propuesto 11.5.1: Crea un programa que lea los primeros 54 bytes
de un fichero BMP (su cabecera) y compruebe si los dos primeros bytes de
esos 54 corresponden a las letras B y M. Si no es as, mostrar el mensaje "No
es un BMP vlido"; si lo son, escribir el mensaje "Parece un BMP vlido"
Ejercicio propuesto 11.5.2: Crea una versin del ejercicio 11.4.2, leyendo a un
array: un programa que extraiga el contenido de un fichero binario, volcando a
un fichero de texto todo lo que sean caracteres imprimibles (basta con que
sean desde la A hasta la Z, junto con el espacio en blanco).

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 110

Cambios en el curso

0.01, de 21 de julio de 2006: Tema 1, de introduccin.

0.02, de 26 de julio de 2006: Tema 2, instalacin del JDK

0.03, de 29 de julio de 2006: Tema 3a, creando y compilado una primera

aplicacin

0.04, de 30 de julio de 2006: Tema 3.2

0.05, de 2 de agosto de 2006: Tema 4

0.06, de 4 de agosto: Tema 5

0.07, de 5 agosto: Tema 6

0.08, de 7 de agosto: Tema 7 (arrays y cadenas de texto)

0.09, de 10 de agosto de 2006: Tema 8 (funciones)

0.10, de 16 de agosto de 2006: Tema 9 (programacin modular)

0.11, de 25 de agosto de 2006: Tema 10 (ms sobre clases)

0.12, de 9 de octubre de 2006: Tema 11, sobre matemticas.

0.13, de 21 de octubre de 2006: Tema 12, toma de contacto con los Applets.

0.14, de 28 de abril de 2011: Revisin de los temas 1 a 4. Ampliacin del

tema 2 y el tema 3, para hablar de NetBeans como entorno de desarrollo.

0.15, de 3 de mayo de 2011: Revisin del tema 5. Actualizacin del tema 2 y

el tema 3, para hablar de Eclipse y de Geany.

0.16, de 4 de mayo de 2011: Aadido el tema 7b: introduccin de datos

mediante consola. Revisin del tema 8.

0.17, de 5 de mayo de 2011: Aadido el tema 7c: introduccin de datos

mediante ventanas. Aadido el tema 7d: ejercicios propuestos de repaso
(16). Revisin del tema 11.

0.18, de 16 de mayo de 2011: Creado el tema 13. Ampliado el tema 12.

0.19, de 26 de junio de 2011: Revisin del tema 9, para incluir los detalles de
cmo crear un proyecto de varios fuentes con NetBeans y para aadir un
ejercicio propuesto. Ligera revisin del tema 10, que tambin incluye un
ejercicio propuesto.
Introduccin a Java 0.40, por Nacho Cabanes - Pgina 111

0.20, de 29 de junio de 2013: Revisados los temas 1, 2, 3

0.21, de 30 de junio de 2013: Revisados los temas 4, 5, 6

0.22, de 01 de julio de 2013: Revisados los temas 7,8

0.23, de 06 de julio de 2013: Revisado el tema 9

0.24, de 10 de julio de 2013: Revisado y parcialmente reescrito el tema 10

0.25, de 21 de julio de 2013: Revisado el tema 12

0.26, de 15 de agosto de 2013: Revisado el tema 14

0.26p, de 08 de noviembre de 2013: Creada una versin PDF con todo el

contenido hasta la fecha.

0.27, de 20 de enero de 2015: Corregido el tema 6: el ejemplo del formato

de "break" con etiqueta era incorrecto.

0.28, de 21 de enero de 2015: Ampliado el tema 4: Incluido un ejemplo de

cmo sumar datos prefijados sin necesidad de variables. El apartado 4.3
muestr como leer datos de teclado e incluye 10 ejercicios propuestos. El
antiguo apartado 4.3, ms avanzado, queda retrasado para otro tema
posterior. Los apartados 4.5 y 4.6 se retrasan para fundirse con el tema 5.

0.29, de 22 de enero de 2015: Ampliado el tema 5: Incluidos en l los que

eran los apartados 4.5 (operadores condicionales) y 4.6 (enlazar
condiciones). Los ejemplos son ms detallados. Aadidos 9 ejercicios
propuestos ms.

0.30, de 23 de enero de 2015: Ampliado el tema 6: Los ejemplos son ms

detallados. Dos nuevos fuentes de ejemplo. Diez nuevos ejercicios
propuestos.

0.31, de 26 de enero de 2015: Ampliado el tema 7: Ampliadas las

explicaciones con ms detalles y hablando tambin de "constantes". Los
ejemplos son ms detallados. Tres nuevos fuentes de ejemplo. Catorce
nuevos ejercicios propuestos.

0.32, de 04 de febrero de 2015: El que antes era el tema 11 (funciones

matemticas) pasa a ser el nuevo tema 8. Aadidos seis nuevos ejercicios
propuestos (dos en el apartado 7.1, cuatro en el nuevo apartado 8).

0.33, de 04 de julio de 2015: Revisado y parcialmente reescrito el tema 8.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 112

0.34, de 07 de julio de 2015: Revisado y ampliado el tema 5. Aadidos

cuatro ejemplos completos de la orden "switch" y uno del operador
condicional.

0.35, de 09 de julio de 2015: Revisado y ampliado el tema 2.

0.36, de 11 de julio de 2015: Reescrito y ampliado el tema 3.

0.37, de 14 de julio de 2015: Reescrito y ampliado el tema 4.

0.38, de 15 de julio de 2015: Revisado y ampliado el tema 6.

0.39, de 23 de julio de 2015: Revisado y ampliado el tema 7.

0.40, de 24 de julio de 2015: Movido el tema 14 (ficheros) al tema 11.

Eliminados (al menos por ahora) los temas anticuados (applets, entrada
usando BufferedReader) e incompletos (Java2D). Ligeramente revisados los
temas 8, 9, 10 y 11.

Introduccin a Java 0.40, por Nacho Cabanes - Pgina 113