Aprenda Java

Aprenda Java
Aprenda Java.
ISC Ral Oramas Bustillos.
roramas@gmail.com
Este obra est bajo una Licencia Creative Commons Atribucin-NoComercial 2.5 Mxico.
1
Aprenda Java
Descripcin del curso.
En este curso se estudian los fundamentos de programacin con Java a travs de ejemplos
prcticos. Con este curso aprenders las habilidades necesarias para desarrollar
aplicaciones a un nivel bsico-intermedio utilizando el lenguaje de programacin Java SE
(Standard Edition), versin 7.
Audiencia.
Este curso est dirigido a estudiantes, profesionistas, y desarrolladores de software que

desean conocer el lenguaje de programacin Java SE (Standard Edition), versin 7.
Requisitos.
Ninguna, ya que en este curso iniciamos desde los fundamentos bsicos del lenguaje.
Objetivos del curso.
Despus de completar este curso, sers capaz de:
Desarrollar y ejecutar programas Java SE (Standard Edition), versin 7.

Comprender los principios bsicos de la programacin con Java: estructura de
secuencia, seleccin, repeticin, programacin modular y arreglos.
Con los conceptos aprendidos en este curso se preparan las bases para aprender a
programar en objetos con Java.
2
Aprenda Java
Tabla de contenidos:
1. Introduccin a Java.........................................................................................................5
1.1. El lenguaje Java......................................................................................................5
1.2. Etapas de desarrollo de un programa en Java.......................................................5
1.3. Software para el desarrollo de programas en Java................................................6
1.4. Estructura bsica de un programa en Java............................................................6
1.5. Instrucciones bsicas para imprimir texto...............................................................8
2. Programas simples.......................................................................................................11
2.1. Escribir un programa simple..................................................................................11
2.2. Leer datos desde el teclado..................................................................................12
2.3. Identificadores.......................................................................................................15
2.4. Variables................................................................................................................16
2.5. Operador de asignacin y expresin de asignacin.............................................18
2.6. Constantes con nombre........................................................................................19
2.7. Tipos de datos primitivos.......................................................................................21
2.8. Operadores aritmticos.........................................................................................22
2.9. Literales en Java...................................................................................................24
2.10. La evaluacin de expresiones en Java...............................................................25
2.11. Operadores abreviados de incremento/decremento...........................................26
2.12. Conversin de tipo (type casting)........................................................................28
2.13. Ejercicios resueltos..............................................................................................31
3. Instrucciones de seleccin...........................................................................................42
3.1. Tipo de dato boolean.............................................................................................42
3.2. Operadores relacionales y de igualdad.................................................................42
3.3. La instruccin if simple..........................................................................................43
3.4. La instruccin if/else..............................................................................................46
3.5. Instrucciones if anidadas.......................................................................................49
3.6. La instruccin if/else/if...........................................................................................52
3.7. Operadores lgicos...............................................................................................54
3.8. El operador condicional (?:)...................................................................................58
3.9. La instruccin switch.............................................................................................59
4. Instrucciones de repeticin...........................................................................................73
4.1. Instruccin de repeticin while..............................................................................73
4.2. Ciclos controlados por un valor centinela.............................................................76
4.3. Ciclos infinitos........................................................................................................78
4.4. Instruccin de repeticin do/while.........................................................................79
4.5. Instruccin de repeticin for...................................................................................80
4.6. Ciclos anidados.....................................................................................................82
4.7. Instruccin break y continue..................................................................................83
4.8. Ejercicios resueltos................................................................................................86
5. Utilizacin de mtodos pre-construidos.......................................................................95
3
Aprenda Java
5.1. Mtodos de la clase Math......................................................................................95

5.2. Formateo de la salida............................................................................................97
5.3. Mtodos de la clase String....................................................................................99
5.4. Formateo de nmeros.........................................................................................100
6. Mtodos......................................................................................................................102
6.1. Programacin modular........................................................................................102
6.2. Mtodos void.......................................................................................................102
6.3. Mtodos void sin parmetros..............................................................................102
6.4. Mtodos void con parmetros.............................................................................104
6.5. Mtodos return.....................................................................................................105
6.6. Mtodos return sin parmetros...........................................................................106
6.7. Mtodos return con parmetros..........................................................................106
6.8. Compatibilidad de argumentos y parmetros.....................................................110
6.9. Mtodos sobrecargados (overload).....................................................................111
6.10. El mbito de las variables..................................................................................113
6.11. Ejercicios resueltos............................................................................................115
7. Arreglos unidimensionales.........................................................................................124
7.1. Declarar, crear y asignar valores a un arreglo unidimensional...........................124
7.2. Operaciones bsicas con arreglos unidimensionales.........................................127
7.3. Paso de arreglos unidimensionales a los mtodos.............................................131
7.4. Arreglos unidimensionales como valor de retorno..............................................132
7.5. Lista de argumentos de longitud variable...........................................................133
7.6. La clase Arrays....................................................................................................134
8. Arreglos bidimensionales...........................................................................................143
8.1. Declarar, crear y asignar valores a un arreglo bidimensional.............................143
8.2. Operaciones bsicas con arreglos bidimensionales...........................................146
8.3. Paso de arreglos bidimensionales a los mtodos...............................................151
9. Bibliografa consultada...............................................................................................159
4
Aprenda Java
1. Introduccin a Java.
Al finalizar esta leccin, sers capaz de:
Conocer las etapas de desarrollo de un programa Java.

Descargar e instalar el software para el desarrollo de programas Java.
Identificar la estructura bsica de un programa en Java.
Escribir programas simples en Java.
1.1. El lenguaje Java.
Java es un lenguaje de programacin orientado a objetos, desarrollado por Sun

Microsystems en la dcada de 1990. Moldeado en base a C++, el lenguaje Java se dise
para ser pequeo, sencillo y porttil a travs de plataformas y sistemas operativos.
En aos recientes la tecnologa de Java fue adquirida por la empresa Oracle (famosa por
su programa administrador de base de datos del mismo nombre).
En la actualidad Java es un lenguaje muy cotizado. Podemos comparar Java respecto a

otros lenguajes de programacin en la pgina Web:
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
1.2. Etapas de desarrollo de un programa en Java.
Para desarrollar un programa en Java tenemos que pasar por las siguientes etapas: edicin,
compilacin y ejecucin.
En la etapa de edicin, se escriben las instrucciones del programa usando el lenguaje Java y
se guarda en un archivo cuyo nombre debe terminar con la extensin .java. As, por
ejemplo, el archivo podra llamarse Saludo.java. A este programa escrito en Java se
denomina cdigo fuente y para escribirlo se puede recurrir a cualquier editor de texto.
En la etapa de compilacin, se traduce el cdigo fuente usando el compilador de Java, que

es un programa denominado javac.exe, con lo que se obtiene un nuevo cdigo conocido
como cdigo de bytes (bytecodes en ingls), que tiene el mismo nombre que el archivo de
cdigo fuente, pero con la extensin .class. As, si el archivo de cdigo fuente se denomina
Saludo.java, el cdigo de bytes quedar almacenado automticamente en un archivo
denominado Saludo.class.
En la etapa de ejecucin, el cdigo de bytes es ejecutado por la Mquina Virtual de Java

(JVM, por sus siglas en ingls). El cdigo de bytes es el lenguaje de la JVM. Existe una JVM
para cada plataforma (para cada sistema operativo); pero, todas las JVM pueden ejecutar el
mismo cdigo de bytes. As, el cdigo de bytes es independiente de la plataforma. Esto
5
Aprenda Java
hace que los programas Java puedan ser ejecutados en cualquier mquina que disponga de
una JVM. Actualmente, existe una JVM para la mayor parte de las plataformas, lo que
garantiza que los programas Java sean ampliamente portables.
1.3. Software para el desarrollo de programas en Java.
Para el desarrollo de programas Java es necesario descargar e instalar la Plataforma Java

en su edicin estndar que lo obtenemos de :
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Tambin necesitaremos un entorno de desarrollo integrado (IDE por sus siglas en ingls).
Entre los ms populares tenemos:
NetBeans: www.netbeans.og
Eclipse: www.eclipse.org
BlueJ: www.bluej.org.
1.4. Estructura bsica de un programa en Java.
Empezaremos el proceso de aprendizaje de Java definiendo la estructura bsica de un

programa en Java. El programa siguiente, HolaMundo.java, declara una clase.
public class HolaMundo {

}
Todo programa en Java consiste de, cuando menos una declaracin de clase: public
class HolaMundo. La palabra clave class introduce una declaracin de clase, la cual
debe ir seguida por el nombre de la clase.
Las palabras clave o palabras reservadas se reservan para uso exclusivo de Java y
siempre se escriben en minscula. El nombre de una clase es un identificador. Un
identificador es una serie de caracteres que pueden ser letras, dgitos, guiones bajos (_) y
signos de moneda ($) que no comience con un dgito ni tenga espacios.
Debemos de tener en cuenta que Java es sensible a maysculas y minsculas; es decir,

las letras maysculas y minsculas en un identificador son distintas.
Cada clase comienza con la palabra clave public. Al guardar este cdigo, el nombre de
ese archivo debe coincidir con el nombre de la clase. Por ejemplo: HolaMundo.java
Una llave izquierda {, comienza con el cuerpo de todas las declaraciones de clases. Su
correspondiente llave derecha }, debe terminar con la declaracin de una clase. A las llaves
{ y } se les conoce como bloque. Un bloque puede contener o anidar otros bloques.
6
Aprenda Java
Todo programa en Java debe de contener un mtodo principal al que se le denomina main.
Se dice entonces que una aplicacin en Java es un programa que contiene el mtodo main.
El programa siguiente, HolaMundo.java incorpora la definicin del mtodo main.

public static void main(String[] args) {
}
}
El mtodo main es el punto de inicio de toda aplicacin en Java. Los parntesis despus
del identificador main indican que este es un mtodo. La palabra clave void indica que
este mtodo realizar una tarea, pero no devolver ningn tipo de informacin cuando
complete su tarea. Las palabras String[] args entre parntesis son una parte requerida
de la declaracin del mtodo main.
La llave izquierda { comienza el cuerpo de la declaracin del mtodo y su correspondiente

llave derecha } debe terminar el cuerpo de esa declaracin.
Ya que tenemos la estructura bsica para crear aplicaciones en Java lo nico que falta es
agregar instrucciones para que el programa realice una o ms acciones. El programa
siguiente, HolaMundo.java, imprime un mensaje de texto en la consola de salida.
/*
Programa: HolaMundo.java
Propsito: Imprimir un mensaje en la consola de salida.
*/
// el mtodo main inicia la ejecucin del programa
System.out.println("Hola Mundo!");
} // fin del mtodo main
} // fin de la clase HolaMundo
Los comentarios ayudan a documentar un programa y mejorar su legibilidad. El

compilador de Java ignora estos comentarios. Un comentario que comienza con // se llama
comentario de fin de lnea (o de una sla lnea). Los comentarios tradicionales (o de
mltiples lneas) se distribuyen en varias lneas y comienza con el delimitador /* y termina
con */.
La lnea: System.out.println("Hola Mundo!"); es una instruccin. Todas las

instrucciones en Java termina con un punto y coma (;). Esta instruccin le indica a la
computadora que imprima la cadena de caracteres contenidas entre los caracteres de
comillas dobles (sin incluirlas). A una cadena tambin se le denomina cadena de
caracteres, mensaje o literal de cadena. System.out se conoce como objeto de salida
7
Aprenda Java
estndar. El mtodo println de System.out imprime una lnea de texto en la consola de

salida (ventana de comandos, lnea de comandos, shell, etc.). La cadena dentro de
parntesis es el argumento para el mtodo.
Al escribir los primeros programas en Java es comn cometer errores de sintaxis. Un error
de sintaxis es una violacin a las reglas del lenguaje. El programa siguiente,
HolaMundo.java, tiene errores de sintaxis por lo tanto no funcionar hasta que esos errores
hayan sido identificados y corregidos.
//No respetar la condicin mayscula/minscula

