Aprenda Java

Aprenda Java.
ISC Ral Oramas Bustillos. roramas@gmail.com

Este obra est bajo una Licencia Creative Commons Atribucin-NoComercial 2.5 Mxico.

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.

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 3.10. Ejercicios resueltos..............................................................................................62 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 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 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 7.7. Ejercicios resueltos..............................................................................................137 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 8.4. Ejercicios resueltos..............................................................................................152 Bibliografa consultada...............................................................................................159

6.

7.

8.

9.

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 class HolaMundo { 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. */ public class HolaMundo { // el mtodo main inicia la ejecucin del programa public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { System.out.print("Bienvenido al "); System.out.println("curso de programacin con Java!"); } // fin del mtodo main } // 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. Mensaje.java, utiliza secuencias de escape para imprimir texto. El programa siguiente,

//Ejemplo de secuencias de escape. public class Mensaje { public static void main(String[] args) { System.out.println("Bienvenido\nal\nMundo\nJava!"); } // fin del mtodo main } // 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 public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { System.out.printf("%s\n%s\n", "Bienvenido al", "tutorial de Java!"); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // fin de la clase Aritmetica

10

Aprenda Java

2. Programas simples.
Al finalizar esta leccin, sers capaz de:

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 { public static void main(String[] args) { // 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 del mtodo main } // 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.
//Calcula el rea de un crculo. import java.util.Scanner; //para leer del teclado

12

Aprenda Java
public class AreaCirculo { public static void main(String[] args) { // Crea objeto para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaracin de variables 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; // imprime el resultado System.out.printf("El rea del crculo es: %f", area); } // fin del mtodo main } // fin de la clase AreaCirculo

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 { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in);

13

Aprenda Java

// declaracin de variables int numero1; // primer nmero a sumar int numero2; // segundo nmero a sumar int suma; // almacena la suma de numero1 + numero2 // mensaje de usuario 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 del mtodo main } // 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.
//Ejemplo de variables, operadores aritmticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Producto { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // mensaje de usuario 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 del mtodo main } // 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 { public static void main(String[] args) { 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 { public static void main(String[] args) { // 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 del metodo main } // 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 { public static void main(String[] args) { 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 ); } // fin del mtodo main } // fin de la clase 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 { public static void main(String[] args) { // declaracin de variables 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 del mtodo main } // 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.
//Ejemplo de variables, operadores aritmticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Numero234 { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaracin de variables int numero, doble, triple, cuadruple; // mensaje de usuario 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 del mtodo main } // 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.
//Ejemplo de variables, operadores aritmticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class AreaTriangulo { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaracin de variables double area; // almacena el rea del tringulo double base; // la base del tringulo double altura; // la altura del tringulo // mensaje de usuario 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 del mtodo main } // 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.
//Calcula el rea de un crculo. import java.util.Scanner; //para leer del teclado public class AreaCirculo { public static void main(String[] args) {

19

Aprenda Java
// declara una constante con nombre final double PI = 3.14159; // Crea objeto para leer datos Scanner entrada = new Scanner(System.in); // declaracin de variables double radio, 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 * PI; // imprime el resultado System.out.printf("El rea del crculo es: %.2f", area); } // fin del mtodo main } // fin de la clase AreaCirculo

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. PieMetro.java, lee un nmero de pies y lo convierte a metros. El programa siguiente,

//Programa que calcula el equivalente de pies a metros. import java.util.Scanner; //para leer del teclado public class PieMetro { public static void main(String[] args) { // declara una constante con nombre final double PIE_METRO = 0.305; Scanner entrada = new Scanner(System.in); // 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class CalculadoraSimple { public static void main(String[] args) { // Crea objeto Scanner para obtener la entrada del teclado Scanner entrada = new Scanner(System.in); int numeroUno, numeroDos;

22

Aprenda Java

// mensaje de usuario 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Division { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // entrada System.out.print( "Introduce un nmero? " ); int num1 = entrada.nextInt(); System.out.print("Introduce otro nmero? "); int num2 = entrada.nextInt(); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class SumaDigitos { public static void main(String[] args) { int unidad, decena, centena; int numero, temporal, suma; Scanner entrada = new Scanner(System.in); // 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; temporal = 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 del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { int resultado = 14 + 8 / 2; // expresin aritmtica System.out.println(resultado); resultado = (14 + 8) / 2; System.out.println(resultado); resultado = 14 + (8 / 2); System.out.println(resultado); } // fin del mtodo main } // 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 { public static void main(String[] args) { // 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
// mensaje de usuario 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 del mtodo main } // 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 { public static void main(String[] args) { int x = 2; x += 3; // x = x + 3; System.out.println("x = " + x); x -= 3; // x = x 3; System.out.println("x = " + x); x *= 2; // x = x * 2 System.out.println("x = " + x); x /= 2; // x = x / 2 System.out.println("x = " + x); } // fin del mtodo main } // 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, incremento/decremento.

IncrementoDecremento.java,

utiliza

los

operadores

de

//Operadores de incremento/decremento. public class IncrementoDecremento { public static void main(String[] args) { 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("x = " + x); System.out.println("y = " + y); System.out.println("Trabajando con el operador prefijo."); y = ++x; System.out.println("x = " + 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 del mtodo main } // 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.
//Ejemplo de variables, operadores aritmticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Sueldo { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaracin de variables 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 // mensaje de usuario 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class VolumenCilindro { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Calcula el volumen de un cilindro."); System.out.println("----------------------------------"); // lectura de los datos System.out.print("Radio? "); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Hipotenusa { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Hipotenusa de un tringulo rectngulo."); System.out.println("--------------------------------------"); // 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)); // imprime el resultado System.out.printf("La hipotenusa es: %d", hipotenusa); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado

31

Aprenda Java

public class Metro { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declaracin de variables 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 System.out.printf("%.2f System.out.printf("%.2f System.out.printf("%.2f System.out.printf("%.2f } // fin del mtodo main } // fin de la clase Metro metros equivalen a:\n\n", nMetros); centmetros\n", centimetro); pulgadas\n", pulgada); pies\n", pie); yardas\n", yarda);

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. import java.util.Scanner; //para leer del teclado public class Inversion { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declaracin de variables 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; // salida de resultados 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 del mtodo main } // 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 IMC= w ( 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. import java.util.Scanner; //para leer del teclado public class IndiceMasaCorporal { public static void main(String[] args) { int pesoCorporal; // en kilos int altura; // en centmetros double imc; Scanner entrada = new Scanner(System.in); System.out.println("Calcula el ndice de masa corporal."); System.out.println("-----------------------------------"); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Distancia { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Calcula la distancia entre dos puntos."); System.out.println("--------------------------------------"); // 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 del mtodo main } // 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 Mercurio Venus Jpiter Saturno Multiplique el peso en la Tierra por 0.4 0.9 2.5 1.1

//Programa que calcula el peso en otros planetas. import java.util.Scanner; //para leer del teclado public class PesoPlanetas { public static void main(String[] args) { // 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; Scanner entrada = new Scanner(System.in); System.out.println("Calcula el peso en otros planetas."); System.out.println("----------------------------------"); // 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 del mtodo main } // 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 Mercurio Venus Jpiter Saturno d = nmero aproximado de das 88 225 4380 10767

//Programa que calcula la edad en otros planetas. import java.util.Scanner; //leer del teclado public class EdadPlanetas { public static void main(String[] args) { // 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; Scanner entrada = new Scanner(System.in); System.out.println("Calcula la edad en otros planetas."); System.out.println("----------------------------------"); // 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 System.out.printf("Edad System.out.printf("Edad System.out.printf("Edad System.out.printf("Edad } // fin del mtodo main } // fin de la clase EdadPlanetas en en en en en la Tierra: %d\n", edad); Mercurio: %d\n", edadMercurio); Venus: %d\n", edadVenus); Jpiter: %d\n", edadJupiter); Saturno: %d\n", edadSaturno);

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. import java.util.Scanner; //para leer del teclado public class HoraSegundos { public static void main(String[] args) { // constantes final int HORA_SEG = 3600; final int MIN_SEG = 60; // variables int hora, minuto, segundo; int nSegundos; Scanner entrada = new Scanner(System.in); System.out.println("Convierte hora-min-seg a segundos."); System.out.println("----------------------------------"); // 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 del mtodo main } // 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 import java.util.Scanner; //para leer del teclado public class CifraCentral { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int digitoCentral = 0; // entrada System.out.print("Nmero de cinco cifras?"); numero = entrada.nextInt(); // determina la cifra central digitoCentral = (numero % 1000) / 100; // salida de resultados System.out.printf("La cifra central es %d", digitoCentral); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Prestamo { public static void main(String[] args) { double cantidad, tasaInteres, nAos; double adeudo; Scanner entrada = new Scanner(System.in); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Monedas { public static void main(String[] args) { final int BILLETE_PESO = 100; // 100 centavos int montoCompra, cambio, temporal; int moneda50, moneda20, moneda10, moneda5, moneda1; Scanner entrada = new Scanner(System.in); // 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; moneda20 = temporal / 20; temporal = temporal % 20; moneda10 = temporal / 10; temporal = temporal % 10; moneda5 = temporal / 5; moneda1 = temporal % 5; // salida System.out.printf("Cambio = $%d\n", cambio); System.out.printf("%d monedas de 50 centavos\n", moneda50); System.out.printf("%d monedas de 20 centavos\n", moneda20); System.out.printf("%d monedas de 10 centavos\n", moneda10); System.out.printf("%d monedas de 5 centavos\n", moneda5); System.out.printf("%d monedas de 1 centavos\n", moneda1); } // fin del mtodo main } // fin de la clase Monedas

41

Aprenda Java

3. Instrucciones de seleccin.
Al finalizar esta leccin, sers capaz de:

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 { public static void main(String[] args) { // 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 del metodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { final int MENOR_EDAD = 18; // declara una constante Scanner entrada = new Scanner(System.in); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class NumerosIguales { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Determina si dos nmeros son iguales."); System.out.println("------------------------------------."); System.out.print("Introduce dos nmeros enteros: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); // determina si son iguales if (num1 == num2) System.out.printf("%d y %d son iguales.", num1, num2); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Multiplo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // 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 } // fin del mtodo main

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 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); 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 del mtodo main } // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class ParImpar { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // operacin de lectura System.out.print("Introduce un nmero: "); int numero = entrada.nextInt(); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class NumerosIguales { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Determina si dos nmeros son iguales."); System.out.println("------------------------------------."); System.out.print("Introduce dos nmeros enteros: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Calificacion { public static void main(String[] args) { final int CALIF_MIN = 7; // minimo aprobatorio Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce cuatro calificaciones (0-10): "); double calif1 = entrada.nextDouble(); double calif2 = entrada.nextDouble(); double calif3 = entrada.nextDouble(); double calif4 = 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Suma { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // genera dos nmeros aleatorios con el mtodo random int numero1 = (int) (Math.random() * 10); int numero2 = (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 } // fin del mtodo main } // fin de la clase Suma

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. import java.util.Scanner; //para leer del teclado public class Resta { public static void main(String[] args) { // genera los nmeros aleatorios int numero1 = (int) (Math.random() * 10); int numero2 = (int) (Math.random() * 10); // 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 Scanner entrada = new Scanner(System.in); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 - numero2 == respuesta) System.out.println("La respuesta es correcta."); else System.out.println("La respuesta es incorrecta."); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Limites { public static void main(String[] args) { final int LSUP = 200; final int LINF = 100; int numero; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Nmero? "); numero = entrada.nextInt(); // 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); System.out.printf( "%d no alcanza el lmite inferior.\n", numero); } // fin del mtodo main } // fin de la clase Limites else

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. import java.util.Scanner; //para leer del teclado. public class PositivoNegativoNulo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Introduce un nmero entero: "); int numero = entrada.nextInt(); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Divisor { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce dos nmeros: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Adivinanza { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numeroSecreto = (int) (Math.random() * 10); System.out.print("Piensa un nmero entre 0 y 9: "); int numero = entrada.nextInt(); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class DiaSemana { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // 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 else if (dia == 2) System.out.println("El da else if (dia == 3) System.out.println("El da else if (dia == 4) System.out.println("El da else if (dia == 5) System.out.println("El da else if (dia == 6) System.out.println("El da else if (dia == 7) System.out.println("El da else System.out.println("Nmero } // fin del mtodo main } // fin de la clase DiaSemana

es: Lunes."); es: Martes."); es: Mircoles."); es: Jueves."); es: Viernes."); es: Sbado."); es: Domingo."); de da incorrecto.");

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.
//Programa para jugar adivinanzas. import java.util.Scanner; //para leer del teclado public class Adivinanza { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numeroSecreto = (int) (Math.random() * 10); System.out.print("Piensa un nmero entre 0 y 9: "); int numero = entrada.nextInt(); if (numero == numeroSecreto) System.out.println("Adivinaste!"); else if (numero < numeroSecreto) System.out.println("Fro!"); else System.out.println("Caliente!"); } // fin del mtodo main } // fin de la clase Adivinanza

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. import java.util.Scanner; //para leer del teclado public class Sueldo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // 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) sueldo *= 1.21; // sueldo = sueldo * 1.21; else sueldo *= 1.18; // sueldo = sueldo * 1.18; // salida

53

Aprenda Java
System.out.printf("El sueldo del trabajador es $%.2f\n", sueldo); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class ClasificarNumero { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Nmero? "); // indicador int numero = entrada.nextInt(); 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 del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main //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. import java.util.Scanner; //para leer del teclado public class Adolescente { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class PromedioPracticas { public static void main(String[] args) { // variables locales int nota1, nota2, nota3, nota4; int suma = 0; float promedio = 0.0F; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce las 4 calificaciones: "); nota1 = entrada.nextInt(); nota2 = entrada.nextInt(); nota3 = entrada.nextInt(); nota4 = entrada.nextInt(); // proceso if (nota1 < nota2 && nota1 < nota3 && nota1 suma = nota2 + nota3 + nota4; else if (nota2 < nota1 && nota2 < nota3 && suma = nota1 + nota3 + nota4; else if (nota3 < nota1 && nota3 < nota2 && suma = nota1 + nota2 + nota4; else if (nota4 < nota1 && nota4 < nota2 && suma = nota1 + nota2 + nota3; < nota4) nota2 < nota4) nota3 < nota4) nota4 < nota3)

promedio = suma / 3.0F; // obtiene el promedio // salida System.out.printf("El promedio es: %d\n", promedio); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Loteria { public static void main(String[] args) {

56

Aprenda Java
// genera el nmero de la loteria int loto = (int) (Math.random() * 100); Scanner entrada = new Scanner(System.in); 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) System.out.println("Ganaste $3,000.00"); else if (digito1 == digitoLoto1 || digito1 == digitoLoto2 || digito2 == digitoLoto1 || digito2 == digitoLoto2) System.out.println("Ganaste $1,000.00"); else System.out.println("Sigue participando."); } // fin del mtodo main } // 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 { public static void main(String[] args) { // simula tres tiros de un dado int dado1 = (int) (Math.random() * 6 + 1); int dado2 = (int) (Math.random() * 6 + 1); int dado3 = (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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Mayor { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce dos nmeros: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class ParImpar { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce un nmero: "); int num = entrada.nextInt(); System.out.println((num % 2 == 0) ? "Es par." : "Es impar."); } // fin del mtodo main } // fin de la clase ParImpar

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 { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class AumentoSueldo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // 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: nuevoSueldo = sueldo * 1.10F; break; case 3: nuevoSueldo = sueldo * 1.08F; break; case 4: nuevoSueldo = sueldo * 1.07F; break; default: System.out.println("Categora invlida"); } // fin switch // salida

60

Aprenda Java
System.out.printf("El nuevo sueldo es $%.2f\n", nuevoSueldo); } // fin del mtodo main } // 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. import java.util.Scanner; public class PiedraPapelTijera { public static void main(String[] args) { final int PIEDRA = 1, PAPEL = 2, TIJERA = 3; int jugador, computadora; Scanner entrada = new Scanner(System.in); // 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) System.out.println("El jugador gana!"); else if (jugador == PAPEL && computadora == PAPEL) System.out.println("Empate."); else if (jugador == PAPEL && computadora == TIJERA) System.out.println("La computadora gana."); if (jugador == TIJERA && computadora == PIEDRA) System.out.println("La computadora gana."); else if (jugador == TIJERA && computadora == PAPEL) System.out.println("El jugador gana!"); else if (jugador == TIJERA && computadora == TIJERA) System.out.println("Empate"); } // fin del mtodo main } // fin de la clase PiedraPapelTijera

3.10. Ejercicios resueltos.

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. Nota: los problemas que se resuelven aqu no tienen una solucin nica. 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 1 a 25 26 a 50 Precio unitario. $17.50 $15.00

62

Aprenda Java 51 a 75 76 en adelante $12.50 $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. import java.util.Scanner; //para leer del teclado public class VentaPaletas { public static void main(String[] args) { // variables locales int numPaletas = 0; double importeCompra = 0.0; double importeDescuento = 0.0; double importePagar = 0.0; Scanner entrada = new Scanner(System.in); 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 >= 26 && numPaletas <= 50) importeCompra = numPaletas * 15.0; if (numPaletas >= 51 && numPaletas <= 75) importeCompra = numPaletas * 12.50; if (numPaletas >= 76) importeCompra = numPaletas * 10.0; // 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

// salida de resultados 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class PromedioFinal { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // 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."); System.out.println("------------------------------"); // entrada System.out.print("Introduce las 3 calificaciones (1-10)? "); nota1 = entrada.nextDouble(); nota2 = entrada.nextDouble(); nota3 = 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; // salida de resultados 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class RestaMenor { public static void main(String[] args) { int numeroUno; int numeroDos; int resta; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce dos nmeros enteros: "); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class SalarioProgramador { public static void main(String[] args) { final int HORAS_BASE = 40; final int HORAS_EXTRA = 60; final int SALARIO_SEMANA = 1600; int nHoras, sueldoTotal; Scanner entrada = new Scanner(System.in); // 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 del mtodo main } // 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
import java.util.Scanner; //para leer del teclado public class CifrasConsecutivas { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // lectura System.out.print("Nmero entero positivo de tres cifras? "); int numero = entrada.nextInt(); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado. public class TresCifras { public static void main(String[] args) { int a, b, c; Scanner entrada = new Scanner(System.in);

67

Aprenda Java
// lectura System.out.print("Nmero 3 cifras? "); int numero = entrada.nextInt(); // 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 + else System.out.println(a + "" + c + else System.out.println(c + "" + a + "" + else if (b > c) if (c > a) System.out.println(b + "" + c + "" + else System.out.println(b + "" + a + "" + else System.out.println(c + "" + b + "" + a); } // fin del mtodo main } // fin de la clase TresCifras

"" + c); "" + b); b); a); c);

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 Tenis Golf Esqu Marcha > 85 70 < TEMP 85 32 < TEMP 70 10 < TEMP 32 10

