Ciclo de Desarrollo de Aplicaciones

Multiplataforma

Grado Superior

Instrucciones
básicas Java

Módulo de Programación

Departamento de Informática y Comunicaciones

Este documento se publica bajo licencia Creative Commons. No se permite un uso
comercial de la obra original ni de las posibles obras derivadas, la distribución de las
cuales se debe hacer con una licencia igual a la que regula la obra original.

Para ver una copia de esta licencia visite: [Link]

 Instrucciones básicas Java

Java es un lenguaje sencillo de aprender, con una sintaxis parecida a la de C++, pero en
la que se han eliminado elementos complicados y que pueden originar errores. Java es
orientado a objetos, con lo que elimina muchas preocupaciones al programador y permite
la utilización de gran cantidad de bibliotecas ya definidas, evitando reescribir código que
ya existe. Es un lenguaje de programación creado para satisfacer nuevas necesidades que
los lenguajes existentes hasta el momento no eran capaces de solventar.

Una de las principales virtudes de Java es su independencia del hardware, ya que el

código que se genera es válido para cualquier plataforma. Este código será ejecutado
sobre una máquina virtual denominada Maquina Virtual Java (MVJ o JVM – Java Virtual
Machine), que interpretará el código convirtiéndolo a código específico de la plataforma
que lo soporta. De este modo el programa se escribe una única vez y puede hacerse
funcionar en cualquier lugar. Lema del lenguaje: “Write once, run everywhere”.

Antes de que apareciera Java, el lenguaje C era uno de los más extendidos por su
versatilidad. Pero cuando los programas escritos en C aumentaban de volumen, su
manejo comenzaba a complicarse. Mediante las técnicas de programación estructurada y
programación modular se conseguían reducir estas complicaciones, pero no era suficiente.
Fue entonces cuando la Programación Orientada a Objetos (POO) entra en escena,
aproximando notablemente la construcción de programas al pensamiento humano y
haciendo más sencillo todo el proceso. Los problemas se dividen en objetos que tienen
propiedades e interactúan con otros objetos, de este modo, el programador puede
centrarse en cada objeto para programar internamente los elementos y funciones que lo
componen.

Las características principales de lenguaje Java se resumen a continuación:

El código generado por el compilador Java es independiente de la arquitectura.
Está totalmente orientado a objetos.
Su sintaxis es similar a C y C++.
Es distribuido, preparado para aplicaciones TCP/IP.
Dispone de un amplio conjunto de bibliotecas.
Es robusto, realizando comprobaciones del código en tiempo de compilación y de
ejecución.
La seguridad está garantizada, ya que las aplicaciones Java no acceden a zonas
delicadas de memoria o de sistema.

Java surgió en 1991 cuando un grupo de ingenieros de Sun Microsystems trataron de

diseñar un nuevo lenguaje de programación destinado a programar pequeños dispositivos
electrónicos. La dificultad de estos dispositivos es que cambian continuamente y para que
un programa funcione en el siguiente dispositivo aparecido, hay que rescribir el código.
Por eso la empresa Sun quería crear un lenguaje independiente del dispositivo.

Pero no fue hasta 1995 cuando pasó a llamarse Java, dándose a conocer al público como
lenguaje de programación para computadores. Java pasa a ser un lenguaje totalmente
independiente de la plataforma y a la vez potente y orientado a objetos. Esa filosofía y su
facilidad para crear aplicaciones para redes TCP/IP ha hecho que sea uno de los lenguajes
más utilizados en la actualidad.

Página 1
 Instrucciones básicas Java

Para el desarrollo de programas en lenguaje Java es necesario utilizar un entorno de

desarrollo denominado JDK (Java Development Kit) o, más actualemente SDK, que
provee de un compilador y un entorno de ejecución (JRE – Java Run Environment) para
los bytecodes generados a partir del código fuente.

Cada diferente versión del lenguaje ha ido incorporando mejoras y el entorno de

desarrollo y ejecución también ha sido mejorado sucesivamente, aunque básicamente
consiste en:

Un lenguaje de programación: Java.

Un conjunto de bibliotecas estándar que vienen incluidas en la plataforma y que
son necesarias en todo entorno Java. Es el Java Core.
Un conjunto de herramientas para el desarrollo de programas, como es el
compilador de bytecodes, el generador de documentación, un depurador, etc.
Un entorno de ejecución que en definitiva es una máquina virtual que ejecuta los
programas traducidos a bytecodes.

En Java, los datos y el código (métodos) se combinan en entidades llamadas objetos. El

objeto tendrá un comportamiento (su código interno) y un estado (los datos). Los objetos
permiten la reutilización del código y pueden considerarse, en sí mismos, como piezas
reutilizables en múltiples proyectos distintos. Esta característica permite reducir el tiempo
de desarrollo de software.

Al emplear los conceptos de la Programación Orientada a Objetos (POO), Java incorpora

las tres características propias de este paradigma: encapsulación, herencia y
polimorfismo. Los patrones o tipos de objetos se denominan clases y los objetos que
utilizan estos patrones o pertenecen a dichos tipos, se identifican con el nombre de
instancias.

Un programa escrito en Java no es directamente ejecutable, es necesario que el código

fuente sea interpretado por la Maquina Virtual Java. El código Java, código fuente, debe
grabarse en un archivo con extensión .Java. Este código es precompilado generándose los
códigos de bytes, Bytecodes (archivos con extensión .class) que serán interpretados
directamente por la Maquina Virtual Java y traducidos a código nativo de la plataforma
sobre la que se esté ejecutando el programa.

Bytecode: Conjunto de instrucciones en lenguaje máquina que no son

específicas a ningún procesador o arquitectura. Un intérprete de código de
bytes (bytecodes) para una plataforma específica será quien los ejecute. A
estos intérpretes también se les conoce como intérpretes Java de tiempo de
ejecución.

En el proceso de precompilación, existe un verificador de códigos de bytes que se

asegurará de que se cumplen las siguientes condiciones:

El código satisface las especificaciones de la Máquina Virtual Java.

No existe amenaza contra la integridad del sistema.
No se producen desbordamientos de memoria.
Los parámetros y sus tipos son adecuados.
No existen conversiones de datos no permitidas.

Página 2
 Instrucciones básicas Java

Para que un bytecode pueda ser ejecutado en cualquier plataforma, es imprescindible que
dicha plataforma cuente con el intérprete adecuado, es decir, la máquina virtual específica
para esa plataforma. En general, la Máquina Virtual Java es un programa de reducido
tamaño y gratuito para todos los sistemas operativos.

Debemos tener en cuenta que Java exige que la clase principal del programa (la que tiene
el método Principal (main()) tiene que tener el mismo nombre que el archivo .Java que la
contiene.

La herramienta básica para empezar a desarrollar aplicaciones en Java es el JDK (Java

Development Kit o Kit de Desarrollo Java), que incluye un compilador y un intérprete para
línea de comandos. Estos dos programas son los empleados en la precompilación e
interpretación del código.

El JDK es un entorno de desarrollo para construir aplicaciones, applets y componentes

utilizando el lenguaje de programación Java. Incluye herramientas útiles para el desarrollo
y prueba de programas escritos en Java y ejecutados en la Plataforma Java.

Así mismo, junto a JDK se incluye una implementación del entorno de ejecución Java, el
JRE (Java Runtime Environment) para ser utilizado por el JDK. El JRE incluye la Máquina
Virtual de Java (MVJ ó JVM – Java Virtual Machine), bibliotecas de clases y otros ficheros
que soportan la ejecución de programas escritos en el lenguaje de programación Java.

Junto con el kit de desarrollo que nos descargamos e instalamos, vienen incluidas
gratuitamente todas las bibliotecas de la API (Aplication Programming Interface – Interfaz
de programación de aplicaciones) de Java, es lo que se conoce como Bibliotecas de Clases
Java. Este conjunto de bibliotecas proporciona al programador paquetes de clases útiles
para la realización de múltiples tareas dentro de un programa. Está organizada en
paquetes lógicos, donde cada paquete contiene un conjunto de clases relacionadas
semánticamente.

Una biblioteca de clases es un conjunto de clases de programación orientada a objetos

que contienen métodos útiles para los programadores, lo que reduce el tiempo de
desarrollo de los programas. También, existen diversas bibliotecas de clases desarrolladas
por terceros que contienen componentes reutilizables de software, y están disponibles a
través de la Web.

Para compilar y ejecutar ficheros Java es necesario realizar ajustes en la configuración del
sistema, de tal forma que se puedan encontrar los ficheros necesarios para realizar las
labores de compilación y ejecución (variable path), en este caso [Link] y [Link], así
como las librerías contenidas en la API de Java y las clases del usuario.

Por ejemplo: C:\Program Files\Java\jdk1.7.0_02\bin)

También debemos configurar la ruta a las bibliotecas de la API de java y de las clases del
usuario (classpath). Es decir, para el acceso a los ficheros .class que se obtienen una vez
compilado el código fuente de un programa escrito en Java.

Por ejemplo: C:\Program Files\Java\jdk1.7.0_02\lib)

Página 3
 Instrucciones básicas Java

Una vez que la configuración del entorno Java está completada y tenemos el código
fuente de nuestro programa escrito en un archivo con extensión .Java, la compilación de
aplicaciones se realiza mediante el programa Javac incluido en el software de desarrollo
de Java.

Para llevar a cabo la compilación desde la línea de comandos, escribiremos:

> Javac [Link]

Donde Javac es el compilador de Java y [Link] es nuestro código fuente.

El resultado de la compilación será un archivo con el mismo nombre que el archivo Java
pero con la extensión class. Esto ya es el archivo con el código en forma de bytecode. Es
decir con el código precompilado.

Para que el programa pueda ser ejecutado, siempre y cuando esté incluido en su interior
el método main, podremos utilizar el intérprete incluido en el kit de desarrollo. La
ejecución de nuestro programa desde la línea de comandos podremos hacerla
escribiendo:

> Java [Link]

Donde Java es el intérprete y [Link] es el archivo con el código precompilado.

/* La clase MiModulo implementa una aplicación que muestra un texto por pantalla */
class MiModulo
{
public static void main(String[] args)
{
[Link]("Hola Mundo ");
}
}

Desde la línea de comandos tecleamos:

> Javac [Link]

El compilador genera entonces un fichero de código de bytes: [Link].

> Finalmente, ejecutamos el programa mediante la sentencia:

> Java [Link]

Si todo ha ido bien, aparecerá en pantalla: Hola Mundo

Página 4
 Instrucciones básicas Java

La versatilidad del lenguaje de programación Java permite al programador crear distintos

tipos de aplicaciones. A continuación, describiremos las características más relevantes de
cada uno de ellos:

Aplicaciones de consola
o Son programas independientes al igual que los creados con los lenguajes
tradicionales.
o Se componen como mínimo de un archivo .class que debe contar
necesariamente con el método main.
o No necesitan un navegador web y se ejecutan cuando invocamos el comando
Java para iniciar la Máquina Virtual de Java (JVM). De no encontrarse el
método main la aplicación no podrá ejecutarse.
o Las aplicaciones de consola leen y escriben hacia y desde la entrada y salida
estándar, sin ninguna interfaz gráfica de usuario.

Aplicaciones gráficas
o Aquellas que utilizan las clases con capacidades gráficas, como Swing que es
la biblioteca para la interfaz gráfica de usuario avanzada de la plataforma
Java SE.
o Incluyen las instrucciones import, que indican al compilador de Java que las
clases del paquete [Link] se incluyan en la compilación.

Applets
o Son programas incrustados en otras aplicaciones, normalmente una página
web que se muestra en un navegador. Cuando el navegador carga una web
que contiene un applet, éste se descarga en el navegador web y comienza a
ejecutarse. Esto nos permite crear programas que cualquier usuario puede
ejecutar con tan solo cargar la página web en su navegador.
o Se pueden descargar de Internet y se observan en un navegador. Los
applets se descargan junto con una página HTML desde un servidor web y se
ejecutan en la máquina cliente.
o No tienen acceso a partes sensibles (por ejemplo: no pueden escribir
archivos), a menos que uno mismo le dé los permisos necesarios en el
sistema.
o No tienen un método principal.
o Son multiplataforma y pueden ejecutarse en cualquier navegador que
soporte Java.

Midlets:
o Son aplicaciones creadas en Java para su ejecución en sistemas de propósito
simple o dispositivos móviles. Los juegos Java creados para teléfonos
móviles son midlets.
o Son programas creados para dispositivos embebidos (se dedican a una sola
actividad), más específicamente para la máquina virtual Java MicroEdition
(Java ME).
o Generalmente son juegos y aplicaciones que se ejecutan en teléfonos
móviles.

Página 5
 Instrucciones básicas Java

Servlets
o Son componentes de la parte del servidor de Java EE, encargados de generar
respuestas a las peticiones recibidas de los clientes.
o Los servlets, al contrario de los applets, son programas que están pensados
para trabajar en el lado del servidor y desarrollar aplicaciones Web que
interactúen con los clientes.