//Es comn escribir con maysculas: public, class, static, main, etc.
//Omitir los pares de { y }, ( y )
//Omitir el punto y coma
//Omitir los pares de comillas dobles y
Public class HolaMundo {
// el mtodo main inicia la ejecucin del programa
public static Void main(String[] args) {
system.out.println("Hola Mundo!);
} // fin de la clase HolaMundo
Para que el programa anterior funcione es necesario respetar la condicin de

mayscula/minscula de cada letra del programa; tambin hay que escribir todos los
smbolos que aparecen en el cdigo del programa. Por lo tanto el programa anterior no
funciona.
1.5 Instrucciones bsicas para imprimir texto.
Para hacer que un programa imprima una lnea de texto necesitamos utilizar el mtodo
println/print de System.out y pasarle como argumento entre comillas dobles el texto
que queremos desplegar en la pantalla de la computadora. El programa siguiente,
Saludo.java utiliza instrucciones print/println para mostrar texto.
//Ejemplo con print/println.

public class Saludo {
System.out.print("Bienvenido al ");
System.out.println("curso de programacin con Java!");
} // fin de la clase Saludo
El mtodo print y println se utilizan para mostrar texto. La diferencia es que println da
un salto de lnea.
Las cadenas pueden incluir caracteres especiales como el de una nueva lnea para indicarle
a los mtodos print y println de System.out cundo deben colocar el cursor de salida al
8
Aprenda Java
inicio de la siguiente lnea en el monitor de la computadora. El programa siguiente,

Mensaje.java, utiliza secuencias de escape para imprimir texto.
//Ejemplo de secuencias de escape.

public class Mensaje {
System.out.println("Bienvenido\nal\nMundo\nJava!");
} // fin de la clase Mensaje
La barra diagonal inversa (\) se conoce como carcter de escape. Este carcter indica a
los mtodos print y println que se va a imprimir un carcter especial. A este carcter se
le conoce como secuencia de escape. La secuencia de escape \n representa el carcter
de una nueva lnea. Veamos otro ejemplo, el programa siguiente, ImprimirTexto.java,
muestra algunas secuencias de escape comunes.
//Imprimir texto con secuencias de escape.

public class ImprimirTexto {
// el mtodo main empieza la ejecucin de la aplicacin en Java
System.out.print("Linea 01\nLinea 02\nLinea 03\nLinea 04");
System.out.print("\nTab 01\tTab 02\tTab 03\tTab 04");
System.out.print("\nEstoy aprendiendo \"Java\"");
System.out.print("\nRuta de BlueJ: c:\\BlueJ");
} // fin de la clase ImprimirTexto
La secuencia de escape \n representa una nueva lnea. El tabulador horizontal est

compuesto por \t. Para imprimir una diagonal \ utilizamos \\. Y si queremos imprimir un
texto entre comillas dobles utilizamos la \ y \.
En este curso vamos a utilizar frecuentemente la instruccin printf para dar formato al
texto. El programa siguiente, Bienvenido.java, utiliza el mtodo printf.
//Ejemplo con printf.

public class Bienvenido {
System.out.printf("%s\n%s\n",
"Bienvenido al", "tutorial de Java!");
} // fin de la clase Bienvenido
La f en el nombre printf representa la palabra formato. La llamada al mtodo printf

especifica tres argumentos. Cuando un mtodo requiere varios argumentos, stos se
separan con comas (,); a esto se le conoce como lista separada por comas. El primer
9
Aprenda Java
argumento del mtodo printf es una cadena de formato que puede consistir en texto fijo
y especificadores de formato. Cada especificador de formato es un receptculo para un
valor, y especifica el tipo de datos a imprimir. Los especificadores de formato empiezan con
un signo porcentual (%) y van seguidos de un carcter que representa el tipo de datos. El
especificador de formato %s es un receptculo para una cadena. La cadena de formato
especifica que printf debe imprimir dos cadenas, y que cada cadena le debe seguir un
carcter de nueva lnea.
El programa siguiente, Aritmetica.java, utiliza el mtodo printf para imprimir nmeros

enteros y en punto flotante.
//Utiliza printf para imprimir nmeros.

public class Aritmetica {
System.out.printf("%d + %d = %d\n", 5, 3, 5 + 3);
System.out.printf("%f + %f = %f\n", 5.5, 3.5, 5.5 + 3.5);
// esto es un error, el especificador de formato es incorrecto
// System.out.printf("%d + %d = %d\n", 5.5, 3, 5 + 3);
// cuando manejamos nmeros hay que cuidar
// la divisin por cero,
// se genera un error en tiempo de ejecucin
// System.out.printf("%d / %d = %d\n", 5, 0, 5 / 0 );
} // fin de la clase Aritmetica
10
Aprenda Java
2. Programas simples.
Escribir programas simples en Java que reciban valores desde el teclado y realicen
clculos aritmticos.
2.1. Escribir un programa simple.
El proceso de aprendizaje para resolver problemas mediante un lenguaje de programacin

pasa por la etapa de resolver y codificar cientos de programas. Veamos un primer ejemplo
de muchos. El programa siguiente, AreaCirculo.java, calcula el rea de un crculo.
//Calcula el rea de un crculo.

public class AreaCirculo {
// declaracin de variables
double radio;
double area;
// asigna el valor al radio

radio = 20;
// calcula el rea
area = radio * radio * 3.14159;
// imprime el resultado
System.out.println( "El rea del crculo es: " + area );
// no confundir la igualdad matemtica y la asignacin

// esto es un error:
// 4 + 5 = x;
// x + y = y + x;
} // fin de la clase AreaCirculo
Una variable es el nombre de una posicin de memoria que puede guardar un valor
especfico. Una declaracin de variable indica al compilador cul es su nombre y su tipo.
El tipo de una variable indica la clase de valor que sta puede almacenar, as como las
operaciones que se puede hacer con ella. Para asignar un valor a una variable se usa el
operador de asignacin, que es el signo igual (=).
11
Aprenda Java
Para emplear el valor de las variables basta con hacer referencia al nombre de stas dentro
del cdigo del programa. Para hacer operaciones matemticas se utilizan los operadores
aritmticos (+ - * / %).
Una expresin aritmtica es un clculo que produce un valor y est compuesta por
operadores aritmticos y operandos. El programa siguiente, DobleNumero.java, utiliza una
expresin aritmtica para calcular el doble de un nmero.
//Programa que calcula el doble de un nmero.

public class DobleNumero {
// declaracin de la variable
// int numero; //error usar una variable sin valor asignado
int numero = 5; // asigna un valor a la variable
// proceso
int doble = numero * 2; // realiza el clculo
// salida
System.out.printf("El doble de %d es %d\n", numero, doble);
} // fin de la clase DobleNumero
Todas las variables deben declararse con un nombre y un tipo antes de poder usarse. No se
puede utilizar una variable si no tiene un valor asignado. Intentar utilizar una variable sin un
valor asignado genera un error en tiempo de compilacin.
Los tipos de variables como int o double se conocen como tipos primitivos o tipos
integrados. Los nombres de los tipos primitivos son palabras clave y, por lo tanto, deben
escribirse en minsculas.
El mtodo printf de System.out utiliza el especificador de formato %d para mostrar un

nmero entero, %f para un nmero en punto flotante y %s para las cadenas.
2.2. Leer datos desde el teclado.
Java proporciona una clase pre-compilada llamada Scanner, que permite obtener entradas
desde el teclado. Dado que la clase Scanner no es parte del conjunto fundamental de las
clases de Java necesitamos indicarle al compilador donde encontrarla. El programa
siguiente, AreaCirculo.java es nos permitir leer datos desde el teclado y calcular el rea
de un crculo.

import java.util.Scanner; //para leer del teclado
12
Aprenda Java

// Crea objeto para leer desde el teclado
Scanner entrada = new Scanner(System.in);
double radio;
double area;
// mensaje de usuario
System.out.println("Calcula el rea de un crculo.");
System.out.println("------------------------------");
// obtiene el radio del crculo

System.out.print("Radio? ");
radio = entrada.nextDouble();
// calcula el rea
area = radio * radio * 3.14159;
System.out.printf("El rea del crculo es: %f", area);
Para utilizar la clase Scanner se utiliza la instruccin: import java.util.Scanner;. Se

requiere insertar esta instruccin en la parte superior del mtodo main: Scanner entrada =
new Scanner(System.in);.
La expresin new Scanner(System.in); crea un objeto y le pasa como argumento el

teclado que est representado con System.in. Este objeto almacena los caracteres
introducidos desde el teclado. Una vez creado el objeto, se puede leer y almacenar un
nmero con la llamada al mtodo nextDouble para el caso de los nmeros en punto
flotante.
Para continuar aprendiendo programacin con Java, veamos un par de ejemplos que nos
permitan trabajar con variables enteras y de punto flotante. En primer lugar vamos a escribir
un programa que nos permita leer del teclado dos nmeros enteros, calcular la suma e
imprimir el resultado en la consola de salida.
//Ejemplo de variables, operadores aritmticos y la clase Scanner.

import java.util.Scanner; // para leer desde el teclado.
public class Suma {
// crea un objeto Scanner para leer desde el teclado
13
Aprenda Java
int numero1; // primer nmero a sumar
int numero2; // segundo nmero a sumar
int suma; // almacena la suma de numero1 + numero2
System.out.println("Programa que suma dos nmeros enteros.");
System.out.println("--------------------------------------");
// entrada
System.out.print("Primer nmero a sumar? "); // indicador
numero1 = entrada.nextInt(); // lee el primer nmero
System.out.print("Segundo nmero a sumar? "); // indicador
numero2 = entrada.nextInt(); // lee el segundo nmero
// proceso
suma = numero1 + numero2; // suma los nmeros
// salida
System.out.printf("La suma es %d\n", suma); // imprime la suma
} // fin de la clase Suma
La instruccin import le ayuda al compilador a localizar una clase que se encuentra en la

API de Java. Java cuenta con un gran conjunto de clases que se organizan en paquetes y
se les conoce como la biblioteca de clases de Java o la API de Java. Una vez creado el
objeto con Scanner entrada = new Scanner(System.in);, se puede leer y almacenar un
nmero entero con la llamada al mtodo nextInt.
Con el programa siguiente, Producto.java, utilizaremos dos variables de tipo float y

calcularemos su producto.

public class Producto {
System.out.println("Programa que multiplica dos nmeros.");
System.out.println("------------------------------------");
// entrada
System.out.print("Primer nmero? "); // indicador
14
Aprenda Java
float numero1 = entrada.nextFloat(); // lee el primer nmero

System.out.print("Segundo nmero? "); // indicador
float numero2 = entrada.nextFloat(); // lee el segundo nmero
// proceso
float producto = numero1 * numero2;
// salida
System.out.printf("%.2f x %.2f = %.2f\n",
numero1, numero2, producto);
} // fin de la clase Producto
El especificador de formato %.2f nos permite indicar el nmero de decimales a mostrar.
2.3. Identificadores.
Un identificador es el trmino tcnico para el nombre de un componente de programa: el

nombre de una clase, el nombre de un mtodo, una variable, etc. El programa siguiente,
Identificador.java, muestra los identificadores en Java.
//Ejemplos de identificadores en Java.

public class Identificador {
float costoTotal;
System.out.println("Identificador -> identificador clase");

System.out.println("main -> identificador mtodo");
System.out.println("costoTotal -> identificador variable");
} // fin del metodo main
} // fin de la clase Identificador
Los identificadores deben estar formados enteramente por letras, dgitos y caracteres como
signos de moneda ($) y/o guin bajo (_). El primer carcter no debe ser un nmero. Si un
identificador no sigue estas reglas, el programa no compilar.
Veamos un ejemplo de como no declarar identificadores en Java. El programa siguiente,

NoIdentificador.java, muestra como no declarar identificadores en Java.
//El programa no funciona solo ilustra identificadores no validos.

public class NoIdentificador {
// float costo Total; //contiene espacios
// int 3deseos; //inicia con un nmero
// boolean public; //public es palabra clave
15
Aprenda Java
// boolean tengo.Mascota; //contiene un punto

// double #numPrimo; //El signo # u otros no estn permitidos
} // fin de la clase NoIdentificador
Para terminar con el tema de los identificadores: recuerda que Java es case-sensitive, es
decir hace distincin entre minsculas y maysculas. El programa siguiente,
CaseSensitive.java, demuestra lo mencionado anteriormente.
//Ejemplo de identificadores case-sensitive.

public class CaseSensitive {
int suma = 5; // variable local
int SUMA = 12; // SUMA es distinta de suma
// imprime el contenido de la variable

System.out.println("El valor de suma es " + suma);
System.out.println("El valor de SUMA es " + SUMA);
// esto es un error, suma no est definida

// System.out.println( "El valor de SUMA es " + Suma );
2.4. Variables.
Una variable en Java puede almacenar slo un tipo de valor. Por ejemplo, una variable de
tipo entero slo puede almacenar valores enteros y no valores en punto flotante. El
programa siguiente, Variable.java, utiliza variables para guardar y manipular datos.
//Programa que declara y manipula variables.

public class Variable {
int edad;
double sueldo;
// tambin se pueden declarar en una sola lnea

// int x, y, z; //usar nombres de variables significativos
// no se puede declarar una variable ms de una vez
// int a, b, c;
// int a; //esto es un error
// asignacin de valores a las variables
edad = 18;
sueldo = 15400.20;
16
Aprenda Java
// declaracin e inicializacin de una variable

int numeroSuerte = 38;
// uso del valor de una variable

System.out.println(edad);
System.out.println(sueldo);
System.out.println(numeroSuerte);
// asignacin incorrecta
// edad = 18.50; //los tipos no coinciden
// la variable aumento no tiene un tipo
// aumento = 1500.0; //error de sintaxis
// declaracin de una variable
int x;
// la variable x no tiene un valor inicial
// x = x + 1; //error de sintaxis
} // fin de la clase Variable
Los nombres de variables son identificadores. En Java, los nmeros no tienen comas.
Java utiliza el signo igual (=) para las instrucciones de asignacin. Una instruccin de
asignacin pone un valor dentro de una variable.
Veamos un ejemplo que nos permita practicar con todos los conceptos estudiados hasta el
momento. El programa siguiente, Numero234.java, calcula el doble, triple, cudruple de un
nmero.

public class Numero234 {
int numero, doble, triple, cuadruple;
System.out.println(
"Calcula el doble, tripe y cudruple de un nmero.");
System.out.println(
"-------------------------------------------------");
// entrada
System.out.print("Nmero? "); // indicador
numero = entrada.nextInt(); // lee el nmero
17
Aprenda Java
// proceso
doble = numero * 2;
triple = numero * 3;
cuadruple = numero * 4;
// salida
System.out.printf(
"El doble, triple y cudruple de %d es %d, %d y %d\n",
numero, doble, triple, cuadruple);
} // fin de la clase Numero234
Al declarar una variable no olvidar poner el punto y coma al final. Al declarar ms de una
variable en una sola instruccin, es importante no olvidar separar las variables por comas.
2.5. Operador de asignacin y expresin de asignacin.
Antes de usar una variable, es necesario declararla y asignarle un valor utilizando el signo
igual (=). El programa siguiente, CalculoSimple.java, realiza clculos simples utilizando
expresiones.
//Programa que realiza clculos de expresiones simples.

public class CalculoSimple {
// variable = expresin
int x = 10;
int z = 5 * 2 + x;
x = x + 1;
z = z + x * 2 / 4 - 5;
System.out.println(x);
System.out.println(z);
// esto es un error
// 1 = x;
// z + 1 = x + 1;
// x = 1.0; //asignacin ilegal de tipo
// x = x / 0; //divisin por cero
} // fin de la clase CalculoSimple
No confundir la igualdad matemtica y la asignacin. Al asignar un valor a una variable

hay que tener en cuenta el tipo de la variable. Una expresin aritmtica involucra valores
nmericos y operadores aritmticos tales como la suma o resta. Cuando dos o ms
operadores estn presentes en una expresin aritmtica, es necesario determinar el orden
18
Aprenda Java
de evaluacin siguiendo las reglas de precedencia.
Veamos un ejemplo que nos permita practicar lo estudiado anteriormente. El programa

siguiente, AreaTriangulo.java, dado la base y la altura de un tringulo calcular su rea.

public class AreaTriangulo {
double area; // almacena el rea del tringulo
double base; // la base del tringulo
double altura; // la altura del tringulo
System.out.println("rea de un tringulo.");
System.out.println("---------------------");
// entrada
System.out.print("Base? "); // indicador
base = entrada.nextDouble(); // lee la base
System.out.print("Altura? "); // indicador
altura = entrada.nextDouble(); // lee la altura
// proceso
area = (base * altura) / 2.0; // calcula el rea
// salida
System.out.printf("El rea es %.2f\n", area);
} // fin de la clase AreaTriangulo
2.6. Constantes con nombre.
Si queremos que un valor permanezca fijo, entonces debemos de utilizar una constante.
Una constante se declara en forma similar a una variable, pero aadiendo la palabra clave
final. El programa siguiente, AreaCirculo.java, define una constante con nombre para
calcular el rea de un crculo.

19
Aprenda Java
// declara una constante con nombre

final double PI = 3.14159;
// Crea objeto para leer datos

double radio, area;
System.out.println("Calcula el rea de un crculo.");
// obtiene el radio del crculo

radio = entrada.nextDouble();
// calcula el rea
area = radio * radio * PI;
System.out.printf("El rea del crculo es: %.2f", area);
En una constante solamente se deben usar letras maysculas y subrayado. La palabra clave
final es un modificador y le indica a la computadora que genere un error si el programa
intenta cambiar el valor de la variable final en un momento posterior. Las constantes con
nombre hace ms fcil la documentacin del cdigo.
Veamos otro ejemplo para practicar con este concepto. El programa siguiente,
PieMetro.java, lee un nmero de pies y lo convierte a metros.
//Programa que calcula el equivalente de pies a metros.

public class PieMetro {
// declara una constante con nombre
final double PIE_METRO = 0.305;
// entrada
System.out.print("Introduce un valor en pies? ");
double nPies = entrada.nextDouble();
// proceso
20
Aprenda Java
double metros = nPies * PIE_METRO;
// salida
System.out.printf("%.2f pies son %.2f metros", nPies, metros);
} // fin de la clase PieMetro
2.7. Tipos de datos primitivos.
Hay seis tipos de datos numricos en Java: byte, short, int, long, float y double. Los
cuatro primeros se utilizan para almacenar nmeros enteros y los dos ltimos para
almacenar nmeros en punto flotante. La diferencia entre estos seis tipos de datos
numricos es principalmente el rango de valores que pueden representar.
Se dice que un tipo de datos con un rango variable ms grande tiene mayor precisin. Por
ejemplo el tipo double tiene una precisin mayor que el tipo de datos float.
En Java tambin se utiliza el tipo de dato char as como el boolean. El programa siguiente,
TipoPrimitivo.java, muestra los ocho tipos de datos primitivos en Java.
//Programa que muestra los ochos tipos de datos primitivos.

public class TipoPrimitivo {
// tipos integrales
byte edad = 38; // 8 bits
short distancia = 127; // 16 bits
int sumaTotal = 1250; // 32 bits -->por default
long distanciaLuna = 238857; // 64 bits
// punto flotante
float salario = 3850.0f; // 32 bits
// asignacin ilegal
// float salario = 3850.00; //3850.00 est en 64 bits
double granTotal = 125000.50; // 64 bits -->por default
// tipo carcter
char letra = 'A'; // 16 bits UNICODE
// asignacin ilegal
// char letra = "A"; //String->comillas dobles
// tipo boolean
boolean tengoPerro = false; // valores: true/false
// cuidado con el overflow

// int valor = 2147483647 + 1; //-2147483648
21
Aprenda Java
// cuidado con el underflow

// int otroValor = -2147483648 - 1; //2147483647
} // fin de la clase TipoPrimitivo
Los tipos de variables definen un conjunto de valores que pueden tomar las variables. Al
asignar a una variable un valor que rebasa sus lmites, ocurre un error de desbordamiento.
La computadora tiene que representar los nmeros mediante una cantidad fija de unos y
ceros. En muchos casos, la computadora puede representar los nmeros con exactitud;
pero en otros, la representacin del nmero es slo cercana, no exacta. El programa
siguiente, Precisin.java, muestra lo que sucede con la aproximacin de punto flotante.
//Ilustra el concepto de precisin.

public class Precision {
public static void main( String[] args ) {
System.out.println( 10 ); //se representa en 32 bits
System.out.println( 10.0 ); //se representa en 64 bits
System.out.println( 10.0F ); //se representa en 32 bits p.f.
System.out.println( 7 / 3 ); //32 bits enteros

System.out.println( 7.0 / 3.0 ); //64 bits punto flotante
System.out.println( 7.0F / 3 ); //7.0F -> 32 bits p.flotante
//imprime 0.89999999999999999
System.out.println( 2.0 - 1.1 );
//error de redondedo
System.out.println( 100 * 4.35 );
} //fin del mtodo main
} //fin de la clase Precision
2.8. Operadores aritmticos.
Los operadores aritmticos pueden utilizarse con los tipos enteros y en punto flotante. Lo
que debemos de tener en cuenta es que si los operandos son enteros, el resultado es un
entero y si alguno de ellos est en punto flotante, el resultado se expresa en punto flotante.
El programa siguiente, CalculadoraSimple.java, muestra los operadores aritmticos en
Java.
//Calculadora simple en Java.

public class CalculadoraSimple {
// Crea objeto Scanner para obtener la entrada del teclado
int numeroUno, numeroDos;
22
Aprenda Java
System.out.println("Calculadora Java.");
System.out.println("-----------------");
System.out.print("Escribe el primer nmero: "); // indicador

numeroUno = entrada.nextInt();
System.out.print("Escribe el segundo nmero: "); // indicador
numeroDos = entrada.nextInt();
System.out.printf("La suma es %d\n", numeroUno + numeroDos);

System.out.printf("La resta es %d\n", numeroUno - numeroDos);
System.out.printf("El producto es %d\n",numeroUno * numeroDos);
System.out.printf("La divisin es %d\n",numeroUno / numeroDos);
System.out.printf("El residuo es %d\n", numeroUno % numeroDos);
} // fin de la clase CalculadoraSimple
Un caso especial se da con la divisin y el mdulo de nmeros enteros. El operador de

mdulo devuelve el resto de una divisin. Veamos un par de ejemplos para ilustrar este
concepto. El programa siguiente, Divisin.java, demuestra la divisin de enteros y el
operador de mdulo.
//Programa para calcular la divisin y mdulo de dos nmeros enteros.

public class Division {
// entrada
System.out.print( "Introduce un nmero? " );
int num1 = entrada.nextInt();
System.out.print("Introduce otro nmero? ");

// proceso
int div1 = num1 / num2;
int mod1 = num1 % num2;
int div2 = num2 / num1;

int mod2 = num2 % num1;
// salida
System.out.println(div1);
System.out.println(mod1);
23
Aprenda Java
System.out.println(div2);
System.out.println(mod2);
} // fin de la clase Division
El programa siguiente, SumaDigitos.java, obtiene la suma los dgitos de un nmero de

cuatro cifras utilizando el concepto de divisin de enteros y el operador de modulo.
//Programa que suma los dgitos de un nmero entre 0 y 1000.

public class SumaDigitos {
int unidad, decena, centena;
int numero, temporal, suma;
// entrada
System.out.print("Introduce un nmero entre 0 y 1000? ");
numero = entrada.nextInt();
// proceso
temporal = numero;
unidad = temporal % 10;
temporal = temporal / 10;
decena = temporal % 10;
centena = temporal % 10;
suma = unidad + decena + centena;
// salida
System.out.printf("La suma de los dgitos de %d es %d ",
numero, suma);
} // fin de la clase SumaDigitos
2.9. Literales en Java.
Una literal es la representacin de un valor en el cdigo fuente de un programa. En Java

tenemos literales para representar nmeros enteros, en punto flotante, caracteres, booleanos
y cadenas. El programa siguiente, Literal.java, demuestra el uso de las literales en Java.
//Programa que utiliza literales.

public class Literal {
System.out.println(10); // literal entera 32 bits
24
Aprenda Java
System.out.println(10L); // literal entera 64 bits

System.out.println(10.0D); // literal en punto flotante 64 bits
System.out.println(10.0F); // literal en punto flotante 32 bits
System.out.println('A'); // literal char
System.out.println(true); // literal boolean
System.out.println("A"); // literal String
} // fin de la clase Literal
2.10. La evaluacin de expresiones en Java.
Cuando una expresin aritmtica tiene ms de un operador aritmtico, el orden de

aplicacin de los operadores sigue un orden preciso determinado por las reglas jerarqua de
los operadores aritmticos. Por ejemplo, las operaciones entre parntesis se realizan
primero en una expresin, y le siguen de izquierda a derecha la multiplicacin o divisin y
finalmente la suma y la resta. Veamos algunos ejemplos que nos permitirn practicar con
estos conceptos.
El programa siguiente, Expresin.java, demuestra la evaluacin de expresiones

aritmticas en Java.
//Expresin aritmtica.
public class Expresion {
int resultado = 14 + 8 / 2; // expresin aritmtica
System.out.println(resultado);
resultado = (14 + 8) / 2;
resultado = 14 + (8 / 2);
} // fin de la clase Expresion
El programa siguiente, Promedio.java, demuestra la evaluacin de expresiones aritmticas

en Java.
//Programa que calcula el promedio de tres calificaciones.

public class Promedio {
// declaracin y asignacin de los valores
double calif1 = 10.0, calif2 = 10.0, calif3 = 10.0;
double promedio = 0.0; // es buena prctica inicializar
25
Aprenda Java
System.out.println("Promedio de tres calificaciones.");
System.out.println("--------------------------------");
promedio = calif1 + calif2 + calif3 / 3;

System.out.printf("El promedio incorrecto es: %.2f\n",
promedio);
promedio = (calif1 + calif2 + calif3) / 3;

System.out.printf("El promedio correcto es: %.2f\n", promedio);
} // fin de la clase Promedio
2.11. Operadores abreviados y de incremento/decremento.
Java proporciona los operadores de incremento, decremento y asignacin compuesta

que permiten escribir una expresin aritmtica en una forma compacta. Veamos un par de
ejemplos. El programa siguiente, OpAbreviado.java que utiliza los operadores abreviados.
//Muestra los operadores abreviados.

public class OpAbreviado {
int x = 2;
x += 3; // x = x + 3;
System.out.println("x = " + x);
x -= 3; // x = x 3;
x *= 2; // x = x * 2
x /= 2; // x = x / 2
} // fin de la clase OpAbreviado
Los operadores abreviados son los siguientes: +=, -=, *=, /= y %= y permiten simplificar
la escritura de expresiones en Java. No hay espacios entre los operadores abreviados. Por
ejemplo: + = debe escribirse como +=.
26
Aprenda Java
El programa siguiente, IncrementoDecremento.java, utiliza los operadores de

incremento/decremento.
//Operadores de incremento/decremento.
public class IncrementoDecremento {
int x = 0, y = 0;
x++; // x = x + 1;
x--; // x = x - 1;
System.out.println(x); // el valor de x es cero

System.out.println("Trabajando con el operador postfijo.");
y = x++;
System.out.println("y = " + y);
System.out.println("Trabajando con el operador prefijo.");

y = ++x;
System.out.println("y = " + y);
// a tener en cuenta
// int i = 10;
// int num = 10 * i++;
// es lo mismo que
// int num = 10 * i;
// i = i + 1;
// a tener en cuenta
// int i = 10;
// int num = 10 * (++i);
// es lo mismo que
// i = i + 1;
// int num = 10 * i;
} // fin de la clase IncrementoDecremento
Los operadores ++ y -- se utilizan para incrementar o decrecer un valor en 1. Por ejemplo,

x++ incrementa el valor de x en 1, al igual que la expresin x = x + 1. De manera similar x--
decrece el valor de x en 1.
Estos operadores de incrementos y decrementos se pueden fijar antes o despus; es decir,

el ++ o -- puede aparecer antes o despus del valor que incremente o decrece. Cuando
utilizamos el operador de posfijo primero se asigna y luego se incrementa. Con el
operador prefijo primero se incrementa la variable y luego se asigna.
27
Aprenda Java
2.12. Conversin de tipo (type casting).
Cuando una expresin aritmtica est formada por variables y constantes del mismo tipo,
el resultado se expresa en ese mismo tipo de dato.
Cuando los tipos de datos de las variables y constantes en una expresin aritmtica son
distintos, es necesario llevar a cabo una conversin. Una conversin de tipo es un proceso
que convierte el valor de un tipo de datos a otro tipo de datos. Hay dos conversiones
posibles en Java: implcitas y explcitas. Una conversin implcita, denominada
promocin numrica, se aplica a todos los operandos de un operador aritmtico. Esta
conversin se denomina promocin porque el operando se convierte de menor a mayor
precisin.
Las conversiones explcitas se aplican a un operador de conversin de tipo y la mayora de

las veces implica perder precisin. El programa siguiente, Conversion.java, ilustra el
concepto de conversin de tipo.
//Programa que demuestra la conversin de tipos.

public class Conversion {
// conversin implcita
System.out.println(3 * 4.5); // es lo mismo que 3.0 * 4.5
// conversin explcita
System.out.println((int) 40.7); // se pierde la fraccin
System.out.println((double) 1 / 2);
// 1920 que est en int (32 bits) se convierte

// a double (64 bits)
double distancia = 1920;
// int temp = distancia; //asignacin ilegal

int aumento = (int) 1520.75; // casting, perdida de precisin
System.out.println(distancia);
System.out.println(aumento);
// elevar un nmero a la n potencia

int cubo = (int) Math.pow(5, 3);
// sacar la raz cuadrada de un nmero
int raiz = (int) Math.sqrt(81);
System.out.println(cubo);
System.out.println(raiz);
} // fin de la clase Conversion
28
Aprenda Java
La clase Math contiene mtodos de clase frecuentemente usados en las funciones

matemticas. Al regresar el resultado lo hace con el tipo de dato double por lo que a
menudo se tiene que realizar una conversin de tipo para poder asignarlo a una variable de
un tipo diferente.
Vamos otros ejemplos que nos permitan trabajar con los conceptos estudiados
anteriormente. El programa siguiente, Sueldo.java, calcula el sueldo de un trabajador.

public class Sueldo {
float sueldoBase; // sueldo del trabajador
float ventas; // ventas realizadas por el trabajador
float comision; // la comisin por las ventas realizadas
float sueldoTotal; // el sueldo total
System.out.println("Calcula el sueldo de un trabajador.");
System.out.println("-----------------------------------");
// entrada
System.out.print("Sueldo base? "); // indicador
sueldoBase = entrada.nextFloat(); // lee el sueldo base
System.out.print("Ventas realizadas? "); // indicador
ventas = entrada.nextFloat(); // las ventas realizadas
// proceso
// comision = ventas * 0.10; //perdida de precisin
// comision = ventas * 0.10F; //ok
comision = (float) (ventas * 0.10); // casting
sueldoTotal = sueldoBase + comision;
// salida
System.out.printf("Sueldo base $%.2f\n", sueldoBase);
System.out.printf("Comisin $%.2f\n", comision);
System.out.printf("Sueldo total $%.2f\n", sueldoTotal);
} // fin de la clase Sueldo
29
Aprenda Java
El programa siguiente, VolumenCilindro.java, calcula el volumen de un cilindro.
//Programa que calcula el volumen de un cilindro.

public class VolumenCilindro {
System.out.println("Calcula el volumen de un cilindro.");
System.out.println("----------------------------------");
// lectura de los datos

float radio = entrada.nextFloat();
System.out.print("Altura? ");
float altura = entrada.nextFloat();
// proceso de los datos

float area = (float) (Math.pow(radio, 2) * Math.PI);
float volumen = area * altura;
// impresin de los resultados

System.out.printf("rea cilindro: %.2f\n", area);
System.out.printf("Volumen cilindro: %.2f\n", volumen);
} // fin de la clase VolumenCilindro
El programa siguiente, Hipotenusa.java, calcula la hipotenusa de un tringulo rectngulo.
/Programa para calcular la hipotenusa de un tringulo rectngulo.

public class Hipotenusa {
System.out.println("Hipotenusa de un tringulo rectngulo.");
// lectura de los datos

System.out.print("Ingresa los valores para el cateto a y b: ");
int catetoA = entrada.nextInt();
int catetoB = entrada.nextInt();
// procesa los datos
int hipotenusa = (int) Math.sqrt(Math.pow(catetoA, 2)
30
Aprenda Java
+ Math.pow(catetoB, 2));
System.out.printf("La hipotenusa es: %d", hipotenusa);
} // fin de la clase Hipotenusa
2.13. Ejercicios resueltos.
El proceso de aprendizaje de cualquier lenguaje de programacin se realiza resolviendo al

menos 100 problemas que utilicen las estructuras de control bsicas (secuencia, seleccin,
repeticin).
Este proceso de aprendizaje inicia con el lpiz y papel; lo fundamental es entender el

problema y auxiliarse de pseudocdigo o diagramas de flujo que nos den la idea bsica de lo
que estamos tratando de resolver.
Una vez que tenemos la idea de como resolver el problema, lo siguiente es codificar el
programa, compilar, corregir los errores de sintaxis y verificar que nuestro programa produce
los resultados adecuados. Finalmente, hay que documentar el programa.
Para empezar nuestro proceso de aprendizaje con Java, podemos seguir las siguientes
etapas:
Declarar de variables.
Entrada/Lectura de los datos.
Proceso de clculo (una o ms frmulas).
Salida/Impresin de resultados.
Nota: los problemas que se resuelven aqu no tienen una solucin nica.
Problema 1.
Escribir un programa que permita convertir una cantidad dada en metros a sus equivalentes
en centmetros, pulgadas, pies y yardas. Considera la siguiente informacin:
1 metro = 100 centmetros

1 pie = 12 pulgadas
1 yarda = 3 pies
1 pulgada = 2.54 centmetros
//Dada una cantidad de metros imprime su equivalencia en otras

//unidades de medida.
31
Aprenda Java
public class Metro {

double nMetros, pie, pulgada, yarda, centimetro;
System.out.println("Convierte metros a otras medidas.");

System.out.println("---------------------------------");
// entrada
System.out.println("Cantidad de metros? ");
nMetros = entrada.nextDouble();
// proceso de conversin
centimetro = nMetros * 100;
pulgada = centimetro / 2.54;
pie = pulgada / 12;
yarda = pie / 3;
// salida de resultados
System.out.printf("%.2f metros equivalen a:\n\n", nMetros);
System.out.printf("%.2f centmetros\n", centimetro);
System.out.printf("%.2f pulgadas\n", pulgada);
System.out.printf("%.2f pies\n", pie);
System.out.printf("%.2f yardas\n", yarda);
} // fin de la clase Metro
Problema 2.
Linus Torvalds, Miguel de Icaza y James Gosling aportan cantidades de dinero para formar
una empresa de tecnologas avanzadas. Escribe un programa que determine el capital
formado y el porcentaje de dicho capital que aporta cada uno de los inversionistas.
//Programa que calcula la proporcin de tres cantidades.

public class Inversion {
float dineroTorvalds = 0.0f;
float dineroIcaza = 0.0f;
float dineroGosling = 0.0f;
32
Aprenda Java
// es buena prctica de programacin declarar e inicializar

float porcentajeTorvalds = 0.0f;
float porcentajeIcaza = 0.0f;
float porcentajeGosling = 0.0f;
float capital = 0.0f; // el total de inversin
System.out.println("Capital invertido.");
System.out.println("------------------");
// entrada de datos
System.out.println("Introduce las tres cantidades:");
System.out.print("Linus Torvalds $");
dineroTorvalds = entrada.nextFloat();
System.out.print("Miguel de Icaza $");
dineroIcaza = entrada.nextFloat();
System.out.print("James Gosling $");
dineroGosling = entrada.nextFloat();
// calcula el el capital formado

capital = dineroTorvalds + dineroIcaza + dineroGosling;
// determina los porcentajes de cada capital respecto del total

porcentajeTorvalds = dineroTorvalds * 100 / capital;
porcentajeIcaza = dineroIcaza * 100 / capital;
porcentajeGosling = dineroGosling * 100 / capital;
System.out.printf("Total de capital a invertir: $%.2f\n",
capital);
System.out.printf("Linus Torvalds tiene el %.2f porciento\n",
porcentajeTorvalds);
System.out.printf("Miguel de Icaza tiene el %.2f porciento\n",
porcentajeIcaza);
System.out.printf("James Gosling tiene el %.2f porciento\n",
porcentajeGosling);
} // fin de la clase Inversion
Problema 3.
Se usa una cantidad conocida como ndice de masa corporal (IMC)para calcular el riesgo de
los problemas de salud relacionados con el peso. El IMC se calcula como la frmula
w
IMC=
( h/100)2
en donde w es el peso en kilogramos y h es la altura en centmetros. Un IMC de 20 a 25 se
33
Aprenda Java
considera normal. Escribe un programa que acepte el peso y la altura (ambos en nmeros
enteros) y produzca el IMC.
//Programa que calcula el ndice de masa corporal.

public class IndiceMasaCorporal {
int pesoCorporal; // en kilos
int altura; // en centmetros
double imc;
System.out.println("Calcula el ndice de masa corporal.");

// entrada
System.out.print("Introduce el peso(kilos) y altura(cms): ");
pesoCorporal = entrada.nextInt();
altura = entrada.nextInt();
// proceso
imc = pesoCorporal / Math.pow(altura / 100.0, 2);
// salida
System.out.printf("El ndice de masa corporal es %.2f\n", imc);
} // fin de la clase IndiceMasaCorporal
Problema 4.
Escribe un programa que calcule la distancia entre dos puntos P1 y P2 de un plano

cartesiano. Para calcular la distancia d entre los dos puntos aplicamos la siguiente frmula:
d= (( X 1X 2 )2+ (Y 1 Y 2)2 )
//Calcula la distancia entre dos puntos.

public class Distancia {
System.out.println("Calcula la distancia entre dos puntos.");

// entrada
34
Aprenda Java
System.out.print("Introduce el punto (x1,y1): ");

double x1 = entrada.nextDouble();
double y1 = entrada.nextDouble();
System.out.print("Introduce el punto (x2,y2): ");

double x2 = entrada.nextDouble();
double y2 = entrada.nextDouble();
// proceso
double d = Math.sqrt(Math.pow((x1 - x2), 2)
+ Math.pow((y1 - y2), 2));
// salida
System.out.printf(
"La distancia entre los dos puntos es %.2f\n", d);
} // fin de la clase Distancia
Problema 5.
Su peso es realmente la cantidad de atraccin gravitacional ejercida sobre usted por la

Tierra. Puesto que la gravedad es nicamente 1/6 de la gravedad que en la Tierra, en la luna
usted nicamente debera pesar 1/6 de lo que pesa en la Tierra. Escribe un programa que
reciba el peso del usuario en la Tierra y calcule su peso en Mercurio, Venus, Jpiter y
Saturno. Use los valores de la tabla de abajo.
Planeta Multiplique el peso en la Tierra por

Mercurio 0.4
Venus 0.9
Jpiter 2.5
Saturno 1.1
//Programa que calcula el peso en otros planetas.

public class PesoPlanetas {
// constantes
final double PESO_MERCURIO = 0.4;
final double PESO_VENUS = 0.9;
final double PESO_JUPITER = 2.5;
final double PESO_SATURNO = 1.1;
// variables
double pesoCorporal;
35
Aprenda Java
double pesoMercurio, pesoVenus, pesoJupiter, pesoSaturno;
System.out.println("Calcula el peso en otros planetas.");

// entrada
System.out.print("Peso corporal (kgs)? ");
pesoCorporal = entrada.nextDouble();
// proceso
pesoMercurio = pesoCorporal * PESO_MERCURIO;
pesoVenus = pesoCorporal * PESO_VENUS;
pesoJupiter = pesoCorporal * PESO_JUPITER;
pesoSaturno = pesoCorporal * PESO_SATURNO;
// salida
System.out.printf("En la Tierra pesas: %.2f kgs.\n",
pesoCorporal);
System.out.printf("En Mercurio pesas: %.2f kgs.\n",
pesoMercurio);
System.out.printf("En Venus pesas: %.2f kgs.\n", pesoVenus);
System.out.printf("En Jpiter pesas: %.2f kgs.\n",
pesoJupiter);
System.out.printf("En Saturno pesas: %.2f kgs.\n",
pesoSaturno);
} // fin de la clase PesoPlanetas
Problema 6.
Cuando usted dice que tiene 18 aos, est diciendo realmente que la Tierra ha dado 18
vueltas al Sol. Puesto que a otros planetas les cuesta ms o menos das que a la Tierra dar
una vuelta alrededor del Sol, su edad sera distinta en otros planetas.
Se puede calcular lo viejo que usted sera en otros planetas mediante la frmula: y = (x *
365) /d, donde x es la edad de la Tierra, y es la edad en otro planeta, y d es el nmero de
das de la Tierra que el planeta y viaja alrededor del Sol.
Escribe una aplicacin que reciba como entrada la edad del usuario en la Tierra e imprima su
edad en Mercurio, Venus, Jpiter y Saturno. Los valores para d en esos planetas se dan en
la tabla siguiente:
36
Aprenda Java
Planeta d = nmero aproximado de das

Mercurio 88
Venus 225
Jpiter 4380
Saturno 10767
//Programa que calcula la edad en otros planetas.

import java.util.Scanner; //leer del teclado
public class EdadPlanetas {
// constantes
final int DIAS_MERCURIO = 88;
final int DIAS_VENUS = 225;
final int DIAS_JUPITER = 4380;
final int DIAS_SATURNO = 10767;
final int DIAS_AO = 365;
// variables
int edad, diasTerrestres;
int edadMercurio, edadVenus, edadJupiter, edadSaturno;
System.out.println("Calcula la edad en otros planetas.");

// entrada
System.out.print("Edad? ");
edad = entrada.nextInt();
// proceso
diasTerrestres = edad * DIAS_AO;
edadMercurio = diasTerrestres / DIAS_MERCURIO;
edadVenus = diasTerrestres / DIAS_VENUS;
edadJupiter = diasTerrestres / DIAS_JUPITER;
edadSaturno = diasTerrestres / DIAS_SATURNO;
// salida
System.out.printf("Edad en la Tierra: %d\n", edad);
System.out.printf("Edad en Mercurio: %d\n", edadMercurio);
System.out.printf("Edad en Venus: %d\n", edadVenus);
System.out.printf("Edad en Jpiter: %d\n", edadJupiter);
System.out.printf("Edad en Saturno: %d\n", edadSaturno);
} // fin de la clase EdadPlanetas
37
Aprenda Java
Problema 7.
El programa siguiente, HoraSegundos.java, convierte horas, minutos y segundos a

segundos.
//Programa que lee una hora, minutos y segundos y calcula

//la cantidad de segundos equivalente.
public class HoraSegundos {
// constantes
final int HORA_SEG = 3600;
final int MIN_SEG = 60;
// variables
int hora, minuto, segundo;
int nSegundos;
System.out.println("Convierte hora-min-seg a segundos.");

// lectura
System.out.print(
"Introduce una hora, mins y segs (ejemplo 1 28 42): ");
hora = entrada.nextInt();
minuto = entrada.nextInt();
segundo = entrada.nextInt();
// proceso
nSegundos = hora * HORA_SEG + minuto * MIN_SEG + segundo;
// salida
System.out.printf(
"Una %d hora(s), %d min(s), %d seg(s) son %d segundos\n",
hora, minuto, segundo, nSegundos);
} // fin de la clase HoraSegundos
38
Aprenda Java
Problema 8.
Escribe un programa que lea un nmero entero de cinco cifras y determine la cifra central del
nmero. As, si el nmero ingresado fuera 45781, la cifra central a mostrar es 7.
//Obtiene la cifra central de un nmero de cinco cifras

public class CifraCentral {

int numero = 0;
int digitoCentral = 0;
// entrada
System.out.print("Nmero de cinco cifras?");
// determina la cifra central

digitoCentral = (numero % 1000) / 100;
System.out.printf("La cifra central es %d", digitoCentral);
} // fin de la clase CifraCentral
Problema 9.
Se pide un prstamo de P pesos durante n aos a una tasa de inters i. Al final de n aos, el
importe de la deuda es de P(i+i) n pesos. Escribe un programa para leer P, i (en porcentaje), n
y adems, para calcular el importe final del adeudo. Comprueba el programa para P =
100.00, i = 8% y n = 5.
//Programa que calcula el adeudo final de un prstamo.

public class Prestamo {
double cantidad, tasaInteres, nAos;
double adeudo;
System.out.println("Calcula el monto de un prstamo.");

System.out.println("--------------------------------");
// entrada
39
Aprenda Java
System.out.print("Cantidad solicitada? $");

cantidad = entrada.nextDouble();
System.out.print("Tasa de inters (5,10,20,...)% ? ");
tasaInteres = entrada.nextDouble();
System.out.print("A pagar en (1,2,3...) aos? ");
nAos = entrada.nextDouble();
// proceso
adeudo = cantidad * Math.pow(1 + tasaInteres / 100.0, nAos);
// salida
System.out.printf("El monto final a pagar es de $%.2f",
adeudo);
} // fin de la clase Prestamo
Problema 10.
Elabora un programa para calcular las monedas que deben darse como cambio en los
siguientes casos:
Si todas las compras fueran menores de un peso.

Si el comprador pagara siempre con un billete de a peso.
Si debiramos dar en cambio el nmero mnimo de monedas.
Si solamente podemos dar en cambio monedas de un centavo, de cinco, de diez, de
veinte, y de cincuenta.
Verifica el programa para las siguientes compras: 97, 78, 54, 21 y 1 centavos.
//Calcula el nmero mnimo de monedas que deben darse como cambio.

public class Monedas {
final int BILLETE_PESO = 100; // 100 centavos
int montoCompra, cambio, temporal;
int moneda50, moneda20, moneda10, moneda5, moneda1;
// entrada
System.out.print("Monto de la compra (menor a 1 peso)? $");
montoCompra = entrada.nextInt();
// proceso
cambio = BILLETE_PESO - montoCompra;
temporal = cambio;
40
Aprenda Java
moneda50 = temporal / 50;

temporal = temporal % 50;
moneda1 = temporal % 5;
// salida
System.out.printf("Cambio = $%d\n", cambio);
System.out.printf("%d monedas de 50 centavos\n", moneda50);
} // fin de la clase Monedas
41
Aprenda Java
3. Instrucciones de seleccin.
Escribir programas que involucren instrucciones de seleccin.
3.1. Tipo de dato boolean.
Las variables boolean slo pueden guardar valores true o false que son palabras clave.
Las variables booleanas se utilizan en programacin para mantener el registro del estado
de cierta accin. El programa siguiente, TipoBoolean.java, declara dos variables
booleanas.
//Declara variables de tipo boolean.

public class TipoBoolean {
// variables locales
boolean tengoMascota = true;
boolean tengoDinero = false;
// imprime el contenido de la variable

System.out.printf("Tengo mascota? %b\n", tengoMascota);
System.out.printf("Tengo dinero? %b\n", tengoDinero);
} // fin de la clase TipoBoolean
3.2. Operadores relacionales y de igualdad.
Los operadores relacionales y de igualdad nos permiten determinar si un valor es igual a,

mayor que o menor que otro valor. Cuando los programas utilizan operadores relacionales y
de igualdad para comparar valores, el resultado de la comparacin es verdadero (true) o
falso (false). Veamos como escribir un programa con operadores relacionales y de
igualdad. El programa siguiente, ExpresionRelacional.java, utiliza operadores
relacionales y de igualdad.
//Operadores de igualdad y relacionales.

public class ExpresionRelacional {
System.out.println("10 > 3 es " + (10 > 3));
System.out.println("10 < 3 es " + (10 < 3));
System.out.println("10 >= 3 es " + (10 >= 3));
System.out.println("10 <= 3 es " + (10 <= 3));
System.out.println("10 == 3 es " + (10 == 3));
System.out.println("10 != 3 es " + (10 != 3));
42
Aprenda Java
// esto es un error
// boolean x = 10 > = 3; //hay un espacio entre > y =
// boolean w = 10 =! 3; //el ! y el = estn volteados
// int num1 = 5;
// int num2 = 6;
// esto es un error si lo que se quiere es comparar
// boolean z = ( num1 = num2 );
} // fin de la clase ExpresionRelacional
3.3. La instruccin if simple.
La instruccin if simple evala una condicin utilizando una expresin relacional. Si la

condicin es verdadera se ejecuta una instruccin o un conjunto de instrucciones que estn
definidas en un bloque. En caso que la condicin sea falsa, se contina con la siguiente
instruccin del programa. El programa siguiente, Edad.java, demuestra el uso de un if
simple.
//Demuestra el uso de la instruccin if simple.

import java.util.Scanner; //para leer del teclado.
public class Edad {
final int MENOR_EDAD = 18; // declara una constante
System.out.print("Ingresa tu edad: "); // indicador

int edad = entrada.nextInt(); // lee la edad del usuario
System.out.printf("Tienes : %d aos.%n", edad);
if (edad < MENOR_EDAD)

System.out.println(
"Por lo tanto todava no eres un adulto.");
System.out.println("La edad es un estado mental.");
// tambin se puede escribir con ms claridad con bloques

// if (edad < MENOR_EDAD) {
// System.out.println(
// "Por lo tanto todava no eres un adulto.");
// } //fin if
// System.out.println("La edad es un estado mental.");
} // fin de la clase Edad
43
Aprenda Java
Las llaves del bloque {...} son opcionales para el caso de los bloques que tienen una
instruccin condicional.
Utilizamos un if simple cuando queremos hacer una cosa o no hacer nada. El programa
siguiente, NumerosIguales.java, utiliza un if simple para determinar si dos nmeros son
iguales.
//Determina si dos nmeros son iguales.

public class NumerosIguales {
System.out.println("Determina si dos nmeros son iguales.");

System.out.println("------------------------------------.");
System.out.print("Introduce dos nmeros enteros: ");

// determina si son iguales

if (num1 == num2)
System.out.printf("%d y %d son iguales.", num1, num2);
} // fin de la clase NumerosIguales
Podemos utilizar en un programa las instrucciones if que sean necesarias. El programa

siguiente, Multiplo.java, utiliza un if simple para determinar si un nmero es mltiplo de
cinco y otro para determinar si ese nmero es par.
//Programa que muestra la estructura de un if simple.

public class Multiplo {
// lee un nmero
System.out.print("Ingresa un nmero entero: ");
int numero = entrada.nextInt();
if (numero % 5 == 0) {
System.out.printf("%d es mltiplo de 5.\n", numero);
} // fin if
if (numero % 2 == 0) {
System.out.printf("%d es par.\n", numero);
} // fin if
44
Aprenda Java
} // fin de la clase Multiplo
Cuando un programa en una instruccin if debe ejecutar un conjunto de instrucciones

porque la evaluacin de la condicin fue verdadera, ese conjunto debe encerrarse entre
llaves ({...}). Las instrucciones encerradas entre tales llaves conforman una instruccin
compuesta. El programa siguiente, CalificacionExamen.java, ilustra lo mencionado
anteriormente.
//Utiliza if compuesto para evaluar una calificacin.

import java.util.Scanner; //el programa utiliza la clase Scanner
public class CalificacionExamen {
System.out.print("Calificacin (1-10)? "); // indicador

int calif = entrada.nextInt();
if (calif > 8) {
System.out.println("La calificacin es excelente.");
System.out.println("Eres un buen programador Java.");
} // fin if
System.out.println("El estudio es la base del triunfo.");
} // fin de la clase CalificacionExamen
A continuacin mostramos algunos errores que pueden ocurrir al utilizar una instruccin if.
El programa siguiente, ErroresTipicos.java, muestra errores tpicos con la instruccin if
simple.
//Errores tpicos en una instruccin if simple.

public class ErroresTipicos {
public static void main(String args[]) {
int x = 10000;
// if( x > 5000 ); //punto y coma, instruccin if vaca
// x = 1000; //la instruccin no forma parte del if
// if(x > 5000 //omitir parntesis es un error
// if x > 5000 //omitir parntesis es un error
// If(x > 5000){} //escribir en maysculas la instruccin if
// if(x = 5000){} //confundir = con ==
// if(x < = 5000 ){ //poner espacios en blanco y olvidar llaves
// if( 80 <= x < 90){} //no funciona igual que en matemticas
System.out.println(x);
} // fin de la clase ErroresTipicos
45
Aprenda Java
3.4. La instruccin if/else.
Utilizamos una instruccin if/else cuando queremos hacer una u otra cosa dependiendo de
una condicin (expresin booleana). En otras palabras: ejecutar instrucciones cuando la
evaluacin de la condicin es verdadera o falsa. Veamos como funciona una instruccin
if/else. El programa siguiente, ParImpar.java, utiliza la instruccin if/else para
determinar si un nmero es par o impar.
//Instruccin if/else.
public class ParImpar {
// operacin de lectura
System.out.print("Introduce un nmero: ");
if (numero % 2 == 0)
System.out.printf("%d es par\n", numero);
else
System.out.printf(numero + " %d es impar\n", numero);
// nota: tambin se puede utiliza las llaves { y } en if/else
} // fin de la clase ParImpar
La instruccin if/else se denomina instruccin de seleccin doble, ya que selecciona

una de dos acciones distintas, o grupo de acciones. El programa siguiente, una nueva
versin de NumerosIguales.java, determina si dos nmeros son iguales.
//Determina si dos nmeros son iguales.

public class NumerosIguales {
System.out.println("Determina si dos nmeros son iguales.");

System.out.println("------------------------------------.");

// determina si son iguales

if (num1 == num2) {
System.out.printf("%d y %d son iguales.", num1, num2);
46
Aprenda Java
} // fin if
else {
System.out.printf("%d y %d no son iguales.", num1, num2);
} // fin else
} // fin de la clase NumerosIguales
En el programa anterior utilizamos una instruccin compuesta, (as como lo hicimos con el if
simple) para que el programa sea ms fcil de leer.
Prctiquemos con otros ejemplos que utilicen la instruccin if/else. El programa siguiente,
Calificacion.java, determina si un estudiante est aprobado/reprobado en base a cuatro
calificaciones.
//Calcula la calificacin final de un estudiante.

public class Calificacion {
final int CALIF_MIN = 7; // minimo aprobatorio
// entrada
System.out.print("Introduce cuatro calificaciones (0-10): ");
double calif1 = entrada.nextDouble();
// proceso y salida
double califFinal = calif1 * 0.30 + calif2 * 0.20 + calif3 *
0.10 + calif4 * 0.40;
System.out.printf("La calificacin final es %.2f\n",
califFinal);
if (califFinal >= CALIF_MIN)

System.out.println("Aprobado");
else
System.out.println("Reprobado");
} // fin de la clase Calificacion
47
Aprenda Java
El programa siguiente, Suma.java, genera dos nmeros aleatorios y permite practicar sumas
aritmticas simples.
//Programa para practicar sumas.

public class Suma {
// genera dos nmeros aleatorios con el mtodo random

int numero1 = (int) (Math.random() * 10);
// muestra la pregunta al usuario

System.out.printf("Cuanto es %d + %d ? ", numero1, numero2);
int respuesta = entrada.nextInt();
// compara la respuesta
if (numero1 + numero2 == respuesta) {
System.out.println("La respuesta es correcta.");
} // fin if
else {
System.out.println("La respuesta es incorrecta.");
} // fin else
El mtodo random de la clase Math devuelve un nmero pseudoaleatorio comprendido en el

intervalo [0.0, 1.0). En el programa anterior lo multiplicamos por 10 y le hacemos un casting
para eliminar la parte fraccionaria y as obtener un nmero entre 0 y 9.
El programa siguiente, Resta.java, es similar al programa anterior, solamente que utiliza un

if simple para determinar si un nmero es mayor que otro, esto es, para no permitir que
genera una pregunta con una resta que de un resultado negativo.
//Programa para practicar restas.

public class Resta {
// genera los nmeros aleatorios
// si numero1 < numero2 intercambia los valores

if (numero1 < numero2) {
int temp = numero1; // variable local a if
48
Aprenda Java
numero1 = numero2;
numero2 = temp;
} // fin if
// pregunta al usuario
System.out.printf("Cuanto es %d - %d ? ", numero1, numero2);
// lee la respuesta
if (numero1 - numero2 == respuesta)
else
} // fin de la clase Resta
3.5. Instrucciones if anidadas.
Un programa puede evaluar varios casos colocando instrucciones if/else dentro de otras
instrucciones if/else, para crear instrucciones if/else anidadas.
//Programa que determina si un nmero se encuentra entre 100 y 200.

public class Limites {
final int LSUP = 200;
final int LINF = 100;
int numero;
// entrada
System.out.print("Nmero? ");
// proceso y salida
if (numero >= LINF)
if (numero <= LSUP)
System.out.printf(
"%d se encuentra entre [%d-%d]\n", numero,
LINF, LSUP);
else
System.out.printf(
49
Aprenda Java
"%d supera el lmite superior.\n", numero);

else
System.out.printf(
"%d no alcanza el lmite inferior.\n", numero);
} // fin de la clase Limites
En una instruccin if anidada, cada instruccin else debe concordar con la instruccin if
precedente ms prxima. Utilizar demasiadas instrucciones if anidadas hace que los
programas se vuelvan ms complejos.
Estudiemos otros ejemplos. El programa siguiente, PositivoNegativoNulo.java,

determina si un nmero es positivo, negativo o nulo, utilizando instrucciones if anidadas.
//Programa que determina si un nmero es positivo, negativo o nulo.

public class PositivoNegativoNulo {
System.out.println("Introduce un nmero entero: ");

if (numero > 0) {
System.out.println("El nmero es positivo.");
} // fin if
else {
if (numero == 0)
System.out.println("El nmero es cero.");
else
System.out.println("El nmero es negativo.");
} // fin else
} // fin de la clase PositivoNegativoNulo
Observa que en programa anterior, utilizamos los bloques {...} para que el programa sea
mucho ms legible. De otra manera, tendramos que leer con cuidado el cdigo para
determinar a que instruccin if pertenece cada parte else.
50
Aprenda Java
El programa siguiente, Divisor.java, utiliza if anidados para determinar si un nmero es

divisor de otro.
//Programa que determina si un nmero es divisor de otro.

public class Divisor {
System.out.print("Introduce dos nmeros: ");

// num2 puede ser divisor?

if (num1 > num2) {
if (num1 % num2 == 0)
System.out.printf(
"%d es divisor de %d\n", num2, num1);
else // este else se asocia al if ms cercano
System.out.printf(
"%d no es divisor de %d\n", num2, num1);
} // fin if
else
System.out.printf("%d no es divisor de %d\n", num2, num1);
} // fin de la clase Divisor
El programa siguiente, Adivinanza.java, utiliza if anidados para simular un juego de

adivinanza, donde el usuario tiene que adivinar un nmero que se encuentra dentro de un
rango de 0 a 9.
//Programa para jugar adivinanzas.

public class Adivinanza {
int numeroSecreto = (int) (Math.random() * 10);
System.out.print("Piensa un nmero entre 0 y 9: ");

if (numero == numeroSecreto) {
System.out.println("Adivinaste!");
} // fin if
else {
if (numero < numeroSecreto) {
51
Aprenda Java
System.out.println("Fro!");
} // fin if
else {
System.out.println("Caliente!");
} // fin else
} // fin else
} // fin de la clase Adivinanza
3.6. La instruccin if/else/if.
Cuando en una condicin existen diversas posibilidades, nos vemos obligados a programar
usando if anidados, lo que complica la realizacin y depuracin del cdigo. Para facilitar la
programacin en estas situaciones se proporciona la instruccin if/else/if. El programa
siguiente, DiaSemana.java, lee un nmero del 1 al 7 y determina el da de la semana
utilizando esta tcnica.
//Programa que dado un nmero del 1 al 7 determina el da de la semana.

public class DiaSemana {
// solicita el da de la semana
System.out.print("Introduce un da de la semana (1-7)? ");
int dia = entrada.nextInt();
// procesa dependiendo del da

if (dia == 1)
System.out.println("El da es: Lunes.");
else if (dia == 2)
System.out.println("El da es: Martes.");
else if (dia == 3)
System.out.println("El da es: Mircoles.");
else if (dia == 4)
System.out.println("El da es: Jueves.");
else if (dia == 5)
System.out.println("El da es: Viernes.");
else if (dia == 6)
System.out.println("El da es: Sbado.");
else if (dia == 7)
System.out.println("El da es: Domingo.");
else
System.out.println("Nmero de da incorrecto.");
} // fin de la clase DiaSemana
52
Aprenda Java
El programa para jugar a la adivinanza, Adivinanza.java, se puede reescribir utilizando

instrucciones if/else/if, lo que simplifica su programacin y posible depuracin cuando se
le tengan que hacer cambios.

System.out.print("Piensa un nmero entre 0 y 9: ");

if (numero == numeroSecreto)
else if (numero < numeroSecreto)
else
Veamos otros ejemplos. El programa siguiente, Sueldo.java, calcula el salario de un

trabajador utilizando instrucciones if/else/if.
//Calcula el aumento de sueldo de un trabajador.

public class Sueldo {
// entrada
System.out.print("Sueldo trabajador? ");
double sueldo = entrada.nextDouble();
// proceso
if (sueldo < 1000)
sueldo *= 1.25; // sueldo = sueldo * 1.25;
else if (sueldo <= 1500)
else
// salida
53
Aprenda Java
System.out.printf("El sueldo del trabajador es $%.2f\n",

sueldo);
} // fin de la clase Sueldo
El programa siguiente, ClasificarNumero.java, utiliza instrucciones if/else/if para

clasificar un nmero entero.
//Clasifica un nmero de acuerdo a una categora.

public class ClasificarNumero {
System.out.print("Nmero? "); // indicador

if (numero < 0)
System.out.printf("%d es menor que cero", numero);
else if (numero <= 100)
System.out.printf("%d se encuentra entre [0,100]",
numero);
else
System.out.printf("%d es mayor que 100", numero);
} // fin de la clase ClasificarNumero
3.7. Operadores lgicos.
Las condiciones simples se expresan en trminos de los operadores relacionales >, <, >=
y <=, y los operadores de igualdad == y !=; cada expresin evala slo una condicin.
Para evaluar condiciones mltiples en el proceso de tomar una decisin, ejecutamos estas
pruebas en instrucciones separadas o en instrucciones if o if/else anidadas. En
ocasiones, las instrucciones if requieren condiciones ms complejas para determinar el
flujo de control de un programa.
Java cuenta con los operadores lgicos, que nos permite formar condiciones ms
complejas, al combinar las expresiones simples. A continuacin estudiaremos el AND
condicional (&&), el OR condicional (||) y el NOT lgico (!).
54
Aprenda Java
El programa siguiente, OperadoresLogicos.java, demuestra el uso de los operadores

lgicos AND, OR y NOT.
//Programa que utiliza los operadores lgicos AND, OR y NOT.

public class OperadoresLogicos {
boolean a = true;
boolean b = false;
//Determina el valor de las variables booleanas

System.out.println( a && b ); //false
System.out.println( a && true ); //true
System.out.println( a || b ); //true
System.out.println( b || false ); //false
System.out.println( !a ); //false
System.out.println( !b ); //true
} //fin de la clase OperadoresLogicos
El AND condicional se utiliza cuando queremos verificar que dos condiciones sean
verdaderas. El OR condicional se utiliza cuando queremos verificar que al menos una de las
condiciones sea verdadera. Y el NOT se usa para negar una condicin.
El programa siguiente, Adolescente.java, determina si una persona es todava un

adolescente utilizando para ello el AND condicional.
//Programa que determina si una persona es un adolescente o no.

public class Adolescente {
System.out.print("Edad? ");
int edad = entrada.nextInt();
if (edad >= 13 && edad <= 18)

System.out.println("Eres un adolescente.");
else
System.out.println("No eres un adolescente.");
// esto es un error
// 13 >= edad <= 18 //no funciona igual que en matemticas
} // fin de la clase Adolescente
55
Aprenda Java
El programa siguiente, PromedioPracticas.java, calcula el promedio de cuatro prcticas

eliminando la menor.
//Determina el promedio de prcticas de un estudiante.

public class PromedioPracticas {
int nota1, nota2, nota3, nota4;
int suma = 0;
float promedio = 0.0F;
// entrada
System.out.print("Introduce las 4 calificaciones: ");
nota1 = entrada.nextInt();
// proceso
if (nota1 < nota2 && nota1 < nota3 && nota1 < nota4)
suma = nota2 + nota3 + nota4;
else if (nota2 < nota1 && nota2 < nota3 && nota2 < nota4)
promedio = suma / 3.0F; // obtiene el promedio
// salida
System.out.printf("El promedio es: %d\n", promedio);
} // fin de la clase PromedioPracticas
El programa siguiente, Loteria.java, simula un juego de lotera y utiliza los operadores

lgicos AND y OR para determinar si el jugador ha obtenido algn premio dependiendo de
los dgitos con los que coincide el premio.
//Programa para jugar a la lotera.

public class Loteria {
56
Aprenda Java
// genera el nmero de la loteria

int loto = (int) (Math.random() * 100);

System.out.print("Ingresa un nmero de dos dgitos: ");
int numGanador = entrada.nextInt();
// obtiene los dgitos de la lotera

int digitoLoto1 = loto / 10;
int digitoLoto2 = loto % 10;
// obtiene los dgitos del usuario

int digito1 = numGanador / 10;
int digito2 = numGanador % 10;
System.out.printf("El nmero de la lotera es: %d\n", loto);
// Revisa por los premios

if (loto == numGanador)
System.out.println("Ganaste $10,000.00");
else if (digito2 == digitoLoto1 && digito1 == digitoLoto2)
else if (digito1 == digitoLoto1 || digito1 == digitoLoto2
|| digito2 == digitoLoto1 || digito2 == digitoLoto2)
else
System.out.println("Sigue participando.");
} // fin de la clase Loteria
El programa siguiente, Apuesta.java, simula un juego de apuestas y utiliza los operadores

lgicos AND y OR para determinar si el jugador ha ganado o perdido dependiendo de la
suma de los dados que se ejecuta aleatoriamente mediante el mtodo Math.random.
//Determina las ganancias al tratar de adivinar los tiros de un dado.

public class Apuesta {
// simula tres tiros de un dado
int dado1 = (int) (Math.random() * 6 + 1);
System.out.printf("Dados: %d, %d, %d\n", dado1, dado2, dado3);
// determina la ganancia
int ganancia = 0;
57
Aprenda Java
if (dado1 == 6 && dado2 == 6 && dado3 == 6)

ganancia = 20;
else if (dado1 == dado2 && dado1 == dado3 && dado2 == dado3)
ganancia = 10;
else if (dado1 == dado2 || dado1 == dado3 || dado2 == dado3)
ganancia = 5;
else
System.out.println("Sigue participando");
System.out.println("Tu ganancia es de $" + ganancia);
} // fin de la clase Apuesta
3.8. El operador condicional (?:).
Java cuenta con el operador condicional (?:), que en ocasiones puede utilizarse en lugar
de una instruccin if/else. ste es el nico operador ternario en Java; es decir, que
utiliza tres operandos. En conjunto, los operandos y el smbolo ?: forman una expresin
condicional. El primer operando (a la izquierda del ?) es una expresin booleana (es
decir, una condicin que se evala a un valor booleano true o false), el segundo
operando (entre el ? y :) es el valor de la expresin condicional si la expresin booleana es
verdadera, y el tercer operando (a la derecha de :) es el valor de la expresin condicional si
la expresin booleana se evala como falsa. El programa siguiente, Mayor.java, utiliza el
operador condicional para determinar si un nmero es mayor que otro.
//Programa que determina el mayor de dos nmeros.

public class Mayor {
System.out.print("Introduce dos nmeros: ");

int max = (num1 > num2) ? num1 : num2;
System.out.println("El mayor es " + max);
// equivalente a
// if( num1 > num2 )
// System.out.println( "El mayor es " + num1 );
// else
// System.out.println( "El mayor es " + num2 );
} // fin de la clase Mayor
58
Aprenda Java
El programa siguiente, ParImpar.java, utiliza el operador condicional para determinar si un

nmero es par/impar.
//Programa que determina si un nmero es par o impar.

System.out.print("Introduce un nmero: ");

int num = entrada.nextInt();
System.out.println((num % 2 == 0) ? "Es par." : "Es impar.");

3.9. La instruccin switch.
La instruccin switch es otra manera de implementar muchas instrucciones if. El programa

siguiente, FabricanteDVD.java, utiliza la instruccin switch para determinar la categora de
un determinado fabricante.
//Programa que lee un cdigo y determina el fabricante.

import java.util.Scanner;
public class FabricanteDVD {
// entrada
System.out.print("Cdigo del fabricante (1-4)? ");
int codigo = entrada.nextInt();
// proceso y salida
switch (codigo) {
case 1:
System.out.println("3M Corporation");
break;
case 2:
System.out.println("Maxwell Corporation");
break;
case 3:
System.out.println("Sony Corporation");
break;
case 4:
System.out.println("Verbatim Corporation");
break;
59
Aprenda Java
default:
System.out.println("Cdigo incorrecto");
} // fin switch
} // fin de la clase FabricanteDVD
A la instruccin switch se le llama instruccin de seleccin mltiple, ya que selecciona una de

varias acciones distintas o grupo de acciones. La palabra break significa ir al final de la
instruccin switch.
Estudiemos otros ejemplos. El programa siguiente, AumentoSueldo.java, calcula el

aumento de un trabajador utilizando una instruccin switch (aunque es factible utilizar una
instruccin if/else/if).
//Calcula el aumento de sueldo de un trabajador.

public class AumentoSueldo {
// entrada
System.out.print("Categora y sueldo del trabajador: ");
int categoria = entrada.nextInt();
float sueldo = entrada.nextFloat();
// proceso
float nuevoSueldo = 0.0F;
switch (categoria) {
case 1:
nuevoSueldo = sueldo * 1.15F;
break;
case 2:
break;
case 3:
break;
case 4:
break;
default:
System.out.println("Categora invlida");
} // fin switch
// salida
60
Aprenda Java
System.out.printf("El nuevo sueldo es $%.2f\n", nuevoSueldo);

} // fin de la clase AumentoSueldo
El programa siguiente, PiedraPapelTijera.java, implementa el juego: piedra-papel-tijera.

En este programa se utilizan todos los conceptos estudiados hasta el momento.
//Programa para jugar al piedra-papel-tijera.

public class PiedraPapelTijera {
final int PIEDRA = 1, PAPEL = 2, TIJERA = 3;
int jugador, computadora;
// solicita la jugada del usuario

System.out.print(
"Tu jugada? 1 = Piedra, 2 = Papel, 3 = Tijera");
jugador = entrada.nextInt();
// genera la jugada de la computadora

computadora = (int) (Math.random() * 3 + 1);
// muestra la jugada del usuario

System.out.print("La jugada del usuario: ");
switch (jugador) {
case PIEDRA:
System.out.println("PIEDRA");
break;
case PAPEL:
System.out.println("PAPEL");
break;
case TIJERA:
System.out.println("TIJERA");
break;
} // fin switch
// muestra la jugada de la computadora

System.out.print("La jugada de la computadora: ");
switch (computadora) {
case PIEDRA:
System.out.println("PIEDRA");
break;
case PAPEL:
System.out.println("PAPEL");
break;
case TIJERA:
61
Aprenda Java
System.out.println("TIJERA");
break;
} // fin switch
// determina el ganador
if (jugador == PIEDRA && computadora == PIEDRA)
System.out.println("Empate.");
else if (jugador == PIEDRA && computadora == PAPEL)
System.out.println("La computadora gana.");
else if (jugador == PIEDRA && computadora == TIJERA)
System.out.println("El jugador gana!");
if (jugador == PAPEL && computadora == PIEDRA)

else if (jugador == PAPEL && computadora == PAPEL)
System.out.println("Empate.");
else if (jugador == PAPEL && computadora == TIJERA)
if (jugador == TIJERA && computadora == PIEDRA)

else if (jugador == TIJERA && computadora == PAPEL)
else if (jugador == TIJERA && computadora == TIJERA)
System.out.println("Empate");
} // fin de la clase PiedraPapelTijera
En la leccin anterior escribimos programas con instrucciones que se ejecutaban en un orden

secuencial. A continuacin vamos a resolver una serie de ejercicios que nos permitirn
afianzar los conceptos de programacin hasta ahora estudiados.
Problema 1.
Una tienda de abarrotes vende paletas de dulce a precios unitarios que dependen de la
cantidad de unidades adquiridas de acuerdo a la siguiente tabla:
Paletas Precio unitario.

1 a 25 $17.50
26 a 50 $15.00
62
Aprenda Java
51 a 75 $12.50
76 en adelante $10.00
Adicionalmente, si el cliente adquiere ms de 50 paletas la tienda de abarrotes le descuenta

el 15% del importe de la compra; en caso contrario, slo le descuenta el 5%.
Escribe un programa que determine el importe de la compra, el importe del descuento y el

importe a pagar por la compra de cierta cantidad de paletas de dulce.
//Determina lo que hay que pagar por una compra de paletas.

public class VentaPaletas {
int numPaletas = 0;
double importeCompra = 0.0;
double importeDescuento = 0.0;
double importePagar = 0.0;
System.out.println("Venta de paletas de dulce.");

System.out.println("--------------------------");
// entrada
System.out.print("Nmero de paletas a comprar? ");
numPaletas = entrada.nextInt();
// clculo del importe de la compra

if (numPaletas >= 1 && numPaletas <= 25)
importeCompra = numPaletas * 17.50;
if (numPaletas >= 76)
// clculo del importe del descuento

if (numPaletas > 50)
importeDescuento = 0.15 * importeCompra;
if (numPaletas <= 50)
importeDescuento = 0.05 * importeCompra;
// calcula el importe a pagar

importePagar = importeCompra - importeDescuento;
63
Aprenda Java
System.out.printf("\nPaletas compradas: %d\n", numPaletas);
System.out.printf("Importe de compra: $%.2f\n", importeCompra);
System.out.printf("Descuento: $%.2f\n", importeDescuento);
System.out.printf("Total a pagar: $%.2f\n", importePagar);
} // fin de la clase VentaPaletas
Problema 2.
El promedio final del curso de programacin Java se obtiene en base al promedio simple de
tres prcticas de laboratorio calificadas. Para ayudar a los alumnos, el profesor de Java ha
establecido incrementar en dos puntos la nota de la tercera prctica calificada, siempre y
cuando sea menor que 10. Disea y codifica un programa que determine el promedio final
de un alumno conociendo sus tres notas. Considera que las calificaciones estn en un rango
de 1 a 10.
//Calcula el promedio de tres notas de laboratorio.

public class PromedioFinal {
// declara e inicializa las variables

double nota1 = 0.0;
double nota2 = 0.0;
double nota3 = 0.0;
double promedio = 0.0;
System.out.println("Promedio final del curso Java.");

// entrada
System.out.print("Introduce las 3 calificaciones (1-10)? ");
nota1 = entrada.nextDouble();
// determina si se aumentan dos puntos

if (nota3 < 10) {
nota3 += 2;
if (nota3 > 10) // la calif mxima es 10

nota3 = 10;
} // fin if
64
Aprenda Java
// determina el promedio
promedio = (nota1 + nota2 + nota3) / 3.0;
System.out.printf("El promedio final es de %.2f\n", promedio);
// determina si esta aprobado/reprobado

if (promedio > 6)
System.out.println("La calificacin es aprobatoria");
else
System.out.println("La calificacin no es aprobatoria");
} // fin de la clase PromedioFinal
Problema 3.
Escribe un programa de manera que la salida sea el resultado de restar el nmero mayor del
menor. As por ejemplo si los nmeros son 6 y 9 la salida ser 3, pero si es 8 y 3, la salida
debe ser 5.
//Programa que resta el nmero menor del mayor.

public class RestaMenor {
int numeroUno;
int numeroDos;
int resta;
// entrada
numeroUno = entrada.nextInt();
numeroDos = entrada.nextInt();
// proceso
if (numeroUno > numeroDos)
resta = numeroUno - numeroDos;
else
resta = numeroDos - numeroUno;
// salida
System.out.printf("La resta es %d", resta);
} // fin de la clase RestaMenor
65
Aprenda Java
Problema 4.
Un programador Java recibe $40 dolares por hora si trabaja semanalmente 40 horas o
menos. Si trabaja ms de 40 horas se le pagan $40 dolares las primeras 40 horas, y $60 po
cada hora adicional. As, un programador que trabaja 40 horas recibe $1600, mientras que el
que trabaja 42 horas recibe 1600 + ( 42 40 ) * 60, que da un total de $1720. Escribe un
programa que lea el nmero de horas trabajadas por un programador e imprima el salario a
devengar.
//Calcula el salario de un programador.

public class SalarioProgramador {
final int HORAS_BASE = 40;
final int HORAS_EXTRA = 60;
final int SALARIO_SEMANA = 1600;
int nHoras, sueldoTotal;
// entrada
System.out.print("Horas trabajadas? ");
nHoras = entrada.nextInt();
// proceso
if (nHoras <= HORAS_BASE)
sueldoTotal = nHoras * HORAS_BASE;
else
sueldoTotal = SALARIO_SEMANA +
(nHoras - HORAS_BASE) * HORAS_EXTRA;
// salida
System.out.printf("El salario del trabajador es $%.2f",
sueldoTotal);
} // fin de la clase SalarioProgramador
Problema 5.
Escribe un programa que lea un nmero entero positivo tres cifras y determine si las cifras
del nmero son o no consecutivas (en orden ascendente o en orden descendente). En caso
que el nmero no sea un nmero positivo de tres cifras, el programa debe imprimir el
mensaje: "El nmero debe ser un entero positivo de tres cifras".
//Programa que lee un entero de tres cifras y determina si son

consecutivas.
66
Aprenda Java

public class CifrasConsecutivas {
// lectura
System.out.print("Nmero entero positivo de tres cifras? ");
// verifica el rango
if (numero >= 100 && numero <= 999) {
// determina las cifras del nmero
int centena = numero / 100;
int decena = (numero % 100) / 10;
int unidad = numero % 10;
// determina si las cifras son consecutivas

if ((decena == centena + 1 && unidad == decena + 1)
|| (decena == centena - 1 && unidad == decena - 1))
System.out.printf(
"Las cifras de %d son consecutivas\n", numero);
else
System.out.printf(
"Las cifras de %d no son consecutivas\n",
numero);
} // fin if
else
System.out.printf(
"%d debe ser un nmero positivo de tres cifras\n",
numero);
} // fin de la clase CifrasConsecutivas
Problema 6.
Escribe un programa que lea un nmero entero positivo de tres cifras y que con forme el
nmero mayor posible con esas cifras.
//Lee un nmero de tres cifras y obtiene el nmero mayor que

//se pueden obtener con esas tres cifras.
public class TresCifras {
int a, b, c;
67
Aprenda Java
// lectura
System.out.print("Nmero 3 cifras? ");
// proceso y salida
a = numero / 100;
numero = numero % 100;
b = numero / 10;
c = numero % 10;
if (a > b)
if (a > c)
if (b > c)
System.out.println(a + "" + b + "" + c);
else
System.out.println(a + "" + c + "" + b);
else
System.out.println(c + "" + a + "" + b);
else if (b > c)
if (c > a)
System.out.println(b + "" + c + "" + a);
else
System.out.println(b + "" + a + "" + c);
else
System.out.println(c + "" + b + "" + a);
} // fin de la clase TresCifras
Problema 7.
Escribe un programa, que dado como dato una temperatura en grados fahrenheit, determine
el deporte que es apropiado practicar a esa temperatura, teniendo en cuenta la siguiente
tabla:
Deporte Temperatura
Natacin > 85
Tenis 70 < TEMP 85
Golf 32 < TEMP 70
Esqu 10 < TEMP 32
Marcha 10
//Dada una temperatura recomienda el deporte a practicar.

public class Deporte {
68
Aprenda Java

// entrada
System.out.print("Temperatura en fahrenheit? ");
int temp = entrada.nextInt();
// proceso y salida
if (temp > 85)
System.out.println("Practica natacin");
else if (temp > 70)
System.out.println("Practica tenis");
else if (temp > 32)
System.out.println("Practica golf");
else if (temp > 10)
System.out.println("Practica esqu");
else
System.out.println("Practica la marcha");
} // fin de la clase Deporte
Problema 8.
Cuatro nmeros enteros entre 0 y 100 representan las puntuaciones de un estudiante de un

curso de programacin con Java. Escribe un programa para encontrar la media de estas
puntuaciones y visualizar una tabla de notas de acuerdo a lo siguiente:
Media (90-10), la puntuacin es una letra A.

Media (80-89), la puntuacin es una letra B.
Media (70-79), la puntuacin es una letra C.
Media (60-69), la puntuacin es una letra D.
Media (0-59), la puntuacin es una letra F.
//Calcula el promedio de cuatro calificaciones

public class PromedioAsignatura {
// variables
float calif1, calif2, calif3, calif4;
float promedio;
// entrada
System.out.print("Introduce las 4 califs (0-100)? ");
calif1 = entrada.nextFloat();
69
Aprenda Java
// proceso y salida
promedio = (calif1 + calif2 + calif3 + calif4) / 4.0f;
if (promedio >= 90)

System.out.println("Tienes una A.");
else if (promedio >= 80)
System.out.println("Tienes una B.");
System.out.println("Tienes una C.");
System.out.println("Tienes una D.");
else
System.out.println("Tienes una F.");
} // fin de la clase PromedioAsignatura
Problema 9.
Escribe un programa que solicitar una nota numrica entera entre 0 y 10, y mostrar dicha
nota de la forma: cero, uno, dos, tres, etc.
//Determina una nota numrica entre 0 y 10.

public class NotaNumerica {
System.out.print("Introduce una nota numrica entre 0 y 10: ");

switch (numero) {
case 0:
System.out.println("CERO");
break;
case 1:
System.out.println("UNO");
break;
case 2:
System.out.println("DOS");
break;
case 3:
System.out.println("TRES");
70
Aprenda Java
break;
case 4:
System.out.println("CUATRO");
break;
case 5:
System.out.println("CINCO");
break;
case 6:
System.out.println("SEIS");
break;
case 7:
System.out.println("SIETE");
break;
case 8:
System.out.println("OCHO");
break;
case 9:
System.out.println("NUEVE");
break;
} // fin switch
} // fin de la clase NotaNumerica
Problema 10.
Una cierta compaa fabricante de repuestos de automviles ha descubierto defectos en

algunos de sus productos, especficamente aquellos cuyos nmeros de serie se encuentran
dentro de los rangos: 14681 a 15681, 70001 a 79999 y 88888 a 111111. La compaia se lo
ha comunicado a la divisin de relaciones con los consumidores y desea un programa que
permita leer el nmero de serie y deducir si es o no defectuoso.
//Determina si un nmero de serie es defectuoso o no.

public class Repuestos {

int numeroSerie;
boolean defectuoso1;
// Prepara el teclado para la lectura de los datos

System.out.println("Nmero de serie es defectuoso");

System.out.println("-----------------------------");
71
Aprenda Java
System.out.print("Numero serie? "); // indicador

numeroSerie = entrada.nextInt();
defectuoso1 = (14681 <= numeroSerie && numeroSerie <= 15681);

if (defectuoso1 || defectuoso2 || defectuoso3)

System.out.printf(
"El nmero de serie %d es defectuoso.\n",
numeroSerie);
else
System.out.printf("El nmero de serie %d es correcto.\n",
numeroSerie);
} // fin de la clase NumeroSerie
72
Aprenda Java
4. Instrucciones de repeticin.
Escribir programas que utilicen instrucciones de repeticin.
4.1. Instruccin de repeticin while.
Una instruccin de repeticin (tambin llamada instruccin de ciclo, ciclo, o bucles) nos
permite especificar que un programa debe repetir una accin mientras que cierta condicin
sea verdadera. A las instrucciones a repetir se conocen como el cuerpo del ciclo y al hecho
de repetir la secuencia de instrucciones se denomina iteracin.
La instruccin de repeticin while permite que los programas repitan instrucciones mientras
que una condicin sea verdadera. En un ciclo while la condicin se evala antes de
cualquier repeticin del ciclo. Si la condicin es verdadera, el ciclo contina. Si es falsa
termina. El programa siguiente, ContadorWhile.java demuestra el uso de un ciclo while.
//Programa que muestra la sintaxis para la instruccin while.

public class ContadorWhile {
int contador = 1; // declara e inicializa
// la variable de control
while (contador <= 10) // condicin de continuacin de ciclo

{
System.out.println(contador);
contador++; // incrementa la variable de control en 1
} // fin de while
} // fin de la clase ContadorWhile
A este tipo de ciclos se les denomina ciclos controlados por contador ya que necesitamos
de una variable llamada contador (o variable de control) para controlar el nmero de veces
que debe ejecutarse un conjunto de instrucciones. El programa siguiente,
CicloWhile.java, utiliza un ciclo controlado por contador.
//Programa que muestra la sintaxis para la instruccin while.

public class CicloWhile {
int contador = 10; // declara e inicializa
// la variable de control
while (contador > 0) // condicin de continuacin de ciclo
73
Aprenda Java
{
contador--; // decrementa la variable de control en 1
} // fin de while
} // fin de la clase CicloWhile
El ciclo while se utiliza generalmente cuando el nmero de repeticiones no se conoce con

anticipacin. El programa siguiente, SumaWhile.java, utiliza un ciclo while para sumar los
primeros n nmeros naturales.
//El programa suma los N primeros nmeros naturales.

public class SumaWhile {
int i = 1; // variable de control
int suma = 0; // acumulador
int n; // representa los n primeros nmero naturales
// entrada
System.out.print("Cantidad de nmeros a sumar? ");
n = entrada.nextInt();
// proceso
while (i <= n) {
suma += i; // suma = suma + i;
i++; // i = i + 1;
} // fin while
// salida
System.out.printf("La suma es %d\n", suma);
} // fin de la clase SumaNaturales
El programa siguiente, es una versin mejorada del programa, Adivinanza.java, que

escribimos en la leccin anterior. Esta versin permite seguir jugando hasta que el usuario
adivine el nmero.

// genera el nmero aleatorio entre 0 y 100
74
Aprenda Java
System.out.println("Piensa un nmero entre 0 y 100.");
System.out.println("-------------------------------");
int numero = -1;

while (numero != numeroSecreto) {
// solicita un nmero al usuario
// evala
if (numero == numeroSecreto)
else if (numero < numeroSecreto)
else
} // fin while
El programa siguiente, es una versin mejorada del programa, Suma.java, que escribimos
en la leccin anterior y que nos permite practicar sumas sencillas un determinado nmero de
veces.
//Programa para practicar sumas.

public class Suma {
final int NUMERO_PREGUNTAS = 5; // nmero mximo de preguntas
int aciertos = 0; // contador de preguntas correctas
int contador = 0; // contador de preguntas
String reporte = ""; // el reporte inicialmente est vaco
while (contador < NUMERO_PREGUNTAS) {


System.out.printf("Cunto es %d + %d ? ",
75
Aprenda Java
numero1, numero2);
aciertos++;
} // fin if
else {
System.out.printf("%d + %d = %d\n", numero1, numero2,
(numero1 + numero2));
} // fin else
contador++; // incrementa el contador
// genera el reporte
reporte += "\n"
+ numero1
+ " + "
+ numero2
+ " = "
+ respuesta
+ ((numero1 + numero2 == respuesta) ? " correcto"
: " incorrecto");
} // fin while
// imprime los resultados obtenidos

System.out.printf("\nRespuestas correctas: %d\n%s",
aciertos, reporte);
4.2. Ciclos controlados por un valor centinela.
Un valor centinela (tambin llamada valor de seal, valor de prueba o valor de bandera)
indica el fin de la introduccin de datos en un ciclo. El programa siguiente,
SumaCentinela.java, utiliza un ciclo while controlado por centinela para sumar una
determinada cantidad de nmeros enteros.
//Programa para sumar nmeros utilizando ciclo while/centinela.

public class SumaCentinela {
int numero = 0;
int suma = 0;
76
Aprenda Java
System.out.print("Nmero a sumar (0 para terminar)? ");

numero = entrada.nextInt(); // lectura
while (numero != 0) {
suma += numero; // suma = suma + numero;
// lee el siguiente nmero
} // fin while
System.out.printf("La suma es %d", suma);
} // fin de la clase SumaCentinela
El programa siguiente, Promedio.java, utiliza un ciclo while controlado por centinela para
calcular la suma y promedio de una serie de nmeros.
//Lee una serie de nmeros enteros y calcula su promedio.

public class Promedio {
int numero = 0;
int contador = 0;
int suma = 0;
System.out.println(
"Ingresa una lista de nmeros enteros positivos.");
System.out.println(
"Marca el final de la lista con un nm negativo.");
System.out.println(
"Teclea la lista de nms: (ejemplo 4, 5, 4, 6, -3)");
while (numero >= 0) {

contador++; // contador = contador + 1;
} // fin while
if (contador == 0)
System.out.println("No ingresaste ningn nmero.");
else {
double promedio = (double) suma / contador;
System.out.printf("%d nmeros ledos.%n", contador);
System.out.printf("El promedio es %.2f ", promedio);
} // fin else
77
Aprenda Java

} // fin de la clase Promedio
4.3. Ciclos infinitos.
Al estar trabajando con ciclos es posible que ms de alguna vez provoquemos un ciclo
infinito. Un ciclo infinito es aquel que no logra que su condicin pueda concluir, y por tanto
detenerse. El programa siguiente, CicloInfinito.java, demuestra los ciclos infinitos.
//Demuestra los ciclos infinitos.

public class CicloInfinito {
int suma = 0, i = 0;
// este es un ciclo infinito

while (i < 10) {
suma = suma + i;
// la variable de control i no cambia
} // fin while
int contador = 1;
// otro ciclo infinito

while (contador != 50)
contador = contador + 2; // la condicin no se cumple
// otro ciclo infinito

while (true)
System.out.println("JavaJavaDo");
} // fin de la clase CicloInfinito
No debemos utilizar valores en punto flotante como variables de control en un ciclo.

Recuerda que los valores en punto flotante son valores aproximados y por lo tanto pueden
producir resultados imprecisos. El programa siguiente, ErrorNumerico.java, demuestra
como se produce un ciclo infinito con valores en punto flotante.
//Ciclos con nmeros en punto flotante.

public class ErrorNumerico {
double item = 1;
double suma = 0.0;
while (item != 0) { // No se garantiza que item tome el valor 0

suma += item;
78
Aprenda Java
item -= 0.1;
System.out.println("Procesando...item vale " + item);
} // fin while
System.out.println(suma);
} // fin de la clase ErrorNumerico
4.4. Instruccin de repeticin do/while.
La instruccin de repeticin do/while primero ejecuta el conjunto de instrucciones y despus

evala la condicin de continuacin del ciclo; por lo tanto, el cuerpo siempre se ejecuta por lo
menos una vez. Cuando termina una instruccin do/while, la ejecucin contina con la
siguiente instruccin en la secuencia. El programa siguiente, ContadorDoWhile.java, utiliza
la instruccin de repeticin do/while.
//La instruccin de repeticin do/while.

public class ContadorDoWhile {
int contador = 1; // inicializa contador
do {
System.out.printf("%d ", contador);
contador++; // incrementa la variable de control
} while (contador <= 10); // condicin de continuacin
} // fin de la clase ContadorDoWhile
Utilizamos el ciclo do/while cuando necesitamos por lo menos una repeticin del ciclo. El
programa siguiente, EncuentraUnTres.java, utiliza la instruccin de repeticin do/while
para generar un nmero aleatorio hasta que el nmero sea un tres.
//Ilustra el uso de la instruccin do/while.

public class EncuentraUnTres {
int numero;
do {
numero = (int) (Math.random() * 20) + 1;
System.out.println(numero);
} while (numero != 3);
System.out.println(
"El programa ha terminado, he encontrado un 3.");
79
Aprenda Java

} // fin de la clase EncuentraUnTres
El programa siguiente, SumaCentinela.java, utiliza la instruccin de repeticin do/while ,

para sumar una serie de nmeros enteros.
//Programa para sumar nmeros utilizando ciclo do/while/centinela.

public class SumaCentinela2 {
int numero = 0;
int suma = 0;
do {
// lee el siguiente nmero
} while (numero != 0); // fin do/while
System.out.printf("La suma es %d", suma);
} // fin de la clase SumaCentinela2
4.5. Instruccin de repeticin for.
La instruccin while puede utilizarse para implementar cualquier ciclo controlado por un
contador. Java, tambin cuenta con la instruccin for, que especifica los detalles de la
repeticin controlada por contador en una sola linea de cdigo. El programa siguiente,
CicloFor.java, ilustra la sintaxis bsica para el ciclo for.
//Muestra la estructura bsica de la instruccin for.

public class CicloFor {
for (int i = 0; i < 100; i++)
System.out.println("JavaJavaDo");
} // fin de la clase CicloFor
80
Aprenda Java
En el ciclo for, tenemos una variable de control (o contador del ciclo), un valor inicial, el
incremento o decremento de la variable de control y la condicin de continuacin del ciclo. El
programa siguiente, ContadorFor.java, utiliza la instruccin de repeticin for.
//Repeticin controlada con contador.

public class ContadorFor {
// el encabezado de la instruccin for incluye
// la iniacializacin, la condicin de continuacin
// del ciclo y el incremento/decremento
for (int contador = 10; contador > 0; contador--)
// esto es un error
// for( int i = 1; i < 10; i++ ); //genera un for vaco
// System.out.println( i );
} // fin de la clase ContadorFor
El programa siguiente, TablaMultiplicar.java, utiliza la instruccin de repeticin for para

imprimir una tabla de multiplicacin.
//El programa obtiene la tabla de mltiplicar de un nmero entero K.

public class TablaMultiplicar {
int nTabla, mult;
System.out.print("Tabla de multiplicar? ");

nTabla = entrada.nextInt();
for (int i = 1; i <= 10; i++) {

mult = nTabla * i;
System.out.printf("%d x %d = %d\n", nTabla, i, mult);
} // fin for
} // fin de la clase TablaMultiplicar
El programa siguiente, ParImpar.java, calcula la suma de nmeros pares e impares.
//Calcula la suma de los nmeros pares e impares.

final int LIM_INF = 1;
81
Aprenda Java
final int LIM_SUP = 200;

int sumaPar = 0;
int sumaImpar = 0;
// proceso
for (int i = LIM_INF; i <= LIM_SUP; i++) {
if (i % 2 == 0) // es par?
sumaPar += i; // sumaPar = sumaPar + i;
else
sumaImpar += i; // sumaImpar = sumaImpar + i;
} // fin for
// salida
System.out.printf("Suma pares: %d y Suma impares: %d\n",
sumaPar, sumaImpar);
4.6. Ciclos anidados.
Un ciclo anidado es un ciclo dentro de otro y los podemos combinar ( while,

do/while,for) dependiendo de las necesidades de programacin. El programa siguiente,
TablasMultiplicar.java, utiliza dos ciclos for anidados para imprimir las tablas de
mltiplicar del 1 al 10.
//Imprime las tablas de multiplicar del 1 al 9.

public class TablasMultiplicar {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 10; j++)
System.out.printf("%d x %d = %d\n", i, j, (i * j));
System.out.println();
} // fin for
} // fin de la clase TablasMultiplicar
El programa siguiente, ParejaValores.java, utiliza dos ciclos for anidados para imprimir
una pareja de valores.
//Imprime una pareja de valores.

public class ParejaValores {
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 2; j++)
System.out.printf("%d\t%d\n", i, j);
82
Aprenda Java

} // fin de la clase ParejaValores
El programa siguiente, NumerosPerfectos.java, encuentra los tres primeros nmeros

perfectos. Un nmero perfecto es un entero positivo, que es igual a la suma de todos los
enteros positivos (excluido el mismo) que son divisores del nmero. El primer nmero
perfecto es 6, ya que los divisores de 6 son 1, 2, 3 y 1 + 2 +3 = 6.
//El programa encuentra los tres primeros nmeros perfectos.

public class NumerosPerfectos {
int contador = 0;
int suma = 0;
int numero = 3; //iniciamos la bsqueda a partir del 3
final int MAX = 3;
while( contador < MAX ) {

for( int i = 1; i < numero; i++ ) {
if( numero % i == 0 )
suma += i;
} //fin for
if( suma == numero ) {

System.out.printf("%d es un nmero perfecto\n", numero );
contador++; //incrementa el contador de nmeros perfectos
} //fin if
numero++; //incrementa el nmero a buscar

suma = 0; //inicializa el valor de suma
} //fin while
} //fin de la clase NumerosPerfectos
4.7. Instruccin break y continue.
Adems de las instrucciones de seleccin y repeticin, Java cuenta con las instrucciones
break y continue para alterar el flujo de control de un programa. Anteriormente
utilizamos la instruccin break para terminar la ejecucin de una instruccin switch.
Cuando break se ejecuta en una instruccin while, do/while, for o switch, ocasiona la
salida inmediata de esa instruccin. La ejecucin contina con la primera instruccin
despus de la instruccin de control. Los usos comunes de break son para escapar
anticipadamente del ciclo, o para omitir el resto de una instruccin switch. El programa
siguiente, ForBreak.java, demuestra el uso de una instruccin break para salir de un ciclo
for.
83
Aprenda Java
//La instruccin break para salir de un ciclo for.

public class ForBreak {
// el mtodo main empieza la ejecucin de la aplicacin en Java
int cuenta; // la variable de control tambin se usa
// cuando termina el ciclo
for (cuenta = 1; cuenta <= 10; cuenta++) // itera 10 veces

{
if (cuenta == 5) // si cuenta es 5
break; // termina el ciclo
System.out.println(cuenta);
} // fin de for
System.out.println("Salio del ciclo en cuenta = " + cuenta);
} // fin de la clase ForBreak
Cuando la instruccin continue se ejecuta en una instruccin while, do/while o for, omite
las instrucciones restantes en el cuerpo del ciclo y contina con la siguiente iteracin del
ciclo. En las instrucciones while y do/while, el programa evala la prueba de
continuacin del ciclo justo despus de que se ejecuta la instruccin continue. En una
instruccin for se ejecuta la expresin de incremento y despus el programa evala la
prueba de continuacin del ciclo. El programa siguiente, ForContinue.java, utiliza la
instruccin continue en un ciclo for.
//Instruccin continue para terminar una iteracin de una instruccin for.

public class ForContinue {
for (int cuenta = 1; cuenta <= 10; cuenta++) // itera 10 veces
{
if (cuenta == 5) // si cuenta es 5,
continue; // omite el resto del cdigo en el ciclo
System.out.printf("%d ", cuenta);

} // fin de for
System.out.println("\nSe uso continue para omitir imprimir 5");
} // fin de la clase ForContinue
84
Aprenda Java
El programa siguiente, NumeroPrimo.java, determina si un nmero es primo. Un nmero es

primo si tiene nicamente dos divisores: 1 y el mismo nmero. Por ejemplo, 3 es primo
porque sus nicos divisores son 1 y 3; en cambio 8 no es primo porque a parte del 1 y el 8
tiene otros divisores.
//Programa que determina si un nmero es primo o no.

public class NumeroPrimo {
boolean esPrimo = true;
int numero;
// entrada
System.out.print("n? ");
// proceso
for (int i = 2; i <= numero / 2; i++) {
if (numero % i == 0) { // es primo?
esPrimo = false; // no es primo
} // fin if
} // fin for
// salida
if (esPrimo)
System.out.printf(" %d es primo\n", numero);
else
System.out.printf(" %d no es primo\n", numero);
} // fin de la clase NumeroPrimo
El programa siguiente, NumerosPrimos.java, imprime los primeros 50 nmeros primos.
//Programa que imprime los primeros 50 nmeros primos.

public class NumerosPrimos {
final int MAX_PRIMOS = 50; // nmero de primos a imprimir
final int NUMERO_POR_LINEA = 10; // nmero de primos por lnea
int contador = 0; // contador para los nmero primos
int numero = 2; // Valor inicial para la bsqueda de primos
System.out.println("Los 50 nmeros primos son:\n");
85
Aprenda Java
// encuentra los nmeros primos

while (contador < MAX_PRIMOS) {
// asume que el nmero es primo
boolean esPrimo = true;
// determina si el nmero es primo

for (int divisor = 2; divisor <= numero / 2; divisor++) {
if (numero % divisor == 0) {
esPrimo = false; // el nmero no es primo
} // fin if
} // fin for
// Imprime el nmero primo e incrementa el contador

if (esPrimo) {
contador++; // incrementa el contador de primos
if (contador % NUMERO_POR_LINEA == 0) {
// inicia una nueva lnea
} // fin if
else {
System.out.print(numero + "\t");
} // fin else
} // fin if
// busca si el siguiente nmero es primo

numero++;
} // fin while
} // fin de la clase NumerosPrimos
La programacin con instrucciones de repeticin nos permite que nuestros programas

realicen tareas interesantes ya que se pueden resolver gran variedad de problemas sobre
todo si los complementamos con las instrucciones estudiadas en las lecciones anteriores.
Problema 1.
Escribe un programa que lea un nmero entero y que imprima su cuadrado; el proceso debe
repetirse hasta que se introduzca un nmero negativo.
//Imprime el cuadrado de un nmero hasta que se introduce

//un nmero negativo.
86
Aprenda Java

public class Cuadrado {
int numero;
int cuadrado;
System.out.print("Introduce un nmero entero: ");

while (numero >= 0) {

cuadrado = numero * numero;
System.out.printf("El cuadrado de %d es %d\n",
numero, cuadrado);
// el ciclo se repite hasta que se lea un numero negativo

System.out.print("Introduce otro nmero entero: ");
} // fin while
System.out.println(">>>Fin del programa...");

} // fin de la clase Cuadrado
Problema 2.
Escribir un programa que lea un nmero entero e indique si es un nmero positivo o

negativo. El proceso se repetir hasta que se introduzca un 0.
//Imprime si un nmero es positivo/negativo hasta que se

//introduce un nmero cero.
public class PositivoNegativo {
System.out.println("Introduce un nmero positivo/negativo. ");

System.out.print("(0 para terminar)? ");
if (numero > 0)
System.out.printf("%d es positivo\n", numero);
else
System.out.printf("%d es negativo\n", numero);
87
Aprenda Java
// el ciclo se repite hasta que se lea un cero

System.out.println(
"Introduce otro nmero positivo/negativo.");
System.out.print("(0 para terminar)? ");
} // fin while
System.out.println(">>>Fin del programa...");
} // fin de la clase PositivoNegativo
Problema 3.
Escribe un programa que lea un nmero entero y sume los dgitos individuales de ese
nmero. Por ejemplo para el nmero 234 el resultado es 9.
//Suma los dgitos de un nmero.