//Dada una temperatura recomienda el deporte a practicar. import java.util.Scanner; //para leer del teclado public class Deporte {

68

Aprenda Java
public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // entrada System.out.print("Temperatura en fahrenheit? "); int temp = entrada.nextInt(); // proceso y salida if (temp > 85) System.out.println("Practica else if (temp > 70) System.out.println("Practica else if (temp > 32) System.out.println("Practica else if (temp > 10) System.out.println("Practica else System.out.println("Practica } // fin del mtodo main } // fin de la clase Deporte

natacin"); tenis"); golf"); esqu"); la marcha");

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 import java.util.Scanner; //para leer del teclado public class PromedioAsignatura { public static void main(String[] args) { // variables float calif1, calif2, calif3, calif4; float promedio; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce las 4 califs (0-100)? "); calif1 = entrada.nextFloat();

69

Aprenda Java
calif2 = entrada.nextFloat(); calif3 = entrada.nextFloat(); calif4 = entrada.nextFloat(); // proceso y salida promedio = (calif1 + calif2 + calif3 + calif4) / 4.0f; if (promedio >= 90) System.out.println("Tienes else if (promedio >= 80) System.out.println("Tienes else if (promedio >= 70) System.out.println("Tienes else if (promedio >= 60) System.out.println("Tienes else System.out.println("Tienes } // fin del mtodo main } // fin de la clase PromedioAsignatura una A."); una B."); una C."); una D."); una F.");

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. import java.util.Scanner; //para leer del teclado public class NotaNumerica { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce una nota numrica entre 0 y 10: "); int numero = entrada.nextInt(); 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 del mtodo main } // 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. import java.util.Scanner; public class Repuestos { public static void main(String[] args) { int numeroSerie; boolean defectuoso1; boolean defectuoso2; boolean defectuoso3; // Prepara el teclado para la lectura de los datos Scanner entrada = new Scanner(System.in); 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); defectuoso2 = (70001 <= numeroSerie && numeroSerie <= 79999); defectuoso3 = (88888 <= numeroSerie && numeroSerie <= 111111); 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 del mtodo main } // fin de la clase NumeroSerie

