Aprenda JavaAprenda Java. ISC Raúl Oramas Bustillos.
[email protected] Este obra está bajo una Licencia Creative Commons Atribución-NoComercial 2.5 México. 1 Aprenda Java Descripción del curso. En este curso se estudian los fundamentos de programación con Java a través de ejemplos prácticos. Con este curso aprenderás las habilidades necesarias para desarrollar aplicaciones a un nivel básico-intermedio utilizando el lenguaje de programación Java SE (Standard Edition), versión 7. Audiencia. Este curso está dirigido a estudiantes, profesionistas, y desarrolladores de software que desean conocer el lenguaje de programación Java SE (Standard Edition), versión 7. Requisitos. Ninguna, ya que en este curso iniciamos desde los fundamentos básicos del lenguaje. Objetivos del curso. Después de completar este curso, serás capaz de: • • • Desarrollar y ejecutar programas Java SE (Standard Edition), versión 7. Comprender los principios básicos de la programación con Java: estructura de secuencia, selección, repetición, programación modular y arreglos. Con los conceptos aprendidos en este curso se preparan las bases para aprender a programar en objetos con Java. 2 Aprenda Java Tabla de contenidos: 1. Introducción 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 básica de un programa en Java............................................................6 1.5. Instrucciones básicas 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 asignación y expresión de asignación.............................................18 2.6. Constantes con nombre........................................................................................19 2.7. Tipos de datos primitivos.......................................................................................21 2.8. Operadores aritméticos.........................................................................................22 2.9. Literales en Java...................................................................................................24 2.10. La evaluación de expresiones en Java...............................................................25 2.11. Operadores abreviados de incremento/decremento...........................................26 2.12. Conversión de tipo (type casting)........................................................................28 2.13. Ejercicios resueltos..............................................................................................31 3. Instrucciones de selección...........................................................................................42 3.1. Tipo de dato boolean.............................................................................................42 3.2. Operadores relacionales y de igualdad.................................................................42 3.3. La instrucción if simple..........................................................................................43 3.4. La instrucción if/else..............................................................................................46 3.5. Instrucciones if anidadas.......................................................................................49 3.6. La instrucción if/else/if...........................................................................................52 3.7. Operadores lógicos...............................................................................................54 3.8. El operador condicional (?:)...................................................................................58 3.9. La instrucción switch.............................................................................................59 3.10. Ejercicios resueltos..............................................................................................62 4. Instrucciones de repetición...........................................................................................73 4.1. Instrucción de repetición while..............................................................................73 4.2. Ciclos controlados por un valor centinela.............................................................76 4.3. Ciclos infinitos........................................................................................................78 4.4. Instrucción de repetición do/while.........................................................................79 4.5. Instrucción de repetición for...................................................................................80 4.6. Ciclos anidados.....................................................................................................82 4.7. Instrucción break y continue..................................................................................83 4.8. Ejercicios resueltos................................................................................................86 5. Utilización de métodos pre-construidos.......................................................................95 3 .....151 8.....146 8....110 6.......... Operaciones básicas con arreglos bidimensionales.......................113 6........................ Declarar..5........................7.....................95 5................................................104 6.................................... Métodos return......127 7...............132 7...............................4........1.............. 4 .....5......................................................................................1........................................... Ejercicios resueltos........................... Métodos void.............99 5...........................6...........................152 Bibliografía consultada.............................. 7..........2................8.....9.....................143 8................................................................................................................................................................... Métodos void sin parámetros.97 5.4........2......................... Operaciones básicas con arreglos unidimensionales.....111 6............................. Métodos de la clase Math.........11........................................................ Ejercicios resueltos..............................Aprenda Java 5......... Métodos de la clase String............1.......... Métodos return sin parámetros.......2......................................3...............................................................................................................................................100 Métodos.....................................................................................................106 6...134 7.6..133 7.........................................................................4............................. Paso de arreglos unidimensionales a los métodos..................................10.................3...........................................7. Formateo de números..................................................................... Métodos void con parámetros.......4.............................. Programación modular.......................................................... La clase Arrays......................................................................102 6........131 7......................124 7........................ Lista de argumentos de longitud variable............... 9...........................3......... Paso de arreglos bidimensionales a los métodos.. Métodos return con parámetros..................................................... crear y asignar valores a un arreglo bidimensional............................................... crear y asignar valores a un arreglo unidimensional..........143 8......................................................................... Métodos sobrecargados (overload)..................... Declarar............... 8...... Compatibilidad de argumentos y parámetros.....3...105 6......................1.........159 6.................................... El ámbito de las variables...........102 6..124 7....115 Arreglos unidimensionales......................106 6.. Formateo de la salida.........................................................137 Arreglos bidimensionales.........................................2..102 6........... Ejercicios resueltos....... Arreglos unidimensionales como valor de retorno..................................................................................102 6.. serás capaz de: • • • • Conocer las etapas de desarrollo de un programa Java. En la etapa de ejecución. se escriben las instrucciones del programa usando el lenguaje Java y se guarda en un archivo cuyo nombre debe terminar con la extensión . se traduce el código fuente usando el compilador de Java. A este programa escrito en Java se denomina código fuente y para escribirlo se puede recurrir a cualquier editor de texto. que tiene el mismo nombre que el archivo de código fuente.1. Podemos comparar Java respecto a otros lenguajes de programación en la página Web: http://www.tiobe. si el archivo de código fuente se denomina Saludo. Etapas de desarrollo de un programa en Java. Para desarrollar un programa en Java tenemos que pasar por las siguientes etapas: edición.php/content/paperinfo/tpci/index. Existe una JVM para cada plataforma (para cada sistema operativo). el archivo podría llamarse Saludo. El código de bytes es el lenguaje de la JVM.Aprenda Java 1.exe. Así. pero con la extensión . compilación y ejecución.class.class. En la etapa de compilación.2. Esto 5 . el código de bytes es independiente de la plataforma. Así. desarrollado por Sun Microsystems en la década de 1990. Descargar e instalar el software para el desarrollo de programas Java. En la actualidad Java es un lenguaje muy cotizado. que es un programa denominado javac. El lenguaje Java. con lo que se obtiene un nuevo código conocido como código de bytes (bytecodes en inglés). En la etapa de edición. pero. por ejemplo.java. Al finalizar esta lección.java. Java es un lenguaje de programación orientado a objetos. Moldeado en base a C++. Introducción a Java.java. sencillo y portátil a través de plataformas y sistemas operativos. En años recientes la tecnología de Java fue adquirida por la empresa Oracle (famosa por su programa administrador de base de datos del mismo nombre). Así. el código de bytes quedará almacenado automáticamente en un archivo denominado Saludo. por sus siglas en inglés).html 1. el lenguaje Java se diseñó para ser pequeño. todas las JVM pueden ejecutar el mismo código de bytes.com/index. Identificar la estructura básica de un programa en Java. el código de bytes es ejecutado por la Máquina Virtual de Java (JVM. Escribir programas simples en Java. 1. Por ejemplo: HolaMundo.com/technetwork/java/javase/downloads/index. dígitos. existe una JVM para la mayor parte de las plataformas. Debemos de tener en cuenta que Java es sensible a mayúsculas y minúsculas. Estructura básica de un programa en Java. las letras mayúsculas y minúsculas en un identificador son distintas. es decir. La palabra clave class introduce una declaración de clase. Al guardar este código.3. Para el desarrollo de programas Java es necesario descargar e instalar la Plataforma Java en su edición estándar que lo obtenemos de : http://www. public class HolaMundo { } Todo programa en Java consiste de.java. Un identificador es una serie de caracteres que pueden ser letras. Empezaremos el proceso de aprendizaje de Java definiendo la estructura básica de un programa en Java.4. debe terminar con la declaración de una clase.org BlueJ: www. 6 . HolaMundo.bluej. Software para el desarrollo de programas en Java. lo que garantiza que los programas Java sean ampliamente portables. la cual debe ir seguida por el nombre de la clase. guiones bajos (_) y signos de moneda ($) que no comience con un dígito ni tenga espacios. Su correspondiente llave derecha }. El programa siguiente. 1.og Eclipse: www.Aprenda Java hace que los programas Java puedan ser ejecutados en cualquier máquina que disponga de una JVM. declara una clase.netbeans.org. 1. A las llaves { y } se les conoce como bloque.eclipse.html También necesitaremos un entorno de desarrollo integrado (IDE por sus siglas en inglés).oracle. Cada clase comienza con la palabra clave public. comienza con el cuerpo de todas las declaraciones de clases. Actualmente. el nombre de ese archivo debe coincidir con el nombre de la clase. Un bloque puede contener o anidar otros bloques. Entre los más populares tenemos: • • • NetBeans: www. Las palabras clave o palabras reservadas se reservan para uso exclusivo de Java y siempre se escriben en minúscula. El nombre de una clase es un identificador. cuando menos una declaración de clase: public class HolaMundo.java Una llave izquierda {. out. Se dice entonces que una aplicación en Java es un programa que contiene el método main. Las palabras String[] args entre paréntesis son una parte requerida de la declaración del método main. El programa siguiente. El programa siguiente. La palabra clave void indica que este método realizará una tarea. Esta instrucción le indica a la computadora que imprima la cadena de caracteres contenidas entre los caracteres de comillas dobles (sin incluirlas). es una instrucción.Aprenda Java Todo programa en Java debe de contener un método principal al que se le denomina main.java. Ya que tenemos la estructura básica para crear aplicaciones en Java lo único que falta es agregar instrucciones para que el programa realice una o más acciones. imprime un mensaje de texto en la consola de salida. pero no devolverá ningún tipo de información cuando complete su tarea. } // fin del método main } // fin de la clase HolaMundo Los comentarios ayudan a documentar un programa y mejorar su legibilidad. public class HolaMundo { public static void main(String[] args) { } } El método main es el punto de inicio de toda aplicación en Java.out se conoce como objeto de salida 7 . HolaMundo.println("¡Hola Mundo!"). El compilador de Java ignora estos comentarios. HolaMundo. Los comentarios tradicionales (o de múltiples líneas) se distribuyen en varias líneas y comienza con el delimitador /* y termina con */.java Propósito: Imprimir un mensaje en la consola de salida. La línea: System.println("¡Hola Mundo!").java incorpora la definición del método main. A una cadena también se le denomina cadena de caracteres. mensaje o literal de cadena. Un comentario que comienza con // se llama comentario de fin de línea (o de una sóla línea). */ public class HolaMundo { // el método main inicia la ejecución del programa public static void main(String[] args) { System. Todas las instrucciones en Java termina con un punto y coma (. /* Programa: HolaMundo. La llave izquierda { comienza el cuerpo de la declaración del método y su correspondiente llave derecha } debe terminar el cuerpo de esa declaración.out. System.). Los paréntesis después del identificador main indican que este es un método. print("¡Bienvenido al "). System. //No respetar la condición mayúscula/minúscula //Es común escribir con mayúsculas: public. class.out. El programa siguiente. La cadena dentro de paréntesis es el argumento para el método. etc.java utiliza instrucciones print/println para mostrar texto.out y pasarle como argumento entre comillas dobles el texto que queremos desplegar en la pantalla de la computadora. etc. Por lo tanto el programa anterior no funciona.5 Instrucciones básicas para imprimir texto. Las cadenas pueden incluir caracteres especiales como el de una nueva línea para indicarle a los métodos print y println de System.println("curso de programación con Java!"). main. 1.out.out imprime una línea de texto en la consola de salida (ventana de comandos.java. Un error de sintaxis es una violación a las reglas del lenguaje. HolaMundo. //Omitir los pares de { y }. El programa siguiente. Al escribir los primeros programas en Java es común cometer errores de sintaxis. Para hacer que un programa imprima una línea de texto necesitamos utilizar el método println/print de System. Saludo. } // fin del método main } // fin de la clase Saludo El método print y println se utilizan para mostrar texto.out. static.out cuándo deben colocar el cursor de salida al 8 . //Ejemplo con print/println.Aprenda Java estándar. El método println de System. } // fin del método main } // fin de la clase HolaMundo Para que el programa anterior funcione es necesario respetar la condición de mayúscula/minúscula de cada letra del programa. La diferencia es que println da un salto de línea. ( y ) //Omitir el punto y coma //Omitir los pares de comillas dobles “ y “ Public class HolaMundo { // el método main inicia la ejecución del programa public static Void main(String[] args) { system. tiene errores de sintaxis por lo tanto no funcionará hasta que esos errores hayan sido identificados y corregidos. también hay que escribir todos los símbolos que aparecen en el código del programa. shell.println("¡Hola Mundo!).). línea de comandos. public class Saludo { public static void main(String[] args) { System. public class ImprimirTexto { // el método main empieza la ejecución de la aplicación en Java public static void main(String[] args) { System. public class Mensaje { public static void main(String[] args) { System.out.out.Aprenda Java inicio de la siguiente línea en el monitor de la computadora.print("\nEstoy aprendiendo \"Java\""). éstos se separan con comas (.out. El programa siguiente. utiliza el método printf. a esto se le conoce como lista separada por comas.println("¡Bienvenido\nal\nMundo\nJava!"). El tabulador horizontal está compuesto por \t.out. ImprimirTexto. Y si queremos imprimir un texto entre comillas dobles utilizamos la \” y \”. A este carácter se le conoce como secuencia de escape. } // fin del método main } // fin de la clase Mensaje La barra diagonal inversa (\) se conoce como carácter de escape.out.print("Linea 01\nLinea 02\nLinea 03\nLinea 04"). System. Bienvenido. Cuando un método requiere varios argumentos. La secuencia de escape \n representa el carácter de una nueva línea. System. La llamada al método printf especifica tres argumentos. //Imprimir texto con secuencias de escape. } // fin del método main } // fin de la clase Bienvenido La f en el nombre printf representa la palabra “formato”. El programa siguiente. El primer 9 . En este curso vamos a utilizar frecuentemente la instrucción printf para dar formato al texto.java. Este carácter indica a los métodos print y println que se va a imprimir un carácter especial. "¡Bienvenido al". muestra algunas secuencias de escape comunes. } // fin del método main } // fin de la clase ImprimirTexto La secuencia de escape \n representa una nueva línea. utiliza secuencias de escape para imprimir texto. Mensaje. System.java.out. Para imprimir una diagonal \ utilizamos \\. Veamos otro ejemplo.printf("%s\n%s\n". //Ejemplo con printf. "tutorial de Java!"). el programa siguiente. //Ejemplo de secuencias de escape. public class Bienvenido { public static void main(String[] args) { System.java.print("\nTab 01\tTab 02\tTab 03\tTab 04").).print("\nRuta de BlueJ: c:\\BlueJ"). printf("%d + %d = %d\n". // se genera un error en tiempo de ejecución // System.5). 5. Aritmetica. Los especificadores de formato empiezan con un signo porcentual (%) y van seguidos de un carácter que representa el tipo de datos. 0.5. 5 + 3). El especificador de formato %s es un receptáculo para una cadena. public class Aritmetica { public static void main(String[] args) { System. El programa siguiente. y que cada cadena le debe seguir un carácter de nueva línea. 3. 3. 3.printf("%d / %d = %d\n". // esto es un error.out.java. //Utiliza printf para imprimir números.5. y especifica el tipo de datos a imprimir. 5 + 3). utiliza el método printf para imprimir números enteros y en punto flotante.5 + 3. System. 5. 5 / 0 ).out.Aprenda Java argumento del método printf es una cadena de formato que puede consistir en texto fijo y especificadores de formato.out. // cuando manejamos números hay que cuidar // la división por cero.printf("%f + %f = %f\n". } // fin del método main } // fin de la clase Aritmetica 10 . 5. el especificador de formato es incorrecto // System.printf("%d + %d = %d\n". 5. 5. Cada especificador de formato es un receptáculo para un valor.out. La cadena de formato especifica que printf debe imprimir dos cadenas.5. // imprime el resultado System. // calcula el área area = radio * radio * 3.println( "El área del círculo es: " + area ). Programas simples. 2. El programa siguiente.out. Al finalizar esta lección. 11 . que es el signo igual (=).1. El proceso de aprendizaje para resolver problemas mediante un lenguaje de programación pasa por la etapa de resolver y codificar cientos de programas. AreaCirculo. // asigna el valor al radio radio = 20. //Calcula el área de un círculo.14159. // no confundir la igualdad matemática y la asignación // esto es un error: // 4 + 5 = x. } // fin del método main } // fin de la clase AreaCirculo Una variable es el nombre de una posición de memoria que puede guardar un valor específico. Una declaración de variable indica al compilador cuál es su nombre y su tipo. double area. public class AreaCirculo { public static void main(String[] args) { // declaración de variables double radio. calcula el área de un círculo.java. Veamos un primer ejemplo de muchos. Para asignar un valor a una variable se usa el operador de asignación. // x + y = y + x. Escribir un programa simple. serás capaz de: • Escribir programas simples en Java que reciban valores desde el teclado y realicen cálculos aritméticos.Aprenda Java 2. así como las operaciones que se puede hacer con ella. El tipo de una variable indica la clase de valor que ésta puede almacenar. Scanner. Una expresión aritmética es un cálculo que produce un valor y está compuesta por operadores aritméticos y operandos. Para hacer operaciones matemáticas se utilizan los operadores aritméticos (+ . numero. //Programa que calcula el doble de un número. El método printf de System. Dado que la clase Scanner no es parte del conjunto fundamental de las clases de Java necesitamos indicarle al compilador donde encontrarla. public class DobleNumero { public static void main(String[] args) { // declaración de la variable // int numero.java es nos permitir leer datos desde el teclado y calcular el área de un círculo. que permite obtener entradas desde el teclado.2.out. AreaCirculo. //para leer del teclado 12 . Los tipos de variables como int o double se conocen como tipos primitivos o tipos integrados. deben escribirse en minúsculas. Leer datos desde el teclado. } // fin del método main } // fin de la clase DobleNumero Todas las variables deben declararse con un nombre y un tipo antes de poder usarse. //error usar una variable sin valor asignado int numero = 5.java. //Calcula el área de un círculo. No se puede utilizar una variable si no tiene un valor asignado. Los nombres de los tipos primitivos son palabras clave y.util.* / %).printf("El doble de %d es %d\n". El programa siguiente. por lo tanto. El programa siguiente. %f para un número en punto flotante y %s para las cadenas. // realiza el cálculo // salida System. Intentar utilizar una variable sin un valor asignado genera un error en tiempo de compilación. 2.out utiliza el especificador de formato %d para mostrar un número entero. DobleNumero. utiliza una expresión aritmética para calcular el doble de un número. import java.Aprenda Java Para emplear el valor de las variables basta con hacer referencia al nombre de éstas dentro del código del programa. doble). Java proporciona una clase pre-compilada llamada Scanner. // asigna un valor a la variable // proceso int doble = numero * 2. println("------------------------------"). System. //Ejemplo de variables. area).in). } // fin del método main } // fin de la clase AreaCirculo Para utilizar la clase Scanner se utiliza la instrucción: import java. La expresión new Scanner(System. veamos un par de ejemplos que nos permitan trabajar con variables enteras y de punto flotante. Una vez creado el objeto. // mensaje de usuario System. public class Suma { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System. se puede leer y almacenar un número con la llamada al método nextDouble para el caso de los números en punto flotante. // imprime el resultado System. En primer lugar vamos a escribir un programa que nos permita leer del teclado dos números enteros. operadores aritméticos y la clase Scanner. Se requiere insertar esta instrucción en la parte superior del método main: Scanner entrada = new Scanner(System.Scanner.util. 13 .println("Calcula el área de un círculo..out..nextDouble().Scanner. // declaración de variables double radio.printf("El área del círculo es: %f".in. Este objeto almacena los caracteres introducidos desde el teclado. calcular la suma e imprimir el resultado en la consola de salida.in). // obtiene el radio del círculo System.out. // para leer desde el teclado.Aprenda Java public class AreaCirculo { public static void main(String[] args) { // Crea objeto para leer desde el teclado Scanner entrada = new Scanner(System. Para continuar aprendiendo programación con Java.").out. import java. crea un objeto y le pasa como argumento el teclado que está representado con System.14159.util.in).print("Radio? ").out. double area. radio = entrada.in). // calcula el área area = radio * radio * 3. // entrada System. // almacena la suma de numero1 + numero2 // mensaje de usuario System.Scanner. // para leer desde el teclado.out.println("Programa que suma dos números enteros.").out.java.nextInt(). //Ejemplo de variables. // lee el segundo número // proceso suma = numero1 + numero2. // lee el primer número System. Producto. utilizaremos dos variables de tipo float y calcularemos su producto.println("Programa que multiplica dos números.println("--------------------------------------")."). // suma los números // salida System.util. suma). // entrada System..out.in). System. // mensaje de usuario System.out.out.println("------------------------------------"). se puede leer y almacenar un número entero con la llamada al método nextInt. Una vez creado el objeto con Scanner entrada = new Scanner(System. // indicador numero1 = entrada.print("Segundo número a sumar? "). // primer número a sumar int numero2. // indicador numero2 = entrada. // imprime la suma } // fin del método main } // fin de la clase Suma La instrucción import le ayuda al compilador a localizar una clase que se encuentra en la API de Java.in). // indicador 14 . Con el programa siguiente. import java.out.print("Primer número a sumar? ").nextInt(). System. public class Producto { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System. 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.Aprenda Java // declaración de variables int numero1. operadores aritméticos y la clase Scanner.out.printf("La suma es %d\n". // segundo número a sumar int suma.print("Primer número? ").out. //El programa no funciona solo ilustra identificadores no validos. El primer carácter no debe ser un número.2f nos permite indicar el número de decimales a mostrar. //public es palabra clave 15 .Aprenda Java float numero1 = entrada. dígitos y caracteres como signos de moneda ($) y/o guión bajo (_). una variable. // lee el segundo número // proceso float producto = numero1 * numero2. public class Identificador { public static void main(String[] args) { float costoTotal. Un identificador es el término técnico para el nombre de un componente de programa: el nombre de una clase.out. System. El programa siguiente.out.printf("%.2f = %. // salida System.println("main -> identificador método"). numero2.3. System. Si un identificador no sigue estas reglas. etc. } // fin del metodo main } // fin de la clase Identificador Los identificadores deben estar formados enteramente por letras.println("costoTotal -> identificador variable").2f x %.out. numero1. muestra como no declarar identificadores en Java. Veamos un ejemplo de como no declarar identificadores en Java. System. producto). public class NoIdentificador { public static void main(String[] args) { // float costo Total.out. El programa siguiente. NoIdentificador. // indicador float numero2 = entrada.out. Identificador.print("Segundo número? "). el nombre de un método.java. //inicia con un número // boolean public. Identificadores. //contiene espacios // int 3deseos.println("Identificador -> identificador clase").2f\n". // lee el primer número System.nextFloat().java. 2.nextFloat(). muestra los identificadores en Java. el programa no compilará. } // fin del método main } // fin de la clase Producto El especificador de formato %. //Ejemplos de identificadores en Java. 20. una variable de tipo entero sólo puede almacenar valores enteros y no valores en punto flotante.out. es decir hace distinción entre minúsculas y mayúsculas.println("El valor de suma es " + suma).java. demuestra lo mencionado anteriormente. sueldo = 15400. // también se pueden declarar en una sola línea // int x. public class Variable { public static void main(String[] args) { // declaración de variables int edad. z. // esto es un error. // variable local int SUMA = 12.println("El valor de SUMA es " + SUMA). suma no está definida // System. El programa siguiente. // int a. //Programa que declara y manipula variables.out. //Ejemplo de identificadores case-sensitive.4. //contiene un punto // double #numPrimo. 16 . Variables. Variable. //El signo # u otros no están permitidos } // fin del metodo main } // fin de la clase NoIdentificador Para terminar con el tema de los identificadores: recuerda que Java es case-sensitive. //usar nombres de variables significativos // no se puede declarar una variable más de una vez // int a.out.java. } // fin del método main } // fin de la clase Suma 2. utiliza variables para guardar y manipular datos.println( "El valor de SUMA es " + Suma ). Por ejemplo. El programa siguiente. CaseSensitive. // SUMA es distinta de suma // imprime el contenido de la variable System. double sueldo. c. b. y. //esto es un error // asignación de valores a las variables edad = 18. System.Aprenda Java // boolean tengo.Mascota. public class CaseSensitive { public static void main(String[] args) { int suma = 5. Una variable en Java puede almacenar sólo un tipo de valor. Scanner.java. triple. Veamos un ejemplo que nos permita practicar con todos los conceptos estudiados hasta el momento. triple. El programa siguiente. tripe y cuádruple de un número."). Java utiliza el signo igual (=) para las instrucciones de asignación. //error de sintaxis // declaración de una variable int x. los números no tienen comas. // asignación incorrecta // edad = 18. System.out.out.println( "Calcula el doble. // para leer desde el teclado. // la variable x no tiene un valor inicial // x = x + 1.print("Número? ").0. // entrada System. Una instrucción de asignación pone un valor dentro de una variable.out.println(sueldo). System. //error de sintaxis } // fin del método main } // fin de la clase Variable Los nombres de variables son identificadores. calcula el doble.util. // uso del valor de una variable System.nextInt(). cuádruple de un número. import java.in).println(edad). public class Numero234 { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System. // lee el número 17 . // mensaje de usuario System.println(numeroSuerte).out. Numero234. En Java. // indicador numero = entrada.println( "-------------------------------------------------"). // declaración de variables int numero.out. cuadruple. System. doble.Aprenda Java // declaración e inicialización de una variable int numeroSuerte = 38.out. //Ejemplo de variables.50. //los tipos no coinciden // la variable aumento no tiene un tipo // aumento = 1500. operadores aritméticos y la clase Scanner. Aprenda Java // proceso doble = numero * 2; triple = numero * 3; cuadruple = numero * 4; // salida System.out.printf( "El doble, triple y cuádruple de %d es %d, %d y %d\n", numero, doble, triple, cuadruple); } // fin del método main } // fin de la clase Numero234 Al declarar una variable no olvidar poner el punto y coma al final. Al declarar más de una variable en una sola instrucción, es importante no olvidar separar las variables por comas. 2.5. Operador de asignación y expresión de asignación. Antes de usar una variable, es necesario declararla y asignarle un valor utilizando el signo igual (=). El programa siguiente, CalculoSimple.java, realiza cálculos simples utilizando expresiones. //Programa que realiza cálculos de expresiones simples. public class CalculoSimple { public static void main(String[] args) { // variable = expresión 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; //asignación ilegal de tipo // x = x / 0; //división por cero } // fin del método main } // fin de la clase CalculoSimple No confundir la igualdad matemática y la asignación. Al asignar un valor a una variable hay que tener en cuenta el tipo de la variable. Una expresión aritmética involucra valores númericos y operadores aritméticos tales como la suma o resta. Cuando dos o más operadores están presentes en una expresión aritmética, es necesario determinar el orden 18 Aprenda Java de evaluación 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 triángulo calculará su área. //Ejemplo de variables, operadores aritméticos 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); // declaración de variables double area; // almacena el área del triángulo double base; // la base del triángulo double altura; // la altura del triángulo // mensaje de usuario System.out.println("Área de un triángulo."); 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 método 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 añadiendo la palabra clave final. El programa siguiente, AreaCirculo.java, define una constante con nombre para calcular el área de un círculo. //Calcula el área de un círculo. 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); // declaración de variables double radio, area; // mensaje de usuario System.out.println("Calcula el área de un círculo."); System.out.println("------------------------------"); // obtiene el radio del círculo System.out.print("Radio? "); radio = entrada.nextDouble(); // calcula el área area = radio * radio * PI; // imprime el resultado System.out.printf("El área del círculo es: %.2f", area); } // fin del método main } // fin de la clase AreaCirculo En una constante solamente se deben usar letras mayúsculas 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 más fácil la documentación del código. Veamos otro ejemplo para practicar con este concepto. PieMetro.java, lee un número 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 Los cuatro primeros se utilizan para almacenar números enteros y los dos últimos para almacenar números en punto flotante. Hay seis tipos de datos numéricos en Java: byte. //Programa que muestra los ochos tipos de datos primitivos. // salida System. El programa siguiente. } // fin del método main } // fin de la clase PieMetro 2.2f pies son %. // 64 bits -->por default // tipo carácter char letra = 'A'. TipoPrimitivo. En Java también se utiliza el tipo de dato char así como el boolean.50. // valores: true/false // cuidado con el overflow // int valor = 2147483647 + 1.printf("%. short.00.0f. nPies.out. float y double. // 8 bits short distancia = 127. long. //-2147483648 21 .Aprenda Java double metros = nPies * PIE_METRO. // 32 bits // asignación ilegal // float salario = 3850.7. // 64 bits // punto flotante float salario = 3850. //String->comillas dobles // tipo boolean boolean tengoPerro = false. int. Tipos de datos primitivos. // 16 bits int sumaTotal = 1250.java. muestra los ocho tipos de datos primitivos en Java.00 está en 64 bits double granTotal = 125000. Se dice que un tipo de datos con un rango variable más grande tiene mayor precisión. La diferencia entre estos seis tipos de datos numéricos es principalmente el rango de valores que pueden representar. Por ejemplo el tipo double tiene una precisión mayor que el tipo de datos float. //3850. // 32 bits -->por default long distanciaLuna = 238857. metros). public class TipoPrimitivo { public static void main(String[] args) { // tipos integrales byte edad = 38. // 16 bits UNICODE // asignación ilegal // char letra = "A".2f metros". //64 bits punto flotante System. //2147483647 } // fin del método main } // fin de la clase TipoPrimitivo Los tipos de variables definen un conjunto de valores que pueden tomar las variables. //Calculadora simple en Java. la computadora puede representar los números con exactitud.out.0 ). //Ilustra el concepto de precisión. public class Precision { public static void main( String[] args ) { System.out. //se representa en 32 bits System.1. //error de redondedo System.Scanner. Precisión.0 ).println( 7 / 3 ). //7.8.java. El programa siguiente. //se representa en 64 bits System. } //fin del método main } //fin de la clase Precision 2.flotante //imprime 0. En muchos casos.out.f.1. import java. System.out.println( 10. Los operadores aritméticos pueden utilizarse con los tipos enteros y en punto flotante.out.out. La computadora tiene que representar los números mediante una cantidad fija de unos y ceros.println( 7. ocurre un error de desbordamiento. el resultado es un entero y si alguno de ellos está en punto flotante.out. CalculadoraSimple. //se representa en 32 bits p. Operadores aritméticos.java. El programa siguiente.util. muestra los operadores aritméticos en Java.println( 10 ).0 .1 ).out.0F -> 32 bits p.println( 100 * 4. no exacta. int numeroUno. 22 .0 / 3. //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). muestra lo que sucede con la aproximación de punto flotante. pero en otros.println( 7. Lo que debemos de tener en cuenta es que si los operandos son enteros.println( 2. la representación del número es sólo cercana. //32 bits enteros System.println( 10.35 ). Al asignar a una variable un valor que rebasa sus límites.89999999999999999 System.0F / 3 ). el resultado se expresa en punto flotante. numeroDos.0F ).Aprenda Java // cuidado con el underflow // int otroValor = -2147483648 . El operador de módulo devuelve el resto de una división.Aprenda Java // mensaje de usuario System.nextInt().numeroUno * numeroDos).printf("El residuo es %d\n".out. // indicador numeroDos = entrada. //para leer del teclado public class Division { public static void main(String[] args) { Scanner entrada = new Scanner(System. int num1 = entrada.print("Introduce otro número? ").java. int mod1 = num1 % num2. import java. // entrada System.printf("La suma es %d\n". // indicador numeroUno = entrada.print("Escribe el primer número: "). El programa siguiente. System. System.out.numeroUno / numeroDos).out.out. System.printf("La división es %d\n".print( "Introduce un número? " ).print("Escribe el segundo número: ").println(div1).printf("La resta es %d\n". demuestra la división de enteros y el operador de módulo.util.nextInt(). División.out.out.Scanner. 23 . numeroUno % numeroDos).nextInt().in).println("-----------------"). System.println(mod1). System.numeroDos). System.nextInt().out. int mod2 = num2 % num1.out. System.out. //Programa para calcular la división y módulo de dos números enteros. // salida System.printf("El producto es %d\n". // proceso int div1 = num1 / num2. int num2 = entrada. int div2 = num2 / num1.println("Calculadora Java.out.").out. System.out.out. numeroUno . System. System. Veamos un par de ejemplos para ilustrar este concepto. numeroUno + numeroDos). } // fin del método main } // fin de la clase CalculadoraSimple Un caso especial se da con la división y el módulo de números enteros. import java.printf("La suma de los dígitos de %d es %d ".println(mod2). centena. //Programa que suma los dígitos de un número entre 0 y 1000. caracteres.out. suma).println(10). SumaDigitos.out.print("Introduce un número entre 0 y 1000? "). suma = unidad + decena + centena.9. demuestra el uso de las literales en Java. numero. //para leer del teclado public class SumaDigitos { public static void main(String[] args) { int unidad. booleanos y cadenas.Scanner.println(div2). en punto flotante. temporal = temporal / 10. decena = temporal % 10. } // fin del método main } // fin de la clase Division El programa siguiente. temporal. unidad = temporal % 10.util.java. // literal entera 32 bits 24 . suma.nextInt().out. numero = entrada. temporal = temporal / 10.out.java. centena = temporal % 10. En Java tenemos literales para representar números enteros. // salida System. Scanner entrada = new Scanner(System. obtiene la suma los dígitos de un número de cuatro cifras utilizando el concepto de división de enteros y el operador de modulo. // proceso temporal = numero. //Programa que utiliza literales. El programa siguiente. Literal. Literales en Java.in).Aprenda Java System. System. Una literal es la representación de un valor en el código fuente de un programa. } // fin del método main } // fin de la clase SumaDigitos 2. // entrada System.out. public class Literal { public static void main(String[] args) { System. decena. int numero. resultado = (14 + 8) / 2.java.println('A').out. calif3 = 10. el orden de aplicación de los operadores sigue un orden preciso determinado por las reglas jerarquía de los operadores aritméticos. // literal String } // fin del método main } // fin de la clase Literal 2.out. La evaluación de expresiones en Java. public class Expresion { public static void main(String[] args) { int resultado = 14 + 8 / 2.println(resultado). // literal char System. // literal entera 64 bits System. } // fin del método main } // fin de la clase Expresion El programa siguiente. // es buena práctica inicializar 25 .println(10. // expresión aritmética System. Expresión.out. calif2 = 10.10.out.0. System. Veamos algunos ejemplos que nos permitirán practicar con estos conceptos. public class Promedio { public static void main(String[] args) { // declaración y asignación de los valores double calif1 = 10. //Programa que calcula el promedio de tres calificaciones.out. // literal boolean System. demuestra la evaluación de expresiones aritméticas en Java.out.java. Por ejemplo.println(10. Cuando una expresión aritmética tiene más de un operador aritmético. Promedio. demuestra la evaluación de expresiones aritméticas en Java. las operaciones entre paréntesis se realizan primero en una expresión. System.println(resultado). //Expresión aritmética. double promedio = 0. // literal en punto flotante 64 bits System.0.0D). El programa siguiente.out.println(resultado). resultado = 14 + (8 / 2).0F).0. // literal en punto flotante 32 bits System.println("A").out. y le siguen de izquierda a derecha la multiplicación o división y finalmente la suma y la resta.println(10L).Aprenda Java System.out.0.println(true). System. Java proporciona los operadores de incremento.out. System.").println("x = " + x). //Muestra los operadores abreviados. // x = x – 3. x *= 2. System. 26 . x += 3. x /= 2. *=.java que utiliza los operadores abreviados. } // fin del método main } // fin de la clase Promedio 2. No hay espacios entre los operadores abreviados.printf("El promedio correcto es: %. // x = x * 2 System. /= y %= y permiten simplificar la escritura de expresiones en Java. -=. promedio = (calif1 + calif2 + calif3) / 3. System. El programa siguiente.out. // x = x / 2 System.out.11.out.println("x = " + x). System.Aprenda Java // mensaje de usuario System. Veamos un par de ejemplos. Por ejemplo: + = debe escribirse como +=. } // fin del método main } // fin de la clase OpAbreviado Los operadores abreviados son los siguientes: +=.printf("El promedio incorrecto es: %.out.out.out. decremento y asignación compuesta que permiten escribir una expresión aritmética en una forma compacta.println("x = " + x).println("x = " + x). promedio = calif1 + calif2 + calif3 / 3. promedio).2f\n". OpAbreviado.2f\n".println("--------------------------------"). promedio). // x = x + 3.println("Promedio de tres calificaciones. x -= 3.out. public class OpAbreviado { public static void main(String[] args) { int x = 2. Operadores abreviados y de incremento/decremento. } // fin del método main } // fin de la clase IncrementoDecremento Los operadores ++ y -. // a tener en cuenta // int i = 10.puede aparecer antes o después del valor que incremente o decrece."). es lo mismo que int num = 10 * i. // int num = 10 * i.").1. int num = 10 * i++. Estos operadores de incrementos y decrementos se pueden fijar antes o después. public class IncrementoDecremento { public static void main(String[] args) { int x = 0. System. y = ++x.out.println("y = " + y).out. // // // // // // a tener en cuenta int i = 10. De manera similar x-decrece el valor de x en 1.println("y = " + y).out. al igual que la expresión x = x + 1. x++. // es lo mismo que // i = i + 1. // x = x . // int num = 10 * (++i). System.Aprenda Java El programa siguiente. // x = x + 1. Por ejemplo.out.out. i = i + 1. x++ incrementa el valor de x en 1. System.java. 27 .println("x = " + x).println(x). y = 0. incremento/decremento. x--. el ++ o -. Con el operador prefijo primero se incrementa la variable y luego se asigna.println("Trabajando con el operador postfijo. System. IncrementoDecremento. // el valor de x es cero System. utiliza los operadores de //Operadores de incremento/decremento. y = x++. es decir.println("x = " + x).println("Trabajando con el operador prefijo.out. System. Cuando utilizamos el operador de posfijo primero se asigna y luego se incrementa. System.out.se utilizan para incrementar o decrecer un valor en 1. Hay dos conversiones posibles en Java: implícitas y explícitas.out. //Programa que demuestra la conversión de tipos.println(raiz).out.out.out. public class Conversion { public static void main(String[] args) { // conversión implícita System. //asignación ilegal int aumento = (int) 1520. Las conversiones explícitas se aplican a un operador de conversión de tipo y la mayoría de las veces implica perder precisión. Cuando una expresión aritmética está formada por variables y constantes del mismo tipo. // se pierde la fracción System. es necesario llevar a cabo una conversión.75.out. // casting.println(aumento). // 1920 que está en int (32 bits) se convierte // a double (64 bits) double distancia = 1920.out. System. // int temp = distancia.pow(5.5). denominada promoción numérica. // sacar la raíz cuadrada de un número int raiz = (int) Math.7). 3). Conversion. Conversión de tipo (type casting).java. Una conversión de tipo es un proceso que convierte el valor de un tipo de datos a otro tipo de datos. El programa siguiente. } // fin del método main } // fin de la clase Conversion 28 .0 * 4. Esta conversión se denomina promoción porque el operando se convierte de menor a mayor precisión.println((double) 1 / 2).println(3 * 4. Una conversión implícita.println(distancia). el resultado se expresa en ese mismo tipo de dato.Aprenda Java 2.out. ilustra el concepto de conversión de tipo. // es lo mismo que 3.println(cubo).12.5 // conversión explícita System.sqrt(81).println((int) 40. System. // elevar un número a la n potencia int cubo = (int) Math. System. se aplica a todos los operandos de un operador aritmético. Cuando los tipos de datos de las variables y constantes en una expresión aritmética son distintos. perdida de precisión System. //Ejemplo de variables. calcula el sueldo de un trabajador.printf("Sueldo total $%.out.Scanner. // indicador ventas = entrada.print("Sueldo base? ").printf("Comisión $%. // sueldo del trabajador float ventas. } // fin del método main } // fin de la clase Sueldo 29 . // salida System.java. // el sueldo total // mensaje de usuario System. // para leer desde el teclado. El programa siguiente. System. // indicador sueldoBase = entrada.out. comision).in).out. //ok comision = (float) (ventas * 0. Véamos otros ejemplos que nos permitan trabajar con los conceptos estudiados anteriormente. // la comisión por las ventas realizadas float sueldoTotal. System.nextFloat().print("Ventas realizadas? ").printf("Sueldo base $%.2f\n".10F.out. //perdida de precisión // comision = ventas * 0.2f\n". // ventas realizadas por el trabajador float comision.out.10). System. // las ventas realizadas // proceso // comision = ventas * 0.util.out. // casting sueldoTotal = sueldoBase + comision.nextFloat(). // declaración de variables float sueldoBase. sueldoTotal).").println("-----------------------------------"). import java. // lee el sueldo base System.2f\n".Aprenda Java La clase Math contiene métodos de clase frecuentemente usados en las funciones matemáticas.10. Al regresar el resultado lo hace con el tipo de dato double por lo que a menudo se tiene que realizar una conversión de tipo para poder asignarlo a una variable de un tipo diferente. sueldoBase).out.println("Calcula el sueldo de un trabajador. operadores aritméticos y la clase Scanner. public class Sueldo { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System. // entrada System. Sueldo. out. calcula la hipotenusa de un triángulo rectángulo.out.out. System.nextFloat().println("Calcula el volumen de un cilindro. // mensaje de usuario System. import java.Scanner.printf("Volumen cilindro: %.util.out.in).out.pow(radio. float altura = entrada. // proceso de los datos float area = (float) (Math.print("Ingresa los valores para el cateto a y b: ").printf("Área cilindro: %. System.sqrt(Math.PI). } // fin del método main } // fin de la clase VolumenCilindro El programa siguiente. Hipotenusa.out.pow(catetoA."). // procesa los datos int hipotenusa = (int) Math.").println("----------------------------------"). //para leer del teclado public class Hipotenusa { public static void main(String[] args) { Scanner entrada = new Scanner(System. int catetoA = entrada.println("--------------------------------------").out.java. System.print("Altura? ").in).util. /Programa para calcular la hipotenusa de un triángulo rectángulo.java. // mensaje de usuario System. int catetoB = entrada. volumen). // lectura de los datos System. //Programa que calcula el volumen de un cilindro. import java. area). // impresión de los resultados System.nextFloat(). // lectura de los datos System. 2) 30 . System. //para leer del teclado public class VolumenCilindro { public static void main(String[] args) { Scanner entrada = new Scanner(System. calcula el volumen de un cilindro.out.println("Hipotenusa de un triángulo rectángulo. float radio = entrada.print("Radio? ").Scanner.out.Aprenda Java El programa siguiente.2f\n". VolumenCilindro.nextInt().2f\n". 2) * Math. float volumen = area * altura.nextInt(). Ejercicios resueltos. podemos seguir las siguientes etapas: • • • • Declarar de variables. Proceso de cálculo (una o más fórmulas). El proceso de aprendizaje de cualquier lenguaje de programación se realiza resolviendo al menos 100 problemas que utilicen las estructuras de control básicas (secuencia. Entrada/Lectura de los datos. //para leer del teclado 31 .pow(catetoB. pulgadas. lo fundamental es entender el problema y auxiliarse de pseudocódigo o diagramas de flujo que nos den la idea básica de lo que estamos tratando de resolver. hay que documentar el programa.out.printf("La hipotenusa es: %d".13. import java.Scanner. lo siguiente es codificar el programa. 2)).54 centímetros //Dada una cantidad de metros imprime su equivalencia en otras //unidades de medida. Escribir un programa que permita convertir una cantidad dada en metros a sus equivalentes en centímetros. pies y yardas.Aprenda Java + Math. Considera la siguiente información: 1 metro = 100 centímetros 1 pie = 12 pulgadas 1 yarda = 3 pies 1 pulgada = 2. compilar. Finalmente. Salida/Impresión de resultados. } // fin del método main } // fin de la clase Hipotenusa 2. corregir los errores de sintaxis y verificar que nuestro programa produce los resultados adecuados. Problema 1.util. Para empezar nuestro proceso de aprendizaje con Java. // imprime el resultado System. Este proceso de aprendizaje inicia con el lápiz y papel. Nota: los problemas que se resuelven aquí no tienen una solución única. hipotenusa). Una vez que tenemos la idea de como resolver el problema. selección. repetición). nMetros = entrada. yarda = pie / 3.out. yardas\n". nMetros). // declaración de variables float dineroTorvalds = 0.out.2f System. // entrada System.out. 32 .54. yarda). // declaración de variables double nMetros.2f System. import java. pie = pulgada / 12.in). Escribe un programa que determine el capital formado y el porcentaje de dicho capital que aporta cada uno de los inversionistas. pies\n".2f System."). System. Linus Torvalds.printf("%.printf("%.2f System. pie). centimetro.out.util.out. //para leer del teclado public class Inversion { public static void main(String[] args) { Scanner entrada = new Scanner(System. Miguel de Icaza y James Gosling aportan cantidades de dinero para formar una empresa de tecnologías avanzadas.println("---------------------------------").Scanner. pulgadas\n". // salida de resultados System. float dineroIcaza = 0.printf("%.println("Cantidad de metros? "). Problema 2.in).out.printf("%.println("Convierte metros a otras medidas.nextDouble().0f. // proceso de conversión centimetro = nMetros * 100. yarda. pulgada.0f.out.printf("%.2f } // fin del método main } // fin de la clase Metro metros equivalen a:\n\n". pulgada = centimetro / 2. System. centímetros\n".0f. pie. centimetro). float dineroGosling = 0. //Programa que calcula la proporción de tres cantidades.Aprenda Java public class Metro { public static void main(String[] args) { Scanner entrada = new Scanner(System. pulgada).out. out. System.2f porciento\n".Aprenda Java // es buena práctica de programación declarar e inicializar float porcentajeTorvalds = 0. dineroTorvalds = entrada. Se usa una cantidad conocida como índice de masa corporal (IMC)para calcular el riesgo de los problemas de salud relacionados con el peso.out. float porcentajeIcaza = 0.out. // salida de resultados System. float capital = 0.nextFloat(). porcentajeGosling = dineroGosling * 100 / capital.2f porciento\n". System.out.nextFloat(). System. System.print("Miguel de Icaza $"). dineroIcaza = entrada.out. porcentajeIcaza = dineroIcaza * 100 / capital."). porcentajeTorvalds).2f porciento\n". } // fin del método main } // fin de la clase Inversion Problema 3.printf("Linus Torvalds tiene el %.out. float porcentajeGosling = 0. // determina los porcentajes de cada capital respecto del total porcentajeTorvalds = dineroTorvalds * 100 / capital.0f.out. // entrada de datos System. System. System. dineroGosling = entrada.2f\n".0f. capital). Un IMC de 20 a 25 se 33 .out.out. // calcula el el capital formado capital = dineroTorvalds + dineroIcaza + dineroGosling. El IMC se calcula como la fórmula IMC= w ( h/100)2 en donde w es el peso en kilogramos y h es la altura en centímetros.printf("Miguel de Icaza tiene el %.out.println("Introduce las tres cantidades:"). porcentajeIcaza). System.println("Capital invertido.0f.0f.nextFloat(). // el total de inversión System.println("------------------").print("James Gosling $").printf("James Gosling tiene el %. porcentajeGosling).printf("Total de capital a invertir: $%.print("Linus Torvalds $"). //Programa que calcula el índice de masa corporal.println("--------------------------------------").out.nextInt().out.in).Scanner.util. // en kilos int altura.println("Calcula el índice de masa corporal. Scanner entrada = new Scanner(System. } // fin del método main } // fin de la clase IndiceMasaCorporal Problema 4.2f\n". altura = entrada."). // proceso imc = pesoCorporal / Math.in).Scanner. // en centímetros double imc.printf("El índice de masa corporal es %. imc).out. pesoCorporal = entrada. //para leer del teclado public class IndiceMasaCorporal { public static void main(String[] args) { int pesoCorporal. Para calcular la distancia d entre los dos puntos aplicamos la siguiente fórmula: d= √ (( X 1−X 2 )2+ (Y 1 −Y 2)2 ) //Calcula la distancia entre dos puntos.0.util. System.println("Calcula la distancia entre dos puntos. System.out. //para leer del teclado public class Distancia { public static void main(String[] args) { Scanner entrada = new Scanner(System.nextInt()."). // salida System. 2). System.out. Escribe un programa que calcule la distancia entre dos puntos P1 y P2 de un plano cartesiano. System. Escribe un programa que acepte el peso y la altura (ambos en números enteros) y produzca el IMC. // entrada 34 .print("Introduce el peso(kilos) y altura(cms): ").println("-----------------------------------"). // entrada System.pow(altura / 100.out.Aprenda Java considera “normal”. import java. import java. } // fin del método main } // fin de la clase Distancia Problema 5.y1): ").1 //Programa que calcula el peso en otros planetas. 2)). Su peso es realmente la cantidad de atracción gravitacional ejercida sobre usted por la Tierra. //para leer del teclado public class PesoPlanetas { public static void main(String[] args) { // constantes final double PESO_MERCURIO = 0. Venus.5.4. final double PESO_VENUS = 0.Scanner. d).out.nextDouble(). final double PESO_SATURNO = 1. Planeta Mercurio Venus Júpiter Saturno Multiplique el peso en la Tierra por 0.pow((y1 .x2). // variables double pesoCorporal.1. 35 .nextDouble().9 2.util. double y1 = entrada. en la luna usted únicamente debería pesar 1/6 de lo que pesa en la Tierra.printf( "La distancia entre los dos puntos es %.sqrt(Math. final double PESO_JUPITER = 2.5 1. System.pow((x1 .y2): ").out.out. Júpiter y Saturno.print("Introduce el punto (x1. Use los valores de la tabla de abajo. Puesto que la gravedad es únicamente 1/6 de la gravedad que en la Tierra.print("Introduce el punto (x2. double x2 = entrada. 2) + Math.4 0.2f\n". import java.nextDouble().Aprenda Java System.9.y2). double y2 = entrada. // salida System. Escribe un programa que reciba el peso del usuario en la Tierra y calcule su peso en Mercurio. double x1 = entrada. // proceso double d = Math.nextDouble(). 2f kgs. Puesto que a otros planetas les cuesta más o menos días que a la Tierra dar una vuelta alrededor del Sol.out. Scanner entrada = new Scanner(System.println("Calcula el peso en otros planetas. pesoSaturno.2f kgs. pesoJupiter. pesoCorporal).printf("En Saturno pesas: %.2f kgs.\n". pesoMercurio). } // fin del método main } // fin de la clase PesoPlanetas Problema 6. pesoJupiter = pesoCorporal * PESO_JUPITER.\n".nextDouble(). pesoCorporal = entrada. pesoSaturno).\n". está diciendo realmente que la Tierra ha dado 18 vueltas al Sol.printf("En Venus pesas: %.").2f kgs. System. pesoVenus). System.out.print("Peso corporal (kgs)? "). // salida System. y d es el número de días de la Tierra que el planeta y viaja alrededor del Sol. System. pesoVenus.printf("En Júpiter pesas: %. pesoSaturno = pesoCorporal * PESO_SATURNO. Los valores para d en esos planetas se dan en la tabla siguiente: 36 .out.\n".2f kgs. Se puede calcular lo viejo que usted sería en otros planetas mediante la fórmula: y = (x * 365) /d. pesoVenus = pesoCorporal * PESO_VENUS.printf("En Mercurio pesas: %. Escribe una aplicación que reciba como entrada la edad del usuario en la Tierra e imprima su edad en Mercurio. y es la edad en otro planeta. Venus. Júpiter y Saturno.in). Cuando usted dice que tiene 18 años.out. System.Aprenda Java double pesoMercurio.println("----------------------------------"). donde x es la edad de la Tierra.out.printf("En la Tierra pesas: %.out. System. System. su edad sería distinta en otros planetas.\n". // entrada System. pesoJupiter). // proceso pesoMercurio = pesoCorporal * PESO_MERCURIO.out.out. Venus: %d\n".println("----------------------------------").printf("Edad } // fin del método main } // fin de la clase EdadPlanetas en en en en en la Tierra: %d\n". Scanner entrada = new Scanner(System. final int DIAS_JUPITER = 4380. Saturno: %d\n". edad = entrada. final int DIAS_VENUS = 225.printf("Edad System.printf("Edad System. final int DIAS_SATURNO = 10767.out. edadSaturno).out.out. System.out. Júpiter: %d\n". edadJupiter. edad). edadVenus = diasTerrestres / DIAS_VENUS.util.Aprenda Java Planeta Mercurio Venus Júpiter Saturno d = número aproximado de días 88 225 4380 10767 //Programa que calcula la edad en otros planetas. // entrada System. System.Scanner.printf("Edad System."). edadSaturno = diasTerrestres / DIAS_SATURNO.out. edadMercurio). edadSaturno. //leer del teclado public class EdadPlanetas { public static void main(String[] args) { // constantes final int DIAS_MERCURIO = 88. // variables int edad. // salida System. // proceso diasTerrestres = edad * DIAS_AÑO. int edadMercurio. final int DIAS_AÑO = 365.out. import java. edadVenus.printf("Edad System. edadJupiter = diasTerrestres / DIAS_JUPITER.println("Calcula la edad en otros planetas.in). diasTerrestres. edadJupiter).nextInt().out.out.print("Edad? "). edadVenus). 37 . Mercurio: %d\n". edadMercurio = diasTerrestres / DIAS_MERCURIO. minuto = entrada. //para leer del teclado public class HoraSegundos { public static void main(String[] args) { // constantes final int HORA_SEG = 3600.nextInt().Aprenda Java Problema 7. minutos y segundos a segundos. %d min(s). int nSegundos. System. %d seg(s) son %d segundos\n".print( "Introduce una hora.out. El programa siguiente.printf( "Una %d hora(s).").println("Convierte hora-min-seg a segundos. mins y segs (ejemplo 1 28 42): "). //Programa que lee una hora. segundo.out.nextInt(). minuto. // salida System.util. import java.in).java.nextInt(). // lectura System. hora = entrada.out.Scanner. hora.out. minutos y segundos y calcula //la cantidad de segundos equivalente. // proceso nSegundos = hora * HORA_SEG + minuto * MIN_SEG + segundo. // variables int hora. final int MIN_SEG = 60. nSegundos). segundo.println("----------------------------------"). System. Scanner entrada = new Scanner(System. HoraSegundos. segundo = entrada. convierte horas. minuto. } // fin del método main } // fin de la clase HoraSegundos 38 . //Obtiene la cifra central de un número de cinco cifras import java. Scanner entrada = new Scanner(System.util. numero = entrada. Escribe un programa que lea un número entero de cinco cifras y determine la cifra central del número.out."). //Programa que calcula el adeudo final de un préstamo. } // fin del método main } // fin de la clase CifraCentral Problema 9. Al final de n años.print("Número de cinco cifras?").Aprenda Java Problema 8.in). import java. //para leer del teclado public class CifraCentral { public static void main(String[] args) { Scanner entrada = new Scanner(System. tasaInteres. para calcular el importe final del adeudo.println("--------------------------------"). n y además. i (en porcentaje). digitoCentral). // salida de resultados System. //para leer del teclado public class Prestamo { public static void main(String[] args) { double cantidad. double adeudo.nextInt(). Se pide un préstamo de P pesos durante n años a una tasa de interés i. Así.00.out. el importe de la deuda es de P(i+i) n pesos. Escribe un programa para leer P. Comprueba el programa para P = 100.Scanner. // entrada System.in).out.util. // entrada 39 . si el número ingresado fuera 45781. i = 8% y n = 5.out.println("Calcula el monto de un préstamo. la cifra central a mostrar es 7.Scanner. nAños. System. int numero = 0. // determina la cifra central digitoCentral = (numero % 1000) / 100. int digitoCentral = 0. System.printf("La cifra central es %d". . nAños = entrada.10.nextDouble(). de diez.montoCompra.20. montoCompra = entrada. 40 .0. //para leer del teclado public class Monedas { public static void main(String[] args) { final int BILLETE_PESO = 100.out. temporal. Si debiéramos dar en cambio el número mínimo de monedas. 21 y 1 centavos.2. cantidad = entrada.print("Monto de la compra (menor a 1 peso)? $"). moneda5. moneda10.nextDouble(). import java. // entrada System.print("Cantidad solicitada? $").nextDouble().)% ? "). // salida System. Si solamente podemos dar en cambio monedas de un centavo. //Calcula el número mínimo de monedas que deben darse como cambio.) años? "). // proceso cambio = BILLETE_PESO ..print("Tasa de interés (5. 54. System. // proceso adeudo = cantidad * Math. cambio. } // fin del método main } // fin de la clase Prestamo Problema 10. 78. de veinte.Scanner.util.out. Si el comprador pagara siempre con un billete de a peso. moneda20.nextInt().out. int moneda50. // 100 centavos int montoCompra.Aprenda Java System. temporal = cambio. de cinco.in). Scanner entrada = new Scanner(System.. System. 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. y de cincuenta. moneda1.3.out..out. adeudo).printf("El monto final a pagar es de $%. nAños).2f". tasaInteres = entrada.print("A pagar en (1.pow(1 + tasaInteres / 100.. Verifica el programa para las siguientes compras: 97. temporal = temporal % 20. System.out. System. moneda1). moneda5 = temporal / 5.printf("%d monedas de 10 centavos\n".out.out. System. moneda20 = temporal / 20.out.Aprenda Java moneda50 = temporal / 50. System. cambio). temporal = temporal % 50.printf("%d monedas de 50 centavos\n". moneda50). // salida System.out.out. } // fin del método main } // fin de la clase Monedas 41 . System. moneda1 = temporal % 5.printf("Cambio = $%d\n". moneda5).printf("%d monedas de 20 centavos\n".printf("%d monedas de 5 centavos\n". temporal = temporal % 10. moneda10). moneda10 = temporal / 10.printf("%d monedas de 1 centavos\n". moneda20). mayor que o menor que otro valor. Al finalizar esta lección. el resultado de la comparación es verdadero (true) o falso (false). Instrucciones de selección.out. boolean tengoDinero = false. System. System.println("10 == 3 es " + (10 == 3)). TipoBoolean. Las variables booleanas se utilizan en programación para mantener el registro del estado de cierta acción. 3. Tipo de dato boolean.Aprenda Java 3. } // fin del metodo main } // fin de la clase TipoBoolean 3. // imprime el contenido de la variable System. //Declara variables de tipo boolean.out.println("10 > 3 es " + (10 > 3)). Cuando los programas utilizan operadores relacionales y de igualdad para comparar valores. tengoDinero).out.2. public class ExpresionRelacional { public static void main(String[] args) { System.println("10 != 3 es " + (10 != 3)). Veamos como escribir un programa con operadores relacionales y de igualdad. //Operadores de igualdad y relacionales. ExpresionRelacional.out. System. tengoMascota). 42 .java.printf("Tengo dinero? %b\n".out.println("10 <= 3 es " + (10 <= 3)). El programa siguiente. Los operadores relacionales y de igualdad nos permiten determinar si un valor es igual a. System.printf("Tengo mascota? %b\n". declara dos variables booleanas. System.java. El programa siguiente.println("10 < 3 es " + (10 < 3)). utiliza operadores relacionales y de igualdad. System. Operadores relacionales y de igualdad. serás capaz de: • Escribir programas que involucren instrucciones de selección.1.println("10 >= 3 es " + (10 >= 3)).out. Las variables boolean sólo pueden guardar valores true o false que son palabras clave.out.out. public class TipoBoolean { public static void main(String[] args) { // variables locales boolean tengoMascota = true. System.out. // esto es un error si lo que se quiere es comparar // boolean z = ( num1 = num2 ). edad). El programa siguiente. demuestra el uso de un if simple.out. // int num2 = 6."). System.out.out.printf("Tienes : %d años.println("La edad es un estado mental. } // fin del método main } // fin de la clase ExpresionRelacional 3.out. import java.nextInt(). se continúa con la siguiente instrucción del programa. //el ! y el = están volteados // int num1 = 5."). public class Edad { public static void main(String[] args) { final int MENOR_EDAD = 18. La instrucción if simple. //Demuestra el uso de la instrucción if simple. //hay un espacio entre > y = // boolean w = 10 =! 3. // indicador int edad = entrada. La instrucción if simple evalúa una condición utilizando una expresión relacional.in). // declara una constante Scanner entrada = new Scanner(System. // lee la edad del usuario System. //para leer del teclado.util.println( "Por lo tanto todavía no eres un adulto.java. Si la condición es verdadera se ejecuta una instrucción o un conjunto de instrucciones que estén definidas en un bloque.%n". En caso que la condición sea falsa.").print("Ingresa tu edad: ").println( // "Por lo tanto todavía no eres un adulto.").out. if (edad < MENOR_EDAD) System. } // fin del método main } // fin de la clase Edad 43 .Scanner.3.Aprenda Java // esto es un error // boolean x = 10 > = 3. Edad. // } //fin if // System.println("La edad es un estado mental. // también se puede escribir con más claridad con bloques // if (edad < MENOR_EDAD) { // System. } // fin if if (numero % 2 == 0) { System. //para leer del teclado public class NumerosIguales { public static void main(String[] args) { Scanner entrada = new Scanner(System. numero).\n". } // fin del método main } // fin de la clase NumerosIguales Podemos utilizar en un programa las instrucciones if que sean necesarias. El programa siguiente. numero).printf("%d es múltiplo de 5. if (numero % 5 == 0) { System..java.in).out.out.println("Determina si dos números son iguales.out.in).} son opcionales para el caso de los bloques que tienen una instrucción condicional.printf("%d es par. num1.Aprenda Java Las llaves del bloque {. Multiplo.out. int numero = entrada. //para leer del teclado public class Multiplo { public static void main(String[] args) { Scanner entrada = new Scanner(System. System.nextInt().java.out. import java. utiliza un if simple para determinar si dos números son iguales.printf("%d y %d son iguales. Utilizamos un if simple cuando queremos hacer una cosa o no hacer nada.Scanner.util.println("------------------------------------. El programa siguiente. num2).".nextInt().print("Ingresa un número entero: "). System.out.print("Introduce dos números enteros: "). //Determina si dos números son iguales. utiliza un if simple para determinar si un número es múltiplo de cinco y otro para determinar si ese número es par. int num1 = entrada."). //Programa que muestra la estructura de un if simple."). NumerosIguales. import java.\n". // lee un número System. } // fin if } // fin del método main 44 .out. // determina si son iguales if (num1 == num2) System.nextInt().. System.Scanner.util. int num2 = entrada. Aprenda Java } // fin de la clase Multiplo Cuando un programa en una instrucción if debe ejecutar un conjunto de instrucciones porque la evaluación de la condición fue verdadera, ese conjunto debe encerrarse entre llaves ({...}). Las instrucciones encerradas entre tales llaves conforman una instrucción compuesta. El programa siguiente, CalificacionExamen.java, ilustra lo mencionado anteriormente. //Utiliza if compuesto para evaluar una calificación. 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("Calificación (1-10)? "); // indicador int calif = entrada.nextInt(); if (calif > 8) { System.out.println("La calificación es excelente."); System.out.println("Eres un buen programador Java."); } // fin if System.out.println("El estudio es la base del triunfo."); } // fin del método main } // fin de la clase CalificacionExamen A continuación mostramos algunos errores que pueden ocurrir al utilizar una instrucción if. El programa siguiente, ErroresTipicos.java, muestra errores típicos con la instrucción if simple. //Errores típicos en una instrucción if simple. public class ErroresTipicos { public static void main(String args[]) { int x = 10000; // if( x > 5000 ); //punto y coma, instrucción if vacía // x = 1000; //la instrucción no forma parte del if // if(x > 5000 //omitir paréntesis es un error // if x > 5000 //omitir paréntesis es un error // If(x > 5000){} //escribir en mayúsculas la instrucción 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 matemáticas System.out.println(x); } // fin del método main } // fin de la clase ErroresTipicos 45 Aprenda Java 3.4. La instrucción if/else. Utilizamos una instrucción if/else cuando queremos hacer una u otra cosa dependiendo de una condición (expresión booleana). En otras palabras: ejecutar instrucciones cuando la evaluación de la condición es verdadera o falsa. Veamos como funciona una instrucción if/else. El programa siguiente, ParImpar.java, utiliza la instrucción if/else para determinar si un número es par o impar. //Instrucción 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); // operación de lectura System.out.print("Introduce un número: "); 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: también se puede utiliza las llaves { y } en if/else } // fin del método main } // fin de la clase ParImpar La instrucción if/else se denomina instrucción de selección doble, ya que selecciona una de dos acciones distintas, o grupo de acciones. El programa siguiente, una nueva versión de NumerosIguales.java, determina si dos números son iguales. //Determina si dos números 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 números son iguales."); System.out.println("------------------------------------."); System.out.print("Introduce dos números 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 método main } // fin de la clase NumerosIguales En el programa anterior utilizamos una instrucción compuesta, (así como lo hicimos con el if simple) para que el programa sea más fácil de leer. Práctiquemos con otros ejemplos que utilicen la instrucción if/else. El programa siguiente, Calificacion.java, determina si un estudiante está aprobado/reprobado en base a cuatro calificaciones. //Calcula la calificación 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 calificación final es %.2f\n", califFinal); if (califFinal >= CALIF_MIN) System.out.println("Aprobado"); else System.out.println("Reprobado"); } // fin del método main } // fin de la clase Calificacion 47 Aprenda Java El programa siguiente.random() * 10).Scanner. // si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1. //para leer del teclado public class Resta { public static void main(String[] args) { // genera los números aleatorios int numero1 = (int) (Math.java. import java. solamente que utiliza un if simple para determinar si un número es mayor que otro.out. // compara la respuesta if (numero1 + numero2 == respuesta) { System.out.println("La respuesta es incorrecta. En el programa anterior lo multiplicamos por 10 y le hacemos un casting para eliminar la parte fraccionaria y así obtener un número entre 0 y 9. } // fin if else { System.").random() * 10). //Programa para practicar sumas.out. genera dos números aleatorios y permite practicar sumas aritméticas simples. numero1. esto es.util.Scanner. //Programa para practicar restas.0). El programa siguiente. int numero2 = (int) (Math.util. int numero2 = (int) (Math. } // fin else } // fin del método main } // fin de la clase Suma El método random de la clase Math devuelve un número pseudoaleatorio comprendido en el intervalo [0.printf("Cuanto es %d + %d ? ". // genera dos números aleatorios con el método random int numero1 = (int) (Math. Suma. Resta. //para leer del teclado public class Suma { public static void main(String[] args) { Scanner entrada = new Scanner(System.random() * 10). // variable local a if 48 .nextInt().java. numero2). // muestra la pregunta al usuario System. import java. int respuesta = entrada. 1. es similar al programa anterior.println("La respuesta es correcta.in).random() * 10). para no permitir que genera una pregunta con una resta que de un resultado negativo.").0. nextInt().5. LSUP).out.out. //Programa que determina si un número se encuentra entre 100 y 200.printf( 49 . Instrucciones if anidadas. //para leer del teclado public class Limites { public static void main(String[] args) { final int LSUP = 200. import java. } // fin if // pregunta al usuario System.nextInt().out. LINF. // entrada System. else System. int numero. int respuesta = entrada. numero.out. Un programa puede evaluar varios casos colocando instrucciones if/else dentro de otras instrucciones if/else.printf("Cuanto es %d .Scanner.println("La respuesta es incorrecta.out. final int LINF = 100. numero1. } // fin del método main } // fin de la clase Resta 3."). // lee la respuesta Scanner entrada = new Scanner(System. Scanner entrada = new Scanner(System.numero2 == respuesta) System.print("Número? ").printf( "%d se encuentra entre [%d-%d]\n".in).in).%d ? ". // proceso y salida if (numero >= LINF) if (numero <= LSUP) System.util."). // compara la respuesta if (numero1 . para crear instrucciones if/else anidadas. numero = entrada. else System. numero2 = temp. numero2).Aprenda Java numero1 = numero2.println("La respuesta es correcta.out. nextInt(). PositivoNegativoNulo.Scanner.println("El número es cero. Utilizar demasiadas instrucciones if anidadas hace que los programas se vuelvan más complejos.\n". import java.println("El número es negativo.out.\n". if (numero > 0) { System.in). } // fin del método main } // fin de la clase Limites else En una instrucción if anidada. public class PositivoNegativoNulo { public static void main(String[] args) { Scanner entrada = new Scanner(System. //para leer del teclado.util.println("El número es positivo.out. } // fin else } // fin del método main } // fin de la clase PositivoNegativoNulo Observa que en programa anterior.java. utilizamos los bloques {. tendríamos que leer con cuidado el código para determinar a que instrucción if pertenece cada parte else. else System. De otra manera. //Programa que determina si un número es positivo. El programa siguiente. determina si un número es positivo.Aprenda Java "%d supera el límite superior. cada instrucción else debe concordar con la instrucción if precedente más próxima. } // fin if else { if (numero == 0) System.printf( "%d no alcanza el límite inferior.} para que el programa sea mucho más legible. utilizando instrucciones if anidadas.. System.. numero). negativo o nulo. 50 .println("Introduce un número entero: "). numero)."). Estudiemos otros ejemplos.out."). System.").out. int numero = entrada.out. negativo o nulo. } // fin if else System.out.printf( "%d es divisor de %d\n". num2. //Programa para jugar adivinanzas.out. num2. } // fin if else { if (numero < numeroSecreto) { 51 .printf("%d no es divisor de %d\n".java. num1).Aprenda Java El programa siguiente. int numero = entrada. int numeroSecreto = (int) (Math. utiliza if anidados para simular un juego de adivinanza.nextInt(). //Programa que determina si un número es divisor de otro.out. } // fin del método main } // fin de la clase Divisor El programa siguiente. Divisor. if (numero == numeroSecreto) { System. num2.out. utiliza if anidados para determinar si un número es divisor de otro. donde el usuario tiene que adivinar un número que se encuentra dentro de un rango de 0 a 9. System.java. //para leer del teclado public class Divisor { public static void main(String[] args) { Scanner entrada = new Scanner(System. //para leer del teclado public class Adivinanza { public static void main(String[] args) { Scanner entrada = new Scanner(System.print("Piensa un número entre 0 y 9: "). import java. int num1 = entrada. System.Scanner.out. num1). // ¿num2 puede ser divisor? if (num1 > num2) { if (num1 % num2 == 0) System.printf( "%d no es divisor de %d\n". else // este else se asocia al if más cercano System. import java.nextInt(). Adivinanza.out.util.in).in).Scanner.random() * 10).println("¡Adivinaste!").nextInt(). int num2 = entrada.util. num1).print("Introduce dos números: "). ").util. } // fin else } // fin else } // fin del método main } // fin de la clase Adivinanza 3. //Programa que dado un número del 1 al 7 determina el día de la semana.in). import java.out. Para facilitar la programación en estas situaciones se proporciona la instrucción if/else/if.println("El día else if (dia == 3) System.java.println("¡Caliente!").out. es: Miércoles. int dia = entrada. El programa siguiente."). es: Domingo. 52 .println("El día else if (dia == 6) System.out.println("El día else if (dia == 5) System. } // fin if else { System. es: Martes. lo que complica la realización y depuración del código. //para leer del teclado public class DiaSemana { public static void main(String[] args) { Scanner entrada = new Scanner(System.println("Número } // fin del método main } // fin de la clase DiaSemana es: Lunes. es: Jueves.").out.println("¡Frío!").Scanner.println("El día else if (dia == 4) System."). La instrucción if/else/if. // procesa dependiendo del día if (dia == 1) System.").out.println("El día else if (dia == 7) System.").out.println("El día else System.out. lee un número del 1 al 7 y determina el día de la semana utilizando esta técnica. nos vemos obligados a programar usando if anidados.Aprenda Java System.out.out.println("El día else if (dia == 2) System. es: Sábado.6. de día incorrecto. Cuando en una condición existen diversas posibilidades.").nextInt(). // solicita el día de la semana System.print("Introduce un día de la semana (1-7)? "). es: Viernes.out.out."). DiaSemana. Aprenda Java El programa para jugar a la adivinanza.21. //para leer del teclado public class Adivinanza { public static void main(String[] args) { Scanner entrada = new Scanner(System. //Calcula el aumento de sueldo de un trabajador. System. // proceso if (sueldo < 1000) sueldo *= 1.21. import java. //Programa para jugar adivinanzas. else if (numero < numeroSecreto) System. calcula el salario de un trabajador utilizando instrucciones if/else/if. int numeroSecreto = (int) (Math.25.out. int numero = entrada.random() * 10). se puede reescribir utilizando instrucciones if/else/if. else System.18.print("Sueldo trabajador? "). double sueldo = entrada. // sueldo = sueldo * 1. import java.in).java.18.util. else sueldo *= 1. // salida 53 . // sueldo = sueldo * 1.in).out.println("¡Frío!").java. // sueldo = sueldo * 1.println("¡Adivinaste!"). else if (sueldo <= 1500) sueldo *= 1.print("Piensa un número entre 0 y 9: "). Adivinanza. if (numero == numeroSecreto) System.out.println("¡Caliente!"). } // fin del método main } // fin de la clase Adivinanza Veamos otros ejemplos.out.nextDouble(). // entrada System.out. //para leer del teclado public class Sueldo { public static void main(String[] args) { Scanner entrada = new Scanner(System.util. lo que simplifica su programación y posible depuración cuando se le tengan que hacer cambios. El programa siguiente. Sueldo.Scanner.25.nextInt().Scanner. } // fin del método main } // fin de la clase ClasificarNumero 3.100]".Aprenda Java System. las instrucciones if requieren condiciones más complejas para determinar el flujo de control de un programa.java. >= y <=.7. ClasificarNumero. 54 .out. Operadores lógicos. cada expresión evalúa sólo una condición. } // fin del método main } // fin de la clase Sueldo El programa siguiente.printf("%d es menor que cero". numero).printf("%d se encuentra entre [0. En ocasiones.Scanner.nextInt().print("Número? ").2f\n".in). que nos permite formar condiciones más complejas. //Clasifica un número de acuerdo a una categoría.out.out. <.out. y los operadores de igualdad == y !=. import java. al combinar las expresiones simples. el OR condicional (||) y el NOT lógico (!). utiliza instrucciones if/else/if para clasificar un número entero.printf("El sueldo del trabajador es $%. //para leer del teclado public class ClasificarNumero { public static void main(String[] args) { Scanner entrada = new Scanner(System. else System.printf("%d es mayor que 100". System. numero).out. // indicador int numero = entrada. A continuación estudiaremos el AND condicional (&&). sueldo). numero). Java cuenta con los operadores lógicos. Para evaluar condiciones múltiples en el proceso de tomar una decisión. if (numero < 0) System. else if (numero <= 100) System.util. Las condiciones simples se expresan en términos de los operadores relacionales >. ejecutamos estas pruebas en instrucciones separadas o en instrucciones if o if/else anidadas. out.out.nextInt().println("No eres un adolescente. // esto es un error // 13 >= edad <= 18 //no funciona igual que en matemáticas } // fin del método main } // fin de la clase Adolescente 55 .Aprenda Java El programa siguiente.out.println( a && b ). int edad = entrada. //Programa que determina si una persona es un adolescente o no.print("Edad? ").println( b || false ). OR y NOT.in). //false System.java. //para leer del teclado public class Adolescente { public static void main(String[] args) { Scanner entrada = new Scanner(System.println( !a ). OR y NOT.").Scanner. determina si una persona es todavía un adolescente utilizando para ello el AND condicional. //Programa que utiliza los operadores lógicos AND.out. //Determina el valor de las variables booleanas System.println("Eres un adolescente. else System. boolean b = false.out. El programa siguiente.out.util. System.java. public class OperadoresLogicos { public static void main(String[] args) { boolean a = true. Adolescente. if (edad >= 13 && edad <= 18) System. //false System.println( a || b ). El OR condicional se utiliza cuando queremos verificar que al menos una de las condiciones sea verdadera. OperadoresLogicos. //true } //fin del método main //fin de la clase OperadoresLogicos } El AND condicional se utiliza cuando queremos verificar que dos condiciones sean verdaderas. import java. demuestra el uso de los operadores lógicos AND.println( !b ). Y el NOT se usa para negar una condición.println( a && true ).out.out.out. //false System. //true System."). //true System. nextInt().0F. nota1 = entrada. import java.java. //Programa para jugar a la lotería. //para leer del teclado public class PromedioPracticas { public static void main(String[] args) { // variables locales int nota1. Loteria.print("Introduce las 4 calificaciones: ").util. else if (nota3 < nota1 && nota3 < nota2 && suma = nota1 + nota2 + nota4.printf("El promedio es: %d\n".out. simula un juego de lotería y utiliza los operadores lógicos AND y OR para determinar si el jugador ha obtenido algún premio dependiendo de los dígitos con los que coincide el premio. nota4 = entrada. //Determina el promedio de prácticas de un estudiante. // obtiene el promedio // salida System. // entrada System.nextInt(). nota3. calcula el promedio de cuatro prácticas eliminando la menor.Scanner. int suma = 0.out. else if (nota2 < nota1 && nota2 < nota3 && suma = nota1 + nota3 + nota4.0F.nextInt(). nota4. PromedioPracticas.Scanner.util. promedio).in). } // fin del método main } // fin de la clase PromedioPracticas El programa siguiente. // proceso if (nota1 < nota2 && nota1 < nota3 && nota1 suma = nota2 + nota3 + nota4.java. < nota4) nota2 < nota4) nota3 < nota4) nota4 < nota3) promedio = suma / 3. nota2 = entrada. else if (nota4 < nota1 && nota4 < nota2 && suma = nota1 + nota2 + nota3. Scanner entrada = new Scanner(System. nota3 = entrada.Aprenda Java El programa siguiente. nota2. float promedio = 0.nextInt(). import java. //para leer del teclado public class Loteria { public static void main(String[] args) { 56 . simula un juego de apuestas y utiliza los operadores lógicos 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 método Math. System.out.00"). dado1.out.random() * 6 + 1). int digito2 = numGanador % 10.java.println("Sigue participando. System. // obtiene los dígitos del usuario int digito1 = numGanador / 10.000. int digitoLoto2 = loto % 10.print("Ingresa un número de dos dígitos: "). int dado2 = (int) (Math. int numGanador = entrada. public class Apuesta { public static void main(String[] args) { // simula tres tiros de un dado int dado1 = (int) (Math. // determina la ganancia int ganancia = 0. int dado3 = (int) (Math. Apuesta.").000. 57 .random() * 6 + 1). System.random() * 100).random() * 6 + 1).00").00").out.printf("El número de la lotería es: %d\n". dado2.printf("Dados: %d. else if (digito1 == digitoLoto1 || digito1 == digitoLoto2 || digito2 == digitoLoto1 || digito2 == digitoLoto2) System. } // fin del método main } // fin de la clase Loteria El programa siguiente. // obtiene los dígitos de la lotería int digitoLoto1 = loto / 10. //Determina las ganancias al tratar de adivinar los tiros de un dado. %d.out. else System.Aprenda Java // genera el número de la loteria int loto = (int) (Math. dado3). %d\n".println("Ganaste $1.println("Ganaste $10.nextInt(). loto). else if (digito2 == digitoLoto1 && digito1 == digitoLoto2) System.random. // Revisa por los premios if (loto == numGanador) System.in).println("Ganaste $3.out. Scanner entrada = new Scanner(System.out.000.out. una condición que se evalúa a un valor booleano true o false).print("Introduce dos números: "). import java. System.out. El operador condicional (?:).java. y el tercer operando (a la derecha de :) es el valor de la expresión condicional si la expresión booleana se evalúa como falsa. // equivalente a // if( num1 > num2 ) // System. else System. int num1 = entrada. else if (dado1 == dado2 || dado1 == dado3 || dado2 == dado3) ganancia = 5. int num2 = entrada.println("El mayor es " + max). //para leer del teclado public class Mayor { public static void main(String[] args) { Scanner entrada = new Scanner(System. que utiliza tres operandos.8. } // fin del método main } // fin de la clase Apuesta 3. } // fin del método main } // fin de la clase Mayor 58 .in). Mayor. //Programa que determina el mayor de dos números. utiliza el operador condicional para determinar si un número es mayor que otro. int max = (num1 > num2) ? num1 : num2.nextInt().println( "El mayor es " + num1 ). El programa siguiente.nextInt().Aprenda Java if (dado1 == 6 && dado2 == 6 && dado3 == 6) ganancia = 20.println( "El mayor es " + num2 ). que en ocasiones puede utilizarse en lugar de una instrucción if/else. Éste es el único operador ternario en Java. El primer operando (a la izquierda del ?) es una expresión booleana (es decir. System.Scanner.println("Tu ganancia es de $" + ganancia).out. es decir. // else // System.println("Sigue participando"). else if (dado1 == dado2 && dado1 == dado3 && dado2 == dado3) ganancia = 10. el segundo operando (entre el ? y :) es el valor de la expresión condicional si la expresión booleana es verdadera.out. los operandos y el símbolo ?: forman una expresión condicional. En conjunto.out.out. System. Java cuenta con el operador condicional (?:).util.out. print("Código del fabricante (1-4)? ").nextInt().println("Maxwell Corporation").out. 59 .out.Aprenda Java El programa siguiente. case 2: System. public class FabricanteDVD { public static void main(String[] args) { Scanner entrada = new Scanner(System. utiliza la instrucción switch para determinar la categoría de un determinado fabricante.out.util. //Programa que lee un código y determina el fabricante.out.out.println("Verbatim Corporation"). El programa siguiente. int num = entrada. FabricanteDVD.out.out. // proceso y salida switch (codigo) { case 1: System. case 4: System.println((num % 2 == 0) ? "Es par.in).java.")." : "Es impar. } // fin del método main } // fin de la clase ParImpar 3.Scanner. break. break. La instrucción switch es otra manera de implementar muchas instrucciones if.print("Introduce un número: ").in). import java.println("3M Corporation").util.println("Sony Corporation").java. System. //Programa que determina si un número es par o impar.Scanner. La instrucción switch. System.9. //para leer del teclado public class ParImpar { public static void main(String[] args) { Scanner entrada = new Scanner(System. break. // entrada System. utiliza el operador condicional para determinar si un número es par/impar. import java.nextInt(). break. int codigo = entrada. case 3: System. ParImpar. //Calcula el aumento de sueldo de un trabajador. case 3: nuevoSueldo = sueldo * 1.out. AumentoSueldo. Estudiemos otros ejemplos.println("Categoría inválida").0F. La palabra break significa ir al final de la instrucción switch.java. calcula el aumento de un trabajador utilizando una instrucción switch (aunque es factible utilizar una instrucción if/else/if). } // fin switch } // fin del método main } // fin de la clase FabricanteDVD A la instrucción switch se le llama instrucción de selección múltiple. int categoria = entrada.nextInt().10F. //para leer del teclado public class AumentoSueldo { public static void main(String[] args) { Scanner entrada = new Scanner(System.out.Aprenda Java default: System. break. case 2: nuevoSueldo = sueldo * 1.08F. // entrada System. ya que selecciona una de varias acciones distintas o grupo de acciones. El programa siguiente. break. import java. case 4: nuevoSueldo = sueldo * 1. } // fin switch // salida 60 .println("Código incorrecto").in). break.Scanner. break.util. // proceso float nuevoSueldo = 0. default: System. switch (categoria) { case 1: nuevoSueldo = sueldo * 1.nextFloat(). float sueldo = entrada.07F.out.print("Categoría y sueldo del trabajador: ").15F. switch (jugador) { case PIEDRA: System.Scanner.out.printf("El nuevo sueldo es $%.random() * 3 + 1).println("PIEDRA").out.println("TIJERA").print("La jugada de la computadora: "). break.print("La jugada del usuario: "). import java. Scanner entrada = new Scanner(System. En este programa se utilizan todos los conceptos estudiados hasta el momento. // muestra la jugada del usuario System. nuevoSueldo). case TIJERA: System. PAPEL = 2. PiedraPapelTijera.in).Aprenda Java System. } // fin switch // muestra la jugada de la computadora System. case PAPEL: System. 3 = Tijera"). break.nextInt(). break. break. TIJERA = 3.out.print( "Tu jugada? 1 = Piedra.out.util. int jugador. //Programa para jugar al piedra-papel-tijera. 2 = Papel. // genera la jugada de la computadora computadora = (int) (Math. jugador = entrada. public class PiedraPapelTijera { public static void main(String[] args) { final int PIEDRA = 1. implementa el juego: piedra-papel-tijera.println("PIEDRA"). case TIJERA: 61 .out. // solicita la jugada del usuario System. switch (computadora) { case PIEDRA: System.out.out. } // fin del método main } // fin de la clase AumentoSueldo El programa siguiente. computadora. break.out.2f\n".println("PAPEL"). case PAPEL: System.println("PAPEL").java.out. out. } // fin del método main } // fin de la clase PiedraPapelTijera 3.println("¡El jugador gana!")."). Problema 1.out.out.").out.println("La computadora gana. A continuación vamos a resolver una serie de ejercicios que nos permitirán afianzar los conceptos de programación hasta ahora estudiados. else if (jugador == PIEDRA && computadora == TIJERA) System. Ejercicios resueltos.00 62 .50 $15.out.println("Empate.println("¡El jugador gana!").out. else if (jugador == PIEDRA && computadora == PAPEL) System.println("La computadora gana.out. $17.").println("Empate"). En la lección anterior escribimos programas con instrucciones que se ejecutaban en un orden secuencial. else if (jugador == PAPEL && computadora == TIJERA) System. else if (jugador == TIJERA && computadora == TIJERA) System.println("TIJERA").Aprenda Java System. } // fin switch // determina el ganador if (jugador == PIEDRA && computadora == PIEDRA) System.println("La computadora gana.out. 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."). else if (jugador == TIJERA && computadora == PAPEL) System.out.out. if (jugador == PAPEL && computadora == PIEDRA) System. else if (jugador == PAPEL && computadora == PAPEL) System. break. if (jugador == TIJERA && computadora == PIEDRA) System. Nota: los problemas que se resuelven aquí no tienen una solución única.10.").println("Empate.println("¡El jugador gana!"). //Determina lo que hay que pagar por una compra de paletas.out.Scanner.println("Venta de paletas de dulce. Scanner entrada = new Scanner(System. // entrada System. en caso contrario. Escribe un programa que determine el importe de la compra. 63 . System.importeDescuento.in). numPaletas = entrada.println("--------------------------")."). el importe del descuento y el importe a pagar por la compra de cierta cantidad de paletas de dulce. System. double importeDescuento = 0. // calcula el importe a pagar importePagar = importeCompra . // cálculo del importe del descuento if (numPaletas > 50) importeDescuento = 0. double importePagar = 0. if (numPaletas <= 50) importeDescuento = 0. sólo le descuenta el 5%.out.50 $10.0.0. //para leer del teclado public class VentaPaletas { public static void main(String[] args) { // variables locales int numPaletas = 0.50.0. double importeCompra = 0. if (numPaletas >= 26 && numPaletas <= 50) importeCompra = numPaletas * 15.Aprenda Java 51 a 75 76 en adelante $12.util. import java.00 Adicionalmente. // cálculo del importe de la compra if (numPaletas >= 1 && numPaletas <= 25) importeCompra = numPaletas * 17.0. si el cliente adquiere más de 50 paletas la tienda de abarrotes le descuenta el 15% del importe de la compra.0.50.out.15 * importeCompra. if (numPaletas >= 51 && numPaletas <= 75) importeCompra = numPaletas * 12.05 * importeCompra.print("Número de paletas a comprar? ").nextInt(). if (numPaletas >= 76) importeCompra = numPaletas * 10. out.print("Introduce las 3 calificaciones (1-10)? "). double nota3 = 0. //Calcula el promedio de tres notas de laboratorio. System.printf("Importe de compra: $%. } // fin del método main } // fin de la clase VentaPaletas Problema 2.2f\n". System. System.out. // entrada System.out. numPaletas).out.0.0.in).println("------------------------------"). el profesor de Java ha establecido incrementar en dos puntos la nota de la tercera práctica calificada. siempre y cuando sea menor que 10. //para leer del teclado public class PromedioFinal { public static void main(String[] args) { Scanner entrada = new Scanner(System.printf("Total a pagar: $%. Considera que las calificaciones están en un rango de 1 a 10. System.out.0. // determina si se aumentan dos puntos if (nota3 < 10) { nota3 += 2. nota1 = entrada.util. // declara e inicializa las variables double nota1 = 0.println("Promedio final del curso Java. nota2 = entrada. import java. } // fin if 64 .Scanner.nextDouble(). Diseña y codifica un programa que determine el promedio final de un alumno conociendo sus tres notas.out. if (nota3 > 10) // la calif máxima es 10 nota3 = 10.2f\n".printf("\nPaletas compradas: %d\n". importePagar). importeDescuento). double nota2 = 0.nextDouble().2f\n"."). El promedio final del curso de programación Java se obtiene en base al promedio simple de tres prácticas de laboratorio calificadas.printf("Descuento: $%. double promedio = 0. nota3 = entrada.out. System.Aprenda Java // salida de resultados System.0. Para ayudar a los alumnos. importeCompra).nextDouble(). Scanner entrada = new Scanner(System. import java.nextInt(). //para leer del teclado public class RestaMenor { public static void main(String[] args) { int numeroUno.out.0. Así por ejemplo si los números son 6 y 9 la salida será 3. // entrada System. // salida System.out. pero si es 8 y 3. la salida debe ser 5. promedio). // salida de resultados System. else System. int numeroDos. numeroUno = entrada.nextInt().2f\n".numeroUno.util. Escribe un programa de manera que la salida sea el resultado de restar el número mayor del menor.out.println("La calificación no es aprobatoria").Aprenda Java // determina el promedio promedio = (nota1 + nota2 + nota3) / 3.printf("El promedio final es de %. //Programa que resta el número menor del mayor. } // fin del método main } // fin de la clase RestaMenor 65 . resta).numeroDos. } // fin del método main } // fin de la clase PromedioFinal Problema 3.print("Introduce dos números enteros: ").out. // proceso if (numeroUno > numeroDos) resta = numeroUno . numeroDos = entrada.println("La calificación es aprobatoria").out. else resta = numeroDos . // determina si esta aprobado/reprobado if (promedio > 6) System.in). int resta.printf("La resta es %d".Scanner. final int HORAS_EXTRA = 60.out. //para leer del teclado public class SalarioProgramador { public static void main(String[] args) { final int HORAS_BASE = 40.out. 66 . Si trabaja más de 40 horas se le pagan $40 dolares las primeras 40 horas. Así. int nHoras. sueldoTotal. nHoras = entrada. //Programa que lee un entero de tres cifras y determina si son consecutivas. y $60 po cada hora adicional. Un programador Java recibe $40 dolares por hora si trabaja semanalmente 40 horas o menos.Scanner. } // fin del método main } // fin de la clase SalarioProgramador Problema 5.in).print("Horas trabajadas? "). final int SALARIO_SEMANA = 1600. el programa debe imprimir el mensaje: "El número debe ser un entero positivo de tres cifras". import java.HORAS_BASE) * HORAS_EXTRA. un programador que trabaja 40 horas recibe $1600. else sueldoTotal = SALARIO_SEMANA + (nHoras . Escribe un programa que lea el número de horas trabajadas por un programador e imprima el salario a devengar.printf("El salario del trabajador es $%. que da un total de $1720. En caso que el número no sea un número positivo de tres cifras. Escribe un programa que lea un número entero positivo tres cifras y determine si las cifras del número son o no consecutivas (en orden ascendente o en orden descendente). // proceso if (nHoras <= HORAS_BASE) sueldoTotal = nHoras * HORAS_BASE. mientras que el que trabaja 42 horas recibe 1600 + ( 42 – 40 ) * 60. Scanner entrada = new Scanner(System. // entrada System.util. // salida System. //Calcula el salario de un programador.2f".nextInt().Aprenda Java Problema 4. sueldoTotal). Escribe un programa que lea un número entero positivo de tres cifras y que con forme el número mayor posible con esas cifras.printf( "Las cifras de %d no son consecutivas\n".out.Aprenda Java import java. 67 . } // fin del método main } // fin de la clase CifrasConsecutivas Problema 6.util. // lectura System.Scanner. b. numero). numero). int decena = (numero % 100) / 10.nextInt().printf( "%d debe ser un número positivo de tres cifras\n".1)) System.in).printf( "Las cifras de %d son consecutivas\n". Scanner entrada = new Scanner(System. // determina si las cifras son consecutivas if ((decena == centena + 1 && unidad == decena + 1) || (decena == centena . // verifica el rango if (numero >= 100 && numero <= 999) { // determina las cifras del número int centena = numero / 100. //Lee un número de tres cifras y obtiene el número mayor que //se pueden obtener con esas tres cifras.in). public class TresCifras { public static void main(String[] args) { int a.print("Número entero positivo de tres cifras? "). c. numero). int numero = entrada. int unidad = numero % 10. import java. else System. } // fin if else System.Scanner.out.out.util. //para leer del teclado.out. //para leer del teclado public class CifrasConsecutivas { public static void main(String[] args) { Scanner entrada = new Scanner(System.1 && unidad == decena . que dado como dato una temperatura en grados fahrenheit.nextInt(). import java. c = numero % 10.out.println(b + "" + a + "" + else System. c). Problema 7. b). "" + b). a).print("Número 3 cifras? "). int numero = entrada.out. } // fin del método main } // fin de la clase TresCifras "" + c).out.println(a + "" + b + else System.println(c + "" + b + "" + a). teniendo en cuenta la siguiente tabla: Deporte Temperatura Natación Tenis Golf Esquí Marcha > 85 70 < TEMP ≤ 85 32 < TEMP ≤ 70 10 < TEMP ≤ 32 ≤ 10 //Dada una temperatura recomienda el deporte a practicar.println(b + "" + c + "" + else System. Escribe un programa.out. numero = numero % 100.println(c + "" + a + "" + else if (b > c) if (c > a) System. // proceso y salida a = numero / 100. //para leer del teclado public class Deporte { 68 . b = numero / 10.out.Aprenda Java // lectura System. determine el deporte que es apropiado practicar a esa temperatura.out. if (a > b) if (a > c) if (b > c) System.out.println(a + "" + c + else System.util.Scanner. Media (70-79). calif1 = entrada.util.out.out.Aprenda Java public static void main(String[] args) { Scanner entrada = new Scanner(System. calif4. Cuatro números enteros entre 0 y 100 representan las puntuaciones de un estudiante de un curso de programación con Java.println("Practica else if (temp > 70) System.println("Practica } // fin del método main } // fin de la clase Deporte natación").nextInt(). calif3. Scanner entrada = new Scanner(System.nextFloat().println("Practica else if (temp > 10) System. esquí"). float promedio. // entrada System. calif2.print("Introduce las 4 califs (0-100)? ").out.in). Media (80-89).println("Practica else if (temp > 32) System. Media (60-69). Problema 8. // entrada System.out. la puntuación es una letra A. la puntuación es una letra B. golf"). la marcha").out. int temp = entrada. Media (0-59).println("Practica else System. //para leer del teclado public class PromedioAsignatura { public static void main(String[] args) { // variables float calif1. //Calcula el promedio de cuatro calificaciones import java.print("Temperatura en fahrenheit? "). la puntuación es una letra F. la puntuación es una letra C. Escribe un programa para encontrar la media de estas puntuaciones y visualizar una tabla de notas de acuerdo a lo siguiente: • • • • • Media (90-10).out.in). // proceso y salida if (temp > 85) System. tenis").Scanner.out. 69 . la puntuación es una letra D. import java.out. case 3: System.nextFloat(). una B.out. case 2: System. break.println("Tienes else if (promedio >= 80) System.println("Tienes } // fin del método main } // fin de la clase PromedioAsignatura una A. System.println("CERO").out.util. tres.in). if (promedio >= 90) System.out.Aprenda Java calif2 = entrada.0f. uno.").Scanner. una F."). //Determina una nota numérica entre 0 y 10. y mostrar dicha nota de la forma: cero.println("Tienes else if (promedio >= 70) System."). una D."). // proceso y salida promedio = (calif1 + calif2 + calif3 + calif4) / 4. 70 . Problema 9. calif4 = entrada. int numero = entrada.out.out. Escribe un programa que solicitar una nota numérica entera entre 0 y 10. break.nextFloat().println("TRES").out. break.println("Tienes else if (promedio >= 60) System.nextInt().out. una C. switch (numero) { case 0: System."). etc. dos.print("Introduce una nota numérica entre 0 y 10: ").nextFloat(). case 1: System.out.out.println("UNO"). calif3 = entrada.println("Tienes else System. //para leer del teclado public class NotaNumerica { public static void main(String[] args) { Scanner entrada = new Scanner(System.println("DOS"). case 4: System. case 6: System. break. break. boolean defectuoso1.out.println("SEIS").out. case 8: System.out. boolean defectuoso3. //Determina si un número de serie es defectuoso o no. System. import java.println("Número de serie es defectuoso").out. case 7: System. Una cierta compañía fabricante de repuestos de automóviles ha descubierto defectos en algunos de sus productos. break. break.println("-----------------------------"). break.out.Scanner.out. 70001 a 79999 y 88888 a 111111.println("CINCO"). break. case 5: System.out. } // fin switch } // fin del método main } // fin de la clase NotaNumerica Problema 10.Aprenda Java break. boolean defectuoso2. case 9: System. public class Repuestos { public static void main(String[] args) { int numeroSerie. La compañia se lo ha comunicado a la división de relaciones con los consumidores y desea un programa que permita leer el número de serie y deducir si es o no defectuoso.println("OCHO").util.println("SIETE").out.println("CUATRO"). 71 .in).println("NUEVE"). específicamente aquellos cuyos números de serie se encuentran dentro de los rangos: 14681 a 15681. // Prepara el teclado para la lectura de los datos Scanner entrada = new Scanner(System. System. Aprenda Java System.out. defectuoso1 = (14681 <= numeroSerie && numeroSerie <= 15681).out.printf("El número de serie %d es correcto.printf( "El número de serie %d es defectuoso.print("Numero serie? ").\n". else System.\n". } // fin del método main } // fin de la clase NumeroSerie 72 .out. numeroSerie). if (defectuoso1 || defectuoso2 || defectuoso3) System. defectuoso3 = (88888 <= numeroSerie && numeroSerie <= 111111). numeroSerie).nextInt(). defectuoso2 = (70001 <= numeroSerie && numeroSerie <= 79999). // indicador numeroSerie = entrada. //Programa que muestra la sintaxis para la instrucción while.java. // declara e inicializa // la variable de control while (contador <= 10) // condición de continuación de ciclo { System.java demuestra el uso de un ciclo while. La instrucción de repetición while permite que los programas repitan instrucciones mientras que una condición sea verdadera. Una instrucción de repetición (también llamada instrucción de ciclo.1.println(contador). Instrucción de repetición while. Si la condición es verdadera. o bucles) nos permite especificar que un programa debe repetir una acción mientras que cierta condición sea verdadera. Si es falsa termina. //Programa que muestra la sintaxis para la instrucción while. Instrucciones de repetición. En un ciclo while la condición se evalúa antes de cualquier repetición del ciclo. serás capaz de: • Escribir programas que utilicen instrucciones de repetición. // incrementa la variable de control en 1 } // fin de while } // fin del método 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 número de veces que debe ejecutarse un conjunto de instrucciones. el ciclo continúa. // declara e inicializa // la variable de control while (contador > 0) // condición de continuación de ciclo 73 . public class ContadorWhile { public static void main(String[] args) { int contador = 1.Aprenda Java 4. public class CicloWhile { public static void main(String[] args) { int contador = 10. El programa siguiente. Al finalizar esta lección. 4. El programa siguiente. contador++. ContadorWhile. A las instrucciones a repetir se conocen como el cuerpo del ciclo y al hecho de repetir la secuencia de instrucciones se denomina iteración.out. utiliza un ciclo controlado por contador. ciclo. CicloWhile. random() * 101). //para leer del teclado public class SumaWhile { public static void main(String[] args) { int i = 1.out. } // fin while // salida System. n = entrada. El programa siguiente.out. // i = i + 1. es una versión mejorada del programa. // acumulador int n. Adivinanza. i++.java.print("Cantidad de números a sumar? ").java.Scanner. } // fin del método main } // fin de la clase SumaNaturales El programa siguiente.Scanner. // suma = suma + i.printf("La suma es %d\n".out. // entrada System. suma). 74 . Esta versión permite seguir jugando hasta que el usuario adivine el número.Aprenda Java { System.util.in). // variable de control int suma = 0. SumaWhile. import java. contador--. // proceso while (i <= n) { suma += i.nextInt().util. // decrementa la variable de control en 1 } // fin de while } // fin del método main } // fin de la clase CicloWhile El ciclo while se utiliza generalmente cuando el número de repeticiones no se conoce con anticipación. // representa los n primeros número naturales Scanner entrada = new Scanner(System. //El programa suma los N primeros números naturales. import java.println(contador). que escribimos en la lección anterior. //para leer del teclado public class Adivinanza { public static void main(String[] args) { // genera el número aleatorio entre 0 y 100 int numeroSecreto = (int) (Math. //Programa para jugar adivinanzas. utiliza un ciclo while para sumar los primeros n números naturales. 75 . else if (numero < numeroSecreto) System. int numero = -1.util.out.print("Número? "). int numero2 = (int) (Math.out.println("¡Frío!"). } // fin while } // fin del método main } // fin de la clase Adivinanza El programa siguiente.random() * 10).in). // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.println("Piensa un número entre 0 y 100.out. //para leer del teclado public class Suma { public static void main(String[] args) { final int NUMERO_PREGUNTAS = 5.printf("¿Cuánto es %d + %d ? ".println("-------------------------------").out.out.random() * 10).java. while (numero != numeroSecreto) { // solicita un número al usuario System.in). System. // muestra la pregunta al usuario System. // contador de preguntas String reporte = "". es una versión mejorada del programa. else System."). // contador de preguntas correctas int contador = 0.println("¡Adivinaste!").Aprenda Java Scanner entrada = new Scanner(System.nextInt(). numero = entrada.out.Scanner. import java.println("¡Caliente!"). que escribimos en la lección anterior y que nos permite practicar sumas sencillas un determinado número de veces. while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math.out. // número máximo de preguntas int aciertos = 0. // evalúa if (numero == numeroSecreto) System. // mensaje de usuario System. Suma. //Programa para practicar sumas. 2. } // fin if else { System.util.in). import java. // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " + " + numero2 + " = " + respuesta + ((numero1 + numero2 == respuesta) : " incorrecto"). ? " correcto" // imprime los resultados obtenidos System. SumaCentinela. incorrecta.out. } // fin while correcta. } // fin else contador++. numero2.out.println("La respuesta es aciertos++. Scanner entrada = new Scanner(System.java. //para leer del teclado public class SumaCentinela { public static void main(String[] args) { int numero = 0. Un valor centinela (también llamada valor de señal. (numero1 + numero2)). aciertos.println("La respuesta es System. numero1. valor de prueba o valor de bandera) indica el fin de la introducción de datos en un ciclo."). El programa siguiente. int suma = 0. 76 .out.printf("%d + %d = %d\n".nextInt()."). int respuesta = entrada. utiliza un ciclo while controlado por centinela para sumar una determinada cantidad de números enteros. Ciclos controlados por un valor centinela.Scanner. // compara la respuesta if (numero1 + numero2 == respuesta) { System.printf("\nRespuestas correctas: %d\n%s". } // fin del método main } // fin de la clase Suma 4.Aprenda Java numero1. reporte). //Programa para sumar números utilizando ciclo while/centinela.out. numero2). else { double promedio = (double) suma / contador.nextInt(). promedio).println( "Teclea la lista de núms: (ejemplo 4.out. System. -3)"). numero = entrada. 4.nextInt().out.nextInt(). // lectura } // fin while System. // suma = suma + numero.out.%n".printf("%d números leídos. System.out.println( "Ingresa una lista de números enteros positivos.printf("La suma es %d". // contador = contador + 1. numero = entrada.println( "Marca el final de la lista con un núm negativo. // lee el siguiente número System. } // fin else 77 . utiliza un ciclo while controlado por centinela para calcular la suma y promedio de una serie de números.out.out. System."). // mensaje de usuario System.util.print("Número a sumar (0 para terminar)? "). contador).in). } // fin del método main } // fin de la clase SumaCentinela El programa siguiente.print("Número a sumar (0 para terminar)? ").printf("El promedio es %. Promedio. numero = entrada. // lectura while (numero >= 0) { suma += numero. int suma = 0.out. 5.out. import java. numero = entrada.").java."). //para leer del teclado public class Promedio { public static void main(String[] args) { int numero = 0.Scanner.Aprenda Java System. // lectura } // fin while if (contador == 0) System.out. suma). 6. contador++.2f ".println("No ingresaste ningún número. // suma = suma + numero. Scanner entrada = new Scanner(System. System.nextInt(). // lectura while (numero != 0) { suma += numero. int contador = 0. //Lee una serie de números enteros y calcula su promedio. 78 . // la variable de control i no cambia } // fin while int contador = 1. //Demuestra los ciclos infinitos. ErrorNumerico. Recuerda que los valores en punto flotante son valores aproximados y por lo tanto pueden producir resultados imprecisos.0. y por tanto detenerse. } // fin del método main } // fin de la clase CicloInfinito No debemos utilizar valores en punto flotante como variables de control en un ciclo.println("JavaJavaDo"). El programa siguiente. El programa siguiente. public class ErrorNumerico { public static void main(String[] args) { double item = 1.out.java. CicloInfinito. Un ciclo infinito es aquel que no logra que su condición pueda concluir. i = 0. //Ciclos con números en punto flotante. demuestra los ciclos infinitos. Al estar trabajando con ciclos es posible que más de alguna vez provoquemos un ciclo infinito.Aprenda Java } // fin del método main } // fin de la clase Promedio 4. // este es un ciclo infinito while (i < 10) { suma = suma + i. demuestra como se produce un ciclo infinito con valores en punto flotante. // otro ciclo infinito while (contador != 50) contador = contador + 2. // la condición no se cumple // otro ciclo infinito while (true) System. Ciclos infinitos.3. while (item != 0) { // No se garantiza que item tome el valor 0 suma += item. public class CicloInfinito { public static void main(String[] args) { int suma = 0.java. double suma = 0. random() * 20) + 1. System.java. Instrucción de repetición do/while. Cuando termina una instrucción do/while.. ContadorDoWhile. el cuerpo siempre se ejecuta por lo menos una vez.out. EncuentraUnTres. // incrementa la variable de control } while (contador <= 10)."). por lo tanto.item vale " + item). he encontrado un 3. contador++.println(suma).Aprenda Java item -= 0. contador).4. utiliza la instrucción de repetición do/while para generar un número aleatorio hasta que el número sea un tres. //Ilustra el uso de la instrucción do/while.println(numero). la ejecución continúa con la siguiente instrucción en la secuencia.. //La instrucción de repetición do/while.out.out. El programa siguiente.out.printf("%d ". } while (numero != 3). System. do { numero = (int) (Math. El programa siguiente. } // fin while System. System.println("Procesando. La instrucción de repetición do/while primero ejecuta el conjunto de instrucciones y después evalúa la condición de continuación del ciclo. // condición de continuación } // fin del método main } // fin de la clase ContadorDoWhile do { Utilizamos el ciclo do/while cuando necesitamos por lo menos una repetición del ciclo.1. public class ContadorDoWhile { public static void main(String[] args) { int contador = 1. } // fin del método main } // fin de la clase ErrorNumerico 4.out. public class EncuentraUnTres { public static void main(String[] args) { int numero.println( "El programa ha terminado.java. utiliza la instrucción de repetición do/while. // inicializa contador System. 79 . suma). //Muestra la estructura básica de la instrucción for.in).util. La instrucción while puede utilizarse para implementar cualquier ciclo controlado por un contador.out. El programa siguiente.println("JavaJavaDo"). do { // lee el siguiente número System. Scanner entrada = new Scanner(System. utiliza la instrucción de repetición do/while . //para leer del teclado public class SumaCentinela2 { public static void main(String[] args) { int numero = 0. Instrucción de repetición for. // lectura suma += numero.Scanner. para sumar una serie de números enteros. } while (numero != 0). // fin do/while System. //Programa para sumar números utilizando ciclo do/while/centinela. } // fin del método main } // fin de la clase CicloFor 80 . ilustra la sintaxis básica para el ciclo for. i < 100.java. } // fin del método main } // fin de la clase SumaCentinela2 4.java. import java.printf("La suma es %d". // suma = suma + numero.print("Número a sumar (0 para terminar)? "). CicloFor. i++) System.out. que especifica los detalles de la repetición controlada por contador en una sola linea de código. int suma = 0. numero = entrada. Java. public class CicloFor { public static void main(String[] args) { for (int i = 0. también cuenta con la instrucción for.5.Aprenda Java } // fin del método main } // fin de la clase EncuentraUnTres El programa siguiente.nextInt().out. SumaCentinela. contador > 0. i++ ). System. import java. mult). public class ParImpar { public static void main(String[] args) { final int LIM_INF = 1.out. 81 . //para leer del teclado public class TablaMultiplicar { public static void main(String[] args) { int nTabla. Scanner entrada = new Scanner(System. for (int i = 1. contador--) System.in). i <= 10. i < 10.java. } // fin for } // fin del método main } // fin de la clase TablaMultiplicar El programa siguiente. // esto es un error // for( int i = 1.print("Tabla de multiplicar? ").Aprenda Java En el ciclo for.printf("%d x %d = %d\n". TablaMultiplicar. i. //Calcula la suma de los números pares e impares.println(contador).println( i ). //Repetición controlada con contador. } // fin del método main } // fin de la clase ContadorFor El programa siguiente.out. i++) { mult = nTabla * i. nTabla. System.out.nextInt(). public class ContadorFor { public static void main(String[] args) { // el encabezado de la instrucción for incluye // la iniacialización. ParImpar. nTabla = entrada. tenemos una variable de control (o contador del ciclo). //El programa obtiene la tabla de múltiplicar de un número entero K.Scanner.out. calcula la suma de números pares e impares. ContadorFor. utiliza la instrucción de repetición for. mult. la condición de continuación // del ciclo y el incremento/decremento for (int contador = 10.util.java. //genera un for vacío // System. El programa siguiente. un valor inicial.java. el incremento o decremento de la variable de control y la condición de continuación del ciclo. utiliza la instrucción de repetición for para imprimir una tabla de multiplicación. Un ciclo anidado es un ciclo dentro de otro y los podemos combinar ( while. j). TablasMultiplicar. public class ParejaValores { public static void main(String[] args) { for (int i = 1. public class TablasMultiplicar { public static void main(String[] args) { for (int i = 1. j++) System.for) dependiendo de las necesidades de programación.out. System. } // fin del método main } // fin de la clase ParImpar 4. Ciclos anidados.printf("%d x %d = %d\n". do/while.6. El programa siguiente.java. //Imprime las tablas de multiplicar del 1 al 9.java. i. sumaImpar). utiliza dos ciclos for anidados para imprimir una pareja de valores. i <= LIM_SUP. i. j <= 10. i++) { for (int j = 1. int sumaImpar = 0. i++) for (int j = 1. i++) { if (i % 2 == 0) // ¿es par? sumaPar += i. i <= 3. int sumaPar = 0.out. // proceso for (int i = LIM_INF.printf("Suma pares: %d y Suma impares: %d\n". utiliza dos ciclos for anidados para imprimir las tablas de múltiplicar del 1 al 10. j <= 2.printf("%d\t%d\n". j. else sumaImpar += i. i <= 9. ParejaValores. // sumaPar = sumaPar + i. sumaPar. 82 . j++) System.Aprenda Java final int LIM_SUP = 200. (i * j)).println(). } // fin for } // fin del método main } // fin de la clase TablasMultiplicar El programa siguiente.out. } // fin for // salida System. //Imprime una pareja de valores. // sumaImpar = sumaImpar + i.out. java. ya que los divisores de 6 son 1. i < numero. El programa siguiente. Un número perfecto es un entero positivo. 2.java.out. ForBreak. i++ ) { if( numero % i == 0 ) suma += i. //inicializa el valor de suma } //fin while } //fin del método main } //fin de la clase NumerosPerfectos 4. El primer número perfecto es 6. La ejecución continúa con la primera instrucción después de la instrucción de control. public class NumerosPerfectos { public static void main( String[] args ) { int contador = 0. NumerosPerfectos. //incrementa el contador de números perfectos } //fin if numero++. Además de las instrucciones de selección y repetición. que es igual a la suma de todos los enteros positivos (excluido el mismo) que son divisores del número. Instrucción break y continue. demuestra el uso de una instrucción break para salir de un ciclo for. Anteriormente utilizamos la instrucción break para terminar la ejecución de una instrucción switch. o para omitir el resto de una instrucción switch. numero ). encuentra los tres primeros números perfectos. Cuando break se ejecuta en una instrucción while. while( contador < MAX ) { for( int i = 1. //incrementa el número a buscar suma = 0.printf("%d es un número perfecto\n". int numero = 3. //iniciamos la búsqueda a partir del 3 final int MAX = 3. //El programa encuentra los tres primeros números perfectos.7. Los usos comunes de break son para escapar anticipadamente del ciclo. 3 y 1 + 2 +3 = 6. int suma = 0. contador++. for o switch. 83 . do/while. Java cuenta con las instrucciones break y continue para alterar el flujo de control de un programa. ocasiona la salida inmediata de esa instrucción.Aprenda Java } // fin del método main } // fin de la clase ParejaValores El programa siguiente. } //fin for if( suma == numero ) { System. Aprenda Java //La instrucción break para salir de un ciclo for. cuenta <= 10.println(cuenta).out. cuenta++) // itera 10 veces { if (cuenta == 5) // si cuenta es 5 break. // termina el ciclo System.java. do/while o for. //Instrucción continue para terminar una iteración de una instrucción for.println("\nSe uso continue para omitir imprimir 5"). } // fin del método main } // fin de la clase ForBreak Cuando la instrucción continue se ejecuta en una instrucción while. En las instrucciones while y do/while.out. } // fin de for System. public class ForContinue { public static void main(String[] args) { for (int cuenta = 1.out. En una instrucción for se ejecuta la expresión de incremento y después el programa evalúa la prueba de continuación del ciclo. } // fin de for System. cuenta). continue. // omite el resto del código en el ciclo System. omite las instrucciones restantes en el cuerpo del ciclo y continúa con la siguiente iteración del ciclo. El programa siguiente. cuenta++) // itera 10 veces { if (cuenta == 5) // si cuenta es 5. ForContinue.out. cuenta <= 10. // la variable de control también se usa // cuando termina el ciclo for (cuenta = 1. } // fin del método main } // fin de la clase ForContinue 84 . el programa evalúa la prueba de continuación del ciclo justo después de que se ejecuta la instrucción continue.printf("%d ". public class ForBreak { // el método main empieza la ejecución de la aplicación en Java public static void main(String[] args) { int cuenta.println("Salio del ciclo en cuenta = " + cuenta). utiliza la instrucción continue en un ciclo for. // número de primos por línea int contador = 0. numero). // entrada System.printf(" %d no es primo\n". numero = entrada. en cambio 8 no es primo porque a parte del 1 y el 8 tiene otros divisores. // contador para los número primos int numero = 2. 85 . // número de primos a imprimir final int NUMERO_POR_LINEA = 10.out. determina si un número es primo. i++) { i == 0) { // ¿es primo? = false.util.Aprenda Java El programa siguiente. NumerosPrimos.nextInt(). Por ejemplo.printf(" %d es primo\n". Scanner entrada = new Scanner(System. //Programa que determina si un número es primo o no. else System. } // fin del método main } // fin de la clase NumeroPrimo El programa siguiente.java.print("n? ").out. //para leer del teclado public class NumeroPrimo { public static void main(String[] args) { boolean esPrimo = true.out.out.Scanner. public class NumerosPrimos { public static void main(String[] args) { final int MAX_PRIMOS = 50. } // fin if } // fin for <= numero / 2.in). NumeroPrimo. //Programa que imprime los primeros 50 números primos. numero). 3 es primo porque sus únicos divisores son 1 y 3.java. int numero. import java. Un número es primo si tiene únicamente dos divisores: 1 y el mismo número. i if (numero % esPrimo break. // no es primo // termina el ciclo // salida if (esPrimo) System. // proceso for (int i = 2. imprime los primeros 50 números primos. // Valor inicial para la búsqueda de primos // mensaje de usuario System.println("Los 50 números primos son:\n"). } // fin while } // fin del método main } // fin de la clase NumerosPrimos 4. divisor <= numero / 2. // termina el ciclo } // fin if } // fin for // Imprime el número primo e incrementa el contador if (esPrimo) { contador++. // determina si el número es primo for (int divisor = 2. Problema 1. 86 .print(numero + "\t"). Escribe un programa que lea un número entero y que imprima su cuadrado. Ejercicios resueltos. // incrementa el contador de primos if (contador % NUMERO_POR_LINEA == 0) { // inicia una nueva línea System.Aprenda Java // encuentra los números primos while (contador < MAX_PRIMOS) { // asume que el número es primo boolean esPrimo = true.out.8. //Imprime el cuadrado de un número hasta que se introduce //un número negativo. } // fin else } // fin if // busca si el siguiente número es primo numero++. Nota: los problemas que se resuelven aquí no tienen una solución única.println(numero).out. // el número no es primo break. divisor++) { if (numero % divisor == 0) { esPrimo = false. La programación con instrucciones de repetición 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. } // fin if else { System. el proceso debe repetirse hasta que se introduzca un número negativo. util. System. numero).out. int numero = entrada.").printf("El cuadrado de %d es %d\n". // el ciclo se repite hasta que se lea un numero negativo System. //Imprime si un número es positivo/negativo hasta que se //introduce un número cero.in).Scanner.out. else System. numero. import java.out. while (numero >= 0) { cuadrado = numero * numero. Escribir un programa que lea un número entero e indique si es un número positivo o negativo.nextInt().out. cuadrado). } // fin while System.printf("%d es negativo\n".print("(0 para terminar)? "). numero = entrada.in).. System.println(">>>Fin del programa. //para leer del teclado public class PositivoNegativo { public static void main(String[] args) { Scanner entrada = new Scanner(System.Scanner.print("Introduce otro número entero: ").out. numero). 87 . ").out.nextInt(). int cuadrado..printf("%d es positivo\n". while (numero != 0) { if (numero > 0) System.println("Introduce un número positivo/negativo.Aprenda Java import java.print("Introduce un número entero: ").nextInt(). System.out. Scanner entrada = new Scanner(System. //para leer del teclado public class Cuadrado { public static void main(String[] args) { int numero. numero = entrada.util. } // fin del método main } // fin de la clase Cuadrado Problema 2. System.out. El proceso se repetirá hasta que se introduzca un 0. System. System.println( "Introduce otro número positivo/negativo.out. import java.out. //para leer del teclado public class SumaDigitos { public static void main(String[] args) { Scanner entrada = new Scanner(System. } // fin while System..out.util.out.out.nextInt(). Por ejemplo para el número 234 el resultado es 9. } // fin del método main } // fin de la clase SumaDigitos 88 .print("(0 para terminar)? "). } // fin del método main } // fin de la clase PositivoNegativo Problema 3. numero = entrada.println("------------------------------"). int temporal = 0.out. //Suma los dígitos de un número. suma).Aprenda Java // el ciclo se repite hasta que se lea un cero System. numero = entrada. int suma = 0..").nextInt(). while (temporal > 0) { // obtiene el dígito digito = temporal % 10.Scanner.println("Suma los dígitos de un número."). Escribe un programa que lea un número entero y sume los dígitos individuales de ese número. int numero = 0.in).print("Número? "). temporal = numero. // lo suma suma += digito."). System. } // fin while System.println(">>>Fin del programa. System. int digito = 0.printf("La suma de los dígitos de %d es %d". // recorta la cifra temporal = temporal / 10. numero.out. temporal = numero. 55555. numero = entrada. Por ejemplo.util.Ulam: • • • • Comience con cualquier entero positivo.Aprenda Java Problema 4. La siguiente se llama la conjetura de ULAM en honor del matemático S. Si es par. Por ejemplo: 12321. else System. // recorta la cifra temporal = temporal / 10.out. while (temporal > 0) { // obtiene el dígito digito = temporal % 10. Escribe un programa que lea un número entero y determine si es el número es palíndromo. Al final.printf("%d no es palíndromo".Scanner.printf("%d es palíndromo".nextInt(). } // fin del método main } // fin de la clase Palindromo Problema 5. 45554 son números palíndromos. // forma el número inverso inverso = (inverso * 10) + digito. divídalo entre 2.out. int numero = 0. System. //Determina si un número es palíndromo. //para leer del teclado public class Palindromo { public static void main(String[] args) { Scanner entrada = new Scanner(System. numero). cuando el 89 .out. obtendrá el número 1.println("Determina si un número es palíndromo. int digito = 0. System.").out. System.println("-------------------------------------"). si es impar. import java.out. int inverso = 0. multípliquelo por 3 y agréguele 1.print("Número? "). numero). Obtenga enteros sucesivamente repitiendo el proceso. int temporal = 0. independientemente del entero inicial. } // fin while if (numero == inverso) System.in). while (numero != 1) { if (numero % 2 == 0) numero = numero / 2. //2. 1800. 12. System.. 1. contador++.println("Conjetura de ULAM"). //cuenta los números por renglón int i = 2. 5.print("Introduce un número entero: "). public class Serie1 { public static void main( String[] args ) { final int LIMITE = 1800. 7.. //cuenta los números por línea 90 .. while( i <= LIMITE ) { sumaSerie += i. } // fin while } // fin del método main } // fin de la clase ConjeturaUlam Problema 6. //El programa imprime y suma los términos de una serie. 10. 12.out. 40.out. . 10. 15. 8. 7.Aprenda Java entero inicial es 26.. import java.out. System. 5. //Imprime la serie para la conjetura de ULAM. //para leer del teclado public class ConjeturaUlam { public static void main(String[] args) { Scanner entrada = new Scanner(System.. . System.util. int contador = 0. else numero = numero * 3 + 1.Scanner. System. 16. 1800.nextInt(). 17. 5. Escribir un programa que imprima y obtenga la suma de los términos de la siguiente serie: 2. 10. 13.. la secuencia será: 26.println("-----------------"). 17. int sumaSerie = 0. int numero = entrada. 20. 15. final int NUMERO_POR_LINEA = 10. 4.println(numero). 2. boolean indicador = true. Escribe un programa que lea un entero positivo y obtenga e imprima la sucesión de ULAM.in).out. Scanner.println(i). + 1/n"). import java. } //fin else //fin while } } } System.println("1 + 1/2 + 1/3 + .out..out.out. indicador = false. i++) serie = serie + 1.print( i + "\t"). Scanner entrada = new Scanner(System.println("Calcula la suma de la serie:"). if( indicador ) { i += 3. sumaSerie ). indicador = true.0 / i.0. i <= numero.Aprenda Java //imprime la serie if( contador % NUMERO_POR_LINEA == 0 ) System. 91 .out. //fin del método main //fin de la clase SumaSerie1 Problema 7.out.print("Introduce el número n: ").. public class Serie2 { public static void main(String[] args) { double serie = 0. System. Escribe un programa que lea un número entero N y calcule el resultado de la siguiente serie: 1 1 1 1 1+ + + + .nextInt().out.in).println("----------------------------").. } //end if else { i += 2.printf( "\nLa suma de la serie es %d".out. int numero = entrada. System. System.. // proceso for (int i = 1. // entrada System.util. else System.+ 2 3 4 N //Calcula el resultado de una determinada serie. . } // fin del método main } // fin de la clase Serie2 Problema 8.0 / i.println("1 .0.print("Introduce el número n: "). Scanner entrada = new Scanner(System.printf("La suma de la serie es %.1/n"). bandera = false.out. System.util. System. i <= numero.± 2 3 4 N //Calcula el resultado de una serie determinada. int numero = entrada. } // fin if else { serie -= 1. import java.out.in). i++) { if (bandera) { serie += 1. for (int i = 1. serie)..1/2 + 1/3 . +.Scanner.out.Aprenda Java // salida System..out.println("Calcula la suma de la serie:"). } // fin del método main } // fin de la clase Serie3 92 . boolean bandera = true.printf("La suma de la serie es %.1/4 . Escribe un programa que lea un número entero N y calcule el resultado de la siguiente serie: 1 1 1 1 1− + − + .2f\n". System. System.nextInt(). } // fin else } // fin for System. bandera = true.out.2f\n"..0 / i. serie).println("------------------------------").out. //para leer del teclado public class Serie3 { public static void main(String[] args) { double serie = 0. // primer valor de la serie int n2 = 1. 55.in). factorial).Scanner.println( "Serie de Fibonacci. 55.. 3. //Ejemplo de la serie: 0. numero.printf( "El factorial de %d! es %d".out. 1.Aprenda Java Problema 9. Escribe un programa que calcule el término 20 de la secuencia de FIBONACCI. 2. i <= numero. // el valor siguiente int siguiente. 1. 8.println( "-------------------" ).. } // fin del método main } // fin de la clase Factorial Problema 10. 13. i++) factorial *= i.out. System."). 21.n public class Fibonacci { public static void main(String[] args) { final int NUMERO_POR_LINEA = 10. System. El resto se calcula como la suma de los dos inmediatos números que le preceden. Recuerda que los dos primeros números de la serie son 0 y 1. Escribe un programa que calcule el factorial de un número.. Por ejemplo.. Ejemplo de la serie: 0. 5. 8. 5. //Calcula el factorial de un número.nextInt().out. el factorial de 4! = 4 x 3 x 2 x 1. 93 .n. 5!= 4x3x2x1. System.. 34. int numero = 0. 34. 2.util.out. import java. System.out. //para leer del teclado public class Factorial { public static void main(String[] args) { Scanner entrada = new Scanner(System." ). 21.out.println("-----------------------"). System. for (int i = 2.print("Número? "). // contador de la secuencia de números int n1 = 0. // número de primos por línea int contador = 0. 3. numero = entrada.println("Factorial de un número. 13.. System. int factorial = 1. //Calcula el término 20 de la secuencia de Fibonacci. println(siguiente). n1 = n2. } // fin else } // fin for } // fin del método main } // fin de la clase Fibonacci 94 . // incrementa el contador de números if (contador % NUMERO_POR_LINEA == 0) { // inicia una nueva línea System.out. } // fin if else { System.print(siguiente + "\t"). n2 = siguiente.Aprenda Java for (int i = 3.out. i <= 22. contador++. i++) { siguiente = n1 + n2. out. llamadas paquetes. Al finalizar esta lección.0 System.println(Math. serás capaz de: • Conocer algunos métodos pre-construidos de la API de Java tales como los de la clase Math.7)). MathDemo. // redondea x al entero más grande que no sea mayor que x System.out.println(). Java contiene muchas clases predefinidas que se agrupan en categorías de clases relacionadas.ceil(-9.println(Math.floor(-9. Utilización de métodos pre-construidos.out.out. // 23.println(Math.7 System. // -9 System.ceil(9. // el valor más pequeño de x y y 95 .out.println(Math.println().out.8)).println(Math. 5. Además de proveer métodos matemáticos. nos referimos a estos paquetes como la Interfaz de Programación de Aplicaciones de Java (API de Java). Métodos de la clase Math.7 System.java utiliza algunos métodos de la clase Math.println(Math.8)). // -2.out. // 0. // 9.abs(23. public class MathDemo { public static void main(String[] args) { // el valor absoluto System.2)).println(Math.println(Math.abs(0. // -10 System.7 System.0 System.out.out.3 System. //Utiliza algunos métodos de la clase Math. // 23. En conjunto.max(2.floor(9. o biblioteca de clases de Java. el método printf de System.println(). 12.2)). Todos los métodos en la clase Math son static.7)).3.out.lang. La clase Math es una de las clases pre-construidas en el paquete java.out.out.out. // 12. // redondea x al entero más pequeño que no sea menor de x System.3. -12. El modificador static significa que son métodos de clase y deben llamarse antecediendo el nombre del método con el de la clase en la cual están definidos.max(-2.1.println(). Esta clase contiene métodos que implementan funciones matemáticas estándar.Aprenda Java 5.println(Math. la clase Math también provee dos constantes matemáticas: PI y e (la base para los logaritmos naturales). // el valor más grande de x y y System. El programa siguiente. String.7)).0)). NumberFormat y DecimalFormat.abs(-23.7)).0 System. // 10.out. pow(2. // 2. int num2 = entrada.lang.println(Math. public class MayorMenor { public static void main(String[] args) { Scanner entrada = new Scanner(System.out.out.out. // x elevado a la potencia y System. // encuentra el menor int menor = min(num1.min y Math.random()).min(-2. System.out.3.java nos ilustra las ventajas de utilizar métodos preconstruidos. mayor). -12.Math.printf("El menor es %d%n". max(num2.max.out.7)).5)).pow(9. num3)).7)).print("Introduce tres números: ").3 System.7 System. 3)).println().out. System.. // 3 System. num3)).nextInt().out.println(). } // fin del método main } // fin de la clase MathDemo Recuerda que los valores numéricos que se pasan como argumento a los métodos deben de coincidir y que posiblemente suceda una conversión automática de esos valores. // La raíz cuadrada de x System.Scanner.println(Math. //Demuestra el uso de Math.nextInt(). int num1 = entrada. min(num2.reutilizar las clases y métodos de la API de Java hay que tener presente la promoción y conversión de argumentos // encuentra el mayor int mayor = max(num1.printf("El mayor es %d%n"..println(Math.in). // // // // evitar reinventar la rueda. //para leer del teclado import static java.sqrt(9)). menor). // 3 System. // 8 System.1 sin incluir el 1 System. 12.3.println(). // genera un número aleatorio 0. System.out.out.*.out.println(Math.out. import java. // -12. } // fin del método main 96 .out.min(2.nextInt().println(Math.. 0. El programa siguiente MayorMenor.Aprenda Java System.util. int num3 = entrada.println(Math. 3f %n".out. // si no se especifica el cero se usa un caracter vacío System.out. Formateo de la salida. // agregando el separador de coma System.out.out.out.java es otro ejemplo de como imprimir texto formateado.PI). } // fin del método main } // fin de la clase PrintfDemo El programa siguiente PrintfTabla. 1974). // imprime un número entero System. 1974).printf("%08d %n".printf("%s%10s%8s%n".out.printf("-%d %n". Math. El programa siguiente. Math. 97 .out.printf("%8.println("123456789012345678901234567890123456789").out.PI).println("---------+---------+---------+---------"). public class PrintfTabla { public static void main(String[] args) { // imprime un encabezado System. 1974).printf("%8d %n". Math. System. // signo positivo y negativo System.Aprenda Java } // fin de la clase MayorMenor 5.out. System.printf("%f %n".d %n%n".PI). "Triple"). System. // agrega un cero a los espacios restantes System.printf("%. "Num". PrintfDemo.java. //Utiliza printf para dar formato a una tabla.println("---------+---------+---------+---------"). 1974).printf("%d %n". 1974).printf("%.printf("+%d %n".out. // 3 digitos después del punto decimal System.println("---------------------"). El método printf de la clase System nos permite imprimir texto formateado.out.out.out. 1974). // imprime un número en punto flotante System. // 8 caracteres y 2 digitos System.out. 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. "Cuadrado".out. System. System.2.3f %n".println("123456789012345678901234567890123456789"). 1974).out. // 3 digitos después del punto decimal cad = String.Aprenda Java for (int i = 1.format("%8.out. i++) System. } // fin del método main } // fin de la clase PrintfTabla Otra manera de dar formato al texto es mediante el método format de la clase String. 1974). // signo positivo y negativo cad = String.out. i <= 10.println(cad).println("123456789012345678901234567890123456789").format("+%d".printf(cad).println(cad). // agrega un cero a los espacios restantes cad = String.out. i. public class StringFormatDemo { public static void main(String[] args) { System. i * i.3f".PI).format("%. System. Math. StringFormatDemo.out.format.format("-%d".out.println(cad). // 8 caracteres y 2 digitos cad = String. 1974). System. System.println("123456789012345678901234567890123456789"). El programa siguiente. System. System.PI). cad = String. Math. //Demuestra el formato de cadenas con String.printf("%3d%10d%8d%n".println(cad).out.println(cad).out. 1974).format("%08d".format("%. System.println(cad). System. // si no se especifica el cero se usa un caracter vacío cad = String. Math.println("---------+---------+---------+---------"). // imprime un número en punto flotante cad = String.out. 1974). // agregando el separador de coma cad = String.out. System. i * i * i).format("%8d".out. Este método trabaja de la misma manera que el método printf de la clase System.out.println("---------+---------+---------+---------"). // imprime un número entero String cad = String.out.java.println(cad).PI). System. System.d %n%n".format("%d". System.println(cad). muestra como dar formato al texto.out. 1974).3f". System.format("%f". } //fin del método main //fin de la clase StringFormatDemo } 98 . indexOf('e')). //Demuestra algunos métodos de la clase String.Aprenda Java 5.println(mensaje. 99 . System.out. '9')). // de Java System.out. // 6 System. // e System. La clase String contiene muchos métodos útiles para la manipulación de cadenas.println(mensaje.java utiliza algunos métodos de la clase String.charAt(6)).println("No son iguales"). } // fin del método main } // fin de la clase StringDemo El programa siguiente.3. CompararString.lang.out.out.out. 6)).println(mensaje.println(mensaje). public class StringDemo { public static void main(String[] args) { String mensaje = "Ahora es el tiempo de Java".out.out. muestra como se deben comparar dos cadenas en Java.substring(0. System.java. System. //Ilustra como comparar cadenas. else System.println(mensaje. System. String cadDos = new String("CSharp"). System.println(mensaje.out.indexOf("es")).println(mensaje.out. // de Java System. // 6 System.replace('e'.out. La clase String es otra de las clases del paquete java.toLowerCase()).out.println("Son iguales").println("012345678901234567890123456789"). El programa siguiente StringDemo.println(mensaje.toUpperCase()). System.out.out.substring(19)). // la forma incorrecta de comparar dos cadenas if (cadUno == cadDos) System. public class CompararString { public static void main(String[] args) { String cadUno = new String("Java").out.println("+--------+---------+---------+"). Métodos de la clase String.println(mensaje.length()). // 26 System.println(mensaje. println(19).format(19)). if (cadDos. System.getCurrencyInstance(). NumberFormat moneda = NumberFormat.println(19.Aprenda Java // la forma correcta if (cadUno.8). System.println(moneda. System. ilustra lo anterior.8)).out.out.out.println("Números sin formato:"). System.out.out. System. //para usar formatos de otros paises public class NumberFormatDemo { public static void main(String[] args) { System.println("Usando el formato de UK:").out.out.out.equals("Java")) System. Formateo de números.4.equalsIgnoreCase("CSHARP")) System. System.out. El programa siguiente. System.println("Usando el formato por default:").81111)).89999)).java. //Demuestra el formato para las monedas import java.out. System. import java.println(monedaUK. NumberFormat monedaUK = NumberFormat.println(moneda.text.out.out.println(moneda.format(19.format(19.out.println(monedaUK. // observa los números redondeados System.out.format(19. System. else System.format(19.out.out.89999)).util.format(19. NumberFormatDemo.8)).println("No son iguales").println().81111)). System.println(19.println("Son iguales (CSharp)").println("Son iguales (Java)"). else System. System. System.Locale.println(monedaUK.println("No son iguales"). System.println().format(19. System.out. } // fin del método main } // fin de la clase CompararString 5.89999).out.println(19.println(moneda.NumberFormat. 100 .getCurrencyInstance(Locale.UK).81111).out. La clase NumberFormat se utiliza para formatear números permitiendo que el código sea independiente de las convenciones propias de cada país.out. 00%").##%"). DecimalFormat porcentaje1 = new DecimalFormat("0. System.out.println("Patrón 1: 00.DecimalFormat.println("Patrón 2: 0. El programa siguiente.out. DecimalFormat patron3 = new DecimalFormat("##. limitar el número de decimales. } // fin del método main } // fin de la clase NumberFormatDemo La clase DecimalFormat nos permite mostrar números con un formato deseado.out. DecimalFormat patron4 = new DecimalFormat("#.000").out. System.format(numero)).out. System.out. public class DecimalFormatDemo { public static void main(String[] args) { DecimalFormat patron1 = new DecimalFormat("00. si usaremos punto o coma.println(porcentaje1.3456789.format(numero)).out. System.out. System. double numero = 2.println(patron3.println(porcentaje2.format(19)).###").out.00%"). System.println(patron2.format(0. System.println(patron1. System.##"). System.##%"). System.println("Patrón 3: ##.out. DecimalFormat porcentaje2 = new DecimalFormat("#.Aprenda Java System.out.out. } // fin del método main } // fin de la clase DecimalFormatDemo 101 . DecimalFormatDemo. es decir.00").000").println(patron4.println(monedaUK.format(numero)). System. System.###").println("Patrón 5: 0.format(numero)).format(0.308)). DecimalFormat patron2 = new DecimalFormat("0. etc.out.println("Patrón 6: #. ilustra lo anterior.##").text.java. //Demuestra el formato para números import java.308)).00").println("Patrón 4: #. Programación modular. cálculos. 6. Para ello se parte de un módulo principal que se descompone en varios submódulos que son controlados por el módulo principal. Un método tipo void es un módulo de programa que puede recibir datos de entrada a través de parámetros. 102 . Métodos void. serás capaz de: • Utilizar la programación modular mediante métodos void y con valor de retorno en los programas Java. razón por el que se le conoce también como método sin valor de retorno. 6.3 Métodos void sin parámetros. pero. Métodos.java.2. Si la tarea asignada a un módulo es demasiado compleja este deberá descomponerse en otros módulos más pequeños hasta lograr módulos que hagan tareas relativamente sencillas. Métodos tipo void con parámetros. salida.Aprenda Java 6. Una vez que el subprograma termina su tarea. que no retorna ningún resultado al punto donde es invocado. etc. Estos métodos no pueden recibir datos de entrada ni retornar ningún resultado al punto de su invocación. La programación modular es una metodología de programación que permite construir un programa grande descomponiéndolo en pequeños subprogramas o módulos. TestMetodoVoid. ilustra lo mencionado anteriormente. Los métodos tipo void pueden dividirse a su vez en dos tipos: • • Métodos tipo void sin parámetros. El programa siguiente. Al finalizar esta lección. control de otros módulos. 6. devuelve el control al punto donde se hizo la llamada. En el lenguaje Java a los módulos o subprogramas se les conoce con el nombre de métodos.1. A este proceso de refinamiento sucesivo se conoce también como la técnica de “divide y vencerás”. Un subprograma puede llamar a su vez a otros subprogramas. Las tareas asignadas a los subprogramas pueden ser de diversa índole: entrada. Para que un subprograma pueda efectuar su tarea tiene que ser llamado o invocado por el programa principal o por algún otro módulo que considere necesario el servicio del subprograma. El programa siguiente.java. Estudiemos otro ejemplo. utiliza métodos void para convertir de celsius a fahrenheit respectivamente. } // fin del método fahrenheitCelsius // convierte de celsius a fahrenheit public static void celsiusFahrenheit() { double fahrenheit. celsius.in). // realiza la conversión celsius = 5. // lee la temperatura System. // lee la temperatura System. } // fin del método saludo public static void main(String[] args) { // invoca al método static saludo().0 * fahrenheit .util.32.print("Ingresa una temperatura en Fahrenheit: "). 103 . } // fin del método main } // fin de la clase TestMetodoVoid Recuerda: si el encabezado del método tiene la palabra clave void (localizado a la izquierda del nombre del método) significa que el método no devuelve ningún valor. celsius). //Utiliza dos métodos para convertir de celsius a fahrenheit y viceversa.Aprenda Java //Define y utiliza un método void. // imprime el resultado System.print("Ingresa una temperatura en Celsius: ").Scanner.out. public class TestMetodoVoid { public static void saludo() { System.println("¡Saludos programador Java!").printf("La temperatura en Celsius es %. celsius.out. En este curso utilizaremos métodos con el modificador static.out. // variables locales Scanner entrada = new Scanner(System. Temperatura.nextDouble().in). fahrenheit = entrada.out.2f%n". //para leer del teclado public class Temperatura { // convierte de Fahrenheit a Celsius public static void fahrenheitCelsius() { double fahrenheit. import java. // variables locales Scanner entrada = new Scanner(System.0 / 9. } // fin del método mostrarMensaje public static void main(String[] args) { mostrarMensaje("Java"). // mensaje de usuario System.out. fahrenheit).nextInt(). if (opcion == 1) fahrenheitCelsius().printf("La temperatura en Fahrenheit es %. Curso. //Declaración de un método con un parámetro.0 / 5.").2f%n".println("2.out. public class Curso { // muestra un mensaje de bienvenida public static void mostrarMensaje(String nombreCurso) { System.out. // imprime el resultado System. pero. Convertir de Celsius a Fahrenheit.nextDouble().println("1."). else celsiusFahrenheit().Aprenda Java celsius = entrada. al igual que en el caso anterior no pueden retornar ningún resultado al punto de su invocación. // realiza la conversión fahrenheit = 9.printf("Bienvenido al curso de %s%n".4.in).java. Convertir de Fahrenheit a Celsius.print("Opción: "). nombreCurso). System. El número de parámetros es variable y depende de las necesidades del método. Métodos void con parámetros. El programa siguiente. opcion = entrada.out.out. } // fin del método celsiusFahrenheit public static void main(String[] args) { int opcion. // llamada al método 104 .0 * celsius + 32. // lee la opción del usuario System. } // fin del método main } // fin de la clase Temperatura 6. declara y utiliza un método con un parámetro para imprimir un mensaje de texto dependiendo del valor que se recibe como argumento. Estos métodos reciben datos de entrada a través de parámetros. // variable local Scanner entrada = new Scanner(System. recibe como dato de entrada una calificación e imprime una nota.java.out. } // fin del método calificar public static void main(String[] args) { System.0) System.Aprenda Java mostrarMensaje("C Sharp"). calificar(59.print("Obtuviste una ").println('C').out. Estos métodos pueden dividirse a su vez en dos tipos: • • Métodos con valor de retorno sin parámetros.println('D').5).5). calificar(78. NotaExamen. Métodos con valor de retorno con parámetros. else if (calificacion >= 60. Un método con valor de retorno es un módulo de programa que puede recibir datos de entrada a través de parámetros y que retorna un resultado al punto donde es invocado. // llamada al método } // fin del método main } // fin de la clase Curso El programa siguiente.0) System.println('F').0) System.out.out.println('A'). System.5. Este tipo de método se utiliza para efectuar cualquier tipo de proceso que produzca un resultado .out.out.0) System. public class NotaExamen { public static void calificar(double calificacion) { if (calificacion >= 90. else System.out. //Define un método void que recibe un valor como argumento. else if (calificacion >= 80.println('B'). 105 . } // fin del método main } // fin de la clase NotaExamen 6. Métodos return.print("Obtuviste una "). else if (calificacion >= 70. pow(radio. } // fin del método area public static void main(String[] args) { Scanner entrada = new Scanner(System. //Utiliza un método con un parámetro para calcular //el área de un círculo. 106 . System.nextDouble().in).%n". pero.java declara y utiliza un método con valor de retorno con un parámetro. 6. Este tipo de métodos no reciben datos de entrada. Métodos return con parámetros. sin parámetros.7.out.util. El programa siguiente. El programa siguiente. //para leer del teclado public class AreaCirculo { // calcula el area de un circulo public static double area(double radio) { return (Math. Métodos return.Scanner.out.println(saludo()). TestMetodoReturn. define un método con valor de retorno. AreaCirculo. el método debe devolver un valor a través de la instrucción return. retornan un resultado al punto donde son invocados.out.2f cms.Aprenda Java 6.print("Radio del círculo:? ").printf("El radio del circulo es de %. y el tipo de valor debe coincidir con el especificado en el encabezado del método. sin parámetros. radio). import java. } // fin del método main } // fin de la clase TestMetodoReturn Recuerda: siempre que en el encabezado de un método sea diferente de void.java. Estos métodos reciben datos de entrada a través de parámetros y retornan un resultado al punto de su invocación. } // fin del método saludo public static void main(String[] args) { // invoca al método static System. 2)).PI * Math. double radio = entrada.6. System. //Define y utiliza un método return public class TestMetodoReturn { public static String saludo() { return "¡Saludos programador Java!". (5. //Encuentra los 10 primeros números primos gemelos.2f%9.2f cms. etc. double pies = 1.out. // valor inicial double metros = 20.Aprenda Java System.java. // incrementa los pies metros += 5.13). divisor <= n / 2.5). "Metros". declara y utiliza dos métodos con valor de retorno y un parámetro para calcular la equivalencia pie a metro y viceversa. area(radio)).out.2f%n". pies. public class PrimosGemelos { // determina si un número es primo public static boolean esPrimo(int n) { for (int divisor = 2. 11 y 13. pies++. pieMetro(pies). 2 y 3 son los únicos primos seguidos. public class PieMetro { public static double pieMetro(double pie) { return 0. " Pies"..printf("%s%9s%9s%9s%n"..7). Por ejemplo.printf("El área del circulo es de %. PieMetro. Pero hay un gran número de pares de números primos que difieren en dos unidades. "Metros". por ejemplo: 3 y 5. //(3. encuentra los primeros 10 números primos gemelos.out. } // fin del método main } // fin de la clase AreaCirculo El programa siguiente. PrimosGemelos. } // fin del método metroPie public static void main(String[] args) { final int MAX = 10. i++) { System. "Pies"). // incrementa los metros } // fin for } // fin del método main } // fin de la clase PiesMetros El programa siguiente.printf("%6. for (int i = 1.0.305.2f%9.etc.java. //Convierte pies a metros y viceversa.2f%9.305 * pie. i <= MAX. 5 y 7.".0. metroPie(metros)). // valor inicial System.(11. divisor++) 107 . metros. } // fin del método pieMetro public static double metroPie(double metro) { return metro / 0. public class ParesPrimos { // determina si un número es primo private static boolean esPrimo(int n) { for (int divisor = 2.printf( "%d y %d son primos gemelos\n". //Encuentra todos los pares primos (AB. // inicia búsqueda int ab = 0. divisor++) if (n % divisor == 0) // ¿es divisible? return false. numero. // cuenta el número de primos int numero = 2. // el número no es primo return true. int contador = 0. // el número es primo } // fin del método esPrimo public static void main(String[] args) { final int MAX = 9999. contador++. ParesPrimos. numero + 2). divisor <= n / 2. int numero = 1001.out.java.CD) donde ABCD también es primo. // el número es primo } // fin del método esPrimo public static void main(String[] args) { final int MAX_PRIMOS = 10. // repetidamente encuentra los pares primos 108 .Aprenda Java if (n % divisor == 0) // ¿es divisible? return false. declara y utiliza un método esPrimo para determinar si un número es primo. cd = 0. CD) donde ABCD también es primo. // el número no es primo return true. // inicia búsqueda // repetidamente encuentra los primos gemelos while (contador < MAX_PRIMOS) { if (esPrimo(numero)) { // primo A if (esPrimo(numero + 2)) { // primo B ( A + 2) System. // incrementa contador primos } } // fin if numero++. // para buscar el siguiente primo } // fin while } // fin del método main } // fin de la clase PrimosGemelos El programa siguiente. El método esPrimo se utiliza como auxiliar para determinar en un rango de números aquellos pares primos (AB. print( "Escribe tres double numero1 = double numero2 = double numero3 = números. ab. // para buscar el siguiente primo } // fin while } // fin del método main } // fin de la clase ParesPrimos Un método puede especificar múltiples parámetros. } // fin if numero++. entrada. El programa siguiente. return valorMaximo. cd). // determina si z es mayor que valorMaximo if (z > valorMaximo) valorMaximo = z. entrada.nextDouble(). if (esPrimo(ab) && esPrimo(cd)) System.in).out.Aprenda Java while (numero < MAX) { if (esPrimo(numero)) { // es primo? ab = numero / 100. // determina el valor máximo 109 .out. BuscadorMaximo. declarado por el programador. entrada. // entrada System.java.nextDouble(). import java.Scanner. // asume que x es el mayor para empezar // determina si y es el mayor que valorMaximo if (y > valorMaximo) valorMaximo = y. numero. //Método máximo. double y. cd = numero % 100. //para leer del teclado public class BuscadorMaximo { // devuelve el máximo de sus tres parámetros double public static double maximo(double x. sólo hay que separar un parámetro de otro mediante una coma (lista separada por comas).util. double z) { double valorMaximo = x.printf("Primo ABCD: %d (%d)(%d)\n". } // fin del método máximo public static void determinarMaximo() { Scanner entrada = new Scanner(System.nextDouble(). separados por espacios: "). declara y utiliza un método con múltiples parámetros. Compatibilidad de argumentos y parámetros. demuestra la compatibilidad de argumentos y parámetros.out. i++) System. //el método no está declarado } // fin del método main } // fin de la clase PasoParametros Otra característica importante de las llamadas a los métodos es la promoción de argumentos: convertir el valor de un argumento al tipo que el método espera recibir en su correspondiente parámetro. } // fin del método determinarMaximo public static void main(String[] args) { // llama al método static determinarMaximo(). "Hola" ). // El orden de los parámetros es correcto // nPrint( 3. } // fin del método nPrint public static void main(String[] args) { nPrint("Hola".Aprenda Java double resultado = maximo(numero1.java. //El tipo es incorrecto // nPrint(). El programa siguiente. El programa siguiente. // muestra el valor máximo System. esto es. PasoParametros. //faltan argumentos // nPront( "Hola.5 ). int n) { for (int i = 0. public class PasoParametros { public static void nPrint(String mensaje. //Demuestra la compatibilidad entre argumentos y parámetros.out.java ilustra lo mencionado anteriormente.8. Las reglas de promoción especifican qué conversiones son permitidas. El número de argumentos en la llamada a un método debe coincidir con el número de parámetros en la lista de parámetros de la declaración del método que se llamó. 2").println("El máximo es: " + resultado). PasoParametros2. //faltan argumentos // nPrint( "Hola" ). } // fin del método main } // fin de la clase BuscadorMaximo 6. numero2. numero3). los tipos de los argumentos en la llamada al método deben ser consistentes con los tipos de ls parámetros correspondientes en la declaración del método. 3).println(mensaje). 110 . //El orden es incorrecto // nPrint( "Hola". qué conversiones pueden realizarse sin perder datos. 3. i < n. Además. //Declaraciones de métodos sobrecargados.out. } // fin del método cuadrado con argumento double // prueba los métodos cuadrado sobrecargados 111 .out. return valorInt * valorInt.out. public class PasoParametros2 { public static double cuadrado(double n) { return n * n. A esto se le conoce como sobrecarga de métodos.println( cuadrado() ). public class Sobrecarga { // método al cuadrado con argumento int public static int cuadrado(int valorInt) { System. // el argumento es correcto // System.printf(" \nSe llamo a cuadrado con argumento double: %f\n". la sobrecarga de métodos se utiliza para crear varios métodos con el mismo nombre que realicen la misma tarea o tareas similares.9.0F)).println(cuadrado(3. Métodos sobrecargados (overload). Por lo general.java. Pueden declararse métodos con el mismo nombre en la misma clase. El programa siguiente. } // fin del método cuadrado con argumento int // método al cuadrado con argumento double public static double cuadrado(double valorDouble) { System. utiliza métodos sobrecargados. } // fin del método cuadrado public static void main(String[] args) { System. Cuando se hace una llamada a un método sobrecargado.println(cuadrado(3)).printf( "\nSe llamo a cuadrado con argumento int: %d\n".println( cuadrado("3") ). valorInt). tipos y orden de los parámetros).println(cuadrado(3. //el tipo es incorrecto } // fin del método main } // fin de la clase PasoParametros2 6.0 System. // 3 -> 3.out. siempre y cuando tengan distintos conjuntos de parámetros (determinados en base al número.out.0F -> 3. // 3.Aprenda Java //Demuestra la compatibilidad entre argumentos y parámetros. //falta el argumento // System.0)).0 System. return valorDouble * valorDouble. Sobrecarga.out.out. valorDouble). tipos y orden de los argumentos en la llamada. el compilador de Java selecciona el método apropiado mediante un análisis del número. 5 y 4.5 es " + max(4. double num2. Sobrecarga2. double num2) { if (num1 > num2) return num1.5D } // fin del método probarMetodosSobrecargados public static void main(String[] args) { // invoca al método probarMetodosSobrecargados().5)).out.5F -> 7. } // fin del método max // regresa el mayor de tres números double public static double max(double num1.printf( "El cuadrado del entero 7 es %d\n". //7. } // fin de main } // fin de la clase Sobrecarga El programa siguiente.printf("El mayor entre 3 y 4 es " + max(3. } // fin del método max public static void main(String[] args) { // invoca al método max con dos parámetros int System. //Demuestra el uso de los métodos sobrecargados public class Sobrecarga2 { // regresa el mayor entre dos valores int public static int max(int num1. double num3){ return (max(max(num1.5.5 es %f\n". // cuadrado(7. cuadrado(7)).5F).Aprenda Java public static void probarMetodosSobrecargados() { System. int num2) { if (num1 > num2) return num1. cuadrado(7.println("El mayor entre 3. else return num2. num2). System.java.out. } // fin del método max // regresa el mayor entre dos valores double public static double max(double num1. else return num2. 112 .printf("El cuadrado del doble 7. 4)).out. 3. es otro programa que utiliza métodos sobrecargados.5)). // invoca al método max con dos parámetros double System. num3)).out. los métodos sobrecargados no necesitan tener el mismo número de parámetros.5 y 4.5. ErrorSobrecarga.println("El mayor entre 3.out. 6.5 y 10.5)). ilustra los errores que genera el compilador cuando dos métodos tienen la misma firma. } // fin del método main } // fin de la clase Sobrecarga2 El compilador diferencia los métodos sobrecargados en base a su firma: una combinación del nombre del método y del número.java. El ámbito de las variables.10.java. } // fin del método cuadrado public double cuadrado(int x) { return x * x. Al igual que con las variables locales. el alcance de los parámetros en un método está limitado únicamente al cuerpo de ese método. ilustra lo mencionado anteriormente. 4. // declara un método con un argumento int public int cuadrado(int x) { return x * x.5. 113 .Aprenda Java // invoca al método max con tres parámetros double System. Los parámetros de un método usualmente no se consideran como variables locales. 10. //Muestra cuando sucede un error en la sobrecarga de métodos. el compilador marca un error // de sintaxis. Además. El programa siguiente. tipos y orden de sus parámetros.5 es " + max(3. El bloque de una variable se establece por el par de llaves más cercanas que encierran la declaración de la variable. pero distintos valores de retorno. } // fin del método cuadrado } // fin de la clase ErrorSobrecarga Los métodos sobrecargados pueden tener tipos de valor de retorno distintos si los métodos tienen distintas listas de parámetros. pero son muy similares a éstas en el sentido de que son declaradas y utilizadas localmente dentro del método. Alcance. Una variable local es una variable que es declarada y utilizada localmente dentro de un método. public class ErrorSobrecarga { // Este programa no funciona. El programa siguiente. println("El parámetro vale: " + valor). // modifica el valor de la variable local // la variable local es visible en este bloque System.out. w = w + 1. // variable distinta de la variable x de metodoUno x++. } // fin del método main } // fin de la clase Alcance 114 .out. // manda llamar al método.out.println(i). } // fin del metodoDos public static void main(String[] args) { metodoUno(). i < x. la variable i no //existe en este bloque // System. la variable w no es visible en este bloque // System. le pasa como argumento el valor de x metodoDos(x). // x es una variable local int w = 5.out. public class Alcance { public static void metodoUno() { int x = 5. // la variable i es visible en el ciclo for for (int i = 0. // la variable w/x es visible aquí también } // fin for // Esto es un error. // w es otra variable local System.println( "w = " + w ). } // fin del metodoUno private static void metodoDos(int valor) { int x = 5.Aprenda Java //Programa que demuestra el ámbito de una variable. // Esto es un error.out.println("x = " + x). i++) { System.println( i ). } // fin del método mostrarTitulo // las opciones del menú private static void menuOpciones() { System. Círculo. cuadrado.Aprenda Java 6. } // fin del método areaCirculo private static double areaRectangulo(double base. System. La programación con métodos es un paso muy importante en el proceso de aprendizaje del lenguaje de programación Java ya que involucra los conceptos estudiados en las lecciones anteriores.println("1. import java.println("3.println("Areas figuras geométricas. Rectángulo.11. System.").out.out.0. //para leer del teclado public class FigurasGeometricas { private static double areaTriangulo(double base.print("Selecciona una opción (1-4): ").util.println("Figuras:").PI * radio * radio. double altura){ return base * altura.").Scanner. //Programa para practicar métodos. } // fin del método areaTriangulo private static double areaCuadrado(double lado) { return lado * lado.out. Ejercicios resueltos.println("4.println("2.println("--------------------------"). Nota: los problemas que se resuelven aquí no tienen una solución única. System. circulo y rectángulo. 115 . Cuadrado. Problema 1.").")."). El programa deberá utilizar métodos void y con valores de retorno. System. Escribe un programa controlado por menú que permita calcular el área de un triangulo.out. Triángulo.out. System. } // fin del método areaCuadrado private static double areaCirculo(double radio) { return Math.out. } // fin del método areaRectangulo private static void mostrarTitulo() { System. System.out.out. double altura) { return base * altura / 2. calcularAreaRectangulo().println("----------------").in). Área rectángulo. case 4: System.out.out. calcularAreaCirculo().out.").print("Altura? "). case 2: System. 116 . break. break. System.print("Base? "). // muestra las opciones del menú menuOpciones(). default: System.nextInt(). System.println("2.out. calcularAreaTriangulo().println("Opción del menú inválida.nextDouble(). // lee la opción del teclado int opcion = entrada."). Área triángulo. double base = entrada. System.out. break.println("1. calcularAreaCuadrado(). System.out. // muestra el título del menú mostrarTitulo().out.Aprenda Java } // fin del método menuOpciones // el menú del programa private static void menu() { // variable local Scanner entrada = new Scanner(System.out."). Área cuadrado. } // fin switch } // fin del método menu private static void calcularAreaTriangulo() { Scanner entrada = new Scanner(System. case 3: System.println("-------------------"). System.println("------------------"). System.out. switch (opcion) { case 1: System.println("-----------------"). Área círculo."). break.println("3.println("4.out.out.in)."). double base = entrada. System.print("Base? ").nextDouble().print("Radio? ").2f". System. 117 .out. System. double altura = entrada. } // fin del método calcularAreaCuadrado private static void calcularAreaRectangulo() { Scanner entrada = new Scanner(System.out.printf("El área es %. area).Aprenda Java double altura = entrada.out.printf("El área es %. System.nextDouble().printf("El área es %.out. System.2f". altura). area). double area = areaCirculo(radio). System.in).nextDouble().out.in). } // fin del método calcularAreaRectangulo private static void calcularAreaCirculo() { Scanner entrada = new Scanner(System. } // fin del método calcularAreaTriangulo private static void calcularAreaCuadrado() { Scanner entrada = new Scanner(System. Scanner entrada = new Scanner(System.nextDouble().in).out.in). System.out.print("Lado? "). } // fin del método calcularAreaCirculo public static void main(String[] args) { String opcion = null.nextDouble(). double area = areaRectangulo(base.out. System.print("Altura? ").printf("El área es %.2f%n". double area = areaCuadrado(lado). double area = areaTriangulo(base. area). double radio = entrada. area).2f". double lado = entrada. altura). out. System. } // fin del método mostrarTitulo // las opciones del menú private static void menuOpciones() { System. System.out. System. opcion = entrada."). Restar.").out.out. restas.out.equals("s")).equals("S") || opcion. multiplicaciones y divisiones. } // fin del método menuOpciones 118 .util.out.").println("3.out.").next(). import java. do { menu().println("Operaciones:").equals("s")). System.. System.. Scanner entrada = new Scanner(System.println(">Fin del programa. Multiplicar.println("4."). System.equals("S") || opcion.next(). Escribir un programa controlado por menú para practicar sumas. public class Aritmetica { public static void main(String[] args) { String opcion = null.print("Selecciona una opción (1-4): ").Scanner. } while (opcion.0. } // fin del metodo main } // fin de la clase FigurasGeometricas Problema 2. //Programa para practicar las operaciones aritméticas básicas. System. Sumar.println("2.println("------------------------").out. System. } while (opcion. } // fin del metodo main private static void mostrarTitulo() { System.println("Programa aritmética 1.out.out.println(">Fin del programa. System.println("1..Aprenda Java do { menu().out. opcion = entrada.").. Dividir.print("\nDeseas continuar? (S/N)"). System.print("\nDeseas continuar? (S/N)").").in).out. // muestra el título del menú mostrarTitulo(). } // fin switch } // fin del método menu private static void practicarSuma() { final int NUMERO_PREGUNTAS = 10. break.").nextInt().out. practicarMultiplicacion(). Practicar restas.println("--------------------"). // contador de preguntas String reporte = ""."). break.out. // número máximo de preguntas int aciertos = 0. case 4: System.println("2. case 3: System.out. practicarSuma().out. break.println("1.println("------------------------").out.println("4. practicarDivision(). System.")."). Practicar divisiones.Aprenda Java // el menú del programa private static void menu() { // variable local Scanner entrada = new Scanner(System. switch (opcion) { case 1: System.out. practicarResta(). System.println("3.out. // el reporte inicialmente está vacío Scanner entrada = new Scanner(System. break.in).println("-------------------"). // lee la opción del teclado int opcion = entrada.println("Opción del menú inválida. System.in). Practicar sumas. // muestra las opciones del menú menuOpciones(). case 2: System. default: System. while (contador < NUMERO_PREGUNTAS) { 119 .println("------------------------------")."). // contador de preguntas correctas int contador = 0. System.out. Practicar multiplicaciones.out. ").").print( "¿Cuánto es " + numero1 + " + " + numero2 + " ? ").out. // muestra la pregunta al usuario System.out. // contador de preguntas String reporte = "". System. // número máximo de preguntas int aciertos = 0.random() * 9 + 1). while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 9 + 1). 120 . // contador de preguntas correctas int contador = 0. } // fin del método practicarSuma private static void practicarResta() { final int NUMERO_PREGUNTAS = 10. } // fin else contador++.in). // compara la respuesta if (numero1 + numero2 == respuesta) { System. // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " + " + numero2 + " = " + respuesta + ((numero1 + numero2 == respuesta) ? " correcto" : " incorrecto").println(numero1 + " + " + numero2 + " = " + (numero1 + numero2)). int respuesta = entrada. // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.out. aciertos++.out.println("La respuesta es incorrecta. } // fin if else { System.println("La respuesta es correcta.out. int numero2 = (int) (Math. int numero2 = (int) (Math.Aprenda Java // genera dos números aleatorios con el método random int numero1 = (int) (Math.nextInt().random() * 9 + 1). } // fin while System.println("\nRespuestas correctas: " + aciertos + "\n" + reporte).random() * 9 + 1). nextInt().numero2 == respuesta) { System. // contador de preguntas correctas int contador = 0.print( "¿Cuánto es " + numero1 + " . numero2 = temp.println("La respuesta es incorrecta.out. // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.println("\nRespuestas correctas: " + aciertos + "\n" + reporte)."). // número máximo de preguntas int aciertos = 0.numero2 == respuesta) ? " correcto" : " incorrecto").out.")." + numero2 + " = " + (numero1 .numero2)).println("La respuesta es correcta.Aprenda Java // si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1. numero1 = numero2. int respuesta = entrada. } // fin if // muestra la pregunta al usuario System.in). } // fin else contador++. } // fin while System. 121 ." + numero2 + " = " + respuesta + ((numero1 . } // fin del método practicarResta private static void practicarMultiplicacion() { final int NUMERO_PREGUNTAS = 10.out. System. // contador de preguntas String reporte = "".println(numero1 + " .out. // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " . // compara la respuesta if (numero1 .out. } // fin if else { System." + numero2 + " ? "). aciertos++. // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " * " + numero2 + " = " + respuesta + ((numero1 * numero2 == respuesta) ? " correcto" : " incorrecto").random() * 9 + 1). // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.println(numero1 + " * " + numero2 + " = " + (numero1 * numero2)).in).out. } // fin while System.").out.").out. } // fin else contador++.nextInt().out. // muestra la pregunta al usuario System.random() * 9 + 1). // compara la respuesta if (numero1 * numero2 == respuesta) { System. // contador de preguntas correctas int contador = 0.print( "¿Cuánto es " + numero1 + " * " + numero2 + " ? "). 122 . } // fin del método practicarMultiplicacion private static void practicarDivision() { final int NUMERO_PREGUNTAS = 10.Aprenda Java while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math. int numero2 = (int) (Math.out. while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math. } // fin if else { System. System.println("La respuesta es correcta. int respuesta = entrada. aciertos++.println("\nRespuestas correctas: " + aciertos + "\n" + reporte).println("La respuesta es incorrecta. // número máximo de preguntas int aciertos = 0.random() * 9 + 1). // contador de preguntas String reporte = "". "). } // fin if // muestra la pregunta al usuario System. } // fin else contador++.print( "¿Cuánto es " + numero1 + " / " + numero2 + " ? "). int respuesta = entrada. // si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1.println("La respuesta es incorrecta. aciertos++.out.random() * 9 + 1).Aprenda Java int numero2 = (int) (Math.nextInt(). // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " / " + numero2 + " = " + respuesta + ((numero1 / numero2 == respuesta) ? " correcto" : " incorrecto").println("La respuesta es correcta. numero2 = temp.out.out. } // fin if else { System.println(numero1 + " / " + numero2 + " = " + (numero1 .out. // compara la respuesta if (numero1 / numero2 == respuesta) { System. } // fin del método practicarDivision } // fin de la clase Aritmetica 123 . } // fin while System. System.numero2)).").out. numero1 = numero2.println("\nRespuestas correctas: " + aciertos + "\n" + reporte). Aprenda Java 7. Arreglos unidimensionales. Al finalizar esta lección, serás capaz de: • Utilizar arreglos de una dimensión 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 número 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 dimensión. 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; // también 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 método main } // fin de la clase DeclaraArreglo Para nombrar un arreglo unidimensional se siguen las mismas convenciones que los demás nombres de variables además 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]; // también se declara así: // int[] edad = new int[5]; // double[] miArreglo; // miArreglo = new Arreglo[10]; // declara y crea el arreglo en una sola línea double[] miArreglo = new double[10]; } // fin del método main } // fin de la clase CrearArreglo Al crear un arreglo unidimensional con la palabra clave new, tenemos que indicar su longitud (cuántos 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 dimensión. 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 posición 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 ejecución // genera un ArrayIndexOutOfBoundsException // miArreglo[29] = 5.5; } // fin del método 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 numéricos, 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 tamaño del arreglo unidimensional. //Tamaño 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 más grande // System.out.println( "miArreglo[0] = " + miArreglo[25] ); // utiliza la propiedad length para obtener // el tamaño del arreglo System.out.println("Tamaño del arreglo = " + miArreglo.length); // esto es un error, no se puede cambiar el tamaño del arreglo // miArreglo.length = 20; } // fin del método main } // fin de la clase DefaultArreglo La expresión arreglo.length obtiene el tamaño del arreglo unidimensional. Dado que los arreglos unidimensionales (y de dos más dimensiones) son de longitud fija, una vez establecido el tamaño 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 número 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 5}.2.println("Lectura de los datos del arreglo. System. //esto es un error //int[] lista. Cuando el compilador encuentra la declaración de un arreglo unidimensional que incluya una lista inicializadora. inicializa un arreglo unidimensional con //Inicializar los valores de un arreglo. } // fin for // imprime el contenido del arreglo System.println("miArreglo[2] = " + miArreglo[2]). int[] miArreglo. Los programas siguientes muestran como inicializar un arreglo unidimensional y algunas operaciones básicas para manipular esos arreglos. cuenta el número de inicializadores en la lista para determinar el tamaño del arreglo unidimensional. int tamaño = entrada. y después establece la operación new apropiada.out.util. El programa siguiente.Aprenda Java System.nextInt(). i++) { System.printf("miArreglo[%d] = %d\n".length.length. //lista = {1.Scanner. for (int i = 0.4. LecturaArreglo. i < miArreglo.in). // crea el arreglo miArreglo = new int[tamaño].out. miArreglo[i] = entrada.3. i++) { System.printf("Valor[%d]? ". // lee los valores del teclado System. for (int i = 0.nextInt().out. 7.out.out. i < miArreglo.").java valores leídos desde el teclado. } // fin del método main } // fin de la clase DatosArreglo El inicializador de un arreglo unidimensional no requiere utilizar la palabra clave new.out. i).2. //para leer del teclado public class LecturaArreglo { public static void main(String[] args) { Scanner entrada = new Scanner(System. import java.print("Introduce el tamaño del arreglo? ").println("\nEl contenido del arreglo:").out. System.println("miArreglo[3] = " + miArreglo[3]). 127 . Operaciones básicas con arreglos unidimensionales. 0 hasta 100 sin incluirlo miArreglo[i] = Math.random.random() * 100. //Inicializar los valores de un arreglo. // suma = suma + miArreglo[i]. miArreglo[i]). i++) { // 0.2f\n". // inicializa el arreglo con valores aleatorios for (int i = 0. public class SumaArreglo { public static void main(String[] args) { double[] miArreglo = new double[10]. // inicializa el arreglo con valores aleatorios for (int i = 0. i++) { System.java suma los elementos de un arreglo //Sumar los valores de un arreglo.out.0. public class ArregloAleatorio { public static void main(String[] args) { double[] miArreglo = new double[10]. // va sumando los valores del arreglo suma += miArreglo[i].java inicializa un arreglo unidimensional con valores aleatorios utilizando el método Math. ArregloAleatorio.random() * 100. } // fin for } // fin del método main } // fin de la clase ArregloAleatorio El programa siguiente. i < miArreglo. miArreglo[i]). for (int i = 0. } // fin for // imprime el contenido del arreglo System. } // fin for } // fin del método main } // fin de la clase LecturaArreglo El programa siguiente. i < miArreglo. i++) { // 0.printf("miArreglo[%d] = %.0 hasta 100 sin incluirlo miArreglo[i] = Math. unidimensional.length. i < miArreglo.Aprenda Java i. i. double suma = 0.length.length.out. } // fin for // imprime la suma del arreglo 128 .println("El contenido del arreglo:"). SumaArreglo. 6.2 }. //Encuentra el elemento mayor de un arreglo. 2. public class MayorArreglo { public static void main(String[] args) { double[] miArreglo = { 1. 1.2f".8. miArreglo[i].length. temporal. // intercambia int temporal = miArreglo[i] = miArreglo[j] = } // fin for miArreglo[i] con miArreglo[j].java encuentra el elemento mayor de un arreglo unidimensional.Aprenda Java System. // imprime los valores del arreglo 129 .9. i++) { if (miArreglo[i] > mayor) mayor = miArreglo[i]. } // fin for // imprime la suma del arreglo System. 5. 8. IntercambioAleatorio. // asume que es el mayor // procesa el arreglo.length). mayor).printf("El elemento mayor es %.out. double mayor = miArreglo[0]. MayorArreglo. 2.2f". 4. //Intercambia aleatoriamente los valores del arreglo. } // fin del método main } // fin de la clase SumaArreglo El programa siguiente. 7. i++) { // genera el indice j aleatoriamente int j = (int) (Math.4. miArreglo[j].java.random para intercambiar aleatoriamente los elementos del arreglo unidimensional. i < miArreglo. 3. public class IntercambioAleatorio { public static void main(String[] args) { int[] miArreglo = { 1. // procesa el arreglo for (int i = 0. suma).printf("La suma de los valores del arreglo es %. i < miArreglo.length.out. } // fin del método main } // fin de la clase MayorArreglo El programa siguiente. iniciando en el indice 1 for (int i = 1. 9 }. 3.random() * miArreglo.9. 2. utiliza el método Math. El programa siguiente.java. } // fin del método main } // fin de la clase CopiarArreglo 130 . 3. CopiarArreglo. ForEach.println("Los valores del arreglo:"). i < lista.out.length]. 5. for (int i = 0. 3.print(miArreglo[i] + " "). // copiamos uno a uno cada elemento for (int i = 0. 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.out. i < miArreglo. //Instrucción for mejorada. //Programa que copia un arreglo en otro. // procesa el arreglo for (int elemento : miArreglo) System. public class ForEach { public static void main(String[] args) { int[] miArreglo = { 1. 2. 5 }. // imprimimos el contenido de copia for (int elemento : copia) System. 9 }. i++) copia[i] = lista[i].println(elemento).out. i++) { System. 7. } // fin for } // fin del método main } // fin de la clase Shuffling El programa siguiente.java utiliza la instrucción for mejorada para procesar arreglos unidimensionales. 4. } // fin del método main } // fin de la clase ForEach La instrucción for mejorada.Aprenda Java System. // creamos el arreglo int[] copia = new int[lista. itera a través de los elementos o colección sin utilizar un contador.print(elemento + " ").length. 4. public class CopiarArreglo { public static void main(String[] args) { int[] lista = { 1.length.out. print(arreglo[i] + " "). 13. 31.length.out.Aprenda Java 7. 31.0 }). 43. demuestra el uso de métodos sobrecargados. i++) System. 34. 13.out.java utiliza un método que recibe como argumento un arreglo unidimensional de tipo double. PasoArreglo2. i < arreglo.0. 23.0. 34.8 }.4. 12. 12. //Paso de arreglos a los métodos. 12. double[] y = { 11. } // fin del método imprimir // método overload 131 . imprimir(y).length. 15. public class PasoArreglo { public static void main(String[] args) { double[] x = { 12.0. imprimir(x). System. PasoArreglo. int[] y = { 11. 23. i < arreglo. imprimir(y).0. 21 }.8. Para pasar un argumento tipo arreglo unidimensional a un método se específica el nombre del arreglo unidimensional sin corchetes.4.0.out. pero ahora utilizando el concepto de métodos sobrecargados. //Paso de arreglos a los métodos.0. El programa siguiente. 12. Paso de arreglos unidimensionales a los métodos. imprimir(x).3.println().0.0. 43.4 }.4.4 }.println(). 21.0. } // fin del método main public static void imprimir(double[] arreglo) { for (int i = 0.7. i++) System. public class PasoArreglo2 { public static void main(String[] args) { double[] x = { 12.print(arreglo[i] + " "). 12.out. System. } // fin del método main // método overload public static void imprimir(double[] arreglo) { for (int i = 0.java. // usando un arreglo anónimo imprimir(new double[] { 11. 13.0. } // fin del método imprimir } // fin de la clase PasoArreglo Veamos otro ejemplo. El programa siguiente. 14.4. b). int[] temp = new int[MAX].java.out.length.i). // proceso int producto = productoVectores(a. } // fin del método imprimir } // fin de la clase PasoArreglo2 7. } // fin del método main private static int[] leerArreglo() { // crea el objeto de lectura Scanner entrada = new Scanner(System.println("Arreglo 2.Aprenda Java public static void imprimir(int[] arreglo) { for (int i = 0. temp[i] = entrada. i++) System. // tamaño del arreglo public static void main(String[] args) { // entrada System. producto). Al igual que cualquier otro tipo de dato podemos especificar que un método retorne un arreglo unidimensional.in). 132 . //para leer del teclado public class ProductoVector { // variable de clase . int[] b) { int producto = 0. int[] a = leerArreglo(). int[] b = leerArreglo(). System. } // fin for return temp.out.util.").4. for (int i = 0. Arreglos unidimensionales como valor de retorno. retorna un arreglo en la llamada de un método. } // fin del método leerArreglo private static int productoVectores(int[] a. i < arreglo.out. ProductoVector. El programa siguiente.out.length."). //Calcula el producto de dos arreglos A y B.printf("Valor[%d]? ". i++) { System.out. System.printf("El producto de AxB = %d".variable static private static final int MAX = 10.nextInt().println(). // salida System.print(arreglo[i] + " "). import java.Scanner.println("Arreglo 1. i < temp.out. 2f%n". System. d2). junto con su tipo. debe colocarse al final de la lista.out.. numeros) { double total = 0.out. System.0. d4). VarArgs. Lista de argumentos de longitud variable.println().out. System. El programa siguiente.out. Un tipo de argumentos que va precedido por una elipsis (.2f%n". System.length.out.").printf("El promedio de d1 y d2 es %. i < MAX. } // fin del método productoVectores } // fin de la clase ProductoVectores 7. i++) producto = producto + (a[i] * b[i]). System.) en la lista de parámetros de un método indica que éste recibe un número variable de argumentos de ese tipo específico.2f%n".java utiliza un método con lista de argumentos de longitud variable.. } // fin del método promedio public static void main(String args[]) { double d1 = 10.0.0. d3). System. double d2 = 20. y la elipsis.printf("d4 = %..out.println("------------------"). d2)). promedio(d1.Aprenda Java for (int i = 0.printf("d3 = %. Este uso de la elipsis puede ocurrir sólo una vez en una lista de parámetros.0.2f%n". double d4 = 40.printf("d1 = %.0. return producto. System.printf("d2 = %. return total / numeros.5. Con las listas de argumentos de longitud variable podemos crear métodos que reciben un número arbitrario de argumentos.out. 133 .println("Valores iniciales.2f%n". d1). System.. public class VarArgs { // calcula el promedio public static double promedio(double. // inicializa el total // calcula el total usando la instrucción for mejorada for (double d : numeros) total = total + d. double d3 = 30. //Uso de listas de argumentos de longitud variable.out. 9. } // fin del método main } // fin de la clase VarArgs es %.binarySearch para buscar un elemento en un arreglo unidimensional. 2.0. d4)).4.6. // ordena el arreglo en forma selectiva Arrays. La clase Arrays está definida en el paquete java. 1. d2.util. // ordena el arreglo en orden ascedente Arrays.out.Arrays.print(arreglo[i] + " ").length. 7.out.9.println(). } // fin del método main private static void imprimir(double[] arreglo) { for (int i = 0. -9. i < arreglo. OrdenaArreglo. imprimir(listaUno). 1.util e incluye una serie de métodos para manipular arreglos unidimensionales.sort import java. 4. 1.9. 134 . } // fin del método imprimir } // fin de la clase OrdenaArreglo El programa siguiente. 6}.util.sort para ordenar un arreglo unidimensional.1 }.binarySearch.5.2f%n".3. d3 y d4 promedio(d1.sort(listaUno). El programa siguiente. 3. 4. imprimir(listaDos). 2.java utiliza el método Arrays. -3. public class BusquedaArreglo { public static void main(String[] args) { int[] miArreglo = { 7. System.sort(listaDos. double[] listaDos = { 4.3. 8.printf("El promedio de d1.Aprenda Java System. d3.5 }. //Busca en un arreglo utilizando Arrays. BusquedaArreglo.Arrays. public class OrdenaArreglo { public static void main(String[] args) { double[] listaUno = { 6.java utiliza el método Arrays. 4).out. import java. 5. //Ordena un arreglo con Arrays.3. d2. 5. -2. i++) System. La clase Arrays. java. Arrays. 80. //Compara si dos arreglos son iguales con el método Arrays. 135 .equals import java. 10}.Arrays.Aprenda Java //ordena el arreglo Arrays. i < arreglo. 2.printf( "El valor %d se 3. ComparaArreglos. 1)).sort( miArreglo ). 19}. encuentra en la pos %d%n". 50. //Utiliza el método Arrays.println(). compara arreglos con el método Arrays. Arrays. califVB)).print(arreglo[i] + " "). 5)).out. 87.out. //busca algunos valores System. 50. miArreglo. 3.util.out. RellenarArreglo. miArreglo.printf( "El valor %d se 1. int[] listaNet = { 1.java utiliza el método Arrays. 80. 10}. int[] califNet = { 100. //imprime el arreglo imprimir( miArreglo ). 4. public class ComparaArreglos { public static void main(String[] args) { int[] califJava = { 100. public class RellenarArreglo { public static void main(String[] args) { int[] listaJava = new int[5].out. encuentra en la pos %d%n". System. 70.equals(califJava. } } private static void imprimir(int[] arreglo) { for (int i = 0.println( Arrays.println( Arrays. System. } // fin del método imprimir //fin de la clase BusquedaArreglo El programa siguiente.out.equals(califJava. System.length. i++) System. 3)). 5 }. miArreglo. Arrays. 75.binarySearch( System.out.binarySearch( //fin del método main encuentra en la pos %d%n". 35.fill. } //fin del método main //fin de la clase ComparaArreglos } El programa siguiente.printf( "El valor %d se 5.fill para llenar el contenido del arreglo con un valor específico. califNet)). int[] califVB = { 100. 70.out.binarySearch( System.equals. i++) System.length).out. System. //Utiliza el método System. // copia el contenido del arreglo System. i < arreglo. 3. i < arreglo. imprimir(listaJava).length. listaJava. // llena de 9 una parte de la lista Arrays. public class CopiarArreglo2 { public static void main(String[] args) { int[] listaJava = new int[5].out. //fin del método main } } private static void imprimir(int[] arreglo) { for (int i = 0.arrayCopy. utiliza el método System. } // fin del método main private static void imprimir(int[] arreglo) { for (int i = 0. 0.println(). System.java. El programa siguiente.print(arreglo[i] + " "). } // fin del método imprimir } // fin de la clase RellenarArreglo Conceptos clave: método fill de la clase Arrays. i++) System.println(). listaJava. 4.out. imprimir(listaJava).fill(listaJava.arraycopy(listaNet. 0. 9).arraycopy para copiar el contenido de un arreglo en otro. 2.length.out. int[] listaNet = { 1.Aprenda Java // llena de 9 el arreglo Arrays. 0. } // fin del método imprimir //fin de la clase CopiarArreglo2 136 . imprimir(listaNet).print(arreglo[i] + " "). CopiarArreglo2. 9). 2.fill(listaNet. 5 }. opcion = entrada. Escribir un programa controlado por menú que utilice las operaciones básicas estudiadas en esta lección. Imprimir el contenido del arreglo.out. } // fin del método mostrarTitulo // las opciones del menú del programa private static void menuOpciones() { System."). Llenar el arreglo aleatoriamente.println("---------------------------------"). Leer desde el teclado.println("Operaciones básicas con arreglos. System. System.in).").Aprenda Java 7.println(">Fin del programa..println("4. Scanner entrada = new Scanner(System. System.next()."). import java.println( 137 . Nota: los problemas que se resuelven aquí no tienen una solución única.println("2."). } while (opcion. //Programa que implementa las operaciones básicas con //arreglos unidimensionales. System.equals("S") || opcion.print("\nDeseas continuar? (S/N)").Arrays. Problema 1. //para leer del teclado public class ArregloApp { public static void main(String[] args) { final int TAMAÑO_ARREGLO = 10.equals("s")).out.println("3. do { menu(listaNumero). String opcion = null.util. System.println("1.. // el tamaño del arreglo // crea un arreglo de 10 posiciones int[] listaNumero = new int[TAMAÑO_ARREGLO].out. System.out.util. import java.out. Ejercicios resueltos.out.out.Scanner. Encontrar el número mayor.out.7."). System. La programación con arreglos unidimensionales es un tópico de programación muy importante ya que es el punto de partida para estudiar las estructuras de datos.out. } // fin del método main // el titulo del programa private static void mostrarTitulo() { System."). println("Selecciona una opción (1-9): ").out.println("1.println( "-------------------------------------").").println("9. // lee la opción del teclado int opcion = entrada. // muestra el titulo del programa mostrarTitulo().println( 138 . Muestra las ocurrencias en el arreglo. Contar las ocurrencias del número mayor. System. datosAleatorios(miArreglo).println( "------------------------------------"). break.out.out.println( "2."). Encontrar el número mayor.out. } // fin del método menuOpciones // el menu del programa private static void menu(int[] miArreglo) { Scanner entrada = new Scanner(System. Contar las ocurrencias del cero.").println("7. case 4: System.").println("-----------------------------"). Leer desde el teclado.out.out. System.in).out. Contar las ocurrencias de un número."). System.out.out.out. Imprimir el contenido del arreglo. Crea un histograma con el arreglo. System. imprimirArreglo(miArreglo). // muestra las opciones del menu menuOpciones(). Llenar el arreglo aleatoriamente.println("4. System."). System."). case 3: System. case 2: System.")."). System. System. break. System.out.println( "8.println("-------------------------"). mostrarMayor(miArreglo).out. break.Aprenda Java "5. leerArreglo(miArreglo).out.out. switch (opcion) { case 1: System. break.nextInt().println( "3. case 5: System.println("6. printf("Valor %d ?".println("-----------------------------------"). case 9: System.out.println( "-------------------------------------").length. Contar las ocurrencias del número mayor.out. break. System. break.Aprenda Java "5.out.in). case 8: System.out.println( "-------------------------------------------").out.").println( "9. Muestra las ocurrencias en el arreglo. i++) { System.random() * 10)). System."). System.out.println( "7. histograma(miArreglo).println( "8. mostrarOcurrenciaCeros(miArreglo).nextInt(). System. Contar las ocurrencias del cero. (int) (Math. Contar las ocurrencias de un número. } // fin switch } // fin del método menu private static void leerArreglo(int[] miArreglo) { Scanner entrada = new Scanner(System. // el número podría leerse desde el teclado // aquí se genera aleatoriamente. case 7: System.out.%n".out.out. break."). System. System.out."). default: System. } // fin for 139 .println( "---------------------------------------"). i + 1).println("6. break. case 6: System.out. miArreglo[i] = entrada. miArreglo."). Crea un histograma con el arreglo. i < miArreglo.printf("Introduce %d números enteros (0-9). break.").println( "-----------------------------------------").println("Opción del menú inválida. mostrarRepeticiones(miArreglo.out. for (int i = 0. mostrarOcurrenciaMayor(miArreglo).length). mostrarRepeticiones(miArreglo). i < miArreglo. item). for (int i = 0. System.println(). int contador = 0.").println( "Generando datos aleatorios para el arreglo. } // fin for return mayor.random() * 10). i++) { if (miArreglo[i] == mayor) contador++. private static int obtenerMayor(int[] miArreglo) { int mayor = miArreglo[0]. } // fin del método datosAleatorios // determina el mayor número del arreglo.out."). } // fin for return contador.out. imprimirArreglo(miArreglo).out. } // fin del método ocurrenciaMayor // cuenta los elementos que son cero private static int cuentaCeros(int[] miArreglo) { int contador = 0. i < miArreglo.length. i < miArreglo.length. i++) { if (miArreglo[i] == 0) 140 .length. } // fin del método imprimirArreglo private static void datosAleatorios(int[] miArreglo) { System. i < miArreglo.printf("%d\t".out.Aprenda Java imprimirArreglo(miArreglo).println("Contenido del arreglo. i++) miArreglo[i] = (int) (Math.length. // asume que es el mayor for (int i = 1. for (int item : miArreglo) System. for (int i = 0. } // fin del método numeroMayor // cuenta las ocurrencias del número mayor private static int ocurrenciaMayor(int[] miArreglo) { int mayor = obtenerMayor(miArreglo). } // fin del método leerArreglo private static void imprimirArreglo(int[] miArreglo) { System. for (int i = 0. i++) { if (miArreglo[i] > mayor) mayor = miArreglo[i]. miArreglo[i]).println().length. i++) { if (miArreglo[i] == numero) contador++. 0.out.sort(temporal).length. } // fin for return contador.length. i < miArreglo. // empezamos a contar las ocurrencias System. // copiamos el contenido del arreglo original a temporal System. for (int i = 0. i++) { // imprime el histograma para ese num System. temporal. for (int i = 0. } // fin for System.out.println(). // ordenamos el arreglo Arrays. for (int i = 0. } // fin for } // fin del método histograma // muestra las ocurrencias de cada número en el arreglo private static void mostrarRepeticiones(int[] miArreglo) { // trabajamos con un arreglo temporal int[] temporal = new int[miArreglo. for (int j = 0. } // fin del método cuentaRepeticiones // imprime un histograma de frecuencia private static void histograma(int[] miArreglo) { System. j++) { if (temporal[i] == temporal[j] && i != j) { temporal[j] = -1.out. j < miArreglo[i]. j++) { System.println(). i < miArreglo. i < temporal. 141 . int contador = 1.length. i++) { for (int j = 0. } // fin for return contador. int numero) { int contador = 0. 0.print("*"). } // fin del método cuentaCeros // muestra las ocurrencias de un determinado número private static int cuentaRepeticiones(int[] miArreglo. j < temporal.out.out.length].Aprenda Java contador++.length).arraycopy(miArreglo. temporal.printf("%d : ". ocurrenciaMayor(miArreglo)).printf("El 0 se repite %d veces%n". contador = 1.printf("El %d se repite %d veces%n". } // fin del método mostrarMayorMenor } // fin de la clase ArregloApp 142 .out.printf("El mayor del arreglo es %d%n".out. numero)).%n". cuentaCeros(miArreglo)). } // fin del método mostrarOcurrenciaMayorMenor private static void mostrarMayor(int[] miArreglo) { System. } // fin del método mostrarRepeticiones private static void mostrarOcurrenciaCeros(int[] miArreglo) { System. } // fin if } // fin for // imprime el reporte if (temporal[i] != -1) System.out.printf( "El número %d se repite %d veces. obtenerMayor(miArreglo)). cuentaRepeticiones(miArreglo. int numero) { System.Aprenda Java contador++.out. numero.out.printf( "%d se repite %d veces%n". } // fin del método mostrarOcurrenciaCeros private static void mostrarOcurrenciaMayor(int[] miArreglo) { System. contador). obtenerMayor(miArreglo). temporal[i]. // inicializa para volver a contar } // fin for } // fin del método mostrarRepeticiones private static void mostrarRepeticiones(int[] miArreglo. excepto por un par segundo par de corchetes ( []). arreglo2D = new double[10][10]. Por convención. CrearArreglo2D. el primero identifica la fila del elemento y el segundo su columna. DeclararArreglo2D. // versión corta int[][] tabla = new int[10][10]. Para declarar y crear un arreglo bidimensional utilizamos el operador new y dos valores literales que representan las filas y columnas respectivamente. Los arreglos bidimensionales se utilizan para representar tablas de valores.java declara y crea dos arreglos bidimensionales de tipo int y double con un tamaño de 10x10 respectivamente. //Declara un arreglo de dos dimensiones. public class DeclararArreglo2D { public static void main(String[] args) { double[][] arreglo2D. } // fin del método main } // fin de la clase DeclararArreglo2D Los arreglos bidimensionales usan la misma sintaxis básica que los arreglos unidimensionales. //Declara y crea un arreglo de dos dimensiones.1. El programa siguiente. Para identificar un elemento específico de un arreglo bidimensional. Al finalizar esta lección. Arreglos bidimensionales. // otra forma: double arreglo2D[][]. las cuales consisten en información ordenada en filas y columnas. public class CrearArreglo2D { public static void main(String[] args) { double[][] arreglo2D. 8. // esto un error // int tabla[4][5].java declara un arreglo bidimensional de tipo double. debemos especificar dos subíndices. // double arreglo2D(4)(3). Declarar. El programa siguiente. 143 .Aprenda Java 8. crear y asignar valores a un arreglo bidimensional. // es un error // double arreglo2D[5][6]. serás capaz de: • Utilizar arreglos bidimensionales en los programas Java. 9. 144 .0 5. 4. } // fin del método main } // fin de la clase CrearArreglo2D Cada elemento del arreglo se identifica mediante una expresión de acceso a un arreglo de la forma tabla[fila][columna] donde tabla es el nombre del arreglo. El programa siguiente. ValoresArreglo2D. fila y columna son los subíndices que identifican en forma única a cada elemento en el arreglo tabla por número de fila y columna. Para obtener el número de filas en un arreglo bidimensional utilizamos la expresión arreglo2D. El programa siguiente.6 4.length y la expresión arreglo2D[fila]. public class ValoresArreglo2D { public static void main(String[] args) { double[][] tabla = new double[3][3]. // // // // inicializar el arreglo 2D con estos datos 5.9 los valores del arreglo 2D renglón x columna 5. } // fin del método main } // fin de la clase ValoresArreglo2D Un error común en Java es confundir la longitud de un arreglo bidimensional con el rango de índices válidos. 4.6.0.4 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.length determina el número de columnas en la fila actual del arreglo bidimensional.0.4.Aprenda Java // int[4][5] tabla. 4. // int tabla = new tabla[5.5.0 3. DefaultArreglo2D.2 4. declara.java.3.2.java. crea y asigna valores a un arreglo bidimensional de tipo double.crea y asigna valores en un arreglo de dos dimensiones. obtiene el tamaño de un arreglo bidimensional así como accede a sus valores por default.2 4.2. 3.5. 1. //Declara. 3.5]. 9.5 3.3 1. 5. System.println( "tabla[0] = " + tabla[5][5] ).out. } // fin del método main } // fin de la clase DefaultArreglo2D Al igual que los arreglos unidimensionales. El programa siguiente. 7.length). { 5. 3.out. " + tabla[2][3]).println("Contenido del System.9 } }.9}}.5. // utiliza la propiedad length para obtener el // tamaño del arreglo 2D System.2.println("tabla[0][2] = primer renglón:").9.length = 20. public class DatosArreglo2D { public static void main(String[] args) { // no se requiere la palabra clave new double[][] tabla = { { 1. // esto es un error // int[][] lista.println("Tamaño del renglón = " + tabla[0].9. // esto es un error.out.2. DatosArreglo2D.out. " + tabla[1][2]). no se puede cambiar el // tamaño del arreglo 2D // tabla.8.println("tabla[0][1] = System.5. Un arreglo bidimensional de nombre tabla con tres filas y tres columnas podría declararse e inicializarse con inicializadores de arreglos anidados.println("tabla[0][0] = System. los arreglos bidimensionales pueden inicializarse mediante inicializadores de arreglos en las declaraciones. } // fin del método main } // fin de la clase DatosArreglo2D 145 . declarar e inicializa un arreglo bidimensional de tipo double. " + tabla[0][1]). public class DefaultArreglo2D { public static void main(String[] args) { double[][] tabla = new double[3][3]. 9.4.4 }. // accede al primer renglón System.println("Tamaño del arreglo 2D = " + tabla.{7. //Declara e inicializa un arreglo de dos dimensiones. 3.3}. // lista = {{1.java.Aprenda Java //Tamaño del arreglo y valores por default. // accede la primera posición del arreglo2D System. // esto es un error. 3. { 8. no se puede acceder a un indice más grande // System.out.out.7. 2.out.{4.6}.println("tabla[0][0] = " + tabla[0][0]).out.3 }.length). El compilador cuenta los valores inicializadores en el inicializador de arreglos anidado de una fila.. 5 }. LecturaArreglo2D. 4. Operaciones básicas con arreglos bidimensionales. 8. // es equivalente a declarar. { 3. 2. 5 }.Aprenda Java Los valores del inicializador se agrupan por filas entre llaves.2. El compilador cuenta el número de inicializadores de arreglos anidados (representados por conjuntos de llaves dentro de las llaves externas) en la declaración del arreglo. { 4. para determinar el número de filas en el arreglo. // declara un arreglo2d de 2x3 int[][] tabla = new int[2][3]. 3.java declara e inicializa un arreglo con filas de distintas longitudes. Los programas siguientes muestran como inicializar un arreglo bidimensional y el uso de los ciclos for anidados en combinación con los indices de fila y columna para manipular los elementos del arreglo bidimensional. 5 }. para determinar el número de columnas en esa fila. { 2. El programa siguiente. //Declara e inicializa un arreglo 2D desigual.. triangulo2[4] = new int[1].Scanner. 3. 4.in).java declara un arreglo bidimensional de tipo int de tamaño 2x3 y utiliza ciclos for anidados para leer los valores desde el teclado. 5 }. public class ArregloDesigual { public static void main(String[] args) { int[][] triangulo = { { 1. { 5 } }. //Inicializa los datos de un arreglo 2D desde el teclado. import java. ArregloDesigual.util. } // fin del método main } // fin de la clase ArregloDesigual En Java no existen los arreglos de dos o más dimensiones ya que Java los mantiene como arreglos de arreglos unidimensionales.se requiere el primer indice int[][] triangulo2 = new int[5][]. triangulo2[0] = new int[5]. triangulo2[1] = new int[4]. 146 . Esto significa que las filas pueden tener distintas longitudes. 4. triangulo2[2] = new int[3]. public class LecturaArreglo2D { public static void main(String[] args) { Scanner entrada = new Scanner(System. El programa siguiente. triangulo2[3] = new int[2]. out.Aprenda Java System.print(tabla[0][0] System.out. j < tabla[i]. i++) for (int j = 0. " "). // lee y asigna el valor del teclado tabla[i][j] = entrada.random.out.print("El renglón System. j++) { System.out. // inicializa el arreglo 2D for (int i = 0.out.length + " renglones y " + tabla[0]. System.").out.print("El renglón System.print(tabla[0][1] System. i.length + " columnas. public class Arreglo2DAleatorio { public static void main(String[] args) { int[][] tabla = new int[2][3]. System. j < tabla[i].printf("Valor[%d][%d]? ". inicializa un arreglo bidimensional con valores aleatorios generados con el método Math.out.out. 147 .length. } // fin for } // fin for // imprime el primer renglón System.out.print(tabla[0][2] } // fin del método main } // fin de la clase Arreglo2DAleatorio 1 + + + = [").").out. Arreglo2DAleatorio. El programa siguiente.println("Introduce números enteros:"). " ").length + " renglones y " + tabla[0]."). j++) tabla[i][j] = (int) (Math. //Inicializa un arreglo 2D con valores aleatorios. "]").java.length + " columnas. "]").print(tabla[0][1] System.length.nextInt(). System. j). " ").println("El arreglo 2D tiene valores random. // imprime el primer renglón System.random() * 100).out. " "). i < tabla.length.length.out.print(tabla[0][2] } // fin del método main } // fin de la clase LecturaArreglo2D 1 + + + = [").print(tabla[0][0] System. // lectura del arreglo for (int i = 0.out.println("Arreglo con " + tabla. i++) { for (int j = 0.println("Arreglo con " + tabla. i < tabla. i++) { System. System. public class ImprimirArreglo2D { public static void main(String[] args) { // Declara e inicializa un arreglo 2D // de 3 renglones. j++) suma += tabulador[i][j]. System. { 7. 18. System.out. 14.50 }.99 } }. 5.println("Valores del arreglo.java. 38. 80. } // fin for } // fin del método main } // fin de la clase ImprimirArreglo2D El programa siguiente. imprime el contenido del arreglo bidimensional .println("Suma los datos del tabulador. 26. 60. public class SumaArreglo2D { public static void main(String[] args) { // declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.println("-----------------------------"). 70.35. 24."). { 4. ImprimirArreglo2D. 9 } }. for (int i = 0. { 34.28. //Imprime el contenido de un arreglo2D.0. i < tabulador.00. System.50. j < tabulador[i]. } // fin del método main } // fin de la clase SumaArreglo2D 148 .25.out.50. 8. suma). SumaArreglo2D.Aprenda Java El programa siguiente. { 20.00. 16. 3 }.println("--------------------"). //Suma todos los elementos del arreglo 2D.printf("La suma total es %.length.50.out. j < tabla[i].length.out.00 }. for (int j = 0.00.00. j++) System."). 00. 3 columnas int[][] tabla = { { 1. 36.out. 12.00. 43. i < tabla.length.75. 27. { 50. // imprime el contenido del arreglo for (int i = 0. 40.00.out.50.00 }. 22.length.00.2f%n".out. 6 }.println("]"). System. i++) for (int j = 0.print("Renglon " + i + " = [ "). 99. System.print(tabla[i][j] + " "). 2. double suma = 0.out.java suma todos los elementos del arreglo bidimensional. i++) { double sumaCol = 0. 18. 36.25.50 }. // el indice del renglon // obtiene la suma del primer renglón for (int i = 0.00.length. 27. 22. 43. { 34.50. 27.50 }.00.00 }.00. double renglonMax = 0. for (int j = 0. 149 . for (int i = 0. 16. 60.out.00 }.99 } }.out.00 }. i < tabulador[0]. 38. bidimensional. public class SumaColumna2D { public static void main(String[] args) { // declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.99 } }.printf("La suma de la columna %d es %. System. SumaColumna2D.00. SumaReglon2D. { 50.0.75.50. //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.00. { 20. i < tabulador[0].length.2f%n". sumaCol).50.25. 12. 16. System.println("-------------------------"). 70.50. { 20.Aprenda Java El programa siguiente. // para almacenar la suma del renglón int indiceRenglonMax = 0.35. 40.00.java .28. j++) sumaCol += tabulador[j][i].00.00.50. i++) renglonMax += tabulador[0][i].00. } // fin for } // fin del método main } // fin de la clase SumaColumna2D El programa siguiente. 99. { 50. 38. 99. 43.length. System. j < tabulador. 80.50.50.suma los renglones de un arreglo bidimensional y determina cual es renglón con la mayor suma. 36.java suma las columnas de un arreglo //Suma las columnas de un arreglo 2D.00.35. 70.00. public class SumaColumna2D { //Suma las columnas de un arreglo 2D.50. 12. 18. 60.00. 22. 00.00 }.75. 14. 00. 26.").00. 26. 80. 40. i.println("Suma los datos x columna. { 34.28. 24. 24.out. 14.00. Aprenda Java // compara renglonMax con la suma de los otros renglones for (int i = 0; i < tabulador.length; i++) { double sumaRenglon = 0; // suma del renglón 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 renglón %d es renglon con mayor suma (%.2f)%n", indiceRenglonMax, renglonMax); } // fin del método 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 después del shuffling."); // imprime el contenido del arreglo for (int i = 0; i < tabla.length; i++) { System.out.print("Renglón " + 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 método main } // fin de la clase IntecambioAleatorio2D 8.3. Paso de arreglos bidimensionales a los métodos. Los métodos son un ingrediente vital en la programación y una característica importante es pasar información hacia y desde ellos en forma de parámetros. El programa siguiente, PasoArreglo2D.java pasa un arreglo bidimensional como parámetro. //Arreglos como parámetros. 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 método 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 método main } // fin de la clase PasoArreglo2D El programa siguiente, Suma2D.java define un método general que recibe un arreglo bidimensional como parámetro para calcular la suma de sus elementos. //Arreglos como parámetros. 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 anónimo 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 método 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 método suma } // fin de la clase Suma2D 8.4. Ejercicios resueltos. La programación con arreglos bidimensionales es un tópico de programación 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 básicas estudiadas en esta lección. //Operaciones básicas 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("Inicialización del Arreglo 2D."); System.out.println("------------------------------"); System.out.print("Número de renglones? "); int renglon = entrada.nextInt(); System.out.print("Número 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 break."). Llenar el arreglo 2D con valores random.").").println("--------------------------"). System. Encontrar el elemento mayor.in).").println("8.println("Operaciones:").out. imprimir(arreglo2D). int opcion = 0.out. switch (opcion) { case 1: System. } // fin del metodo main // el titulo del programa private static void mostrarTitulo() { System.println("2.out.out.println("7. opcion = teclado.out.println("Operaciones básicas con arreglos 2D.out.").Aprenda Java opcion = entrada.out.println("4. // muestra las opciones del menú menuOpciones().out. Intercambiar valores aleatoriamente. Imprimir el arreglo 2D.println("6. System.equals("s")).").").out.out. } // fin del método menuOpciones // el menú del programa private static void menu(int[][] arreglo2D) { // variable local Scanner teclado = new Scanner(System.next().println("1.println("------------------------------------"). } // fin del método mostrarTitulo // las opciones del menú private static void menuOpciones() { System.").nextInt(). System. System. System.println("2. Imprimir la suma total. } while (opcion. System.out.equals("S") || opcion.").println(">Fin del programa.out.println("------------------------").print("Selecciona una opción (1-8): "). 153 ..println( "3.println("5. case 2: System.out. System.println("1.."). Imprimir el arreglo 2D. Imprimir el promedio.out. Llenar el arreglo 2D. System. System. leer(arreglo2D).out. Encontrar el elemento menor. Llenar el arreglo 2D. System. System.out.").out. System."). System. println("-------------------------------"). break. break.out. imprimirSuma(arreglo2D). System.out.out. System.out. shuffling(arreglo2D). Imprimir el promedio. case 7: System. Encontrar el elemento menor.out.")."). System.").println( "----------------------------------------"). System.out. 154 . Encontrar el elemento mayor. Intercambiar valores aleatoriamente.out. break. case 8: System.in).").out.println("--------------------------"). case 6: System. case 5: System.println( "---------------------------------------").out. imprimirPromedio(arreglo2D)."). imprimirMaxValor(arreglo2D).println("5.out. // mensaje de usuario System."). break.out. System. break. default: System. Imprimir la suma total.println("------------------------"). System. Llenar el arreglo con valores random. } // fin switch } // fin del método 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.println("7.println("Opción del menú inválida. case 4: System. case 3: System.println( "3.println( "4.println("6. llenarRandom(arreglo2D). imprimirMinValor(arreglo2D).println("8.out. break.Aprenda Java break.").out.printf("Introduce los datos de la matriz %d x %d%n".out.println("-------------------------------"). ren++) { for (int col = 0.nextInt(). // intercambia tabla[ren][col] 155 .length. ren < matriz. col < matriz[ren].println().out.println( "La matriz se ha inicializado con datos random.length). ren. col++) { // genera indices aleatorios para ren.length.length.length. col < matriz[ren].length.out. ren < matriz."). matriz. ren++) { for (int col = 0.length. col).length). } // fin for } // fin for } // fin del método leer // imprime el contenido del matriz private static void imprimir(int[][] matriz) { // mensaje de usuario System.length). ren++) { for (int col = 0. +matriz[0].length.random() * 100). ren++) for (int col = 0.printf("[ %d ] ".length. } // fin for } // fin del método 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.printf("Valor[%d][%d]? ".random() * matriz.length. // lectura de la matriz for (int ren = 0. col++) matriz[ren][col] = (int) (Math. matriz[ren][col]). System. int colAux = (int) (Math. matriz[0].length.out.out. col < matriz[ren].out.length). col++) { System.random() * matriz[col]. col++) System. col int renAux = (int) (Math. ren < matriz. // impresión del matriz for (int ren = 0. ren < matriz.printf("Matriz de %d x %d.%n". matriz[ren][col] = entrada. } // fin del método llenarRandom // intercambia aleatoriamente los datos del matriz private static void shuffling(int[][] matriz) { // procesa el arreglo intercambiando los valores aleatoriamente for (int ren = 0.Aprenda Java matriz. col < matriz[ren]. System. imprimir(matriz). promedio(matriz)). return sum. } // fin for } // fin for System. col < matriz[ren]. ren < matriz. ren++) for (int col = 0. imprimir(matriz). col++) sum = sum + matriz[ren][col].length.length. ren++) for (int col = 0. suma(matriz)).println( "Los datos de la matriz ya se han intercambiado. } // fin del método imprimir private static double promedio(int[][] matriz) { return (double) suma(matriz) / (matriz.length).2f%n". } // fin del método shuffling // suma todos los datos de la matriz private static int suma(int[][] matriz) { int sum = 0. matriz[renAux][colAux] = temp. matriz[ren][col] = matriz[renAux][colAux]. col < matriz[ren]. // asume que es el valor más grande // busca el elemento más grande for (int ren = 0.length.out.length."). matriz[0].length * matriz[0]. ren < matriz. } // fin del método imprimirPromedio private static int maxValor(int[][] matriz) { int max = matriz[0][0].out.length. // actualiza max 156 .length. } // fin del método calcularSuma // imprime la suma de los datos del matriz private static void imprimirSuma(int[][] matriz) { System. matriz. } // fin del método calcularPromedio // imprime el promedio del total de elementos del matriz private static void imprimirPromedio(int[][] matriz) { System.printf( "El promedio de los datos de la matriz de %d x %d es %. col++) if (matriz[ren][col] > max) // Busca el num mayor max = matriz[ren][col].printf("La suma de la matriz de %d x %d es %d%n".length. matriz. for (int ren = 0. matriz[0].out.length.Aprenda Java // por tabla[renAux][colAux] int temp = matriz[ren][col]. ren < matriz. minValor(matriz)). } // fin del método maxValor // imprimir el elemento más grande del matriz private static void imprimirMaxValor(int[][] matriz) { System.Aprenda Java return max. maxValor(matriz)). matriz. col < matriz[ren]. matriz[0].out. } // fin del método imprimirMinValor } // fin de la clase Arreglo2DApp 157 .out. } // fin del método minValor // imprimir el elemento más grande del matriz private static void imprimirMinValor(int[][] matriz) { System. matriz[0]. ren++) for (int col = 0.length. matriz. col++) if (matriz[ren][col] < min) // Busca el num menor min = matriz[ren][col].length. } // fin del método imprimirMaxValor private static int minValor(int[][] matriz) { int min = matriz[0][0]. // actualiza min return min. // asume que es el valor más pequeño // busca el elemento más grande for (int ren = 0.length.length.length.printf( "El elemento más pequeño de la matriz de %d x %d es %d%n".length.printf( "El elemento más grande de la matriz de %d x %d es %d%n". tercera edicion. México 2008. First Edition. Introducción a la programación con Java. C. Séptima edición. Programación en Java. Beth Brown . Java Programming. John Dean & Raymond Dean. Lawrenceville Press . Eighth Edition . Primera edición. Como programar en Java. New Jersey 2011. Y. Java para estudiantes.Aprenda Java 9. Manual de introducción a la algoritmia: http://es. Pearson Education. McGraw Hill. México 2003. Bibliografía consultada. Prentice Hall. Daniel Liang. • • • • • • • Deitel & Deitel. Bell Douglas & Parr Mike. 158 .scribd. Primera edición. USA 2005. México 2009. Thomas Wu.com/doc/59204592/IntroducciA %C2%B3n-a-la-Algoritmia-1. A guide to programming in Java 2 Platform Standard Edition 5. McGraw Hill. Pearson Education. Introducción a la programación orientada a objetos. Comprehensive versión. México 2008.