public class SumaDigitos {
int numero = 0;
int suma = 0;
int temporal = 0;
int digito = 0;
System.out.println("Suma los dgitos de un nmero.");

temporal = numero;
while (temporal > 0) {
// obtiene el dgito
digito = temporal % 10;
// lo suma
suma += digito;
// recorta la cifra
} // fin while
System.out.printf("La suma de los dgitos de %d es %d",
numero, suma);
} // fin de la clase SumaDigitos
88
Aprenda Java
Problema 4.
Escribe un programa que lea un nmero entero y determine si es el nmero es palndromo.

Por ejemplo: 12321, 55555, 45554 son nmeros palndromos.
//Determina si un nmero es palndromo.

public class Palindromo {
int numero = 0;
int inverso = 0;
int temporal = 0;
int digito = 0;
System.out.println("Determina si un nmero es palndromo.");

System.out.println("-------------------------------------");
temporal = numero;
while (temporal > 0) {
// obtiene el dgito
digito = temporal % 10;
// forma el nmero inverso
inverso = (inverso * 10) + digito;
// recorta la cifra
} // fin while
if (numero == inverso)
System.out.printf("%d es palndromo", numero);
else
System.out.printf("%d no es palndromo", numero);
} // fin de la clase Palindromo
Problema 5.
La siguiente se llama la conjetura de ULAM en honor del matemtico S.Ulam:
Comience con cualquier entero positivo.