72

Aprenda Java

4. Instrucciones de repeticin.
Al finalizar esta leccin, sers capaz de:

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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { int contador = 10; // declara e inicializa // la variable de control while (contador > 0) // condicin de continuacin de ciclo

73

Aprenda Java
{

System.out.println(contador); contador--; // decrementa la variable de control en 1 } // fin de while } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class SumaWhile { public static void main(String[] args) { int i = 1; // variable de control int suma = 0; // acumulador int n; // representa los n primeros nmero naturales Scanner entrada = new Scanner(System.in); // 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 del mtodo main } // 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.
//Programa para jugar adivinanzas. import java.util.Scanner; //para leer del teclado public class Adivinanza { public static void main(String[] args) { // genera el nmero aleatorio entre 0 y 100 int numeroSecreto = (int) (Math.random() * 101);

74

Aprenda Java

Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Piensa un nmero entre 0 y 100."); System.out.println("-------------------------------"); int numero = -1; while (numero != numeroSecreto) { // solicita un nmero al usuario System.out.print("Nmero? "); numero = entrada.nextInt(); // evala if (numero == numeroSecreto) System.out.println("Adivinaste!"); else if (numero < numeroSecreto) System.out.println("Fro!"); else System.out.println("Caliente!"); } // fin while } // fin del mtodo main } // fin de la clase Adivinanza

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. import java.util.Scanner; //para leer del teclado public class Suma { public static void main(String[] args) { 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 Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) { // genera dos nmeros aleatorios con el mtodo random int numero1 = (int) (Math.random() * 10); int numero2 = (int) (Math.random() * 10); // muestra la pregunta al usuario System.out.printf("Cunto es %d + %d ? ",

75

Aprenda Java
numero1, numero2); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 + numero2 == respuesta) { System.out.println("La respuesta es aciertos++; } // fin if else { System.out.println("La respuesta es System.out.printf("%d + %d = %d\n", (numero1 + numero2)); } // fin else contador++; // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " + " + numero2 + " = " + respuesta + ((numero1 + numero2 == respuesta) : " incorrecto"); } // fin while

correcta.");

incorrecta."); numero1, numero2,

? " correcto"

// imprime los resultados obtenidos System.out.printf("\nRespuestas correctas: %d\n%s", aciertos, reporte); } // fin del mtodo main } // fin de la clase Suma

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. import java.util.Scanner; //para leer del teclado public class SumaCentinela { public static void main(String[] args) { int numero = 0; int suma = 0; Scanner entrada = new Scanner(System.in);

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 System.out.print("Nmero a sumar (0 para terminar)? "); numero = entrada.nextInt(); // lectura } // fin while System.out.printf("La suma es %d", suma); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Promedio { public static void main(String[] args) { int numero = 0; int contador = 0; int suma = 0; Scanner entrada = new Scanner(System.in); // mensaje de usuario 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)"); numero = entrada.nextInt(); // lectura while (numero >= 0) { suma += numero; // suma = suma + numero; contador++; // contador = contador + 1; numero = entrada.nextInt(); // lectura } // 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 del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { int contador = 1; // inicializa contador System.out.printf("%d ", contador); contador++; // incrementa la variable de control } while (contador <= 10); // condicin de continuacin } // fin del mtodo main } // fin de la clase ContadorDoWhile do {

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 { public static void main(String[] args) { 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class SumaCentinela2 { public static void main(String[] args) { int numero = 0; int suma = 0; Scanner entrada = new Scanner(System.in); do { // lee el siguiente nmero System.out.print("Nmero a sumar (0 para terminar)? "); numero = entrada.nextInt(); // lectura suma += numero; // suma = suma + numero; } while (numero != 0); // fin do/while System.out.printf("La suma es %d", suma); } // fin del mtodo main } // 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 { public static void main(String[] args) { for (int i = 0; i < 100; i++) System.out.println("JavaJavaDo"); } // fin del mtodo main } // 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 { public static void main(String[] args) { // 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--) System.out.println(contador); // esto es un error // for( int i = 1; i < 10; i++ ); //genera un for vaco // System.out.println( i ); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class TablaMultiplicar { public static void main(String[] args) { int nTabla, mult; Scanner entrada = new Scanner(System.in); 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 del mtodo main } // 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. public class ParImpar { public static void main(String[] args) { 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); } // fin del mtodo main } // fin de la clase ParImpar

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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main( String[] args ) { 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 del mtodo main } //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 public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class NumeroPrimo { public static void main(String[] args) { boolean esPrimo = true; int numero; Scanner entrada = new Scanner(System.in); // entrada System.out.print("n? "); numero = entrada.nextInt(); // proceso for (int i = 2; i if (numero % esPrimo break; } // fin if } // fin for <= numero / 2; i++) { i == 0) { // es primo? = false; // no es primo // termina el ciclo

// salida if (esPrimo) System.out.printf(" %d es primo\n", numero); else System.out.printf(" %d no es primo\n", numero); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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 // mensaje de usuario 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 break; // termina el ciclo } // 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 System.out.println(numero); } // fin if else { System.out.print(numero + "\t"); } // fin else } // fin if // busca si el siguiente nmero es primo numero++; } // fin while } // fin del mtodo main } // fin de la clase NumerosPrimos

4.8. Ejercicios resueltos.

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. Nota: los problemas que se resuelven aqu no tienen una solucin nica. 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
import java.util.Scanner; //para leer del teclado public class Cuadrado { public static void main(String[] args) { int numero; int cuadrado; Scanner entrada = new Scanner(System.in); System.out.print("Introduce un nmero entero: "); numero = entrada.nextInt(); 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: "); numero = entrada.nextInt(); } // fin while System.out.println(">>>Fin del programa..."); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class PositivoNegativo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Introduce un nmero positivo/negativo. "); System.out.print("(0 para terminar)? "); int numero = entrada.nextInt(); while (numero != 0) { 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)? "); numero = entrada.nextInt(); } // fin while System.out.println(">>>Fin del programa..."); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class SumaDigitos { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int suma = 0; int temporal = 0; int digito = 0; System.out.println("Suma los dgitos de un nmero."); System.out.println("------------------------------"); System.out.print("Nmero? "); numero = entrada.nextInt(); temporal = numero; while (temporal > 0) { // obtiene el dgito digito = temporal % 10; // lo suma suma += digito; // recorta la cifra temporal = temporal / 10; } // fin while System.out.printf("La suma de los dgitos de %d es %d", numero, suma); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Palindromo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int inverso = 0; int temporal = 0; int digito = 0; System.out.println("Determina si un nmero es palndromo."); System.out.println("-------------------------------------"); System.out.print("Nmero? "); numero = entrada.nextInt(); temporal = numero; while (temporal > 0) { // obtiene el dgito digito = temporal % 10; // forma el nmero inverso inverso = (inverso * 10) + digito; // recorta la cifra temporal = temporal / 10; } // fin while if (numero == inverso) System.out.printf("%d es palndromo", numero); else System.out.printf("%d no es palndromo", numero); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class ConjeturaUlam { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Conjetura de ULAM"); System.out.println("-----------------"); System.out.print("Introduce un nmero entero: "); int numero = entrada.nextInt(); while (numero != 1) { if (numero % 2 == 0) numero = numero / 2; else numero = numero * 3 + 1; System.out.println(numero); } // fin while } // fin del mtodo main } // 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 { public static void main( String[] args ) { 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 del mtodo main //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. import java.util.Scanner; public class Serie2 { public static void main(String[] args) { double serie = 0.0; Scanner entrada = new Scanner(System.in); 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: "); int numero = entrada.nextInt(); // 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Serie3 { public static void main(String[] args) { double serie = 0.0; boolean bandera = true; Scanner entrada = new Scanner(System.in); System.out.println("Calcula la suma de la serie:"); System.out.println("1 - 1/2 + 1/3 - 1/4 ... +- 1/n"); System.out.println("------------------------------"); System.out.print("Introduce el nmero n: "); int numero = entrada.nextInt(); 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Factorial { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int factorial = 1; System.out.println("Factorial de un nmero."); System.out.println("-----------------------"); System.out.print("Nmero? "); numero = entrada.nextInt(); for (int i = 2; i <= numero; i++) factorial *= i; System.out.printf( "El factorial de %d! es %d", numero, factorial); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // fin de la clase Fibonacci

94

Aprenda Java

5. Utilizacin de mtodos pre-construidos.

Al finalizar esta leccin, sers capaz de:

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 { public static void main(String[] args) { // 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 System.out.println(); // 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 System.out.println(); // 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 System.out.println(); // 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 System.out.println(); // 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 System.out.println(); // La raz cuadrada de x System.out.println(Math.sqrt(9)); // 3 System.out.println(); // x elevado a la potencia y System.out.println(Math.pow(2, 3)); // 8 System.out.println(Math.pow(9, 0.5)); // 3 System.out.println(); // genera un nmero aleatorio 0..1 sin incluir el 1 System.out.println(Math.random()); } // fin del mtodo main } // 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 preconstruidos.
//Demuestra el uso de Math.min y Math.max. import java.util.Scanner; //para leer del teclado import static java.lang.Math.*; public class MayorMenor { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce tres nmeros: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); int num3 = entrada.nextInt(); // // // // 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); } // fin del mtodo main

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 { public static void main(String[] args) { 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); System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 del mtodo main } // 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 { public static void main(String[] args) { System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // 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); System.out.println(cad); // si no se especifica el cero se usa un caracter vaco cad = String.format("%8d", 1974); System.out.println(cad); // signo positivo y negativo cad = String.format("+%d", 1974); System.out.println(cad); cad = String.format("-%d", 1974); System.out.println(cad); // agregando el separador de coma cad = String.format("%,d %n%n", 1974); System.out.printf(cad); System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // imprime un nmero en punto flotante cad = String.format("%f", Math.PI); System.out.println(cad); // 3 digitos despus del punto decimal cad = String.format("%.3f", Math.PI); System.out.println(cad); // 8 caracteres y 2 digitos cad = String.format("%8.3f", Math.PI); System.out.println(cad); } //fin del mtodo main //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 { public static void main(String[] args) { String mensaje = "Ahora es el tiempo de Java"; System.out.println("012345678901234567890123456789"); 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 del mtodo main } // 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 { public static void main(String[] args) { 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 System.out.println("No son iguales"); if (cadDos.equalsIgnoreCase("CSHARP")) System.out.println("Son iguales (CSharp)"); else System.out.println("No son iguales"); } // fin del mtodo main } // 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 { public static void main(String[] args) { System.out.println("Nmeros sin formato:"); System.out.println(19.8); System.out.println(19.81111); System.out.println(19.89999); System.out.println(19); System.out.println(); 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.81111)); System.out.println(moneda.format(19.89999)); System.out.println(moneda.format(19)); System.out.println(); System.out.println("Usando el formato de UK:"); NumberFormat monedaUK = NumberFormat.getCurrencyInstance(Locale.UK); System.out.println(monedaUK.format(19.8)); System.out.println(monedaUK.format(19.81111)); System.out.println(monedaUK.format(19.89999));

100

Aprenda Java
System.out.println(monedaUK.format(19)); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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"); System.out.println(patron2.format(numero)); DecimalFormat patron3 = new DecimalFormat("##.###"); DecimalFormat patron4 = new DecimalFormat("#.##"); System.out.println("Patrn 3: ##.###"); System.out.println(patron3.format(numero)); System.out.println("Patrn 4: #.##"); System.out.println(patron4.format(numero)); 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 del mtodo main } // fin de la clase DecimalFormatDemo

101

Aprenda Java

6. Mtodos.
Al finalizar esta leccin, sers capaz de:

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 public static void main(String[] args) { // invoca al mtodo static saludo(); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class Temperatura { // convierte de Fahrenheit a Celsius public static void fahrenheitCelsius() { double fahrenheit, celsius; // variables locales Scanner entrada = new Scanner(System.in); // lee la temperatura System.out.print("Ingresa una temperatura en Fahrenheit: "); fahrenheit = entrada.nextDouble(); // realiza la conversin celsius = 5.0 / 9.0 * fahrenheit - 32; // imprime el resultado 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 Scanner entrada = new Scanner(System.in); // 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; // imprime el resultado System.out.printf("La temperatura en Fahrenheit es %.2f%n", fahrenheit); } // fin del mtodo celsiusFahrenheit public static void main(String[] args) { int opcion; // variable local Scanner entrada = new Scanner(System.in); // mensaje de usuario 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 del mtodo main } // 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 public static void main(String[] args) { mostrarMensaje("Java"); // llamada al mtodo

104

Aprenda Java
mostrarMensaje("C Sharp"); // llamada al mtodo } // fin del mtodo main } // 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'); else if (calificacion >= 70.0) System.out.println('C'); else if (calificacion >= 60.0) System.out.println('D'); else System.out.println('F'); } // fin del mtodo calificar public static void main(String[] args) { System.out.print("Obtuviste una "); calificar(78.5); System.out.print("Obtuviste una "); calificar(59.5); } // fin del mtodo main } // 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 public static void main(String[] args) { // invoca al mtodo static System.out.println(saludo()); } // fin del mtodo main } // 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. import java.util.Scanner; //para leer del teclado public class AreaCirculo { // calcula el area de un circulo public static double area(double radio) { return (Math.PI * Math.pow(radio, 2)); } // fin del mtodo area public static void main(String[] args) { Scanner entrada = new Scanner(System.in); 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)); } // fin del mtodo main } // fin de la clase AreaCirculo

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 public static void main(String[] args) { 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 del mtodo main } // 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 public static void main(String[] args) { 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 del mtodo main } // 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 public static void main(String[] args) { 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 del mtodo main } // 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. import java.util.Scanner; //para leer del teclado 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() { Scanner entrada = new Scanner(System.in); // entrada System.out.print( "Escribe tres double numero1 = double numero2 = double numero3 =

nmeros, separados por espacios: "); entrada.nextDouble(); entrada.nextDouble(); 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 public static void main(String[] args) { // llama al mtodo static determinarMaximo(); } // fin del mtodo main } // 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 public static void main(String[] args) { 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 del mtodo main } // 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 public static void main(String[] args) { 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 del mtodo main } // 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 public static void main(String[] args) { // 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; } // fin del mtodo max // regresa el mayor de tres nmeros double public static double max(double num1, double num2, double num3){ return (max(max(num1, num2), num3)); } // fin del mtodo max public static void main(String[] args) { // 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 del mtodo main } // 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; } // fin del mtodo cuadrado public double cuadrado(int x) { return x * x; } // fin del mtodo cuadrado } // 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 System.out.println("x = " + x); // 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 public static void main(String[] args) { metodoUno(); } // fin del mtodo main } // fin de la clase Alcance

114

Aprenda Java

6.11. Ejercicios resueltos.

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. Nota: los problemas que se resuelven aqu no tienen una solucin nica. 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. import java.util.Scanner; //para leer del teclado 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."); System.out.println("--------------------------"); } // 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 Scanner entrada = new Scanner(System.in); // 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."); System.out.println("------------------"); calcularAreaTriangulo(); break; case 2: System.out.println("2. rea cuadrado."); System.out.println("-----------------"); 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() { Scanner entrada = new Scanner(System.in); System.out.print("Base? "); double base = entrada.nextDouble(); System.out.print("Altura? ");

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() { Scanner entrada = new Scanner(System.in); 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() { Scanner entrada = new Scanner(System.in); System.out.print("Base? "); double base = entrada.nextDouble(); System.out.print("Altura? "); double altura = entrada.nextDouble(); double area = areaRectangulo(base, altura); System.out.printf("El rea es %.2f", area); } // fin del mtodo calcularAreaRectangulo private static void calcularAreaCirculo() { Scanner entrada = new Scanner(System.in); System.out.print("Radio? "); double radio = entrada.nextDouble(); double area = areaCirculo(radio); System.out.printf("El rea es %.2f", area); } // fin del mtodo calcularAreaCirculo public static void main(String[] args) { String opcion = null; Scanner entrada = new Scanner(System.in);

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 del metodo main } // 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. import java.util.Scanner; public class Aritmetica { public static void main(String[] args) { String opcion = null; Scanner entrada = new Scanner(System.in); 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 del metodo main private static void mostrarTitulo() { System.out.println("Programa aritmtica 1.0."); System.out.println("------------------------"); } // fin del mtodo mostrarTitulo // las opciones del men private static void menuOpciones() { System.out.println("Operaciones:"); System.out.println("1. Sumar."); System.out.println("2. Restar."); System.out.println("3. Multiplicar."); System.out.println("4. Dividir."); System.out.print("Selecciona una opcin (1-4): "); } // fin del mtodo menuOpciones

118

Aprenda Java
// el men del programa private static void menu() { // variable local Scanner entrada = new Scanner(System.in); // 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. 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."); System.out.println("------------------------------"); practicarMultiplicacion(); break; case 4: System.out.println("4. Practicar divisiones."); System.out.println("------------------------"); practicarDivision(); break; default: System.out.println("Opcin del men invlida."); } // fin switch } // fin del mtodo menu private static void practicarSuma() { final int NUMERO_PREGUNTAS = 10; // nmero mximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente est vaco Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) {

119

Aprenda Java
// genera dos nmeros aleatorios con el mtodo random int numero1 = (int) (Math.random() * 9 + 1); int numero2 = (int) (Math.random() * 9 + 1); // muestra la pregunta al usuario System.out.print( "Cunto es " + numero1 + " + " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 + numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(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 System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del mtodo practicarSuma private static void practicarResta() { final int NUMERO_PREGUNTAS = 10; // nmero mximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente est vaco Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) { // genera dos nmeros aleatorios con el mtodo random int numero1 = (int) (Math.random() * 9 + 1); int numero2 = (int) (Math.random() * 9 + 1);

120

Aprenda Java

// si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1; numero1 = numero2; numero2 = temp; } // fin if // muestra la pregunta al usuario System.out.print( "Cunto es " + numero1 + " - " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 - numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(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 System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del mtodo practicarResta private static void practicarMultiplicacion() { final int NUMERO_PREGUNTAS = 10; // nmero mximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente est vaco Scanner entrada = new Scanner(System.in);

121

Aprenda Java
while (contador < NUMERO_PREGUNTAS) { // genera dos nmeros aleatorios con el mtodo random int numero1 = (int) (Math.random() * 9 + 1); int numero2 = (int) (Math.random() * 9 + 1); // muestra la pregunta al usuario System.out.print( "Cunto es " + numero1 + " * " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 * numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(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 System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del mtodo practicarMultiplicacion private static void practicarDivision() { final int NUMERO_PREGUNTAS = 10; // nmero mximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente est vaco Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) { // genera dos nmeros aleatorios con el mtodo random int numero1 = (int) (Math.random() * 9 + 1);

122

Aprenda Java
int numero2 = (int) (Math.random() * 9 + 1); // si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1; numero1 = numero2; numero2 = temp; } // fin if // muestra la pregunta al usuario System.out.print( "Cunto es " + numero1 + " / " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 / numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(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 System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del mtodo practicarDivision } // fin de la clase Aritmetica

123

Aprenda Java

7. Arreglos unidimensionales.
Al finalizar esta leccin, sers capaz de:

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 { public static void main(String[] args) { // 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 del mtodo main } // 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 { public static void main(String[] args) { double[] miArreglo = new double[10]; // 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[5] = 34.33; miArreglo[6] = 34.0; miArreglo[7] = 45.45; miArreglo[8] = 99.93; 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 del mtodo main } // 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 { public static void main(String[] args) { double[] miArreglo = new double[10]; // 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 del mtodo main } // 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 { public static void main(String[] args) { double[] miArreglo = { 1.9, 2.9, 3.4, 3.5 }; System.out.println("Contenido del arreglo:"); System.out.println("miArreglo[0] = " + miArreglo[0]); System.out.println("miArreglo[1] = " + miArreglo[1]);

126

Aprenda Java
System.out.println("miArreglo[2] = " + miArreglo[2]); System.out.println("miArreglo[3] = " + miArreglo[3]); //esto es un error //int[] lista; //lista = {1,2,3,4,5}; } // fin del mtodo main } // 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 valores ledos desde el teclado. inicializa un arreglo unidimensional con

//Inicializar los valores de un arreglo. import java.util.Scanner; //para leer del teclado public class LecturaArreglo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); 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:"); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("miArreglo[%d] = %d\n",

127

Aprenda Java
i, miArreglo[i]); } // fin for } // fin del mtodo main } // 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 { public static void main(String[] args) { double[] miArreglo = new double[10]; // inicializa el arreglo con valores aleatorios for (int i = 0; i < miArreglo.length; i++) { // 0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random() * 100; } // fin for // imprime el contenido del arreglo System.out.println("El contenido del arreglo:"); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("miArreglo[%d] = %.2f\n", i, miArreglo[i]); } // fin for } // fin del mtodo main } // fin de la clase ArregloAleatorio

El programa siguiente, unidimensional.

SumaArreglo.java

suma

los

elementos

de

un

arreglo

//Sumar los valores de un arreglo. public class SumaArreglo { public static void main(String[] args) { double[] miArreglo = new double[10]; double suma = 0.0; // inicializa el arreglo con valores aleatorios for (int i = 0; i < miArreglo.length; i++) { // 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 del mtodo main } // 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 { public static void main(String[] args) { 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 for (int i = 1; i < miArreglo.length; i++) { if (miArreglo[i] > mayor) mayor = miArreglo[i]; } // fin for // imprime la suma del arreglo System.out.printf("El elemento mayor es %.2f", mayor); } // fin del mtodo main } // 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 { public static void main(String[] args) { int[] miArreglo = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // procesa el arreglo for (int i = 0; i < miArreglo.length; i++) { // genera el indice j aleatoriamente int j = (int) (Math.random() * miArreglo.length); // intercambia int temporal = miArreglo[i] = miArreglo[j] = } // fin for miArreglo[i] con miArreglo[j]; miArreglo[i]; miArreglo[j]; temporal;

// imprime los valores del arreglo

129

Aprenda Java
System.out.println("Los valores del arreglo:"); for (int i = 0; i < miArreglo.length; i++) { System.out.print(miArreglo[i] + " "); } // fin for } // fin del mtodo main } // 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 { public static void main(String[] args) { int[] miArreglo = { 1, 5, 3, 4, 7, 9 }; // procesa el arreglo for (int elemento : miArreglo) System.out.println(elemento); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { 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 }); } // fin del mtodo main
public static void imprimir(double[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // 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 { public static void main(String[] args) { double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 }; int[] y = { 11, 31, 13, 12, 21 };

imprimir(x); imprimir(y); } // fin del mtodo main

// mtodo overload public static void imprimir(double[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del mtodo imprimir // mtodo overload

131

Aprenda Java
public static void imprimir(int[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del mtodo imprimir } // 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. import java.util.Scanner; //para leer del teclado public class ProductoVector { // variable de clase - variable static private static final int MAX = 10; // tamao del arreglo public static void main(String[] args) { // 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); } // fin del mtodo main private static int[] leerArreglo() { // crea el objeto de lectura Scanner entrada = new Scanner(System.in); 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.println("------------------"); System.out.printf("d1 = %.2f%n", d1); System.out.printf("d2 = %.2f%n", d2); System.out.printf("d3 = %.2f%n", d3); System.out.printf("d4 = %.2f%n", d4); System.out.println(); 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 promedio(d1, d2, d3, d4)); } // fin del mtodo main } // fin de la clase VarArgs

es %.2f%n",

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 { public static void main(String[] args) { 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); } // fin del mtodo main private static void imprimir(double[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del mtodo imprimir } // 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. import java.util.Arrays; public class BusquedaArreglo { public static void main(String[] args) { 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 1, Arrays.binarySearch( System.out.printf( "El valor %d se 5, Arrays.binarySearch( System.out.printf( "El valor %d se 3, Arrays.binarySearch( //fin del mtodo main encuentra en la pos %d%n", miArreglo, 1)); encuentra en la pos %d%n", miArreglo, 5)); encuentra en la pos %d%n", miArreglo, 3));

private static void imprimir(int[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del mtodo imprimir //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 import java.util.Arrays; public class ComparaArreglos { public static void main(String[] args) { 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 del mtodo main //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 { public static void main(String[] args) { 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 del mtodo main

private static void imprimir(int[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del mtodo imprimir } // 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 { public static void main(String[] args) { 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 del mtodo main

private static void imprimir(int[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del mtodo imprimir //fin de la clase CopiarArreglo2

136

Aprenda Java

7.7. Ejercicios resueltos.

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. Nota: los problemas que se resuelven aqu no tienen una solucin nica. 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. import java.util.Arrays; import java.util.Scanner; //para leer del teclado public class ArregloApp { public static void main(String[] args) { final int TAMAO_ARREGLO = 10; // el tamao del arreglo // crea un arreglo de 10 posiciones int[] listaNumero = new int[TAMAO_ARREGLO]; String opcion = null; Scanner entrada = new Scanner(System.in); do {

menu(listaNumero); System.out.print("\nDeseas continuar? (S/N)"); opcion = entrada.next(); } while (opcion.equals("S") || opcion.equals("s"));

System.out.println(">Fin del programa..."); } // fin del mtodo main // el titulo del programa private static void mostrarTitulo() { System.out.println("Operaciones bsicas con arreglos."); System.out.println("---------------------------------"); } // fin del mtodo mostrarTitulo // las opciones del men del programa private static void menuOpciones() { 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): "); } // fin del mtodo menuOpciones // el menu del programa private static void menu(int[] miArreglo) { Scanner entrada = new Scanner(System.in); // muestra el titulo del programa mostrarTitulo(); // muestra las opciones del menu menuOpciones(); // lee la opcin del teclado int opcion = entrada.nextInt(); 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."); System.out.println("-----------------------------"); 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."); System.out.println("-----------------------------------"); 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: System.out.println("Opcin del men invlida."); } // fin switch } // fin del mtodo menu private static void leerArreglo(int[] miArreglo) { Scanner entrada = new Scanner(System.in); System.out.printf("Introduce %d nmeros enteros (0-9).%n", miArreglo.length); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("Valor %d ?", i + 1); miArreglo[i] = entrada.nextInt(); } // fin for

139

Aprenda Java
imprimirArreglo(miArreglo); } // 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); System.out.println(); } // 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); imprimirArreglo(miArreglo); } // 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 for (int i = 1; i < miArreglo.length; i++) { 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; for (int i = 0; i < miArreglo.length; i++) { 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; for (int i = 0; i < miArreglo.length; i++) { 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; for (int i = 0; i < miArreglo.length; i++) { if (miArreglo[i] == numero) contador++; } // fin for return contador; } // fin del mtodo cuentaRepeticiones // imprime un histograma de frecuencia private static void histograma(int[] miArreglo) { System.out.println(); for (int i = 0; i < miArreglo.length; i++) { // 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 System.out.println(); } // 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 System.out.println(); 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.
Al finalizar esta leccin, sers capaz de:

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 { public static void main(String[] args) { double[][] arreglo2D; // otra forma: double arreglo2D[][]; // es un error // double arreglo2D[5][6]; // double arreglo2D(4)(3); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { 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 los valores del arreglo 2D rengln x columna 5.6; 4.5; 3.3; 1.2; 4.0; 3.2; 4.0; 5.4; 9.9;

// inicializa tabla[0][0] = tabla[0][1] = tabla[0][2] = tabla[1][0] = tabla[1][1] = tabla[1][2] = tabla[2][0] = tabla[2][1] = tabla[2][2] =

// esto es un error // genera un ArrayIndexOutOfBoundsException // tabla[3][3] = 12.5; } // fin del mtodo main } // 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 { public static void main(String[] args) { 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 System.out.println("tabla[0][0] = System.out.println("tabla[0][1] = System.out.println("tabla[0][2] = primer rengln:"); " + tabla[0][1]); " + tabla[1][2]); " + tabla[2][3]);

// esto es un error // int[][] lista; // lista = {{1,2,3},{4,5,6},{7,8,9}}; } // fin del mtodo main } // 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 { public static void main(String[] args) { 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]; triangulo2[1] = new int[4]; triangulo2[2] = new int[3]; triangulo2[3] = new int[2]; triangulo2[4] = new int[1]; } // fin del mtodo main } // 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. import java.util.Scanner; public class LecturaArreglo2D { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declara un arreglo2d de 2x3 int[][] tabla = new int[2][3];

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 System.out.print(tabla[0][0] System.out.print(tabla[0][1] System.out.print(tabla[0][2] } // fin del mtodo main } // fin de la clase LecturaArreglo2D 1 + + + = ["); " "); " "); "]");

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 { public static void main(String[] args) { int[][] tabla = new int[2][3]; 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 System.out.print(tabla[0][0] System.out.print(tabla[0][1] System.out.print(tabla[0][2] } // fin del mtodo main } // fin de la clase Arreglo2DAleatorio 1 + + + = ["); " "); " "); "]");

147

Aprenda Java El programa siguiente, ImprimirArreglo2D.java, imprime el contenido del arreglo bidimensional .
//Imprime el contenido de un arreglo2D. public class ImprimirArreglo2D { public static void main(String[] args) { // 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("--------------------"); // imprime el contenido del arreglo for (int i = 0; i < tabla.length; i++) { System.out.print("Renglon " + i + " = [ "); for (int j = 0; j < tabla[i].length; j++) System.out.print(tabla[i][j] + " "); System.out.println("]"); } // fin for } // fin del mtodo main } // 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 { public static void main(String[] args) { // 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."); System.out.println("-----------------------------"); 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 del mtodo main } // fin de la clase SumaArreglo2D

148

Aprenda Java El programa siguiente, bidimensional.

SumaColumna2D.java

suma las columnas de un arreglo

//Suma las columnas de un arreglo 2D. public class SumaColumna2D { //Suma las columnas de un arreglo 2D. public class SumaColumna2D { public static void main(String[] args) { // 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 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 del mtodo main } // 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 { public static void main(String[] args) { // 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 } }; 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 del mtodo main } // 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 { public static void main(String[] args) { // declara e inicializa un arreglo de 3x3 int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; // procesa el arreglo intercambiando los valores for (int i = 0; i < tabla.length; i++) { 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."); // imprime el contenido del arreglo for (int i = 0; i < tabla.length; i++) { System.out.print("Rengln " + i + " = [ "); for (int j = 0; j < tabla[i].length; j++)

150

Aprenda Java
System.out.print(tabla[i][j] + " "); System.out.println("]"); } // fin for } // fin del mtodo main } // 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] + " "); System.out.println("]"); } // fin for } // fin del mtodo imprimirArreglo public static void main(String[] args) { int tabla[][] = { { 25, 5, 6, 15, 18 }, { 12, 54, 21, 1, 14 }, { 34, 28, 8, 67, 7 } };

imprimirArreglo(tabla); } // fin del mtodo main } // 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 { public static void main(String[] args) { 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); } // fin del mtodo main 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

8.4. Ejercicios resueltos.

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. import java.util.Scanner; //para leer del teclado public class Arreglo2DApp { public static void main(String[] args) { String opcion = null; Scanner entrada = new Scanner(System.in); System.out.println("Inicializacin del Arreglo 2D."); System.out.println("------------------------------"); 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); System.out.print("\nDeseas continuar? (S/N)");

152

Aprenda Java
opcion = entrada.next(); } while (opcion.equals("S") || opcion.equals("s")); System.out.println(">Fin del programa..."); } // fin del metodo main // el titulo del programa private static void mostrarTitulo() { System.out.println("Operaciones bsicas con arreglos 2D."); System.out.println("------------------------------------"); } // fin del mtodo mostrarTitulo // las opciones del men private static void menuOpciones() { 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."); System.out.print("Selecciona una opcin (1-8): "); } // fin del mtodo menuOpciones // el men del programa private static void menu(int[][] arreglo2D) { // variable local Scanner teclado = new Scanner(System.in); int opcion = 0; // muestra las opciones del men menuOpciones(); opcion = teclado.nextInt(); switch (opcion) { case 1: System.out.println("1. Llenar el arreglo 2D."); System.out.println("------------------------"); leer(arreglo2D); break; case 2: System.out.println("2. Imprimir el arreglo 2D."); System.out.println("--------------------------"); 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."); System.out.println("--------------------------"); imprimirSuma(arreglo2D); break; case 6: System.out.println("6. Imprimir el promedio."); System.out.println("------------------------"); imprimirPromedio(arreglo2D); break; case 7: System.out.println("7. Encontrar el elemento mayor."); System.out.println("-------------------------------"); imprimirMaxValor(arreglo2D); break; case 8: System.out.println("8. Encontrar el elemento menor."); System.out.println("-------------------------------"); imprimirMinValor(arreglo2D); break; default: System.out.println("Opcin del men invlida."); } // 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 Scanner entrada = new Scanner(System.in); // mensaje de usuario 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) { // mensaje de usuario System.out.printf("Matriz de %d x %d.%n", matriz.length, +matriz[0].length); // impresin del matriz for (int ren = 0; ren < matriz.length; ren++) { for (int col = 0; col < matriz[ren].length; col++) System.out.printf("[ %d ] ", matriz[ren][col]); System.out.println(); } // fin for } // fin del mtodo imprimir // 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++) for (int col = 0; col < matriz[ren].length; col++) 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 ren = 0; ren < matriz.length; ren++) { 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; for (int ren = 0; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) 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)); } // fin del mtodo imprimir 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 for (int ren = 0; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) 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 for (int ren = 0; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) 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