Actualmente hay tres ediciones de Java. Cada una de ellas se corresponde con una
plataforma que incluye una serie de funciones, paquetes y elementos del lenguaje (es
decir la API, Application Program Interface).

Java SE .- Java Standard Edition. Antes se la conocía como J2SE (el dos se refiere a
Java 2). Permite escribir código Java relacionado con la creación de aplicaciones y
applets en lenguaje Java común.

Java EE.- Java Enterprise Edition. Todavía conocida como J2EE. Pensada para la
creación de aplicaciones Java empresariales y del lado del servidor.

Java ME.- Java Mobile Edition. También conocida como J2ME. Pensada para la
creación de aplicaciones Java para dispositivos móviles.

Si bien en sus comienzos de Java la utilización de la línea de comandos era algo habitual,
con el paso del tiempo, se fueron desarrollando aplicaciones que incluían las herramientas
necesarias para realizar todo el proceso de configuración y programación de forma más
sencilla, fiable y rápida. Estas aplicaciones reciben el nombre de entornos de desarrollo.

Los entornos de desarrollo son aplicaciones que ofrecen la posibilidad de llevar a

cabo el proceso completo de desarrollo de software a través de un único programa.
Podremos realizar las labores de edición, compilación, depuración, detección de
errores, corrección y ejecución de programas escritos en Java o en otros lenguajes
de programación, bajo un entorno gráfico (no mediante línea de comandos).

Para el lenguaje de programación Java existen múltiples alternativas, siendo los

principales entornos de desarrollo:

Eclipse. Es un entorno completo de código abierto que posee numerosas

extensiones (incluido un módulo para JEE y otro para programar en C++) y
posibilidades. Hoy en día es el más utilizado y recomendable. Posee una comunidad
muy dinámica y desde luego es uno de los más potentes. Disponible en
[Link].

NetBeans. Entorno gratuito de código abierto para la generación de código en

diversos lenguajes (especialmente pensado para Java). Contiene prácticamente
todo lo que se suele pedir a un IDE, editor avanzado de código, depurador, diversos
lenguajes, extensiones de todo tipo. Incluye además un servidor de aplicaciones
Tomcat para probar aplicaciones de servidor. Se descarga en [Link].

JBuilder. Entorno completo creado por la empresa Borland (famosa por su lenguaje
Delphi) para la creación de todo tipo de aplicaciones Java, incluidas aplicaciones
para móviles. Es un entorno muy potente.

Página 6
 Instrucciones básicas Java

JDeveloper. De Oracle. Entorno completo para la construcción de aplicaciones Java

y XMl. Uno de los más potentes y completos (ideal para programadores de Oracle).

IntelliJ Idea. Entorno comercial de programación bastante fácil de utilizar pero a la

vez con características similares al resto. Es menos pesado que los anteriores y
muy bueno con el código.

Microsoft Visual J++ y Visual J#. Ofrece un compilador recomendable para los
conocedores de los entornos de desarrollo de Visual Studio y Visual [Link]
respectivamente. Pero el Java de Microsoft no es estándar y por ello es muy poco
utilizado.

El entorno que hemos seleccionado llevar a cabo nuestros desarrollos de software, en este
módulo profesional, será Eclipse, al ser uno de los más utilizados.

Antes de empezar a describir los elementos básicos de un programa, tenemos que hacer
referencia a las librerías, es decir al conjunto de clases ya definidas, que facilitan la
creación de nuestros programas. En el caso de Java estas librerías reciben el nombre de
paquetes.

Cuando se instala el kit de desarrollo de Java, además de los programas necesarios para
compilar y ejecutar código Java, se incluyen miles de clases dentro de cientos de
paquetes ya listos que facilitan la generación de programas. Algunos paquetes sirven para
utilizar funciones matemáticas, funciones de lectura y escritura, comunicación en red,
programación de gráficos, etc.

Por ejemplo la clase System está dentro del paquete [Link] (paquete básico) y posee
el método [Link] que necesitamos para escribir fácilmente por pantalla. Para poder
utilizar la clase, debemos incorporar ese código y para ello debemos utilizar la sentencia
import, colocada en la parte superior de todo el código, con la estructura arborescente
necearia para llegar a la clase.

import [Link]....clase

Ejemplo: import [Link]

Esa sentencia también permite utilizar el comodín asterisco (“*”) para incorporar todas las
clases que están dentro del paquete.

Ejemplo: import [Link].*

En el ejemplo se pide incluir en el código todas las clases que están dentro del paquete
awt de java. El paquete awt contiene clases para crear aplicaciones para entornos
gráficos.

Si omitimos la sentencia import, cuando utilicemos algún miembro de la clase, debemos

escribir su ruta completa.

[Link]

Página 7
 Instrucciones básicas Java

Un comentario es un texto que se incluye en el código fuente del programa, con la idea de
facilitar la legibilidad del código a los programadores y cuyo contenido es ignorado por el
compilador. Es fundamental comentar los códigos de los programas.

Los comentarios suelen utilizarse para incluir información sobre el autor del código, su
fecha de creación y modificación, para aclarar el significado de alguna sección del código,
para describir el funcionamiento de los métodos, etc.

En Java un comentario de una línea se escribe tras las símbolos //.

// Texto comentado // Anidamos un segundo comentario y es válido.

Cuando los comentarios ocupan más de una línea se encierran entre los símbolos / * y */

/* Texto comentado válido*/

/* Texto comentado /* no válido*/ por estar anidado con otro comentario */

Existen también otra clase de comentarios, denominados comentarios de documentación

y que se utilizan para generar automáticamente documentación, a través de una
herramienta llamada Javadoc y que viene en el kit de desarrollo de Java

Su sintaxis básica es:

> javadoc [Link] o paquete

EL funcionamiento es el siguiente:

Comenzaremos la línea de comentario con los códigos /**, y finalizaremos este

comentario de documentación con el código */, pudiendo ocupar tantas líneas como
queramos.

Cada línea javadoc se suele iniciar con eL símbolo de asterisco (*) vpara mejorar su
legibilidad. Dentro de esa línea se puede incluir cualquier texto; incluso se pueden utilizar
códigos HTML.

En el código javadoc se pueden usar etiquetas especiales, las cuales comienzan con el
símbolo @ y que pueden ser:

@author. Tras esa palabra se indica el autor del documento.

@version. Tras la cual se indica la versión de la aplicación
@see. Para indicar la relación del código que estamos escribiendo con otro código
@since. Indica desde cuándo esta disponible este código
@deprecated. Palabra a la que no sigue ningún otro texto en la Línea y que indica
que esta clase o método esta obsoleta.
@throws. Indica las excepciones que pueden lanzarse en ese código.
@param. Descripción de los parámetros que requiere el método para su utilización.
Cada parámetro se coloca en una etiqueta param, por lo que puede haber varios
@param para el mismo método.
@return. Para describir el valor devuelto por el método.

Página 8
 Instrucciones básicas Java

El código javadoc hay que colocarlo en tres sitios distintos dentro del código java de la
aplicación:

Al principio del código de la clase (antes de cualquier código Java). En esta zona se
colocan comentarios generales sobre la clase o interfaz que se crea mediante el
código Java. Dentro de estos comentarios se pueden utilizar las etiquetas:
@author, @version, @see, @since y @deprecated

Delante de cada método. Los métodos describen el comportamiento que tiene los
objetos que pertenecen a esa clase. Delante de cada método los comentarios
javadoc se usan para describir al método en concreto. Además de los comentarios
que podamos hacer, en esta zona se pueden incluir las etiquetas: @see, @param,
@exception, @return, @since y @deprecated

Delante de cada atributo. Se describe para qué sirve cada atributo en cada clase.
Puede poseer las etiquetas: @since y @deprecated