Si es par, divdalo entre 2; si es impar, multpliquelo por 3 y agrguele 1.
Obtenga enteros sucesivamente repitiendo el proceso.

Al final, obtendr el nmero 1, independientemente del entero inicial. Por ejemplo, cuando el
89
Aprenda Java
entero inicial es 26, la secuencia ser: 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1.
Escribe un programa que lea un entero positivo y obtenga e imprima la sucesin de ULAM.
//Imprime la serie para la conjetura de ULAM.

public class ConjeturaUlam {

System.out.println("Conjetura de ULAM");
System.out.print("Introduce un nmero entero: ");
if (numero % 2 == 0)
numero = numero / 2;
else
numero = numero * 3 + 1;
} // fin while
} // fin de la clase ConjeturaUlam
Problema 6.
Escribir un programa que imprima y obtenga la suma de los trminos de la siguiente serie:
2, 5, 7, 10, 12, 15, 17, ..., 1800.
//El programa imprime y suma los trminos de una serie.

//2, 5, 7, 10, 12, 15, 17, ..., 1800.
public class Serie1 {
final int LIMITE = 1800;
final int NUMERO_POR_LINEA = 10;
int contador = 0; //cuenta los nmeros por rengln
int i = 2;
int sumaSerie = 0;
boolean indicador = true;
while( i <= LIMITE ) {

sumaSerie += i;
contador++; //cuenta los nmeros por lnea
90
Aprenda Java
//imprime la serie
if( contador % NUMERO_POR_LINEA == 0 )
System.out.println(i);
else
System.out.print( i + "\t");
if( indicador ) {
i += 3;
indicador = false;
} //end if
else {
i += 2;
indicador = true;
} //fin else
} //fin while
System.out.printf( "\nLa suma de la serie es %d", sumaSerie );

} //fin de la clase SumaSerie1
Problema 7.
Escribe un programa que lea un nmero entero N y calcule el resultado de la siguiente serie:
1 1 1 1
1+ + + + ...+
2 3 4 N
//Calcula el resultado de una determinada serie.
double serie = 0.0;
System.out.println("Calcula la suma de la serie:");