/** Esto es un comentario javadoc

* Generaremos un archivo HML con el comentario.
* <strong>Prueba de Javadoc</strong>
*
* @author J. Alvarez
* @version 1.0
*/
public class Mensaje
{
// Clase que muestra un mensaje por pantalla. Este no lo procesará javadoc
/** Este es el método principal de la clase
* Por aquí comienza a ejecutarse el código
* @param args Lista de argumentos recibidos de la línea de
comandos
* @return void No devolveremos nada
*/
public static void main(String args[])
{
[Link]("Hola Mundo");
}

Ejecutamos javadoc.

Página 9
 Instrucciones básicas Java

Obtenemos la página web siguiente:

Página 10
 Instrucciones básicas Java

Al igual que sucede en el mundo real, que identificamos un objeto con un nombre, los
lenguajes de programación utilizan nombres para identificar a los diferentes elementos de
un programas, como son las variables, los métodos, las clases, etc. Estos nombres
reciben el nombre de identificadores.

Java define las reglas que deben cumplir los identificadores:

El nombre empieza obligatoriamente por una letra, un símbolo de subrayado (_) o un

símbolo dólar ($).
Tras la letra inicial, se pueden utilizar cualquier carácter UNICODE
No existe limitación en cuanto a la longitud del identificador, aunque por razones
prácticas es mejor limitarse a un tamaño razonable.
No se pueden usar espacios en blanco en medio de un identificador. El especio
en blanco es un separador y realmente le estaríamos proporcionando al compilador
dos identificadores en vez de uno.
Se hace distinción entre minúsculas y mayúsculas
Las palabras clave del lenguaje no deben ser utilizadas como identificadores.

Además de lo anterior, es común:

Utilizar identificadores que comienzan por letras mayúsculas para aquellos elementos
que sean públicos y por minúsculas cuando sean privados.
Nombrar a las constantes con todas las letras en mayúscula y si la constante la forma
más de una palabra separarlas por el símbolo del subrayado (“_”).
Utilizar la nomenclatura ÇamelCase para aquellos identificadores que contienen varias
palabras.
Utilizar identificadores claros y descriptivos, pero no excesivamente largos.

Por ejemplo, si queremos recoger los valores del número de horas extras
trabajadas, número de horas de ausencia del trabajador y número de horas
semanales del trabajador según convenio, entenderemos que N1, N2 y N3, no
son nombres de variables adecuadas, pues no son descriptivas. Parece más
adecuado utilizar identificadores como: horasExtrasTrabajador, horasAusencia,
horasSemanalesConvenio.

Las palabras reservadas (keywords), son palabras que tienen un determinado significado
para el compilador y no pueden ser utilizadas para otros fines. En Java tenemos:

Página 11
 Instrucciones básicas Java

Java tiene muchos tipos de datos predefinidos. A estos tipos de datos ya definidos en el
lenguaje se le denominan primitivos.

Java es un lenguaje fuertemente “tipado”, lo que implica que cualquier objeto que se
utilice en un programa deber tener un tipo asociado y que además debe ser declarado
antes de ser utilizado.

En Java los tipos de datos pueden ser de dos tipos:

Tipos valor. Cuando un objeto cualquiera se declare de un tipo valor, el valor se

almacena en la memoria que llamamos stack (pila). A los objetos de tipo valor se
les llama variables.

Tipos referencia. Cuando un objeto cualquiera se declara de tipo referencia su valor

se almacena en la zona de memoria que llamanos heap (montón) y la referencia a
esa dirección de memoria se almacena en la pila (stack).

stack (pila) heap (montón)

void método(int numero)
{
numero 25 A000
Persona p;
José Alonso
p=new Persona()
} p null
A000

La creación de objetos de tipo de dato referencia, consume más memoria y

es un proceso más lento.

El lenguaje Java dispone de una serie de datos de tipo valor:

Tipo Tamaño Valores mínimo y máximo

byte 8 bits -128 a 127
short 16 bits -32768 a 32767
int 32 bits -2147483648 a 2147483647
long 64 bits -9223372036854775808 a 9223372036854775807

Tipo Tamaño Valores mínimo y máximo

float 4 bytes 1.4E-45 a 3.4028235E38
double 8 bytes 4.9E-324 a 1.7976931348623157E308

Página 12
 Instrucciones básicas Java

El tipo char se utiliza para almacenar un carácter único. Una variable de tipo char utiliza
dos bytes para almacenar el código Unicode del carácter.

Los caracteres especiales, es decir, aquellos que tienen un significado especial para Java
se deben representar de una forma especial, es lo que se conoce como secuencia de
escape, y para ello se utiliza el carácter “\” seguido por otro carácter que indica el
significado de la secuencia de escape.

secuencia significado
\t Tabulación
\b Retroceso
\n Salto de línea
\r Retorno de carro
\f Salto de página
\’ Comilla simple
\" Comilla doble
\\ Barra invertida

Cuando tenemos que especificar un carácter Unicode que no tenemos en el teclado lo

representaremos también mediante una secuencia de escape compuesta por los
caracteres \u seguidos por el valor hexadecimal del código Unicode del carácter. Por
ejemplo, el símbolo del euro es la secuencia \u20AC.

El tipo de dato String se utiliza para almacenar cadenas de caracteres. Este tipo de dato
realmente es una clase, pero Java permite utilizarlo como un tipo primitivo del lenguaje,
es decir, no hay que instanciarlo para poder utilizarlo.

Las cadenas de caracteres son invariables, porque durante la asignación de un valor a una
variable de tipo cadena de caracteres se reserva algo de espacio en memoria para el
almacenamiento de la cadena. Si más adelante esta variable recibe un nuevo valor, se le
atribuye una nueva ubicación en memoria. Todo este proceso se hace de forma
transparente. Con este mecanismo se consigue que las cadenas puedan tener diferentes
tamaños en diferentes momentos, pero se pierde tiempo en la reubicación de los datos.

Para asignar un valor a una cadena de caracteres encerraremos su contenido entre

comillas dobles:

String NombreAlumno;

NombreAlumno = “Joaquín Álvarez”

Dado que realmente String es una clase, Java proporciona numerosos métodos para su
tratamiento, como veremos más adelante.

Página 13
 Instrucciones básicas Java

El tipo booleano permite tener una variable que puede almacenar un valor de dos
posibles: true (verdadero) y false (falso)

boolean variableLogica;

variableLogica = true;

Básicamente cada tipo lo que nos define es un rango de valores permitidos, y las
operaciones que se pueden efectuar, a modo de ejemplo:

DATO CASO DE ESTUDIO TIPO BREVE JUSTIFICACION

Queremos saber si el trabajador
está casado o no, a fin de elaborar Sólo son posibles dos respuestas: Sí o
Casado sus horarios de trabajo y mejorar Boolean No
la conciliación de la vida laboral y (Verdadero o Falso)
familiar

Queremos almacenar el estado civil

de un empleado, y distinguir entre Con una sóla letra podemos distinguir
Casado, Soltero, Viudo y entre las 4 situaciones posibles,
Sexo char asignando ‘C’ a Casado, ‘S’ a soltero,
Desconocido, ya que existe la
posibilidad de que en su ficha no lo ‘V’ a Viudo y ‘D’ a Desconocido
haya rellenado.

Se expresará como número del 1 al

7, pero tenemos que tener Permite representar números enteros
presente que hay problemas de entre -128 y 127, por lo que es más
Día de la capacidad de memoria para el que suficiente para los valores de 1 a 7
byte
semana ordenador en que se va a ejecutar que queremos guardar. Además sólo
la aplicación, por lo que debemos ocupa 8 bits. Es el tipo entero más
ahorrar todo el espacio de pequeño que podemos usar.
almacenamiento que podamos

Permite representar números enteros

entre -32.768y 32.767, por lo que es
Se expresará como un número más que suficiente para los valores de
entre 1 y 1 a 366 que queremos guardar. Sin
Día del año 366. Al igual que antes, queremos short embargo el tipo byte no proporciona un
aprovechar al máximo el espacio de rango suficiente. Además sólo ocupa
almacenamiento. 16 bits. Es el tipo entero más pequeño
que podemos usar para este conjunto
de valores.

Permite representar números enteros,

sin decimales, entre -[Link] y
Será una cantidad redondeada a
[Link]. Por mucho que
euros, ya que nuestros clientes nos
Total Factura int nuestros clientes nos paguen grandes
pagan grandes sumas, en las que sumas, no tendremos la suerte de que
incluir céntimos parece ridículo. nos paguen más de dos mil millones de
euros en una sola factura.

Es una cantidad considerable, que no

Número de milisegundos que han podemos almacenar en un int, pero que
trascurrido desde las 00:00:00 sigue siendo un número entero en el
Milisegundos long rango de long. De hecho esa es la
horas del día 1 de Enero de 1970
hasta nuestros días. cantidad que usa Java en la clase Date
para expresar una fecha.

Página 14
 Instrucciones básicas Java

Es el tipo de número real (con

decimales) de menor precisión y que
Queremos expresar el sueldo de menos memoria ocupa. No obstante, su
cada empleado en euros, con rango de valores permite representar el
Sueldo
precisión de céntimos. Suponemos float sueldo de cualquier trabajador de la
Mensual empresa, por elevado que éste sea.
que seguimos con limitaciones de
memoria. Además tampoco necesitamos más
precisión, ya que para los céntimos,
con dos decimales nos basta.

Número PI. Necesitamos almacenar

el valor del número pi para una Es el tipo real que mayor precisión nos
aplicación que realiza cálculos proporciona. El número Pi es un
científicos de gran precisión. número real irracional, es decir, con
Constante PI Necesitamos poder representar el double
infinitos decimales. Con double
mayor número posible de podremos representar de forma exacta
decimales del número Pi, para no el mayor número posible de ellos.
perder precisión en los cálculos.

Las variables son contenedores de información que nos van a permitir almacenar
información de diferente tipo. Según la ubicación de su declaración una variable
pertenecerá a una de las categorías siguientes:

Declarada en el interior de una clase, la variable es una variable de instancia (de un

objeto). Sólo existirá si tenemos un objeto de esa clase. Cada objeto tendrá su
propio ejemplar de la variable.

Declarada con la palabra clave static en el interior de una clase, la variable es una
variable de clase. Se puede acceder a ella directamente por el nombre de la clase y
existe en un único ejemplar, que será compartido por todos los objetos de la clase.

Declarada en el interior de un método, la variable es una variable local. Sólo existe

durante la ejecución del método y sólo se puede acceder a ella desde el código de
ésta.

Declarada como parámetro de un método es una variable local, con la salvedad que
debe ser inicializada antes o durante la llamada de la función.

Para poder utilizar una variable, previamente debemos definirla, es decir, debemos indicar
el tipo de dato que va a almacenar. Como ya dijimos, Java dispone de dos categorías de
tipos de variables:

Los tipos por valor. La variable contiene realmente la información. Esta variable se
guarda en el stack y no es inicializada cuando se crea. La forma de declarar una
variable de tipo valor es la siguiente:

Tipo_de_dato identificador_de_la_variable;

Ejemplos:
int segundos; // segundos contendrá un número entero, sin decimales
boolean decisión; //decisión sólo puede ser verdadera o falsa

Página 15
 Instrucciones básicas Java

También se puede hacer que La variable tome un valor inicial en el momento de

realizar la declaración:

int segundo =36000;

Se puede declarar más de una variable en la misma línea, separándolas por comas,
incluso podemos declarar una variable asignándole el resultado de una operación:

int numero 12000,valor, salarioNeto= SalarioBruto-descuento;

Los tipos por referencia. La variable, que se guarda en el stack, contiene la

dirección de memoria donde se encuentra realmente almacenada la información
(heap).

Este tipo de variables se crean utilizando el operador new, que veremos

posteriormente y son inicializadas, de forma automática, por el compilador, según
la tabla siguiente:

Tipo Valor por defecto

byte 0
short 0
int 0
long 0
float 0.0
double 0.0
char \u0000
boolean false
String null

El ámbito de una variable es la zona de código en la que se puede manipular dicha

variable y dependerá de la ubicación de la declaración.

Como ya dijimos, se puede hacer esta declaración en el bloque de código de una clase, en
los parámetros de un método o en un bloque de código en el interior del método. Sólo el
código del bloque donde se declara la variable puede utilizarlo.

Si el mismo bloque de código se ejecuta varias veces durante la ejecución de la función,

caso de un bucle while por ejemplo, la variable se creará a cada paso en el bucle. En este
caso, la inicialización de la variable es obligatoria.

Página 16
 Instrucciones básicas Java

No se pueden tener dos variables con mismo nombre con el mismo alcance. Sin embargo,
tenemos la posibilidad de declarar una variable interna de un método o en un parámetro
del método con el mismo nombre que una variable declarada a nivel de la clase. En este
caso, la variable declarada al nivel de la clase queda oculta por la variable interna de la
función.

Si un bloque tuviera otros bloques anidados, no se podrán declarar variables en los

bloques interiores con el nombre de otras de ámbito superior.

{
i=25;
j=30;
{
int aux; // variable local que sólo tendrá vigencia en este bloque
aux =j;
j= i;
i= aux;
}
}

La declaración de variables, entre las líneas del código, siendo válida, conlleva código más
difícil de leer y de mantener. Salvo que se quiera crear un ámbito muy concreto a una
variable, no debemos declararla entre las instrucciones.

El nivel de acceso de una variable se combina con el ámbito de la variable y determina

qué porción de código tiene derecho de leer y escribir en la variable.

Un conjunto de palabras clave permite controlar el nivel de acceso. Se utilizan en la

declaración de la variable y deben ser ubicadas delante del tipo de la variable. Sólo
pueden ser utilizadas para la declaración de una variable en el interior de una clase,
quedando prohibido su uso en el interior de una función.

private: la variable sólo se utiliza con el código de la clase donde está definida.

protected: la variable se utiliza en la clase donde está definida, en las subclases de

esta clase y en las clases que forman parte del mismo paquete.

public: la variable es accesible desde cualquier clase sin importar el paquete.

static: esta palabra clave se asocia a una de las palabras clave anteriores para
transformar una declaración de variable de instancia en declaración de variable de
clase (utilizable sin que exista una instancia de la clase).

Si a una variable no se le especifica ningún nivel de acceso, la variable es accesible desde

todas las clases que forman parte del mismo paquete.

Página 17
 Instrucciones básicas Java

El ciclo de vida de una variable nos permite especificar durante cuánto tiempo el
contenido de una variable estará disponible a lo largo de la ejecución de la aplicación.

Para una variable declarada en un método, la duración del ciclo de vida corresponde a la
duración de la ejecución del método. En cuanto termine la ejecución del método, la
variable se elimina de la memoria. Volverá a ser creada en la siguiente llamada.

Una variable declarada en el interior de una clase puede ser utilizada mientras esté
disponible un objeto de esa clase. Las variables declaradas con la palabra clave static
están accesibles durante toda la ejecución de la aplicación.

Los valores numéricos enteros se pueden utilizar con su representación decimal, octal,
hexadecimal o binario. Las cuatro líneas siguientes de código surten el mismo efecto.

i=243; // número 243 en el sistema decimal

i=0363; // número 243 en el sistema octal
i=0xF3; // número 243 en el sistema hexadecimal
i=0b11110011; // número 243 en el sistema binario

Los valores numéricos reales se pueden expresar con la notación decimal o la notación
científica.

superficie= 2356.8F; // F es un sufijo para indicar un valor float

superficie= 2.3568e3F; // F es un sufijo para indicar un valor float

Java puede insertar caracteres subrayado (“_”) en los literales numéricos para facilitar su
lectura.

precio = 1_234_876_567;
precio = 1234876567;

Los valores literales enteros se consideran por defecto como tipos int. En cuanto a los
valores literales reales se consideran como tipos double. Esta consideración que hace el
lenguaje es, a veces, fuente de errores de compilación

float precio = 123.23; // Error de compilación, 123.23 se considera double

Para evitar este problema tenemos que utilizar un sufijo F (mayúscula o minúscula) para
forzar la definición del literal.

float precio = 123.23f; // Correcto, 123.23 se considera float

Página 18
 Instrucciones básicas Java

Una instrucción es una acción. Una instrucción es una expresión válida escrita en un
lenguaje de programación. Las instrucciones se pueden utilizar para asignar un valor a
una variable, o para conocer el valor que contiene, para realizar una comparación, un
proceso repetitivo, para llamar a un método, para definir objeto, etc.

En Java TODAS las instrucciones terminan en punto y coma (;)

Por legibilidad las instrucciones se escriben en líneas separadas. Las instrucciones se

agrupan formando bloques de instrucciones, encerradas entre llaves y que se ejecutan
una a continuación de la otra. Ni en la llave de apertura, ni en la llave de cierra se ponen
“;” porque no son instrucciones, son elementos para agrupar las instrucciones.

{
// Lista de instrucciones finalizadas en ;
}

Toda variable que se defina dentro de un bloque de instrucciones, solo existirá dentro de
dicho bloque, fuera de ahí será inaccesible.

public void f()

{
{
int b=1;
}
b++; // Error, b no existe fuera del bloque anterior
}

Los bloques de instrucciones pueden anidarse, aunque si dentro de un bloque interno,

definimos una variable con el mismo nombre que otra definida en el bloque externo, se
producirá un error, puesto que no se podrá determinar a cuál de las dos se está haciendo
referencia, dentro del bloque más interno.

Toda variable que se defina dentro de un método, será local y solo podrá ser accedida por
las instrucciones que forman ese método.

Las instrucciones podemos agruparlas en tres bloques:

Sentencias de expresión. Están formadas por una expresión seguida del

carácter; (punto y coma).

Sentencias de declaración. La declaración de una variable, en la que se le asocia al

identificador de la variable un tipo, y opcionalmente un valor, que genera una
sentencia, al añadirle el símbolo de terminación.

Sentencias de control de flujo. Se encargan de “contener” a las otras

sentencias del programa, de forma que se indique el orden en que se van a
ejecutar esas sentencias, y bajo qué condiciones. Pueden considerarse como
sentencias estructurales dentro del programa.

Página 19
 Instrucciones básicas Java

Una instrucción de asignación, es aquella que permite almacenar en una variable un valor.
Para realizar la asignación se utiliza el operador “=”, con la idea de que “lo que está a la
derecha del igual, se asigna a la variable que está a su izquierda”.

También incluiremos entre estas instrucciones a aquellas formadas por cualquiera de los
operadores de asignación combinados (+=, -=, *=, /=, %=, principalmente). También
a las formadas por los operadores de incremento o decremento (++, --), que llevan una
asignación implícita.

Todas esas expresiones son sentencias al añadirles el punto y coma, ya que indican una
acción a realizar, que consiste en modificar el valor almacenado en una variable.

saludo = "Hola";
n = 5 * cont;
a++;
a+=2;

Para declarar una variable basta con indicar el tipo de una variable seguido de su
identificador y terminar con un punto y coma, como cualquier otra sentencia. El
compilador de Java siempre que encuentra un tipo seguido de un identificador, interpreta
que se trata de una declaración.

Las declaraciones consisten básicamente en indicar, la primera vez que aparece en el

programa una variable, cuál va a ser su tipo. Esto ayuda al compilador a saber cuanto
espacio debe reservar en memoria para esa variable, y permite que se pueda simplificar
las comprobaciones que debe hacer el compilador, ya que toda variable que usemos debe
ser previamente declarada.

Java es, según lo dicho, un lenguaje fuertemente tipado. Esa cualidad, lejos de ser un
inconveniente como puede parecer a primera vista, es una garantía de seguridad, y de
que los valores que nos vamos a encontrar en una variable son los esperados, y nunca
cualquier otra cosa.

Podemos construir sentencias de declaración de tres tipos:

Declaración simple de una variable int a;
Declaración e inicialización de una variable int a = 0;
Declaración e inicialización de varias variables del mismo tipo simultáneamente. int
a = 0, b, c = 5;

Cuando se declaran constantes debemos utilizar la palabra reservada final y tenemos que
asignarle un valor, que no podrá variar a lo largo de la ejecución del programa. Por
cuestiones de legibilidad del código, se recomienda nombrarlas en mayúsculas.

final float PI=3.1416F;

Página 20
 Instrucciones básicas Java

Permiten representar la secuenciación de instrucciones, la ejecución condicional de

instrucciones, y la ejecución repetitiva de instrucciones.

Java también dispone de sentencias de salto incondicional, que pudiendo ser útiles, son
totalmente desaconsejables en condiciones normales. El uso de sentencias de salto
incondicional debería ser nulo.

La ejecución secuencial se hace tal y como se le indicaría a una persona: “Escribe las
tareas en el orden en que vas a hacerlas, es decir, una detrás de otra”.

En Java pueden escribirse varias instrucciones, incluso todo el programa, en una sola
línea, aunque lo recomendable es escribir cada una de ellas en una línea y usar
indentación o tabulación. También es posible, y ocurre frecuentemente, que una sola
sentencia ocupe varias líneas del programa.

Pero al permitir esas posibilidades nos obliga a delimitar donde termina y donde empieza
cada sentencia y para ello todas las sentencias se terminan con un carácter de punto y
coma (;).

Existe la sentencia nula, que es el carácter punto y coma. En cualquier sitio donde la
sintaxis de Java admita una sentencia, también podremos poner la sentencia nula, es
decir, simplemente un punto y coma, para indicarle que no haga nada. No obstante,
cualquier programa puede hacerse sin necesidad de usar la sentencia nula y si alguna vez
se usa es por dar claridad al código.

Se pueden definir bloques de sentencias. En cualquier sitio donde la sintaxis de Java

admita una sentencia, se puede colocar todo un bloque de sentencias, que se ejecutarían
como una sola en el orden que se indique, sin más que encerrarlas entre llaves.

En cuanto a la tabulación del código, más conocida como indentación, en Java se utiliza el
estilo K&R (Kernighan & Ritchie). Este estilo consistente en abrir la llave en la misma línea
de la declaración de la orden, en nuevas líneas se van tabulando las instrucciones que
corresponden a esa estructura y cerrando la llave en una nueva línea, al mismo nivel que
la declaración.

if (variable== TRUE) {
intrucción1;
instruccion2;
…
}

Es evidente que el estilo es totalmente opcional, son las reglas de estilo de la empresa en
la que se desarrolle, el que lo marcará. Así, por ejemplo, en la actualidad hay otro modelo
bastante utilizado, en especial, por los programadores de Visual Studio de Micrsoft, que es
el estilo Allman (definido por Eric Allman), y básicamente consiste en que la llave de
apertura está la línea siguiente a la declaración de la orden.

Página 21
 Instrucciones básicas Java

if (variable== TRUE)
{
intrucción1;
instruccion2;
…
}

Instrucción if (si)

La instrucción if permite a un programa tomar la decisión sobre la ejecución o no, de una

acción, o de un grupo de acciones, mediante la evaluación de una expresión lógica.

La acción o grupo de acciones, se ejecutarán cuando la evaluación de una expresión lógica

encerrada entre paréntesis, sea cierta; en caso contrario no se ejecutan las instrucciones.

if (ExpresionCierta) instrucción;

if (ExpresionCierta)
{
// Instrucciones
}

Por ejemplo: Si el contenido de la variable valor es igual a 50, entonces poner la

variable número a 1, multiplicar el valor de la variable b por 2, guardar el resultado
en la variable a y continuar la ejecución del programa.

if (valor == 50)
{
numero=1;
a=2*b;
}

La expresión que se evalúa estará encerrada entre paréntesis. Dentro de una expresión
puede haber una o más condiciones. Es conveniente que cada condición esté encerrada
entre paréntesis, por cuestiones de legibilidad.

if ((valor == 50) && (x < 5))

{
numero=1;
a=2*b;
}
La colocación de un punto y coma después de la expresión de una estructura if, constituye
un error en la lógica del programa, porque no tiene sentido.

if (ExpresionCierta) ; // Si se cumple la ExpresionCierta no se hace nada.

Página 22
 Instrucciones básicas Java

Instrucción if-else (si- si no)

Es una instrucción condicional donde se ofrecen dos alternativas a seguir, basadas en la

comprobación de una expresión.

if (ExpresionCierta)
{
// Instrucciones para el true
}
else
{
// Instrucciones para el false
}

Si la evaluación de la expresión que escribimos entre paréntesis es cierta, se ejecuta el

bloque de sentencias primero (el correspondiente al bloque if) y si no lo es, se ejecutará
el bloque de sentencias del else. Ambos bloques de instrucciones están agrupados entre
llaves, para indicar su comienzo y su final. En el caso de que sea una única instrucción se
pueden omitir.

Es posible anidar sentencias if-else.

if (ExpresionCierta)
{
if (otraExpresionEsCierta)
{
// Instrucciones para el true
}
else
{
// Instrucciones para el false
}
}
else
{
// Instrucciones para el false
}

El ejemplo siguiente resuelve un programa en Java que genera un nº aleatorio entre 1 y

100 e imprime como salida por pantalla si dicho número es par o impar.

Página 23
 Instrucciones básicas Java

// Importamos el paquete que contiene la clase Random

import [Link].*;

public class Aleatorio {

public static void main(String[] args) {
int valor;
Random numAleatorio;

numAleatorio = new Random(); // creamos el objeto;

valor = [Link] (50); //obtenemos números entre 0 y 99;

if (valor %2 ==0) [Link]("ha salido un numero par: " + valor);

else [Link]("ha salido un numero impar: " + valor);
}
}

En el ejemplo anterior se ha utilizado el estilo K&R, que ocupa menos líneas de código,
aunque quizá resulta más difícil de ver los bloques de instrucciones. Repetimos el mismo
código con la notación Allman

// Importamos el paquete que contiene la clase Random

import [Link].*;

public class Aleatorio

{
public static void main(String[] args)
{
int valor;
Random numAleatorio;

numAleatorio = new Random(); // creamos el objeto;

valor = [Link] (50); //obtenemos números entre 0 y 99;

if (valor %2 ==0) [Link]("ha salido un numero par: " + valor);

else [Link]("ha salido un numero impar: " + valor);
}
}

Página 24
 Instrucciones básicas Java

Operador ?: (si resumido)

El operador ?: es un operador que se utiliza para expresar de forma más concisa la

instrucción if-else. Su formato es el siguiente:

ExpresionCondicional ? Instrucciones_True : Instrucciones_False;

Por ejemplo, supongamos la siguiente instrucción if:

if (x != 0.0) s = [Link](x)/x;
else s = 1.0;

Podríamos expresarla mediante el operador ? de la forma siguiente:

x != 0.0 ? s=[Link](x)/x : s=1.0;

También podríamos haberla escrito como:

s = x != 0.0 ? [Link](x)/x : 1.0;

Si al evaluar la expresión, resultase cierta, se ejecutaría la instrucción a la derecha del

operador ?, por el contrario, si la evaluación de la expresión hubiera sido falsa, se
ejecutaría la instrucción a la derecha del símbolo “:”

El operador condicional es asociativo por la derecha.

Si escribimos: a ? b : c ? d : e
se evalúa como: a ? b : (c ? d : e) y no como: (a ? b : c) ? d : e

Ejemplo: Escribir la expresión que permite calcular el mayor de dos números, x e y,

mediante el operador ?. Escribe la instrucción if-else equivalente.

Mayor = (x > y) ? x : y;

if (x > y) Mayor = x;
else Mayor = y;

Página 25
 Instrucciones básicas Java

Instrucción switch (en caso de)

Cuando se tienen muchas alternativas posibles para elegir, el uso de sentencias if-else
puede resultar bastante engorroso, siendo más habitual la utilización de una sentencia
switch.

switch (expresión)
{
case valor1:
Instrucción 11;
...
break;
case valor2:
Instrucción 21;
...
break;
default:
Instrucción n1;
...
break;
}

Hemos de tener en cuenta que cada instrucción del bloque de instrucciones terminará con
su correspondiente punto y coma (;)

El funcionamiento de la sentencia switch es el siguiente:

El valor de la expresión se evalúa al principio de la estructura (por el switch) luego

se compara el valor obtenido con el valor especificado con los diferentes casos,
hasta encontrar uno que satisfaga la condición.

El valor que se debe probar puede estar contenido en una variable pero también
puede ser el resultado de un cálculo. En tal caso, sólo se ejecuta el cálculo una
única vez al principio del switch.

El tipo del valor probado puede ser numérico entero, carácter, cadena de caracteres
o enumeración. Por supuesto, es necesario que el tipo de la variable probada
corresponda al tipo de los valores en los diferentes case.

Cuando se encuentre una concordancia, entre el valor probada y uno de los casos,
el bloque de código asociado a ese caso se ejecuta. Si no, se compara el valor
obtenido con el valor del case siguiente y así sucesivamente hasta encontrar la
concordancia o hasta el default.

Si no se encuentra ningún valor concordante en los diferentes case se ejecuta el

bloque de código especificado en el default.

La cláusula default es un caso especial del case. Su bloque de instrucciones se

ejecuta si ninguna de las constantes anteriores satisface la evaluación de la
condición.

Página 26
 Instrucciones básicas Java

Cada uno de los bloques de código debe ser finalizado por la instrucción break, en
caso contrario, la ejecución continuará por el bloque de código siguiente hasta
encontrar una instrucción break o hasta el fin de la estructura switch. Esta solución
se puede utilizar para poder ejecutar un mismo bloque de código para diferentes
valores probados.

Cuando para diferentes valores evaluados de la expresión, se tengan que ejecutar

las mismas instrucciones, se pueden agrupar los valores en un único case,

case constante1:
case constante2: <bloqueInstrucciones>
break;

Ejemplo.- Obtener una nota aleatoria entre 0 y 14. Calificar con letras la nota. Toda nota
superior a 10 se considera un error.

class Notas
{
public static void main (String[] args)
{
int notaEntera;
Random numAleatorio;

numAleatorio = new Random(); // creamos el objeto;

notaEnterar = [Link] (15); //obtenemos números entre 0 y 15

switch (notaEntera)
{
case 0:
case 1:
case 2: [Link]("Muy Deficiente");
break;
case 3:
case 4: [Link]("Insuficiente");
break;
case 5: [Link]("Suficiente");
break;
case 6: [Link]("Bien");
break;
case 7:
case 8: [Link]("Notable");
break;
case 9: [Link]("Sobresaliente");
break;
case 10:[Link]("Matrícula de Honor");
break;
default:
[Link]("Nota errónea: Sólo son notas válidas los números
enteros del 0 al 10");
}
}
}

Página 27
 Instrucciones básicas Java

Son instrucciones que permiten ejecutar repetidas veces un bloque de instrucciones,

mientras se cumpla una determinada expresión (una expresión puede estar formada por
múltiples condiciones combinadas con los operadores relacionales).

Instrucción while (mientras)

Permite ejecutar un bloque de instrucciones mientras se cumpla una determinada

expresión, que se evalúa previamente.

while (ExpresionCierta)
{
// Intrucciones;
}

En la instrucción while se evalúa la expresión que escribimos entre paréntesis, la cual

devolverá un valor lógico (true o false). Si el valor es true (verdadero), se entra en el
bloque de instrucciones, que se ejecutan y, tras ello, se vuelve a evaluar la expresión.
Este proceso se repite hasta que la evaluación de la expresión resulte false (falsa),
momento en que se sale del proceso repetitivo y se continuará con la siguiente instrucción
después del while.

Por la estructura del while, dentro del bloque de instrucciones deberá haber alguna
instrucción que en algún momento pueda alterar el valor de la condición, pues en otro
caso se entrará en un bucle infinito.

Ejemplo, escribir el proceso repetitivo que me mostraría los números enteros desde el 0
hasta el 9, ambos inclusive

i=0;
while (i<10)
{
[Link](i);
i++;
}

Nota Importante.- Cuando se captura un dato y ese dato, además de ser un valor que se
puede utilizar en el proceso, se pueda utilizar como condición de finalización, caso
anterior (numero además de contener un valor para el proceso, puede contener un valor
para finalizar), siempre se utiliza una expresión while para construir el proceso.

Página 28
 Instrucciones básicas Java

Instrucción do-while (repetir-mientras)

Esta instrucción es una variante de la instrucción anterior; ahora la evaluación de la

expresión se realiza tras haber ejecutado el bloque de instrucciones al menos una vez.

do
{
// Intrucciones
} while (ExpresionCierta);

Ejemplo, escribir el proceso repetitivo que me mostraría los números enteros desde el 0
hasta el 9, ambos inclusive

i=0;
do
{
[Link](i);
i++;
} while (i<10);

Esta estructura tiene un funcionamiento idéntico a la anterior excepto que la condición se

examina después de la ejecución del bloque de código. Nos permite garantizar que el
bloque de código se ejecutará al menos una vez ya que la condición se probará por
primera vez después de la primera ejecución del bloque de código. Si la condición es true,
el bloque se ejecuta de nuevo hasta que la condición sea false. Debemos tener cuidado en
no olvidar el punto y coma después del while.

Instrucción for (para)

Cuando sabemos el número de iteraciones que se deben realizar en un bucle, es preferible

utilizar la estructura for. Para poder utilizar esta instrucción, se debe declarar una variable
de contador. Se puede declarar esta variable en la estructura for o en el exterior, y en tal
caso se debe declarar antes de la estructura for.

for (<Inicialización> ; <ExpresionFinalBucle> ; <Iterador>)

{
// Intrucciones
}

Su funcionamiento es el siguiente:

1. Inicialización: Se efectúa la instrucción, o instrucciones, del bloque <inicialización>.

Este bloque, generalmente, estará formado por la variable de control del número
de veces que se va a repetir el proceso, pudiendo existir otras instrucciones
separadas por comas. Este bloque sólo se ejecuta una vez. En este bloque se puede
definir una, o más variables (separadas por comas) y su ámbito de actuación será
el bloque de instrucciones que componen el for.

Página 29
 Instrucciones básicas Java

2. ExpresionFinalBucle: Se evalúa la expresión y,

o Si el resultado de la evaluación es falso, se finaliza la ejecución del bucle y se

pasa a la siguiente instrucción fuera del bucle.

o Si el resultado de la evaluación fuese verdadero se procede a ejecutar el

bloque de instrucciones, que entre otras muchas cosas, se utilizarán para
modificar valores que determinen el final del proceso repetitivo. Una vez que
se ha ejecutado el bloque de instrucciones se pasa al iterador

3. Iterador: Se ejecuta la instrucción, o instrucciones, del bloque iterador.

4. Se vuelve al paso segundo.

Ejemplo, imprimir en pantalla las tablas de multiplicar del 1 al 10

for(int k=1;k<10;k++)
{
for (int l = 1; l < 10; l++)
{
[Link](k * l + "\t");
}
[Link]();
}

Obtenemos el resultado siguiente:

1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81

Página 30
 Instrucciones básicas Java

Instrucción for de iteración (para iterativo)

Existe otra sintaxis del bucle for que permite ejecutar un bloque de código para cada
elemento contenido en una colección. Esta sintaxis se introdujo en Java 5 (Tiger) con
objeto de facilita recorrer las colecciones de forma similar a los bucles for in de Python o
los foreach de Visual Studio y PHP.

La sintaxis general de esta instrucción es la siguiente:

for (tipo variable: colección)

No hay noción de contador en esta estructura ya que efectúa por sí misma las iteraciones
en todos los elementos presentes en el array o colección.

La variable declarada en la estructura sirve para extraer uno a uno los elementos del
array o de la colección para que el bloque de código pueda manipularlos. Por supuesto
hace falta que el tipo de la variable sea compatible con el tipo de los elementos
almacenados en el array o la colección.

Se debe declarar la variable obligatoriamente en la estructura for y no en el exterior. Sólo

se podrá utilizar en el interior de la estructura. Por lo contrario, no tenemos que
preocuparnos del número de elementos porque la estructura es capaz de gestionar por sí
misma el desplazamiento en el array o la colección.

Ejemplo, se define un array con cuatro colores y se pide mostrarlos en pantalla, con un
bucle for clásico y con un bucle for de iteración.

Con un bucle clásico:

String[] array={"rojo","verde","azul","blanco"};

for (int cpt = 0; cpt < [Link]; cpt++)

{
[Link](array[cpt]);
}

Con el bucle for de iteración:

String[] array={"rojo","verde","azul","blanco"};

for (String s: array)

{
[Link](s);
}

Página 31
 Instrucciones básicas Java

Instrucción break

La sentencia break ya ha aparecido asociada a la sentencia switch. También puede

emplearse en el interior de sentencias cíclicas. En todos los casos, transfiere el control al
final del ciclo while, do while, for o sentencia switch más interna en la que se encuentra.

Ejecutar esta sentencia sin incluirla en ninguna condición es altamente desaconsejable, y

si va asociada a una condición, siempre podremos encontrar una alternativa en la que se
pueda conseguir el mismo efecto sin usar break, por el procedimiento de incorporar la
condición que controla el break a la condición de salida del bucle.

Por ejemplo, ante una construcción del tipo:

while (condicion1)
{
sentencia1;
for ( ; ; ) // Bucle infinito
{
sentencia2;
if (condicion2)
{
sentencia3;
……
}
else break; // Forzamos la salida del bucle
}
sentencia4;
……
}

Tenemos una alternativa más clara, sin falta de usar break

while (condicion1)
{
sentencia1;
for ( ;condicion2; ) // Mientras condicion2 sea cierta
{
sentencia2;
if (condicion2)
{
sentencia3;
……
}
}
sentencia4;
}

Página 32
 Instrucciones básicas Java

Y otra aún más clara:

while (condicion1)
{
sentencia1;
while (condicion2) // Mientras condicion2 sea cierta
{
sentencia2;
if (condicion2)
{
sentencia3;
……
}
}
sentencia4;
}

Esta instrucción, si bien se utiliza, no es aconsejable utilizarla, pues hace el código menos
comprensible.

Instrucción continue

La sentencia continue también se usa para alterar el flujo normal de ejecución en las
sentencias repetitivas while , do while y for, pero no se puede usar con switch).

En el caso de continue, lo que hace es devolver el control al bucle que se interrumpe, y

que será el más interno, el que contiene la sentencia.

De nuevo nos encontramos ante una instrucción desaconsejable y siempre podremos

encontrar una alternativa en la que se pueda conseguir el mismo efecto

Por ejemplo, ante una construcción del tipo:

while (condicion1)
{
sentencia1;
while (condicion2)
{
sentencia2;
if (condicion3)
{
sentencia3;
…..
}
else continue;
sentencia4;
}
}

Tenemos una alternativa más clara, sin falta de usar continue

Página 33
 Instrucciones básicas Java

while (condicion1)
{
sentencia1;
while (condicion2)
{
sentencia2;
if (condicion3)
{
sentencia3;
sentencia4;
}
}
}

Esta instrucción, si bien se utiliza, no es aconsejable utilizarla, pues hace el código menos
comprensible.

Instrucción continue con etiquetas

Pudiera ser que el bucle que queremos interrumpir no es el más interno, sino un bucle
más externo que está más “alejado” de la sentencia break o continue. En ese caso,
podemos indicar el lugar al que queremos transferir el control, mediante el uso de
etiquetas.

Supongamos que en el ejemplo anterior el continue debe devolver el control al principio

del bucle correspondiente a while (condicion1), que no es el que contiene la sentencia
continue, si no el más externo. Podemos conseguir esto de la siguiente forma:

bucleExterno:
while (condicion1)
{
sentencia1;
while (condicion2)
{
sentencia2;
if (condicion3)
{
sentencia3;
….
}
else
{
continue bucleExterno;
}
sentencia4;
}
}

Donde bucleExterno: es una etiqueta que colocamos en el lugar al que queremos

transferir el control, justo delante del comienzo del bucle más externo.

Página 34
 Instrucciones básicas Java

Lo mismo puede hacerse con la sentencia break. No obstante el uso de este tipo de
etiquetas, que permiten saltos del control del flujo hacia atrás y a zonas de código más
remotas, son altamente desaconsejables, por enturbiar la claridad del código, y
escasamente útiles.

Nota.- El uso de la instrucción continue con etiquetas está muy mal visto, muy pocos
casos justifican su uso, pues se dificulta el seguimiento del código. Debemos evitar usarla.

Instrucción return.

La sentencia return nos permite finalizar la ejecución de un método o función antes de

que termine. En realidad la sentencia return se usa con una doble finalidad:

Termina la ejecución del método en el que se encuentre, transfiriendo el control al

punto desde el que se hizo la llamada a ese método, continuando con la sentencia
posterior.

Si va acompañado de una expresión de un determinado tipo, hace que el método

devuelva un valor, es decir, que en el lugar donde se hizo la llamada al método,
esa llamada se sustituya por el valor resultante de evaluar la expresión que
acompaña al método.

Lo normal es que el return sea la última línea de un método, de forma que se cumpla el
principio de una entrada – una salida, pero también puede usarse en cualquier punto de
un método, y éste terminará en el mismo punto donde se ejecute ese return, incluso
podemos poner varios return en un mismo método.

A pesar de lo dicho anteriormente es aconsejable, por claridad del código, que sólo
aparezca un return al final de cada método.

Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe
el flujo normal de las sentencias.

Durante la ejecución de un programa, se pueden producir múltiples sucesos que generen

excepciones, por ejemplo, problemas de hardware, como la avería de un disco duro, una
división por cero, etc.

Cuando dicho error ocurre dentro de un método Java, el método crea un objeto
'exception' y lo maneja la máquina virtual Java. Este objeto contiene información sobre la
excepción, incluyendo su tipo y el estado del programa cuando ocurrió el error. Para el
tratamiento de la excepción, la máquina virtual Java busca en el método que generó el
error, una gestión de excepciones y luego, si no la encuentra, va subiendo por los
métodos llamadores hasta el método main de la aplicación, si es necesario. Cuando se
localiza un gestor de excepción adecuado, se le transmite el objeto Exception para que se
encargue de su tratamiento. Si la búsqueda no da resultado, la aplicación produce un
mensaje de error y se finaliza abruptamente el programa.

Página 35
 Instrucciones básicas Java

En la programación tradicional, la detección, el informe y el manejo de errores se

convierte en un código muy confuso.

Por ejemplo, supongamos que tenemos una función que lee un fichero completo dentro de
la memoria. A grandes rasgos, la función se podría parecer a esto.

publico vacio leerFichero (cadena nombreFichero)

{
abrir el fichero nombreFichero
determinar su tamaño;
asignar suficiente memoria;
leer el fichero a la memoria;
cerrar el fichero nombreFichero;
}

A primera vista esta función parece bastante sencilla, pero ignora todos aquellos errores
potenciales.

¿Qué sucede si no se puede abrir el fichero?

¿Qué sucede si no se puede determinar la longitud del fichero?
¿Qué sucede si no hay suficiente memoria libre?
¿Qué sucede si la lectura falla?
¿Qué sucede si no se puede cerrar el fichero?

Para responder a estas cuestiones dentro de la función, tendríamos que añadir mucho
código para la detección y el manejo de errores. El aspecto final de la función se parecería
esto.

publico entero odigodeError leerFichero (cadena nombreFichero)

{
Definir código de error

inicializar codigodeError = 0;
abrir el fichero nombreFichero
si (ficheroAbierto)
{
determinar la longitud del fichero;
si (obtenerLongitudDelFichero)
{
asignar suficiente memoria;
si (obtenerSuficienteMemoria)
{
leer el fichero a memoria;
si (falloDeLectura)
{
codigodeError = -1;
}
}
si no
{
codigodeError = -2;
}
}

Página 36
 Instrucciones básicas Java

si no
{
codigodeError = -3;
}

cerrar el fichero nombreFichero;

si (ficheroNoCerrado)
{
codigodeError = -4;
}
}
si no
{
codigodeError = --5;
}
return codigodeError;
}

Añadiendo la detección de errores, las 7 líneas originales se han convertido en un montón

de líneas de código y, lo que es peor, existe tantas líneas de detección, manejo de errores
y de retorno del código del error, que se pierde la claridad del código. Ni que decir tiene
que pasado un tiempo, modificar este código puede hacer que perdamos mucho tiempo,
analizando lo que hace, y eso que sólo tiene 7 líneas de código, el resto son de
tratamiento de errores.

Java proporciona una solución elegante al problema del tratamiento de errores: las
excepciones. Las excepciones le permiten escribir el flujo principal de su código y tratar
los casos excepcionales en otro lugar. Si la función leerFcihero utilizara excepciones en
lugar de las técnicas de manejo de errores tradicionales se podría parecer a esto.

publico entero odigodeError leerFichero (cadena nombreFichero)

{
try
{
abrir el fichero nombreFichero;
determinar su tamaño;
asignar suficiente memoria;
leer el fichero a la memoria;
abrir el fichero nombreFichero
}
catch (falloAbrirFichero)
{
retornar -6
}
catch (falloDeterminacionTamaño)
{
retornar -5
}
catch (falloAsignaciondeMemoria)
{
retornar -2
}

Página 37
 Instrucciones básicas Java

catch (falloLectura)
{
retornar -1
}
catch (falloCerrarFichero)
{
retornar -4
}
}

Ahora el código es más legible. Las excepciones no evitan el esfuerzo de hacer el trabajo
de detectar, informar y manejar errores. Lo que proporcionan las excepciones es la
posibilidad de separar los detalles oscuros de qué hacer cuando ocurre algo fuera de la
normal.

Otra ventaja de las excepciones es la posibilidad del propagar el error encontrado sobre la
pila de llamadas a métodos. Supongamos que el método leerFichero es el cuarto método
en una serie de llamadas a métodos anidadas realizadas por un programa principal:
metodo1 llama a metodo2, que llama a metodo3, que finalmente llama a leerFichero.

(…) metodo1 (..)

{
….
metodo2(….);
}
(…) metodo2 (…)
{
….
Metodo3(….);
}
(…) metodo3 (…)
{
….
leerFichero(….);
}

Supongamos también que metodo1 es el único método interesado en el error que ocurre
dentro de leerFichero. Tradicionalmente las técnicas de notificación del error forzarían a
metodo2 y metodo3 a propagar el código de error devuelto por leerFichero sobre la pila
de llamadas hasta que el código de error llegue finalmente a metodo1 -- el único método
que está interesado en él.

El sistema de gestión de excepciones de Java permite buscar hacia atrás, en la pila de

llamadas para encontrar cualquier método que esté interesado en manejar una excepción
particular, de tal forma que un método Java puede "esquivar" cualquier excepción lanzada
dentro de él, y encomendar su tratamiento a los métodos que están por encima de él, de
esta forma, sólo los métodos interesados en el error, deben preocuparse de detectarlo.

Página 38
 Instrucciones básicas Java

(…) metodo1 (…)

{
try
{
metodo2 (…);
}
catch (excepcion)
{
procesodelError;
}
}

(…) metodo2 (…) throws excepción

{
metodo3 (…);
}

(…) metodo3 (…) throws excepcion

{
leerFichero (…);
}

En el ejemplo vemos que el método3, no realiza el tratamiento de la excepción e informa

a su llamador sobre las excepciones que se pudieron lanzar, lo cual se especifica con
throws excepción después de los parámetros del método. Este mismo proceso lo realiza el método2
y es el método 1 el que realiza el tratamiento de la excepción.

De nuevo el código es más compacto y más fácil de entender.

La orden que nos permite tratar las excepciones es la orden try-catch. Asociada a estas
está finally, que es opcional.

Con la orden try protegemos un bloque de código contra las excepciones que podrían
introducirse en él. El código "peligroso" debe ser ubicado en un bloque try. Si una
excepción se activa en este bloque de código, se examina el bloque, o bloques catch
(puede haber más de uno) hasta encontrar uno capaz de tratar la excepción y ejecuta el
código que hayamos escrito. Si no hubiera ninguno, se propagará la excepción hacia los
métodos llamadores.

Asociada a la instrucción try-catch, está la instrucción finally. Esta instrucción, que es

opcional, permite marcar un grupo de instrucciones que serán ejecutadas ya sea a la
salida del bloque try, si no se produjo ninguna excepción, o a la salida de un bloque catch,
si se activó una excepción.

try
{
...
// Instrucciones peligrosas
...
}

Página 39
 Instrucciones básicas Java

catch (tipoExcepción1 error1)

{
// Código ejecutado si se produce una excepción de tipoExcepción1
...
}
catch (tipoExcepción2 error2)
{
// Código ejecutado si se produce una excepción de tipoExcepción2
...
}
finally
{
// código ejecutado en todo caso después de la salida del bloque try o catch
...
}

En el bloque catch, podemos tratar excepciones concretas y poner una entrada para un
tipo genérico (Exception). La idea es parecida a la instrucción switch, con la opción
default, por eso pondremos siempre el tratamiento desde los tipos más concretos hasta
los más generales.

El código de cada bloque catch puede obtener más información sobre la excepción que
debe tratar utilizando los métodos disponibles en la clase correspondiente a la excepción,
entre los que vamos a destacar getMessage, que permite obtener el mensaje de error
asociado a la excepción.

import [Link].*;

public class Excepcion

{
public static void main(String[] args)
{
int numerador, denominador, cociente;
byte resto;
Scanner teclado=new Scanner([Link]);

try
{
[Link]("Introduzca el numerador: ");
numerador = [Link]();

[Link]("Introduzca el denominador: ");

denominador = [Link]();

cociente = numerador/(denominador);
[Link]("El cociente es "+cociente);
}
catch (ArithmeticException error)
{
[Link]("El denominador no puede ser cero. Error: "+[Link]());
}
catch (InputMismatchException error)
{
[Link]("Los datos deben ser enteros. Error: "+[Link]());
}
catch (Exception error)
{
[Link]("Error: "+[Link]());
}
}
}

Página 40
 Instrucciones básicas Java

Un bloque catch puede gestionar varios tipos de excepciones y para ello, los distintos
tipos de excepciones que puede procesar deben indicarse en el paréntesis, separándolos
mediante el carácter |.

catch (ArithmeticException | InputMismatchException error)

{
[Link]("Los datos deben ser numéricos y el denominador no puede ser cero.
Error: "+[Link]());
}

Página 41
 Instrucciones básicas Java

También podemos utilizar la instrucción throw para lanzar una excepción.

import [Link].*;

public class Excepcion

{
public static void main(String[] args)
{
int numerador, denominador, cociente;
byte resto;
Scanner teclado=new Scanner([Link]);

try
{
[Link]("Introduzca el numerador: ");
numerador = [Link]();

[Link]("Introduzca el denominador: ");

denominador = [Link]();
if (denominador==0)
throw new ArithmeticException();

cociente = numerador/(denominador);
[Link]("El cociente es "+cociente);
}

catch (ArithmeticException | InputMismatchException error)

{
[Link]("Los datos deben ser numéricos y el denominador no puede ser
cero. Error: "+[Link]());
}
}
}

Dado que las excepciones son clases, podemos crear nuestra clase excepción y utilizar un
mecanismo de herencia, para que herede de la clase Exception. E este caso se
recomienda que el nombre de la clase con el término Excepcion.

Una vez hecho esto podemos crear objetos de la clase y activar una excepción con la
palabra reservada throw. La activación de una excepción en una función con la palabra
clave throw provoca la salida inmediata de la función.

class MisExcepciones extends Exception

{
String mensaje;
public MisExcepciones(String msg)
{
mensaje = msg;
}
String mensaje (String mensaje)
{
return mensaje;
}
}

import [Link].*;

Página 42
 Instrucciones básicas Java

public class Excepcion

{
public static void main(String[] args)
{
int numerador, denominador, cociente;
byte resto;
Scanner teclado=new Scanner([Link]);

try
{
[Link]("Introduzca el numerador: ");
numerador = [Link]();

[Link]("Introduzca el denominador: ");

denominador = [Link]();
if (denominador==0)
throw new MisExcepciones("No se puede dividir por cero");

cociente = numerador/(denominador);
[Link]("El cociente es "+cociente);
}
catch (MisExcepciones error)
{
[Link]("Error: "+[Link]);
}
}
}

Frecuentemente un programa necesitará obtener datos desde un origen, por ejemplo

desde el teclado, y para enviar información a un destino, como puede ser mostrar datos
en la pantalla.

El intercambio de información entre el origen y el destino se realiza mediante un flujo de

información (stream en inglés). Un flujo de información es un objeto que hace de
intermediario entre el programa y el origen/destino de la información.

Un programa leerá o escribirá en el flujo, sin importarle desde donde viene la información
o a dónde va. Tampoco le importa el tipo de los datos que se leen o se escriben.

El nivel de abstracción del lenguaje hace que el programa no tenga que saber nada de las
características del dispositivo, ni del tipo de dato que se envía, lo que se traduce en una
facilidad más, a la hora de escribir los programas. Java utiliza este concepto y para ello
modela flujos mediante clases del paquete [Link].

Dado que los flujos de datos son objeto de estudio posteriormente, nos limitaremos a ver
cómo podemos capturar datos del teclado y cómo mostrar resultados en pantalla.

Página 43
 Instrucciones básicas Java

Una primera posibilidad es utilizar [Link]. Este objeto pertenece a la clase

InputStream, esto significa que para leer tenemos que emplear sus métodos, el más
básico es read, que permite leer un carácter:

char caracter = (char) [Link]();

Este método sólo permite leer una letra, y por ello, si queremos leer una cadena de
caracteres, emplearemos lo siguiente:

En primer lugar realizaremos la declaración siguiente:

BufferedReader br = new BufferedReader(new InputStreamReader([Link]));

A partir de ahí, podemos realizar una llamada al método readLine que leerá cadenas de
caracteres, hasta que el usuario pulse la tecla <Entrar>

String línea = [Link]();

Para poder emplear esta lectura, es necesario realizar un import de [Link]

Un problema es que la línea del readLine puede lanzar Excepciones, y por ello debemos
encerrarla entre instrucciones try/catch para poder gestionar el posible error.

InputStreamReader teclado = new InputStreamReader([Link]);

BufferedReader br = new BufferedReader(teclado);

String línea;

try
{
línea = [Link]();
}
catch(Exception e)
{
[Link]();
}

[Link](línea);

Ahora bien, si lo que queremos es leer un número del teclado, debemos capturar ese
número como cadena de caracteres y luego realizar la conversión.

Si el usuario escribe por ejemplo 123, con la clase BufferedReader obtendremos un String
que contiene "123", es decir, tres caracteres. Ahora, para convertir el String en un
número entero (sin decimales), podemos usar la clase Integer, para convertir un String a
int, siempre que sea posible.

La clase Integer es muy estricta. Para convertir el String a int necesita que el String sea
exactamente un int. Cualquier carácter o letra que tenga el String y no valga, hará que la
conversión falle o que no sea correcta.

Página 44
 Instrucciones básicas Java

Para realizar la conversión haremos uso del método parseInt.

int valor = [Link](texto);

Si la conversión es posible guarda el resultado de la conversión en una variable entera

llamada valor. Cada tipo de dato numérico tiene su método parse.

import [Link].*;

public class suma

{
public static void main (String [] args)
{
InputStreamReader miTeclado = new InputStreamReader([Link]);
BufferedReader br = new BufferedReader (miTeclado);
int n1, n2, suma;

try
{
[Link]("Introduzca un primer numero : ");
n1 = [Link]([Link]());

[Link]("Introduzca un segundo numero : ");

n2 = [Link]([Link]());

suma=n1+n2;
[Link] ("La suma " +n1 + " + " + n2 +" = "+ suma);
}
catch (Exception e)
{
[Link]();
}
}
}

Una segunda posibilidad es utilizar la clase Scanner, que se introdujo a partir de la

versión 5 de java.

La clase Scanner permite crear objetos capaces de leer información desde una fuente de
datos que puede ser un archivo, una cadena de caracteres, el teclado, etc. y para poder
utilizarla es necesario importarla.

import [Link];

Vamos a ver su funcionamiento a través de un ejemplo: Pediremos un texto por teclado y

lo mostraremos por pantalla:

import [Link];
class Ejemplo
{
public static void main(String arg[])
{
String variableString;
Scanner entrada=new Scanner([Link]);

Página 45
 Instrucciones básicas Java

[Link]("Introduzca un texto: ");

variableString = [Link]();

[Link]("Texto ingresado: "+variableString);

}
}

En el código anterior se importa la clase Scanner, posteriormente se declara una instancia

de la misma llamada "entrada" y se inicializa pasando como parámetro un objeto
InputStream, el cual es devuelto por la clase System con ayuda de su método in.

Luego vemos como se imprime el aviso correspondiente del tipo de datos que se va a
pedir y se guarda todo lo que se teclee (hasta que se pulse la tecla <Entrar>) en la
variable "variableString”, para lo cual se utiliza el método next(). Es importante señalar
que el método next() no admite espacios en blanco, considerando el espacio como el final
del texto. Por ello, si queremos capturar varias palabras haremos uso del método
nextLine().

De la misma forma que es posible capturar un dato de tipo String, con el método next(),
es posible capturar otros tipos de datos. Así, dependiendo del tipo de dato al que
corresponda la información que se va a capturar tendremos, para los tipos de datos más
importantes:

Para el tipo byte: nextByte( )

Para el tipo short nextShort( )
Para el tipo float: nextFloat( )
Para el tipo double: nextDouble()
Para el tipo long: nextLong( )
Para el tipo String: nextLine( )

Con Scanner podemos introducir varios datos en una sola línea o en varias sin importar el
tipo de datos que introduzcamos, de tal manera que se pueden colocar números y
cadenas, separándolos por un espacio en blanco y luego hacer la correcta asignación.

Por ejemplo si queremos sumar dos números, podemos escribir en una sola línea “2 3” y
para que el programa separe la entrada en dos variables lo escribimos de la forma
siguiente:

import [Link];

public class Ejemplo

{
public static void main(String[] args)
{
Scanner teclado=new Scanner([Link]);
int n1, n2;

[Link]("Teclee dos números separados por un espacio");

n1=[Link]();
n2=[Link]();

[Link]("n1 = "+n1+ " n2 = "+n2);

}
}

Página 46
 Instrucciones básicas Java

Pero cuidado, que esto puede producir errores inesperados.

import [Link];

public class Ejemplo

{
public static void main(String[] args)
{
Scanner teclado=new Scanner([Link]);
String nombre;
int edad;

[Link]("Teclee el nombre:");
nombre=[Link]();

[Link]("Teclee la edad:");
edad=[Link]();

[Link]("Su nombre es "+nombre+ "su edad es "+edad);

}
}

Si el usuario teclea un nombre, sin espacios en blanco, y un número para la edad, el

programa funcionará correctamente, pero si teclea un nombre con espacios en blanco
(por ejemplo José Antonio) el programa romperá, pues José se almacena de forma
correcta en nombre, pero Antonio se reserva para la siguiente captura, que es un dato
que se espera sea numérico.

También hay que tener cuidado con el funcionamiento de la clase Scanner, puesto que al
utilizar un buffer de lectura, donde va acumulando los caracteres leídos del teclado, es
posible que en el buffer, tras una lectura, queden caracteres pendientes de leer y, en ese
caso, en la lectura siguiente que se haga se asignará directamente esos caracteres
pendientes, sin esperar a que el usuario teclee sus datos. Consideremos el código
siguiente:

import [Link];

public class pruebas

{
public static void main(String[] args)
{
Scanner teclado=new Scanner([Link]);
String nombre;
int edad;

[Link]("Teclee la edad: ");

edad=[Link]();

[Link]("Teclee el nombre: ");

nombre=[Link]();

[Link]("Su nombre es "+ nombre + " su edad es "+edad);

}
}

Página 47
 Instrucciones básicas Java

La ejecución del programa sería:

En este caso, tras la lectura de la edad, queda un retorno de carro en el buffer de lectura
y dado, que el carácter que queda es compatible con la lectura siguiente, el ordenador en
la línea siguiente asume que el usuario ha pulsado intro directamente, por lo que el
usuario no puede teclear el nombre, en la línea nombre=[Link]();

Cuando esto nos ocurra, debemos vaciar el buffer de lectura, utilizando una falsa captura
de datos.

import [Link];

public class pruebas

{
public static void main(String[] args)
{
Scanner teclado=new Scanner([Link]);
String nombre;
int edad;

[Link]("Teclee la edad: ");

edad=[Link]();

// Vaciamos el buffer de lectura

[Link]();

[Link]("Teclee el nombre: ");

nombre=[Link]();

[Link]("Su nombre es "+ nombre + " su edad es "+edad);

}
}

Ahora la ejecución del programa es correcta.

Página 48
 Instrucciones básicas Java

Una tercera posibilidad es crear nuestra propia clase, donde podamos establecer, por
código, todas las características que queramos.

// Clase para facilitar las capturas de datos por teclado

import [Link].*;

public class Entrada

{
static String inicializar()
{
String buzon;
InputStreamReader flujo = new InputStreamReader([Link]);
BufferedReader miTeclado = new BufferedReader(flujo);

try
{
buzon=[Link]();
}
catch (Exception e)
{

}
return buzon;
}

static int entero()

{
int valor=[Link](inicializar());
return valor;
}

static double real()

{
double valor=[Link](inicializar());
return valor;
}

static String cadena()

{
String valor= inicializar();
return valor;
}

static char caracter()

{
String valor= inicializar();
return [Link](0);
}
}

Página 49
 Instrucciones básicas Java

import [Link];
public class Ejemplo
{
public static void main(String[] args)
{
int numeroUsuario;

// Nos protegemos de los errores del usuario en el teclado

try
{
// Pedimos datos al usuario. Utilizamos la clase creada
[Link]("Introduzca un número ");
numeroUsuario=[Link]();

[Link]("El número es "+numeroUsuario);

}
catch (Exception e) // Si se produce una excepción se ejecuta esta parte
{
[Link]("Error. El dato debe ser numérico entero");
}
}
}

La salida de datos en modo texto se puede hacer en Java fácilmente a través del método
println() de [Link].

[Link]("El que sabe no habla, el que habla no sabe");

Esta sentencia hace que aparezca por pantalla la secuencia de caracteres escrita entre
comillas. Esta instrucción es tan flexible que nos permite igualmente escribir enteros,
reales, caracteres, etc.

[Link](124); Salida por pantalla: 124

[Link]('a'); Salida por pantalla: a
[Link](1.618033); Salida por pantalla: 1.618033

En lugar de escribir la secuencia de caracteres directamente, también nos puede interesar

mostrar el valor contenido en una variable, cuyo identificador no debe ir entrecomillado.

[Link] (area);

Si queremos que una instrucción nos muestre varios literales o valores de variables,
utilizaremos el símbolo + .

Un aspecto a considerar es que [Link]() termina con un salto de línea tras

escribir en la pantalla. Si no queremos realizar ese salto de línea, debemos usar
[Link](), La única diferencia entre uno y otro es que este último no tiene 'ln' al
final. Por ejemplo, las dos líneas siguientes son equivalentes:

[Link]("Hola Mundo");
[Link]("Hola Mundo \n");

Página 50
 Instrucciones básicas Java

Un aspecto importante a la hora de mostrar datos, es el formato en que los vamos a

mostrar. A partir de la versión 5 de Java, se introdujo el método printf, que permite
formatear la salida.

El método printf nos permite dar a la salida en consola un formato específico, se comporta
de manera similar a print pero te permite especificar, por ejemplo, la cantidad de
números que deseas obtener tras el punto decimal.

Un ejemplo sería el siguiente:

double total = 13.7;

[Link]("$");
[Link]("%6.2f",total);
[Link](" a pagar");

El código anterior muestra en consola: $ 13.70 a pagar

Al utilizar el método printf debemos especificar primeramente el formato que se aplicará

(dentro de comillas dobles) y posteriormente el objeto, variable o cantidad a formatear.

Desglosando el caso que tomamos por ejemplo obtenemos que:

"%6.2f" -> es el formato a aplicar

total -> es la variable cuyo valor deseamos formatear

Ahora analicemos el formato:

% -> indica que a partir de ahí encontraremos un especificador de formato.
6 -> indica la cantidad de espacios en total que ocupará la cantidad formateada.
.2 -> indica la cantidad de números tras el punto decimal.
f -> indica que la cantidad es de punto flotante

Dado que en el ejemplo anterior especificamos que los espacios a ocupar serían 6, la
salida con formato es así " 13.70", es decir, se agrega un espacio al inicio para completar
los 6 que indicamos.

Si quisiéramos imprimir la salida anterior completa en una sola sentencia podríamos

hacerlo de la siguiente manera:

[Link]("$%6.2f a pagar",total);

La salida sería así: $ 13.70 a pagar

Cabe mencionar que los argumentos del formato (en este caso el 6 y el .2) son
opcionales, puedes omitir cualquiera de los dos o ambos.

Veamos otro ejemplo:

double n = 123.4567;
[Link]("El cuadrado de %1$f es %2$.2f\n", n, n*n);

Página 51
 Instrucciones básicas Java

La salida es: El cuadrado de 123,456700 es 15241,56

Especificadores de formato:

%[posición_dato$][indicador_de_formato][ancho][.precision]carácter_de_conversión

Los elementos entre corchetes son opcionales.

posición_dato: indica la posición del dato sobre el que se va aplicar el formato. El primero
por la izquierda ocupa la posición 1.

indicador_de_formato: es el conjunto de caracteres que determina el formato de salida.

Los indicadores de formato de printf en Java son:

ancho: Indica el tamaño mínimo, medido en número de caracteres, que debe ocupar el
dato en pantalla.

.precision: Indica el número de decimales que serán representados. Solo aplicable a datos
de tipo float o double.

carácter_de_conversión: Carácter que indica cómo tiene que ser formateado el dato. Los
más utilizados se muestran en la tabla.

Página 52
 Instrucciones básicas Java

Ejemplos de printf en Java:

Mostrar el contenido de una variable precio, de tipo double, en un ancho de campo de

10 caracteres y con dos decimales.

double precio = 1.22;

[Link]("%10.2f", precio);

Salida: bbbbbb1.22 (NOTA.- el carácter b indica un espacio en blanco)

El número ocupa un espacio total de 10 caracteres incluyendo el punto y los dos

decimales.

mostrar la cadena "Total:" con un ancho de 10 caracteres y alineada a la izquierda:

[Link]("%-10s", "Total:");

Salida: Total:bbbb

Mostrar la cadena "Total:" con un ancho de 10 caracteres y alineada a la derecha:

[Link]("%10s", "Total:");

Salida: bbbbTotal:

Mostrar la salida del programa siguiente:

public static void main(String[] args)

{
double q = 1.0/3.0;

[Link] ("1.0/3.0 = %5.3f /n", q);

[Link] ("1.0/3.0 = %7.5f /n", q);

q = 1.0/2.0;

[Link] ("1.0/2.0 = %09.3f /n", q);

q = 1000.0/3.0;
[Link] ("1000/3.0 = %7.1e h /n", q);

q = 3.0/4567.0;
[Link] ("3.0/4567.0 = %7.3e /n", q);

q = -1.0/0.0;
[Link] ("-1.0/0.0 = %7.2e /n", q);

q = 0.0/0.0;
[Link] ("0.0/0.0 = %5.2e /n", q);
[Link] ("pi = %5.3f, e = %10.4f /n", [Link], Math.E);

double r = 1.1;
[Link] ("C = 2 * %1$5.5f * %2$4.1f, "+"A = %2$4.1f * %2$4.1f * %1$5.5f
/n",[Link], r);
}

Página 53
 Instrucciones básicas Java

Los métodos (también llamados funciones por tradición de los lenguajes estructurados)
son la base de la programación en Java. Los métodos pertenecen a las clases.

Básicamente se trata de un grupo de instrucciones ordenadas, que se ejecuta para llevar

a cabo una tarea concreta y al que se le da un nombre para invocarlo, cuando sea
necesario, desde cualquier parte del programa y sería como evitar reescribir un trozo del
código cada vez que se quiera utilizar en un programa.

Cualquier llamada a un método es una indicación al compilador, para que sustituya esa
llamada por todas las instrucciones que contiene ese método en su definición, y que las
ejecute. Por tanto, añadir punto y coma a una llamada a un método es una sentencia en
Java, e indica claramente una tarea a realizar. A su vez, un método puede llamar a otros
métodos.

Algunos de esos métodos o funciones los podemos definir nosotros mismos, y otros nos
los proporciona el propio lenguaje. Éste es el caso del método println(). Este método nos
lo proporciona Java, pero para llamarlo, tenemos que hacerlo a través del objeto out de la
clase System, que representa el dispositivo de salida estándar, y que suele ser la pantalla.

Si un conjunto de sentencias quiero ejecutarlas frecuentemente en un programa, lo mejor

es agrupar todas esas sentencias en un método y llamar al método desde cualquier parte
que necesite la ejecución de las sentencias que contiene.

Pero además, puedo mejorar la versatilidad de mi programa, si para cada ejecución puedo
indicar de alguna forma que tenga en cuenta algunos datos en la ejecución de esas
sentencias, de manera que:

El resultado de la ejecución de cada llamada no va a ser siempre el mismo, sino que

va a depender de los parámetros que le hayamos suministrado.
Y ese resultado, puede ser la devolución de un valor, del tipo que sea, de forma que
además de ejecutar las sentencias,
La llamada puede incluirse en cualquier expresión, y será sustituida por el valor
devuelto tras la ejecución del método, como si fuera una función en medio de una
expresión matemática.

Una cuestión importante es que cuando un método termina de ejecutarse, todas las
variables locales que usa o que haya declarado se borran de la memoria.

Página 54
 Instrucciones básicas Java

Cuando escribimos un método, tendremos que definir las siguientes partes:

Accesibilidad del Método

Tipo de dato que se devuelve
Un Nombre para el método
Una lista de parámetros
Un cuerpo para el método

La accesibilidad de un método define la forma en que los objetos van a poder acceder al
método. El lenguaje Java permite los siguientes ámbitos:

private: indica que el método sólo puede ser usado en la clase donde está definido.

protected: indica que sólo se puede utilizar el método en la clase donde está
definido, en las subclases de esta clase y en las otras clases que forman parte del
mismo paquete.

public: indica que se puede utilizar el método desde cualquier otra clase, sin más
que tener un objeto de esa clase.

static: indica que el método es un método de clase. Puede ser accedido sin tener un
objeto de esa clase.

abstract: indica que el método es abstracto y que no contiene código. La clase

donde está definido también debe ser abstracta.

final: indica que el método no puede ser sobrescrito en una subclase.

native: indica que el código del método se encuentra en un fichero externo escrito
en otro lenguaje.

synchronized: indica que el método sólo puede ser ejecutado por un único hilo de
ejecución a la vez.

En la definición de cualquier método siempre hay que indicar el tipo de dato que
devuelve. Pero es posible que no se necesite que el método devuelva nada, por ejemplo,
cuando un método sólo tiene que escribir un mensaje en pantalla. En este caso, se debe
indicar que el método devuelve el tipo “vacío”. Esto se indica con la palabra reservada
void.

Todos lo métodos tienen que tener un nombre, es el nombre del método. Ese nombre es
un identificador, que debe seguir las reglas ya señaladas y, aunque se puede utlilizar el
identificador que quiera, se recomienda comenzar por mayúscula los métodos públicos.

Página 55
 Instrucciones básicas Java

Los parámetros que se pasan en la llamada son variables locales al método, en las que se
copian los valores pasados en la llamada. Por tanto, para los tipos primitivos, las
modificaciones sobre ellos no se ven desde fuera del método. Si alguna de ellas tiene
información que necesito, debo declararla como variable global, o devolverla como valor
de retorno del método.

Sin embargo, con los objetos la cosa cambia. Si paso un objeto como parámetro lo que
realmente estoy pasando es la referencia. En el parámetro local se hace una copia del
valor de la referencia. Pero ese valor no es más que la dirección de memoria en la que
está el objeto real, por lo que el método trabajará con el objeto real.

Los parámetros son los que permiten que el método no se ejecute exactamente igual cada
vez. Es la forma de “particularizar” cada ejecución. De momento podemos decir que los
parámetros son valores o variables que se indican entre paréntesis en la definición y en la
llamada a un método. Los parámetros se utilizan en el cuerpo del método para llevar a
cabo las tareas programadas en el mismo, e influyen directamente en el resultado de
ejecutar dicho método, por ejemplo en el valor devuelto (cuando se trate de este caso).

En muchos lenguajes existen dos formas de pasar variables como parámetros a un

método:

Paso de parámetros por valor. Al método se le pasa el valor de la variable (una

especie de copia), de forma que todas las operaciones o modificaciones que se
hacen sobre el parámetro dentro del método se pierden cuando termina la
ejecución del método, no se ven desde fuera. Es la forma en que se pasan los
parámetros en Java para tipos de datos primitivos.

Paso de parámetros por referencia. Al método se le pasa la dirección de memoria

donde está el objeto original (una copia de la referencia o dirección de memoria
donde se guarda el objeto), por lo que se trabaja con el objeto en sí y cualquier
modificación se hace sobre el objeto original. Cuando el método termina, se borra
la copia de la referencia que se pasó como parámetro, pero la referencia original
sigue apuntando al objeto sobre el que ha trabajado el método. Ésta es la forma en
que Java usa como parámetros todos los objetos o instancias de clase.

Tanto el tipo devuelto, como el nombre y la lista de parámetros que se le pasan

entre paréntesis, conforman el prototipo de un método. En la misma clase, no pueden
existir dos métodos que tengan el mismo prototipo, aunque si el mismo nombre

El prototipo de un método es lo que nos permite distinguirlo, y constituye su interfaz, la

forma de comunicarnos con él como usuarios programadores.

El cuerpo del método es el conjunto de instrucciones que resuelven el proceso asignado al

método. Este conjunto de instrucciones deben estar entre llaves. La llave de apertura va a
continuación de la lista de parámetros, o en la línea siguiente, y la llave de finalización es
la última línea del cuerpo del método.

Página 56
 Instrucciones básicas Java

public class programa

{
static int suma (int y, int x) // declaración de función con parámetros
{
return x + y; // cuerpo de la función
}

public static void main(String[] args) // función principal

{
int valora = 3;
int valorB= 5;

[Link]("la suma es : " + suma (valorA, valorB));

}
}

Todo programa Java comienza a ejecutarse por un método especial, es el método main.
Este método, que es especial, tiene la siguiente declaración

public static void main(String[]args)

Si nos fijamos en su declaración el método es public static, esto es, es un método público
y es estático, lo que quiere decir que no necesitamos tener ningún objeto de la clase en la
que está definido el método main, para poder acceder a él. Además no debe devolver
ningún valor y puede recibir una lista de parámetros, que son cadenas de caracteres,
separadas por espacios en blanco.

public static void main(String[] argumentos)

{
…
}

Trabajando con un entorno de desarrollo a menudo nos olvidamos de que un programa

java se puede ejecutar desde la línea de comandos del sistema operativo con la orden:

C:\> java nombrePrograma

Además, mediante esta orden, podemos enviar valores al programa. Estos valores reciben
el nombre de argumentos y van separados por un espacio en blanco.

C:\> java ordenar 4 6 3 7 1

Estos argumentos (args) son recogidos por el método main, a través de los parámetros
del main, que como dijimos, trata como una tabla de cadenas: String[] argumentos

Página 57
 Instrucciones básicas Java

Aunque se le suele dar el nombre args, no es obligatorio que este parámetro se llame así,
podemos darle el nombre que queramos.

La propiedad length de la tabla de argumentos contiene el número de valores enviados al

programa. Siempre que trabajemos con valores recibidos desde la línea de comandos
debemos controlar el número de valores recibidos para evitar que se produzcan errores al
procesar el array.

Ejemplo.- Programa llamado saludo que recibe desde la línea de comandos del sistema
operativo un nombre de persona y lo muestra por pantalla.

public class saludo

{
public static void main(String[] args)
{
if ([Link] > 1) // si hay más de 1 parámetro
{
[Link]("Hay demasiados parámetros”);
}
else
{
if ([Link] == 0) //si no hay parámetros
{
[Link]("Falta el nombre de la persona");
}
else
{
[Link]("Buenos Días " + args[0]);
}
}
}
}

Para ejecutarlo se debe escribir en la línea de comandos:

> java saludo Juan

La salida del programa sería en este caso:

Buenos Días Juan

Debemos tener en cuenta que todos los valores que se envían a main desde la línea de
comandos son de tipo String. Si uno de los parámetros introducido en la línea de
comandos es un número, el programa lo tratará como un String, por lo que para tratarlo
como número y poder operar matemáticamente con él habrá que hacer la conversión al
tipo numérico adecuado.

Página 58
 Instrucciones básicas Java

Los métodos pertenecen a las clases. Para poder llamar (invocar a un método) debemos
tener un objeto (una variable) que pertenezca a esa clase, salvo que sea estático. La
llamada entonces seguirá el formato siguiente:

[Link](<listaParamentros>);

class Ejemplo
{
int buscaMayor(int numero1, int numero2)
{
if (numero1 > numero2) return numero1;
else return numero2;
}

public static void main(String[] args)

{
Ejemplo miVariable=new Ejemplo(); //definición de variable de clase
int mayor;

mayor = [Link](3, 5);

[Link](mayor);
}
}

En el ejemplo, para llamar al métido buscaMayor, necesitamos tener un objeto y no lo

tenemos, pues la MVJ ha llamado al método main, que es estático, sin falta de definir un
objeto.

Veamos ahora el siguiente código:

class Ejemplo
{

int BuscaMayor(int numero1, int numero2)

{
if (numero1 > numero2) return numero1;
else return numero2;
}

public int CalculaMayor(int numero1, int numero2)

{
return BuscaMayor(numero1, numero2);
}

public static void main(String[] args)

{
Ejemplo miVariable=new Ejemplo(); //definición de variable de clase
int mayor;

mayor = [Link](3, 5);

[Link](mayor);
}
}

Página 59
 Instrucciones básicas Java

Podemos observar cómo para llamar al método CalculaMayor es necesario definir el

objeto, pero sin embargo desde el método CalculaMayor llamamos al método BuscaMayor,
sin hacerlo. Esto es debido a que el compilador, internamente, ya sabe que tiene un
objeto miVariable, que es el que está ejecutando el método. Ese objeto lo tiene guardado
en la variable this y realmente la llamada que está haciendo es:

public int CalculaMayor(int numero1, int numero2)

{
return [Link](numero1, numero2);
}

Recursividad es el proceso por el que algo se define en términos de sí mismo. Cuando se

aplica a lenguajes de programación, recursividad significa que un método se puede llamar
a sí mismo.

Un método se dice que es recursivo si en una sentencia del cuerpo de ese método se
llama a sí misma. Es importante señalar que los métodos recursivos siempre tienen que
tener un punto de salida, pues si no se estarán llamando a si mismos de forma infinita,
hasta consumir toda la memoria, provocando la ruptura del programa.

Java soporta recursividad, aunque no todos los lenguajes de programación lo hacen. En

este programa se muestra un ejemplo sencillo de recursividad:

public class progrecur

{
static void frecursiva (int i ) // función recursiva prototipo
{
if (i < 5) // condición de “finalización”
{
frecursiva (i+1); // llamada a la propia función desde la misma
[Link] ( i );
}
} // fin de la función recursiva

public static void main(String[] args)

{
frecursiva (0);
} // fin de la función principal
}

Este programa imprime 4 3 2 1 0 en la pantalla. Veamos su funcionamiento:

El método main() llama entonces a la función frecursiva, que recibe el valor 0 y

comienza su ejecución.

La función frecursiva analiza el valor recibido, y como es menor que cinco, entra
por la condición if y se llama a si misma pasándose el valor 1 (i+1) y dejando
pendiente escribir el valor de i (que es cero en ese momento).

Página 60
 Instrucciones básicas Java

Se repite el proceso sucesivamente, dejándose siempre pendiente el escribir un

valor en pantalla, el que toque según el valor que haya recibido la función.

Cuando la función recibe el valor cinco, no hace nada, porque no entra por el if y
acaba, retornando a quien la llamó, que si recordamos tenía pendiente escribir un
valor. Este proceso se repite hacía atrás sucesivamente hasta llegar a la función
principal.

Método main()
……
frecursiva (0)
}

Método recursiva(0)

recursiva (0+1)
[Link] ( i );

Método recursiva(1)

recursiva (1+1)
[Link] ( i );
}

Función recursiva(2)

recursiva (2+1)
[Link] ( i );
}

Método recursiva(3)

recursiva (3+1)
[Link] ( i );
}

Método recursiva(4)
{
if (i < 5)
{
frecursiva (i+1);
[Link] ( i );
}
}

Este tipo de recursividad se conoce con el nombre de recursividad directa. Existe otro tipo
de recursividad, conocida como recursividad indirecta, que consiste en que un método
llama a otro, que a su vez llama al primero. Tendrá, al menos, un punto de salida.

Página 61
 Instrucciones básicas Java

Ejemplo.- Se puede calcular si un número es par o impar de la forma siguiente: Dado un

número mayor que cero, llamamos, de forma alternativa, a un método (método par) y
desde aquí a llamamos a otro método (método impar) con un valor menos y repetimos el
proceso. Cuando el valor llegue a un método valiendo cero, ese método determinará si el
valor es par o impar.

class Ejemplo
{
static boolean Par(int n)
{
if (n == 0) return true;
else return Impar(n - 1);
}

static boolean Impar(int n)

{
if (n == 0) return false;
else return Par(n - 1);
}

public static void main(String[] args)

{
int n=12;

if (Par(n)) [Link](n+" es un numero par");

else [Link](n+" es un numero impar");
}
}

Página 62