System.out.println("1 + 1/2 + 1/3 + ... + 1/n");
System.out.println("----------------------------");
// entrada
System.out.print("Introduce el nmero n: ");
// proceso
for (int i = 1; i <= numero; i++)
serie = serie + 1.0 / i;
91
Aprenda Java
// salida
System.out.printf("La suma de la serie es %.2f\n", serie);
} // fin de la clase Serie2
Problema 8.
Escribe un programa que lea un nmero entero N y calcule el resultado de la siguiente serie:
1 1 1 1
1 + + ...
2 3 4 N
//Calcula el resultado de una serie determinada.

double serie = 0.0;
boolean bandera = true;
System.out.println("Calcula la suma de la serie:");

System.out.println("1 - 1/2 + 1/3 - 1/4 ... +- 1/n");
System.out.print("Introduce el nmero n: ");

for (int i = 1; i <= numero; i++) {

if (bandera) {
serie += 1.0 / i;
bandera = false;
} // fin if
else {
serie -= 1.0 / i;
bandera = true;
} // fin else
} // fin for
System.out.printf("La suma de la serie es %.2f\n", serie);

} // fin de la clase Serie3
92
Aprenda Java
Problema 9.
Escribe un programa que calcule el factorial de un nmero. Por ejemplo, el factorial de 4! = 4

x 3 x 2 x 1.
//Calcula el factorial de un nmero. 5!= 4x3x2x1.

public class Factorial {
int numero = 0;
int factorial = 1;
System.out.println("Factorial de un nmero.");
System.out.println("-----------------------");
for (int i = 2; i <= numero; i++)

factorial *= i;
System.out.printf(
"El factorial de %d! es %d", numero, factorial);
} // fin de la clase Factorial
Problema 10.
Escribe un programa que calcule el trmino 20 de la secuencia de FIBONACCI. Recuerda

que los dos primeros nmeros de la serie son 0 y 1. El resto se calcula como la suma de los
dos inmediatos nmeros que le preceden. Ejemplo de la serie: 0, 1, 2, 3, 5, 8, 13, 21, 34,
55,...n.
//Calcula el trmino 20 de la secuencia de Fibonacci.

//Ejemplo de la serie: 0, 1, 2, 3, 5, 8, 13, 21, 34, 55,...n
public class Fibonacci {
final int NUMERO_POR_LINEA = 10; // nmero de primos por lnea
int contador = 0; // contador de la secuencia de nmeros
int n1 = 0; // primer valor de la serie
int n2 = 1; // el valor siguiente
int siguiente;
System.out.println( "Serie de Fibonacci." );

System.out.println( "-------------------" );
93
Aprenda Java
for (int i = 3; i <= 22; i++) {

siguiente = n1 + n2;
n1 = n2;
n2 = siguiente;
contador++; // incrementa el contador de nmeros

if (contador % NUMERO_POR_LINEA == 0) {
// inicia una nueva lnea
System.out.println(siguiente);
} // fin if
else {
System.out.print(siguiente + "\t");
} // fin else
} // fin for
} // fin de la clase Fibonacci
94
Aprenda Java
5. Utilizacin de mtodos pre-construidos.

Conocer algunos mtodos pre-construidos de la API de Java tales como los de la

clase Math, String, el mtodo printf de System.out, NumberFormat y DecimalFormat.
5.1. Mtodos de la clase Math.
Java contiene muchas clases predefinidas que se agrupan en categoras de clases

relacionadas, llamadas paquetes. En conjunto, nos referimos a estos paquetes como la
Interfaz de Programacin de Aplicaciones de Java (API de Java), o biblioteca de clases
de Java.
La clase Math es una de las clases pre-construidas en el paquete java.lang. Esta clase
contiene mtodos que implementan funciones matemticas estndar. Adems de proveer
mtodos matemticos, la clase Math tambin provee dos constantes matemticas: PI y e (la
base para los logaritmos naturales).
Todos los mtodos en la clase Math son static. El modificador static significa que son
mtodos de clase y deben llamarse antecediendo el nombre del mtodo con el de la clase
en la cual estn definidos. El programa siguiente, MathDemo.java utiliza algunos mtodos
de la clase Math.
//Utiliza algunos mtodos de la clase Math.

public class MathDemo {
// el valor absoluto
System.out.println(Math.abs(23.7)); // 23.7
System.out.println(Math.abs(0.0)); // 0.0
System.out.println(Math.abs(-23.7)); // 23.7
// redondea x al entero ms pequeo que no sea menor de x
System.out.println(Math.ceil(9.2)); // 10.0
System.out.println(Math.ceil(-9.8)); // -9
// redondea x al entero ms grande que no sea mayor que x
System.out.println(Math.floor(9.2)); // 9.0
System.out.println(Math.floor(-9.8)); // -10
// el valor ms grande de x y y
System.out.println(Math.max(2.3, 12.7)); // 12.7
System.out.println(Math.max(-2.3, -12.7)); // -2.3
// el valor ms pequeo de x y y
95
Aprenda Java
System.out.println(Math.min(2.3, 12.7)); // 2.3

System.out.println(Math.min(-2.3, -12.7)); // -12.7
// La raz cuadrada de x
System.out.println(Math.sqrt(9)); // 3
// x elevado a la potencia y
System.out.println(Math.pow(2, 3)); // 8
System.out.println(Math.pow(9, 0.5)); // 3
// genera un nmero aleatorio 0..1 sin incluir el 1
System.out.println(Math.random());
} // fin de la clase MathDemo
Recuerda que los valores numricos que se pasan como argumento a los mtodos deben de
coincidir y que posiblemente suceda una conversin automtica de esos valores.
El programa siguiente MayorMenor.java nos ilustra las ventajas de utilizar mtodos pre-
construidos.
//Demuestra el uso de Math.min y Math.max.

import static java.lang.Math.*;
public class MayorMenor {
System.out.print("Introduce tres nmeros: ");

// evitar reinventar la rueda...reutilizar las clases y

// mtodos de la API de Java
// hay que tener presente la promocin y
// conversin de argumentos
// encuentra el mayor
int mayor = max(num1, max(num2, num3));
// encuentra el menor
int menor = min(num1, min(num2, num3));
System.out.printf("El mayor es %d%n", mayor);

System.out.printf("El menor es %d%n", menor);
96
Aprenda Java
} // fin de la clase MayorMenor
5.2. Formateo de la salida.
El mtodo printf de la clase System nos permite imprimir texto formateado. El programa
siguiente, PrintfDemo.java, ilustra como utilizar algunos especificadores de formato para
imprimir texto formateado.
//Demuestra el formato de cadenas con printf

public class PrintfDemo {
System.out.println("123456789012345678901234567890123456789");
System.out.println("---------+---------+---------+---------");
// imprime un nmero entero
System.out.printf("%d %n", 1974);
// agrega un cero a los espacios restantes
System.out.printf("%08d %n", 1974);
// si no se especifica el cero se usa un caracter vaco
System.out.printf("%8d %n", 1974);
// signo positivo y negativo
System.out.printf("+%d %n", 1974);
System.out.printf("-%d %n", 1974);
// agregando el separador de coma
System.out.printf("%,d %n%n", 1974);
// imprime un nmero en punto flotante
System.out.printf("%f %n", Math.PI);
// 3 digitos despus del punto decimal
System.out.printf("%.3f %n", Math.PI);
// 8 caracteres y 2 digitos
System.out.printf("%8.3f %n", Math.PI);
} // fin de la clase PrintfDemo
El programa siguiente PrintfTabla.java es otro ejemplo de como imprimir texto

formateado.
//Utiliza printf para dar formato a una tabla.

public class PrintfTabla {
// imprime un encabezado
System.out.printf("%s%10s%8s%n", "Num", "Cuadrado", "Triple");
System.out.println("---------------------");
97
Aprenda Java
for (int i = 1; i <= 10; i++)

System.out.printf("%3d%10d%8d%n", i, i * i, i * i * i);
} // fin de la clase PrintfTabla
Otra manera de dar formato al texto es mediante el mtodo format de la clase String. Este
mtodo trabaja de la misma manera que el mtodo printf de la clase System. El programa
siguiente, StringFormatDemo.java, muestra como dar formato al texto.
//Demuestra el formato de cadenas con String.format.

public class StringFormatDemo {
// imprime un nmero entero
String cad = String.format("%d", 1974);
System.out.println(cad);
// agrega un cero a los espacios restantes
cad = String.format("%08d", 1974);
// si no se especifica el cero se usa un caracter vaco
cad = String.format("%8d", 1974);
// signo positivo y negativo
cad = String.format("+%d", 1974);
cad = String.format("-%d", 1974);
// agregando el separador de coma
cad = String.format("%,d %n%n", 1974);
System.out.printf(cad);
// imprime un nmero en punto flotante
cad = String.format("%f", Math.PI);
// 3 digitos despus del punto decimal
cad = String.format("%.3f", Math.PI);
// 8 caracteres y 2 digitos
cad = String.format("%8.3f", Math.PI);
} //fin de la clase StringFormatDemo
98
Aprenda Java
5.3. Mtodos de la clase String.
La clase String es otra de las clases del paquete java.lang. La clase String contiene
muchos mtodos tiles para la manipulacin de cadenas. El programa siguiente
StringDemo.java utiliza algunos mtodos de la clase String.
//Demuestra algunos mtodos de la clase String.

public class StringDemo {
String mensaje = "Ahora es el tiempo de Java";
System.out.println("+--------+---------+---------+");
System.out.println(mensaje);
System.out.println(mensaje.charAt(6)); // e
System.out.println(mensaje.length()); // 26
System.out.println(mensaje.indexOf('e')); // 6
System.out.println(mensaje.indexOf("es")); // 6
System.out.println(mensaje.substring(19)); // de Java
System.out.println(mensaje.substring(0, 6)); // de Java
System.out.println(mensaje.toLowerCase());
System.out.println(mensaje.toUpperCase());
System.out.println(mensaje.replace('e', '9'));
} // fin de la clase StringDemo
El programa siguiente, CompararString.java, muestra como se deben comparar dos

cadenas en Java.
//Ilustra como comparar cadenas.

public class CompararString {
String cadUno = new String("Java");
String cadDos = new String("CSharp");
// la forma incorrecta de comparar dos cadenas

if (cadUno == cadDos)
System.out.println("Son iguales");
else
System.out.println("No son iguales");
99
Aprenda Java
// la forma correcta
if (cadUno.equals("Java"))
System.out.println("Son iguales (Java)");
else
if (cadDos.equalsIgnoreCase("CSHARP"))
System.out.println("Son iguales (CSharp)");
else
} // fin de la clase CompararString
5.4. Formateo de nmeros.
La clase NumberFormat se utiliza para formatear nmeros permitiendo que el cdigo sea
independiente de las convenciones propias de cada pas. El programa siguiente,
NumberFormatDemo.java, ilustra lo anterior.
//Demuestra el formato para las monedas

import java.text.NumberFormat;
import java.util.Locale; //para usar formatos de otros paises
public class NumberFormatDemo {
System.out.println("Nmeros sin formato:");
System.out.println(19.8);
System.out.println(19);
System.out.println("Usando el formato por default:");

NumberFormat moneda = NumberFormat.getCurrencyInstance();
// observa los nmeros redondeados
System.out.println(moneda.format(19.8));
System.out.println(moneda.format(19));
System.out.println("Usando el formato de UK:");

NumberFormat monedaUK =
NumberFormat.getCurrencyInstance(Locale.UK);
System.out.println(monedaUK.format(19.8));
100
Aprenda Java
System.out.println(monedaUK.format(19));
} // fin de la clase NumberFormatDemo
La clase DecimalFormat nos permite mostrar nmeros con un formato deseado, es decir,
limitar el nmero de decimales, si usaremos punto o coma, etc. El programa siguiente,
DecimalFormatDemo.java, ilustra lo anterior.
//Demuestra el formato para nmeros

import java.text.DecimalFormat;
public class DecimalFormatDemo {
DecimalFormat patron1 = new DecimalFormat("00.000");
DecimalFormat patron2 = new DecimalFormat("0.00");
double numero = 2.3456789;

System.out.println("Patrn 1: 00.000");
System.out.println(patron1.format(numero));
System.out.println("Patrn 2: 0.00");
DecimalFormat patron3 = new DecimalFormat("##.###");

DecimalFormat patron4 = new DecimalFormat("#.##");
System.out.println("Patrn 3: ##.###");
System.out.println("Patrn 4: #.##");
DecimalFormat porcentaje1 = new DecimalFormat("0.00%");

System.out.println("Patrn 5: 0.00%");
System.out.println(porcentaje1.format(0.308));
DecimalFormat porcentaje2 = new DecimalFormat("#.##%");

System.out.println("Patrn 6: #.##%");
System.out.println(porcentaje2.format(0.308));
} // fin de la clase DecimalFormatDemo
101
Aprenda Java
6. Mtodos.
Utilizar la programacin modular mediante mtodos void y con valor de retorno en los
programas Java.
6.1. Programacin modular.
La programacin modular es una metodologa de programacin que permite construir un

programa grande descomponindolo en pequeos subprogramas o mdulos. Para ello se
parte de un mdulo principal que se descompone en varios submdulos que son controlados
por el mdulo principal. Si la tarea asignada a un mdulo es demasiado compleja este
deber descomponerse en otros mdulos ms pequeos hasta lograr mdulos que hagan
tareas relativamente sencillas. A este proceso de refinamiento sucesivo se conoce tambin
como la tcnica de divide y vencers.
Las tareas asignadas a los subprogramas pueden ser de diversa ndole: entrada, salida,
clculos, control de otros mdulos, etc. Para que un subprograma pueda efectuar su
tarea tiene que ser llamado o invocado por el programa principal o por algn otro mdulo
que considere necesario el servicio del subprograma. Una vez que el subprograma termina
su tarea, devuelve el control al punto donde se hizo la llamada. Un subprograma puede
llamar a su vez a otros subprogramas.
En el lenguaje Java a los mdulos o subprogramas se les conoce con el nombre de

mtodos.
6.2. Mtodos void.
Un mtodo tipo void es un mdulo de programa que puede recibir datos de entrada a travs
de parmetros; pero, que no retorna ningn resultado al punto donde es invocado, razn por
el que se le conoce tambin como mtodo sin valor de retorno. Los mtodos tipo void
pueden dividirse a su vez en dos tipos:
Mtodos tipo void sin parmetros.

Mtodos tipo void con parmetros.
6.3 Mtodos void sin parmetros.
Estos mtodos no pueden recibir datos de entrada ni retornar ningn resultado al punto de su
invocacin. El programa siguiente, TestMetodoVoid.java, ilustra lo mencionado
anteriormente.
102
Aprenda Java
//Define y utiliza un mtodo void.

public class TestMetodoVoid {
public static void saludo() {
System.out.println("Saludos programador Java!");
} // fin del mtodo saludo

// invoca al mtodo static
saludo();
} // fin de la clase TestMetodoVoid
Recuerda: si el encabezado del mtodo tiene la palabra clave void (localizado a la izquierda
del nombre del mtodo) significa que el mtodo no devuelve ningn valor. En este curso
utilizaremos mtodos con el modificador static.
Estudiemos otro ejemplo. El programa siguiente, Temperatura.java, utiliza mtodos void

para convertir de celsius a fahrenheit respectivamente.
//Utiliza dos mtodos para convertir de celsius a fahrenheit y viceversa.

public class Temperatura {
// convierte de Fahrenheit a Celsius
public static void fahrenheitCelsius() {
double fahrenheit, celsius; // variables locales
// lee la temperatura
System.out.print("Ingresa una temperatura en Fahrenheit: ");
fahrenheit = entrada.nextDouble();
// realiza la conversin
celsius = 5.0 / 9.0 * fahrenheit - 32;
System.out.printf("La temperatura en Celsius es %.2f%n",
celsius);
} // fin del mtodo fahrenheitCelsius
// convierte de celsius a fahrenheit

public static void celsiusFahrenheit() {
double fahrenheit, celsius; // variables locales
// lee la temperatura
System.out.print("Ingresa una temperatura en Celsius: ");
103
Aprenda Java
celsius = entrada.nextDouble();
// realiza la conversin
fahrenheit = 9.0 / 5.0 * celsius + 32;
System.out.printf("La temperatura en Fahrenheit es %.2f%n",
fahrenheit);
} // fin del mtodo celsiusFahrenheit

int opcion; // variable local
System.out.println("1. Convertir de Fahrenheit a Celsius.");
System.out.println("2. Convertir de Celsius a Fahrenheit.");
// lee la opcin del usuario

System.out.print("Opcin: ");
opcion = entrada.nextInt();
if (opcion == 1)
fahrenheitCelsius();
else
celsiusFahrenheit();
} // fin de la clase Temperatura
6.4. Mtodos void con parmetros.
Estos mtodos reciben datos de entrada a travs de parmetros; pero, al igual que en el
caso anterior no pueden retornar ningn resultado al punto de su invocacin. El nmero de
parmetros es variable y depende de las necesidades del mtodo. El programa siguiente,
Curso.java, declara y utiliza un mtodo con un parmetro para imprimir un mensaje de texto
dependiendo del valor que se recibe como argumento.
//Declaracin de un mtodo con un parmetro.

public class Curso {
// muestra un mensaje de bienvenida
public static void mostrarMensaje(String nombreCurso) {
System.out.printf("Bienvenido al curso de %s%n", nombreCurso);
} // fin del mtodo mostrarMensaje

mostrarMensaje("Java"); // llamada al mtodo
104
Aprenda Java
mostrarMensaje("C Sharp"); // llamada al mtodo

} // fin de la clase Curso
El programa siguiente, NotaExamen.java, recibe como dato de entrada una calificacin e

imprime una nota.
//Define un mtodo void que recibe un valor como argumento.

public class NotaExamen {
public static void calificar(double calificacion) {
if (calificacion >= 90.0)
System.out.println('A');
else if (calificacion >= 80.0)
System.out.println('B');
System.out.println('C');
System.out.println('D');
else
System.out.println('F');
} // fin del mtodo calificar

System.out.print("Obtuviste una ");
calificar(78.5);
System.out.print("Obtuviste una ");

calificar(59.5);
} // fin de la clase NotaExamen
6.5. Mtodos return.
Un mtodo con valor de retorno es un mdulo de programa que puede recibir datos de
entrada a travs de parmetros y que retorna un resultado al punto donde es invocado. Este
tipo de mtodo se utiliza para efectuar cualquier tipo de proceso que produzca un resultado .
Estos mtodos pueden dividirse a su vez en dos tipos:
Mtodos con valor de retorno sin parmetros.

Mtodos con valor de retorno con parmetros.
105
Aprenda Java
6.6. Mtodos return, sin parmetros.
Este tipo de mtodos no reciben datos de entrada; pero, retornan un resultado al punto
donde son invocados. El programa siguiente, TestMetodoReturn.java, define un mtodo
con valor de retorno, sin parmetros.
//Define y utiliza un mtodo return

public class TestMetodoReturn {
public static String saludo() {
return "Saludos programador Java!";
} // fin del mtodo saludo

// invoca al mtodo static
System.out.println(saludo());
} // fin de la clase TestMetodoReturn
Recuerda: siempre que en el encabezado de un mtodo sea diferente de void, el mtodo

debe devolver un valor a travs de la instruccin return, y el tipo de valor debe coincidir con
el especificado en el encabezado del mtodo.
6.7. Mtodos return con parmetros.
Estos mtodos reciben datos de entrada a travs de parmetros y retornan un resultado al

punto de su invocacin. El programa siguiente, AreaCirculo.java declara y utiliza un
mtodo con valor de retorno con un parmetro.
//Utiliza un mtodo con un parmetro para calcular

//el rea de un crculo.
// calcula el area de un circulo
public static double area(double radio) {
return (Math.PI * Math.pow(radio, 2));
} // fin del mtodo area

System.out.print("Radio del crculo:? ");

double radio = entrada.nextDouble();
System.out.printf("El radio del circulo es de %.2f cms.%n",

radio);
106
Aprenda Java
System.out.printf("El rea del circulo es de %.2f cms.",

area(radio));
El programa siguiente, PieMetro.java, declara y utiliza dos mtodos con valor de retorno y
un parmetro para calcular la equivalencia pie a metro y viceversa.
//Convierte pies a metros y viceversa.

public class PieMetro {
public static double pieMetro(double pie) {
return 0.305 * pie;
} // fin del mtodo pieMetro
public static double metroPie(double metro) {

return metro / 0.305;
} // fin del mtodo metroPie

final int MAX = 10;
double pies = 1.0; // valor inicial
double metros = 20.0; // valor inicial
System.out.printf("%s%9s%9s%9s%n",
" Pies", "Metros", "Metros", "Pies");
for (int i = 1; i <= MAX; i++) {

System.out.printf("%6.2f%9.2f%9.2f%9.2f%n",
pies, pieMetro(pies), metros, metroPie(metros));
pies++; // incrementa los pies
metros += 5; // incrementa los metros
} // fin for
} // fin de la clase PiesMetros
El programa siguiente, PrimosGemelos.java, encuentra los primeros 10 nmeros primos

gemelos. Por ejemplo, 2 y 3 son los nicos primos seguidos. Pero hay un gran nmero de
pares de nmeros primos que difieren en dos unidades, por ejemplo: 3 y 5, 5 y 7, 11 y 13,
etc.
//Encuentra los 10 primeros nmeros primos gemelos.

//(3,5),(5,7),(11,13)...etc.
public class PrimosGemelos {
// determina si un nmero es primo
public static boolean esPrimo(int n) {
for (int divisor = 2; divisor <= n / 2; divisor++)
107
Aprenda Java
if (n % divisor == 0) // es divisible?
return false; // el nmero no es primo
return true; // el nmero es primo
} // fin del mtodo esPrimo

final int MAX_PRIMOS = 10;
int contador = 0; // cuenta el nmero de primos
int numero = 2; // inicia bsqueda
// repetidamente encuentra los primos gemelos

while (contador < MAX_PRIMOS) {
if (esPrimo(numero)) { // primo A
if (esPrimo(numero + 2)) { // primo B ( A + 2)
System.out.printf(
"%d y %d son primos gemelos\n", numero,
numero + 2);
contador++; // incrementa contador primos
}
} // fin if
numero++; // para buscar el siguiente primo
} // fin while
} // fin de la clase PrimosGemelos
El programa siguiente, ParesPrimos.java, declara y utiliza un mtodo esPrimo para

determinar si un nmero es primo. El mtodo esPrimo se utiliza como auxiliar para
determinar en un rango de nmeros aquellos pares primos (AB, CD) donde ABCD tambin es
primo.
//Encuentra todos los pares primos (AB,CD) donde ABCD tambin es primo.
public class ParesPrimos {
// determina si un nmero es primo
private static boolean esPrimo(int n) {
for (int divisor = 2; divisor <= n / 2; divisor++)
if (n % divisor == 0) // es divisible?
return false; // el nmero no es primo
return true; // el nmero es primo
} // fin del mtodo esPrimo

final int MAX = 9999;
int numero = 1001; // inicia bsqueda
int ab = 0, cd = 0;
// repetidamente encuentra los pares primos
108
Aprenda Java
while (numero < MAX) {

if (esPrimo(numero)) { // es primo?
ab = numero / 100;
cd = numero % 100;
if (esPrimo(ab) && esPrimo(cd))
System.out.printf("Primo ABCD: %d (%d)(%d)\n",
numero, ab, cd);
} // fin if
numero++; // para buscar el siguiente primo
} // fin while
} // fin de la clase ParesPrimos
Un mtodo puede especificar mltiples parmetros; slo hay que separar un parmetro de
otro mediante una coma (lista separada por comas). El programa siguiente,
BuscadorMaximo.java, declara y utiliza un mtodo con mltiples parmetros.
//Mtodo mximo, declarado por el programador.

public class BuscadorMaximo {
// devuelve el mximo de sus tres parmetros double
public static double maximo(double x, double y, double z) {
double valorMaximo = x; // asume que x es el mayor para empezar
// determina si y es el mayor que valorMaximo

if (y > valorMaximo)
valorMaximo = y;
// determina si z es mayor que valorMaximo

if (z > valorMaximo)
valorMaximo = z;
return valorMaximo;
} // fin del mtodo mximo
public static void determinarMaximo() {

// entrada
System.out.print(
"Escribe tres nmeros, separados por espacios: ");
double numero1 = entrada.nextDouble();
// determina el valor mximo
109
Aprenda Java
double resultado = maximo(numero1, numero2, numero3);
// muestra el valor mximo

System.out.println("El mximo es: " + resultado);
} // fin del mtodo determinarMaximo

// llama al mtodo static
determinarMaximo();
} // fin de la clase BuscadorMaximo
6.8. Compatibilidad de argumentos y parmetros.
El nmero de argumentos en la llamada a un mtodo debe coincidir con el nmero de

parmetros en la lista de parmetros de la declaracin del mtodo que se llam. Adems,
los tipos de los argumentos en la llamada al mtodo deben ser consistentes con los tipos de
ls parmetros correspondientes en la declaracin del mtodo. El programa siguiente,
PasoParametros.java, demuestra la compatibilidad de argumentos y parmetros.
//Demuestra la compatibilidad entre argumentos y parmetros.

public class PasoParametros {
public static void nPrint(String mensaje, int n) {
for (int i = 0; i < n; i++)
System.out.println(mensaje);
} // fin del mtodo nPrint

nPrint("Hola", 3); // El orden de los parmetros es correcto
// nPrint( 3, "Hola" ); //El orden es incorrecto
// nPrint( "Hola", 3.5 ); //El tipo es incorrecto
// nPrint(); //faltan argumentos

// nPrint( "Hola" ); //faltan argumentos
// nPront( "Hola, 2"); //el mtodo no est declarado
} // fin de la clase PasoParametros
Otra caracterstica importante de las llamadas a los mtodos es la promocin de

argumentos: convertir el valor de un argumento al tipo que el mtodo espera recibir en su
correspondiente parmetro.
Las reglas de promocin especifican qu conversiones son permitidas; esto es, qu

conversiones pueden realizarse sin perder datos. El programa siguiente,
PasoParametros2.java ilustra lo mencionado anteriormente.
110
Aprenda Java
//Demuestra la compatibilidad entre argumentos y parmetros.

public class PasoParametros2 {
public static double cuadrado(double n) {
return n * n;
} // fin del mtodo cuadrado

System.out.println(cuadrado(3)); // 3 -> 3.0
System.out.println(cuadrado(3.0F)); // 3.0F -> 3.0
System.out.println(cuadrado(3.0)); // el argumento es correcto
// System.out.println( cuadrado() ); //falta el argumento
// System.out.println( cuadrado("3") ); //el tipo es incorrecto
} // fin de la clase PasoParametros2
6.9. Mtodos sobrecargados (overload).
Pueden declararse mtodos con el mismo nombre en la misma clase, siempre y cuando
tengan distintos conjuntos de parmetros (determinados en base al nmero, tipos y orden de
los parmetros). A esto se le conoce como sobrecarga de mtodos. Cuando se hace una
llamada a un mtodo sobrecargado, el compilador de Java selecciona el mtodo apropiado
mediante un anlisis del nmero, tipos y orden de los argumentos en la llamada. Por lo
general, la sobrecarga de mtodos se utiliza para crear varios mtodos con el mismo nombre
que realicen la misma tarea o tareas similares. El programa siguiente, Sobrecarga.java,
utiliza mtodos sobrecargados.
//Declaraciones de mtodos sobrecargados.

public class Sobrecarga {
// mtodo al cuadrado con argumento int
public static int cuadrado(int valorInt) {
System.out.printf(
"\nSe llamo a cuadrado con argumento int: %d\n",
valorInt);
return valorInt * valorInt;
} // fin del mtodo cuadrado con argumento int
// mtodo al cuadrado con argumento double

public static double cuadrado(double valorDouble) {
System.out.printf("
\nSe llamo a cuadrado con argumento double: %f\n",
valorDouble);
return valorDouble * valorDouble;
} // fin del mtodo cuadrado con argumento double
// prueba los mtodos cuadrado sobrecargados
111
Aprenda Java
public static void probarMetodosSobrecargados() {

System.out.printf(
"El cuadrado del entero 7 es %d\n", cuadrado(7));
System.out.printf("El cuadrado del doble 7.5 es %f\n",
cuadrado(7.5));
// cuadrado(7.5F); //7.5F -> 7.5D
} // fin del mtodo probarMetodosSobrecargados

// invoca al mtodo
probarMetodosSobrecargados();
} // fin de main
} // fin de la clase Sobrecarga
El programa siguiente, Sobrecarga2.java, es otro programa que utiliza mtodos

sobrecargados.
//Demuestra el uso de los mtodos sobrecargados

public class Sobrecarga2 {
// regresa el mayor entre dos valores int
public static int max(int num1, int num2) {
if (num1 > num2)
return num1;
else
return num2;
} // fin del mtodo max
// regresa el mayor entre dos valores double

public static double max(double num1, double num2) {
if (num1 > num2)
return num1;
else
return num2;
// regresa el mayor de tres nmeros double

public static double max(double num1, double num2, double num3){
return (max(max(num1, num2), num3));

// invoca al mtodo max con dos parmetros int
System.out.printf("El mayor entre 3 y 4 es " + max(3, 4));
// invoca al mtodo max con dos parmetros double

System.out.println("El mayor entre 3.5 y 4.5 es "
+ max(4.5, 3.5));
112
Aprenda Java
// invoca al mtodo max con tres parmetros double

System.out.println("El mayor entre 3.5 y 4.5 y 10.5 es "
+ max(3.5, 4.5, 10.5));
} // fin de la clase Sobrecarga2
El compilador diferencia los mtodos sobrecargados en base a su firma: una combinacin

del nombre del mtodo y del nmero, tipos y orden de sus parmetros. El programa
siguiente, ErrorSobrecarga.java, ilustra los errores que genera el compilador cuando dos
mtodos tienen la misma firma, pero distintos valores de retorno.
//Muestra cuando sucede un error en la sobrecarga de mtodos.

public class ErrorSobrecarga {
// Este programa no funciona, el compilador marca un error
// de sintaxis.
// declara un mtodo con un argumento int

public int cuadrado(int x) {
return x * x;
public double cuadrado(int x) {

return x * x;
} // fin de la clase ErrorSobrecarga
Los mtodos sobrecargados pueden tener tipos de valor de retorno distintos si los mtodos
tienen distintas listas de parmetros. Adems, los mtodos sobrecargados no necesitan
tener el mismo nmero de parmetros.
6.10. El mbito de las variables.
Una variable local es una variable que es declarada y utilizada localmente dentro de un
mtodo. El bloque de una variable se establece por el par de llaves ms cercanas que
encierran la declaracin de la variable.
Los parmetros de un mtodo usualmente no se consideran como variables locales, pero

son muy similares a stas en el sentido de que son declaradas y utilizadas localmente dentro
del mtodo. Al igual que con las variables locales, el alcance de los parmetros en un
mtodo est limitado nicamente al cuerpo de ese mtodo. El programa siguiente,
Alcance.java, ilustra lo mencionado anteriormente.
113
Aprenda Java
//Programa que demuestra el mbito de una variable.

public class Alcance {
public static void metodoUno() {
int x = 5; // x es una variable local
int w = 5; // w es otra variable local
// la variable i es visible en el ciclo for

for (int i = 0; i < x; i++) {
System.out.println(i);
w = w + 1;
// la variable w/x es visible aqu tambin
} // fin for
// Esto es un error, la variable i no

//existe en este bloque
// System.out.println( i );
// manda llamar al mtodo, le pasa como argumento el valor de x

metodoDos(x);
} // fin del metodoUno
private static void metodoDos(int valor) {

int x = 5; // variable distinta de la variable x de metodoUno
x++; // modifica el valor de la variable local
// la variable local es visible en este bloque

System.out.println("El parmetro vale: " + valor);
// Esto es un error, la variable w no es visible en este bloque

// System.out.println( "w = " + w );
} // fin del metodoDos

metodoUno();
} // fin de la clase Alcance
114
Aprenda Java
La programacin con mtodos es un paso muy importante en el proceso de aprendizaje del

lenguaje de programacin Java ya que involucra los conceptos estudiados en las lecciones
anteriores.
Problema 1.
Escribe un programa controlado por men que permita calcular el rea de un triangulo,
cuadrado, circulo y rectngulo. El programa deber utilizar mtodos void y con valores de
retorno.
//Programa para practicar mtodos.

public class FigurasGeometricas {
private static double areaTriangulo(double base, double altura) {
return base * altura / 2.0;
} // fin del mtodo areaTriangulo
private static double areaCuadrado(double lado) {

return lado * lado;
} // fin del mtodo areaCuadrado
private static double areaCirculo(double radio) {

return Math.PI * radio * radio;
} // fin del mtodo areaCirculo
private static double areaRectangulo(double base, double altura){

return base * altura;
} // fin del mtodo areaRectangulo
private static void mostrarTitulo() {

System.out.println("Areas figuras geomtricas.");
} // fin del mtodo mostrarTitulo
// las opciones del men

private static void menuOpciones() {
System.out.println("Figuras:");
System.out.println("1. Tringulo.");
System.out.println("2. Cuadrado.");
System.out.println("3. Rectngulo.");
System.out.println("4. Crculo.");
System.out.print("Selecciona una opcin (1-4): ");
115
Aprenda Java
} // fin del mtodo menuOpciones
// el men del programa

private static void menu() {
// variable local
// muestra el ttulo del men

mostrarTitulo();
// muestra las opciones del men
menuOpciones();
// lee la opcin del teclado
int opcion = entrada.nextInt();
switch (opcion) {
case 1:
System.out.println("1. rea tringulo.");
calcularAreaTriangulo();
break;
case 2:
System.out.println("2. rea cuadrado.");
calcularAreaCuadrado();
break;
case 3:
System.out.println("3. rea rectngulo.");
System.out.println("-------------------");
calcularAreaRectangulo();
break;
case 4:
System.out.println("4. rea crculo.");
System.out.println("----------------");
calcularAreaCirculo();
break;
default:
System.out.println("Opcin del men invlida.");
} // fin switch
} // fin del mtodo menu
private static void calcularAreaTriangulo() {

System.out.print("Base? ");
double base = entrada.nextDouble();
116
Aprenda Java
double altura = entrada.nextDouble();
double area = areaTriangulo(base, altura);
System.out.printf("El rea es %.2f%n", area);

} // fin del mtodo calcularAreaTriangulo
private static void calcularAreaCuadrado() {

System.out.print("Lado? ");
double lado = entrada.nextDouble();
double area = areaCuadrado(lado);
System.out.printf("El rea es %.2f", area);

} // fin del mtodo calcularAreaCuadrado
private static void calcularAreaRectangulo() {

System.out.print("Base? ");
double base = entrada.nextDouble();
double altura = entrada.nextDouble();
double area = areaRectangulo(base, altura);

} // fin del mtodo calcularAreaRectangulo
private static void calcularAreaCirculo() {

double radio = entrada.nextDouble();
double area = areaCirculo(radio);

} // fin del mtodo calcularAreaCirculo

String opcion = null;
117
Aprenda Java
do {
menu();
System.out.print("\nDeseas continuar? (S/N)");
opcion = entrada.next();
} while (opcion.equals("S") || opcion.equals("s"));
System.out.println(">Fin del programa...");

} // fin de la clase FigurasGeometricas
Problema 2.
Escribir un programa controlado por men para practicar sumas, restas, multiplicaciones y
divisiones.
//Programa para practicar las operaciones aritmticas bsicas.

public class Aritmetica {
do {
menu();


System.out.println("Programa aritmtica 1.0.");
System.out.println("------------------------");

System.out.println("Operaciones:");
System.out.println("1. Sumar.");
System.out.println("2. Restar.");
System.out.println("3. Multiplicar.");
System.out.println("4. Dividir.");
118
Aprenda Java

private static void menu() {
// variable local
// muestra el ttulo del men

mostrarTitulo();
menuOpciones();
switch (opcion) {
case 1:
System.out.println("1. Practicar sumas.");
System.out.println("-------------------");
practicarSuma();
break;
case 2:
System.out.println("2. Practicar restas.");
System.out.println("--------------------");
practicarResta();
break;
case 3:
System.out.println("3. Practicar multiplicaciones.");
practicarMultiplicacion();
break;
case 4:
System.out.println("4. Practicar divisiones.");
practicarDivision();
break;
default:
} // fin switch
private static void practicarSuma() {

119
Aprenda Java

int numero1 = (int) (Math.random() * 9 + 1);

System.out.print(
"Cunto es " + numero1 + " + " + numero2 + " ? ");
aciertos++;
} // fin if
else {
System.out.println(numero1 + " + " + numero2 + " = "
+ (numero1 + numero2));
} // fin else
reporte += "\n"
+ numero1
+ " + "
+ numero2
+ " = "
+ respuesta
+ ((numero1 + numero2 == respuesta) ?
" correcto" : " incorrecto");
} // fin while
System.out.println("\nRespuestas correctas: " + aciertos + "\n"

+ reporte);
} // fin del mtodo practicarSuma
private static void practicarResta() {


120
Aprenda Java

int temp = numero1;
numero1 = numero2;
numero2 = temp;
} // fin if

System.out.print(
"Cunto es " + numero1 + " - " + numero2 + " ? ");
if (numero1 - numero2 == respuesta) {
aciertos++;
} // fin if
else {
System.out.println(numero1 + " - " + numero2
+ " = " + (numero1 - numero2));
} // fin else
reporte += "\n"
+ numero1
+ " - "
+ numero2
+ " = "
+ respuesta
+ ((numero1 - numero2 == respuesta) ?
} // fin while

+ reporte);
} // fin del mtodo practicarResta
private static void practicarMultiplicacion() {

121
Aprenda Java


System.out.print(
"Cunto es " + numero1 + " * " + numero2 + " ? ");
if (numero1 * numero2 == respuesta) {
aciertos++;
} // fin if
else {
System.out.println(numero1 + " * " + numero2 + " = "
+ (numero1 * numero2));
} // fin else
reporte += "\n"
+ numero1
+ " * "
+ numero2
+ " = "
+ respuesta
+ ((numero1 * numero2 == respuesta) ?
} // fin while

+ reporte);
} // fin del mtodo practicarMultiplicacion
private static void practicarDivision() {


122
Aprenda Java

int temp = numero1;
numero1 = numero2;
numero2 = temp;
} // fin if

System.out.print(
"Cunto es " + numero1 + " / " + numero2 + " ? ");
if (numero1 / numero2 == respuesta) {
aciertos++;
} // fin if
else {
System.out.println(numero1 + " / " + numero2 + " = "
+ (numero1 - numero2));
} // fin else
reporte += "\n"
+ numero1
+ " / "
+ numero2
+ " = "
+ respuesta
+ ((numero1 / numero2 == respuesta) ?
} // fin while

+ reporte);
} // fin del mtodo practicarDivision
} // fin de la clase Aritmetica
123
Aprenda Java
7. Arreglos unidimensionales.
Utilizar arreglos de una dimensin en los programas Java.
7.1. Declarar, crear y asignar valores a un arreglo unidimensional.
En Java, un arreglo es un grupo de variables (llamadas elementos o componentes) que

contienen valores, todos del mismo tipo. Para declarar un arreglo unidimensional, debemos
especificar el tipo de cada elemento y el nmero de elementos que se requieren para el
arreglo. El programa siguiente DeclararArreglo.java muestra como declarar un arreglo
unidimensional de tipo int y double.
//Declara un arreglo de una sola dimensin.

public class DeclararArreglo {
// declara un arreglo de tipo int
int[] edad;
// declara un arreglo de tipo double
double[] miArreglo;
// tambin se puede declarar as:

// int edad[]:
// double miArreglo[];
// esto es incorrecto
// int[5] edad;
// int edad[5];
// double(5) miArreglo;
// double miArreglo(5);
} // fin de la clase DeclaraArreglo
Para nombrar un arreglo unidimensional se siguen las mismas convenciones que los dems
nombres de variables adems de que tenemos que usar los corchetes. Los arreglos
unidimensionales se crean con la palabra clave new. El programa siguiente,
CrearArreglo.java crea un arreglo unidimensional de tipo int y double.
//Declara y crea un arreglo.

public class CrearArreglo {
// declara un arreglo de tipo int
int[] edad;
124
Aprenda Java
// crea el arreglo de tipo int

edad = new int[5];
// tambin se declara as:

// int[] edad = new int[5];
// double[] miArreglo;
// miArreglo = new Arreglo[10];
// declara y crea el arreglo en una sola lnea
double[] miArreglo = new double[10];
} // fin de la clase CrearArreglo
Al crear un arreglo unidimensional con la palabra clave new, tenemos que indicar su longitud
(cuntos valores va a contener) y el tipo de valores que van a estar contenidos en el arreglo
unidimensional . El programa siguiente, ValoresArreglo.java, crea y asigna valores a un
arreglo unidimensional de tipo double.
//Declara un arreglo de una sola dimensin.

public class ValoresArreglo {
// inicializa los valores del arreglo

miArreglo[0] = 5.6; // el arreglo inicia en la posicin 0
miArreglo[1] = 4.5;
miArreglo[2] = 3.3;
miArreglo[3] = 13.2;
miArreglo[4] = 4.0;
miArreglo[9] = 99.39; // el arreglo termina en la pos: n - 1
// esto es un error en tiempo de ejecucin

// genera un ArrayIndexOutOfBoundsException
// miArreglo[29] = 5.5;
} // fin de la clase ValoresArreglo
La manera en que un programa hace referencia a un elemento individual de un arreglo

unidimensional es especificando el valor de su ndice encerrado entre corchetes ([]). El
primer elemento en cualquier arreglo unidimensional tiene el ndice cero, y algunas veces se
le denomina elemento cero.
125
Aprenda Java
Al crear un arreglo unidimensional, cada uno de sus elementos, recibe un valor

predeterminado: cero para los valores numricos, false para los elementos boolean y
null para las referencias (hablaremos de las referencias a objetos en otro curso). El
programa siguiente, DefaultArreglo.java crea un arreglo unidimensional, accede al ndice
cero del arreglo unidimensional (para obtener su valor por default) y obtiene el tamao del
arreglo unidimensional.
//Tamao del arreglo y valores por default.

public class DefaultArreglo {
// accede al indice 0 del arreglo e

// imprime el valor por default
System.out.println("miArreglo[0] = " + miArreglo[0]);
// esto es un error, no se puede acceder a un indice ms grande

// System.out.println( "miArreglo[0] = " + miArreglo[25] );
// utiliza la propiedad length para obtener

// el tamao del arreglo
System.out.println("Tamao del arreglo = " + miArreglo.length);
// esto es un error, no se puede cambiar el tamao del arreglo

// miArreglo.length = 20;
} // fin de la clase DefaultArreglo
La expresin arreglo.length obtiene el tamao del arreglo unidimensional. Dado que los
arreglos unidimensionales (y de dos ms dimensiones) son de longitud fija, una vez
establecido el tamao del arreglo unidimensional este no se puede cambiar.
Un programa puede crear un arreglo unidimensional e inicializar sus elementos con un

inicializador de arreglo, que es una lista de expresiones separadas por comas (la cual se
conoce como lista inicializadora) encerrada entre llaves ({ y }); la longitud del arreglo
unidimensional se determina en base al nmero de elementos en la lista inicializadora. El
programa siguiente, DatosArreglo.java inicializa un arreglo unidimensional al declararlo.
//Declara e inicializa un arreglo.

public class DatosArreglo {
double[] miArreglo = { 1.9, 2.9, 3.4, 3.5 };
System.out.println("Contenido del arreglo:");

126
Aprenda Java

//esto es un error
//int[] lista;
//lista = {1,2,3,4,5};
} // fin de la clase DatosArreglo
El inicializador de un arreglo unidimensional no requiere utilizar la palabra clave new.

Cuando el compilador encuentra la declaracin de un arreglo unidimensional que incluya una
lista inicializadora, cuenta el nmero de inicializadores en la lista para determinar el tamao
del arreglo unidimensional, y despus establece la operacin new apropiada.
7.2. Operaciones bsicas con arreglos unidimensionales.
Los programas siguientes muestran como inicializar un arreglo unidimensional y algunas

operaciones bsicas para manipular esos arreglos.
El programa siguiente, LecturaArreglo.java inicializa un arreglo unidimensional con

valores ledos desde el teclado.
//Inicializar los valores de un arreglo.

public class LecturaArreglo {
int[] miArreglo;
System.out.print("Introduce el tamao del arreglo? ");

int tamao = entrada.nextInt();
// crea el arreglo
miArreglo = new int[tamao];
// lee los valores del teclado

System.out.println("Lectura de los datos del arreglo.");
for (int i = 0; i < miArreglo.length; i++) {
System.out.printf("Valor[%d]? ", i);
miArreglo[i] = entrada.nextInt();
} // fin for
// imprime el contenido del arreglo

System.out.println("\nEl contenido del arreglo:");
System.out.printf("miArreglo[%d] = %d\n",
127
Aprenda Java
i, miArreglo[i]);
} // fin for
} // fin de la clase LecturaArreglo
El programa siguiente, ArregloAleatorio.java inicializa un arreglo unidimensional con

valores aleatorios utilizando el mtodo Math.random.
//Inicializar los valores de un arreglo.

public class ArregloAleatorio {
// inicializa el arreglo con valores aleatorios

// 0.0 hasta 100 sin incluirlo
miArreglo[i] = Math.random() * 100;
} // fin for

System.out.println("El contenido del arreglo:");
System.out.printf("miArreglo[%d] = %.2f\n",
i, miArreglo[i]);
} // fin for
} // fin de la clase ArregloAleatorio
El programa siguiente, SumaArreglo.java suma los elementos de un arreglo

unidimensional.
//Sumar los valores de un arreglo.

public class SumaArreglo {
double suma = 0.0;
// inicializa el arreglo con valores aleatorios

// 0.0 hasta 100 sin incluirlo
miArreglo[i] = Math.random() * 100;
// va sumando los valores del arreglo
suma += miArreglo[i]; // suma = suma + miArreglo[i];
} // fin for
// imprime la suma del arreglo
128
Aprenda Java
System.out.printf("La suma de los valores del arreglo es %.2f",

suma);
} // fin de la clase SumaArreglo
El programa siguiente, MayorArreglo.java encuentra el elemento mayor de un arreglo

unidimensional.
//Encuentra el elemento mayor de un arreglo.

public class MayorArreglo {
double[] miArreglo = { 1.9, 2.9, 1.8, 3.4, 2.2 };
double mayor = miArreglo[0]; // asume que es el mayor
// procesa el arreglo, iniciando en el indice 1

if (miArreglo[i] > mayor)
mayor = miArreglo[i];
} // fin for
// imprime la suma del arreglo

System.out.printf("El elemento mayor es %.2f", mayor);
} // fin de la clase MayorArreglo
El programa siguiente, IntercambioAleatorio.java, utiliza el mtodo Math.random para

intercambiar aleatoriamente los elementos del arreglo unidimensional.
//Intercambia aleatoriamente los valores del arreglo.

public class IntercambioAleatorio {
int[] miArreglo = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// procesa el arreglo
// genera el indice j aleatoriamente
int j = (int) (Math.random() * miArreglo.length);
// intercambia miArreglo[i] con miArreglo[j];

int temporal = miArreglo[i];
miArreglo[i] = miArreglo[j];
miArreglo[j] = temporal;
} // fin for
// imprime los valores del arreglo
129
Aprenda Java
System.out.println("Los valores del arreglo:");

System.out.print(miArreglo[i] + " ");
} // fin for
} // fin de la clase Shuffling
El programa siguiente, ForEach.java utiliza la instruccin for mejorada para procesar

arreglos unidimensionales.
//Instruccin for mejorada.

public class ForEach {
int[] miArreglo = { 1, 5, 3, 4, 7, 9 };
// procesa el arreglo
for (int elemento : miArreglo)
System.out.println(elemento);
} // fin de la clase ForEach
La instruccin for mejorada, itera a travs de los elementos o coleccin sin utilizar un
contador. El programa siguiente, CopiarArreglo.java, copia el contenido de un arreglo
unidimensional en otro utilizando un ciclo for tradicional y usa un for mejorado para listar
los elementos del arreglo copiado.
//Programa que copia un arreglo en otro.

public class CopiarArreglo {
int[] lista = { 1, 2, 3, 4, 5 };
// creamos el arreglo
int[] copia = new int[lista.length];
// copiamos uno a uno cada elemento

for (int i = 0; i < lista.length; i++)
copia[i] = lista[i];
// imprimimos el contenido de copia

for (int elemento : copia)
System.out.print(elemento + " ");
} // fin de la clase CopiarArreglo
130
Aprenda Java
7.3. Paso de arreglos unidimensionales a los mtodos.
Para pasar un argumento tipo arreglo unidimensional a un mtodo se especfica el nombre

del arreglo unidimensional sin corchetes. El programa siguiente, PasoArreglo.java utiliza
un mtodo que recibe como argumento un arreglo unidimensional de tipo double.
//Paso de arreglos a los mtodos.

public class PasoArreglo {
double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 };
double[] y = { 11.4, 31.7, 13.4, 12.8, 21.8 };
imprimir(x);
imprimir(y);
// usando un arreglo annimo
imprimir(new double[] { 11.0, 12.0, 13.0, 14.0, 15.0 });
public static void imprimir(double[] arreglo) {

for (int i = 0; i < arreglo.length; i++)
System.out.print(arreglo[i] + " ");
} // fin del mtodo imprimir
} // fin de la clase PasoArreglo
Veamos otro ejemplo, pero ahora utilizando el concepto de mtodos sobrecargados. El

programa siguiente, PasoArreglo2.java, demuestra el uso de mtodos sobrecargados.
//Paso de arreglos a los mtodos.

public class PasoArreglo2 {
double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 };
int[] y = { 11, 31, 13, 12, 21 };
imprimir(x);
imprimir(y);
// mtodo overload
public static void imprimir(double[] arreglo) {
// mtodo overload
131
Aprenda Java
public static void imprimir(int[] arreglo) {

} // fin de la clase PasoArreglo2
7.4. Arreglos unidimensionales como valor de retorno.
Al igual que cualquier otro tipo de dato podemos especificar que un mtodo retorne un
arreglo unidimensional. El programa siguiente, ProductoVector.java, retorna un arreglo en
la llamada de un mtodo.
//Calcula el producto de dos arreglos A y B.

public class ProductoVector {
// variable de clase - variable static
private static final int MAX = 10; // tamao del arreglo

// entrada
System.out.println("Arreglo 1.");
int[] a = leerArreglo();
System.out.println("Arreglo 2.");
int[] b = leerArreglo();
// proceso
int producto = productoVectores(a, b);
// salida
System.out.printf("El producto de AxB = %d", producto);
private static int[] leerArreglo() {

// crea el objeto de lectura
int[] temp = new int[MAX];
for (int i = 0; i < temp.length; i++) {
System.out.printf("Valor[%d]? ",i);
temp[i] = entrada.nextInt();
} // fin for
return temp;
} // fin del mtodo leerArreglo
private static int productoVectores(int[] a, int[] b) {

int producto = 0;
132
Aprenda Java
for (int i = 0; i < MAX; i++)

producto = producto + (a[i] * b[i]);
return producto;
} // fin del mtodo productoVectores
} // fin de la clase ProductoVectores
7.5. Lista de argumentos de longitud variable.
Con las listas de argumentos de longitud variable podemos crear mtodos que reciben un
nmero arbitrario de argumentos. Un tipo de argumentos que va precedido por una elipsis
(...) en la lista de parmetros de un mtodo indica que ste recibe un nmero variable de
argumentos de ese tipo especfico. Este uso de la elipsis puede ocurrir slo una vez en una
lista de parmetros, y la elipsis, junto con su tipo, debe colocarse al final de la lista.
El programa siguiente, VarArgs.java utiliza un mtodo con lista de argumentos de

longitud variable.
//Uso de listas de argumentos de longitud variable.

public class VarArgs {
// calcula el promedio
public static double promedio(double... numeros) {
double total = 0.0; // inicializa el total
// calcula el total usando la instruccin for mejorada

for (double d : numeros)
total = total + d;
return total / numeros.length;

} // fin del mtodo promedio
public static void main(String args[]) {

double d1 = 10.0;
double d2 = 20.0;
double d3 = 30.0;
double d4 = 40.0;
System.out.println("Valores iniciales.");
System.out.printf("d1 = %.2f%n", d1);
System.out.printf("El promedio de d1 y d2 es %.2f%n",
promedio(d1, d2));
133
Aprenda Java
System.out.printf("El promedio de d1, d2, d3 y d4 es %.2f%n",

promedio(d1, d2, d3, d4));
} // fin de la clase VarArgs
7.6. La clase Arrays.
La clase Arrays est definida en el paquete java.util e incluye una serie de mtodos para
manipular arreglos unidimensionales.
El programa siguiente, OrdenaArreglo.java utiliza el mtodo Arrays.sort para ordenar

un arreglo unidimensional.
//Ordena un arreglo con Arrays.sort

import java.util.Arrays;
public class OrdenaArreglo {
double[] listaUno = { 6.0, 4.4, -3.3, 2.9, 3.5 };
double[] listaDos = { 4.3, -9.9, 5.5, -2.3, 1.1 };
// ordena el arreglo en orden ascedente

Arrays.sort(listaUno);
imprimir(listaUno);
// ordena el arreglo en forma selectiva

Arrays.sort(listaDos, 1, 4);
imprimir(listaDos);
private static void imprimir(double[] arreglo) {

} // fin de la clase OrdenaArreglo
El programa siguiente, BusquedaArreglo.java utiliza el mtodo Arrays.binarySearch

para buscar un elemento en un arreglo unidimensional.
//Busca en un arreglo utilizando Arrays.binarySearch.

public class BusquedaArreglo {
int[] miArreglo = { 7, 9, 1, 2, 4, 5, 8, 6};
134
Aprenda Java
//ordena el arreglo
Arrays.sort( miArreglo );
//imprime el arreglo
imprimir( miArreglo );
//busca algunos valores

System.out.printf( "El valor %d se encuentra en la pos %d%n",
1, Arrays.binarySearch( miArreglo, 1));
private static void imprimir(int[] arreglo) {

} //fin de la clase BusquedaArreglo
El programa siguiente, ComparaArreglos.java, compara arreglos con el mtodo

Arrays.equals.
//Compara si dos arreglos son iguales con el mtodo Arrays.equals

public class ComparaArreglos {
int[] califJava = { 100, 80, 70, 50, 10};
int[] califNet = { 100, 80, 70, 50, 10};
int[] califVB = { 100, 87, 75, 35, 19};
System.out.println( Arrays.equals(califJava, califNet));

System.out.println( Arrays.equals(califJava, califVB));
} //fin de la clase ComparaArreglos
El programa siguiente, RellenarArreglo.java utiliza el mtodo Arrays.fill para llenar el

contenido del arreglo con un valor especfico.
//Utiliza el mtodo Arrays.fill.

public class RellenarArreglo {
int[] listaJava = new int[5];
int[] listaNet = { 1, 2, 3, 4, 5 };
135
Aprenda Java
// llena de 9 el arreglo
Arrays.fill(listaJava, 9);
// llena de 9 una parte de la lista

Arrays.fill(listaNet, 0, 2, 9);
imprimir(listaJava);
imprimir(listaNet);

} // fin de la clase RellenarArreglo
Conceptos clave: mtodo fill de la clase Arrays.
El programa siguiente, CopiarArreglo2.java, utiliza el mtodo System.arraycopy para

copiar el contenido de un arreglo en otro.
//Utiliza el mtodo System.arrayCopy.

public class CopiarArreglo2 {
int[] listaJava = new int[5];
int[] listaNet = { 1, 2, 3, 4, 5 };
// copia el contenido del arreglo

System.arraycopy(listaNet, 0, listaJava, 0, listaJava.length);
imprimir(listaJava);

} //fin de la clase CopiarArreglo2
136
Aprenda Java
La programacin con arreglos unidimensionales es un tpico de programacin muy

importante ya que es el punto de partida para estudiar las estructuras de datos.
Problema 1.
Escribir un programa controlado por men que utilice las operaciones bsicas estudiadas en
esta leccin.
//Programa que implementa las operaciones bsicas con

//arreglos unidimensionales.
public class ArregloApp {
final int TAMAO_ARREGLO = 10; // el tamao del arreglo
// crea un arreglo de 10 posiciones
int[] listaNumero = new int[TAMAO_ARREGLO];
do {
menu(listaNumero);

// el titulo del programa

System.out.println("Operaciones bsicas con arreglos.");
System.out.println("---------------------------------");
// las opciones del men del programa

System.out.println("1. Leer desde el teclado.");
System.out.println("2. Llenar el arreglo aleatoriamente.");
System.out.println("3. Imprimir el contenido del arreglo.");
System.out.println("4. Encontrar el nmero mayor.");
System.out.println(
137
Aprenda Java
"5. Contar las ocurrencias del nmero mayor.");

System.out.println("6. Contar las ocurrencias del cero.");
System.out.println("7. Contar las ocurrencias de un nmero.");
System.out.println(
"8. Muestra las ocurrencias en el arreglo.");
System.out.println("9. Crea un histograma con el arreglo.");
System.out.println("Selecciona una opcin (1-9): ");
// el menu del programa

private static void menu(int[] miArreglo) {
// muestra el titulo del programa

mostrarTitulo();
// muestra las opciones del menu
menuOpciones();
switch (opcion) {
case 1:
System.out.println("1. Leer desde el teclado.");
System.out.println("-------------------------");
leerArreglo(miArreglo);
break;
case 2:
System.out.println(
"2. Llenar el arreglo aleatoriamente.");
System.out.println(
"------------------------------------");
datosAleatorios(miArreglo);
break;
case 3:
System.out.println(
"3. Imprimir el contenido del arreglo.");
System.out.println(
"-------------------------------------");
imprimirArreglo(miArreglo);
break;
case 4:
System.out.println("4. Encontrar el nmero mayor.");
mostrarMayor(miArreglo);
break;
case 5:
System.out.println(
138
Aprenda Java
"5. Contar las ocurrencias del nmero mayor.");

System.out.println(
"-------------------------------------------");
mostrarOcurrenciaMayor(miArreglo);
break;
case 6:
System.out.println("6. Contar las ocurrencias del cero.");
mostrarOcurrenciaCeros(miArreglo);
break;
case 7:
System.out.println(
"7. Contar las ocurrencias de un nmero.");
System.out.println(
"---------------------------------------");
// el nmero podra leerse desde el teclado
// aqu se genera aleatoriamente.
mostrarRepeticiones(miArreglo,
(int) (Math.random() * 10));
break;
case 8:
System.out.println(
"8. Muestra las ocurrencias en el arreglo.");
System.out.println(
"-----------------------------------------");
mostrarRepeticiones(miArreglo);
break;
case 9:
System.out.println(
"9. Crea un histograma con el arreglo.");
System.out.println(
"-------------------------------------");
histograma(miArreglo);
break;
default:
} // fin switch
private static void leerArreglo(int[] miArreglo) {

System.out.printf("Introduce %d nmeros enteros (0-9).%n",
miArreglo.length);
System.out.printf("Valor %d ?", i + 1);
miArreglo[i] = entrada.nextInt();
} // fin for
139
Aprenda Java
} // fin del mtodo leerArreglo
private static void imprimirArreglo(int[] miArreglo) {

System.out.println("Contenido del arreglo.");
for (int item : miArreglo)
System.out.printf("%d\t", item);
} // fin del mtodo imprimirArreglo
private static void datosAleatorios(int[] miArreglo) {

System.out.println(
"Generando datos aleatorios para el arreglo.");
for (int i = 0; i < miArreglo.length; i++)
miArreglo[i] = (int) (Math.random() * 10);
} // fin del mtodo datosAleatorios
// determina el mayor nmero del arreglo.

private static int obtenerMayor(int[] miArreglo) {
int mayor = miArreglo[0]; // asume que es el mayor

if (miArreglo[i] > mayor)
mayor = miArreglo[i];
} // fin for
return mayor;
} // fin del mtodo numeroMayor
// cuenta las ocurrencias del nmero mayor

private static int ocurrenciaMayor(int[] miArreglo) {
int mayor = obtenerMayor(miArreglo);
int contador = 0;

if (miArreglo[i] == mayor)
contador++;
} // fin for
return contador;
} // fin del mtodo ocurrenciaMayor
// cuenta los elementos que son cero

private static int cuentaCeros(int[] miArreglo) {
int contador = 0;

if (miArreglo[i] == 0)
140
Aprenda Java
contador++;
} // fin for
return contador;
} // fin del mtodo cuentaCeros
// muestra las ocurrencias de un determinado nmero

private static int cuentaRepeticiones(int[] miArreglo,
int numero) {
int contador = 0;
if (miArreglo[i] == numero)
contador++;
} // fin for
return contador;
} // fin del mtodo cuentaRepeticiones
// imprime un histograma de frecuencia

private static void histograma(int[] miArreglo) {
// imprime el histograma para ese num
System.out.printf("%d : ", miArreglo[i]);
for (int j = 0; j < miArreglo[i]; j++) {
System.out.print("*");
} // fin for
} // fin for
} // fin del mtodo histograma
// muestra las ocurrencias de cada nmero en el arreglo

private static void mostrarRepeticiones(int[] miArreglo) {
// trabajamos con un arreglo temporal
int[] temporal = new int[miArreglo.length];
// copiamos el contenido del arreglo original a temporal

System.arraycopy(miArreglo, 0, temporal, 0, temporal.length);
// ordenamos el arreglo
Arrays.sort(temporal);
// empezamos a contar las ocurrencias

int contador = 1;
for (int i = 0; i < temporal.length; i++) {
for (int j = 0; j < temporal.length; j++) {
if (temporal[i] == temporal[j] && i != j) {
temporal[j] = -1;
141
Aprenda Java
contador++;
} // fin if
} // fin for
// imprime el reporte
if (temporal[i] != -1)
System.out.printf(
"%d se repite %d veces%n", temporal[i],
contador);
contador = 1; // inicializa para volver a contar
} // fin for
} // fin del mtodo mostrarRepeticiones
private static void mostrarRepeticiones(int[] miArreglo,

int numero) {
System.out.printf(
"El nmero %d se repite %d veces.%n", numero,
cuentaRepeticiones(miArreglo, numero));
} // fin del mtodo mostrarRepeticiones
private static void mostrarOcurrenciaCeros(int[] miArreglo) {

System.out.printf("El 0 se repite %d veces%n",
cuentaCeros(miArreglo));
} // fin del mtodo mostrarOcurrenciaCeros
private static void mostrarOcurrenciaMayor(int[] miArreglo) {

System.out.printf("El %d se repite %d veces%n",
obtenerMayor(miArreglo), ocurrenciaMayor(miArreglo));
} // fin del mtodo mostrarOcurrenciaMayorMenor
private static void mostrarMayor(int[] miArreglo) {

System.out.printf("El mayor del arreglo es %d%n",
obtenerMayor(miArreglo));
} // fin del mtodo mostrarMayorMenor
} // fin de la clase ArregloApp
142
Aprenda Java
8. Arreglos bidimensionales.
Utilizar arreglos bidimensionales en los programas Java.
8.1. Declarar, crear y asignar valores a un arreglo bidimensional.
Los arreglos bidimensionales se utilizan para representar tablas de valores, las cuales
consisten en informacin ordenada en filas y columnas. Para identificar un elemento
especfico de un arreglo bidimensional, debemos especificar dos subndices. Por
convencin, el primero identifica la fila del elemento y el segundo su columna. El programa
siguiente, DeclararArreglo2D.java declara un arreglo bidimensional de tipo double.
//Declara un arreglo de dos dimensiones.

public class DeclararArreglo2D {
double[][] arreglo2D;
// otra forma: double arreglo2D[][];
// es un error
// double arreglo2D[5][6];
// double arreglo2D(4)(3);
} // fin de la clase DeclararArreglo2D
Los arreglos bidimensionales usan la misma sintaxis bsica que los arreglos
unidimensionales, excepto por un par segundo par de corchetes ( []). Para declarar y crear
un arreglo bidimensional utilizamos el operador new y dos valores literales que representan
las filas y columnas respectivamente. El programa siguiente, CrearArreglo2D.java declara
y crea dos arreglos bidimensionales de tipo int y double con un tamao de 10x10
respectivamente.
//Declara y crea un arreglo de dos dimensiones.

public class CrearArreglo2D {
double[][] arreglo2D;
arreglo2D = new double[10][10];
// versin corta
int[][] tabla = new int[10][10];
// esto un error
// int tabla[4][5];
143
Aprenda Java
// int[4][5] tabla;
// int tabla = new tabla[5,5];
} // fin de la clase CrearArreglo2D
Cada elemento del arreglo se identifica mediante una expresin de acceso a un arreglo de
la forma tabla[fila][columna] donde tabla es el nombre del arreglo, fila y columna
son los subndices que identifican en forma nica a cada elemento en el arreglo tabla por
nmero de fila y columna. El programa siguiente, ValoresArreglo2D.java, declara, crea y
asigna valores a un arreglo bidimensional de tipo double.
//Declara,crea y asigna valores en un arreglo de dos dimensiones.

public class ValoresArreglo2D {
double[][] tabla = new double[3][3];
// inicializar el arreglo 2D con estos datos

// 5.6 4.5 3.3
// 1.2 4.0 3.2
// 4.0 5.4 9.9
// inicializa los valores del arreglo 2D rengln x columna

tabla[0][0] = 5.6;
tabla[0][1] = 4.5;
tabla[0][2] = 3.3;
tabla[1][0] = 1.2;
tabla[1][1] = 4.0;
tabla[1][2] = 3.2;
tabla[2][0] = 4.0;
tabla[2][1] = 5.4;
tabla[2][2] = 9.9;
// esto es un error
// genera un ArrayIndexOutOfBoundsException
// tabla[3][3] = 12.5;
} // fin de la clase ValoresArreglo2D
Un error comn en Java es confundir la longitud de un arreglo bidimensional con el rango

de ndices vlidos. Para obtener el nmero de filas en un arreglo bidimensional utilizamos la
expresin arreglo2D.length y la expresin arreglo2D[fila].length determina el
nmero de columnas en la fila actual del arreglo bidimensional. El programa siguiente,
DefaultArreglo2D.java, obtiene el tamao de un arreglo bidimensional as como accede a
sus valores por default.
144
Aprenda Java
//Tamao del arreglo y valores por default.

public class DefaultArreglo2D {
double[][] tabla = new double[3][3];
// accede la primera posicin del arreglo2D

System.out.println("tabla[0][0] = " + tabla[0][0]);
// esto es un error, no se puede acceder a un indice ms grande

// System.out.println( "tabla[0] = " + tabla[5][5] );
// utiliza la propiedad length para obtener el

// tamao del arreglo 2D
System.out.println("Tamao del arreglo 2D = " + tabla.length);
System.out.println("Tamao del rengln = " + tabla[0].length);
// esto es un error, no se puede cambiar el

// tamao del arreglo 2D
// tabla.length = 20;
} // fin de la clase DefaultArreglo2D
Al igual que los arreglos unidimensionales, los arreglos bidimensionales pueden inicializarse
mediante inicializadores de arreglos en las declaraciones. Un arreglo bidimensional de
nombre tabla con tres filas y tres columnas podra declararse e inicializarse con
inicializadores de arreglos anidados. El programa siguiente, DatosArreglo2D.java,
declarar e inicializa un arreglo bidimensional de tipo double.
//Declara e inicializa un arreglo de dos dimensiones.

public class DatosArreglo2D {
// no se requiere la palabra clave new
double[][] tabla = { { 1.9, 2.9, 3.4 }, { 5.5, 7.2, 3.3 },
{ 8.7, 3.4, 9.9 } };
// accede al primer rengln

System.out.println("Contenido del primer rengln:");
// esto es un error
// int[][] lista;
// lista = {{1,2,3},{4,5,6},{7,8,9}};
} // fin de la clase DatosArreglo2D
145
Aprenda Java
Los valores del inicializador se agrupan por filas entre llaves. El compilador cuenta el
nmero de inicializadores de arreglos anidados (representados por conjuntos de llaves
dentro de las llaves externas) en la declaracin del arreglo, para determinar el nmero de
filas en el arreglo. El compilador cuenta los valores inicializadores en el inicializador de
arreglos anidado de una fila, para determinar el nmero de columnas en esa fila. Esto
significa que las filas pueden tener distintas longitudes. El programa siguiente,
ArregloDesigual.java declara e inicializa un arreglo con filas de distintas longitudes.
//Declara e inicializa un arreglo 2D desigual.

public class ArregloDesigual {
int[][] triangulo = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5 },
{ 3, 4, 5 }, { 4, 5 }, { 5 } };
// es equivalente a declarar...se requiere el primer indice

int[][] triangulo2 = new int[5][];
triangulo2[0] = new int[5];

} // fin de la clase ArregloDesigual
En Java no existen los arreglos de dos o ms dimensiones ya que Java los mantiene como
arreglos de arreglos unidimensionales.
8.2. Operaciones bsicas con arreglos bidimensionales.
Los programas siguientes muestran como inicializar un arreglo bidimensional y el uso de los
ciclos for anidados en combinacin con los indices de fila y columna para manipular los
elementos del arreglo bidimensional.
El programa siguiente, LecturaArreglo2D.java declara un arreglo bidimensional de tipo

int de tamao 2x3 y utiliza ciclos for anidados para leer los valores desde el teclado.
//Inicializa los datos de un arreglo 2D desde el teclado.

public class LecturaArreglo2D {
// declara un arreglo2d de 2x3
146
Aprenda Java
System.out.println("Arreglo con " + tabla.length

+ " renglones y "
+ tabla[0].length + " columnas.");
System.out.println("Introduce nmeros enteros:");
// lectura del arreglo

for (int i = 0; i < tabla.length; i++) {
for (int j = 0; j < tabla[i].length; j++) {
System.out.printf("Valor[%d][%d]? ", i, j);
// lee y asigna el valor del teclado
tabla[i][j] = entrada.nextInt();
} // fin for
} // fin for
// imprime el primer rengln

System.out.print("El rengln 1 = [");
System.out.print(tabla[0][0] + " ");
System.out.print(tabla[0][2] + "]");
} // fin de la clase LecturaArreglo2D
El programa siguiente, Arreglo2DAleatorio.java, inicializa un arreglo bidimensional con

valores aleatorios generados con el mtodo Math.random.
//Inicializa un arreglo 2D con valores aleatorios.

public class Arreglo2DAleatorio {
System.out.println("Arreglo con " + tabla.length
+ " renglones y "
+ tabla[0].length + " columnas.");
System.out.println("El arreglo 2D tiene valores random.");
// inicializa el arreglo 2D
for (int i = 0; i < tabla.length; i++)
for (int j = 0; j < tabla[i].length; j++)
tabla[i][j] = (int) (Math.random() * 100);
// imprime el primer rengln

System.out.print("El rengln 1 = [");
System.out.print(tabla[0][2] + "]");
} // fin de la clase Arreglo2DAleatorio
147
Aprenda Java
El programa siguiente, ImprimirArreglo2D.java, imprime el contenido del arreglo

bidimensional .
//Imprime el contenido de un arreglo2D.

public class ImprimirArreglo2D {
// Declara e inicializa un arreglo 2D
// de 3 renglones, 3 columnas
int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
System.out.println("Valores del arreglo.");

System.out.println("--------------------");

System.out.print("Renglon " + i + " = [ ");
System.out.print(tabla[i][j] + " ");
System.out.println("]");
} // fin for
} // fin de la clase ImprimirArreglo2D
El programa siguiente, SumaArreglo2D.java suma todos los elementos del arreglo

bidimensional.
//Suma todos los elementos del arreglo 2D.

public class SumaArreglo2D {
// declara e inicializa un arreglo de 4x5
double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 },
{ 20.50, 22.28, 24.00, 26.25, 27.50 },
{ 34.00, 36.50, 38.00, 40.35, 43.00 },
{ 50.00, 60, 00, 70.00, 80.00, 99.99 } };
System.out.println("Suma los datos del tabulador.");

double suma = 0.0;
for (int i = 0; i < tabulador.length; i++)
for (int j = 0; j < tabulador[i].length; j++)
suma += tabulador[i][j];
System.out.printf("La suma total es %.2f%n", suma);
} // fin de la clase SumaArreglo2D
148
Aprenda Java
El programa siguiente, SumaColumna2D.java suma las columnas de un arreglo

bidimensional.
//Suma las columnas de un arreglo 2D.

public class SumaColumna2D {
//Suma las columnas de un arreglo 2D.
public class SumaColumna2D {
{ 20.50, 22.28, 24.00, 26.25, 27.50 },
{ 34.00, 36.50, 38.00, 40.35, 43.00 },
{ 50.00, 60, 00, 70.00, 80.00, 99.99 } };
System.out.println("Suma los datos x columna.");

System.out.println("-------------------------");
for (int i = 0; i < tabulador[0].length; i++) {

double sumaCol = 0.0;
for (int j = 0; j < tabulador.length; j++)
sumaCol += tabulador[j][i];
System.out.printf("La suma de la columna %d es %.2f%n",

i, sumaCol);
} // fin for
} // fin de la clase SumaColumna2D
El programa siguiente, SumaReglon2D.java ,suma los renglones de un arreglo bidimensional

y determina cual es rengln con la mayor suma.
//Suma los renglones de un arreglo 2D y encuentra el mayor

public class SumaRenglon2D {
{ 20.50, 22.28, 24.00, 26.25, 27.50 },
{ 34.00, 36.50, 38.00, 40.35, 43.00 },
{ 50.00, 60, 00, 70.00, 80.00, 99.99 } };
double renglonMax = 0; // para almacenar la suma del rengln

int indiceRenglonMax = 0; // el indice del renglon
// obtiene la suma del primer rengln

for (int i = 0; i < tabulador[0].length; i++)
renglonMax += tabulador[0][i];
149
Aprenda Java
// compara renglonMax con la suma de los otros renglones

for (int i = 0; i < tabulador.length; i++) {
double sumaRenglon = 0; // suma del rengln actual
for (int j = 0; j < tabulador[i].length; j++)
sumaRenglon += tabulador[i][j];
// compara el renglonMax con sumaRenglon
if (sumaRenglon > renglonMax) {
renglonMax = sumaRenglon;
indiceRenglonMax = i; // actualiza el indice
} // fin if
} // fin for
System.out.printf(
"El rengln %d es renglon con mayor suma (%.2f)%n",
indiceRenglonMax, renglonMax);
} // fin de la clase SumaRenglon2D
El programa siguiente, IntercambioAleatorio2D.java realiza un intercambio aleatorio de

los datos en un arreglo bidimensional.
//Intercambio aleatorio de los elementos de un arreglo 2D.

public class IntercambioAleatorio2D {
int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
// procesa el arreglo intercambiando los valores

for (int j = 0; j < tabla[i].length; j++) {
// genera indices aleatorios para ren, col
int renAux = (int) (Math.random() * tabla.length);
int colAux =
(int) (Math.random() * tabla[j].length);
// intercambia tabla[ren][col]
// por tabla[renAux][colAux]
int temp = tabla[i][j];
tabla[i][j] = tabla[renAux][colAux];
tabla[renAux][colAux] = temp;
} // fin for
} // fin for
System.out.println("El arreglo despus del shuffling.");
System.out.print("Rengln " + i + " = [ ");
150
Aprenda Java
System.out.print(tabla[i][j] + " ");

} // fin for
} // fin de la clase IntecambioAleatorio2D
8.3. Paso de arreglos bidimensionales a los mtodos.
Los mtodos son un ingrediente vital en la programacin y una caracterstica importante es

pasar informacin hacia y desde ellos en forma de parmetros. El programa siguiente,
PasoArreglo2D.java pasa un arreglo bidimensional como parmetro.
//Arreglos como parmetros.

public class PasoArreglo2D {
public static void imprimirArreglo(int[][] arreglo2D) {
for (int i = 0; i < arreglo2D.length; i++) {
System.out.print("Renglon " + i + " = [ ");
for (int j = 0; j < arreglo2D[i].length; j++)
System.out.print(arreglo2D[i][j] + " ");
} // fin for
} // fin del mtodo imprimirArreglo

int tabla[][] = { { 25, 5, 6, 15, 18 }, { 12, 54, 21, 1, 14 },
{ 34, 28, 8, 67, 7 } };
imprimirArreglo(tabla);
} // fin de la clase PasoArreglo2D
El programa siguiente, Suma2D.java define un mtodo general que recibe un arreglo

bidimensional como parmetro para calcular la suma de sus elementos.
//Arreglos como parmetros.

public class Suma2D {
int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 } };
// obtiene la suma de tabla
int total = suma(tabla);
System.out.printf("La suma es %d%n", total);
// crea un arreglo annimo y suma sus elementos

int total2 = suma(new int[][] { { 1, 2, 3, 4 },
151
Aprenda Java
{ 5, 6, 7 }, { 8, 9 } });
System.out.printf("La suma es %d%n", total2);
public static int suma(int[][] arreglo2D) {

int suma = 0; // variable local
for (int i = 0; i < arreglo2D.length; i++)
for (int j = 0; j < arreglo2D[i].length; j++)
suma += arreglo2D[i][j];
return suma;
} // fin del mtodo suma
} // fin de la clase Suma2D
La programacin con arreglos bidimensionales es un tpico de programacin muy importante

ya que es el punto de partida para estudiar las estructuras de datos.
Problema 1.
Escribir un programa controlado por men que utilice las operaciones bsicas estudiadas en
esta leccin.
//Operaciones bsicas con arreglos 2D.

public class Arreglo2DApp {
System.out.println("Inicializacin del Arreglo 2D.");

System.out.print("Nmero de renglones? ");

int renglon = entrada.nextInt();
System.out.print("Nmero de columnas? ");
int columna = entrada.nextInt();
// crea el Matriz
int[][] arreglo2D = new int[renglon][columna];
// muestra el men del programa

do {
mostrarTitulo();
menu(arreglo2D);
152
Aprenda Java

// el titulo del programa

System.out.println("Operaciones bsicas con arreglos 2D.");
System.out.println("------------------------------------");

System.out.println("Operaciones:");
System.out.println("1. Llenar el arreglo 2D.");
System.out.println("2. Imprimir el arreglo 2D.");
System.out.println(
"3. Llenar el arreglo 2D con valores random.");
System.out.println("4. Intercambiar valores aleatoriamente.");
System.out.println("5. Imprimir la suma total.");
System.out.println("6. Imprimir el promedio.");
System.out.println("7. Encontrar el elemento mayor.");
System.out.println("8. Encontrar el elemento menor.");

private static void menu(int[][] arreglo2D) {
// variable local
Scanner teclado = new Scanner(System.in);
int opcion = 0;

menuOpciones();
opcion = teclado.nextInt();
switch (opcion) {
case 1:
System.out.println("1. Llenar el arreglo 2D.");
leer(arreglo2D);
break;
case 2:
System.out.println("2. Imprimir el arreglo 2D.");
imprimir(arreglo2D);
153
Aprenda Java
break;
case 3:
System.out.println(
"3. Llenar el arreglo con valores random.");
System.out.println(
"----------------------------------------");
llenarRandom(arreglo2D);
break;
case 4:
System.out.println(
"4. Intercambiar valores aleatoriamente.");
System.out.println(
"---------------------------------------");
shuffling(arreglo2D);
break;
case 5:
System.out.println("5. Imprimir la suma total.");
imprimirSuma(arreglo2D);
break;
case 6:
System.out.println("6. Imprimir el promedio.");
imprimirPromedio(arreglo2D);
break;
case 7:
System.out.println("7. Encontrar el elemento mayor.");
imprimirMaxValor(arreglo2D);
break;
case 8:
System.out.println("8. Encontrar el elemento menor.");
imprimirMinValor(arreglo2D);
break;
default:
} // fin switch
} // fin del mtodo mostrarMenu
// lee los datos de un matriz desde el teclado
private static void leer(int[][] matriz) {

// para poder leer los datos crear objeto Scanner
System.out.printf("Introduce los datos de la matriz %d x %d%n",
154
Aprenda Java
matriz.length, matriz[0].length);
// lectura de la matriz
for (int ren = 0; ren < matriz.length; ren++) {
for (int col = 0; col < matriz[ren].length; col++) {
System.out.printf("Valor[%d][%d]? ", ren, col);
matriz[ren][col] = entrada.nextInt();
} // fin for
} // fin for
} // fin del mtodo leer
// imprime el contenido del matriz

private static void imprimir(int[][] matriz) {
System.out.printf("Matriz de %d x %d.%n", matriz.length,
+matriz[0].length);
// impresin del matriz

for (int col = 0; col < matriz[ren].length; col++)
System.out.printf("[ %d ] ", matriz[ren][col]);
} // fin for
// inicializa los datos del matriz con valores aleatorios

private static void llenarRandom(int[][] matriz) {
// llena el matriz con valores random
for (int ren = 0; ren < matriz.length; ren++)
matriz[ren][col] = (int) (Math.random() * 100);
System.out.println(
"La matriz se ha inicializado con datos random.");
imprimir(matriz);
} // fin del mtodo llenarRandom
// intercambia aleatoriamente los datos del matriz

private static void shuffling(int[][] matriz) {
// procesa el arreglo intercambiando los valores aleatoriamente
for (int col = 0; col < matriz[ren].length; col++) {
// genera indices aleatorios para ren, col
int renAux = (int) (Math.random() * matriz.length);
int colAux = (int) (Math.random()
* matriz[col].length);
// intercambia tabla[ren][col]
155
Aprenda Java
// por tabla[renAux][colAux]
int temp = matriz[ren][col];
matriz[ren][col] = matriz[renAux][colAux];
matriz[renAux][colAux] = temp;
} // fin for
} // fin for
System.out.println(
"Los datos de la matriz ya se han intercambiado.");
imprimir(matriz);
} // fin del mtodo shuffling
// suma todos los datos de la matriz

private static int suma(int[][] matriz) {
int sum = 0;
sum = sum + matriz[ren][col];
return sum;
} // fin del mtodo calcularSuma
// imprime la suma de los datos del matriz

private static void imprimirSuma(int[][] matriz) {
System.out.printf("La suma de la matriz de %d x %d es %d%n",

matriz.length, matriz[0].length, suma(matriz));
private static double promedio(int[][] matriz) {

return (double) suma(matriz) /
(matriz.length * matriz[0].length);
} // fin del mtodo calcularPromedio
// imprime el promedio del total de elementos del matriz

private static void imprimirPromedio(int[][] matriz) {
System.out.printf(
"El promedio de los datos de la matriz de %d x %d es %.2f%n",
matriz.length, matriz[0].length, promedio(matriz));
} // fin del mtodo imprimirPromedio
private static int maxValor(int[][] matriz) {
int max = matriz[0][0]; // asume que es el valor ms grande

// busca el elemento ms grande
if (matriz[ren][col] > max) // Busca el num mayor
max = matriz[ren][col]; // actualiza max
156
Aprenda Java
return max;
} // fin del mtodo maxValor
// imprimir el elemento ms grande del matriz

private static void imprimirMaxValor(int[][] matriz) {
System.out.printf(
"El elemento ms grande de la matriz de %d x %d es %d%n",
matriz.length, matriz[0].length, maxValor(matriz));
} // fin del mtodo imprimirMaxValor
private static int minValor(int[][] matriz) {
int min = matriz[0][0]; // asume que es el valor ms pequeo

// busca el elemento ms grande
if (matriz[ren][col] < min) // Busca el num menor
min = matriz[ren][col]; // actualiza min
return min;
} // fin del mtodo minValor
// imprimir el elemento ms grande del matriz

private static void imprimirMinValor(int[][] matriz) {
System.out.printf(
"El elemento ms pequeo de la matriz de %d x %d es %d%n",
matriz.length, matriz[0].length, minValor(matriz));
} // fin del mtodo imprimirMinValor
} // fin de la clase Arreglo2DApp
157
Aprenda Java
9. Bibliografa consultada.
Deitel & Deitel, Como programar en Java, Sptima edicin, Pearson Education,
Mxico 2008.
John Dean & Raymond Dean, Introduccin a la programacin con Java, Primera
edicin, McGraw Hill, Mxico 2009.
C. Thomas Wu, Programacin en Java, Introduccin a la programacin orientada a
objetos, Primera edicin, McGraw Hill, Mxico 2008.
Bell Douglas & Parr Mike, Java para estudiantes, tercera edicion, Pearson Education,
Mxico 2003.
Y. Daniel Liang, Java Programming, Comprehensive versin, Eighth Edition , Prentice
Hall, New Jersey 2011.
Beth Brown , A guide to programming in Java 2 Platform Standard Edition 5, First
Edition, Lawrenceville Press , USA 2005.
Manual de introduccin a la algoritmia: http://es.scribd.com/doc/59204592/IntroducciA
%C2%B3n-a-la-Algoritmia-1.
158

Aprenda Java - Raul Oramas

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Aprenda Java - Raul Oramas

Cargado por

Copyright:

Formatos disponibles

Descripcin del curso.

Este curso est dirigido a estudiantes, profesionistas, y desarrolladores de software que

Objetivos del curso.

Despus de completar este curso, sers capaz de:

Desarrollar y ejecutar programas Java SE (Standard Edition), versin 7.

5.1. Mtodos de la clase Math......................................................................................95

Conocer las etapas de desarrollo de un programa Java.

1.1. El lenguaje Java.

Java es un lenguaje de programacin orientado a objetos, desarrollado por Sun

En la actualidad Java es un lenguaje muy cotizado. Podemos comparar Java respecto a

1.2. Etapas de desarrollo de un programa en Java.

En la etapa de compilacin, se traduce el cdigo fuente usando el compilador de Java, que

En la etapa de ejecucin, el cdigo de bytes es ejecutado por la Mquina Virtual de Java

1.3. Software para el desarrollo de programas en Java.

Para el desarrollo de programas Java es necesario descargar e instalar la Plataforma Java

1.4. Estructura bsica de un programa en Java.

Empezaremos el proceso de aprendizaje de Java definiendo la estructura bsica de un

public class HolaMundo {

Debemos de tener en cuenta que Java es sensible a maysculas y minsculas; es decir,

public class HolaMundo {

La llave izquierda { comienza el cuerpo de la declaracin del mtodo y su correspondiente

Los comentarios ayudan a documentar un programa y mejorar su legibilidad. El

La lnea: System.out.println("Hola Mundo!"); es una instruccin. Todas las

estndar. El mtodo println de System.out imprime una lnea de texto en la consola de

//No respetar la condicin mayscula/minscula

Para que el programa anterior funcione es necesario respetar la condicin de

1.5 Instrucciones bsicas para imprimir texto.

//Ejemplo con print/println.

inicio de la siguiente lnea en el monitor de la computadora. El programa siguiente,

//Ejemplo de secuencias de escape.

//Imprimir texto con secuencias de escape.

La secuencia de escape \n representa una nueva lnea. El tabulador horizontal est

//Ejemplo con printf.

La f en el nombre printf representa la palabra formato. La llamada al mtodo printf

El programa siguiente, Aritmetica.java, utiliza el mtodo printf para imprimir nmeros

//Utiliza printf para imprimir nmeros.

2.1. Escribir un programa simple.

El proceso de aprendizaje para resolver problemas mediante un lenguaje de programacin

//Calcula el rea de un crculo.

// asigna el valor al radio

// no confundir la igualdad matemtica y la asignacin

//Programa que calcula el doble de un nmero.

El mtodo printf de System.out utiliza el especificador de formato %d para mostrar un

2.2. Leer datos desde el teclado.

//Calcula el rea de un crculo.

public class AreaCirculo {

// obtiene el radio del crculo

Para utilizar la clase Scanner se utiliza la instruccin: import java.util.Scanner;. Se

La expresin new Scanner(System.in); crea un objeto y le pasa como argumento el

//Ejemplo de variables, operadores aritmticos y la clase Scanner.

La instruccin import le ayuda al compilador a localizar una clase que se encuentra en la

Con el programa siguiente, Producto.java, utilizaremos dos variables de tipo float y

//Ejemplo de variables, operadores aritmticos y la clase Scanner.

float numero1 = entrada.nextFloat(); // lee el primer nmero

El especificador de formato %.2f nos permite indicar el nmero de decimales a mostrar.

Un identificador es el trmino tcnico para el nombre de un componente de programa: el

//Ejemplos de identificadores en Java.

System.out.println("Identificador -> identificador clase");

Veamos un ejemplo de como no declarar identificadores en Java. El programa siguiente,

//El programa no funciona solo ilustra identificadores no validos.

// boolean tengo.Mascota; //contiene un punto

//Ejemplo de identificadores case-sensitive.

// imprime el contenido de la variable